1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002 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
52 #include "elf/alpha.h"
72 #include "elf/m68hc11.h"
73 #include "elf/mcore.h"
76 #include "elf/mn10200.h"
77 #include "elf/mn10300.h"
83 #include "elf/sparc.h"
86 #include "elf/x86-64.h"
87 #include "elf/xstormy16.h"
92 char * program_name
= "readelf";
93 unsigned int dynamic_addr
;
94 bfd_size_type dynamic_size
;
95 unsigned int rela_addr
;
96 unsigned int rela_size
;
97 char * dynamic_strings
;
99 unsigned long string_table_length
;
100 unsigned long num_dynamic_syms
;
101 Elf_Internal_Sym
* dynamic_symbols
;
102 Elf_Internal_Syminfo
* dynamic_syminfo
;
103 unsigned long dynamic_syminfo_offset
;
104 unsigned int dynamic_syminfo_nent
;
105 char program_interpreter
[64];
106 int dynamic_info
[DT_JMPREL
+ 1];
107 int version_info
[16];
109 Elf_Internal_Ehdr elf_header
;
110 Elf_Internal_Shdr
* section_headers
;
111 Elf_Internal_Dyn
* dynamic_segment
;
112 Elf_Internal_Shdr
* symtab_shndx_hdr
;
120 int do_using_dynamic
;
128 int do_debug_abbrevs
;
130 int do_debug_pubnames
;
131 int do_debug_aranges
;
133 int do_debug_frames_interp
;
134 int do_debug_macinfo
;
141 /* A dynamic array of flags indicating which sections require dumping. */
142 char * dump_sects
= NULL
;
143 unsigned int num_dump_sects
= 0;
145 #define HEX_DUMP (1 << 0)
146 #define DISASS_DUMP (1 << 1)
147 #define DEBUG_DUMP (1 << 2)
149 /* How to rpint a vma value. */
150 typedef enum print_mode
162 /* Forward declarations for dumb compilers. */
163 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
164 static void print_symbol
PARAMS ((int, char *));
165 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
166 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
167 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
168 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
169 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
170 static const char * get_ppc64_dynamic_type
PARAMS ((unsigned long));
171 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
172 static const char * get_dynamic_type
PARAMS ((unsigned long));
173 static int slurp_rela_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**, unsigned long *));
174 static int slurp_rel_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel
**, unsigned long *));
175 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
176 static char * get_file_type
PARAMS ((unsigned));
177 static char * get_machine_name
PARAMS ((unsigned));
178 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
179 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
180 static const char * get_mips_segment_type
PARAMS ((unsigned long));
181 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
182 static const char * get_ia64_segment_type
PARAMS ((unsigned long));
183 static const char * get_segment_type
PARAMS ((unsigned long));
184 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
185 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
186 static const char * get_ia64_section_type_name
PARAMS ((unsigned int));
187 static const char * get_section_type_name
PARAMS ((unsigned int));
188 static const char * get_symbol_binding
PARAMS ((unsigned int));
189 static const char * get_symbol_type
PARAMS ((unsigned int));
190 static const char * get_symbol_visibility
PARAMS ((unsigned int));
191 static const char * get_symbol_index_type
PARAMS ((unsigned int));
192 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
193 static void usage
PARAMS ((void));
194 static void parse_args
PARAMS ((int, char **));
195 static int process_file_header
PARAMS ((void));
196 static int process_program_headers
PARAMS ((FILE *));
197 static int process_section_headers
PARAMS ((FILE *));
198 static int process_unwind
PARAMS ((FILE *));
199 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
200 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
201 static int process_dynamic_segment
PARAMS ((FILE *));
202 static int process_symbol_table
PARAMS ((FILE *));
203 static int process_syminfo
PARAMS ((FILE *));
204 static int process_section_contents
PARAMS ((FILE *));
205 static void process_mips_fpe_exception
PARAMS ((int));
206 static int process_mips_specific
PARAMS ((FILE *));
207 static int process_file
PARAMS ((char *));
208 static int process_relocs
PARAMS ((FILE *));
209 static int process_version_sections
PARAMS ((FILE *));
210 static char * get_ver_flags
PARAMS ((unsigned int));
211 static int get_32bit_section_headers
PARAMS ((FILE *, unsigned int));
212 static int get_64bit_section_headers
PARAMS ((FILE *, unsigned int));
213 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
214 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
215 static int get_file_header
PARAMS ((FILE *));
216 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
217 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
218 static const char * get_elf_section_flags
PARAMS ((bfd_vma
));
219 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
220 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
221 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
222 #ifdef SUPPORT_DISASSEMBLY
223 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
225 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
226 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
227 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
228 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
229 static int prescan_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
230 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
231 static int display_debug_pubnames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
232 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
233 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
234 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
235 static int display_debug_macinfo
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
236 static int display_debug_str
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
237 static int display_debug_loc
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
238 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
239 static void load_debug_str
PARAMS ((FILE *));
240 static void free_debug_str
PARAMS ((void));
241 static const char * fetch_indirect_string
PARAMS ((unsigned long));
242 static void load_debug_loc
PARAMS ((FILE *));
243 static void free_debug_loc
PARAMS ((void));
244 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
245 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
246 static void reset_state_machine
PARAMS ((int));
247 static char * get_TAG_name
PARAMS ((unsigned long));
248 static char * get_AT_name
PARAMS ((unsigned long));
249 static char * get_FORM_name
PARAMS ((unsigned long));
250 static void free_abbrevs
PARAMS ((void));
251 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
252 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
253 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
254 static unsigned char * read_and_display_attr_value
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
255 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
256 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
257 static void request_dump
PARAMS ((unsigned int, int));
258 static const char * get_elf_class
PARAMS ((unsigned int));
259 static const char * get_data_encoding
PARAMS ((unsigned int));
260 static const char * get_osabi_name
PARAMS ((unsigned int));
261 static int guess_is_rela
PARAMS ((unsigned long));
262 static const char * get_note_type
PARAMS ((unsigned int));
263 static const char * get_netbsd_elfcore_note_type
PARAMS ((unsigned int));
264 static int process_note
PARAMS ((Elf32_Internal_Note
*));
265 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
266 static int process_corefile_note_segments
PARAMS ((FILE *));
267 static int process_corefile_contents
PARAMS ((FILE *));
268 static int process_arch_specific
PARAMS ((FILE *));
269 static int process_gnu_liblist
PARAMS ((FILE *));
271 typedef int Elf32_Word
;
279 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
280 ((X)->sh_name >= string_table_length \
281 ? "<corrupt>" : string_table + (X)->sh_name))
283 /* Given st_shndx I, map to section_headers index. */
284 #define SECTION_HEADER_INDEX(I) \
285 ((I) < SHN_LORESERVE \
287 : ((I) <= SHN_HIRESERVE \
289 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
291 /* Reverse of the above. */
292 #define SECTION_HEADER_NUM(N) \
293 ((N) < SHN_LORESERVE \
295 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
297 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
299 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
301 #define BYTE_GET(field) byte_get (field, sizeof (field))
303 /* If we can support a 64 bit data type then BFD64 should be defined
304 and sizeof (bfd_vma) == 8. In this case when translating from an
305 external 8 byte field to an internal field, we can assume that the
306 internal field is also 8 bytes wide and so we can extract all the data.
307 If, however, BFD64 is not defined, then we must assume that the
308 internal data structure only has 4 byte wide fields that are the
309 equivalent of the 8 byte wide external counterparts, and so we must
310 truncate the data. */
312 #define BYTE_GET8(field) byte_get (field, -8)
314 #define BYTE_GET8(field) byte_get (field, 8)
317 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
319 #define GET_ELF_SYMBOLS(file, section) \
320 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
321 : get_64bit_elf_symbols (file, section))
325 error
VPARAMS ((const char *message
, ...))
327 VA_OPEN (args
, message
);
328 VA_FIXEDARG (args
, const char *, message
);
330 fprintf (stderr
, _("%s: Error: "), program_name
);
331 vfprintf (stderr
, message
, args
);
336 warn
VPARAMS ((const char *message
, ...))
338 VA_OPEN (args
, message
);
339 VA_FIXEDARG (args
, const char *, message
);
341 fprintf (stderr
, _("%s: Warning: "), program_name
);
342 vfprintf (stderr
, message
, args
);
346 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
349 get_data (var
, file
, offset
, size
, reason
)
361 if (fseek (file
, offset
, SEEK_SET
))
363 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
370 mvar
= (PTR
) malloc (size
);
374 error (_("Out of memory allocating %d bytes for %s\n"),
380 if (fread (mvar
, size
, 1, file
) != 1)
382 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
392 byte_get_little_endian (field
, size
)
393 unsigned char * field
;
402 return ((unsigned int) (field
[0]))
403 | (((unsigned int) (field
[1])) << 8);
407 /* We want to extract data from an 8 byte wide field and
408 place it into a 4 byte wide field. Since this is a little
409 endian source we can juts use the 4 byte extraction code. */
413 return ((unsigned long) (field
[0]))
414 | (((unsigned long) (field
[1])) << 8)
415 | (((unsigned long) (field
[2])) << 16)
416 | (((unsigned long) (field
[3])) << 24);
421 /* This is a special case, generated by the BYTE_GET8 macro.
422 It means that we are loading an 8 byte value from a field
423 in an external structure into an 8 byte value in a field
424 in an internal strcuture. */
425 return ((bfd_vma
) (field
[0]))
426 | (((bfd_vma
) (field
[1])) << 8)
427 | (((bfd_vma
) (field
[2])) << 16)
428 | (((bfd_vma
) (field
[3])) << 24)
429 | (((bfd_vma
) (field
[4])) << 32)
430 | (((bfd_vma
) (field
[5])) << 40)
431 | (((bfd_vma
) (field
[6])) << 48)
432 | (((bfd_vma
) (field
[7])) << 56);
435 error (_("Unhandled data length: %d\n"), size
);
440 /* Print a VMA value. */
442 print_vma (vma
, mode
)
452 case FULL_HEX
: printf ("0x"); /* drop through */
453 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
454 case PREFIX_HEX
: printf ("0x"); /* drop through */
455 case HEX
: printf ("%lx", (unsigned long) vma
); break;
456 case DEC
: printf ("%ld", (unsigned long) vma
); break;
457 case DEC_5
: printf ("%5ld", (long) vma
); break;
458 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
479 #if BFD_HOST_64BIT_LONG
482 if (_bfd_int64_high (vma
))
483 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
485 printf ("%lx", _bfd_int64_low (vma
));
490 #if BFD_HOST_64BIT_LONG
493 if (_bfd_int64_high (vma
))
495 printf ("++%ld", _bfd_int64_low (vma
));
497 printf ("%ld", _bfd_int64_low (vma
));
502 #if BFD_HOST_64BIT_LONG
503 printf ("%5ld", vma
);
505 if (_bfd_int64_high (vma
))
507 printf ("++%ld", _bfd_int64_low (vma
));
509 printf ("%5ld", _bfd_int64_low (vma
));
514 #if BFD_HOST_64BIT_LONG
517 if (_bfd_int64_high (vma
))
519 printf ("++%lu", _bfd_int64_low (vma
));
521 printf ("%lu", _bfd_int64_low (vma
));
529 /* Display a symbol on stdout. If do_wide is not true then
530 format the symbol to be at most WIDTH characters,
531 truncating as necessary. If WIDTH is negative then
532 format the string to be exactly - WIDTH characters,
533 truncating or padding as necessary. */
536 print_symbol (width
, symbol
)
543 printf ("%-*.*s", width
, width
, symbol
);
545 printf ("%-.*s", width
, symbol
);
549 byte_get_big_endian (field
, size
)
550 unsigned char * field
;
559 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
562 return ((unsigned long) (field
[3]))
563 | (((unsigned long) (field
[2])) << 8)
564 | (((unsigned long) (field
[1])) << 16)
565 | (((unsigned long) (field
[0])) << 24);
569 /* Although we are extracing data from an 8 byte wide field, we
570 are returning only 4 bytes of data. */
571 return ((unsigned long) (field
[7]))
572 | (((unsigned long) (field
[6])) << 8)
573 | (((unsigned long) (field
[5])) << 16)
574 | (((unsigned long) (field
[4])) << 24);
578 /* This is a special case, generated by the BYTE_GET8 macro.
579 It means that we are loading an 8 byte value from a field
580 in an external structure into an 8 byte value in a field
581 in an internal strcuture. */
582 return ((bfd_vma
) (field
[7]))
583 | (((bfd_vma
) (field
[6])) << 8)
584 | (((bfd_vma
) (field
[5])) << 16)
585 | (((bfd_vma
) (field
[4])) << 24)
586 | (((bfd_vma
) (field
[3])) << 32)
587 | (((bfd_vma
) (field
[2])) << 40)
588 | (((bfd_vma
) (field
[1])) << 48)
589 | (((bfd_vma
) (field
[0])) << 56);
593 error (_("Unhandled data length: %d\n"), size
);
598 /* Guess the relocation size commonly used by the specific machines. */
601 guess_is_rela (e_machine
)
602 unsigned long e_machine
;
606 /* Targets that use REL relocations. */
622 /* Targets that use RELA relocations. */
637 case EM_CYGNUS_MN10200
:
639 case EM_CYGNUS_MN10300
:
679 warn (_("Don't know about relocations on this machine architecture\n"));
685 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
687 unsigned long rel_offset
;
688 unsigned long rel_size
;
689 Elf_Internal_Rela
**relasp
;
690 unsigned long *nrelasp
;
692 Elf_Internal_Rela
*relas
;
693 unsigned long nrelas
;
698 Elf32_External_Rela
* erelas
;
700 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
701 rel_size
, _("relocs"));
705 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
707 relas
= (Elf_Internal_Rela
*)
708 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
712 error(_("out of memory parsing relocs"));
716 for (i
= 0; i
< nrelas
; i
++)
718 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
719 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
720 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
727 Elf64_External_Rela
* erelas
;
729 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
730 rel_size
, _("relocs"));
734 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
736 relas
= (Elf_Internal_Rela
*)
737 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
741 error(_("out of memory parsing relocs"));
745 for (i
= 0; i
< nrelas
; i
++)
747 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
748 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
749 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
760 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
762 unsigned long rel_offset
;
763 unsigned long rel_size
;
764 Elf_Internal_Rel
**relsp
;
765 unsigned long *nrelsp
;
767 Elf_Internal_Rel
*rels
;
773 Elf32_External_Rel
* erels
;
775 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
776 rel_size
, _("relocs"));
780 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
782 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
786 error(_("out of memory parsing relocs"));
790 for (i
= 0; i
< nrels
; i
++)
792 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
793 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
800 Elf64_External_Rel
* erels
;
802 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
803 rel_size
, _("relocs"));
807 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
809 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
813 error(_("out of memory parsing relocs"));
817 for (i
= 0; i
< nrels
; i
++)
819 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
820 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
830 /* Display the contents of the relocation data found at the specified offset. */
832 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
834 unsigned long rel_offset
;
835 unsigned long rel_size
;
836 Elf_Internal_Sym
* symtab
;
842 Elf_Internal_Rel
* rels
;
843 Elf_Internal_Rela
* relas
;
846 if (is_rela
== UNKNOWN
)
847 is_rela
= guess_is_rela (elf_header
.e_machine
);
851 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &relas
, &rel_size
))
856 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
865 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
867 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
872 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
874 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
882 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
884 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
889 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
891 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
895 for (i
= 0; i
< rel_size
; i
++)
898 const char * rtype2
= NULL
;
899 const char * rtype3
= NULL
;
902 bfd_vma symtab_index
;
904 bfd_vma type2
= (bfd_vma
) NULL
;
905 bfd_vma type3
= (bfd_vma
) NULL
;
909 offset
= relas
[i
].r_offset
;
910 info
= relas
[i
].r_info
;
914 offset
= rels
[i
].r_offset
;
915 info
= rels
[i
].r_info
;
920 type
= ELF32_R_TYPE (info
);
921 symtab_index
= ELF32_R_SYM (info
);
925 if (elf_header
.e_machine
== EM_MIPS
)
927 type
= ELF64_MIPS_R_TYPE (info
);
928 type2
= ELF64_MIPS_R_TYPE2 (info
);
929 type3
= ELF64_MIPS_R_TYPE3 (info
);
931 else if (elf_header
.e_machine
== EM_SPARCV9
)
932 type
= ELF64_R_TYPE_ID (info
);
934 type
= ELF64_R_TYPE (info
);
935 /* The #ifdef BFD64 below is to prevent a compile time warning.
936 We know that if we do not have a 64 bit data type that we
937 will never execute this code anyway. */
939 symtab_index
= ELF64_R_SYM (info
);
945 #ifdef _bfd_int64_low
946 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
948 printf ("%8.8lx %8.8lx ", offset
, info
);
953 #ifdef _bfd_int64_low
955 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
956 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
957 _bfd_int64_high (offset
),
958 _bfd_int64_low (offset
),
959 _bfd_int64_high (info
),
960 _bfd_int64_low (info
));
963 ? "%16.16lx %16.16lx "
964 : "%12.12lx %12.12lx ",
969 switch (elf_header
.e_machine
)
977 rtype
= elf_m32r_reloc_type (type
);
982 rtype
= elf_i386_reloc_type (type
);
987 rtype
= elf_m68hc11_reloc_type (type
);
991 rtype
= elf_m68k_reloc_type (type
);
995 rtype
= elf_i960_reloc_type (type
);
1000 rtype
= elf_avr_reloc_type (type
);
1003 case EM_OLD_SPARCV9
:
1004 case EM_SPARC32PLUS
:
1007 rtype
= elf_sparc_reloc_type (type
);
1011 case EM_CYGNUS_V850
:
1012 rtype
= v850_reloc_type (type
);
1016 case EM_CYGNUS_D10V
:
1017 rtype
= elf_d10v_reloc_type (type
);
1021 case EM_CYGNUS_D30V
:
1022 rtype
= elf_d30v_reloc_type (type
);
1026 rtype
= elf_dlx_reloc_type (type
);
1030 rtype
= elf_sh_reloc_type (type
);
1034 case EM_CYGNUS_MN10300
:
1035 rtype
= elf_mn10300_reloc_type (type
);
1039 case EM_CYGNUS_MN10200
:
1040 rtype
= elf_mn10200_reloc_type (type
);
1044 case EM_CYGNUS_FR30
:
1045 rtype
= elf_fr30_reloc_type (type
);
1049 rtype
= elf_frv_reloc_type (type
);
1053 rtype
= elf_mcore_reloc_type (type
);
1057 rtype
= elf_mmix_reloc_type (type
);
1062 rtype
= elf_ppc_reloc_type (type
);
1066 case EM_MIPS_RS3_LE
:
1067 rtype
= elf_mips_reloc_type (type
);
1070 rtype2
= elf_mips_reloc_type (type2
);
1071 rtype3
= elf_mips_reloc_type (type3
);
1076 rtype
= elf_alpha_reloc_type (type
);
1080 rtype
= elf_arm_reloc_type (type
);
1084 rtype
= elf_arc_reloc_type (type
);
1088 rtype
= elf_hppa_reloc_type (type
);
1094 rtype
= elf_h8_reloc_type (type
);
1099 rtype
= elf_or32_reloc_type (type
);
1104 rtype
= elf_pj_reloc_type (type
);
1107 rtype
= elf_ia64_reloc_type (type
);
1111 rtype
= elf_cris_reloc_type (type
);
1115 rtype
= elf_i860_reloc_type (type
);
1119 rtype
= elf_x86_64_reloc_type (type
);
1123 rtype
= i370_reloc_type (type
);
1128 rtype
= elf_s390_reloc_type (type
);
1132 rtype
= elf_xstormy16_reloc_type (type
);
1136 rtype
= elf_vax_reloc_type (type
);
1141 rtype
= elf_ip2k_reloc_type (type
);
1146 #ifdef _bfd_int64_low
1147 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1149 printf (_("unrecognized: %-7lx"), type
);
1152 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1156 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1157 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1160 Elf_Internal_Sym
* psym
;
1162 psym
= symtab
+ symtab_index
;
1165 print_vma (psym
->st_value
, LONG_HEX
);
1166 printf (is_32bit_elf
? " " : " ");
1168 if (psym
->st_name
== 0)
1169 print_symbol (22, SECTION_NAME (section_headers
+ psym
->st_shndx
));
1170 else if (strtab
== NULL
)
1171 printf (_("<string table index %3ld>"), psym
->st_name
);
1173 print_symbol (22, strtab
+ psym
->st_name
);
1176 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
1181 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1182 print_vma (relas
[i
].r_addend
, LONG_HEX
);
1185 if (elf_header
.e_machine
== EM_SPARCV9
1186 && !strcmp (rtype
, "R_SPARC_OLO10"))
1187 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1191 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1193 printf (" Type2: ");
1196 #ifdef _bfd_int64_low
1197 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1199 printf (_("unrecognized: %-7lx"), type2
);
1202 printf ("%-17.17s", rtype2
);
1204 printf("\n Type3: ");
1207 #ifdef _bfd_int64_low
1208 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1210 printf (_("unrecognized: %-7lx"), type3
);
1213 printf ("%-17.17s", rtype3
);
1228 get_mips_dynamic_type (type
)
1233 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1234 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1235 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1236 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1237 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1238 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1239 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1240 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1241 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1242 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1243 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1244 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1245 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1246 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1247 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1248 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1249 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1250 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1251 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1252 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1253 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1254 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1255 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1256 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1257 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1258 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1259 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1260 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1261 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1262 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1263 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1264 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1265 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1266 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1267 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1268 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1269 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1270 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1271 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1272 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1273 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1274 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1275 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1282 get_sparc64_dynamic_type (type
)
1287 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1294 get_ppc64_dynamic_type (type
)
1299 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1300 case DT_PPC64_OPD
: return "PPC64_OPD";
1301 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1308 get_parisc_dynamic_type (type
)
1313 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1314 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1315 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1316 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1317 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1318 case DT_HP_PREINIT
: return "HP_PREINIT";
1319 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1320 case DT_HP_NEEDED
: return "HP_NEEDED";
1321 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1322 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1323 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1324 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1325 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1332 get_dynamic_type (type
)
1335 static char buff
[32];
1339 case DT_NULL
: return "NULL";
1340 case DT_NEEDED
: return "NEEDED";
1341 case DT_PLTRELSZ
: return "PLTRELSZ";
1342 case DT_PLTGOT
: return "PLTGOT";
1343 case DT_HASH
: return "HASH";
1344 case DT_STRTAB
: return "STRTAB";
1345 case DT_SYMTAB
: return "SYMTAB";
1346 case DT_RELA
: return "RELA";
1347 case DT_RELASZ
: return "RELASZ";
1348 case DT_RELAENT
: return "RELAENT";
1349 case DT_STRSZ
: return "STRSZ";
1350 case DT_SYMENT
: return "SYMENT";
1351 case DT_INIT
: return "INIT";
1352 case DT_FINI
: return "FINI";
1353 case DT_SONAME
: return "SONAME";
1354 case DT_RPATH
: return "RPATH";
1355 case DT_SYMBOLIC
: return "SYMBOLIC";
1356 case DT_REL
: return "REL";
1357 case DT_RELSZ
: return "RELSZ";
1358 case DT_RELENT
: return "RELENT";
1359 case DT_PLTREL
: return "PLTREL";
1360 case DT_DEBUG
: return "DEBUG";
1361 case DT_TEXTREL
: return "TEXTREL";
1362 case DT_JMPREL
: return "JMPREL";
1363 case DT_BIND_NOW
: return "BIND_NOW";
1364 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1365 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1366 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1367 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1368 case DT_RUNPATH
: return "RUNPATH";
1369 case DT_FLAGS
: return "FLAGS";
1371 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1372 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1374 case DT_CHECKSUM
: return "CHECKSUM";
1375 case DT_PLTPADSZ
: return "PLTPADSZ";
1376 case DT_MOVEENT
: return "MOVEENT";
1377 case DT_MOVESZ
: return "MOVESZ";
1378 case DT_FEATURE
: return "FEATURE";
1379 case DT_POSFLAG_1
: return "POSFLAG_1";
1380 case DT_SYMINSZ
: return "SYMINSZ";
1381 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1383 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1384 case DT_CONFIG
: return "CONFIG";
1385 case DT_DEPAUDIT
: return "DEPAUDIT";
1386 case DT_AUDIT
: return "AUDIT";
1387 case DT_PLTPAD
: return "PLTPAD";
1388 case DT_MOVETAB
: return "MOVETAB";
1389 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1391 case DT_VERSYM
: return "VERSYM";
1393 case DT_RELACOUNT
: return "RELACOUNT";
1394 case DT_RELCOUNT
: return "RELCOUNT";
1395 case DT_FLAGS_1
: return "FLAGS_1";
1396 case DT_VERDEF
: return "VERDEF";
1397 case DT_VERDEFNUM
: return "VERDEFNUM";
1398 case DT_VERNEED
: return "VERNEED";
1399 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1401 case DT_AUXILIARY
: return "AUXILIARY";
1402 case DT_USED
: return "USED";
1403 case DT_FILTER
: return "FILTER";
1405 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1406 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1407 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1408 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1409 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1412 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1414 const char * result
;
1416 switch (elf_header
.e_machine
)
1419 case EM_MIPS_RS3_LE
:
1420 result
= get_mips_dynamic_type (type
);
1423 result
= get_sparc64_dynamic_type (type
);
1426 result
= get_ppc64_dynamic_type (type
);
1436 sprintf (buff
, _("Processor Specific: %lx"), type
);
1438 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1440 const char * result
;
1442 switch (elf_header
.e_machine
)
1445 result
= get_parisc_dynamic_type (type
);
1455 sprintf (buff
, _("Operating System specific: %lx"), type
);
1458 sprintf (buff
, _("<unknown>: %lx"), type
);
1465 get_file_type (e_type
)
1468 static char buff
[32];
1472 case ET_NONE
: return _("NONE (None)");
1473 case ET_REL
: return _("REL (Relocatable file)");
1474 case ET_EXEC
: return _("EXEC (Executable file)");
1475 case ET_DYN
: return _("DYN (Shared object file)");
1476 case ET_CORE
: return _("CORE (Core file)");
1479 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1480 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1481 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1482 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1484 sprintf (buff
, _("<unknown>: %x"), e_type
);
1490 get_machine_name (e_machine
)
1493 static char buff
[64]; /* XXX */
1497 case EM_NONE
: return _("None");
1498 case EM_M32
: return "WE32100";
1499 case EM_SPARC
: return "Sparc";
1500 case EM_386
: return "Intel 80386";
1501 case EM_68K
: return "MC68000";
1502 case EM_88K
: return "MC88000";
1503 case EM_486
: return "Intel 80486";
1504 case EM_860
: return "Intel 80860";
1505 case EM_MIPS
: return "MIPS R3000";
1506 case EM_S370
: return "IBM System/370";
1507 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1508 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1509 case EM_PARISC
: return "HPPA";
1510 case EM_PPC_OLD
: return "Power PC (old)";
1511 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1512 case EM_960
: return "Intel 90860";
1513 case EM_PPC
: return "PowerPC";
1514 case EM_PPC64
: return "PowerPC64";
1515 case EM_V800
: return "NEC V800";
1516 case EM_FR20
: return "Fujitsu FR20";
1517 case EM_RH32
: return "TRW RH32";
1518 case EM_MCORE
: return "MCORE";
1519 case EM_ARM
: return "ARM";
1520 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1521 case EM_SH
: return "Hitachi SH";
1522 case EM_SPARCV9
: return "Sparc v9";
1523 case EM_TRICORE
: return "Siemens Tricore";
1524 case EM_ARC
: return "ARC";
1525 case EM_H8_300
: return "Hitachi H8/300";
1526 case EM_H8_300H
: return "Hitachi H8/300H";
1527 case EM_H8S
: return "Hitachi H8S";
1528 case EM_H8_500
: return "Hitachi H8/500";
1529 case EM_IA_64
: return "Intel IA-64";
1530 case EM_MIPS_X
: return "Stanford MIPS-X";
1531 case EM_COLDFIRE
: return "Motorola Coldfire";
1532 case EM_68HC12
: return "Motorola M68HC12";
1533 case EM_ALPHA
: return "Alpha";
1534 case EM_CYGNUS_D10V
:
1535 case EM_D10V
: return "d10v";
1536 case EM_CYGNUS_D30V
:
1537 case EM_D30V
: return "d30v";
1538 case EM_CYGNUS_M32R
:
1539 case EM_M32R
: return "Mitsubishi M32r";
1540 case EM_CYGNUS_V850
:
1541 case EM_V850
: return "NEC v850";
1542 case EM_CYGNUS_MN10300
:
1543 case EM_MN10300
: return "mn10300";
1544 case EM_CYGNUS_MN10200
:
1545 case EM_MN10200
: return "mn10200";
1546 case EM_CYGNUS_FR30
:
1547 case EM_FR30
: return "Fujitsu FR30";
1548 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1550 case EM_PJ
: return "picoJava";
1551 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1552 case EM_PCP
: return "Siemens PCP";
1553 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1554 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1555 case EM_STARCORE
: return "Motorola Star*Core processor";
1556 case EM_ME16
: return "Toyota ME16 processor";
1557 case EM_ST100
: return "STMicroelectronics ST100 processor";
1558 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1559 case EM_FX66
: return "Siemens FX66 microcontroller";
1560 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1561 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1562 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1563 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1564 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1565 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1566 case EM_SVX
: return "Silicon Graphics SVx";
1567 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1568 case EM_VAX
: return "Digital VAX";
1570 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1571 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1572 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1573 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1574 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1575 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1576 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1577 case EM_PRISM
: return "SiTera Prism";
1578 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1580 case EM_S390
: return "IBM S/390";
1581 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1583 case EM_OR32
: return "OpenRISC";
1584 case EM_DLX
: return "OpenDLX";
1586 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1588 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1594 decode_ARM_machine_flags (e_flags
, buf
)
1601 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1602 e_flags
&= ~ EF_ARM_EABIMASK
;
1604 /* Handle "generic" ARM flags. */
1605 if (e_flags
& EF_ARM_RELEXEC
)
1607 strcat (buf
, ", relocatable executable");
1608 e_flags
&= ~ EF_ARM_RELEXEC
;
1611 if (e_flags
& EF_ARM_HASENTRY
)
1613 strcat (buf
, ", has entry point");
1614 e_flags
&= ~ EF_ARM_HASENTRY
;
1617 /* Now handle EABI specific flags. */
1621 strcat (buf
, ", <unrecognized EABI>");
1626 case EF_ARM_EABI_VER1
:
1627 strcat (buf
, ", Version1 EABI");
1632 /* Process flags one bit at a time. */
1633 flag
= e_flags
& - e_flags
;
1638 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1639 strcat (buf
, ", sorted symbol tables");
1649 case EF_ARM_EABI_VER2
:
1650 strcat (buf
, ", Version2 EABI");
1655 /* Process flags one bit at a time. */
1656 flag
= e_flags
& - e_flags
;
1661 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1662 strcat (buf
, ", sorted symbol tables");
1665 case EF_ARM_DYNSYMSUSESEGIDX
:
1666 strcat (buf
, ", dynamic symbols use segment index");
1669 case EF_ARM_MAPSYMSFIRST
:
1670 strcat (buf
, ", mapping symbols precede others");
1680 case EF_ARM_EABI_UNKNOWN
:
1681 strcat (buf
, ", GNU EABI");
1686 /* Process flags one bit at a time. */
1687 flag
= e_flags
& - e_flags
;
1692 case EF_ARM_INTERWORK
:
1693 strcat (buf
, ", interworking enabled");
1696 case EF_ARM_APCS_26
:
1697 strcat (buf
, ", uses APCS/26");
1700 case EF_ARM_APCS_FLOAT
:
1701 strcat (buf
, ", uses APCS/float");
1705 strcat (buf
, ", position independent");
1709 strcat (buf
, ", 8 bit structure alignment");
1712 case EF_ARM_NEW_ABI
:
1713 strcat (buf
, ", uses new ABI");
1716 case EF_ARM_OLD_ABI
:
1717 strcat (buf
, ", uses old ABI");
1720 case EF_ARM_SOFT_FLOAT
:
1721 strcat (buf
, ", software FP");
1732 strcat (buf
,", <unknown>");
1736 get_machine_flags (e_flags
, e_machine
)
1740 static char buf
[1024];
1752 decode_ARM_machine_flags (e_flags
, buf
);
1756 if (e_flags
& EF_CPU32
)
1757 strcat (buf
, ", cpu32");
1758 if (e_flags
& EF_M68000
)
1759 strcat (buf
, ", m68000");
1763 if (e_flags
& EF_PPC_EMB
)
1764 strcat (buf
, ", emb");
1766 if (e_flags
& EF_PPC_RELOCATABLE
)
1767 strcat (buf
, ", relocatable");
1769 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1770 strcat (buf
, ", relocatable-lib");
1774 case EM_CYGNUS_V850
:
1775 switch (e_flags
& EF_V850_ARCH
)
1778 strcat (buf
, ", v850e");
1781 strcat (buf
, ", v850");
1784 strcat (buf
, ", unknown v850 architecture variant");
1790 case EM_CYGNUS_M32R
:
1791 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1792 strcat (buf
, ", m32r");
1797 case EM_MIPS_RS3_LE
:
1798 if (e_flags
& EF_MIPS_NOREORDER
)
1799 strcat (buf
, ", noreorder");
1801 if (e_flags
& EF_MIPS_PIC
)
1802 strcat (buf
, ", pic");
1804 if (e_flags
& EF_MIPS_CPIC
)
1805 strcat (buf
, ", cpic");
1807 if (e_flags
& EF_MIPS_UCODE
)
1808 strcat (buf
, ", ugen_reserved");
1810 if (e_flags
& EF_MIPS_ABI2
)
1811 strcat (buf
, ", abi2");
1813 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1814 strcat (buf
, ", odk first");
1816 if (e_flags
& EF_MIPS_32BITMODE
)
1817 strcat (buf
, ", 32bitmode");
1819 switch ((e_flags
& EF_MIPS_MACH
))
1821 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1822 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1823 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1824 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1825 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1826 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1828 /* We simply ignore the field in this case to avoid confusion:
1829 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1832 default: strcat (buf
, ", unknown CPU"); break;
1835 switch ((e_flags
& EF_MIPS_ABI
))
1837 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1838 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1839 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1840 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1842 /* We simply ignore the field in this case to avoid confusion:
1843 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1844 This means it is likely to be an o32 file, but not for
1847 default: strcat (buf
, ", unknown ABI"); break;
1850 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1851 strcat (buf
, ", mdmx");
1853 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1854 strcat (buf
, ", mips16");
1856 switch ((e_flags
& EF_MIPS_ARCH
))
1858 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1859 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1860 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1861 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1862 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1863 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1864 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1865 default: strcat (buf
, ", unknown ISA"); break;
1871 if (e_flags
& EF_SPARC_32PLUS
)
1872 strcat (buf
, ", v8+");
1874 if (e_flags
& EF_SPARC_SUN_US1
)
1875 strcat (buf
, ", ultrasparcI");
1877 if (e_flags
& EF_SPARC_SUN_US3
)
1878 strcat (buf
, ", ultrasparcIII");
1880 if (e_flags
& EF_SPARC_HAL_R1
)
1881 strcat (buf
, ", halr1");
1883 if (e_flags
& EF_SPARC_LEDATA
)
1884 strcat (buf
, ", ledata");
1886 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1887 strcat (buf
, ", tso");
1889 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1890 strcat (buf
, ", pso");
1892 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1893 strcat (buf
, ", rmo");
1897 switch (e_flags
& EF_PARISC_ARCH
)
1899 case EFA_PARISC_1_0
:
1900 strcpy (buf
, ", PA-RISC 1.0");
1902 case EFA_PARISC_1_1
:
1903 strcpy (buf
, ", PA-RISC 1.1");
1905 case EFA_PARISC_2_0
:
1906 strcpy (buf
, ", PA-RISC 2.0");
1911 if (e_flags
& EF_PARISC_TRAPNIL
)
1912 strcat (buf
, ", trapnil");
1913 if (e_flags
& EF_PARISC_EXT
)
1914 strcat (buf
, ", ext");
1915 if (e_flags
& EF_PARISC_LSB
)
1916 strcat (buf
, ", lsb");
1917 if (e_flags
& EF_PARISC_WIDE
)
1918 strcat (buf
, ", wide");
1919 if (e_flags
& EF_PARISC_NO_KABP
)
1920 strcat (buf
, ", no kabp");
1921 if (e_flags
& EF_PARISC_LAZYSWAP
)
1922 strcat (buf
, ", lazyswap");
1927 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1928 strcat (buf
, ", new calling convention");
1930 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1931 strcat (buf
, ", gnu calling convention");
1935 if ((e_flags
& EF_IA_64_ABI64
))
1936 strcat (buf
, ", 64-bit");
1938 strcat (buf
, ", 32-bit");
1939 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1940 strcat (buf
, ", reduced fp model");
1941 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1942 strcat (buf
, ", no function descriptors, constant gp");
1943 else if ((e_flags
& EF_IA_64_CONS_GP
))
1944 strcat (buf
, ", constant gp");
1945 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1946 strcat (buf
, ", absolute");
1950 if ((e_flags
& EF_VAX_NONPIC
))
1951 strcat (buf
, ", non-PIC");
1952 if ((e_flags
& EF_VAX_DFLOAT
))
1953 strcat (buf
, ", D-Float");
1954 if ((e_flags
& EF_VAX_GFLOAT
))
1955 strcat (buf
, ", G-Float");
1964 get_mips_segment_type (type
)
1969 case PT_MIPS_REGINFO
:
1971 case PT_MIPS_RTPROC
:
1973 case PT_MIPS_OPTIONS
:
1983 get_parisc_segment_type (type
)
1988 case PT_HP_TLS
: return "HP_TLS";
1989 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1990 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1991 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1992 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1993 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1994 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1995 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1996 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1997 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1998 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1999 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2000 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2001 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2010 get_ia64_segment_type (type
)
2015 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2016 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2017 case PT_HP_TLS
: return "HP_TLS";
2018 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2019 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2020 case PT_IA_64_HP_STACK
: return "HP_STACK";
2029 get_segment_type (p_type
)
2030 unsigned long p_type
;
2032 static char buff
[32];
2036 case PT_NULL
: return "NULL";
2037 case PT_LOAD
: return "LOAD";
2038 case PT_DYNAMIC
: return "DYNAMIC";
2039 case PT_INTERP
: return "INTERP";
2040 case PT_NOTE
: return "NOTE";
2041 case PT_SHLIB
: return "SHLIB";
2042 case PT_PHDR
: return "PHDR";
2043 case PT_TLS
: return "TLS";
2045 case PT_GNU_EH_FRAME
:
2046 return "GNU_EH_FRAME";
2049 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2051 const char * result
;
2053 switch (elf_header
.e_machine
)
2056 case EM_MIPS_RS3_LE
:
2057 result
= get_mips_segment_type (p_type
);
2060 result
= get_parisc_segment_type (p_type
);
2063 result
= get_ia64_segment_type (p_type
);
2073 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2075 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2077 const char * result
;
2079 switch (elf_header
.e_machine
)
2082 result
= get_parisc_segment_type (p_type
);
2085 result
= get_ia64_segment_type (p_type
);
2095 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2098 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2105 get_mips_section_type_name (sh_type
)
2106 unsigned int sh_type
;
2110 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2111 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2112 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2113 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2114 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2115 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2116 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2117 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2118 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2119 case SHT_MIPS_RELD
: return "MIPS_RELD";
2120 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2121 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2122 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2123 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2124 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2125 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2126 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2127 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2128 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2129 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2130 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2131 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2132 case SHT_MIPS_LINE
: return "MIPS_LINE";
2133 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2134 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2135 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2136 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2137 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2138 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2139 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2140 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2141 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2142 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2143 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2144 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2145 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2146 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2147 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2148 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2156 get_parisc_section_type_name (sh_type
)
2157 unsigned int sh_type
;
2161 case SHT_PARISC_EXT
: return "PARISC_EXT";
2162 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2163 case SHT_PARISC_DOC
: return "PARISC_DOC";
2171 get_ia64_section_type_name (sh_type
)
2172 unsigned int sh_type
;
2176 case SHT_IA_64_EXT
: return "IA_64_EXT";
2177 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2185 get_section_type_name (sh_type
)
2186 unsigned int sh_type
;
2188 static char buff
[32];
2192 case SHT_NULL
: return "NULL";
2193 case SHT_PROGBITS
: return "PROGBITS";
2194 case SHT_SYMTAB
: return "SYMTAB";
2195 case SHT_STRTAB
: return "STRTAB";
2196 case SHT_RELA
: return "RELA";
2197 case SHT_HASH
: return "HASH";
2198 case SHT_DYNAMIC
: return "DYNAMIC";
2199 case SHT_NOTE
: return "NOTE";
2200 case SHT_NOBITS
: return "NOBITS";
2201 case SHT_REL
: return "REL";
2202 case SHT_SHLIB
: return "SHLIB";
2203 case SHT_DYNSYM
: return "DYNSYM";
2204 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2205 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2206 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2207 case SHT_GROUP
: return "GROUP";
2208 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2209 case SHT_GNU_verdef
: return "VERDEF";
2210 case SHT_GNU_verneed
: return "VERNEED";
2211 case SHT_GNU_versym
: return "VERSYM";
2212 case 0x6ffffff0: return "VERSYM";
2213 case 0x6ffffffc: return "VERDEF";
2214 case 0x7ffffffd: return "AUXILIARY";
2215 case 0x7fffffff: return "FILTER";
2216 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2219 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2221 const char * result
;
2223 switch (elf_header
.e_machine
)
2226 case EM_MIPS_RS3_LE
:
2227 result
= get_mips_section_type_name (sh_type
);
2230 result
= get_parisc_section_type_name (sh_type
);
2233 result
= get_ia64_section_type_name (sh_type
);
2243 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2245 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2246 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2247 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2248 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2250 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2256 #define OPTION_DEBUG_DUMP 512
2258 struct option options
[] =
2260 {"all", no_argument
, 0, 'a'},
2261 {"file-header", no_argument
, 0, 'h'},
2262 {"program-headers", no_argument
, 0, 'l'},
2263 {"headers", no_argument
, 0, 'e'},
2264 {"histogram", no_argument
, 0, 'I'},
2265 {"segments", no_argument
, 0, 'l'},
2266 {"sections", no_argument
, 0, 'S'},
2267 {"section-headers", no_argument
, 0, 'S'},
2268 {"symbols", no_argument
, 0, 's'},
2269 {"syms", no_argument
, 0, 's'},
2270 {"relocs", no_argument
, 0, 'r'},
2271 {"notes", no_argument
, 0, 'n'},
2272 {"dynamic", no_argument
, 0, 'd'},
2273 {"arch-specific", no_argument
, 0, 'A'},
2274 {"version-info", no_argument
, 0, 'V'},
2275 {"use-dynamic", no_argument
, 0, 'D'},
2276 {"hex-dump", required_argument
, 0, 'x'},
2277 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2278 {"unwind", no_argument
, 0, 'u'},
2279 #ifdef SUPPORT_DISASSEMBLY
2280 {"instruction-dump", required_argument
, 0, 'i'},
2283 {"version", no_argument
, 0, 'v'},
2284 {"wide", no_argument
, 0, 'W'},
2285 {"help", no_argument
, 0, 'H'},
2286 {0, no_argument
, 0, 0}
2292 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2293 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2294 fprintf (stdout
, _(" Options are:\n\
2295 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2296 -h --file-header Display the ELF file header\n\
2297 -l --program-headers Display the program headers\n\
2298 --segments An alias for --program-headers\n\
2299 -S --section-headers Display the sections' header\n\
2300 --sections An alias for --section-headers\n\
2301 -e --headers Equivalent to: -h -l -S\n\
2302 -s --syms Display the symbol table\n\
2303 --symbols An alias for --syms\n\
2304 -n --notes Display the core notes (if present)\n\
2305 -r --relocs Display the relocations (if present)\n\
2306 -u --unwind Display the unwind info (if present)\n\
2307 -d --dynamic Display the dynamic segment (if present)\n\
2308 -V --version-info Display the version sections (if present)\n\
2309 -A --arch-specific Display architecture specific information (if any).\n\
2310 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2311 -x --hex-dump=<number> Dump the contents of section <number>\n\
2312 -w[liaprmfFso] or\n\
2313 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2314 Display the contents of DWARF2 debug sections\n"));
2315 #ifdef SUPPORT_DISASSEMBLY
2316 fprintf (stdout
, _("\
2317 -i --instruction-dump=<number>\n\
2318 Disassemble the contents of section <number>\n"));
2320 fprintf (stdout
, _("\
2321 -I --histogram Display histogram of bucket list lengths\n\
2322 -W --wide Allow output width to exceed 80 characters\n\
2323 -H --help Display this information\n\
2324 -v --version Display the version number of readelf\n"));
2325 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2331 request_dump (section
, type
)
2332 unsigned int section
;
2335 if (section
>= num_dump_sects
)
2337 char * new_dump_sects
;
2339 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2341 if (new_dump_sects
== NULL
)
2342 error (_("Out of memory allocating dump request table."));
2345 /* Copy current flag settings. */
2346 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2350 dump_sects
= new_dump_sects
;
2351 num_dump_sects
= section
+ 1;
2356 dump_sects
[section
] |= type
;
2362 parse_args (argc
, argv
)
2371 while ((c
= getopt_long
2372 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2408 do_using_dynamic
++;
2439 section
= strtoul (optarg
, & cp
, 0);
2440 if (! * cp
&& section
>= 0)
2442 request_dump (section
, HEX_DUMP
);
2452 unsigned int index
= 0;
2456 while (optarg
[index
])
2457 switch (optarg
[index
++])
2466 do_debug_abbrevs
= 1;
2476 do_debug_pubnames
= 1;
2481 do_debug_aranges
= 1;
2485 do_debug_frames_interp
= 1;
2487 do_debug_frames
= 1;
2492 do_debug_macinfo
= 1;
2506 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2511 case OPTION_DEBUG_DUMP
:
2517 static const char *debug_dump_opt
[]
2518 = { "line", "info", "abbrev", "pubnames", "ranges",
2519 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2528 for (index
= 0; debug_dump_opt
[index
]; index
++)
2530 size_t len
= strlen (debug_dump_opt
[index
]);
2532 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2533 && (p
[len
] == ',' || p
[len
] == '\0'))
2542 do_debug_abbrevs
= 1;
2553 do_debug_pubnames
= 1;
2557 do_debug_aranges
= 1;
2562 do_debug_frames_interp
= 1;
2563 do_debug_frames
= 1;
2567 do_debug_macinfo
= 1;
2580 if (debug_dump_opt
[index
] == NULL
)
2582 warn (_("Unrecognized debug option '%s'\n"), p
);
2583 p
= strchr (p
, ',');
2593 #ifdef SUPPORT_DISASSEMBLY
2596 section
= strtoul (optarg
, & cp
, 0);
2597 if (! * cp
&& section
>= 0)
2599 request_dump (section
, DISASS_DUMP
);
2605 print_version (program_name
);
2615 /* xgettext:c-format */
2616 error (_("Invalid option '-%c'\n"), c
);
2623 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2624 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2625 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2629 warn (_("Nothing to do.\n"));
2635 get_elf_class (elf_class
)
2636 unsigned int elf_class
;
2638 static char buff
[32];
2642 case ELFCLASSNONE
: return _("none");
2643 case ELFCLASS32
: return "ELF32";
2644 case ELFCLASS64
: return "ELF64";
2646 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2652 get_data_encoding (encoding
)
2653 unsigned int encoding
;
2655 static char buff
[32];
2659 case ELFDATANONE
: return _("none");
2660 case ELFDATA2LSB
: return _("2's complement, little endian");
2661 case ELFDATA2MSB
: return _("2's complement, big endian");
2663 sprintf (buff
, _("<unknown: %x>"), encoding
);
2669 get_osabi_name (osabi
)
2672 static char buff
[32];
2676 case ELFOSABI_NONE
: return "UNIX - System V";
2677 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2678 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2679 case ELFOSABI_LINUX
: return "UNIX - Linux";
2680 case ELFOSABI_HURD
: return "GNU/Hurd";
2681 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2682 case ELFOSABI_AIX
: return "UNIX - AIX";
2683 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2684 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2685 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2686 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2687 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2688 case ELFOSABI_STANDALONE
: return _("Standalone App");
2689 case ELFOSABI_ARM
: return "ARM";
2691 sprintf (buff
, _("<unknown: %x>"), osabi
);
2696 /* Decode the data held in 'elf_header'. */
2698 process_file_header ()
2700 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2701 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2702 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2703 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2706 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2714 printf (_("ELF Header:\n"));
2715 printf (_(" Magic: "));
2716 for (i
= 0; i
< EI_NIDENT
; i
++)
2717 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2719 printf (_(" Class: %s\n"),
2720 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2721 printf (_(" Data: %s\n"),
2722 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2723 printf (_(" Version: %d %s\n"),
2724 elf_header
.e_ident
[EI_VERSION
],
2725 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2727 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2730 printf (_(" OS/ABI: %s\n"),
2731 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2732 printf (_(" ABI Version: %d\n"),
2733 elf_header
.e_ident
[EI_ABIVERSION
]);
2734 printf (_(" Type: %s\n"),
2735 get_file_type (elf_header
.e_type
));
2736 printf (_(" Machine: %s\n"),
2737 get_machine_name (elf_header
.e_machine
));
2738 printf (_(" Version: 0x%lx\n"),
2739 (unsigned long) elf_header
.e_version
);
2741 printf (_(" Entry point address: "));
2742 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2743 printf (_("\n Start of program headers: "));
2744 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2745 printf (_(" (bytes into file)\n Start of section headers: "));
2746 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2747 printf (_(" (bytes into file)\n"));
2749 printf (_(" Flags: 0x%lx%s\n"),
2750 (unsigned long) elf_header
.e_flags
,
2751 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2752 printf (_(" Size of this header: %ld (bytes)\n"),
2753 (long) elf_header
.e_ehsize
);
2754 printf (_(" Size of program headers: %ld (bytes)\n"),
2755 (long) elf_header
.e_phentsize
);
2756 printf (_(" Number of program headers: %ld\n"),
2757 (long) elf_header
.e_phnum
);
2758 printf (_(" Size of section headers: %ld (bytes)\n"),
2759 (long) elf_header
.e_shentsize
);
2760 printf (_(" Number of section headers: %ld"),
2761 (long) elf_header
.e_shnum
);
2762 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2763 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2764 putc ('\n', stdout
);
2765 printf (_(" Section header string table index: %ld"),
2766 (long) elf_header
.e_shstrndx
);
2767 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2768 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2769 putc ('\n', stdout
);
2772 if (section_headers
!= NULL
)
2774 if (elf_header
.e_shnum
== 0)
2775 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2776 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2777 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2778 free (section_headers
);
2779 section_headers
= NULL
;
2787 get_32bit_program_headers (file
, program_headers
)
2789 Elf_Internal_Phdr
* program_headers
;
2791 Elf32_External_Phdr
* phdrs
;
2792 Elf32_External_Phdr
* external
;
2793 Elf32_Internal_Phdr
* internal
;
2796 phdrs
= ((Elf32_External_Phdr
*)
2797 get_data (NULL
, file
, elf_header
.e_phoff
,
2798 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2799 _("program headers")));
2803 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2804 i
< elf_header
.e_phnum
;
2805 i
++, internal
++, external
++)
2807 internal
->p_type
= BYTE_GET (external
->p_type
);
2808 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2809 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2810 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2811 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2812 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2813 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2814 internal
->p_align
= BYTE_GET (external
->p_align
);
2823 get_64bit_program_headers (file
, program_headers
)
2825 Elf_Internal_Phdr
* program_headers
;
2827 Elf64_External_Phdr
* phdrs
;
2828 Elf64_External_Phdr
* external
;
2829 Elf64_Internal_Phdr
* internal
;
2832 phdrs
= ((Elf64_External_Phdr
*)
2833 get_data (NULL
, file
, elf_header
.e_phoff
,
2834 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2835 _("program headers")));
2839 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2840 i
< elf_header
.e_phnum
;
2841 i
++, internal
++, external
++)
2843 internal
->p_type
= BYTE_GET (external
->p_type
);
2844 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2845 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2846 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2847 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2848 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2849 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2850 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2859 process_program_headers (file
)
2862 Elf_Internal_Phdr
* program_headers
;
2863 Elf_Internal_Phdr
* segment
;
2866 if (elf_header
.e_phnum
== 0)
2869 printf (_("\nThere are no program headers in this file.\n"));
2873 if (do_segments
&& !do_header
)
2875 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2876 printf (_("Entry point "));
2877 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2878 printf (_("\nThere are %d program headers, starting at offset "),
2879 elf_header
.e_phnum
);
2880 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2884 program_headers
= (Elf_Internal_Phdr
*) malloc
2885 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2887 if (program_headers
== NULL
)
2889 error (_("Out of memory\n"));
2894 i
= get_32bit_program_headers (file
, program_headers
);
2896 i
= get_64bit_program_headers (file
, program_headers
);
2900 free (program_headers
);
2906 if (elf_header
.e_phnum
> 1)
2907 printf (_("\nProgram Headers:\n"));
2909 printf (_("\nProgram Headers:\n"));
2913 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2916 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2920 (_(" Type Offset VirtAddr PhysAddr\n"));
2922 (_(" FileSiz MemSiz Flags Align\n"));
2930 for (i
= 0, segment
= program_headers
;
2931 i
< elf_header
.e_phnum
;
2936 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2940 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2941 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2942 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2943 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2944 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2946 (segment
->p_flags
& PF_R
? 'R' : ' '),
2947 (segment
->p_flags
& PF_W
? 'W' : ' '),
2948 (segment
->p_flags
& PF_X
? 'E' : ' '));
2949 printf ("%#lx", (unsigned long) segment
->p_align
);
2953 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2954 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2957 print_vma (segment
->p_offset
, FULL_HEX
);
2961 print_vma (segment
->p_vaddr
, FULL_HEX
);
2963 print_vma (segment
->p_paddr
, FULL_HEX
);
2966 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
2967 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
2970 print_vma (segment
->p_filesz
, FULL_HEX
);
2974 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
2975 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
2978 print_vma (segment
->p_offset
, FULL_HEX
);
2982 (segment
->p_flags
& PF_R
? 'R' : ' '),
2983 (segment
->p_flags
& PF_W
? 'W' : ' '),
2984 (segment
->p_flags
& PF_X
? 'E' : ' '));
2986 if ((unsigned long) segment
->p_align
== segment
->p_align
)
2987 printf ("%#lx", (unsigned long) segment
->p_align
);
2990 print_vma (segment
->p_align
, PREFIX_HEX
);
2995 print_vma (segment
->p_offset
, FULL_HEX
);
2997 print_vma (segment
->p_vaddr
, FULL_HEX
);
2999 print_vma (segment
->p_paddr
, FULL_HEX
);
3001 print_vma (segment
->p_filesz
, FULL_HEX
);
3003 print_vma (segment
->p_memsz
, FULL_HEX
);
3005 (segment
->p_flags
& PF_R
? 'R' : ' '),
3006 (segment
->p_flags
& PF_W
? 'W' : ' '),
3007 (segment
->p_flags
& PF_X
? 'E' : ' '));
3008 print_vma (segment
->p_align
, HEX
);
3012 switch (segment
->p_type
)
3016 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
3017 - (segment
->p_offset
& 0xfffff000);
3022 error (_("more than one dynamic segment\n"));
3024 dynamic_addr
= segment
->p_offset
;
3025 dynamic_size
= segment
->p_filesz
;
3029 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
3030 error (_("Unable to find program interpreter name\n"));
3033 program_interpreter
[0] = 0;
3034 fscanf (file
, "%63s", program_interpreter
);
3037 printf (_("\n [Requesting program interpreter: %s]"),
3038 program_interpreter
);
3044 putc ('\n', stdout
);
3053 if (do_segments
&& section_headers
!= NULL
)
3055 printf (_("\n Section to Segment mapping:\n"));
3056 printf (_(" Segment Sections...\n"));
3058 assert (string_table
!= NULL
);
3060 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3063 Elf_Internal_Shdr
* section
;
3065 segment
= program_headers
+ i
;
3066 section
= section_headers
;
3068 printf (" %2.2d ", i
);
3070 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3072 if (section
->sh_size
> 0
3073 /* Compare allocated sections by VMA, unallocated
3074 sections by file offset. */
3075 && (section
->sh_flags
& SHF_ALLOC
3076 ? (section
->sh_addr
>= segment
->p_vaddr
3077 && section
->sh_addr
+ section
->sh_size
3078 <= segment
->p_vaddr
+ segment
->p_memsz
)
3079 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3080 && (section
->sh_offset
+ section
->sh_size
3081 <= segment
->p_offset
+ segment
->p_filesz
))))
3082 printf ("%s ", SECTION_NAME (section
));
3089 free (program_headers
);
3096 get_32bit_section_headers (file
, num
)
3100 Elf32_External_Shdr
* shdrs
;
3101 Elf32_Internal_Shdr
* internal
;
3104 shdrs
= ((Elf32_External_Shdr
*)
3105 get_data (NULL
, file
, elf_header
.e_shoff
,
3106 elf_header
.e_shentsize
* num
,
3107 _("section headers")));
3111 section_headers
= ((Elf_Internal_Shdr
*)
3112 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3114 if (section_headers
== NULL
)
3116 error (_("Out of memory\n"));
3120 for (i
= 0, internal
= section_headers
;
3124 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3125 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3126 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3127 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3128 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3129 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3130 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3131 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3132 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3133 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3142 get_64bit_section_headers (file
, num
)
3146 Elf64_External_Shdr
* shdrs
;
3147 Elf64_Internal_Shdr
* internal
;
3150 shdrs
= ((Elf64_External_Shdr
*)
3151 get_data (NULL
, file
, elf_header
.e_shoff
,
3152 elf_header
.e_shentsize
* num
,
3153 _("section headers")));
3157 section_headers
= ((Elf_Internal_Shdr
*)
3158 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3160 if (section_headers
== NULL
)
3162 error (_("Out of memory\n"));
3166 for (i
= 0, internal
= section_headers
;
3170 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3171 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3172 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3173 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3174 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3175 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3176 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3177 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3178 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3179 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3187 static Elf_Internal_Sym
*
3188 get_32bit_elf_symbols (file
, section
)
3190 Elf_Internal_Shdr
*section
;
3192 unsigned long number
;
3193 Elf32_External_Sym
* esyms
;
3194 Elf_External_Sym_Shndx
*shndx
;
3195 Elf_Internal_Sym
* isyms
;
3196 Elf_Internal_Sym
* psym
;
3199 esyms
= ((Elf32_External_Sym
*)
3200 get_data (NULL
, file
, section
->sh_offset
,
3201 section
->sh_size
, _("symbols")));
3206 if (symtab_shndx_hdr
!= NULL
3207 && (symtab_shndx_hdr
->sh_link
3208 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3210 shndx
= ((Elf_External_Sym_Shndx
*)
3211 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3212 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3220 number
= section
->sh_size
/ section
->sh_entsize
;
3221 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3225 error (_("Out of memory\n"));
3232 for (j
= 0, psym
= isyms
;
3236 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3237 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3238 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3239 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3240 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3242 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3243 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3244 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3254 static Elf_Internal_Sym
*
3255 get_64bit_elf_symbols (file
, section
)
3257 Elf_Internal_Shdr
*section
;
3259 unsigned long number
;
3260 Elf64_External_Sym
* esyms
;
3261 Elf_External_Sym_Shndx
*shndx
;
3262 Elf_Internal_Sym
* isyms
;
3263 Elf_Internal_Sym
* psym
;
3266 esyms
= ((Elf64_External_Sym
*)
3267 get_data (NULL
, file
, section
->sh_offset
,
3268 section
->sh_size
, _("symbols")));
3273 if (symtab_shndx_hdr
!= NULL
3274 && (symtab_shndx_hdr
->sh_link
3275 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3277 shndx
= ((Elf_External_Sym_Shndx
*)
3278 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3279 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3287 number
= section
->sh_size
/ section
->sh_entsize
;
3288 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3292 error (_("Out of memory\n"));
3299 for (j
= 0, psym
= isyms
;
3303 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3304 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3305 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3306 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3307 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3309 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3310 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3311 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3322 get_elf_section_flags (sh_flags
)
3325 static char buff
[32];
3333 flag
= sh_flags
& - sh_flags
;
3338 case SHF_WRITE
: strcat (buff
, "W"); break;
3339 case SHF_ALLOC
: strcat (buff
, "A"); break;
3340 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3341 case SHF_MERGE
: strcat (buff
, "M"); break;
3342 case SHF_STRINGS
: strcat (buff
, "S"); break;
3343 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3344 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3345 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3346 case SHF_GROUP
: strcat (buff
, "G"); break;
3347 case SHF_TLS
: strcat (buff
, "T"); break;
3350 if (flag
& SHF_MASKOS
)
3353 sh_flags
&= ~ SHF_MASKOS
;
3355 else if (flag
& SHF_MASKPROC
)
3358 sh_flags
&= ~ SHF_MASKPROC
;
3370 process_section_headers (file
)
3373 Elf_Internal_Shdr
* section
;
3376 section_headers
= NULL
;
3378 if (elf_header
.e_shnum
== 0)
3381 printf (_("\nThere are no sections in this file.\n"));
3386 if (do_sections
&& !do_header
)
3387 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3388 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3392 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3395 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3398 /* Read in the string table, so that we have names to display. */
3399 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3401 if (section
->sh_size
!= 0)
3403 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3404 section
->sh_size
, _("string table"));
3406 string_table_length
= section
->sh_size
;
3409 /* Scan the sections for the dynamic symbol table
3410 and dynamic string table and debug sections. */
3411 dynamic_symbols
= NULL
;
3412 dynamic_strings
= NULL
;
3413 dynamic_syminfo
= NULL
;
3415 for (i
= 0, section
= section_headers
;
3416 i
< elf_header
.e_shnum
;
3419 char * name
= SECTION_NAME (section
);
3421 if (section
->sh_type
== SHT_DYNSYM
)
3423 if (dynamic_symbols
!= NULL
)
3425 error (_("File contains multiple dynamic symbol tables\n"));
3429 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3430 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3432 else if (section
->sh_type
== SHT_STRTAB
3433 && strcmp (name
, ".dynstr") == 0)
3435 if (dynamic_strings
!= NULL
)
3437 error (_("File contains multiple dynamic string tables\n"));
3441 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3443 _("dynamic strings"));
3445 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3447 if (symtab_shndx_hdr
!= NULL
)
3449 error (_("File contains multiple symtab shndx tables\n"));
3452 symtab_shndx_hdr
= section
;
3454 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3455 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3456 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3458 && strncmp (name
, ".debug_", 7) == 0)
3463 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3464 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3465 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3466 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3467 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3468 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3469 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3470 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3471 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3473 request_dump (i
, DEBUG_DUMP
);
3475 /* linkonce section to be combined with .debug_info at link time. */
3476 else if ((do_debugging
|| do_debug_info
)
3477 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3478 request_dump (i
, DEBUG_DUMP
);
3479 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3480 request_dump (i
, DEBUG_DUMP
);
3486 if (elf_header
.e_shnum
> 1)
3487 printf (_("\nSection Headers:\n"));
3489 printf (_("\nSection Header:\n"));
3493 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3496 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3499 printf (_(" [Nr] Name Type Address Offset\n"));
3500 printf (_(" Size EntSize Flags Link Info Align\n"));
3503 for (i
= 0, section
= section_headers
;
3504 i
< elf_header
.e_shnum
;
3507 printf (" [%2u] %-17.17s %-15.15s ",
3508 SECTION_HEADER_NUM (i
),
3509 SECTION_NAME (section
),
3510 get_section_type_name (section
->sh_type
));
3514 print_vma (section
->sh_addr
, LONG_HEX
);
3516 printf ( " %6.6lx %6.6lx %2.2lx",
3517 (unsigned long) section
->sh_offset
,
3518 (unsigned long) section
->sh_size
,
3519 (unsigned long) section
->sh_entsize
);
3521 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3523 printf ("%2ld %3lx %2ld\n",
3524 (unsigned long) section
->sh_link
,
3525 (unsigned long) section
->sh_info
,
3526 (unsigned long) section
->sh_addralign
);
3530 print_vma (section
->sh_addr
, LONG_HEX
);
3532 if ((long) section
->sh_offset
== section
->sh_offset
)
3533 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3537 print_vma (section
->sh_offset
, LONG_HEX
);
3540 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3541 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3545 print_vma (section
->sh_size
, LONG_HEX
);
3548 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3549 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3553 print_vma (section
->sh_entsize
, LONG_HEX
);
3556 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3558 printf ("%2ld %3lx ",
3559 (unsigned long) section
->sh_link
,
3560 (unsigned long) section
->sh_info
);
3562 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3563 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3566 print_vma (section
->sh_addralign
, DEC
);
3573 print_vma (section
->sh_addr
, LONG_HEX
);
3574 if ((long) section
->sh_offset
== section
->sh_offset
)
3575 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3579 print_vma (section
->sh_offset
, LONG_HEX
);
3582 print_vma (section
->sh_size
, LONG_HEX
);
3584 print_vma (section
->sh_entsize
, LONG_HEX
);
3586 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3588 printf (" %2ld %3lx %ld\n",
3589 (unsigned long) section
->sh_link
,
3590 (unsigned long) section
->sh_info
,
3591 (unsigned long) section
->sh_addralign
);
3595 printf (_("Key to Flags:\n\
3596 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3597 I (info), L (link order), G (group), x (unknown)\n\
3598 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3603 /* Process the reloc section. */
3605 process_relocs (file
)
3608 unsigned long rel_size
;
3609 unsigned long rel_offset
;
3615 if (do_using_dynamic
)
3617 int is_rela
= FALSE
;
3622 if (dynamic_info
[DT_REL
])
3624 rel_offset
= dynamic_info
[DT_REL
];
3625 rel_size
= dynamic_info
[DT_RELSZ
];
3628 else if (dynamic_info
[DT_RELA
])
3630 rel_offset
= dynamic_info
[DT_RELA
];
3631 rel_size
= dynamic_info
[DT_RELASZ
];
3634 else if (dynamic_info
[DT_JMPREL
])
3636 rel_offset
= dynamic_info
[DT_JMPREL
];
3637 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3639 switch (dynamic_info
[DT_PLTREL
])
3656 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3657 rel_offset
, rel_size
);
3659 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3660 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3663 printf (_("\nThere are no dynamic relocations in this file.\n"));
3667 Elf32_Internal_Shdr
* section
;
3671 for (i
= 0, section
= section_headers
;
3672 i
< elf_header
.e_shnum
;
3675 if ( section
->sh_type
!= SHT_RELA
3676 && section
->sh_type
!= SHT_REL
)
3679 rel_offset
= section
->sh_offset
;
3680 rel_size
= section
->sh_size
;
3684 Elf32_Internal_Shdr
* strsec
;
3685 Elf_Internal_Sym
* symtab
;
3688 unsigned long nsyms
;
3690 printf (_("\nRelocation section "));
3692 if (string_table
== NULL
)
3693 printf ("%d", section
->sh_name
);
3695 printf (_("'%s'"), SECTION_NAME (section
));
3697 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3698 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3703 if (section
->sh_link
)
3705 Elf32_Internal_Shdr
* symsec
;
3707 symsec
= SECTION_HEADER (section
->sh_link
);
3708 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3709 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3714 strsec
= SECTION_HEADER (symsec
->sh_link
);
3716 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3720 is_rela
= section
->sh_type
== SHT_RELA
;
3722 dump_relocations (file
, rel_offset
, rel_size
,
3723 symtab
, nsyms
, strtab
, is_rela
);
3735 printf (_("\nThere are no relocations in this file.\n"));
3741 #include "unwind-ia64.h"
3743 /* An absolute address consists of a section and an offset. If the
3744 section is NULL, the offset itself is the address, otherwise, the
3745 address equals to LOAD_ADDRESS(section) + offset. */
3749 unsigned short section
;
3755 struct unw_table_entry
3757 struct absaddr start
;
3759 struct absaddr info
;
3761 *table
; /* Unwind table. */
3762 unsigned long table_len
; /* Length of unwind table. */
3763 unsigned char * info
; /* Unwind info. */
3764 unsigned long info_size
; /* Size of unwind info. */
3765 bfd_vma info_addr
; /* starting address of unwind info. */
3766 bfd_vma seg_base
; /* Starting address of segment. */
3767 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3768 unsigned long nsyms
; /* Number of symbols. */
3769 char * strtab
; /* The string table. */
3770 unsigned long strtab_size
; /* Size of string table. */
3773 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3774 struct absaddr
, const char **,
3776 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3777 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3778 Elf32_Internal_Shdr
*));
3781 find_symbol_for_address (aux
, addr
, symname
, offset
)
3782 struct unw_aux_info
*aux
;
3783 struct absaddr addr
;
3784 const char **symname
;
3787 bfd_vma dist
= (bfd_vma
) 0x100000;
3788 Elf_Internal_Sym
*sym
, *best
= NULL
;
3791 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3793 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3794 && sym
->st_name
!= 0
3795 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3796 && addr
.offset
>= sym
->st_value
3797 && addr
.offset
- sym
->st_value
< dist
)
3800 dist
= addr
.offset
- sym
->st_value
;
3807 *symname
= (best
->st_name
>= aux
->strtab_size
3808 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3813 *offset
= addr
.offset
;
3817 dump_ia64_unwind (aux
)
3818 struct unw_aux_info
*aux
;
3821 struct unw_table_entry
* tp
;
3824 addr_size
= is_32bit_elf
? 4 : 8;
3826 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3830 const unsigned char * dp
;
3831 const unsigned char * head
;
3832 const char * procname
;
3834 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3836 fputs ("\n<", stdout
);
3840 fputs (procname
, stdout
);
3843 printf ("+%lx", (unsigned long) offset
);
3846 fputs (">: [", stdout
);
3847 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3848 fputc ('-', stdout
);
3849 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3850 printf ("], info at +0x%lx\n",
3851 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3853 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3854 stamp
= BYTE_GET8 ((unsigned char *) head
);
3856 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
3857 (unsigned) UNW_VER (stamp
),
3858 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3859 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3860 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3861 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3863 if (UNW_VER (stamp
) != 1)
3865 printf ("\tUnknown version.\n");
3870 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3871 dp
= unw_decode (dp
, in_body
, & in_body
);
3876 slurp_ia64_unwind_table (file
, aux
, sec
)
3878 struct unw_aux_info
*aux
;
3879 Elf32_Internal_Shdr
*sec
;
3881 unsigned long size
, addr_size
, nrelas
, i
;
3882 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3883 struct unw_table_entry
*tep
;
3884 Elf32_Internal_Shdr
*relsec
;
3885 Elf_Internal_Rela
*rela
, *rp
;
3886 unsigned char *table
, *tp
;
3887 Elf_Internal_Sym
*sym
;
3888 const char *relname
;
3891 addr_size
= is_32bit_elf
? 4 : 8;
3893 /* First, find the starting address of the segment that includes
3896 if (elf_header
.e_phnum
)
3898 prog_hdrs
= (Elf_Internal_Phdr
*)
3899 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3902 result
= get_32bit_program_headers (file
, prog_hdrs
);
3904 result
= get_64bit_program_headers (file
, prog_hdrs
);
3912 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3914 if (seg
->p_type
!= PT_LOAD
)
3917 if (sec
->sh_addr
>= seg
->p_vaddr
3918 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3920 aux
->seg_base
= seg
->p_vaddr
;
3928 /* Second, build the unwind table from the contents of the unwind section: */
3929 size
= sec
->sh_size
;
3930 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3931 size
, _("unwind table"));
3935 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3936 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3938 tep
->start
.section
= SHN_UNDEF
;
3939 tep
->end
.section
= SHN_UNDEF
;
3940 tep
->info
.section
= SHN_UNDEF
;
3943 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3944 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3945 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3949 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3950 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3951 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3953 tep
->start
.offset
+= aux
->seg_base
;
3954 tep
->end
.offset
+= aux
->seg_base
;
3955 tep
->info
.offset
+= aux
->seg_base
;
3959 /* Third, apply any relocations to the unwind table: */
3961 for (relsec
= section_headers
;
3962 relsec
< section_headers
+ elf_header
.e_shnum
;
3965 if (relsec
->sh_type
!= SHT_RELA
3966 || SECTION_HEADER (relsec
->sh_info
) != sec
)
3969 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3973 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3977 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3978 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3980 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3982 warn (_("Skipping unexpected symbol type %u\n"),
3983 ELF32_ST_TYPE (sym
->st_info
));
3989 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3990 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3992 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3994 warn (_("Skipping unexpected symbol type %u\n"),
3995 ELF64_ST_TYPE (sym
->st_info
));
4000 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4002 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4006 i
= rp
->r_offset
/ (3 * addr_size
);
4008 switch (rp
->r_offset
/addr_size
% 3)
4011 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4012 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4015 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4016 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4019 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4020 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4030 aux
->table_len
= size
/ (3 * addr_size
);
4035 process_unwind (file
)
4038 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4039 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4040 struct unw_aux_info aux
;
4045 if (elf_header
.e_machine
!= EM_IA_64
)
4047 printf (_("\nThere are no unwind sections in this file.\n"));
4051 memset (& aux
, 0, sizeof (aux
));
4053 addr_size
= is_32bit_elf
? 4 : 8;
4055 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4057 if (sec
->sh_type
== SHT_SYMTAB
)
4059 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4060 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4062 strsec
= SECTION_HEADER (sec
->sh_link
);
4063 aux
.strtab_size
= strsec
->sh_size
;
4064 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4065 aux
.strtab_size
, _("string table"));
4067 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4072 printf (_("\nThere are no unwind sections in this file.\n"));
4074 while (unwcount
-- > 0)
4079 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4080 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4081 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4088 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4090 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
4093 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4094 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4095 suffix
= SECTION_NAME (unwsec
) + len
;
4096 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4098 if (strncmp (SECTION_NAME (sec
),
4099 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4100 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4105 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4106 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4107 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4108 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4110 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4112 suffix
= SECTION_NAME (unwsec
) + len
;
4113 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4115 if (strncmp (SECTION_NAME (sec
),
4116 ELF_STRING_ia64_unwind_info
, len2
) == 0
4117 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4121 if (i
== elf_header
.e_shnum
)
4123 printf (_("\nCould not find unwind info section for "));
4125 if (string_table
== NULL
)
4126 printf ("%d", unwsec
->sh_name
);
4128 printf (_("'%s'"), SECTION_NAME (unwsec
));
4132 aux
.info_size
= sec
->sh_size
;
4133 aux
.info_addr
= sec
->sh_addr
;
4134 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4135 aux
.info_size
, _("unwind info"));
4137 printf (_("\nUnwind section "));
4139 if (string_table
== NULL
)
4140 printf ("%d", unwsec
->sh_name
);
4142 printf (_("'%s'"), SECTION_NAME (unwsec
));
4144 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4145 (unsigned long) unwsec
->sh_offset
,
4146 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4148 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4150 if (aux
.table_len
> 0)
4151 dump_ia64_unwind (& aux
);
4154 free ((char *) aux
.table
);
4156 free ((char *) aux
.info
);
4165 free ((char *) aux
.strtab
);
4171 dynamic_segment_mips_val (entry
)
4172 Elf_Internal_Dyn
* entry
;
4174 switch (entry
->d_tag
)
4177 if (entry
->d_un
.d_val
== 0)
4181 static const char * opts
[] =
4183 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4184 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4185 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4186 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4191 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
4192 if (entry
->d_un
.d_val
& (1 << cnt
))
4194 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4201 case DT_MIPS_IVERSION
:
4202 if (dynamic_strings
!= NULL
)
4203 printf ("Interface Version: %s\n",
4204 dynamic_strings
+ entry
->d_un
.d_val
);
4206 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4209 case DT_MIPS_TIME_STAMP
:
4214 time_t time
= entry
->d_un
.d_val
;
4215 tmp
= gmtime (&time
);
4216 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4217 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4218 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4219 printf ("Time Stamp: %s\n", timebuf
);
4223 case DT_MIPS_RLD_VERSION
:
4224 case DT_MIPS_LOCAL_GOTNO
:
4225 case DT_MIPS_CONFLICTNO
:
4226 case DT_MIPS_LIBLISTNO
:
4227 case DT_MIPS_SYMTABNO
:
4228 case DT_MIPS_UNREFEXTNO
:
4229 case DT_MIPS_HIPAGENO
:
4230 case DT_MIPS_DELTA_CLASS_NO
:
4231 case DT_MIPS_DELTA_INSTANCE_NO
:
4232 case DT_MIPS_DELTA_RELOC_NO
:
4233 case DT_MIPS_DELTA_SYM_NO
:
4234 case DT_MIPS_DELTA_CLASSSYM_NO
:
4235 case DT_MIPS_COMPACT_SIZE
:
4236 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4240 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4246 dynamic_segment_parisc_val (entry
)
4247 Elf_Internal_Dyn
* entry
;
4249 switch (entry
->d_tag
)
4251 case DT_HP_DLD_FLAGS
:
4260 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4261 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4262 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4263 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4264 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4265 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4266 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4267 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4268 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4269 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4270 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4274 bfd_vma val
= entry
->d_un
.d_val
;
4276 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4277 if (val
& flags
[cnt
].bit
)
4281 fputs (flags
[cnt
].str
, stdout
);
4283 val
^= flags
[cnt
].bit
;
4286 if (val
!= 0 || first
)
4290 print_vma (val
, HEX
);
4296 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4303 get_32bit_dynamic_segment (file
)
4306 Elf32_External_Dyn
* edyn
;
4307 Elf_Internal_Dyn
* entry
;
4310 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4311 dynamic_size
, _("dynamic segment"));
4315 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4316 how large this .dynamic is now. We can do this even before the byte
4317 swapping since the DT_NULL tag is recognizable. */
4319 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4322 dynamic_segment
= (Elf_Internal_Dyn
*)
4323 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4325 if (dynamic_segment
== NULL
)
4327 error (_("Out of memory\n"));
4332 for (i
= 0, entry
= dynamic_segment
;
4336 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4337 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4346 get_64bit_dynamic_segment (file
)
4349 Elf64_External_Dyn
* edyn
;
4350 Elf_Internal_Dyn
* entry
;
4353 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4354 dynamic_size
, _("dynamic segment"));
4358 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4359 how large this .dynamic is now. We can do this even before the byte
4360 swapping since the DT_NULL tag is recognizable. */
4362 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4365 dynamic_segment
= (Elf_Internal_Dyn
*)
4366 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4368 if (dynamic_segment
== NULL
)
4370 error (_("Out of memory\n"));
4375 for (i
= 0, entry
= dynamic_segment
;
4379 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4380 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4389 get_dynamic_flags (flags
)
4392 static char buff
[128];
4400 flag
= flags
& - flags
;
4408 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4409 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4410 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4411 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4412 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4413 default: strcpy (p
, "unknown"); break;
4416 p
= strchr (p
, '\0');
4421 /* Parse and display the contents of the dynamic segment. */
4423 process_dynamic_segment (file
)
4426 Elf_Internal_Dyn
* entry
;
4429 if (dynamic_size
== 0)
4432 printf (_("\nThere is no dynamic segment in this file.\n"));
4439 if (! get_32bit_dynamic_segment (file
))
4442 else if (! get_64bit_dynamic_segment (file
))
4445 /* Find the appropriate symbol table. */
4446 if (dynamic_symbols
== NULL
)
4448 for (i
= 0, entry
= dynamic_segment
;
4452 Elf32_Internal_Shdr section
;
4454 if (entry
->d_tag
!= DT_SYMTAB
)
4457 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4459 /* Since we do not know how big the symbol table is,
4460 we default to reading in the entire file (!) and
4461 processing that. This is overkill, I know, but it
4463 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4465 if (fseek (file
, 0, SEEK_END
))
4466 error (_("Unable to seek to end of file!"));
4468 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4470 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4472 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4474 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4475 if (num_dynamic_syms
< 1)
4477 error (_("Unable to determine the number of symbols to load\n"));
4481 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4485 /* Similarly find a string table. */
4486 if (dynamic_strings
== NULL
)
4488 for (i
= 0, entry
= dynamic_segment
;
4492 unsigned long offset
;
4495 if (entry
->d_tag
!= DT_STRTAB
)
4498 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4500 /* Since we do not know how big the string table is,
4501 we default to reading in the entire file (!) and
4502 processing that. This is overkill, I know, but it
4505 offset
= entry
->d_un
.d_val
- loadaddr
;
4506 if (fseek (file
, 0, SEEK_END
))
4507 error (_("Unable to seek to end of file\n"));
4508 str_tab_len
= ftell (file
) - offset
;
4510 if (str_tab_len
< 1)
4513 (_("Unable to determine the length of the dynamic string table\n"));
4517 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4518 _("dynamic string table"));
4523 /* And find the syminfo section if available. */
4524 if (dynamic_syminfo
== NULL
)
4526 unsigned int syminsz
= 0;
4528 for (i
= 0, entry
= dynamic_segment
;
4532 if (entry
->d_tag
== DT_SYMINENT
)
4534 /* Note: these braces are necessary to avoid a syntax
4535 error from the SunOS4 C compiler. */
4536 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4538 else if (entry
->d_tag
== DT_SYMINSZ
)
4539 syminsz
= entry
->d_un
.d_val
;
4540 else if (entry
->d_tag
== DT_SYMINFO
)
4541 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4544 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4546 Elf_External_Syminfo
* extsyminfo
;
4547 Elf_Internal_Syminfo
* syminfo
;
4549 /* There is a syminfo section. Read the data. */
4550 extsyminfo
= ((Elf_External_Syminfo
*)
4551 get_data (NULL
, file
, dynamic_syminfo_offset
,
4552 syminsz
, _("symbol information")));
4556 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4557 if (dynamic_syminfo
== NULL
)
4559 error (_("Out of memory\n"));
4563 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4564 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4567 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4568 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4575 if (do_dynamic
&& dynamic_addr
)
4576 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4577 dynamic_addr
, (long) dynamic_size
);
4579 printf (_(" Tag Type Name/Value\n"));
4581 for (i
= 0, entry
= dynamic_segment
;
4590 print_vma (entry
->d_tag
, FULL_HEX
);
4591 dtype
= get_dynamic_type (entry
->d_tag
);
4592 printf (" (%s)%*s", dtype
,
4593 ((is_32bit_elf
? 27 : 19)
4594 - (int) strlen (dtype
)),
4598 switch (entry
->d_tag
)
4602 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4612 switch (entry
->d_tag
)
4615 printf (_("Auxiliary library"));
4619 printf (_("Filter library"));
4623 printf (_("Configuration file"));
4627 printf (_("Dependency audit library"));
4631 printf (_("Audit library"));
4635 if (dynamic_strings
)
4636 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4640 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4649 printf (_("Flags:"));
4651 if (entry
->d_un
.d_val
== 0)
4652 printf (_(" None\n"));
4655 unsigned long int val
= entry
->d_un
.d_val
;
4657 if (val
& DTF_1_PARINIT
)
4659 printf (" PARINIT");
4660 val
^= DTF_1_PARINIT
;
4662 if (val
& DTF_1_CONFEXP
)
4664 printf (" CONFEXP");
4665 val
^= DTF_1_CONFEXP
;
4668 printf (" %lx", val
);
4677 printf (_("Flags:"));
4679 if (entry
->d_un
.d_val
== 0)
4680 printf (_(" None\n"));
4683 unsigned long int val
= entry
->d_un
.d_val
;
4685 if (val
& DF_P1_LAZYLOAD
)
4687 printf (" LAZYLOAD");
4688 val
^= DF_P1_LAZYLOAD
;
4690 if (val
& DF_P1_GROUPPERM
)
4692 printf (" GROUPPERM");
4693 val
^= DF_P1_GROUPPERM
;
4696 printf (" %lx", val
);
4705 printf (_("Flags:"));
4706 if (entry
->d_un
.d_val
== 0)
4707 printf (_(" None\n"));
4710 unsigned long int val
= entry
->d_un
.d_val
;
4717 if (val
& DF_1_GLOBAL
)
4722 if (val
& DF_1_GROUP
)
4727 if (val
& DF_1_NODELETE
)
4729 printf (" NODELETE");
4730 val
^= DF_1_NODELETE
;
4732 if (val
& DF_1_LOADFLTR
)
4734 printf (" LOADFLTR");
4735 val
^= DF_1_LOADFLTR
;
4737 if (val
& DF_1_INITFIRST
)
4739 printf (" INITFIRST");
4740 val
^= DF_1_INITFIRST
;
4742 if (val
& DF_1_NOOPEN
)
4747 if (val
& DF_1_ORIGIN
)
4752 if (val
& DF_1_DIRECT
)
4757 if (val
& DF_1_TRANS
)
4762 if (val
& DF_1_INTERPOSE
)
4764 printf (" INTERPOSE");
4765 val
^= DF_1_INTERPOSE
;
4767 if (val
& DF_1_NODEFLIB
)
4769 printf (" NODEFLIB");
4770 val
^= DF_1_NODEFLIB
;
4772 if (val
& DF_1_NODUMP
)
4777 if (val
& DF_1_CONLFAT
)
4779 printf (" CONLFAT");
4780 val
^= DF_1_CONLFAT
;
4783 printf (" %lx", val
);
4791 puts (get_dynamic_type (entry
->d_un
.d_val
));
4811 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4817 if (dynamic_strings
== NULL
)
4820 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4824 switch (entry
->d_tag
)
4827 printf (_("Shared library: [%s]"), name
);
4829 if (strcmp (name
, program_interpreter
) == 0)
4830 printf (_(" program interpreter"));
4834 printf (_("Library soname: [%s]"), name
);
4838 printf (_("Library rpath: [%s]"), name
);
4842 printf (_("Library runpath: [%s]"), name
);
4846 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4851 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4867 case DT_INIT_ARRAYSZ
:
4868 case DT_FINI_ARRAYSZ
:
4869 case DT_GNU_CONFLICTSZ
:
4870 case DT_GNU_LIBLISTSZ
:
4873 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4874 printf (" (bytes)\n");
4884 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4897 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4901 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4905 printf (_("Not needed object: [%s]\n"), name
);
4910 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4916 /* The value of this entry is ignored. */
4921 case DT_GNU_PRELINKED
:
4925 time_t time
= entry
->d_un
.d_val
;
4927 tmp
= gmtime (&time
);
4928 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
4929 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4930 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4936 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4937 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4942 switch (elf_header
.e_machine
)
4945 case EM_MIPS_RS3_LE
:
4946 dynamic_segment_mips_val (entry
);
4949 dynamic_segment_parisc_val (entry
);
4952 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4964 get_ver_flags (flags
)
4967 static char buff
[32];
4974 if (flags
& VER_FLG_BASE
)
4975 strcat (buff
, "BASE ");
4977 if (flags
& VER_FLG_WEAK
)
4979 if (flags
& VER_FLG_BASE
)
4980 strcat (buff
, "| ");
4982 strcat (buff
, "WEAK ");
4985 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4986 strcat (buff
, "| <unknown>");
4991 /* Display the contents of the version sections. */
4993 process_version_sections (file
)
4996 Elf32_Internal_Shdr
* section
;
5003 for (i
= 0, section
= section_headers
;
5004 i
< elf_header
.e_shnum
;
5007 switch (section
->sh_type
)
5009 case SHT_GNU_verdef
:
5011 Elf_External_Verdef
* edefs
;
5018 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5019 SECTION_NAME (section
), section
->sh_info
);
5021 printf (_(" Addr: 0x"));
5022 printf_vma (section
->sh_addr
);
5023 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5024 (unsigned long) section
->sh_offset
, section
->sh_link
,
5025 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5027 edefs
= ((Elf_External_Verdef
*)
5028 get_data (NULL
, file
, section
->sh_offset
,
5030 _("version definition section")));
5034 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
5037 Elf_External_Verdef
* edef
;
5038 Elf_Internal_Verdef ent
;
5039 Elf_External_Verdaux
* eaux
;
5040 Elf_Internal_Verdaux aux
;
5044 vstart
= ((char *) edefs
) + idx
;
5046 edef
= (Elf_External_Verdef
*) vstart
;
5048 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5049 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5050 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5051 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5052 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5053 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5054 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5056 printf (_(" %#06x: Rev: %d Flags: %s"),
5057 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5059 printf (_(" Index: %d Cnt: %d "),
5060 ent
.vd_ndx
, ent
.vd_cnt
);
5062 vstart
+= ent
.vd_aux
;
5064 eaux
= (Elf_External_Verdaux
*) vstart
;
5066 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5067 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5069 if (dynamic_strings
)
5070 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5072 printf (_("Name index: %ld\n"), aux
.vda_name
);
5074 isum
= idx
+ ent
.vd_aux
;
5076 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5078 isum
+= aux
.vda_next
;
5079 vstart
+= aux
.vda_next
;
5081 eaux
= (Elf_External_Verdaux
*) vstart
;
5083 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5084 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5086 if (dynamic_strings
)
5087 printf (_(" %#06x: Parent %d: %s\n"),
5088 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5090 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5091 isum
, j
, aux
.vda_name
);
5101 case SHT_GNU_verneed
:
5103 Elf_External_Verneed
* eneed
;
5109 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5110 SECTION_NAME (section
), section
->sh_info
);
5112 printf (_(" Addr: 0x"));
5113 printf_vma (section
->sh_addr
);
5114 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5115 (unsigned long) section
->sh_offset
, section
->sh_link
,
5116 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5118 eneed
= ((Elf_External_Verneed
*)
5119 get_data (NULL
, file
, section
->sh_offset
,
5120 section
->sh_size
, _("version need section")));
5124 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5126 Elf_External_Verneed
* entry
;
5127 Elf_Internal_Verneed ent
;
5132 vstart
= ((char *) eneed
) + idx
;
5134 entry
= (Elf_External_Verneed
*) vstart
;
5136 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5137 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5138 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5139 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5140 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5142 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5144 if (dynamic_strings
)
5145 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5147 printf (_(" File: %lx"), ent
.vn_file
);
5149 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5151 vstart
+= ent
.vn_aux
;
5153 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5155 Elf_External_Vernaux
* eaux
;
5156 Elf_Internal_Vernaux aux
;
5158 eaux
= (Elf_External_Vernaux
*) vstart
;
5160 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5161 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5162 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5163 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5164 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5166 if (dynamic_strings
)
5167 printf (_(" %#06x: Name: %s"),
5168 isum
, dynamic_strings
+ aux
.vna_name
);
5170 printf (_(" %#06x: Name index: %lx"),
5171 isum
, aux
.vna_name
);
5173 printf (_(" Flags: %s Version: %d\n"),
5174 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5176 isum
+= aux
.vna_next
;
5177 vstart
+= aux
.vna_next
;
5187 case SHT_GNU_versym
:
5189 Elf32_Internal_Shdr
* link_section
;
5192 unsigned char * edata
;
5193 unsigned short * data
;
5195 Elf_Internal_Sym
* symbols
;
5196 Elf32_Internal_Shdr
* string_sec
;
5198 link_section
= SECTION_HEADER (section
->sh_link
);
5199 total
= section
->sh_size
/ section
->sh_entsize
;
5203 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5205 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5207 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5208 string_sec
->sh_size
,
5209 _("version string table"));
5213 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5214 SECTION_NAME (section
), total
);
5216 printf (_(" Addr: "));
5217 printf_vma (section
->sh_addr
);
5218 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5219 (unsigned long) section
->sh_offset
, section
->sh_link
,
5220 SECTION_NAME (link_section
));
5224 get_data (NULL
, file
,
5225 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5226 total
* sizeof (short), _("version symbol data")));
5233 data
= (unsigned short *) malloc (total
* sizeof (short));
5235 for (cnt
= total
; cnt
--;)
5236 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5241 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5244 int check_def
, check_need
;
5247 printf (" %03x:", cnt
);
5249 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5250 switch (data
[cnt
+ j
])
5253 fputs (_(" 0 (*local*) "), stdout
);
5257 fputs (_(" 1 (*global*) "), stdout
);
5261 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5262 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5266 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5269 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5276 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5278 Elf_Internal_Verneed ivn
;
5279 unsigned long offset
;
5281 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5286 Elf_Internal_Vernaux ivna
;
5287 Elf_External_Verneed evn
;
5288 Elf_External_Vernaux evna
;
5289 unsigned long a_off
;
5291 get_data (&evn
, file
, offset
, sizeof (evn
),
5294 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5295 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5297 a_off
= offset
+ ivn
.vn_aux
;
5301 get_data (&evna
, file
, a_off
, sizeof (evna
),
5302 _("version need aux (2)"));
5304 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5305 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5307 a_off
+= ivna
.vna_next
;
5309 while (ivna
.vna_other
!= data
[cnt
+ j
]
5310 && ivna
.vna_next
!= 0);
5312 if (ivna
.vna_other
== data
[cnt
+ j
])
5314 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5316 name
= strtab
+ ivna
.vna_name
;
5317 nn
+= printf ("(%s%-*s",
5319 12 - (int) strlen (name
),
5325 offset
+= ivn
.vn_next
;
5327 while (ivn
.vn_next
);
5330 if (check_def
&& data
[cnt
+ j
] != 0x8001
5331 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5333 Elf_Internal_Verdef ivd
;
5334 Elf_External_Verdef evd
;
5335 unsigned long offset
;
5337 offset
= version_info
5338 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
5342 get_data (&evd
, file
, offset
, sizeof (evd
),
5345 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5346 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5348 offset
+= ivd
.vd_next
;
5350 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5351 && ivd
.vd_next
!= 0);
5353 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5355 Elf_External_Verdaux evda
;
5356 Elf_Internal_Verdaux ivda
;
5358 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5360 get_data (&evda
, file
,
5361 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5362 sizeof (evda
), _("version def aux"));
5364 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5366 name
= strtab
+ ivda
.vda_name
;
5367 nn
+= printf ("(%s%-*s",
5369 12 - (int) strlen (name
),
5375 printf ("%*c", 18 - nn
, ' ');
5393 printf (_("\nNo version information found in this file.\n"));
5399 get_symbol_binding (binding
)
5400 unsigned int binding
;
5402 static char buff
[32];
5406 case STB_LOCAL
: return "LOCAL";
5407 case STB_GLOBAL
: return "GLOBAL";
5408 case STB_WEAK
: return "WEAK";
5410 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5411 sprintf (buff
, _("<processor specific>: %d"), binding
);
5412 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5413 sprintf (buff
, _("<OS specific>: %d"), binding
);
5415 sprintf (buff
, _("<unknown>: %d"), binding
);
5421 get_symbol_type (type
)
5424 static char buff
[32];
5428 case STT_NOTYPE
: return "NOTYPE";
5429 case STT_OBJECT
: return "OBJECT";
5430 case STT_FUNC
: return "FUNC";
5431 case STT_SECTION
: return "SECTION";
5432 case STT_FILE
: return "FILE";
5433 case STT_COMMON
: return "COMMON";
5434 case STT_TLS
: return "TLS";
5436 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5438 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5439 return "THUMB_FUNC";
5441 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5444 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5445 return "PARISC_MILLI";
5447 sprintf (buff
, _("<processor specific>: %d"), type
);
5449 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5451 if (elf_header
.e_machine
== EM_PARISC
)
5453 if (type
== STT_HP_OPAQUE
)
5455 if (type
== STT_HP_STUB
)
5459 sprintf (buff
, _("<OS specific>: %d"), type
);
5462 sprintf (buff
, _("<unknown>: %d"), type
);
5468 get_symbol_visibility (visibility
)
5469 unsigned int visibility
;
5473 case STV_DEFAULT
: return "DEFAULT";
5474 case STV_INTERNAL
: return "INTERNAL";
5475 case STV_HIDDEN
: return "HIDDEN";
5476 case STV_PROTECTED
: return "PROTECTED";
5482 get_symbol_index_type (type
)
5487 case SHN_UNDEF
: return "UND";
5488 case SHN_ABS
: return "ABS";
5489 case SHN_COMMON
: return "COM";
5491 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5493 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5495 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5499 static char buff
[32];
5501 sprintf (buff
, "%3d", type
);
5508 get_dynamic_data (file
, number
)
5510 unsigned int number
;
5512 unsigned char * e_data
;
5515 e_data
= (unsigned char *) malloc (number
* 4);
5519 error (_("Out of memory\n"));
5523 if (fread (e_data
, 4, number
, file
) != number
)
5525 error (_("Unable to read in dynamic data\n"));
5529 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5533 error (_("Out of memory\n"));
5539 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5546 /* Dump the symbol table. */
5548 process_symbol_table (file
)
5551 Elf32_Internal_Shdr
* section
;
5552 unsigned char nb
[4];
5553 unsigned char nc
[4];
5556 int * buckets
= NULL
;
5557 int * chains
= NULL
;
5559 if (! do_syms
&& !do_histogram
)
5562 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5565 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5567 error (_("Unable to seek to start of dynamic information"));
5571 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5573 error (_("Failed to read in number of buckets\n"));
5577 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5579 error (_("Failed to read in number of chains\n"));
5583 nbuckets
= byte_get (nb
, 4);
5584 nchains
= byte_get (nc
, 4);
5586 buckets
= get_dynamic_data (file
, nbuckets
);
5587 chains
= get_dynamic_data (file
, nchains
);
5589 if (buckets
== NULL
|| chains
== NULL
)
5594 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5599 printf (_("\nSymbol table for image:\n"));
5601 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5603 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5605 for (hn
= 0; hn
< nbuckets
; hn
++)
5610 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5612 Elf_Internal_Sym
* psym
;
5614 psym
= dynamic_symbols
+ si
;
5616 printf (" %3d %3d: ", si
, hn
);
5617 print_vma (psym
->st_value
, LONG_HEX
);
5619 print_vma (psym
->st_size
, DEC_5
);
5621 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5622 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5623 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5624 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5625 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5630 else if (do_syms
&& !do_using_dynamic
)
5634 for (i
= 0, section
= section_headers
;
5635 i
< elf_header
.e_shnum
;
5640 Elf_Internal_Sym
* symtab
;
5641 Elf_Internal_Sym
* psym
;
5644 if ( section
->sh_type
!= SHT_SYMTAB
5645 && section
->sh_type
!= SHT_DYNSYM
)
5648 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5649 SECTION_NAME (section
),
5650 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5652 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5654 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5656 symtab
= GET_ELF_SYMBOLS (file
, section
);
5660 if (section
->sh_link
== elf_header
.e_shstrndx
)
5661 strtab
= string_table
;
5664 Elf32_Internal_Shdr
* string_sec
;
5666 string_sec
= SECTION_HEADER (section
->sh_link
);
5668 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5669 string_sec
->sh_size
,
5673 for (si
= 0, psym
= symtab
;
5674 si
< section
->sh_size
/ section
->sh_entsize
;
5677 printf ("%6d: ", si
);
5678 print_vma (psym
->st_value
, LONG_HEX
);
5680 print_vma (psym
->st_size
, DEC_5
);
5681 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5682 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5683 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5684 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5685 print_symbol (25, strtab
+ psym
->st_name
);
5687 if (section
->sh_type
== SHT_DYNSYM
&&
5688 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5690 unsigned char data
[2];
5691 unsigned short vers_data
;
5692 unsigned long offset
;
5696 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5699 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5700 sizeof (data
), _("version data"));
5702 vers_data
= byte_get (data
, 2);
5704 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5707 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5709 if ((vers_data
& 0x8000) || vers_data
> 1)
5711 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5712 && (is_nobits
|| ! check_def
))
5714 Elf_External_Verneed evn
;
5715 Elf_Internal_Verneed ivn
;
5716 Elf_Internal_Vernaux ivna
;
5718 /* We must test both. */
5719 offset
= version_info
5720 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5724 unsigned long vna_off
;
5726 get_data (&evn
, file
, offset
, sizeof (evn
),
5729 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5730 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5732 vna_off
= offset
+ ivn
.vn_aux
;
5736 Elf_External_Vernaux evna
;
5738 get_data (&evna
, file
, vna_off
,
5740 _("version need aux (3)"));
5742 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5743 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5744 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5746 vna_off
+= ivna
.vna_next
;
5748 while (ivna
.vna_other
!= vers_data
5749 && ivna
.vna_next
!= 0);
5751 if (ivna
.vna_other
== vers_data
)
5754 offset
+= ivn
.vn_next
;
5756 while (ivn
.vn_next
!= 0);
5758 if (ivna
.vna_other
== vers_data
)
5761 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5764 else if (! is_nobits
)
5765 error (_("bad dynamic symbol"));
5772 if (vers_data
!= 0x8001
5773 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5775 Elf_Internal_Verdef ivd
;
5776 Elf_Internal_Verdaux ivda
;
5777 Elf_External_Verdaux evda
;
5778 unsigned long offset
;
5781 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5786 Elf_External_Verdef evd
;
5788 get_data (&evd
, file
, offset
, sizeof (evd
),
5791 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5792 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5793 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5795 offset
+= ivd
.vd_next
;
5797 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5798 && ivd
.vd_next
!= 0);
5800 offset
-= ivd
.vd_next
;
5801 offset
+= ivd
.vd_aux
;
5803 get_data (&evda
, file
, offset
, sizeof (evda
),
5804 _("version def aux"));
5806 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5808 if (psym
->st_name
!= ivda
.vda_name
)
5809 printf ((vers_data
& 0x8000)
5811 strtab
+ ivda
.vda_name
);
5821 if (strtab
!= string_table
)
5827 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5829 if (do_histogram
&& buckets
!= NULL
)
5836 int nzero_counts
= 0;
5839 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5841 printf (_(" Length Number %% of total Coverage\n"));
5843 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5844 if (lengths
== NULL
)
5846 error (_("Out of memory"));
5849 for (hn
= 0; hn
< nbuckets
; ++hn
)
5854 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5857 if (maxlength
< ++lengths
[hn
])
5862 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5865 error (_("Out of memory"));
5869 for (hn
= 0; hn
< nbuckets
; ++hn
)
5870 ++ counts
[lengths
[hn
]];
5874 printf (" 0 %-10d (%5.1f%%)\n",
5875 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5876 for (si
= 1; si
<= maxlength
; ++si
)
5878 nzero_counts
+= counts
[si
] * si
;
5879 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5880 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5881 (nzero_counts
* 100.0) / nsyms
);
5889 if (buckets
!= NULL
)
5899 process_syminfo (file
)
5900 FILE * file ATTRIBUTE_UNUSED
;
5904 if (dynamic_syminfo
== NULL
5906 /* No syminfo, this is ok. */
5909 /* There better should be a dynamic symbol section. */
5910 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5914 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5915 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5917 printf (_(" Num: Name BoundTo Flags\n"));
5918 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5920 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5922 printf ("%4d: ", i
);
5923 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5926 switch (dynamic_syminfo
[i
].si_boundto
)
5928 case SYMINFO_BT_SELF
:
5929 fputs ("SELF ", stdout
);
5931 case SYMINFO_BT_PARENT
:
5932 fputs ("PARENT ", stdout
);
5935 if (dynamic_syminfo
[i
].si_boundto
> 0
5936 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5938 print_symbol (10, dynamic_strings
5940 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5944 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5948 if (flags
& SYMINFO_FLG_DIRECT
)
5950 if (flags
& SYMINFO_FLG_PASSTHRU
)
5951 printf (" PASSTHRU");
5952 if (flags
& SYMINFO_FLG_COPY
)
5954 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5955 printf (" LAZYLOAD");
5963 #ifdef SUPPORT_DISASSEMBLY
5965 disassemble_section (section
, file
)
5966 Elf32_Internal_Shdr
* section
;
5969 printf (_("\nAssembly dump of section %s\n"),
5970 SECTION_NAME (section
));
5972 /* XXX -- to be done --- XXX */
5979 dump_section (section
, file
)
5980 Elf32_Internal_Shdr
* section
;
5983 bfd_size_type bytes
;
5985 unsigned char * data
;
5986 unsigned char * start
;
5988 bytes
= section
->sh_size
;
5992 printf (_("\nSection '%s' has no data to dump.\n"),
5993 SECTION_NAME (section
));
5997 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5999 addr
= section
->sh_addr
;
6001 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
6014 lbytes
= (bytes
> 16 ? 16 : bytes
);
6016 printf (" 0x%8.8lx ", (unsigned long) addr
);
6018 switch (elf_header
.e_ident
[EI_DATA
])
6022 for (j
= 15; j
>= 0; j
--)
6025 printf ("%2.2x", data
[j
]);
6035 for (j
= 0; j
< 16; j
++)
6038 printf ("%2.2x", data
[j
]);
6048 for (j
= 0; j
< lbytes
; j
++)
6051 if (k
>= ' ' && k
< 0x80)
6070 static unsigned long int
6071 read_leb128 (data
, length_return
, sign
)
6072 unsigned char * data
;
6073 int * length_return
;
6076 unsigned long int result
= 0;
6077 unsigned int num_read
= 0;
6086 result
|= (byte
& 0x7f) << shift
;
6091 while (byte
& 0x80);
6093 if (length_return
!= NULL
)
6094 * length_return
= num_read
;
6096 if (sign
&& (shift
< 32) && (byte
& 0x40))
6097 result
|= -1 << shift
;
6102 typedef struct State_Machine_Registers
6104 unsigned long address
;
6107 unsigned int column
;
6111 /* This variable hold the number of the last entry seen
6112 in the File Table. */
6113 unsigned int last_file_entry
;
6116 static SMR state_machine_regs
;
6119 reset_state_machine (is_stmt
)
6122 state_machine_regs
.address
= 0;
6123 state_machine_regs
.file
= 1;
6124 state_machine_regs
.line
= 1;
6125 state_machine_regs
.column
= 0;
6126 state_machine_regs
.is_stmt
= is_stmt
;
6127 state_machine_regs
.basic_block
= 0;
6128 state_machine_regs
.end_sequence
= 0;
6129 state_machine_regs
.last_file_entry
= 0;
6132 /* Handled an extend line op. Returns true if this is the end
6135 process_extended_line_op (data
, is_stmt
, pointer_size
)
6136 unsigned char * data
;
6140 unsigned char op_code
;
6143 unsigned char * name
;
6146 len
= read_leb128 (data
, & bytes_read
, 0);
6151 warn (_("badly formed extended line op encountered!\n"));
6156 op_code
= * data
++;
6158 printf (_(" Extended opcode %d: "), op_code
);
6162 case DW_LNE_end_sequence
:
6163 printf (_("End of Sequence\n\n"));
6164 reset_state_machine (is_stmt
);
6167 case DW_LNE_set_address
:
6168 adr
= byte_get (data
, pointer_size
);
6169 printf (_("set Address to 0x%lx\n"), adr
);
6170 state_machine_regs
.address
= adr
;
6173 case DW_LNE_define_file
:
6174 printf (_(" define new File Table entry\n"));
6175 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6177 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6179 data
+= strlen ((char *) data
) + 1;
6180 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6182 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6184 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6185 printf (_("%s\n\n"), name
);
6189 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6196 /* Size of pointers in the .debug_line section. This information is not
6197 really present in that section. It's obtained before dumping the debug
6198 sections by doing some pre-scan of the .debug_info section. */
6199 static int debug_line_pointer_size
= 4;
6202 display_debug_lines (section
, start
, file
)
6203 Elf32_Internal_Shdr
* section
;
6204 unsigned char * start
;
6205 FILE * file ATTRIBUTE_UNUSED
;
6207 DWARF2_External_LineInfo
* external
;
6208 DWARF2_Internal_LineInfo info
;
6209 unsigned char * standard_opcodes
;
6210 unsigned char * data
= start
;
6211 unsigned char * end
= start
+ section
->sh_size
;
6212 unsigned char * end_of_sequence
;
6215 printf (_("\nDump of debug contents of section %s:\n\n"),
6216 SECTION_NAME (section
));
6220 external
= (DWARF2_External_LineInfo
*) data
;
6222 /* Check the length of the block. */
6223 info
.li_length
= BYTE_GET (external
->li_length
);
6225 if (info
.li_length
== 0xffffffff)
6227 warn (_("64-bit DWARF line info is not supported yet.\n"));
6231 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6234 (_("The line info appears to be corrupt - the section is too small\n"));
6238 /* Check its version number. */
6239 info
.li_version
= BYTE_GET (external
->li_version
);
6240 if (info
.li_version
!= 2)
6242 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6246 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6247 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6248 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6249 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6250 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6251 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6253 /* Sign extend the line base field. */
6254 info
.li_line_base
<<= 24;
6255 info
.li_line_base
>>= 24;
6257 printf (_(" Length: %ld\n"), info
.li_length
);
6258 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6259 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6260 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6261 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6262 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6263 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6264 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6266 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6268 reset_state_machine (info
.li_default_is_stmt
);
6270 /* Display the contents of the Opcodes table. */
6271 standard_opcodes
= data
+ sizeof (* external
);
6273 printf (_("\n Opcodes:\n"));
6275 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6276 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6278 /* Display the contents of the Directory table. */
6279 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6282 printf (_("\n The Directory Table is empty.\n"));
6285 printf (_("\n The Directory Table:\n"));
6289 printf (_(" %s\n"), data
);
6291 data
+= strlen ((char *) data
) + 1;
6295 /* Skip the NUL at the end of the table. */
6298 /* Display the contents of the File Name table. */
6300 printf (_("\n The File Name Table is empty.\n"));
6303 printf (_("\n The File Name Table:\n"));
6304 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6308 unsigned char * name
;
6311 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6314 data
+= strlen ((char *) data
) + 1;
6316 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6318 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6320 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6322 printf (_("%s\n"), name
);
6326 /* Skip the NUL at the end of the table. */
6329 /* Now display the statements. */
6330 printf (_("\n Line Number Statements:\n"));
6333 while (data
< end_of_sequence
)
6335 unsigned char op_code
;
6339 op_code
= * data
++;
6341 if (op_code
>= info
.li_opcode_base
)
6343 op_code
-= info
.li_opcode_base
;
6344 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6345 state_machine_regs
.address
+= adv
;
6346 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6347 op_code
, adv
, state_machine_regs
.address
);
6348 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6349 state_machine_regs
.line
+= adv
;
6350 printf (_(" and Line by %d to %d\n"),
6351 adv
, state_machine_regs
.line
);
6353 else switch (op_code
)
6355 case DW_LNS_extended_op
:
6356 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6357 debug_line_pointer_size
);
6361 printf (_(" Copy\n"));
6364 case DW_LNS_advance_pc
:
6365 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6367 state_machine_regs
.address
+= adv
;
6368 printf (_(" Advance PC by %d to %lx\n"), adv
,
6369 state_machine_regs
.address
);
6372 case DW_LNS_advance_line
:
6373 adv
= read_leb128 (data
, & bytes_read
, 1);
6375 state_machine_regs
.line
+= adv
;
6376 printf (_(" Advance Line by %d to %d\n"), adv
,
6377 state_machine_regs
.line
);
6380 case DW_LNS_set_file
:
6381 adv
= read_leb128 (data
, & bytes_read
, 0);
6383 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6385 state_machine_regs
.file
= adv
;
6388 case DW_LNS_set_column
:
6389 adv
= read_leb128 (data
, & bytes_read
, 0);
6391 printf (_(" Set column to %d\n"), adv
);
6392 state_machine_regs
.column
= adv
;
6395 case DW_LNS_negate_stmt
:
6396 adv
= state_machine_regs
.is_stmt
;
6398 printf (_(" Set is_stmt to %d\n"), adv
);
6399 state_machine_regs
.is_stmt
= adv
;
6402 case DW_LNS_set_basic_block
:
6403 printf (_(" Set basic block\n"));
6404 state_machine_regs
.basic_block
= 1;
6407 case DW_LNS_const_add_pc
:
6408 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6409 * info
.li_min_insn_length
);
6410 state_machine_regs
.address
+= adv
;
6411 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6412 state_machine_regs
.address
);
6415 case DW_LNS_fixed_advance_pc
:
6416 adv
= byte_get (data
, 2);
6418 state_machine_regs
.address
+= adv
;
6419 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6420 adv
, state_machine_regs
.address
);
6423 case DW_LNS_set_prologue_end
:
6424 printf (_(" Set prologue_end to true\n"));
6427 case DW_LNS_set_epilogue_begin
:
6428 printf (_(" Set epilogue_begin to true\n"));
6431 case DW_LNS_set_isa
:
6432 adv
= read_leb128 (data
, & bytes_read
, 0);
6434 printf (_(" Set ISA to %d\n"), adv
);
6438 printf (_(" Unknown opcode %d with operands: "), op_code
);
6441 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6443 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6444 i
== 1 ? "" : ", ");
6459 display_debug_pubnames (section
, start
, file
)
6460 Elf32_Internal_Shdr
* section
;
6461 unsigned char * start
;
6462 FILE * file ATTRIBUTE_UNUSED
;
6464 DWARF2_External_PubNames
* external
;
6465 DWARF2_Internal_PubNames pubnames
;
6466 unsigned char * end
;
6468 end
= start
+ section
->sh_size
;
6470 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6474 unsigned char * data
;
6475 unsigned long offset
;
6477 external
= (DWARF2_External_PubNames
*) start
;
6479 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6480 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6481 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6482 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6484 data
= start
+ sizeof (* external
);
6485 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6487 if (pubnames
.pn_length
== 0xffffffff)
6489 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6493 if (pubnames
.pn_version
!= 2)
6495 static int warned
= 0;
6499 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6506 printf (_(" Length: %ld\n"),
6507 pubnames
.pn_length
);
6508 printf (_(" Version: %d\n"),
6509 pubnames
.pn_version
);
6510 printf (_(" Offset into .debug_info section: %ld\n"),
6511 pubnames
.pn_offset
);
6512 printf (_(" Size of area in .debug_info section: %ld\n"),
6515 printf (_("\n Offset\tName\n"));
6519 offset
= byte_get (data
, 4);
6524 printf (" %ld\t\t%s\n", offset
, data
);
6525 data
+= strlen ((char *) data
) + 1;
6528 while (offset
!= 0);
6541 case DW_TAG_padding
: return "DW_TAG_padding";
6542 case DW_TAG_array_type
: return "DW_TAG_array_type";
6543 case DW_TAG_class_type
: return "DW_TAG_class_type";
6544 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6545 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6546 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6547 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6548 case DW_TAG_label
: return "DW_TAG_label";
6549 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6550 case DW_TAG_member
: return "DW_TAG_member";
6551 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6552 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6553 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6554 case DW_TAG_string_type
: return "DW_TAG_string_type";
6555 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6556 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6557 case DW_TAG_typedef
: return "DW_TAG_typedef";
6558 case DW_TAG_union_type
: return "DW_TAG_union_type";
6559 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6560 case DW_TAG_variant
: return "DW_TAG_variant";
6561 case DW_TAG_common_block
: return "DW_TAG_common_block";
6562 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6563 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6564 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6565 case DW_TAG_module
: return "DW_TAG_module";
6566 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6567 case DW_TAG_set_type
: return "DW_TAG_set_type";
6568 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6569 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6570 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6571 case DW_TAG_base_type
: return "DW_TAG_base_type";
6572 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6573 case DW_TAG_const_type
: return "DW_TAG_const_type";
6574 case DW_TAG_constant
: return "DW_TAG_constant";
6575 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6576 case DW_TAG_file_type
: return "DW_TAG_file_type";
6577 case DW_TAG_friend
: return "DW_TAG_friend";
6578 case DW_TAG_namelist
: return "DW_TAG_namelist";
6579 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6580 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6581 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6582 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6583 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6584 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6585 case DW_TAG_try_block
: return "DW_TAG_try_block";
6586 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6587 case DW_TAG_variable
: return "DW_TAG_variable";
6588 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6589 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6590 case DW_TAG_format_label
: return "DW_TAG_format_label";
6591 case DW_TAG_function_template
: return "DW_TAG_function_template";
6592 case DW_TAG_class_template
: return "DW_TAG_class_template";
6593 /* DWARF 2.1 values. */
6594 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6595 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6596 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6597 case DW_TAG_namespace
: return "DW_TAG_namespace";
6598 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6599 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6600 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6601 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6604 static char buffer
[100];
6606 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6613 get_AT_name (attribute
)
6614 unsigned long attribute
;
6618 case DW_AT_sibling
: return "DW_AT_sibling";
6619 case DW_AT_location
: return "DW_AT_location";
6620 case DW_AT_name
: return "DW_AT_name";
6621 case DW_AT_ordering
: return "DW_AT_ordering";
6622 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6623 case DW_AT_byte_size
: return "DW_AT_byte_size";
6624 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6625 case DW_AT_bit_size
: return "DW_AT_bit_size";
6626 case DW_AT_element_list
: return "DW_AT_element_list";
6627 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6628 case DW_AT_low_pc
: return "DW_AT_low_pc";
6629 case DW_AT_high_pc
: return "DW_AT_high_pc";
6630 case DW_AT_language
: return "DW_AT_language";
6631 case DW_AT_member
: return "DW_AT_member";
6632 case DW_AT_discr
: return "DW_AT_discr";
6633 case DW_AT_discr_value
: return "DW_AT_discr_value";
6634 case DW_AT_visibility
: return "DW_AT_visibility";
6635 case DW_AT_import
: return "DW_AT_import";
6636 case DW_AT_string_length
: return "DW_AT_string_length";
6637 case DW_AT_common_reference
: return "DW_AT_common_reference";
6638 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6639 case DW_AT_const_value
: return "DW_AT_const_value";
6640 case DW_AT_containing_type
: return "DW_AT_containing_type";
6641 case DW_AT_default_value
: return "DW_AT_default_value";
6642 case DW_AT_inline
: return "DW_AT_inline";
6643 case DW_AT_is_optional
: return "DW_AT_is_optional";
6644 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6645 case DW_AT_producer
: return "DW_AT_producer";
6646 case DW_AT_prototyped
: return "DW_AT_prototyped";
6647 case DW_AT_return_addr
: return "DW_AT_return_addr";
6648 case DW_AT_start_scope
: return "DW_AT_start_scope";
6649 case DW_AT_stride_size
: return "DW_AT_stride_size";
6650 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6651 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6652 case DW_AT_accessibility
: return "DW_AT_accessibility";
6653 case DW_AT_address_class
: return "DW_AT_address_class";
6654 case DW_AT_artificial
: return "DW_AT_artificial";
6655 case DW_AT_base_types
: return "DW_AT_base_types";
6656 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6657 case DW_AT_count
: return "DW_AT_count";
6658 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6659 case DW_AT_decl_column
: return "DW_AT_decl_column";
6660 case DW_AT_decl_file
: return "DW_AT_decl_file";
6661 case DW_AT_decl_line
: return "DW_AT_decl_line";
6662 case DW_AT_declaration
: return "DW_AT_declaration";
6663 case DW_AT_discr_list
: return "DW_AT_discr_list";
6664 case DW_AT_encoding
: return "DW_AT_encoding";
6665 case DW_AT_external
: return "DW_AT_external";
6666 case DW_AT_frame_base
: return "DW_AT_frame_base";
6667 case DW_AT_friend
: return "DW_AT_friend";
6668 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6669 case DW_AT_macro_info
: return "DW_AT_macro_info";
6670 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6671 case DW_AT_priority
: return "DW_AT_priority";
6672 case DW_AT_segment
: return "DW_AT_segment";
6673 case DW_AT_specification
: return "DW_AT_specification";
6674 case DW_AT_static_link
: return "DW_AT_static_link";
6675 case DW_AT_type
: return "DW_AT_type";
6676 case DW_AT_use_location
: return "DW_AT_use_location";
6677 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6678 case DW_AT_virtuality
: return "DW_AT_virtuality";
6679 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6680 /* DWARF 2.1 values. */
6681 case DW_AT_allocated
: return "DW_AT_allocated";
6682 case DW_AT_associated
: return "DW_AT_associated";
6683 case DW_AT_data_location
: return "DW_AT_data_location";
6684 case DW_AT_stride
: return "DW_AT_stride";
6685 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6686 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6687 case DW_AT_extension
: return "DW_AT_extension";
6688 case DW_AT_ranges
: return "DW_AT_ranges";
6689 case DW_AT_trampoline
: return "DW_AT_trampoline";
6690 case DW_AT_call_column
: return "DW_AT_call_column";
6691 case DW_AT_call_file
: return "DW_AT_call_file";
6692 case DW_AT_call_line
: return "DW_AT_call_line";
6693 /* SGI/MIPS extensions. */
6694 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6695 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6696 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6697 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6698 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6699 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6700 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6701 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6702 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6703 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6704 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6705 /* GNU extensions. */
6706 case DW_AT_sf_names
: return "DW_AT_sf_names";
6707 case DW_AT_src_info
: return "DW_AT_src_info";
6708 case DW_AT_mac_info
: return "DW_AT_mac_info";
6709 case DW_AT_src_coords
: return "DW_AT_src_coords";
6710 case DW_AT_body_begin
: return "DW_AT_body_begin";
6711 case DW_AT_body_end
: return "DW_AT_body_end";
6712 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6715 static char buffer
[100];
6717 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6724 get_FORM_name (form
)
6729 case DW_FORM_addr
: return "DW_FORM_addr";
6730 case DW_FORM_block2
: return "DW_FORM_block2";
6731 case DW_FORM_block4
: return "DW_FORM_block4";
6732 case DW_FORM_data2
: return "DW_FORM_data2";
6733 case DW_FORM_data4
: return "DW_FORM_data4";
6734 case DW_FORM_data8
: return "DW_FORM_data8";
6735 case DW_FORM_string
: return "DW_FORM_string";
6736 case DW_FORM_block
: return "DW_FORM_block";
6737 case DW_FORM_block1
: return "DW_FORM_block1";
6738 case DW_FORM_data1
: return "DW_FORM_data1";
6739 case DW_FORM_flag
: return "DW_FORM_flag";
6740 case DW_FORM_sdata
: return "DW_FORM_sdata";
6741 case DW_FORM_strp
: return "DW_FORM_strp";
6742 case DW_FORM_udata
: return "DW_FORM_udata";
6743 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6744 case DW_FORM_ref1
: return "DW_FORM_ref1";
6745 case DW_FORM_ref2
: return "DW_FORM_ref2";
6746 case DW_FORM_ref4
: return "DW_FORM_ref4";
6747 case DW_FORM_ref8
: return "DW_FORM_ref8";
6748 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6749 case DW_FORM_indirect
: return "DW_FORM_indirect";
6752 static char buffer
[100];
6754 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6760 /* FIXME: There are better and more effiecint ways to handle
6761 these structures. For now though, I just want something that
6762 is simple to implement. */
6763 typedef struct abbrev_attr
6765 unsigned long attribute
;
6767 struct abbrev_attr
* next
;
6771 typedef struct abbrev_entry
6773 unsigned long entry
;
6776 struct abbrev_attr
* first_attr
;
6777 struct abbrev_attr
* last_attr
;
6778 struct abbrev_entry
* next
;
6782 static abbrev_entry
* first_abbrev
= NULL
;
6783 static abbrev_entry
* last_abbrev
= NULL
;
6786 free_abbrevs
PARAMS ((void))
6788 abbrev_entry
* abbrev
;
6790 for (abbrev
= first_abbrev
; abbrev
;)
6792 abbrev_entry
* next
= abbrev
->next
;
6795 for (attr
= abbrev
->first_attr
; attr
;)
6797 abbrev_attr
* next
= attr
->next
;
6807 last_abbrev
= first_abbrev
= NULL
;
6811 add_abbrev (number
, tag
, children
)
6812 unsigned long number
;
6816 abbrev_entry
* entry
;
6818 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6824 entry
->entry
= number
;
6826 entry
->children
= children
;
6827 entry
->first_attr
= NULL
;
6828 entry
->last_attr
= NULL
;
6831 if (first_abbrev
== NULL
)
6832 first_abbrev
= entry
;
6834 last_abbrev
->next
= entry
;
6836 last_abbrev
= entry
;
6840 add_abbrev_attr (attribute
, form
)
6841 unsigned long attribute
;
6846 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6852 attr
->attribute
= attribute
;
6856 if (last_abbrev
->first_attr
== NULL
)
6857 last_abbrev
->first_attr
= attr
;
6859 last_abbrev
->last_attr
->next
= attr
;
6861 last_abbrev
->last_attr
= attr
;
6864 /* Processes the (partial) contents of a .debug_abbrev section.
6865 Returns NULL if the end of the section was encountered.
6866 Returns the address after the last byte read if the end of
6867 an abbreviation set was found. */
6869 static unsigned char *
6870 process_abbrev_section (start
, end
)
6871 unsigned char * start
;
6872 unsigned char * end
;
6874 if (first_abbrev
!= NULL
)
6880 unsigned long entry
;
6882 unsigned long attribute
;
6885 entry
= read_leb128 (start
, & bytes_read
, 0);
6886 start
+= bytes_read
;
6888 /* A single zero is supposed to end the section according
6889 to the standard. If there's more, then signal that to
6892 return start
== end
? NULL
: start
;
6894 tag
= read_leb128 (start
, & bytes_read
, 0);
6895 start
+= bytes_read
;
6897 children
= * start
++;
6899 add_abbrev (entry
, tag
, children
);
6905 attribute
= read_leb128 (start
, & bytes_read
, 0);
6906 start
+= bytes_read
;
6908 form
= read_leb128 (start
, & bytes_read
, 0);
6909 start
+= bytes_read
;
6912 add_abbrev_attr (attribute
, form
);
6914 while (attribute
!= 0);
6922 display_debug_macinfo (section
, start
, file
)
6923 Elf32_Internal_Shdr
* section
;
6924 unsigned char * start
;
6925 FILE * file ATTRIBUTE_UNUSED
;
6927 unsigned char * end
= start
+ section
->sh_size
;
6928 unsigned char * curr
= start
;
6929 unsigned int bytes_read
;
6930 enum dwarf_macinfo_record_type op
;
6932 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6936 unsigned int lineno
;
6937 const char * string
;
6944 case DW_MACINFO_start_file
:
6946 unsigned int filenum
;
6948 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6950 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6953 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6957 case DW_MACINFO_end_file
:
6958 printf (_(" DW_MACINFO_end_file\n"));
6961 case DW_MACINFO_define
:
6962 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6965 curr
+= strlen (string
) + 1;
6966 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6969 case DW_MACINFO_undef
:
6970 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6973 curr
+= strlen (string
) + 1;
6974 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
6977 case DW_MACINFO_vendor_ext
:
6979 unsigned int constant
;
6981 constant
= read_leb128 (curr
, & bytes_read
, 0);
6984 curr
+= strlen (string
) + 1;
6985 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
6996 display_debug_abbrev (section
, start
, file
)
6997 Elf32_Internal_Shdr
* section
;
6998 unsigned char * start
;
6999 FILE * file ATTRIBUTE_UNUSED
;
7001 abbrev_entry
* entry
;
7002 unsigned char * end
= start
+ section
->sh_size
;
7004 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7008 start
= process_abbrev_section (start
, end
);
7010 if (first_abbrev
== NULL
)
7013 printf (_(" Number TAG\n"));
7015 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7019 printf (_(" %ld %s [%s]\n"),
7021 get_TAG_name (entry
->tag
),
7022 entry
->children
? _("has children") : _("no children"));
7024 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7026 printf (_(" %-18s %s\n"),
7027 get_AT_name (attr
->attribute
),
7028 get_FORM_name (attr
->form
));
7042 static unsigned char *
7043 display_block (data
, length
)
7044 unsigned char * data
;
7045 unsigned long length
;
7047 printf (_(" %lu byte block: "), length
);
7050 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7056 decode_location_expression (data
, pointer_size
, length
)
7057 unsigned char * data
;
7058 unsigned int pointer_size
;
7059 unsigned long length
;
7063 unsigned long uvalue
;
7064 unsigned char * end
= data
+ length
;
7073 printf ("DW_OP_addr: %lx",
7074 (unsigned long) byte_get (data
, pointer_size
));
7075 data
+= pointer_size
;
7078 printf ("DW_OP_deref");
7081 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7084 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7087 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7091 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7095 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7099 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7103 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7104 (unsigned long) byte_get (data
+ 4, 4));
7108 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7109 (long) byte_get (data
+ 4, 4));
7113 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7117 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7121 printf ("DW_OP_dup");
7124 printf ("DW_OP_drop");
7127 printf ("DW_OP_over");
7130 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7133 printf ("DW_OP_swap");
7136 printf ("DW_OP_rot");
7139 printf ("DW_OP_xderef");
7142 printf ("DW_OP_abs");
7145 printf ("DW_OP_and");
7148 printf ("DW_OP_div");
7151 printf ("DW_OP_minus");
7154 printf ("DW_OP_mod");
7157 printf ("DW_OP_mul");
7160 printf ("DW_OP_neg");
7163 printf ("DW_OP_not");
7166 printf ("DW_OP_or");
7169 printf ("DW_OP_plus");
7171 case DW_OP_plus_uconst
:
7172 printf ("DW_OP_plus_uconst: %lu",
7173 read_leb128 (data
, &bytes_read
, 0));
7177 printf ("DW_OP_shl");
7180 printf ("DW_OP_shr");
7183 printf ("DW_OP_shra");
7186 printf ("DW_OP_xor");
7189 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7193 printf ("DW_OP_eq");
7196 printf ("DW_OP_ge");
7199 printf ("DW_OP_gt");
7202 printf ("DW_OP_le");
7205 printf ("DW_OP_lt");
7208 printf ("DW_OP_ne");
7211 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7247 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7282 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7317 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7318 read_leb128 (data
, &bytes_read
, 1));
7323 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7327 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7331 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7333 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7334 read_leb128 (data
, &bytes_read
, 1));
7338 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7341 case DW_OP_deref_size
:
7342 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7344 case DW_OP_xderef_size
:
7345 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7348 printf ("DW_OP_nop");
7351 /* DWARF 3 extensions. */
7352 case DW_OP_push_object_address
:
7353 printf ("DW_OP_push_object_address");
7356 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7360 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7363 case DW_OP_call_ref
:
7364 printf ("DW_OP_call_ref");
7367 /* GNU extensions. */
7368 case DW_OP_GNU_push_tls_address
:
7369 printf ("DW_OP_GNU_push_tls_address");
7373 if (op
>= DW_OP_lo_user
7374 && op
<= DW_OP_hi_user
)
7375 printf (_("(User defined location op)"));
7377 printf (_("(Unknown location op)"));
7378 /* No way to tell where the next op is, so just bail. */
7382 /* Separate the ops. */
7387 static const char * debug_loc_contents
;
7388 static bfd_vma debug_loc_size
;
7391 load_debug_loc (file
)
7394 Elf32_Internal_Shdr
* sec
;
7397 /* If it is already loaded, do nothing. */
7398 if (debug_loc_contents
!= NULL
)
7401 /* Locate the .debug_loc section. */
7402 for (i
= 0, sec
= section_headers
;
7403 i
< elf_header
.e_shnum
;
7405 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7408 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7411 debug_loc_size
= sec
->sh_size
;
7413 debug_loc_contents
= ((char *)
7414 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7415 _("debug_loc section data")));
7421 if (debug_loc_contents
== NULL
)
7424 free ((char *) debug_loc_contents
);
7425 debug_loc_contents
= NULL
;
7431 display_debug_loc (section
, start
, file
)
7432 Elf32_Internal_Shdr
* section
;
7433 unsigned char * start
;
7434 FILE * file ATTRIBUTE_UNUSED
;
7436 unsigned char *section_end
;
7437 unsigned long bytes
;
7438 unsigned char *section_begin
= start
;
7441 addr
= section
->sh_addr
;
7442 bytes
= section
->sh_size
;
7443 section_end
= start
+ bytes
;
7447 printf (_("\nThe .debug_loc section is empty.\n"));
7451 printf (_("Contents of the .debug_loc section:\n\n"));
7452 printf (_("\n Offset Begin End Expression\n"));
7454 while (start
< section_end
)
7456 unsigned long begin
;
7458 unsigned short length
;
7459 unsigned long offset
;
7461 offset
= start
- section_begin
;
7465 /* Normally, the lists in the debug_loc section are related to a
7466 given compilation unit, and thus, we would use the
7467 pointer size of that compilation unit. However, since we are
7468 displaying it seperately here, we either have to store
7469 pointer sizes of all compilation units, or assume they don't
7470 change. We assume, like the debug_line display, that
7471 it doesn't change. */
7472 begin
= byte_get (start
, debug_line_pointer_size
);
7473 start
+= debug_line_pointer_size
;
7474 end
= byte_get (start
, debug_line_pointer_size
);
7475 start
+= debug_line_pointer_size
;
7477 if (begin
== 0 && end
== 0)
7483 length
= byte_get (start
, 2);
7486 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7487 decode_location_expression (start
, debug_line_pointer_size
, length
);
7497 static const char * debug_str_contents
;
7498 static bfd_vma debug_str_size
;
7501 load_debug_str (file
)
7504 Elf32_Internal_Shdr
* sec
;
7507 /* If it is already loaded, do nothing. */
7508 if (debug_str_contents
!= NULL
)
7511 /* Locate the .debug_str section. */
7512 for (i
= 0, sec
= section_headers
;
7513 i
< elf_header
.e_shnum
;
7515 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7518 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7521 debug_str_size
= sec
->sh_size
;
7523 debug_str_contents
= ((char *)
7524 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7525 _("debug_str section data")));
7531 if (debug_str_contents
== NULL
)
7534 free ((char *) debug_str_contents
);
7535 debug_str_contents
= NULL
;
7540 fetch_indirect_string (offset
)
7541 unsigned long offset
;
7543 if (debug_str_contents
== NULL
)
7544 return _("<no .debug_str section>");
7546 if (offset
> debug_str_size
)
7547 return _("<offset is too big>");
7549 return debug_str_contents
+ offset
;
7553 display_debug_str (section
, start
, file
)
7554 Elf32_Internal_Shdr
* section
;
7555 unsigned char * start
;
7556 FILE * file ATTRIBUTE_UNUSED
;
7558 unsigned long bytes
;
7561 addr
= section
->sh_addr
;
7562 bytes
= section
->sh_size
;
7566 printf (_("\nThe .debug_str section is empty.\n"));
7570 printf (_("Contents of the .debug_str section:\n\n"));
7578 lbytes
= (bytes
> 16 ? 16 : bytes
);
7580 printf (" 0x%8.8lx ", (unsigned long) addr
);
7582 for (j
= 0; j
< 16; j
++)
7585 printf ("%2.2x", start
[j
]);
7593 for (j
= 0; j
< lbytes
; j
++)
7596 if (k
>= ' ' && k
< 0x80)
7612 static unsigned char *
7613 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7614 unsigned long attribute
;
7616 unsigned char * data
;
7617 unsigned long cu_offset
;
7618 unsigned long pointer_size
;
7620 unsigned long uvalue
= 0;
7621 unsigned char * block_start
= NULL
;
7629 case DW_FORM_ref_addr
:
7631 uvalue
= byte_get (data
, pointer_size
);
7632 data
+= pointer_size
;
7636 uvalue
= byte_get (data
, /* offset_size */ 4);
7637 data
+= /* offset_size */ 4;
7643 uvalue
= byte_get (data
++, 1);
7648 uvalue
= byte_get (data
, 2);
7654 uvalue
= byte_get (data
, 4);
7659 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7663 case DW_FORM_ref_udata
:
7665 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7669 case DW_FORM_indirect
:
7670 form
= read_leb128 (data
, & bytes_read
, 0);
7672 printf (" %s", get_FORM_name (form
));
7673 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7679 case DW_FORM_ref_addr
:
7680 printf (" <#%lx>", uvalue
);
7686 case DW_FORM_ref_udata
:
7687 printf (" <%lx>", uvalue
+ cu_offset
);
7691 printf (" %#lx", uvalue
);
7699 printf (" %ld", uvalue
);
7704 uvalue
= byte_get (data
, 4);
7705 printf (" %lx", uvalue
);
7706 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7710 case DW_FORM_string
:
7711 printf (" %s", data
);
7712 data
+= strlen ((char *) data
) + 1;
7716 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7717 block_start
= data
+ bytes_read
;
7718 data
= display_block (block_start
, uvalue
);
7721 case DW_FORM_block1
:
7722 uvalue
= byte_get (data
, 1);
7723 block_start
= data
+ 1;
7724 data
= display_block (block_start
, uvalue
);
7727 case DW_FORM_block2
:
7728 uvalue
= byte_get (data
, 2);
7729 block_start
= data
+ 2;
7730 data
= display_block (block_start
, uvalue
);
7733 case DW_FORM_block4
:
7734 uvalue
= byte_get (data
, 4);
7735 block_start
= data
+ 4;
7736 data
= display_block (block_start
, uvalue
);
7740 printf (_(" (indirect string, offset: 0x%lx): "), uvalue
);
7741 printf (fetch_indirect_string (uvalue
));
7744 case DW_FORM_indirect
:
7745 /* Handled above. */
7749 warn (_("Unrecognized form: %d\n"), form
);
7753 /* For some attributes we can display futher information. */
7762 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7763 case DW_INL_inlined
: printf (_("(inlined)")); break;
7764 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7765 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7766 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7770 case DW_AT_language
:
7773 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7774 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7775 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7776 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7777 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7778 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7779 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7780 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7781 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7782 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7783 /* DWARF 2.1 values. */
7784 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7785 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7786 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7787 /* MIPS extension. */
7788 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7789 default: printf ("(Unknown: %lx)", uvalue
); break;
7793 case DW_AT_encoding
:
7796 case DW_ATE_void
: printf ("(void)"); break;
7797 case DW_ATE_address
: printf ("(machine address)"); break;
7798 case DW_ATE_boolean
: printf ("(boolean)"); break;
7799 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7800 case DW_ATE_float
: printf ("(float)"); break;
7801 case DW_ATE_signed
: printf ("(signed)"); break;
7802 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7803 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7804 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7805 /* DWARF 2.1 value. */
7806 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7808 if (uvalue
>= DW_ATE_lo_user
7809 && uvalue
<= DW_ATE_hi_user
)
7810 printf ("(user defined type)");
7812 printf ("(unknown type)");
7817 case DW_AT_accessibility
:
7820 case DW_ACCESS_public
: printf ("(public)"); break;
7821 case DW_ACCESS_protected
: printf ("(protected)"); break;
7822 case DW_ACCESS_private
: printf ("(private)"); break;
7823 default: printf ("(unknown accessibility)"); break;
7827 case DW_AT_visibility
:
7830 case DW_VIS_local
: printf ("(local)"); break;
7831 case DW_VIS_exported
: printf ("(exported)"); break;
7832 case DW_VIS_qualified
: printf ("(qualified)"); break;
7833 default: printf ("(unknown visibility)"); break;
7837 case DW_AT_virtuality
:
7840 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7841 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7842 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7843 default: printf ("(unknown virtuality)"); break;
7847 case DW_AT_identifier_case
:
7850 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7851 case DW_ID_up_case
: printf ("(up_case)"); break;
7852 case DW_ID_down_case
: printf ("(down_case)"); break;
7853 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7854 default: printf ("(unknown case)"); break;
7858 case DW_AT_calling_convention
:
7861 case DW_CC_normal
: printf ("(normal)"); break;
7862 case DW_CC_program
: printf ("(program)"); break;
7863 case DW_CC_nocall
: printf ("(nocall)"); break;
7865 if (uvalue
>= DW_CC_lo_user
7866 && uvalue
<= DW_CC_hi_user
)
7867 printf ("(user defined)");
7869 printf ("(unknown convention)");
7873 case DW_AT_ordering
:
7876 case -1: printf ("(undefined)"); break;
7877 case 0: printf ("(row major)"); break;
7878 case 1: printf ("(column major)"); break;
7882 case DW_AT_frame_base
:
7883 case DW_AT_location
:
7884 case DW_AT_data_member_location
:
7885 case DW_AT_vtable_elem_location
:
7886 case DW_AT_allocated
:
7887 case DW_AT_associated
:
7888 case DW_AT_data_location
:
7890 case DW_AT_upper_bound
:
7891 case DW_AT_lower_bound
:
7895 decode_location_expression (block_start
, pointer_size
, uvalue
);
7898 else if (form
== DW_FORM_data4
)
7901 printf ("location list");
7913 static unsigned char *
7914 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7915 unsigned long attribute
;
7917 unsigned char * data
;
7918 unsigned long cu_offset
;
7919 unsigned long pointer_size
;
7921 printf (" %-18s:", get_AT_name (attribute
));
7922 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7929 display_debug_info (section
, start
, file
)
7930 Elf32_Internal_Shdr
* section
;
7931 unsigned char * start
;
7934 unsigned char * end
= start
+ section
->sh_size
;
7935 unsigned char * section_begin
= start
;
7937 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7939 load_debug_str (file
);
7940 load_debug_loc (file
);
7944 DWARF2_External_CompUnit
* external
;
7945 DWARF2_Internal_CompUnit compunit
;
7946 Elf32_Internal_Shdr
* relsec
;
7947 unsigned char * tags
;
7950 unsigned long cu_offset
;
7952 external
= (DWARF2_External_CompUnit
*) start
;
7954 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7955 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7956 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7957 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7959 if (compunit
.cu_length
== 0xffffffff)
7961 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7965 /* Check for RELA relocations in the
7966 abbrev_offset address, and apply them. */
7967 for (relsec
= section_headers
;
7968 relsec
< section_headers
+ elf_header
.e_shnum
;
7971 unsigned long nrelas
;
7972 Elf_Internal_Rela
*rela
, *rp
;
7973 Elf32_Internal_Shdr
*symsec
;
7974 Elf_Internal_Sym
*symtab
;
7975 Elf_Internal_Sym
*sym
;
7977 if (relsec
->sh_type
!= SHT_RELA
7978 || SECTION_HEADER (relsec
->sh_info
) != section
)
7981 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7985 symsec
= SECTION_HEADER (relsec
->sh_link
);
7986 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7988 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7991 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
7997 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7999 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8001 warn (_("Skipping unexpected symbol type %u\n"),
8002 ELF32_ST_TYPE (sym
->st_info
));
8008 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8010 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8012 warn (_("Skipping unexpected symbol type %u\n"),
8013 ELF64_ST_TYPE (sym
->st_info
));
8018 compunit
.cu_abbrev_offset
+= rp
->r_addend
;
8026 tags
= start
+ sizeof (* external
);
8027 cu_offset
= start
- section_begin
;
8028 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
8030 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8031 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8032 printf (_(" Version: %d\n"), compunit
.cu_version
);
8033 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8034 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8036 if (compunit
.cu_version
!= 2)
8038 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8044 /* Read in the abbrevs used by this compilation unit. */
8046 Elf32_Internal_Shdr
* sec
;
8047 unsigned char * begin
;
8049 /* Locate the .debug_abbrev section and process it. */
8050 for (i
= 0, sec
= section_headers
;
8051 i
< elf_header
.e_shnum
;
8053 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
8056 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
8058 warn (_("Unable to locate .debug_abbrev section!\n"));
8062 begin
= ((unsigned char *)
8063 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8064 _("debug_abbrev section data")));
8068 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8069 begin
+ sec
->sh_size
);
8075 while (tags
< start
)
8078 unsigned long abbrev_number
;
8079 abbrev_entry
* entry
;
8082 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8085 /* A null DIE marks the end of a list of children. */
8086 if (abbrev_number
== 0)
8092 /* Scan through the abbreviation list until we reach the
8094 for (entry
= first_abbrev
;
8095 entry
&& entry
->entry
!= abbrev_number
;
8096 entry
= entry
->next
)
8101 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8106 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8108 (unsigned long) (tags
- section_begin
- bytes_read
),
8110 get_TAG_name (entry
->tag
));
8112 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8113 tags
= read_and_display_attr (attr
->attribute
,
8116 compunit
.cu_pointer_size
);
8118 if (entry
->children
)
8132 display_debug_aranges (section
, start
, file
)
8133 Elf32_Internal_Shdr
* section
;
8134 unsigned char * start
;
8135 FILE * file ATTRIBUTE_UNUSED
;
8137 unsigned char * end
= start
+ section
->sh_size
;
8139 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8143 DWARF2_External_ARange
* external
;
8144 DWARF2_Internal_ARange arange
;
8145 unsigned char * ranges
;
8146 unsigned long length
;
8147 unsigned long address
;
8150 external
= (DWARF2_External_ARange
*) start
;
8152 arange
.ar_length
= BYTE_GET (external
->ar_length
);
8153 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8154 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8155 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8156 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8158 if (arange
.ar_length
== 0xffffffff)
8160 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8164 if (arange
.ar_version
!= 2)
8166 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8170 printf (_(" Length: %ld\n"), arange
.ar_length
);
8171 printf (_(" Version: %d\n"), arange
.ar_version
);
8172 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8173 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8174 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8176 printf (_("\n Address Length\n"));
8178 ranges
= start
+ sizeof (* external
);
8180 /* Must pad to an alignment boundary that is twice the pointer size. */
8181 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
8183 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8187 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8189 ranges
+= arange
.ar_pointer_size
;
8191 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8193 ranges
+= arange
.ar_pointer_size
;
8195 /* A pair of zeros marks the end of the list. */
8196 if (address
== 0 && length
== 0)
8199 printf (" %8.8lx %lu\n", address
, length
);
8202 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8210 typedef struct Frame_Chunk
8212 struct Frame_Chunk
* next
;
8213 unsigned char * chunk_start
;
8215 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8216 short int * col_type
;
8218 char * augmentation
;
8219 unsigned int code_factor
;
8221 unsigned long pc_begin
;
8222 unsigned long pc_range
;
8226 unsigned char fde_encoding
;
8230 /* A marker for a col_type that means this column was never referenced
8231 in the frame info. */
8232 #define DW_CFA_unreferenced (-1)
8234 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8235 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8236 static int size_of_encoded_value
PARAMS ((int));
8239 frame_need_space (fc
, reg
)
8243 int prev
= fc
->ncols
;
8245 if (reg
< fc
->ncols
)
8248 fc
->ncols
= reg
+ 1;
8249 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8250 fc
->ncols
* sizeof (short int));
8251 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8252 fc
->ncols
* sizeof (int));
8254 while (prev
< fc
->ncols
)
8256 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8257 fc
->col_offset
[prev
] = 0;
8263 frame_display_row (fc
, need_col_headers
, max_regs
)
8265 int * need_col_headers
;
8271 if (* max_regs
< fc
->ncols
)
8272 * max_regs
= fc
->ncols
;
8274 if (* need_col_headers
)
8276 * need_col_headers
= 0;
8278 printf (" LOC CFA ");
8280 for (r
= 0; r
< * max_regs
; r
++)
8281 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8286 printf ("r%-4d", r
);
8292 printf ("%08lx ", fc
->pc_begin
);
8293 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8294 printf ("%-8s ", tmp
);
8296 for (r
= 0; r
< fc
->ncols
; r
++)
8298 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8300 switch (fc
->col_type
[r
])
8302 case DW_CFA_undefined
:
8305 case DW_CFA_same_value
:
8309 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8311 case DW_CFA_register
:
8312 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8315 strcpy (tmp
, "n/a");
8318 printf ("%-5s", tmp
);
8325 size_of_encoded_value (encoding
)
8328 switch (encoding
& 0x7)
8331 case 0: return is_32bit_elf
? 4 : 8;
8338 #define GET(N) byte_get (start, N); start += N
8339 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8340 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8343 display_debug_frames (section
, start
, file
)
8344 Elf32_Internal_Shdr
* section
;
8345 unsigned char * start
;
8346 FILE * file ATTRIBUTE_UNUSED
;
8348 unsigned char * end
= start
+ section
->sh_size
;
8349 unsigned char * section_start
= start
;
8350 Frame_Chunk
* chunks
= 0;
8351 Frame_Chunk
* remembered_state
= 0;
8353 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8356 int addr_size
= is_32bit_elf
? 4 : 8;
8358 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8362 unsigned char * saved_start
;
8363 unsigned char * block_end
;
8364 unsigned long length
;
8365 unsigned long cie_id
;
8368 int need_col_headers
= 1;
8369 unsigned char * augmentation_data
= NULL
;
8370 unsigned long augmentation_data_len
= 0;
8371 int encoded_ptr_size
= addr_size
;
8373 saved_start
= start
;
8374 length
= byte_get (start
, 4); start
+= 4;
8379 if (length
== 0xffffffff)
8381 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8385 block_end
= saved_start
+ length
+ 4;
8386 cie_id
= byte_get (start
, 4); start
+= 4;
8388 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8392 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8393 memset (fc
, 0, sizeof (Frame_Chunk
));
8397 fc
->chunk_start
= saved_start
;
8399 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8400 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8401 frame_need_space (fc
, max_regs
-1);
8405 fc
->augmentation
= start
;
8406 start
= strchr (start
, '\0') + 1;
8408 if (fc
->augmentation
[0] == 'z')
8410 fc
->code_factor
= LEB ();
8411 fc
->data_factor
= SLEB ();
8412 fc
->ra
= byte_get (start
, 1); start
+= 1;
8413 augmentation_data_len
= LEB ();
8414 augmentation_data
= start
;
8415 start
+= augmentation_data_len
;
8417 else if (strcmp (fc
->augmentation
, "eh") == 0)
8420 fc
->code_factor
= LEB ();
8421 fc
->data_factor
= SLEB ();
8422 fc
->ra
= byte_get (start
, 1); start
+= 1;
8426 fc
->code_factor
= LEB ();
8427 fc
->data_factor
= SLEB ();
8428 fc
->ra
= byte_get (start
, 1); start
+= 1;
8432 if (do_debug_frames_interp
)
8433 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8434 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8435 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8439 printf ("\n%08lx %08lx %08lx CIE\n",
8440 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8441 printf (" Version: %d\n", version
);
8442 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8443 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8444 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8445 printf (" Return address column: %d\n", fc
->ra
);
8447 if (augmentation_data_len
)
8450 printf (" Augmentation data: ");
8451 for (i
= 0; i
< augmentation_data_len
; ++i
)
8452 printf (" %02x", augmentation_data
[i
]);
8458 if (augmentation_data_len
)
8460 unsigned char *p
, *q
;
8461 p
= fc
->augmentation
+ 1;
8462 q
= augmentation_data
;
8469 q
+= 1 + size_of_encoded_value (*q
);
8471 fc
->fde_encoding
= *q
++;
8477 if (fc
->fde_encoding
)
8478 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8481 frame_need_space (fc
, fc
->ra
);
8485 unsigned char * look_for
;
8486 static Frame_Chunk fde_fc
;
8489 memset (fc
, 0, sizeof (Frame_Chunk
));
8491 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8493 for (cie
= chunks
; cie
; cie
= cie
->next
)
8494 if (cie
->chunk_start
== look_for
)
8499 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8500 cie_id
, saved_start
);
8503 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8504 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8505 frame_need_space (fc
, max_regs
- 1);
8507 fc
->augmentation
= "";
8508 fc
->fde_encoding
= 0;
8512 fc
->ncols
= cie
->ncols
;
8513 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8514 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8515 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8516 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8517 fc
->augmentation
= cie
->augmentation
;
8518 fc
->code_factor
= cie
->code_factor
;
8519 fc
->data_factor
= cie
->data_factor
;
8520 fc
->cfa_reg
= cie
->cfa_reg
;
8521 fc
->cfa_offset
= cie
->cfa_offset
;
8523 frame_need_space (fc
, max_regs
-1);
8524 fc
->fde_encoding
= cie
->fde_encoding
;
8527 if (fc
->fde_encoding
)
8528 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8530 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8531 start
+= encoded_ptr_size
;
8532 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8533 start
+= encoded_ptr_size
;
8535 if (cie
->augmentation
[0] == 'z')
8537 augmentation_data_len
= LEB ();
8538 augmentation_data
= start
;
8539 start
+= augmentation_data_len
;
8542 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8543 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8544 (unsigned long)(cie
->chunk_start
- section_start
),
8545 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8546 if (! do_debug_frames_interp
&& augmentation_data_len
)
8549 printf (" Augmentation data: ");
8550 for (i
= 0; i
< augmentation_data_len
; ++i
)
8551 printf (" %02x", augmentation_data
[i
]);
8557 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8558 about to interpret instructions for the chunk. */
8560 if (do_debug_frames_interp
)
8562 /* Start by making a pass over the chunk, allocating storage
8563 and taking note of what registers are used. */
8564 unsigned char * tmp
= start
;
8566 while (start
< block_end
)
8576 /* Warning: if you add any more cases to this switch, be
8577 sure to add them to the corresponding switch below. */
8580 case DW_CFA_advance_loc
:
8584 frame_need_space (fc
, opa
);
8585 fc
->col_type
[opa
] = DW_CFA_undefined
;
8587 case DW_CFA_restore
:
8588 frame_need_space (fc
, opa
);
8589 fc
->col_type
[opa
] = DW_CFA_undefined
;
8591 case DW_CFA_set_loc
:
8592 start
+= encoded_ptr_size
;
8594 case DW_CFA_advance_loc1
:
8597 case DW_CFA_advance_loc2
:
8600 case DW_CFA_advance_loc4
:
8603 case DW_CFA_offset_extended
:
8604 reg
= LEB (); LEB ();
8605 frame_need_space (fc
, reg
);
8606 fc
->col_type
[reg
] = DW_CFA_undefined
;
8608 case DW_CFA_restore_extended
:
8610 frame_need_space (fc
, reg
);
8611 fc
->col_type
[reg
] = DW_CFA_undefined
;
8613 case DW_CFA_undefined
:
8615 frame_need_space (fc
, reg
);
8616 fc
->col_type
[reg
] = DW_CFA_undefined
;
8618 case DW_CFA_same_value
:
8620 frame_need_space (fc
, reg
);
8621 fc
->col_type
[reg
] = DW_CFA_undefined
;
8623 case DW_CFA_register
:
8624 reg
= LEB (); LEB ();
8625 frame_need_space (fc
, reg
);
8626 fc
->col_type
[reg
] = DW_CFA_undefined
;
8628 case DW_CFA_def_cfa
:
8631 case DW_CFA_def_cfa_register
:
8634 case DW_CFA_def_cfa_offset
:
8637 case DW_CFA_offset_extended_sf
:
8638 reg
= LEB (); SLEB ();
8639 frame_need_space (fc
, reg
);
8640 fc
->col_type
[reg
] = DW_CFA_undefined
;
8642 case DW_CFA_def_cfa_sf
:
8645 case DW_CFA_def_cfa_offset_sf
:
8648 case DW_CFA_GNU_args_size
:
8651 case DW_CFA_GNU_negative_offset_extended
:
8652 reg
= LEB (); LEB ();
8653 frame_need_space (fc
, reg
);
8654 fc
->col_type
[reg
] = DW_CFA_undefined
;
8663 /* Now we know what registers are used, make a second pass over
8664 the chunk, this time actually printing out the info. */
8666 while (start
< block_end
)
8669 unsigned long ul
, reg
, roffs
;
8678 /* Warning: if you add any more cases to this switch, be
8679 sure to add them to the corresponding switch above. */
8682 case DW_CFA_advance_loc
:
8683 if (do_debug_frames_interp
)
8684 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8686 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8687 opa
* fc
->code_factor
,
8688 fc
->pc_begin
+ opa
* fc
->code_factor
);
8689 fc
->pc_begin
+= opa
* fc
->code_factor
;
8694 if (! do_debug_frames_interp
)
8695 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8696 opa
, roffs
* fc
->data_factor
);
8697 fc
->col_type
[opa
] = DW_CFA_offset
;
8698 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8701 case DW_CFA_restore
:
8702 if (! do_debug_frames_interp
)
8703 printf (" DW_CFA_restore: r%d\n", opa
);
8704 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8705 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8708 case DW_CFA_set_loc
:
8709 vma
= byte_get (start
, encoded_ptr_size
);
8710 start
+= encoded_ptr_size
;
8711 if (do_debug_frames_interp
)
8712 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8714 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8718 case DW_CFA_advance_loc1
:
8719 ofs
= byte_get (start
, 1); start
+= 1;
8720 if (do_debug_frames_interp
)
8721 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8723 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8724 ofs
* fc
->code_factor
,
8725 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8726 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8729 case DW_CFA_advance_loc2
:
8730 ofs
= byte_get (start
, 2); start
+= 2;
8731 if (do_debug_frames_interp
)
8732 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8734 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8735 ofs
* fc
->code_factor
,
8736 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8737 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8740 case DW_CFA_advance_loc4
:
8741 ofs
= byte_get (start
, 4); start
+= 4;
8742 if (do_debug_frames_interp
)
8743 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8745 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8746 ofs
* fc
->code_factor
,
8747 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8748 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8751 case DW_CFA_offset_extended
:
8754 if (! do_debug_frames_interp
)
8755 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8756 reg
, roffs
* fc
->data_factor
);
8757 fc
->col_type
[reg
] = DW_CFA_offset
;
8758 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8761 case DW_CFA_restore_extended
:
8763 if (! do_debug_frames_interp
)
8764 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8765 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8766 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8769 case DW_CFA_undefined
:
8771 if (! do_debug_frames_interp
)
8772 printf (" DW_CFA_undefined: r%ld\n", reg
);
8773 fc
->col_type
[reg
] = DW_CFA_undefined
;
8774 fc
->col_offset
[reg
] = 0;
8777 case DW_CFA_same_value
:
8779 if (! do_debug_frames_interp
)
8780 printf (" DW_CFA_same_value: r%ld\n", reg
);
8781 fc
->col_type
[reg
] = DW_CFA_same_value
;
8782 fc
->col_offset
[reg
] = 0;
8785 case DW_CFA_register
:
8788 if (! do_debug_frames_interp
)
8789 printf (" DW_CFA_register: r%ld\n", reg
);
8790 fc
->col_type
[reg
] = DW_CFA_register
;
8791 fc
->col_offset
[reg
] = roffs
;
8794 case DW_CFA_remember_state
:
8795 if (! do_debug_frames_interp
)
8796 printf (" DW_CFA_remember_state\n");
8797 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8798 rs
->ncols
= fc
->ncols
;
8799 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8800 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8801 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8802 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8803 rs
->next
= remembered_state
;
8804 remembered_state
= rs
;
8807 case DW_CFA_restore_state
:
8808 if (! do_debug_frames_interp
)
8809 printf (" DW_CFA_restore_state\n");
8810 rs
= remembered_state
;
8811 remembered_state
= rs
->next
;
8812 frame_need_space (fc
, rs
->ncols
-1);
8813 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8814 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8815 free (rs
->col_type
);
8816 free (rs
->col_offset
);
8820 case DW_CFA_def_cfa
:
8821 fc
->cfa_reg
= LEB ();
8822 fc
->cfa_offset
= LEB ();
8823 if (! do_debug_frames_interp
)
8824 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8825 fc
->cfa_reg
, fc
->cfa_offset
);
8828 case DW_CFA_def_cfa_register
:
8829 fc
->cfa_reg
= LEB ();
8830 if (! do_debug_frames_interp
)
8831 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8834 case DW_CFA_def_cfa_offset
:
8835 fc
->cfa_offset
= LEB ();
8836 if (! do_debug_frames_interp
)
8837 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8841 if (! do_debug_frames_interp
)
8842 printf (" DW_CFA_nop\n");
8845 case DW_CFA_offset_extended_sf
:
8848 frame_need_space (fc
, reg
);
8849 if (! do_debug_frames_interp
)
8850 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8851 reg
, l
* fc
->data_factor
);
8852 fc
->col_type
[reg
] = DW_CFA_offset
;
8853 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8856 case DW_CFA_def_cfa_sf
:
8857 fc
->cfa_reg
= LEB ();
8858 fc
->cfa_offset
= SLEB ();
8859 if (! do_debug_frames_interp
)
8860 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8861 fc
->cfa_reg
, fc
->cfa_offset
);
8864 case DW_CFA_def_cfa_offset_sf
:
8865 fc
->cfa_offset
= SLEB ();
8866 if (! do_debug_frames_interp
)
8867 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
8870 case DW_CFA_GNU_window_save
:
8871 if (! do_debug_frames_interp
)
8872 printf (" DW_CFA_GNU_window_save\n");
8875 case DW_CFA_GNU_args_size
:
8877 if (! do_debug_frames_interp
)
8878 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8881 case DW_CFA_GNU_negative_offset_extended
:
8884 frame_need_space (fc
, reg
);
8885 if (! do_debug_frames_interp
)
8886 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8887 reg
, l
* fc
->data_factor
);
8888 fc
->col_type
[reg
] = DW_CFA_offset
;
8889 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8892 /* FIXME: How do we handle these? */
8893 case DW_CFA_def_cfa_expression
:
8894 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
8898 case DW_CFA_expression
:
8899 fprintf (stderr
, "unsupported DW_CFA_expression\n");
8904 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8909 if (do_debug_frames_interp
)
8910 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8925 display_debug_not_supported (section
, start
, file
)
8926 Elf32_Internal_Shdr
* section
;
8927 unsigned char * start ATTRIBUTE_UNUSED
;
8928 FILE * file ATTRIBUTE_UNUSED
;
8930 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8931 SECTION_NAME (section
));
8936 /* Pre-scan the .debug_info section to record the size of address.
8937 When dumping the .debug_line, we use that size information, assuming
8938 that all compilation units have the same address size. */
8940 prescan_debug_info (section
, start
, file
)
8941 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8942 unsigned char * start
;
8943 FILE * file ATTRIBUTE_UNUSED
;
8945 DWARF2_External_CompUnit
* external
;
8947 external
= (DWARF2_External_CompUnit
*) start
;
8949 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8953 /* A structure containing the name of a debug section and a pointer
8954 to a function that can decode it. The third field is a prescan
8955 function to be run over the section before displaying any of the
8959 const char * const name
;
8960 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8961 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8965 { ".debug_abbrev", display_debug_abbrev
, NULL
},
8966 { ".debug_aranges", display_debug_aranges
, NULL
},
8967 { ".debug_frame", display_debug_frames
, NULL
},
8968 { ".debug_info", display_debug_info
, prescan_debug_info
},
8969 { ".debug_line", display_debug_lines
, NULL
},
8970 { ".debug_pubnames", display_debug_pubnames
, NULL
},
8971 { ".eh_frame", display_debug_frames
, NULL
},
8972 { ".debug_macinfo", display_debug_macinfo
, NULL
},
8973 { ".debug_str", display_debug_str
, NULL
},
8974 { ".debug_loc", display_debug_loc
, NULL
},
8975 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
8976 { ".debug_ranges", display_debug_not_supported
, NULL
},
8977 { ".debug_static_func", display_debug_not_supported
, NULL
},
8978 { ".debug_static_vars", display_debug_not_supported
, NULL
},
8979 { ".debug_types", display_debug_not_supported
, NULL
},
8980 { ".debug_weaknames", display_debug_not_supported
, NULL
}
8984 display_debug_section (section
, file
)
8985 Elf32_Internal_Shdr
* section
;
8988 char * name
= SECTION_NAME (section
);
8989 bfd_size_type length
;
8990 unsigned char * start
;
8993 length
= section
->sh_size
;
8996 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9000 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
9001 _("debug section data"));
9005 /* See if we know how to display the contents of this section. */
9006 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9007 name
= ".debug_info";
9009 for (i
= NUM_ELEM (debug_displays
); i
--;)
9010 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9012 debug_displays
[i
].display (section
, start
, file
);
9017 printf (_("Unrecognized debug section: %s\n"), name
);
9021 /* If we loaded in the abbrev section at some point,
9022 we must release it here. */
9029 process_section_contents (file
)
9032 Elf32_Internal_Shdr
* section
;
9038 /* Pre-scan the debug sections to find some debug information not
9039 present in some of them. For the .debug_line, we must find out the
9040 size of address (specified in .debug_info and .debug_aranges). */
9041 for (i
= 0, section
= section_headers
;
9042 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9045 char * name
= SECTION_NAME (section
);
9048 if (section
->sh_size
== 0)
9051 /* See if there is some pre-scan operation for this section. */
9052 for (j
= NUM_ELEM (debug_displays
); j
--;)
9053 if (strcmp (debug_displays
[j
].name
, name
) == 0)
9055 if (debug_displays
[j
].prescan
!= NULL
)
9057 bfd_size_type length
;
9058 unsigned char * start
;
9060 length
= section
->sh_size
;
9061 start
= ((unsigned char *)
9062 get_data (NULL
, file
, section
->sh_offset
, length
,
9063 _("debug section data")));
9067 debug_displays
[j
].prescan (section
, start
, file
);
9075 for (i
= 0, section
= section_headers
;
9076 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9079 #ifdef SUPPORT_DISASSEMBLY
9080 if (dump_sects
[i
] & DISASS_DUMP
)
9081 disassemble_section (section
, file
);
9083 if (dump_sects
[i
] & HEX_DUMP
)
9084 dump_section (section
, file
);
9086 if (dump_sects
[i
] & DEBUG_DUMP
)
9087 display_debug_section (section
, file
);
9090 if (i
< num_dump_sects
)
9091 warn (_("Some sections were not dumped because they do not exist!\n"));
9097 process_mips_fpe_exception (mask
)
9103 if (mask
& OEX_FPU_INEX
)
9104 fputs ("INEX", stdout
), first
= 0;
9105 if (mask
& OEX_FPU_UFLO
)
9106 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9107 if (mask
& OEX_FPU_OFLO
)
9108 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9109 if (mask
& OEX_FPU_DIV0
)
9110 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9111 if (mask
& OEX_FPU_INVAL
)
9112 printf ("%sINVAL", first
? "" : "|");
9115 fputs ("0", stdout
);
9119 process_mips_specific (file
)
9122 Elf_Internal_Dyn
* entry
;
9123 size_t liblist_offset
= 0;
9124 size_t liblistno
= 0;
9125 size_t conflictsno
= 0;
9126 size_t options_offset
= 0;
9127 size_t conflicts_offset
= 0;
9129 /* We have a lot of special sections. Thanks SGI! */
9130 if (dynamic_segment
== NULL
)
9131 /* No information available. */
9134 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9135 switch (entry
->d_tag
)
9137 case DT_MIPS_LIBLIST
:
9138 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
9140 case DT_MIPS_LIBLISTNO
:
9141 liblistno
= entry
->d_un
.d_val
;
9143 case DT_MIPS_OPTIONS
:
9144 options_offset
= entry
->d_un
.d_val
- loadaddr
;
9146 case DT_MIPS_CONFLICT
:
9147 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
9149 case DT_MIPS_CONFLICTNO
:
9150 conflictsno
= entry
->d_un
.d_val
;
9156 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9158 Elf32_External_Lib
* elib
;
9161 elib
= ((Elf32_External_Lib
*)
9162 get_data (NULL
, file
, liblist_offset
,
9163 liblistno
* sizeof (Elf32_External_Lib
),
9167 printf ("\nSection '.liblist' contains %lu entries:\n",
9168 (unsigned long) liblistno
);
9169 fputs (" Library Time Stamp Checksum Version Flags\n",
9172 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9179 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9180 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9181 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9182 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9183 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9185 tmp
= gmtime (&time
);
9186 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9187 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9188 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9190 printf ("%3lu: ", (unsigned long) cnt
);
9191 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9192 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9195 if (liblist
.l_flags
== 0)
9206 { " EXACT_MATCH", LL_EXACT_MATCH
},
9207 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9208 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9209 { " EXPORTS", LL_EXPORTS
},
9210 { " DELAY_LOAD", LL_DELAY_LOAD
},
9211 { " DELTA", LL_DELTA
}
9213 int flags
= liblist
.l_flags
;
9217 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9219 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9221 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9222 flags
^= l_flags_vals
[fcnt
].bit
;
9225 printf (" %#x", (unsigned int) flags
);
9235 if (options_offset
!= 0)
9237 Elf_External_Options
* eopt
;
9238 Elf_Internal_Shdr
* sect
= section_headers
;
9239 Elf_Internal_Options
* iopt
;
9240 Elf_Internal_Options
* option
;
9244 /* Find the section header so that we get the size. */
9245 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9248 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9249 sect
->sh_size
, _("options"));
9252 iopt
= ((Elf_Internal_Options
*)
9253 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
9256 error (_("Out of memory"));
9263 while (offset
< sect
->sh_size
)
9265 Elf_External_Options
* eoption
;
9267 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9269 option
->kind
= BYTE_GET (eoption
->kind
);
9270 option
->size
= BYTE_GET (eoption
->size
);
9271 option
->section
= BYTE_GET (eoption
->section
);
9272 option
->info
= BYTE_GET (eoption
->info
);
9274 offset
+= option
->size
;
9280 printf (_("\nSection '%s' contains %d entries:\n"),
9281 SECTION_NAME (sect
), cnt
);
9289 switch (option
->kind
)
9292 /* This shouldn't happen. */
9293 printf (" NULL %d %lx", option
->section
, option
->info
);
9296 printf (" REGINFO ");
9297 if (elf_header
.e_machine
== EM_MIPS
)
9300 Elf32_External_RegInfo
* ereg
;
9301 Elf32_RegInfo reginfo
;
9303 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9304 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9305 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9306 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9307 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9308 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9309 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9311 printf ("GPR %08lx GP 0x%lx\n",
9313 (unsigned long) reginfo
.ri_gp_value
);
9314 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9315 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9316 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9321 Elf64_External_RegInfo
* ereg
;
9322 Elf64_Internal_RegInfo reginfo
;
9324 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9325 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9326 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9327 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9328 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9329 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9330 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9332 printf ("GPR %08lx GP 0x",
9333 reginfo
.ri_gprmask
);
9334 printf_vma (reginfo
.ri_gp_value
);
9337 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9338 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9339 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9343 case ODK_EXCEPTIONS
:
9344 fputs (" EXCEPTIONS fpe_min(", stdout
);
9345 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9346 fputs (") fpe_max(", stdout
);
9347 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9348 fputs (")", stdout
);
9350 if (option
->info
& OEX_PAGE0
)
9351 fputs (" PAGE0", stdout
);
9352 if (option
->info
& OEX_SMM
)
9353 fputs (" SMM", stdout
);
9354 if (option
->info
& OEX_FPDBUG
)
9355 fputs (" FPDBUG", stdout
);
9356 if (option
->info
& OEX_DISMISS
)
9357 fputs (" DISMISS", stdout
);
9360 fputs (" PAD ", stdout
);
9361 if (option
->info
& OPAD_PREFIX
)
9362 fputs (" PREFIX", stdout
);
9363 if (option
->info
& OPAD_POSTFIX
)
9364 fputs (" POSTFIX", stdout
);
9365 if (option
->info
& OPAD_SYMBOL
)
9366 fputs (" SYMBOL", stdout
);
9369 fputs (" HWPATCH ", stdout
);
9370 if (option
->info
& OHW_R4KEOP
)
9371 fputs (" R4KEOP", stdout
);
9372 if (option
->info
& OHW_R8KPFETCH
)
9373 fputs (" R8KPFETCH", stdout
);
9374 if (option
->info
& OHW_R5KEOP
)
9375 fputs (" R5KEOP", stdout
);
9376 if (option
->info
& OHW_R5KCVTL
)
9377 fputs (" R5KCVTL", stdout
);
9380 fputs (" FILL ", stdout
);
9381 /* XXX Print content of info word? */
9384 fputs (" TAGS ", stdout
);
9385 /* XXX Print content of info word? */
9388 fputs (" HWAND ", stdout
);
9389 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9390 fputs (" R4KEOP_CHECKED", stdout
);
9391 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9392 fputs (" R4KEOP_CLEAN", stdout
);
9395 fputs (" HWOR ", stdout
);
9396 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9397 fputs (" R4KEOP_CHECKED", stdout
);
9398 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9399 fputs (" R4KEOP_CLEAN", stdout
);
9402 printf (" GP_GROUP %#06lx self-contained %#06lx",
9403 option
->info
& OGP_GROUP
,
9404 (option
->info
& OGP_SELF
) >> 16);
9407 printf (" IDENT %#06lx self-contained %#06lx",
9408 option
->info
& OGP_GROUP
,
9409 (option
->info
& OGP_SELF
) >> 16);
9412 /* This shouldn't happen. */
9413 printf (" %3d ??? %d %lx",
9414 option
->kind
, option
->section
, option
->info
);
9418 len
= sizeof (* eopt
);
9419 while (len
< option
->size
)
9420 if (((char *) option
)[len
] >= ' '
9421 && ((char *) option
)[len
] < 0x7f)
9422 printf ("%c", ((char *) option
)[len
++]);
9424 printf ("\\%03o", ((char *) option
)[len
++]);
9426 fputs ("\n", stdout
);
9434 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9436 Elf32_Conflict
* iconf
;
9439 if (dynamic_symbols
== NULL
)
9441 error (_("conflict list found without a dynamic symbol table"));
9445 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
9448 error (_("Out of memory"));
9454 Elf32_External_Conflict
* econf32
;
9456 econf32
= ((Elf32_External_Conflict
*)
9457 get_data (NULL
, file
, conflicts_offset
,
9458 conflictsno
* sizeof (* econf32
),
9463 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9464 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9470 Elf64_External_Conflict
* econf64
;
9472 econf64
= ((Elf64_External_Conflict
*)
9473 get_data (NULL
, file
, conflicts_offset
,
9474 conflictsno
* sizeof (* econf64
),
9479 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9480 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9485 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9486 (long) conflictsno
);
9487 puts (_(" Num: Index Value Name"));
9489 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9491 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9493 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9494 print_vma (psym
->st_value
, FULL_HEX
);
9496 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9507 process_gnu_liblist (file
)
9510 Elf_Internal_Shdr
* section
, * string_sec
;
9511 Elf32_External_Lib
* elib
;
9519 for (i
= 0, section
= section_headers
;
9520 i
< elf_header
.e_shnum
;
9523 switch (section
->sh_type
)
9525 case SHT_GNU_LIBLIST
:
9526 elib
= ((Elf32_External_Lib
*)
9527 get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9532 string_sec
= SECTION_HEADER (section
->sh_link
);
9534 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9535 string_sec
->sh_size
,
9536 _("liblist string table"));
9539 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9545 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9546 SECTION_NAME (section
),
9547 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9549 puts (" Library Time Stamp Checksum Version Flags");
9551 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9559 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9560 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9561 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9562 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9563 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9565 tmp
= gmtime (&time
);
9566 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9567 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9568 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9570 printf ("%3lu: ", (unsigned long) cnt
);
9572 printf ("%-20s", strtab
+ liblist
.l_name
);
9574 printf ("%-20.20s", strtab
+ liblist
.l_name
);
9575 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9576 liblist
.l_version
, liblist
.l_flags
);
9587 get_note_type (e_type
)
9590 static char buff
[64];
9594 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9595 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9596 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9597 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9598 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9599 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9600 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9601 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9602 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9603 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9604 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9606 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9612 get_netbsd_elfcore_note_type (e_type
)
9615 static char buff
[64];
9617 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9619 /* NetBSD core "procinfo" structure. */
9620 return _("NetBSD procinfo structure");
9623 /* As of Jan 2002 there are no other machine-independent notes
9624 defined for NetBSD core files. If the note type is less
9625 than the start of the machine-dependent note types, we don't
9628 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9630 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9634 switch (elf_header
.e_machine
)
9636 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9637 and PT_GETFPREGS == mach+2. */
9642 case EM_SPARC32PLUS
:
9646 case NT_NETBSDCORE_FIRSTMACH
+0:
9647 return _("PT_GETREGS (reg structure)");
9648 case NT_NETBSDCORE_FIRSTMACH
+2:
9649 return _("PT_GETFPREGS (fpreg structure)");
9655 /* On all other arch's, PT_GETREGS == mach+1 and
9656 PT_GETFPREGS == mach+3. */
9660 case NT_NETBSDCORE_FIRSTMACH
+1:
9661 return _("PT_GETREGS (reg structure)");
9662 case NT_NETBSDCORE_FIRSTMACH
+3:
9663 return _("PT_GETFPREGS (fpreg structure)");
9669 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9673 /* Note that by the ELF standard, the name field is already null byte
9674 terminated, and namesz includes the terminating null byte.
9675 I.E. the value of namesz for the name "FSF" is 4.
9677 If the value of namesz is zero, there is no name present. */
9679 process_note (pnote
)
9680 Elf32_Internal_Note
* pnote
;
9684 if (pnote
->namesz
== 0)
9686 /* If there is no note name, then use the default set of
9687 note type strings. */
9688 nt
= get_note_type (pnote
->type
);
9690 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9692 /* NetBSD-specific core file notes. */
9693 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9697 /* Don't recognize this note name; just use the default set of
9698 note type strings. */
9699 nt
= get_note_type (pnote
->type
);
9702 printf (" %s\t\t0x%08lx\t%s\n",
9703 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9710 process_corefile_note_segment (file
, offset
, length
)
9715 Elf_External_Note
* pnotes
;
9716 Elf_External_Note
* external
;
9722 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9729 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9730 (unsigned long) offset
, (unsigned long) length
);
9731 printf (_(" Owner\t\tData size\tDescription\n"));
9733 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9735 Elf_External_Note
* next
;
9736 Elf32_Internal_Note inote
;
9739 inote
.type
= BYTE_GET (external
->type
);
9740 inote
.namesz
= BYTE_GET (external
->namesz
);
9741 inote
.namedata
= external
->name
;
9742 inote
.descsz
= BYTE_GET (external
->descsz
);
9743 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9744 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9746 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9748 if (((char *) next
) > (((char *) pnotes
) + length
))
9750 warn (_("corrupt note found at offset %x into core notes\n"),
9751 ((char *) external
) - ((char *) pnotes
));
9752 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9753 inote
.type
, inote
.namesz
, inote
.descsz
);
9759 /* Verify that name is null terminated. It appears that at least
9760 one version of Linux (RedHat 6.0) generates corefiles that don't
9761 comply with the ELF spec by failing to include the null byte in
9763 if (inote
.namedata
[inote
.namesz
] != '\0')
9765 temp
= malloc (inote
.namesz
+ 1);
9769 error (_("Out of memory\n"));
9774 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9775 temp
[inote
.namesz
] = 0;
9777 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9778 inote
.namedata
= temp
;
9781 res
&= process_note (& inote
);
9796 process_corefile_note_segments (file
)
9799 Elf_Internal_Phdr
* program_headers
;
9800 Elf_Internal_Phdr
* segment
;
9804 program_headers
= (Elf_Internal_Phdr
*) malloc
9805 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9807 if (program_headers
== NULL
)
9809 error (_("Out of memory\n"));
9814 i
= get_32bit_program_headers (file
, program_headers
);
9816 i
= get_64bit_program_headers (file
, program_headers
);
9820 free (program_headers
);
9824 for (i
= 0, segment
= program_headers
;
9825 i
< elf_header
.e_phnum
;
9828 if (segment
->p_type
== PT_NOTE
)
9829 res
&= process_corefile_note_segment (file
,
9830 (bfd_vma
) segment
->p_offset
,
9831 (bfd_vma
) segment
->p_filesz
);
9834 free (program_headers
);
9840 process_corefile_contents (file
)
9843 /* If we have not been asked to display the notes then do nothing. */
9847 /* If file is not a core file then exit. */
9848 if (elf_header
.e_type
!= ET_CORE
)
9851 /* No program headers means no NOTE segment. */
9852 if (elf_header
.e_phnum
== 0)
9854 printf (_("No note segments present in the core file.\n"));
9858 return process_corefile_note_segments (file
);
9862 process_arch_specific (file
)
9868 switch (elf_header
.e_machine
)
9871 case EM_MIPS_RS3_LE
:
9872 return process_mips_specific (file
);
9881 get_file_header (file
)
9884 /* Read in the identity array. */
9885 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9888 /* Determine how to read the rest of the header. */
9889 switch (elf_header
.e_ident
[EI_DATA
])
9891 default: /* fall through */
9892 case ELFDATANONE
: /* fall through */
9893 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9894 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9897 /* For now we only support 32 bit and 64 bit ELF files. */
9898 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9900 /* Read in the rest of the header. */
9903 Elf32_External_Ehdr ehdr32
;
9905 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9908 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9909 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9910 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9911 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9912 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9913 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9914 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9915 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9916 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9917 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9918 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9919 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9920 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9924 Elf64_External_Ehdr ehdr64
;
9926 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9927 we will not be able to cope with the 64bit data found in
9928 64 ELF files. Detect this now and abort before we start
9929 overwritting things. */
9930 if (sizeof (bfd_vma
) < 8)
9932 error (_("This instance of readelf has been built without support for a\n\
9933 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9937 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9940 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9941 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9942 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9943 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9944 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9945 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9946 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9947 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9948 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9949 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9950 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9951 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9952 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9955 if (elf_header
.e_shoff
)
9957 /* There may be some extensions in the first section header. Don't
9958 bomb if we can't read it. */
9960 get_32bit_section_headers (file
, 1);
9962 get_64bit_section_headers (file
, 1);
9969 process_file (file_name
)
9973 struct stat statbuf
;
9976 if (stat (file_name
, & statbuf
) < 0)
9978 error (_("Cannot stat input file %s.\n"), file_name
);
9982 file
= fopen (file_name
, "rb");
9985 error (_("Input file %s not found.\n"), file_name
);
9989 if (! get_file_header (file
))
9991 error (_("%s: Failed to read file header\n"), file_name
);
9996 /* Initialise per file variables. */
9997 for (i
= NUM_ELEM (version_info
); i
--;)
9998 version_info
[i
] = 0;
10000 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10001 dynamic_info
[i
] = 0;
10003 /* Process the file. */
10005 printf (_("\nFile: %s\n"), file_name
);
10007 if (! process_file_header ())
10013 process_section_headers (file
);
10015 process_program_headers (file
);
10017 process_dynamic_segment (file
);
10019 process_relocs (file
);
10021 process_unwind (file
);
10023 process_symbol_table (file
);
10025 process_syminfo (file
);
10027 process_version_sections (file
);
10029 process_section_contents (file
);
10031 process_corefile_contents (file
);
10033 process_gnu_liblist (file
);
10035 process_arch_specific (file
);
10039 if (section_headers
)
10041 free (section_headers
);
10042 section_headers
= NULL
;
10047 free (string_table
);
10048 string_table
= NULL
;
10049 string_table_length
= 0;
10052 if (dynamic_strings
)
10054 free (dynamic_strings
);
10055 dynamic_strings
= NULL
;
10058 if (dynamic_symbols
)
10060 free (dynamic_symbols
);
10061 dynamic_symbols
= NULL
;
10062 num_dynamic_syms
= 0;
10065 if (dynamic_syminfo
)
10067 free (dynamic_syminfo
);
10068 dynamic_syminfo
= NULL
;
10074 #ifdef SUPPORT_DISASSEMBLY
10075 /* Needed by the i386 disassembler. For extra credit, someone could
10076 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10080 print_address (unsigned int addr
, FILE * outfile
)
10082 fprintf (outfile
,"0x%8.8x", addr
);
10085 /* Needed by the i386 disassembler. */
10087 db_task_printsym (unsigned int addr
)
10089 print_address (addr
, stderr
);
10093 int main
PARAMS ((int, char **));
10102 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10103 setlocale (LC_MESSAGES
, "");
10105 #if defined (HAVE_SETLOCALE)
10106 setlocale (LC_CTYPE
, "");
10108 bindtextdomain (PACKAGE
, LOCALEDIR
);
10109 textdomain (PACKAGE
);
10111 parse_args (argc
, argv
);
10113 if (optind
< (argc
- 1))
10117 while (optind
< argc
)
10118 err
|= process_file (argv
[optind
++]);
10120 if (dump_sects
!= NULL
)