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
, ", v850ea");
1784 strcat (buf
, ", v850");
1787 strcat (buf
, ", unknown v850 architecture variant");
1793 case EM_CYGNUS_M32R
:
1794 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1795 strcat (buf
, ", m32r");
1800 case EM_MIPS_RS3_LE
:
1801 if (e_flags
& EF_MIPS_NOREORDER
)
1802 strcat (buf
, ", noreorder");
1804 if (e_flags
& EF_MIPS_PIC
)
1805 strcat (buf
, ", pic");
1807 if (e_flags
& EF_MIPS_CPIC
)
1808 strcat (buf
, ", cpic");
1810 if (e_flags
& EF_MIPS_UCODE
)
1811 strcat (buf
, ", ugen_reserved");
1813 if (e_flags
& EF_MIPS_ABI2
)
1814 strcat (buf
, ", abi2");
1816 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1817 strcat (buf
, ", odk first");
1819 if (e_flags
& EF_MIPS_32BITMODE
)
1820 strcat (buf
, ", 32bitmode");
1822 switch ((e_flags
& EF_MIPS_MACH
))
1824 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1825 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1826 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1827 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1828 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1829 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1831 /* We simply ignore the field in this case to avoid confusion:
1832 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1835 default: strcat (buf
, ", unknown CPU"); break;
1838 switch ((e_flags
& EF_MIPS_ABI
))
1840 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1841 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1842 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1843 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1845 /* We simply ignore the field in this case to avoid confusion:
1846 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1847 This means it is likely to be an o32 file, but not for
1850 default: strcat (buf
, ", unknown ABI"); break;
1853 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1854 strcat (buf
, ", mdmx");
1856 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1857 strcat (buf
, ", mips16");
1859 switch ((e_flags
& EF_MIPS_ARCH
))
1861 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1862 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1863 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1864 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1865 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1866 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1867 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1868 default: strcat (buf
, ", unknown ISA"); break;
1874 if (e_flags
& EF_SPARC_32PLUS
)
1875 strcat (buf
, ", v8+");
1877 if (e_flags
& EF_SPARC_SUN_US1
)
1878 strcat (buf
, ", ultrasparcI");
1880 if (e_flags
& EF_SPARC_SUN_US3
)
1881 strcat (buf
, ", ultrasparcIII");
1883 if (e_flags
& EF_SPARC_HAL_R1
)
1884 strcat (buf
, ", halr1");
1886 if (e_flags
& EF_SPARC_LEDATA
)
1887 strcat (buf
, ", ledata");
1889 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1890 strcat (buf
, ", tso");
1892 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1893 strcat (buf
, ", pso");
1895 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1896 strcat (buf
, ", rmo");
1900 switch (e_flags
& EF_PARISC_ARCH
)
1902 case EFA_PARISC_1_0
:
1903 strcpy (buf
, ", PA-RISC 1.0");
1905 case EFA_PARISC_1_1
:
1906 strcpy (buf
, ", PA-RISC 1.1");
1908 case EFA_PARISC_2_0
:
1909 strcpy (buf
, ", PA-RISC 2.0");
1914 if (e_flags
& EF_PARISC_TRAPNIL
)
1915 strcat (buf
, ", trapnil");
1916 if (e_flags
& EF_PARISC_EXT
)
1917 strcat (buf
, ", ext");
1918 if (e_flags
& EF_PARISC_LSB
)
1919 strcat (buf
, ", lsb");
1920 if (e_flags
& EF_PARISC_WIDE
)
1921 strcat (buf
, ", wide");
1922 if (e_flags
& EF_PARISC_NO_KABP
)
1923 strcat (buf
, ", no kabp");
1924 if (e_flags
& EF_PARISC_LAZYSWAP
)
1925 strcat (buf
, ", lazyswap");
1930 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1931 strcat (buf
, ", new calling convention");
1933 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1934 strcat (buf
, ", gnu calling convention");
1938 if ((e_flags
& EF_IA_64_ABI64
))
1939 strcat (buf
, ", 64-bit");
1941 strcat (buf
, ", 32-bit");
1942 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1943 strcat (buf
, ", reduced fp model");
1944 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1945 strcat (buf
, ", no function descriptors, constant gp");
1946 else if ((e_flags
& EF_IA_64_CONS_GP
))
1947 strcat (buf
, ", constant gp");
1948 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1949 strcat (buf
, ", absolute");
1953 if ((e_flags
& EF_VAX_NONPIC
))
1954 strcat (buf
, ", non-PIC");
1955 if ((e_flags
& EF_VAX_DFLOAT
))
1956 strcat (buf
, ", D-Float");
1957 if ((e_flags
& EF_VAX_GFLOAT
))
1958 strcat (buf
, ", G-Float");
1967 get_mips_segment_type (type
)
1972 case PT_MIPS_REGINFO
:
1974 case PT_MIPS_RTPROC
:
1976 case PT_MIPS_OPTIONS
:
1986 get_parisc_segment_type (type
)
1991 case PT_HP_TLS
: return "HP_TLS";
1992 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1993 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1994 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1995 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1996 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1997 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1998 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1999 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2000 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2001 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2002 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2003 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2004 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2013 get_ia64_segment_type (type
)
2018 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2019 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2020 case PT_HP_TLS
: return "HP_TLS";
2021 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2022 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2023 case PT_IA_64_HP_STACK
: return "HP_STACK";
2032 get_segment_type (p_type
)
2033 unsigned long p_type
;
2035 static char buff
[32];
2039 case PT_NULL
: return "NULL";
2040 case PT_LOAD
: return "LOAD";
2041 case PT_DYNAMIC
: return "DYNAMIC";
2042 case PT_INTERP
: return "INTERP";
2043 case PT_NOTE
: return "NOTE";
2044 case PT_SHLIB
: return "SHLIB";
2045 case PT_PHDR
: return "PHDR";
2046 case PT_TLS
: return "TLS";
2048 case PT_GNU_EH_FRAME
:
2049 return "GNU_EH_FRAME";
2052 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2054 const char * result
;
2056 switch (elf_header
.e_machine
)
2059 case EM_MIPS_RS3_LE
:
2060 result
= get_mips_segment_type (p_type
);
2063 result
= get_parisc_segment_type (p_type
);
2066 result
= get_ia64_segment_type (p_type
);
2076 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2078 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2080 const char * result
;
2082 switch (elf_header
.e_machine
)
2085 result
= get_parisc_segment_type (p_type
);
2088 result
= get_ia64_segment_type (p_type
);
2098 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2101 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2108 get_mips_section_type_name (sh_type
)
2109 unsigned int sh_type
;
2113 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2114 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2115 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2116 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2117 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2118 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2119 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2120 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2121 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2122 case SHT_MIPS_RELD
: return "MIPS_RELD";
2123 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2124 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2125 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2126 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2127 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2128 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2129 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2130 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2131 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2132 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2133 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2134 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2135 case SHT_MIPS_LINE
: return "MIPS_LINE";
2136 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2137 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2138 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2139 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2140 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2141 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2142 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2143 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2144 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2145 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2146 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2147 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2148 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2149 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2150 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2151 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2159 get_parisc_section_type_name (sh_type
)
2160 unsigned int sh_type
;
2164 case SHT_PARISC_EXT
: return "PARISC_EXT";
2165 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2166 case SHT_PARISC_DOC
: return "PARISC_DOC";
2174 get_ia64_section_type_name (sh_type
)
2175 unsigned int sh_type
;
2179 case SHT_IA_64_EXT
: return "IA_64_EXT";
2180 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2188 get_section_type_name (sh_type
)
2189 unsigned int sh_type
;
2191 static char buff
[32];
2195 case SHT_NULL
: return "NULL";
2196 case SHT_PROGBITS
: return "PROGBITS";
2197 case SHT_SYMTAB
: return "SYMTAB";
2198 case SHT_STRTAB
: return "STRTAB";
2199 case SHT_RELA
: return "RELA";
2200 case SHT_HASH
: return "HASH";
2201 case SHT_DYNAMIC
: return "DYNAMIC";
2202 case SHT_NOTE
: return "NOTE";
2203 case SHT_NOBITS
: return "NOBITS";
2204 case SHT_REL
: return "REL";
2205 case SHT_SHLIB
: return "SHLIB";
2206 case SHT_DYNSYM
: return "DYNSYM";
2207 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2208 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2209 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2210 case SHT_GROUP
: return "GROUP";
2211 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2212 case SHT_GNU_verdef
: return "VERDEF";
2213 case SHT_GNU_verneed
: return "VERNEED";
2214 case SHT_GNU_versym
: return "VERSYM";
2215 case 0x6ffffff0: return "VERSYM";
2216 case 0x6ffffffc: return "VERDEF";
2217 case 0x7ffffffd: return "AUXILIARY";
2218 case 0x7fffffff: return "FILTER";
2219 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2222 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2224 const char * result
;
2226 switch (elf_header
.e_machine
)
2229 case EM_MIPS_RS3_LE
:
2230 result
= get_mips_section_type_name (sh_type
);
2233 result
= get_parisc_section_type_name (sh_type
);
2236 result
= get_ia64_section_type_name (sh_type
);
2246 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2248 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2249 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2250 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2251 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2253 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2259 #define OPTION_DEBUG_DUMP 512
2261 struct option options
[] =
2263 {"all", no_argument
, 0, 'a'},
2264 {"file-header", no_argument
, 0, 'h'},
2265 {"program-headers", no_argument
, 0, 'l'},
2266 {"headers", no_argument
, 0, 'e'},
2267 {"histogram", no_argument
, 0, 'I'},
2268 {"segments", no_argument
, 0, 'l'},
2269 {"sections", no_argument
, 0, 'S'},
2270 {"section-headers", no_argument
, 0, 'S'},
2271 {"symbols", no_argument
, 0, 's'},
2272 {"syms", no_argument
, 0, 's'},
2273 {"relocs", no_argument
, 0, 'r'},
2274 {"notes", no_argument
, 0, 'n'},
2275 {"dynamic", no_argument
, 0, 'd'},
2276 {"arch-specific", no_argument
, 0, 'A'},
2277 {"version-info", no_argument
, 0, 'V'},
2278 {"use-dynamic", no_argument
, 0, 'D'},
2279 {"hex-dump", required_argument
, 0, 'x'},
2280 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2281 {"unwind", no_argument
, 0, 'u'},
2282 #ifdef SUPPORT_DISASSEMBLY
2283 {"instruction-dump", required_argument
, 0, 'i'},
2286 {"version", no_argument
, 0, 'v'},
2287 {"wide", no_argument
, 0, 'W'},
2288 {"help", no_argument
, 0, 'H'},
2289 {0, no_argument
, 0, 0}
2295 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2296 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2297 fprintf (stdout
, _(" Options are:\n\
2298 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2299 -h --file-header Display the ELF file header\n\
2300 -l --program-headers Display the program headers\n\
2301 --segments An alias for --program-headers\n\
2302 -S --section-headers Display the sections' header\n\
2303 --sections An alias for --section-headers\n\
2304 -e --headers Equivalent to: -h -l -S\n\
2305 -s --syms Display the symbol table\n\
2306 --symbols An alias for --syms\n\
2307 -n --notes Display the core notes (if present)\n\
2308 -r --relocs Display the relocations (if present)\n\
2309 -u --unwind Display the unwind info (if present)\n\
2310 -d --dynamic Display the dynamic segment (if present)\n\
2311 -V --version-info Display the version sections (if present)\n\
2312 -A --arch-specific Display architecture specific information (if any).\n\
2313 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2314 -x --hex-dump=<number> Dump the contents of section <number>\n\
2315 -w[liaprmfFso] or\n\
2316 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2317 Display the contents of DWARF2 debug sections\n"));
2318 #ifdef SUPPORT_DISASSEMBLY
2319 fprintf (stdout
, _("\
2320 -i --instruction-dump=<number>\n\
2321 Disassemble the contents of section <number>\n"));
2323 fprintf (stdout
, _("\
2324 -I --histogram Display histogram of bucket list lengths\n\
2325 -W --wide Allow output width to exceed 80 characters\n\
2326 -H --help Display this information\n\
2327 -v --version Display the version number of readelf\n"));
2328 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2334 request_dump (section
, type
)
2335 unsigned int section
;
2338 if (section
>= num_dump_sects
)
2340 char * new_dump_sects
;
2342 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2344 if (new_dump_sects
== NULL
)
2345 error (_("Out of memory allocating dump request table."));
2348 /* Copy current flag settings. */
2349 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2353 dump_sects
= new_dump_sects
;
2354 num_dump_sects
= section
+ 1;
2359 dump_sects
[section
] |= type
;
2365 parse_args (argc
, argv
)
2374 while ((c
= getopt_long
2375 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2411 do_using_dynamic
++;
2442 section
= strtoul (optarg
, & cp
, 0);
2443 if (! * cp
&& section
>= 0)
2445 request_dump (section
, HEX_DUMP
);
2455 unsigned int index
= 0;
2459 while (optarg
[index
])
2460 switch (optarg
[index
++])
2469 do_debug_abbrevs
= 1;
2479 do_debug_pubnames
= 1;
2484 do_debug_aranges
= 1;
2488 do_debug_frames_interp
= 1;
2490 do_debug_frames
= 1;
2495 do_debug_macinfo
= 1;
2509 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2514 case OPTION_DEBUG_DUMP
:
2520 const char *debug_dump_opt
[]
2521 = { "line", "info", "abbrev", "pubnames", "ranges",
2522 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2531 for (index
= 0; debug_dump_opt
[index
]; index
++)
2533 size_t len
= strlen (debug_dump_opt
[index
]);
2535 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2536 && (p
[len
] == ',' || p
[len
] == '\0'))
2545 do_debug_abbrevs
= 1;
2556 do_debug_pubnames
= 1;
2560 do_debug_aranges
= 1;
2565 do_debug_frames_interp
= 1;
2566 do_debug_frames
= 1;
2570 do_debug_macinfo
= 1;
2583 if (debug_dump_opt
[index
] == NULL
)
2585 warn (_("Unrecognized debug option '%s'\n"), p
);
2586 p
= strchr (p
, ',');
2596 #ifdef SUPPORT_DISASSEMBLY
2599 section
= strtoul (optarg
, & cp
, 0);
2600 if (! * cp
&& section
>= 0)
2602 request_dump (section
, DISASS_DUMP
);
2608 print_version (program_name
);
2618 /* xgettext:c-format */
2619 error (_("Invalid option '-%c'\n"), c
);
2626 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2627 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2628 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2632 warn (_("Nothing to do.\n"));
2638 get_elf_class (elf_class
)
2639 unsigned int elf_class
;
2641 static char buff
[32];
2645 case ELFCLASSNONE
: return _("none");
2646 case ELFCLASS32
: return "ELF32";
2647 case ELFCLASS64
: return "ELF64";
2649 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2655 get_data_encoding (encoding
)
2656 unsigned int encoding
;
2658 static char buff
[32];
2662 case ELFDATANONE
: return _("none");
2663 case ELFDATA2LSB
: return _("2's complement, little endian");
2664 case ELFDATA2MSB
: return _("2's complement, big endian");
2666 sprintf (buff
, _("<unknown: %x>"), encoding
);
2672 get_osabi_name (osabi
)
2675 static char buff
[32];
2679 case ELFOSABI_NONE
: return "UNIX - System V";
2680 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2681 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2682 case ELFOSABI_LINUX
: return "UNIX - Linux";
2683 case ELFOSABI_HURD
: return "GNU/Hurd";
2684 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2685 case ELFOSABI_AIX
: return "UNIX - AIX";
2686 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2687 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2688 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2689 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2690 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2691 case ELFOSABI_STANDALONE
: return _("Standalone App");
2692 case ELFOSABI_ARM
: return "ARM";
2694 sprintf (buff
, _("<unknown: %x>"), osabi
);
2699 /* Decode the data held in 'elf_header'. */
2701 process_file_header ()
2703 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2704 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2705 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2706 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2709 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2717 printf (_("ELF Header:\n"));
2718 printf (_(" Magic: "));
2719 for (i
= 0; i
< EI_NIDENT
; i
++)
2720 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2722 printf (_(" Class: %s\n"),
2723 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2724 printf (_(" Data: %s\n"),
2725 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2726 printf (_(" Version: %d %s\n"),
2727 elf_header
.e_ident
[EI_VERSION
],
2728 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2730 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2733 printf (_(" OS/ABI: %s\n"),
2734 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2735 printf (_(" ABI Version: %d\n"),
2736 elf_header
.e_ident
[EI_ABIVERSION
]);
2737 printf (_(" Type: %s\n"),
2738 get_file_type (elf_header
.e_type
));
2739 printf (_(" Machine: %s\n"),
2740 get_machine_name (elf_header
.e_machine
));
2741 printf (_(" Version: 0x%lx\n"),
2742 (unsigned long) elf_header
.e_version
);
2744 printf (_(" Entry point address: "));
2745 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2746 printf (_("\n Start of program headers: "));
2747 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2748 printf (_(" (bytes into file)\n Start of section headers: "));
2749 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2750 printf (_(" (bytes into file)\n"));
2752 printf (_(" Flags: 0x%lx%s\n"),
2753 (unsigned long) elf_header
.e_flags
,
2754 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2755 printf (_(" Size of this header: %ld (bytes)\n"),
2756 (long) elf_header
.e_ehsize
);
2757 printf (_(" Size of program headers: %ld (bytes)\n"),
2758 (long) elf_header
.e_phentsize
);
2759 printf (_(" Number of program headers: %ld\n"),
2760 (long) elf_header
.e_phnum
);
2761 printf (_(" Size of section headers: %ld (bytes)\n"),
2762 (long) elf_header
.e_shentsize
);
2763 printf (_(" Number of section headers: %ld"),
2764 (long) elf_header
.e_shnum
);
2765 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2766 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2767 putc ('\n', stdout
);
2768 printf (_(" Section header string table index: %ld"),
2769 (long) elf_header
.e_shstrndx
);
2770 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2771 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2772 putc ('\n', stdout
);
2775 if (section_headers
!= NULL
)
2777 if (elf_header
.e_shnum
== 0)
2778 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2779 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2780 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2781 free (section_headers
);
2782 section_headers
= NULL
;
2790 get_32bit_program_headers (file
, program_headers
)
2792 Elf_Internal_Phdr
* program_headers
;
2794 Elf32_External_Phdr
* phdrs
;
2795 Elf32_External_Phdr
* external
;
2796 Elf32_Internal_Phdr
* internal
;
2799 phdrs
= ((Elf32_External_Phdr
*)
2800 get_data (NULL
, file
, elf_header
.e_phoff
,
2801 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2802 _("program headers")));
2806 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2807 i
< elf_header
.e_phnum
;
2808 i
++, internal
++, external
++)
2810 internal
->p_type
= BYTE_GET (external
->p_type
);
2811 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2812 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2813 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2814 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2815 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2816 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2817 internal
->p_align
= BYTE_GET (external
->p_align
);
2826 get_64bit_program_headers (file
, program_headers
)
2828 Elf_Internal_Phdr
* program_headers
;
2830 Elf64_External_Phdr
* phdrs
;
2831 Elf64_External_Phdr
* external
;
2832 Elf64_Internal_Phdr
* internal
;
2835 phdrs
= ((Elf64_External_Phdr
*)
2836 get_data (NULL
, file
, elf_header
.e_phoff
,
2837 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2838 _("program headers")));
2842 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2843 i
< elf_header
.e_phnum
;
2844 i
++, internal
++, external
++)
2846 internal
->p_type
= BYTE_GET (external
->p_type
);
2847 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2848 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2849 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2850 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2851 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2852 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2853 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2862 process_program_headers (file
)
2865 Elf_Internal_Phdr
* program_headers
;
2866 Elf_Internal_Phdr
* segment
;
2869 if (elf_header
.e_phnum
== 0)
2872 printf (_("\nThere are no program headers in this file.\n"));
2876 if (do_segments
&& !do_header
)
2878 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2879 printf (_("Entry point "));
2880 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2881 printf (_("\nThere are %d program headers, starting at offset "),
2882 elf_header
.e_phnum
);
2883 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2887 program_headers
= (Elf_Internal_Phdr
*) malloc
2888 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2890 if (program_headers
== NULL
)
2892 error (_("Out of memory\n"));
2897 i
= get_32bit_program_headers (file
, program_headers
);
2899 i
= get_64bit_program_headers (file
, program_headers
);
2903 free (program_headers
);
2909 if (elf_header
.e_phnum
> 1)
2910 printf (_("\nProgram Headers:\n"));
2912 printf (_("\nProgram Headers:\n"));
2916 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2919 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2923 (_(" Type Offset VirtAddr PhysAddr\n"));
2925 (_(" FileSiz MemSiz Flags Align\n"));
2933 for (i
= 0, segment
= program_headers
;
2934 i
< elf_header
.e_phnum
;
2939 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2943 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2944 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2945 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2946 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2947 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2949 (segment
->p_flags
& PF_R
? 'R' : ' '),
2950 (segment
->p_flags
& PF_W
? 'W' : ' '),
2951 (segment
->p_flags
& PF_X
? 'E' : ' '));
2952 printf ("%#lx", (unsigned long) segment
->p_align
);
2956 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2957 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2960 print_vma (segment
->p_offset
, FULL_HEX
);
2964 print_vma (segment
->p_vaddr
, FULL_HEX
);
2966 print_vma (segment
->p_paddr
, FULL_HEX
);
2969 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
2970 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
2973 print_vma (segment
->p_filesz
, FULL_HEX
);
2977 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
2978 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
2981 print_vma (segment
->p_offset
, FULL_HEX
);
2985 (segment
->p_flags
& PF_R
? 'R' : ' '),
2986 (segment
->p_flags
& PF_W
? 'W' : ' '),
2987 (segment
->p_flags
& PF_X
? 'E' : ' '));
2989 if ((unsigned long) segment
->p_align
== segment
->p_align
)
2990 printf ("%#lx", (unsigned long) segment
->p_align
);
2993 print_vma (segment
->p_align
, PREFIX_HEX
);
2998 print_vma (segment
->p_offset
, FULL_HEX
);
3000 print_vma (segment
->p_vaddr
, FULL_HEX
);
3002 print_vma (segment
->p_paddr
, FULL_HEX
);
3004 print_vma (segment
->p_filesz
, FULL_HEX
);
3006 print_vma (segment
->p_memsz
, FULL_HEX
);
3008 (segment
->p_flags
& PF_R
? 'R' : ' '),
3009 (segment
->p_flags
& PF_W
? 'W' : ' '),
3010 (segment
->p_flags
& PF_X
? 'E' : ' '));
3011 print_vma (segment
->p_align
, HEX
);
3015 switch (segment
->p_type
)
3019 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
3020 - (segment
->p_offset
& 0xfffff000);
3025 error (_("more than one dynamic segment\n"));
3027 dynamic_addr
= segment
->p_offset
;
3028 dynamic_size
= segment
->p_filesz
;
3032 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
3033 error (_("Unable to find program interpreter name\n"));
3036 program_interpreter
[0] = 0;
3037 fscanf (file
, "%63s", program_interpreter
);
3040 printf (_("\n [Requesting program interpreter: %s]"),
3041 program_interpreter
);
3047 putc ('\n', stdout
);
3056 if (do_segments
&& section_headers
!= NULL
)
3058 printf (_("\n Section to Segment mapping:\n"));
3059 printf (_(" Segment Sections...\n"));
3061 assert (string_table
!= NULL
);
3063 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3066 Elf_Internal_Shdr
* section
;
3068 segment
= program_headers
+ i
;
3069 section
= section_headers
;
3071 printf (" %2.2d ", i
);
3073 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3075 if (section
->sh_size
> 0
3076 /* Compare allocated sections by VMA, unallocated
3077 sections by file offset. */
3078 && (section
->sh_flags
& SHF_ALLOC
3079 ? (section
->sh_addr
>= segment
->p_vaddr
3080 && section
->sh_addr
+ section
->sh_size
3081 <= segment
->p_vaddr
+ segment
->p_memsz
)
3082 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3083 && (section
->sh_offset
+ section
->sh_size
3084 <= segment
->p_offset
+ segment
->p_filesz
))))
3085 printf ("%s ", SECTION_NAME (section
));
3092 free (program_headers
);
3099 get_32bit_section_headers (file
, num
)
3103 Elf32_External_Shdr
* shdrs
;
3104 Elf32_Internal_Shdr
* internal
;
3107 shdrs
= ((Elf32_External_Shdr
*)
3108 get_data (NULL
, file
, elf_header
.e_shoff
,
3109 elf_header
.e_shentsize
* num
,
3110 _("section headers")));
3114 section_headers
= ((Elf_Internal_Shdr
*)
3115 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3117 if (section_headers
== NULL
)
3119 error (_("Out of memory\n"));
3123 for (i
= 0, internal
= section_headers
;
3127 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3128 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3129 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3130 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3131 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3132 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3133 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3134 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3135 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3136 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3145 get_64bit_section_headers (file
, num
)
3149 Elf64_External_Shdr
* shdrs
;
3150 Elf64_Internal_Shdr
* internal
;
3153 shdrs
= ((Elf64_External_Shdr
*)
3154 get_data (NULL
, file
, elf_header
.e_shoff
,
3155 elf_header
.e_shentsize
* num
,
3156 _("section headers")));
3160 section_headers
= ((Elf_Internal_Shdr
*)
3161 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3163 if (section_headers
== NULL
)
3165 error (_("Out of memory\n"));
3169 for (i
= 0, internal
= section_headers
;
3173 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3174 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3175 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3176 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3177 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3178 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3179 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3180 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3181 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3182 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3190 static Elf_Internal_Sym
*
3191 get_32bit_elf_symbols (file
, section
)
3193 Elf_Internal_Shdr
*section
;
3195 unsigned long number
;
3196 Elf32_External_Sym
* esyms
;
3197 Elf_External_Sym_Shndx
*shndx
;
3198 Elf_Internal_Sym
* isyms
;
3199 Elf_Internal_Sym
* psym
;
3202 esyms
= ((Elf32_External_Sym
*)
3203 get_data (NULL
, file
, section
->sh_offset
,
3204 section
->sh_size
, _("symbols")));
3209 if (symtab_shndx_hdr
!= NULL
3210 && (symtab_shndx_hdr
->sh_link
3211 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3213 shndx
= ((Elf_External_Sym_Shndx
*)
3214 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3215 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3223 number
= section
->sh_size
/ section
->sh_entsize
;
3224 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3228 error (_("Out of memory\n"));
3235 for (j
= 0, psym
= isyms
;
3239 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3240 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3241 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3242 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3243 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3245 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3246 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3247 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3257 static Elf_Internal_Sym
*
3258 get_64bit_elf_symbols (file
, section
)
3260 Elf_Internal_Shdr
*section
;
3262 unsigned long number
;
3263 Elf64_External_Sym
* esyms
;
3264 Elf_External_Sym_Shndx
*shndx
;
3265 Elf_Internal_Sym
* isyms
;
3266 Elf_Internal_Sym
* psym
;
3269 esyms
= ((Elf64_External_Sym
*)
3270 get_data (NULL
, file
, section
->sh_offset
,
3271 section
->sh_size
, _("symbols")));
3276 if (symtab_shndx_hdr
!= NULL
3277 && (symtab_shndx_hdr
->sh_link
3278 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3280 shndx
= ((Elf_External_Sym_Shndx
*)
3281 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3282 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3290 number
= section
->sh_size
/ section
->sh_entsize
;
3291 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3295 error (_("Out of memory\n"));
3302 for (j
= 0, psym
= isyms
;
3306 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3307 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3308 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3309 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3310 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3312 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3313 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3314 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3325 get_elf_section_flags (sh_flags
)
3328 static char buff
[32];
3336 flag
= sh_flags
& - sh_flags
;
3341 case SHF_WRITE
: strcat (buff
, "W"); break;
3342 case SHF_ALLOC
: strcat (buff
, "A"); break;
3343 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3344 case SHF_MERGE
: strcat (buff
, "M"); break;
3345 case SHF_STRINGS
: strcat (buff
, "S"); break;
3346 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3347 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3348 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3349 case SHF_GROUP
: strcat (buff
, "G"); break;
3350 case SHF_TLS
: strcat (buff
, "T"); break;
3353 if (flag
& SHF_MASKOS
)
3356 sh_flags
&= ~ SHF_MASKOS
;
3358 else if (flag
& SHF_MASKPROC
)
3361 sh_flags
&= ~ SHF_MASKPROC
;
3373 process_section_headers (file
)
3376 Elf_Internal_Shdr
* section
;
3379 section_headers
= NULL
;
3381 if (elf_header
.e_shnum
== 0)
3384 printf (_("\nThere are no sections in this file.\n"));
3389 if (do_sections
&& !do_header
)
3390 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3391 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3395 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3398 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3401 /* Read in the string table, so that we have names to display. */
3402 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3404 if (section
->sh_size
!= 0)
3406 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3407 section
->sh_size
, _("string table"));
3409 string_table_length
= section
->sh_size
;
3412 /* Scan the sections for the dynamic symbol table
3413 and dynamic string table and debug sections. */
3414 dynamic_symbols
= NULL
;
3415 dynamic_strings
= NULL
;
3416 dynamic_syminfo
= NULL
;
3418 for (i
= 0, section
= section_headers
;
3419 i
< elf_header
.e_shnum
;
3422 char * name
= SECTION_NAME (section
);
3424 if (section
->sh_type
== SHT_DYNSYM
)
3426 if (dynamic_symbols
!= NULL
)
3428 error (_("File contains multiple dynamic symbol tables\n"));
3432 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3433 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3435 else if (section
->sh_type
== SHT_STRTAB
3436 && strcmp (name
, ".dynstr") == 0)
3438 if (dynamic_strings
!= NULL
)
3440 error (_("File contains multiple dynamic string tables\n"));
3444 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3446 _("dynamic strings"));
3448 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3450 if (symtab_shndx_hdr
!= NULL
)
3452 error (_("File contains multiple symtab shndx tables\n"));
3455 symtab_shndx_hdr
= section
;
3457 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3458 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3459 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3461 && strncmp (name
, ".debug_", 7) == 0)
3466 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3467 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3468 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3469 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3470 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3471 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3472 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3473 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3474 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3476 request_dump (i
, DEBUG_DUMP
);
3478 /* linkonce section to be combined with .debug_info at link time. */
3479 else if ((do_debugging
|| do_debug_info
)
3480 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3481 request_dump (i
, DEBUG_DUMP
);
3482 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3483 request_dump (i
, DEBUG_DUMP
);
3489 if (elf_header
.e_shnum
> 1)
3490 printf (_("\nSection Headers:\n"));
3492 printf (_("\nSection Header:\n"));
3496 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3499 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3502 printf (_(" [Nr] Name Type Address Offset\n"));
3503 printf (_(" Size EntSize Flags Link Info Align\n"));
3506 for (i
= 0, section
= section_headers
;
3507 i
< elf_header
.e_shnum
;
3510 printf (" [%2u] %-17.17s %-15.15s ",
3511 SECTION_HEADER_NUM (i
),
3512 SECTION_NAME (section
),
3513 get_section_type_name (section
->sh_type
));
3517 print_vma (section
->sh_addr
, LONG_HEX
);
3519 printf ( " %6.6lx %6.6lx %2.2lx",
3520 (unsigned long) section
->sh_offset
,
3521 (unsigned long) section
->sh_size
,
3522 (unsigned long) section
->sh_entsize
);
3524 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3526 printf ("%2ld %3lx %2ld\n",
3527 (unsigned long) section
->sh_link
,
3528 (unsigned long) section
->sh_info
,
3529 (unsigned long) section
->sh_addralign
);
3533 print_vma (section
->sh_addr
, LONG_HEX
);
3535 if ((long) section
->sh_offset
== section
->sh_offset
)
3536 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3540 print_vma (section
->sh_offset
, LONG_HEX
);
3543 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3544 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3548 print_vma (section
->sh_size
, LONG_HEX
);
3551 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3552 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3556 print_vma (section
->sh_entsize
, LONG_HEX
);
3559 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3561 printf ("%2ld %3lx ",
3562 (unsigned long) section
->sh_link
,
3563 (unsigned long) section
->sh_info
);
3565 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3566 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3569 print_vma (section
->sh_addralign
, DEC
);
3576 print_vma (section
->sh_addr
, LONG_HEX
);
3577 if ((long) section
->sh_offset
== section
->sh_offset
)
3578 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3582 print_vma (section
->sh_offset
, LONG_HEX
);
3585 print_vma (section
->sh_size
, LONG_HEX
);
3587 print_vma (section
->sh_entsize
, LONG_HEX
);
3589 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3591 printf (" %2ld %3lx %ld\n",
3592 (unsigned long) section
->sh_link
,
3593 (unsigned long) section
->sh_info
,
3594 (unsigned long) section
->sh_addralign
);
3598 printf (_("Key to Flags:\n\
3599 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3600 I (info), L (link order), G (group), x (unknown)\n\
3601 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3606 /* Process the reloc section. */
3608 process_relocs (file
)
3611 unsigned long rel_size
;
3612 unsigned long rel_offset
;
3618 if (do_using_dynamic
)
3620 int is_rela
= FALSE
;
3625 if (dynamic_info
[DT_REL
])
3627 rel_offset
= dynamic_info
[DT_REL
];
3628 rel_size
= dynamic_info
[DT_RELSZ
];
3631 else if (dynamic_info
[DT_RELA
])
3633 rel_offset
= dynamic_info
[DT_RELA
];
3634 rel_size
= dynamic_info
[DT_RELASZ
];
3637 else if (dynamic_info
[DT_JMPREL
])
3639 rel_offset
= dynamic_info
[DT_JMPREL
];
3640 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3642 switch (dynamic_info
[DT_PLTREL
])
3659 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3660 rel_offset
, rel_size
);
3662 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3663 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3666 printf (_("\nThere are no dynamic relocations in this file.\n"));
3670 Elf32_Internal_Shdr
* section
;
3674 for (i
= 0, section
= section_headers
;
3675 i
< elf_header
.e_shnum
;
3678 if ( section
->sh_type
!= SHT_RELA
3679 && section
->sh_type
!= SHT_REL
)
3682 rel_offset
= section
->sh_offset
;
3683 rel_size
= section
->sh_size
;
3687 Elf32_Internal_Shdr
* strsec
;
3688 Elf_Internal_Sym
* symtab
;
3691 unsigned long nsyms
;
3693 printf (_("\nRelocation section "));
3695 if (string_table
== NULL
)
3696 printf ("%d", section
->sh_name
);
3698 printf (_("'%s'"), SECTION_NAME (section
));
3700 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3701 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3706 if (section
->sh_link
)
3708 Elf32_Internal_Shdr
* symsec
;
3710 symsec
= SECTION_HEADER (section
->sh_link
);
3711 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3712 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3717 strsec
= SECTION_HEADER (symsec
->sh_link
);
3719 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3723 is_rela
= section
->sh_type
== SHT_RELA
;
3725 dump_relocations (file
, rel_offset
, rel_size
,
3726 symtab
, nsyms
, strtab
, is_rela
);
3738 printf (_("\nThere are no relocations in this file.\n"));
3744 #include "unwind-ia64.h"
3746 /* An absolute address consists of a section and an offset. If the
3747 section is NULL, the offset itself is the address, otherwise, the
3748 address equals to LOAD_ADDRESS(section) + offset. */
3752 unsigned short section
;
3758 struct unw_table_entry
3760 struct absaddr start
;
3762 struct absaddr info
;
3764 *table
; /* Unwind table. */
3765 unsigned long table_len
; /* Length of unwind table. */
3766 unsigned char * info
; /* Unwind info. */
3767 unsigned long info_size
; /* Size of unwind info. */
3768 bfd_vma info_addr
; /* starting address of unwind info. */
3769 bfd_vma seg_base
; /* Starting address of segment. */
3770 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3771 unsigned long nsyms
; /* Number of symbols. */
3772 char * strtab
; /* The string table. */
3773 unsigned long strtab_size
; /* Size of string table. */
3776 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3777 struct absaddr
, const char **,
3779 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3780 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3781 Elf32_Internal_Shdr
*));
3784 find_symbol_for_address (aux
, addr
, symname
, offset
)
3785 struct unw_aux_info
*aux
;
3786 struct absaddr addr
;
3787 const char **symname
;
3790 bfd_vma dist
= (bfd_vma
) 0x100000;
3791 Elf_Internal_Sym
*sym
, *best
= NULL
;
3794 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3796 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3797 && sym
->st_name
!= 0
3798 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3799 && addr
.offset
>= sym
->st_value
3800 && addr
.offset
- sym
->st_value
< dist
)
3803 dist
= addr
.offset
- sym
->st_value
;
3810 *symname
= (best
->st_name
>= aux
->strtab_size
3811 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3816 *offset
= addr
.offset
;
3820 dump_ia64_unwind (aux
)
3821 struct unw_aux_info
*aux
;
3824 struct unw_table_entry
* tp
;
3827 addr_size
= is_32bit_elf
? 4 : 8;
3829 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3833 const unsigned char * dp
;
3834 const unsigned char * head
;
3835 const char * procname
;
3837 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3839 fputs ("\n<", stdout
);
3843 fputs (procname
, stdout
);
3846 printf ("+%lx", (unsigned long) offset
);
3849 fputs (">: [", stdout
);
3850 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3851 fputc ('-', stdout
);
3852 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3853 printf ("), info at +0x%lx\n",
3854 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3856 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3857 stamp
= BYTE_GET8 ((unsigned char *) head
);
3859 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3860 (unsigned) UNW_VER (stamp
),
3861 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3862 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3863 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3864 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3866 if (UNW_VER (stamp
) != 1)
3868 printf ("\tUnknown version.\n");
3873 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3874 dp
= unw_decode (dp
, in_body
, & in_body
);
3879 slurp_ia64_unwind_table (file
, aux
, sec
)
3881 struct unw_aux_info
*aux
;
3882 Elf32_Internal_Shdr
*sec
;
3884 unsigned long size
, addr_size
, nrelas
, i
;
3885 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3886 struct unw_table_entry
*tep
;
3887 Elf32_Internal_Shdr
*relsec
;
3888 Elf_Internal_Rela
*rela
, *rp
;
3889 unsigned char *table
, *tp
;
3890 Elf_Internal_Sym
*sym
;
3891 const char *relname
;
3894 addr_size
= is_32bit_elf
? 4 : 8;
3896 /* First, find the starting address of the segment that includes
3899 if (elf_header
.e_phnum
)
3901 prog_hdrs
= (Elf_Internal_Phdr
*)
3902 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3905 result
= get_32bit_program_headers (file
, prog_hdrs
);
3907 result
= get_64bit_program_headers (file
, prog_hdrs
);
3915 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3917 if (seg
->p_type
!= PT_LOAD
)
3920 if (sec
->sh_addr
>= seg
->p_vaddr
3921 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3923 aux
->seg_base
= seg
->p_vaddr
;
3931 /* Second, build the unwind table from the contents of the unwind section: */
3932 size
= sec
->sh_size
;
3933 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3934 size
, _("unwind table"));
3938 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3939 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3941 tep
->start
.section
= SHN_UNDEF
;
3942 tep
->end
.section
= SHN_UNDEF
;
3943 tep
->info
.section
= SHN_UNDEF
;
3946 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3947 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3948 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3952 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3953 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3954 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3956 tep
->start
.offset
+= aux
->seg_base
;
3957 tep
->end
.offset
+= aux
->seg_base
;
3958 tep
->info
.offset
+= aux
->seg_base
;
3962 /* Third, apply any relocations to the unwind table: */
3964 for (relsec
= section_headers
;
3965 relsec
< section_headers
+ elf_header
.e_shnum
;
3968 if (relsec
->sh_type
!= SHT_RELA
3969 || SECTION_HEADER (relsec
->sh_info
) != sec
)
3972 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3976 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3980 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3981 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3983 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3985 warn (_("Skipping unexpected symbol type %u\n"),
3986 ELF32_ST_TYPE (sym
->st_info
));
3992 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3993 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3995 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3997 warn (_("Skipping unexpected symbol type %u\n"),
3998 ELF64_ST_TYPE (sym
->st_info
));
4003 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4005 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4009 i
= rp
->r_offset
/ (3 * addr_size
);
4011 switch (rp
->r_offset
/addr_size
% 3)
4014 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4015 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4018 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4019 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4022 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4023 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4033 aux
->table_len
= size
/ (3 * addr_size
);
4038 process_unwind (file
)
4041 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4042 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4043 struct unw_aux_info aux
;
4048 if (elf_header
.e_machine
!= EM_IA_64
)
4050 printf (_("\nThere are no unwind sections in this file.\n"));
4054 memset (& aux
, 0, sizeof (aux
));
4056 addr_size
= is_32bit_elf
? 4 : 8;
4058 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4060 if (sec
->sh_type
== SHT_SYMTAB
)
4062 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4063 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4065 strsec
= SECTION_HEADER (sec
->sh_link
);
4066 aux
.strtab_size
= strsec
->sh_size
;
4067 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4068 aux
.strtab_size
, _("string table"));
4070 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4075 printf (_("\nThere are no unwind sections in this file.\n"));
4077 while (unwcount
-- > 0)
4082 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4083 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4084 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4091 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4093 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
4096 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4097 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4098 suffix
= SECTION_NAME (unwsec
) + len
;
4099 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4101 if (strncmp (SECTION_NAME (sec
),
4102 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4103 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4108 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4109 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4110 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4111 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4113 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4115 suffix
= SECTION_NAME (unwsec
) + len
;
4116 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4118 if (strncmp (SECTION_NAME (sec
),
4119 ELF_STRING_ia64_unwind_info
, len2
) == 0
4120 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4124 if (i
== elf_header
.e_shnum
)
4126 printf (_("\nCould not find unwind info section for "));
4128 if (string_table
== NULL
)
4129 printf ("%d", unwsec
->sh_name
);
4131 printf (_("'%s'"), SECTION_NAME (unwsec
));
4135 aux
.info_size
= sec
->sh_size
;
4136 aux
.info_addr
= sec
->sh_addr
;
4137 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4138 aux
.info_size
, _("unwind info"));
4140 printf (_("\nUnwind section "));
4142 if (string_table
== NULL
)
4143 printf ("%d", unwsec
->sh_name
);
4145 printf (_("'%s'"), SECTION_NAME (unwsec
));
4147 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4148 (unsigned long) unwsec
->sh_offset
,
4149 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4151 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4153 if (aux
.table_len
> 0)
4154 dump_ia64_unwind (& aux
);
4157 free ((char *) aux
.table
);
4159 free ((char *) aux
.info
);
4168 free ((char *) aux
.strtab
);
4174 dynamic_segment_mips_val (entry
)
4175 Elf_Internal_Dyn
* entry
;
4177 switch (entry
->d_tag
)
4180 if (entry
->d_un
.d_val
== 0)
4184 static const char * opts
[] =
4186 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4187 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4188 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4189 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4194 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
4195 if (entry
->d_un
.d_val
& (1 << cnt
))
4197 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4204 case DT_MIPS_IVERSION
:
4205 if (dynamic_strings
!= NULL
)
4206 printf ("Interface Version: %s\n",
4207 dynamic_strings
+ entry
->d_un
.d_val
);
4209 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4212 case DT_MIPS_TIME_STAMP
:
4217 time_t time
= entry
->d_un
.d_val
;
4218 tmp
= gmtime (&time
);
4219 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4220 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4221 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4222 printf ("Time Stamp: %s\n", timebuf
);
4226 case DT_MIPS_RLD_VERSION
:
4227 case DT_MIPS_LOCAL_GOTNO
:
4228 case DT_MIPS_CONFLICTNO
:
4229 case DT_MIPS_LIBLISTNO
:
4230 case DT_MIPS_SYMTABNO
:
4231 case DT_MIPS_UNREFEXTNO
:
4232 case DT_MIPS_HIPAGENO
:
4233 case DT_MIPS_DELTA_CLASS_NO
:
4234 case DT_MIPS_DELTA_INSTANCE_NO
:
4235 case DT_MIPS_DELTA_RELOC_NO
:
4236 case DT_MIPS_DELTA_SYM_NO
:
4237 case DT_MIPS_DELTA_CLASSSYM_NO
:
4238 case DT_MIPS_COMPACT_SIZE
:
4239 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4243 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4249 dynamic_segment_parisc_val (entry
)
4250 Elf_Internal_Dyn
* entry
;
4252 switch (entry
->d_tag
)
4254 case DT_HP_DLD_FLAGS
:
4263 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4264 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4265 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4266 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4267 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4268 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4269 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4270 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4271 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4272 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4273 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4277 bfd_vma val
= entry
->d_un
.d_val
;
4279 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4280 if (val
& flags
[cnt
].bit
)
4284 fputs (flags
[cnt
].str
, stdout
);
4286 val
^= flags
[cnt
].bit
;
4289 if (val
!= 0 || first
)
4293 print_vma (val
, HEX
);
4299 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4306 get_32bit_dynamic_segment (file
)
4309 Elf32_External_Dyn
* edyn
;
4310 Elf_Internal_Dyn
* entry
;
4313 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4314 dynamic_size
, _("dynamic segment"));
4318 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4319 how large this .dynamic is now. We can do this even before the byte
4320 swapping since the DT_NULL tag is recognizable. */
4322 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4325 dynamic_segment
= (Elf_Internal_Dyn
*)
4326 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4328 if (dynamic_segment
== NULL
)
4330 error (_("Out of memory\n"));
4335 for (i
= 0, entry
= dynamic_segment
;
4339 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4340 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4349 get_64bit_dynamic_segment (file
)
4352 Elf64_External_Dyn
* edyn
;
4353 Elf_Internal_Dyn
* entry
;
4356 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4357 dynamic_size
, _("dynamic segment"));
4361 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4362 how large this .dynamic is now. We can do this even before the byte
4363 swapping since the DT_NULL tag is recognizable. */
4365 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4368 dynamic_segment
= (Elf_Internal_Dyn
*)
4369 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4371 if (dynamic_segment
== NULL
)
4373 error (_("Out of memory\n"));
4378 for (i
= 0, entry
= dynamic_segment
;
4382 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4383 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4392 get_dynamic_flags (flags
)
4395 static char buff
[128];
4403 flag
= flags
& - flags
;
4411 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4412 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4413 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4414 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4415 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4416 default: strcpy (p
, "unknown"); break;
4419 p
= strchr (p
, '\0');
4424 /* Parse and display the contents of the dynamic segment. */
4426 process_dynamic_segment (file
)
4429 Elf_Internal_Dyn
* entry
;
4432 if (dynamic_size
== 0)
4435 printf (_("\nThere is no dynamic segment in this file.\n"));
4442 if (! get_32bit_dynamic_segment (file
))
4445 else if (! get_64bit_dynamic_segment (file
))
4448 /* Find the appropriate symbol table. */
4449 if (dynamic_symbols
== NULL
)
4451 for (i
= 0, entry
= dynamic_segment
;
4455 Elf32_Internal_Shdr section
;
4457 if (entry
->d_tag
!= DT_SYMTAB
)
4460 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4462 /* Since we do not know how big the symbol table is,
4463 we default to reading in the entire file (!) and
4464 processing that. This is overkill, I know, but it
4466 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4468 if (fseek (file
, 0, SEEK_END
))
4469 error (_("Unable to seek to end of file!"));
4471 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4473 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4475 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4477 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4478 if (num_dynamic_syms
< 1)
4480 error (_("Unable to determine the number of symbols to load\n"));
4484 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4488 /* Similarly find a string table. */
4489 if (dynamic_strings
== NULL
)
4491 for (i
= 0, entry
= dynamic_segment
;
4495 unsigned long offset
;
4498 if (entry
->d_tag
!= DT_STRTAB
)
4501 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4503 /* Since we do not know how big the string table is,
4504 we default to reading in the entire file (!) and
4505 processing that. This is overkill, I know, but it
4508 offset
= entry
->d_un
.d_val
- loadaddr
;
4509 if (fseek (file
, 0, SEEK_END
))
4510 error (_("Unable to seek to end of file\n"));
4511 str_tab_len
= ftell (file
) - offset
;
4513 if (str_tab_len
< 1)
4516 (_("Unable to determine the length of the dynamic string table\n"));
4520 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4521 _("dynamic string table"));
4526 /* And find the syminfo section if available. */
4527 if (dynamic_syminfo
== NULL
)
4529 unsigned int syminsz
= 0;
4531 for (i
= 0, entry
= dynamic_segment
;
4535 if (entry
->d_tag
== DT_SYMINENT
)
4537 /* Note: these braces are necessary to avoid a syntax
4538 error from the SunOS4 C compiler. */
4539 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4541 else if (entry
->d_tag
== DT_SYMINSZ
)
4542 syminsz
= entry
->d_un
.d_val
;
4543 else if (entry
->d_tag
== DT_SYMINFO
)
4544 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4547 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4549 Elf_External_Syminfo
* extsyminfo
;
4550 Elf_Internal_Syminfo
* syminfo
;
4552 /* There is a syminfo section. Read the data. */
4553 extsyminfo
= ((Elf_External_Syminfo
*)
4554 get_data (NULL
, file
, dynamic_syminfo_offset
,
4555 syminsz
, _("symbol information")));
4559 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4560 if (dynamic_syminfo
== NULL
)
4562 error (_("Out of memory\n"));
4566 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4567 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4570 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4571 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4578 if (do_dynamic
&& dynamic_addr
)
4579 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4580 dynamic_addr
, (long) dynamic_size
);
4582 printf (_(" Tag Type Name/Value\n"));
4584 for (i
= 0, entry
= dynamic_segment
;
4593 print_vma (entry
->d_tag
, FULL_HEX
);
4594 dtype
= get_dynamic_type (entry
->d_tag
);
4595 printf (" (%s)%*s", dtype
,
4596 ((is_32bit_elf
? 27 : 19)
4597 - (int) strlen (dtype
)),
4601 switch (entry
->d_tag
)
4605 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4615 switch (entry
->d_tag
)
4618 printf (_("Auxiliary library"));
4622 printf (_("Filter library"));
4626 printf (_("Configuration file"));
4630 printf (_("Dependency audit library"));
4634 printf (_("Audit library"));
4638 if (dynamic_strings
)
4639 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4643 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4652 printf (_("Flags:"));
4653 if (entry
->d_un
.d_val
== 0)
4654 printf (_(" None\n"));
4657 unsigned long int val
= entry
->d_un
.d_val
;
4658 if (val
& DTF_1_PARINIT
)
4660 printf (" PARINIT");
4661 val
^= DTF_1_PARINIT
;
4663 if (val
& DTF_1_CONFEXP
)
4665 printf (" CONFEXP");
4666 val
^= DTF_1_CONFEXP
;
4669 printf (" %lx", val
);
4678 printf (_("Flags:"));
4679 if (entry
->d_un
.d_val
== 0)
4680 printf (_(" None\n"));
4683 unsigned long int val
= entry
->d_un
.d_val
;
4684 if (val
& DF_P1_LAZYLOAD
)
4686 printf (" LAZYLOAD");
4687 val
^= DF_P1_LAZYLOAD
;
4689 if (val
& DF_P1_GROUPPERM
)
4691 printf (" GROUPPERM");
4692 val
^= DF_P1_GROUPPERM
;
4695 printf (" %lx", val
);
4704 printf (_("Flags:"));
4705 if (entry
->d_un
.d_val
== 0)
4706 printf (_(" None\n"));
4709 unsigned long int val
= entry
->d_un
.d_val
;
4715 if (val
& DF_1_GLOBAL
)
4720 if (val
& DF_1_GROUP
)
4725 if (val
& DF_1_NODELETE
)
4727 printf (" NODELETE");
4728 val
^= DF_1_NODELETE
;
4730 if (val
& DF_1_LOADFLTR
)
4732 printf (" LOADFLTR");
4733 val
^= DF_1_LOADFLTR
;
4735 if (val
& DF_1_INITFIRST
)
4737 printf (" INITFIRST");
4738 val
^= DF_1_INITFIRST
;
4740 if (val
& DF_1_NOOPEN
)
4745 if (val
& DF_1_ORIGIN
)
4750 if (val
& DF_1_DIRECT
)
4755 if (val
& DF_1_TRANS
)
4760 if (val
& DF_1_INTERPOSE
)
4762 printf (" INTERPOSE");
4763 val
^= DF_1_INTERPOSE
;
4765 if (val
& DF_1_NODEFLIB
)
4767 printf (" NODEFLIB");
4768 val
^= DF_1_NODEFLIB
;
4770 if (val
& DF_1_NODUMP
)
4775 if (val
& DF_1_CONLFAT
)
4777 printf (" CONLFAT");
4778 val
^= DF_1_CONLFAT
;
4781 printf (" %lx", val
);
4789 puts (get_dynamic_type (entry
->d_un
.d_val
));
4809 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4815 if (dynamic_strings
== NULL
)
4818 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4822 switch (entry
->d_tag
)
4825 printf (_("Shared library: [%s]"), name
);
4827 if (strcmp (name
, program_interpreter
) == 0)
4828 printf (_(" program interpreter"));
4832 printf (_("Library soname: [%s]"), name
);
4836 printf (_("Library rpath: [%s]"), name
);
4840 printf (_("Library runpath: [%s]"), name
);
4844 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4849 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4865 case DT_INIT_ARRAYSZ
:
4866 case DT_FINI_ARRAYSZ
:
4867 case DT_GNU_CONFLICTSZ
:
4868 case DT_GNU_LIBLISTSZ
:
4871 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4872 printf (" (bytes)\n");
4882 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4895 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4899 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4903 printf (_("Not needed object: [%s]\n"), name
);
4908 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4914 /* The value of this entry is ignored. */
4919 case DT_GNU_PRELINKED
:
4923 time_t time
= entry
->d_un
.d_val
;
4925 tmp
= gmtime (&time
);
4926 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
4927 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4928 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4934 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4935 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4940 switch (elf_header
.e_machine
)
4943 case EM_MIPS_RS3_LE
:
4944 dynamic_segment_mips_val (entry
);
4947 dynamic_segment_parisc_val (entry
);
4950 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4962 get_ver_flags (flags
)
4965 static char buff
[32];
4972 if (flags
& VER_FLG_BASE
)
4973 strcat (buff
, "BASE ");
4975 if (flags
& VER_FLG_WEAK
)
4977 if (flags
& VER_FLG_BASE
)
4978 strcat (buff
, "| ");
4980 strcat (buff
, "WEAK ");
4983 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4984 strcat (buff
, "| <unknown>");
4989 /* Display the contents of the version sections. */
4991 process_version_sections (file
)
4994 Elf32_Internal_Shdr
* section
;
5001 for (i
= 0, section
= section_headers
;
5002 i
< elf_header
.e_shnum
;
5005 switch (section
->sh_type
)
5007 case SHT_GNU_verdef
:
5009 Elf_External_Verdef
* edefs
;
5016 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5017 SECTION_NAME (section
), section
->sh_info
);
5019 printf (_(" Addr: 0x"));
5020 printf_vma (section
->sh_addr
);
5021 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5022 (unsigned long) section
->sh_offset
, section
->sh_link
,
5023 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5025 edefs
= ((Elf_External_Verdef
*)
5026 get_data (NULL
, file
, section
->sh_offset
,
5028 _("version definition section")));
5032 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
5035 Elf_External_Verdef
* edef
;
5036 Elf_Internal_Verdef ent
;
5037 Elf_External_Verdaux
* eaux
;
5038 Elf_Internal_Verdaux aux
;
5042 vstart
= ((char *) edefs
) + idx
;
5044 edef
= (Elf_External_Verdef
*) vstart
;
5046 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5047 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5048 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5049 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5050 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5051 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5052 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5054 printf (_(" %#06x: Rev: %d Flags: %s"),
5055 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5057 printf (_(" Index: %d Cnt: %d "),
5058 ent
.vd_ndx
, ent
.vd_cnt
);
5060 vstart
+= ent
.vd_aux
;
5062 eaux
= (Elf_External_Verdaux
*) vstart
;
5064 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5065 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5067 if (dynamic_strings
)
5068 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5070 printf (_("Name index: %ld\n"), aux
.vda_name
);
5072 isum
= idx
+ ent
.vd_aux
;
5074 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5076 isum
+= aux
.vda_next
;
5077 vstart
+= aux
.vda_next
;
5079 eaux
= (Elf_External_Verdaux
*) vstart
;
5081 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5082 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5084 if (dynamic_strings
)
5085 printf (_(" %#06x: Parent %d: %s\n"),
5086 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5088 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5089 isum
, j
, aux
.vda_name
);
5099 case SHT_GNU_verneed
:
5101 Elf_External_Verneed
* eneed
;
5107 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5108 SECTION_NAME (section
), section
->sh_info
);
5110 printf (_(" Addr: 0x"));
5111 printf_vma (section
->sh_addr
);
5112 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5113 (unsigned long) section
->sh_offset
, section
->sh_link
,
5114 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5116 eneed
= ((Elf_External_Verneed
*)
5117 get_data (NULL
, file
, section
->sh_offset
,
5118 section
->sh_size
, _("version need section")));
5122 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5124 Elf_External_Verneed
* entry
;
5125 Elf_Internal_Verneed ent
;
5130 vstart
= ((char *) eneed
) + idx
;
5132 entry
= (Elf_External_Verneed
*) vstart
;
5134 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5135 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5136 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5137 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5138 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5140 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5142 if (dynamic_strings
)
5143 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5145 printf (_(" File: %lx"), ent
.vn_file
);
5147 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5149 vstart
+= ent
.vn_aux
;
5151 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5153 Elf_External_Vernaux
* eaux
;
5154 Elf_Internal_Vernaux aux
;
5156 eaux
= (Elf_External_Vernaux
*) vstart
;
5158 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5159 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5160 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5161 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5162 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5164 if (dynamic_strings
)
5165 printf (_(" %#06x: Name: %s"),
5166 isum
, dynamic_strings
+ aux
.vna_name
);
5168 printf (_(" %#06x: Name index: %lx"),
5169 isum
, aux
.vna_name
);
5171 printf (_(" Flags: %s Version: %d\n"),
5172 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5174 isum
+= aux
.vna_next
;
5175 vstart
+= aux
.vna_next
;
5185 case SHT_GNU_versym
:
5187 Elf32_Internal_Shdr
* link_section
;
5190 unsigned char * edata
;
5191 unsigned short * data
;
5193 Elf_Internal_Sym
* symbols
;
5194 Elf32_Internal_Shdr
* string_sec
;
5196 link_section
= SECTION_HEADER (section
->sh_link
);
5197 total
= section
->sh_size
/ section
->sh_entsize
;
5201 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5203 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5205 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5206 string_sec
->sh_size
,
5207 _("version string table"));
5211 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5212 SECTION_NAME (section
), total
);
5214 printf (_(" Addr: "));
5215 printf_vma (section
->sh_addr
);
5216 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5217 (unsigned long) section
->sh_offset
, section
->sh_link
,
5218 SECTION_NAME (link_section
));
5222 get_data (NULL
, file
,
5223 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5224 total
* sizeof (short), _("version symbol data")));
5231 data
= (unsigned short *) malloc (total
* sizeof (short));
5233 for (cnt
= total
; cnt
--;)
5234 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5239 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5242 int check_def
, check_need
;
5245 printf (" %03x:", cnt
);
5247 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5248 switch (data
[cnt
+ j
])
5251 fputs (_(" 0 (*local*) "), stdout
);
5255 fputs (_(" 1 (*global*) "), stdout
);
5259 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5260 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5264 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5267 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5274 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5276 Elf_Internal_Verneed ivn
;
5277 unsigned long offset
;
5279 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5284 Elf_Internal_Vernaux ivna
;
5285 Elf_External_Verneed evn
;
5286 Elf_External_Vernaux evna
;
5287 unsigned long a_off
;
5289 get_data (&evn
, file
, offset
, sizeof (evn
),
5292 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5293 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5295 a_off
= offset
+ ivn
.vn_aux
;
5299 get_data (&evna
, file
, a_off
, sizeof (evna
),
5300 _("version need aux (2)"));
5302 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5303 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5305 a_off
+= ivna
.vna_next
;
5307 while (ivna
.vna_other
!= data
[cnt
+ j
]
5308 && ivna
.vna_next
!= 0);
5310 if (ivna
.vna_other
== data
[cnt
+ j
])
5312 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5314 name
= strtab
+ ivna
.vna_name
;
5315 nn
+= printf ("(%s%-*s",
5317 12 - (int) strlen (name
),
5323 offset
+= ivn
.vn_next
;
5325 while (ivn
.vn_next
);
5328 if (check_def
&& data
[cnt
+ j
] != 0x8001
5329 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5331 Elf_Internal_Verdef ivd
;
5332 Elf_External_Verdef evd
;
5333 unsigned long offset
;
5335 offset
= version_info
5336 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
5340 get_data (&evd
, file
, offset
, sizeof (evd
),
5343 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5344 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5346 offset
+= ivd
.vd_next
;
5348 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5349 && ivd
.vd_next
!= 0);
5351 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5353 Elf_External_Verdaux evda
;
5354 Elf_Internal_Verdaux ivda
;
5356 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5358 get_data (&evda
, file
,
5359 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5360 sizeof (evda
), _("version def aux"));
5362 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5364 name
= strtab
+ ivda
.vda_name
;
5365 nn
+= printf ("(%s%-*s",
5367 12 - (int) strlen (name
),
5373 printf ("%*c", 18 - nn
, ' ');
5391 printf (_("\nNo version information found in this file.\n"));
5397 get_symbol_binding (binding
)
5398 unsigned int binding
;
5400 static char buff
[32];
5404 case STB_LOCAL
: return "LOCAL";
5405 case STB_GLOBAL
: return "GLOBAL";
5406 case STB_WEAK
: return "WEAK";
5408 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5409 sprintf (buff
, _("<processor specific>: %d"), binding
);
5410 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5411 sprintf (buff
, _("<OS specific>: %d"), binding
);
5413 sprintf (buff
, _("<unknown>: %d"), binding
);
5419 get_symbol_type (type
)
5422 static char buff
[32];
5426 case STT_NOTYPE
: return "NOTYPE";
5427 case STT_OBJECT
: return "OBJECT";
5428 case STT_FUNC
: return "FUNC";
5429 case STT_SECTION
: return "SECTION";
5430 case STT_FILE
: return "FILE";
5431 case STT_COMMON
: return "COMMON";
5432 case STT_TLS
: return "TLS";
5434 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5436 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5437 return "THUMB_FUNC";
5439 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5442 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5443 return "PARISC_MILLI";
5445 sprintf (buff
, _("<processor specific>: %d"), type
);
5447 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5449 if (elf_header
.e_machine
== EM_PARISC
)
5451 if (type
== STT_HP_OPAQUE
)
5453 if (type
== STT_HP_STUB
)
5457 sprintf (buff
, _("<OS specific>: %d"), type
);
5460 sprintf (buff
, _("<unknown>: %d"), type
);
5466 get_symbol_visibility (visibility
)
5467 unsigned int visibility
;
5471 case STV_DEFAULT
: return "DEFAULT";
5472 case STV_INTERNAL
: return "INTERNAL";
5473 case STV_HIDDEN
: return "HIDDEN";
5474 case STV_PROTECTED
: return "PROTECTED";
5480 get_symbol_index_type (type
)
5485 case SHN_UNDEF
: return "UND";
5486 case SHN_ABS
: return "ABS";
5487 case SHN_COMMON
: return "COM";
5489 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5491 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5493 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5497 static char buff
[32];
5499 sprintf (buff
, "%3d", type
);
5506 get_dynamic_data (file
, number
)
5508 unsigned int number
;
5510 unsigned char * e_data
;
5513 e_data
= (unsigned char *) malloc (number
* 4);
5517 error (_("Out of memory\n"));
5521 if (fread (e_data
, 4, number
, file
) != number
)
5523 error (_("Unable to read in dynamic data\n"));
5527 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5531 error (_("Out of memory\n"));
5537 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5544 /* Dump the symbol table. */
5546 process_symbol_table (file
)
5549 Elf32_Internal_Shdr
* section
;
5550 unsigned char nb
[4];
5551 unsigned char nc
[4];
5554 int * buckets
= NULL
;
5555 int * chains
= NULL
;
5557 if (! do_syms
&& !do_histogram
)
5560 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5563 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5565 error (_("Unable to seek to start of dynamic information"));
5569 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5571 error (_("Failed to read in number of buckets\n"));
5575 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5577 error (_("Failed to read in number of chains\n"));
5581 nbuckets
= byte_get (nb
, 4);
5582 nchains
= byte_get (nc
, 4);
5584 buckets
= get_dynamic_data (file
, nbuckets
);
5585 chains
= get_dynamic_data (file
, nchains
);
5587 if (buckets
== NULL
|| chains
== NULL
)
5592 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5597 printf (_("\nSymbol table for image:\n"));
5599 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5601 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5603 for (hn
= 0; hn
< nbuckets
; hn
++)
5608 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5610 Elf_Internal_Sym
* psym
;
5612 psym
= dynamic_symbols
+ si
;
5614 printf (" %3d %3d: ", si
, hn
);
5615 print_vma (psym
->st_value
, LONG_HEX
);
5617 print_vma (psym
->st_size
, DEC_5
);
5619 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5620 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5621 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5622 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5623 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5628 else if (do_syms
&& !do_using_dynamic
)
5632 for (i
= 0, section
= section_headers
;
5633 i
< elf_header
.e_shnum
;
5638 Elf_Internal_Sym
* symtab
;
5639 Elf_Internal_Sym
* psym
;
5642 if ( section
->sh_type
!= SHT_SYMTAB
5643 && section
->sh_type
!= SHT_DYNSYM
)
5646 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5647 SECTION_NAME (section
),
5648 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5650 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5652 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5654 symtab
= GET_ELF_SYMBOLS (file
, section
);
5658 if (section
->sh_link
== elf_header
.e_shstrndx
)
5659 strtab
= string_table
;
5662 Elf32_Internal_Shdr
* string_sec
;
5664 string_sec
= SECTION_HEADER (section
->sh_link
);
5666 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5667 string_sec
->sh_size
,
5671 for (si
= 0, psym
= symtab
;
5672 si
< section
->sh_size
/ section
->sh_entsize
;
5675 printf ("%6d: ", si
);
5676 print_vma (psym
->st_value
, LONG_HEX
);
5678 print_vma (psym
->st_size
, DEC_5
);
5679 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5680 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5681 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5682 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5683 print_symbol (25, strtab
+ psym
->st_name
);
5685 if (section
->sh_type
== SHT_DYNSYM
&&
5686 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5688 unsigned char data
[2];
5689 unsigned short vers_data
;
5690 unsigned long offset
;
5694 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5697 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5698 sizeof (data
), _("version data"));
5700 vers_data
= byte_get (data
, 2);
5702 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5705 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5707 if ((vers_data
& 0x8000) || vers_data
> 1)
5709 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5710 && (is_nobits
|| ! check_def
))
5712 Elf_External_Verneed evn
;
5713 Elf_Internal_Verneed ivn
;
5714 Elf_Internal_Vernaux ivna
;
5716 /* We must test both. */
5717 offset
= version_info
5718 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5722 unsigned long vna_off
;
5724 get_data (&evn
, file
, offset
, sizeof (evn
),
5727 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5728 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5730 vna_off
= offset
+ ivn
.vn_aux
;
5734 Elf_External_Vernaux evna
;
5736 get_data (&evna
, file
, vna_off
,
5738 _("version need aux (3)"));
5740 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5741 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5742 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5744 vna_off
+= ivna
.vna_next
;
5746 while (ivna
.vna_other
!= vers_data
5747 && ivna
.vna_next
!= 0);
5749 if (ivna
.vna_other
== vers_data
)
5752 offset
+= ivn
.vn_next
;
5754 while (ivn
.vn_next
!= 0);
5756 if (ivna
.vna_other
== vers_data
)
5759 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5762 else if (! is_nobits
)
5763 error (_("bad dynamic symbol"));
5770 if (vers_data
!= 0x8001
5771 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5773 Elf_Internal_Verdef ivd
;
5774 Elf_Internal_Verdaux ivda
;
5775 Elf_External_Verdaux evda
;
5776 unsigned long offset
;
5779 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5784 Elf_External_Verdef evd
;
5786 get_data (&evd
, file
, offset
, sizeof (evd
),
5789 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5790 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5791 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5793 offset
+= ivd
.vd_next
;
5795 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5796 && ivd
.vd_next
!= 0);
5798 offset
-= ivd
.vd_next
;
5799 offset
+= ivd
.vd_aux
;
5801 get_data (&evda
, file
, offset
, sizeof (evda
),
5802 _("version def aux"));
5804 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5806 if (psym
->st_name
!= ivda
.vda_name
)
5807 printf ((vers_data
& 0x8000)
5809 strtab
+ ivda
.vda_name
);
5819 if (strtab
!= string_table
)
5825 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5827 if (do_histogram
&& buckets
!= NULL
)
5834 int nzero_counts
= 0;
5837 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5839 printf (_(" Length Number %% of total Coverage\n"));
5841 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5842 if (lengths
== NULL
)
5844 error (_("Out of memory"));
5847 for (hn
= 0; hn
< nbuckets
; ++hn
)
5852 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5855 if (maxlength
< ++lengths
[hn
])
5860 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5863 error (_("Out of memory"));
5867 for (hn
= 0; hn
< nbuckets
; ++hn
)
5868 ++ counts
[lengths
[hn
]];
5872 printf (" 0 %-10d (%5.1f%%)\n",
5873 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5874 for (si
= 1; si
<= maxlength
; ++si
)
5876 nzero_counts
+= counts
[si
] * si
;
5877 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5878 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5879 (nzero_counts
* 100.0) / nsyms
);
5887 if (buckets
!= NULL
)
5897 process_syminfo (file
)
5898 FILE * file ATTRIBUTE_UNUSED
;
5902 if (dynamic_syminfo
== NULL
5904 /* No syminfo, this is ok. */
5907 /* There better should be a dynamic symbol section. */
5908 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5912 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5913 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5915 printf (_(" Num: Name BoundTo Flags\n"));
5916 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5918 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5920 printf ("%4d: ", i
);
5921 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5924 switch (dynamic_syminfo
[i
].si_boundto
)
5926 case SYMINFO_BT_SELF
:
5927 fputs ("SELF ", stdout
);
5929 case SYMINFO_BT_PARENT
:
5930 fputs ("PARENT ", stdout
);
5933 if (dynamic_syminfo
[i
].si_boundto
> 0
5934 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5936 print_symbol (10, dynamic_strings
5938 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5942 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5946 if (flags
& SYMINFO_FLG_DIRECT
)
5948 if (flags
& SYMINFO_FLG_PASSTHRU
)
5949 printf (" PASSTHRU");
5950 if (flags
& SYMINFO_FLG_COPY
)
5952 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5953 printf (" LAZYLOAD");
5961 #ifdef SUPPORT_DISASSEMBLY
5963 disassemble_section (section
, file
)
5964 Elf32_Internal_Shdr
* section
;
5967 printf (_("\nAssembly dump of section %s\n"),
5968 SECTION_NAME (section
));
5970 /* XXX -- to be done --- XXX */
5977 dump_section (section
, file
)
5978 Elf32_Internal_Shdr
* section
;
5981 bfd_size_type bytes
;
5983 unsigned char * data
;
5984 unsigned char * start
;
5986 bytes
= section
->sh_size
;
5990 printf (_("\nSection '%s' has no data to dump.\n"),
5991 SECTION_NAME (section
));
5995 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5997 addr
= section
->sh_addr
;
5999 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
6012 lbytes
= (bytes
> 16 ? 16 : bytes
);
6014 printf (" 0x%8.8lx ", (unsigned long) addr
);
6016 switch (elf_header
.e_ident
[EI_DATA
])
6020 for (j
= 15; j
>= 0; j
--)
6023 printf ("%2.2x", data
[j
]);
6033 for (j
= 0; j
< 16; j
++)
6036 printf ("%2.2x", data
[j
]);
6046 for (j
= 0; j
< lbytes
; j
++)
6049 if (k
>= ' ' && k
< 0x80)
6068 static unsigned long int
6069 read_leb128 (data
, length_return
, sign
)
6070 unsigned char * data
;
6071 int * length_return
;
6074 unsigned long int result
= 0;
6075 unsigned int num_read
= 0;
6084 result
|= (byte
& 0x7f) << shift
;
6089 while (byte
& 0x80);
6091 if (length_return
!= NULL
)
6092 * length_return
= num_read
;
6094 if (sign
&& (shift
< 32) && (byte
& 0x40))
6095 result
|= -1 << shift
;
6100 typedef struct State_Machine_Registers
6102 unsigned long address
;
6105 unsigned int column
;
6109 /* This variable hold the number of the last entry seen
6110 in the File Table. */
6111 unsigned int last_file_entry
;
6114 static SMR state_machine_regs
;
6117 reset_state_machine (is_stmt
)
6120 state_machine_regs
.address
= 0;
6121 state_machine_regs
.file
= 1;
6122 state_machine_regs
.line
= 1;
6123 state_machine_regs
.column
= 0;
6124 state_machine_regs
.is_stmt
= is_stmt
;
6125 state_machine_regs
.basic_block
= 0;
6126 state_machine_regs
.end_sequence
= 0;
6127 state_machine_regs
.last_file_entry
= 0;
6130 /* Handled an extend line op. Returns true if this is the end
6133 process_extended_line_op (data
, is_stmt
, pointer_size
)
6134 unsigned char * data
;
6138 unsigned char op_code
;
6141 unsigned char * name
;
6144 len
= read_leb128 (data
, & bytes_read
, 0);
6149 warn (_("badly formed extended line op encountered!\n"));
6154 op_code
= * data
++;
6156 printf (_(" Extended opcode %d: "), op_code
);
6160 case DW_LNE_end_sequence
:
6161 printf (_("End of Sequence\n\n"));
6162 reset_state_machine (is_stmt
);
6165 case DW_LNE_set_address
:
6166 adr
= byte_get (data
, pointer_size
);
6167 printf (_("set Address to 0x%lx\n"), adr
);
6168 state_machine_regs
.address
= adr
;
6171 case DW_LNE_define_file
:
6172 printf (_(" define new File Table entry\n"));
6173 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6175 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6177 data
+= strlen ((char *) data
) + 1;
6178 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6180 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6182 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6183 printf (_("%s\n\n"), name
);
6187 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6194 /* Size of pointers in the .debug_line section. This information is not
6195 really present in that section. It's obtained before dumping the debug
6196 sections by doing some pre-scan of the .debug_info section. */
6197 static int debug_line_pointer_size
= 4;
6200 display_debug_lines (section
, start
, file
)
6201 Elf32_Internal_Shdr
* section
;
6202 unsigned char * start
;
6203 FILE * file ATTRIBUTE_UNUSED
;
6205 DWARF2_External_LineInfo
* external
;
6206 DWARF2_Internal_LineInfo info
;
6207 unsigned char * standard_opcodes
;
6208 unsigned char * data
= start
;
6209 unsigned char * end
= start
+ section
->sh_size
;
6210 unsigned char * end_of_sequence
;
6213 printf (_("\nDump of debug contents of section %s:\n\n"),
6214 SECTION_NAME (section
));
6218 external
= (DWARF2_External_LineInfo
*) data
;
6220 /* Check the length of the block. */
6221 info
.li_length
= BYTE_GET (external
->li_length
);
6223 if (info
.li_length
== 0xffffffff)
6225 warn (_("64-bit DWARF line info is not supported yet.\n"));
6229 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6232 (_("The line info appears to be corrupt - the section is too small\n"));
6236 /* Check its version number. */
6237 info
.li_version
= BYTE_GET (external
->li_version
);
6238 if (info
.li_version
!= 2)
6240 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6244 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6245 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6246 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6247 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6248 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6249 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6251 /* Sign extend the line base field. */
6252 info
.li_line_base
<<= 24;
6253 info
.li_line_base
>>= 24;
6255 printf (_(" Length: %ld\n"), info
.li_length
);
6256 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6257 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6258 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6259 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6260 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6261 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6262 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6264 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6266 reset_state_machine (info
.li_default_is_stmt
);
6268 /* Display the contents of the Opcodes table. */
6269 standard_opcodes
= data
+ sizeof (* external
);
6271 printf (_("\n Opcodes:\n"));
6273 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6274 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6276 /* Display the contents of the Directory table. */
6277 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6280 printf (_("\n The Directory Table is empty.\n"));
6283 printf (_("\n The Directory Table:\n"));
6287 printf (_(" %s\n"), data
);
6289 data
+= strlen ((char *) data
) + 1;
6293 /* Skip the NUL at the end of the table. */
6296 /* Display the contents of the File Name table. */
6298 printf (_("\n The File Name Table is empty.\n"));
6301 printf (_("\n The File Name Table:\n"));
6302 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6306 unsigned char * name
;
6309 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6312 data
+= strlen ((char *) data
) + 1;
6314 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6316 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6318 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6320 printf (_("%s\n"), name
);
6324 /* Skip the NUL at the end of the table. */
6327 /* Now display the statements. */
6328 printf (_("\n Line Number Statements:\n"));
6331 while (data
< end_of_sequence
)
6333 unsigned char op_code
;
6337 op_code
= * data
++;
6339 if (op_code
>= info
.li_opcode_base
)
6341 op_code
-= info
.li_opcode_base
;
6342 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6343 state_machine_regs
.address
+= adv
;
6344 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6345 op_code
, adv
, state_machine_regs
.address
);
6346 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6347 state_machine_regs
.line
+= adv
;
6348 printf (_(" and Line by %d to %d\n"),
6349 adv
, state_machine_regs
.line
);
6351 else switch (op_code
)
6353 case DW_LNS_extended_op
:
6354 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6355 debug_line_pointer_size
);
6359 printf (_(" Copy\n"));
6362 case DW_LNS_advance_pc
:
6363 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6365 state_machine_regs
.address
+= adv
;
6366 printf (_(" Advance PC by %d to %lx\n"), adv
,
6367 state_machine_regs
.address
);
6370 case DW_LNS_advance_line
:
6371 adv
= read_leb128 (data
, & bytes_read
, 1);
6373 state_machine_regs
.line
+= adv
;
6374 printf (_(" Advance Line by %d to %d\n"), adv
,
6375 state_machine_regs
.line
);
6378 case DW_LNS_set_file
:
6379 adv
= read_leb128 (data
, & bytes_read
, 0);
6381 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6383 state_machine_regs
.file
= adv
;
6386 case DW_LNS_set_column
:
6387 adv
= read_leb128 (data
, & bytes_read
, 0);
6389 printf (_(" Set column to %d\n"), adv
);
6390 state_machine_regs
.column
= adv
;
6393 case DW_LNS_negate_stmt
:
6394 adv
= state_machine_regs
.is_stmt
;
6396 printf (_(" Set is_stmt to %d\n"), adv
);
6397 state_machine_regs
.is_stmt
= adv
;
6400 case DW_LNS_set_basic_block
:
6401 printf (_(" Set basic block\n"));
6402 state_machine_regs
.basic_block
= 1;
6405 case DW_LNS_const_add_pc
:
6406 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6407 * info
.li_min_insn_length
);
6408 state_machine_regs
.address
+= adv
;
6409 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6410 state_machine_regs
.address
);
6413 case DW_LNS_fixed_advance_pc
:
6414 adv
= byte_get (data
, 2);
6416 state_machine_regs
.address
+= adv
;
6417 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6418 adv
, state_machine_regs
.address
);
6421 case DW_LNS_set_prologue_end
:
6422 printf (_(" Set prologue_end to true\n"));
6425 case DW_LNS_set_epilogue_begin
:
6426 printf (_(" Set epilogue_begin to true\n"));
6429 case DW_LNS_set_isa
:
6430 adv
= read_leb128 (data
, & bytes_read
, 0);
6432 printf (_(" Set ISA to %d\n"), adv
);
6436 printf (_(" Unknown opcode %d with operands: "), op_code
);
6439 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6441 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6442 i
== 1 ? "" : ", ");
6457 display_debug_pubnames (section
, start
, file
)
6458 Elf32_Internal_Shdr
* section
;
6459 unsigned char * start
;
6460 FILE * file ATTRIBUTE_UNUSED
;
6462 DWARF2_External_PubNames
* external
;
6463 DWARF2_Internal_PubNames pubnames
;
6464 unsigned char * end
;
6466 end
= start
+ section
->sh_size
;
6468 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6472 unsigned char * data
;
6473 unsigned long offset
;
6475 external
= (DWARF2_External_PubNames
*) start
;
6477 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6478 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6479 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6480 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6482 data
= start
+ sizeof (* external
);
6483 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6485 if (pubnames
.pn_length
== 0xffffffff)
6487 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6491 if (pubnames
.pn_version
!= 2)
6493 static int warned
= 0;
6497 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6504 printf (_(" Length: %ld\n"),
6505 pubnames
.pn_length
);
6506 printf (_(" Version: %d\n"),
6507 pubnames
.pn_version
);
6508 printf (_(" Offset into .debug_info section: %ld\n"),
6509 pubnames
.pn_offset
);
6510 printf (_(" Size of area in .debug_info section: %ld\n"),
6513 printf (_("\n Offset\tName\n"));
6517 offset
= byte_get (data
, 4);
6522 printf (" %ld\t\t%s\n", offset
, data
);
6523 data
+= strlen ((char *) data
) + 1;
6526 while (offset
!= 0);
6539 case DW_TAG_padding
: return "DW_TAG_padding";
6540 case DW_TAG_array_type
: return "DW_TAG_array_type";
6541 case DW_TAG_class_type
: return "DW_TAG_class_type";
6542 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6543 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6544 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6545 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6546 case DW_TAG_label
: return "DW_TAG_label";
6547 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6548 case DW_TAG_member
: return "DW_TAG_member";
6549 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6550 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6551 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6552 case DW_TAG_string_type
: return "DW_TAG_string_type";
6553 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6554 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6555 case DW_TAG_typedef
: return "DW_TAG_typedef";
6556 case DW_TAG_union_type
: return "DW_TAG_union_type";
6557 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6558 case DW_TAG_variant
: return "DW_TAG_variant";
6559 case DW_TAG_common_block
: return "DW_TAG_common_block";
6560 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6561 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6562 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6563 case DW_TAG_module
: return "DW_TAG_module";
6564 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6565 case DW_TAG_set_type
: return "DW_TAG_set_type";
6566 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6567 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6568 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6569 case DW_TAG_base_type
: return "DW_TAG_base_type";
6570 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6571 case DW_TAG_const_type
: return "DW_TAG_const_type";
6572 case DW_TAG_constant
: return "DW_TAG_constant";
6573 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6574 case DW_TAG_file_type
: return "DW_TAG_file_type";
6575 case DW_TAG_friend
: return "DW_TAG_friend";
6576 case DW_TAG_namelist
: return "DW_TAG_namelist";
6577 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6578 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6579 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6580 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6581 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6582 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6583 case DW_TAG_try_block
: return "DW_TAG_try_block";
6584 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6585 case DW_TAG_variable
: return "DW_TAG_variable";
6586 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6587 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6588 case DW_TAG_format_label
: return "DW_TAG_format_label";
6589 case DW_TAG_function_template
: return "DW_TAG_function_template";
6590 case DW_TAG_class_template
: return "DW_TAG_class_template";
6591 /* DWARF 2.1 values. */
6592 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6593 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6594 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6595 case DW_TAG_namespace
: return "DW_TAG_namespace";
6596 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6597 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6598 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6599 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6602 static char buffer
[100];
6604 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6611 get_AT_name (attribute
)
6612 unsigned long attribute
;
6616 case DW_AT_sibling
: return "DW_AT_sibling";
6617 case DW_AT_location
: return "DW_AT_location";
6618 case DW_AT_name
: return "DW_AT_name";
6619 case DW_AT_ordering
: return "DW_AT_ordering";
6620 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6621 case DW_AT_byte_size
: return "DW_AT_byte_size";
6622 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6623 case DW_AT_bit_size
: return "DW_AT_bit_size";
6624 case DW_AT_element_list
: return "DW_AT_element_list";
6625 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6626 case DW_AT_low_pc
: return "DW_AT_low_pc";
6627 case DW_AT_high_pc
: return "DW_AT_high_pc";
6628 case DW_AT_language
: return "DW_AT_language";
6629 case DW_AT_member
: return "DW_AT_member";
6630 case DW_AT_discr
: return "DW_AT_discr";
6631 case DW_AT_discr_value
: return "DW_AT_discr_value";
6632 case DW_AT_visibility
: return "DW_AT_visibility";
6633 case DW_AT_import
: return "DW_AT_import";
6634 case DW_AT_string_length
: return "DW_AT_string_length";
6635 case DW_AT_common_reference
: return "DW_AT_common_reference";
6636 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6637 case DW_AT_const_value
: return "DW_AT_const_value";
6638 case DW_AT_containing_type
: return "DW_AT_containing_type";
6639 case DW_AT_default_value
: return "DW_AT_default_value";
6640 case DW_AT_inline
: return "DW_AT_inline";
6641 case DW_AT_is_optional
: return "DW_AT_is_optional";
6642 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6643 case DW_AT_producer
: return "DW_AT_producer";
6644 case DW_AT_prototyped
: return "DW_AT_prototyped";
6645 case DW_AT_return_addr
: return "DW_AT_return_addr";
6646 case DW_AT_start_scope
: return "DW_AT_start_scope";
6647 case DW_AT_stride_size
: return "DW_AT_stride_size";
6648 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6649 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6650 case DW_AT_accessibility
: return "DW_AT_accessibility";
6651 case DW_AT_address_class
: return "DW_AT_address_class";
6652 case DW_AT_artificial
: return "DW_AT_artificial";
6653 case DW_AT_base_types
: return "DW_AT_base_types";
6654 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6655 case DW_AT_count
: return "DW_AT_count";
6656 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6657 case DW_AT_decl_column
: return "DW_AT_decl_column";
6658 case DW_AT_decl_file
: return "DW_AT_decl_file";
6659 case DW_AT_decl_line
: return "DW_AT_decl_line";
6660 case DW_AT_declaration
: return "DW_AT_declaration";
6661 case DW_AT_discr_list
: return "DW_AT_discr_list";
6662 case DW_AT_encoding
: return "DW_AT_encoding";
6663 case DW_AT_external
: return "DW_AT_external";
6664 case DW_AT_frame_base
: return "DW_AT_frame_base";
6665 case DW_AT_friend
: return "DW_AT_friend";
6666 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6667 case DW_AT_macro_info
: return "DW_AT_macro_info";
6668 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6669 case DW_AT_priority
: return "DW_AT_priority";
6670 case DW_AT_segment
: return "DW_AT_segment";
6671 case DW_AT_specification
: return "DW_AT_specification";
6672 case DW_AT_static_link
: return "DW_AT_static_link";
6673 case DW_AT_type
: return "DW_AT_type";
6674 case DW_AT_use_location
: return "DW_AT_use_location";
6675 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6676 case DW_AT_virtuality
: return "DW_AT_virtuality";
6677 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6678 /* DWARF 2.1 values. */
6679 case DW_AT_allocated
: return "DW_AT_allocated";
6680 case DW_AT_associated
: return "DW_AT_associated";
6681 case DW_AT_data_location
: return "DW_AT_data_location";
6682 case DW_AT_stride
: return "DW_AT_stride";
6683 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6684 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6685 case DW_AT_extension
: return "DW_AT_extension";
6686 case DW_AT_ranges
: return "DW_AT_ranges";
6687 case DW_AT_trampoline
: return "DW_AT_trampoline";
6688 case DW_AT_call_column
: return "DW_AT_call_column";
6689 case DW_AT_call_file
: return "DW_AT_call_file";
6690 case DW_AT_call_line
: return "DW_AT_call_line";
6691 /* SGI/MIPS extensions. */
6692 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6693 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6694 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6695 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6696 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6697 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6698 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6699 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6700 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6701 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6702 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6703 /* GNU extensions. */
6704 case DW_AT_sf_names
: return "DW_AT_sf_names";
6705 case DW_AT_src_info
: return "DW_AT_src_info";
6706 case DW_AT_mac_info
: return "DW_AT_mac_info";
6707 case DW_AT_src_coords
: return "DW_AT_src_coords";
6708 case DW_AT_body_begin
: return "DW_AT_body_begin";
6709 case DW_AT_body_end
: return "DW_AT_body_end";
6710 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6713 static char buffer
[100];
6715 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6722 get_FORM_name (form
)
6727 case DW_FORM_addr
: return "DW_FORM_addr";
6728 case DW_FORM_block2
: return "DW_FORM_block2";
6729 case DW_FORM_block4
: return "DW_FORM_block4";
6730 case DW_FORM_data2
: return "DW_FORM_data2";
6731 case DW_FORM_data4
: return "DW_FORM_data4";
6732 case DW_FORM_data8
: return "DW_FORM_data8";
6733 case DW_FORM_string
: return "DW_FORM_string";
6734 case DW_FORM_block
: return "DW_FORM_block";
6735 case DW_FORM_block1
: return "DW_FORM_block1";
6736 case DW_FORM_data1
: return "DW_FORM_data1";
6737 case DW_FORM_flag
: return "DW_FORM_flag";
6738 case DW_FORM_sdata
: return "DW_FORM_sdata";
6739 case DW_FORM_strp
: return "DW_FORM_strp";
6740 case DW_FORM_udata
: return "DW_FORM_udata";
6741 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6742 case DW_FORM_ref1
: return "DW_FORM_ref1";
6743 case DW_FORM_ref2
: return "DW_FORM_ref2";
6744 case DW_FORM_ref4
: return "DW_FORM_ref4";
6745 case DW_FORM_ref8
: return "DW_FORM_ref8";
6746 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6747 case DW_FORM_indirect
: return "DW_FORM_indirect";
6750 static char buffer
[100];
6752 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6758 /* FIXME: There are better and more effiecint ways to handle
6759 these structures. For now though, I just want something that
6760 is simple to implement. */
6761 typedef struct abbrev_attr
6763 unsigned long attribute
;
6765 struct abbrev_attr
* next
;
6769 typedef struct abbrev_entry
6771 unsigned long entry
;
6774 struct abbrev_attr
* first_attr
;
6775 struct abbrev_attr
* last_attr
;
6776 struct abbrev_entry
* next
;
6780 static abbrev_entry
* first_abbrev
= NULL
;
6781 static abbrev_entry
* last_abbrev
= NULL
;
6784 free_abbrevs
PARAMS ((void))
6786 abbrev_entry
* abbrev
;
6788 for (abbrev
= first_abbrev
; abbrev
;)
6790 abbrev_entry
* next
= abbrev
->next
;
6793 for (attr
= abbrev
->first_attr
; attr
;)
6795 abbrev_attr
* next
= attr
->next
;
6805 last_abbrev
= first_abbrev
= NULL
;
6809 add_abbrev (number
, tag
, children
)
6810 unsigned long number
;
6814 abbrev_entry
* entry
;
6816 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6822 entry
->entry
= number
;
6824 entry
->children
= children
;
6825 entry
->first_attr
= NULL
;
6826 entry
->last_attr
= NULL
;
6829 if (first_abbrev
== NULL
)
6830 first_abbrev
= entry
;
6832 last_abbrev
->next
= entry
;
6834 last_abbrev
= entry
;
6838 add_abbrev_attr (attribute
, form
)
6839 unsigned long attribute
;
6844 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6850 attr
->attribute
= attribute
;
6854 if (last_abbrev
->first_attr
== NULL
)
6855 last_abbrev
->first_attr
= attr
;
6857 last_abbrev
->last_attr
->next
= attr
;
6859 last_abbrev
->last_attr
= attr
;
6862 /* Processes the (partial) contents of a .debug_abbrev section.
6863 Returns NULL if the end of the section was encountered.
6864 Returns the address after the last byte read if the end of
6865 an abbreviation set was found. */
6867 static unsigned char *
6868 process_abbrev_section (start
, end
)
6869 unsigned char * start
;
6870 unsigned char * end
;
6872 if (first_abbrev
!= NULL
)
6878 unsigned long entry
;
6880 unsigned long attribute
;
6883 entry
= read_leb128 (start
, & bytes_read
, 0);
6884 start
+= bytes_read
;
6886 /* A single zero is supposed to end the section according
6887 to the standard. If there's more, then signal that to
6890 return start
== end
? NULL
: start
;
6892 tag
= read_leb128 (start
, & bytes_read
, 0);
6893 start
+= bytes_read
;
6895 children
= * start
++;
6897 add_abbrev (entry
, tag
, children
);
6903 attribute
= read_leb128 (start
, & bytes_read
, 0);
6904 start
+= bytes_read
;
6906 form
= read_leb128 (start
, & bytes_read
, 0);
6907 start
+= bytes_read
;
6910 add_abbrev_attr (attribute
, form
);
6912 while (attribute
!= 0);
6920 display_debug_macinfo (section
, start
, file
)
6921 Elf32_Internal_Shdr
* section
;
6922 unsigned char * start
;
6923 FILE * file ATTRIBUTE_UNUSED
;
6925 unsigned char * end
= start
+ section
->sh_size
;
6926 unsigned char * curr
= start
;
6927 unsigned int bytes_read
;
6928 enum dwarf_macinfo_record_type op
;
6930 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6934 unsigned int lineno
;
6935 const char * string
;
6942 case DW_MACINFO_start_file
:
6944 unsigned int filenum
;
6946 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6948 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6951 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6955 case DW_MACINFO_end_file
:
6956 printf (_(" DW_MACINFO_end_file\n"));
6959 case DW_MACINFO_define
:
6960 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6963 curr
+= strlen (string
) + 1;
6964 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6967 case DW_MACINFO_undef
:
6968 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6971 curr
+= strlen (string
) + 1;
6972 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
6975 case DW_MACINFO_vendor_ext
:
6977 unsigned int constant
;
6979 constant
= read_leb128 (curr
, & bytes_read
, 0);
6982 curr
+= strlen (string
) + 1;
6983 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
6994 display_debug_abbrev (section
, start
, file
)
6995 Elf32_Internal_Shdr
* section
;
6996 unsigned char * start
;
6997 FILE * file ATTRIBUTE_UNUSED
;
6999 abbrev_entry
* entry
;
7000 unsigned char * end
= start
+ section
->sh_size
;
7002 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7006 start
= process_abbrev_section (start
, end
);
7008 if (first_abbrev
== NULL
)
7011 printf (_(" Number TAG\n"));
7013 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7017 printf (_(" %ld %s [%s]\n"),
7019 get_TAG_name (entry
->tag
),
7020 entry
->children
? _("has children") : _("no children"));
7022 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7024 printf (_(" %-18s %s\n"),
7025 get_AT_name (attr
->attribute
),
7026 get_FORM_name (attr
->form
));
7040 static unsigned char *
7041 display_block (data
, length
)
7042 unsigned char * data
;
7043 unsigned long length
;
7045 printf (_(" %lu byte block: "), length
);
7048 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7054 decode_location_expression (data
, pointer_size
, length
)
7055 unsigned char * data
;
7056 unsigned int pointer_size
;
7057 unsigned long length
;
7061 unsigned long uvalue
;
7062 unsigned char * end
= data
+ length
;
7071 printf ("DW_OP_addr: %lx",
7072 (unsigned long) byte_get (data
, pointer_size
));
7073 data
+= pointer_size
;
7076 printf ("DW_OP_deref");
7079 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7082 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7085 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7089 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7093 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7097 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7101 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7102 (unsigned long) byte_get (data
+ 4, 4));
7106 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7107 (long) byte_get (data
+ 4, 4));
7111 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7115 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7119 printf ("DW_OP_dup");
7122 printf ("DW_OP_drop");
7125 printf ("DW_OP_over");
7128 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7131 printf ("DW_OP_swap");
7134 printf ("DW_OP_rot");
7137 printf ("DW_OP_xderef");
7140 printf ("DW_OP_abs");
7143 printf ("DW_OP_and");
7146 printf ("DW_OP_div");
7149 printf ("DW_OP_minus");
7152 printf ("DW_OP_mod");
7155 printf ("DW_OP_mul");
7158 printf ("DW_OP_neg");
7161 printf ("DW_OP_not");
7164 printf ("DW_OP_or");
7167 printf ("DW_OP_plus");
7169 case DW_OP_plus_uconst
:
7170 printf ("DW_OP_plus_uconst: %lu",
7171 read_leb128 (data
, &bytes_read
, 0));
7175 printf ("DW_OP_shl");
7178 printf ("DW_OP_shr");
7181 printf ("DW_OP_shra");
7184 printf ("DW_OP_xor");
7187 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7191 printf ("DW_OP_eq");
7194 printf ("DW_OP_ge");
7197 printf ("DW_OP_gt");
7200 printf ("DW_OP_le");
7203 printf ("DW_OP_lt");
7206 printf ("DW_OP_ne");
7209 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7245 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7280 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7315 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7316 read_leb128 (data
, &bytes_read
, 1));
7321 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7325 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7329 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7331 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7332 read_leb128 (data
, &bytes_read
, 1));
7336 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7339 case DW_OP_deref_size
:
7340 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7342 case DW_OP_xderef_size
:
7343 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7346 printf ("DW_OP_nop");
7349 /* DWARF 2.1 extensions. */
7350 case DW_OP_push_object_address
:
7351 printf ("DW_OP_push_object_address");
7354 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7358 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7362 printf ("DW_OP_calli");
7366 if (op
>= DW_OP_lo_user
7367 && op
<= DW_OP_hi_user
)
7368 printf (_("(User defined location op)"));
7370 printf (_("(Unknown location op)"));
7371 /* No way to tell where the next op is, so just bail. */
7375 /* Separate the ops. */
7380 static const char * debug_loc_contents
;
7381 static bfd_vma debug_loc_size
;
7384 load_debug_loc (file
)
7387 Elf32_Internal_Shdr
* sec
;
7390 /* If it is already loaded, do nothing. */
7391 if (debug_loc_contents
!= NULL
)
7394 /* Locate the .debug_loc section. */
7395 for (i
= 0, sec
= section_headers
;
7396 i
< elf_header
.e_shnum
;
7398 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7401 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7404 debug_loc_size
= sec
->sh_size
;
7406 debug_loc_contents
= ((char *)
7407 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7408 _("debug_loc section data")));
7414 if (debug_loc_contents
== NULL
)
7417 free ((char *) debug_loc_contents
);
7418 debug_loc_contents
= NULL
;
7424 display_debug_loc (section
, start
, file
)
7425 Elf32_Internal_Shdr
* section
;
7426 unsigned char * start
;
7427 FILE * file ATTRIBUTE_UNUSED
;
7429 unsigned char *section_end
;
7430 unsigned long bytes
;
7431 unsigned char *section_begin
= start
;
7434 addr
= section
->sh_addr
;
7435 bytes
= section
->sh_size
;
7436 section_end
= start
+ bytes
;
7439 printf (_("\nThe .debug_loc section is empty.\n"));
7442 printf (_("Contents of the .debug_loc section:\n\n"));
7443 printf (_("\n Offset Begin End Expression\n"));
7444 while (start
< section_end
)
7446 unsigned long begin
;
7448 unsigned short length
;
7449 unsigned long offset
;
7451 offset
= start
- section_begin
;
7455 /* Normally, the lists in the debug_loc section are related to a
7456 given compilation unit, and thus, we would use the
7457 pointer size of that compilation unit. However, since we are
7458 displaying it seperately here, we either have to store
7459 pointer sizes of all compilation units, or assume they don't
7460 change. We assume, like the debug_line display, that
7461 it doesn't change. */
7462 begin
= byte_get (start
, debug_line_pointer_size
);
7463 start
+= debug_line_pointer_size
;
7464 end
= byte_get (start
, debug_line_pointer_size
);
7465 start
+= debug_line_pointer_size
;
7467 if (begin
== 0 && end
== 0)
7473 length
= byte_get (start
, 2);
7476 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7477 decode_location_expression (start
, debug_line_pointer_size
, length
);
7487 static const char * debug_str_contents
;
7488 static bfd_vma debug_str_size
;
7491 load_debug_str (file
)
7494 Elf32_Internal_Shdr
* sec
;
7497 /* If it is already loaded, do nothing. */
7498 if (debug_str_contents
!= NULL
)
7501 /* Locate the .debug_str section. */
7502 for (i
= 0, sec
= section_headers
;
7503 i
< elf_header
.e_shnum
;
7505 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7508 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7511 debug_str_size
= sec
->sh_size
;
7513 debug_str_contents
= ((char *)
7514 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7515 _("debug_str section data")));
7521 if (debug_str_contents
== NULL
)
7524 free ((char *) debug_str_contents
);
7525 debug_str_contents
= NULL
;
7530 fetch_indirect_string (offset
)
7531 unsigned long offset
;
7533 if (debug_str_contents
== NULL
)
7534 return _("<no .debug_str section>");
7536 if (offset
> debug_str_size
)
7537 return _("<offset is too big>");
7539 return debug_str_contents
+ offset
;
7544 display_debug_str (section
, start
, file
)
7545 Elf32_Internal_Shdr
* section
;
7546 unsigned char * start
;
7547 FILE * file ATTRIBUTE_UNUSED
;
7549 unsigned long bytes
;
7552 addr
= section
->sh_addr
;
7553 bytes
= section
->sh_size
;
7557 printf (_("\nThe .debug_str section is empty.\n"));
7561 printf (_("Contents of the .debug_str section:\n\n"));
7569 lbytes
= (bytes
> 16 ? 16 : bytes
);
7571 printf (" 0x%8.8lx ", (unsigned long) addr
);
7573 for (j
= 0; j
< 16; j
++)
7576 printf ("%2.2x", start
[j
]);
7584 for (j
= 0; j
< lbytes
; j
++)
7587 if (k
>= ' ' && k
< 0x80)
7604 static unsigned char *
7605 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7606 unsigned long attribute
;
7608 unsigned char * data
;
7609 unsigned long cu_offset
;
7610 unsigned long pointer_size
;
7612 unsigned long uvalue
= 0;
7613 unsigned char * block_start
= NULL
;
7621 case DW_FORM_ref_addr
:
7623 uvalue
= byte_get (data
, pointer_size
);
7624 data
+= pointer_size
;
7628 uvalue
= byte_get (data
, /* offset_size */ 4);
7629 data
+= /* offset_size */ 4;
7635 uvalue
= byte_get (data
++, 1);
7640 uvalue
= byte_get (data
, 2);
7646 uvalue
= byte_get (data
, 4);
7651 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7655 case DW_FORM_ref_udata
:
7657 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7661 case DW_FORM_indirect
:
7662 form
= read_leb128 (data
, & bytes_read
, 0);
7664 printf (" %s", get_FORM_name (form
));
7665 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7671 case DW_FORM_ref_addr
:
7672 printf (" <#%lx>", uvalue
);
7678 case DW_FORM_ref_udata
:
7679 printf (" <%lx>", uvalue
+ cu_offset
);
7683 printf (" %#lx", uvalue
);
7691 printf (" %ld", uvalue
);
7696 uvalue
= byte_get (data
, 4);
7697 printf (" %lx", uvalue
);
7698 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7702 case DW_FORM_string
:
7703 printf (" %s", data
);
7704 data
+= strlen ((char *) data
) + 1;
7708 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7709 block_start
= data
+ bytes_read
;
7710 data
= display_block (block_start
, uvalue
);
7713 case DW_FORM_block1
:
7714 uvalue
= byte_get (data
, 1);
7715 block_start
= data
+ 1;
7716 data
= display_block (block_start
, uvalue
);
7719 case DW_FORM_block2
:
7720 uvalue
= byte_get (data
, 2);
7721 block_start
= data
+ 2;
7722 data
= display_block (block_start
, uvalue
);
7725 case DW_FORM_block4
:
7726 uvalue
= byte_get (data
, 4);
7727 block_start
= data
+ 4;
7728 data
= display_block (block_start
, uvalue
);
7732 printf (_(" (indirect string, offset: 0x%lx): "), uvalue
);
7733 printf (fetch_indirect_string (uvalue
));
7736 case DW_FORM_indirect
:
7737 /* Handled above. */
7741 warn (_("Unrecognized form: %d\n"), form
);
7745 /* For some attributes we can display futher information. */
7754 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7755 case DW_INL_inlined
: printf (_("(inlined)")); break;
7756 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7757 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7758 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7762 case DW_AT_language
:
7765 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7766 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7767 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7768 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7769 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7770 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7771 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7772 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7773 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7774 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7775 /* DWARF 2.1 values. */
7776 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7777 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7778 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7779 /* MIPS extension. */
7780 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7781 default: printf ("(Unknown: %lx)", uvalue
); break;
7785 case DW_AT_encoding
:
7788 case DW_ATE_void
: printf ("(void)"); break;
7789 case DW_ATE_address
: printf ("(machine address)"); break;
7790 case DW_ATE_boolean
: printf ("(boolean)"); break;
7791 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7792 case DW_ATE_float
: printf ("(float)"); break;
7793 case DW_ATE_signed
: printf ("(signed)"); break;
7794 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7795 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7796 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7797 /* DWARF 2.1 value. */
7798 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7800 if (uvalue
>= DW_ATE_lo_user
7801 && uvalue
<= DW_ATE_hi_user
)
7802 printf ("(user defined type)");
7804 printf ("(unknown type)");
7809 case DW_AT_accessibility
:
7812 case DW_ACCESS_public
: printf ("(public)"); break;
7813 case DW_ACCESS_protected
: printf ("(protected)"); break;
7814 case DW_ACCESS_private
: printf ("(private)"); break;
7815 default: printf ("(unknown accessibility)"); break;
7819 case DW_AT_visibility
:
7822 case DW_VIS_local
: printf ("(local)"); break;
7823 case DW_VIS_exported
: printf ("(exported)"); break;
7824 case DW_VIS_qualified
: printf ("(qualified)"); break;
7825 default: printf ("(unknown visibility)"); break;
7829 case DW_AT_virtuality
:
7832 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7833 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7834 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7835 default: printf ("(unknown virtuality)"); break;
7839 case DW_AT_identifier_case
:
7842 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7843 case DW_ID_up_case
: printf ("(up_case)"); break;
7844 case DW_ID_down_case
: printf ("(down_case)"); break;
7845 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7846 default: printf ("(unknown case)"); break;
7850 case DW_AT_calling_convention
:
7853 case DW_CC_normal
: printf ("(normal)"); break;
7854 case DW_CC_program
: printf ("(program)"); break;
7855 case DW_CC_nocall
: printf ("(nocall)"); break;
7857 if (uvalue
>= DW_CC_lo_user
7858 && uvalue
<= DW_CC_hi_user
)
7859 printf ("(user defined)");
7861 printf ("(unknown convention)");
7865 case DW_AT_ordering
:
7868 case -1: printf ("(undefined)"); break;
7869 case 0: printf ("(row major)"); break;
7870 case 1: printf ("(column major)"); break;
7874 case DW_AT_frame_base
:
7875 case DW_AT_location
:
7876 case DW_AT_data_member_location
:
7877 case DW_AT_vtable_elem_location
:
7878 case DW_AT_allocated
:
7879 case DW_AT_associated
:
7880 case DW_AT_data_location
:
7882 case DW_AT_upper_bound
:
7883 case DW_AT_lower_bound
:
7887 decode_location_expression (block_start
, pointer_size
, uvalue
);
7890 else if (form
== DW_FORM_data4
)
7893 printf ("location list");
7905 static unsigned char *
7906 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7907 unsigned long attribute
;
7909 unsigned char * data
;
7910 unsigned long cu_offset
;
7911 unsigned long pointer_size
;
7913 printf (" %-18s:", get_AT_name (attribute
));
7914 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7921 display_debug_info (section
, start
, file
)
7922 Elf32_Internal_Shdr
* section
;
7923 unsigned char * start
;
7926 unsigned char * end
= start
+ section
->sh_size
;
7927 unsigned char * section_begin
= start
;
7929 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7931 load_debug_str (file
);
7932 load_debug_loc (file
);
7936 DWARF2_External_CompUnit
* external
;
7937 DWARF2_Internal_CompUnit compunit
;
7938 Elf32_Internal_Shdr
* relsec
;
7939 unsigned char * tags
;
7942 unsigned long cu_offset
;
7944 external
= (DWARF2_External_CompUnit
*) start
;
7946 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7947 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7948 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7949 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7951 if (compunit
.cu_length
== 0xffffffff)
7953 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7957 /* Check for RELA relocations in the abbrev_offset address, and
7959 for (relsec
= section_headers
;
7960 relsec
< section_headers
+ elf_header
.e_shnum
;
7963 unsigned long nrelas
;
7964 Elf_Internal_Rela
*rela
, *rp
;
7965 Elf32_Internal_Shdr
*symsec
;
7966 Elf_Internal_Sym
*symtab
;
7967 Elf_Internal_Sym
*sym
;
7969 if (relsec
->sh_type
!= SHT_RELA
7970 || SECTION_HEADER (relsec
->sh_info
) != section
)
7973 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7977 symsec
= SECTION_HEADER (relsec
->sh_link
);
7978 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7980 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7983 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
7989 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7991 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7993 warn (_("Skipping unexpected symbol type %u\n"),
7994 ELF32_ST_TYPE (sym
->st_info
));
8000 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8002 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8004 warn (_("Skipping unexpected symbol type %u\n"),
8005 ELF64_ST_TYPE (sym
->st_info
));
8010 compunit
.cu_abbrev_offset
+= rp
->r_addend
;
8018 tags
= start
+ sizeof (* external
);
8019 cu_offset
= start
- section_begin
;
8020 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
8022 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8023 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8024 printf (_(" Version: %d\n"), compunit
.cu_version
);
8025 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8026 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8028 if (compunit
.cu_version
!= 2)
8030 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8036 /* Read in the abbrevs used by this compilation unit. */
8039 Elf32_Internal_Shdr
* sec
;
8040 unsigned char * begin
;
8042 /* Locate the .debug_abbrev section and process it. */
8043 for (i
= 0, sec
= section_headers
;
8044 i
< elf_header
.e_shnum
;
8046 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
8049 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
8051 warn (_("Unable to locate .debug_abbrev section!\n"));
8055 begin
= ((unsigned char *)
8056 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8057 _("debug_abbrev section data")));
8061 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8062 begin
+ sec
->sh_size
);
8068 while (tags
< start
)
8071 unsigned long abbrev_number
;
8072 abbrev_entry
* entry
;
8075 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8078 /* A null DIE marks the end of a list of children. */
8079 if (abbrev_number
== 0)
8085 /* Scan through the abbreviation list until we reach the
8087 for (entry
= first_abbrev
;
8088 entry
&& entry
->entry
!= abbrev_number
;
8089 entry
= entry
->next
)
8094 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8099 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8101 (unsigned long) (tags
- section_begin
- bytes_read
),
8103 get_TAG_name (entry
->tag
));
8105 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8106 tags
= read_and_display_attr (attr
->attribute
,
8109 compunit
.cu_pointer_size
);
8111 if (entry
->children
)
8125 display_debug_aranges (section
, start
, file
)
8126 Elf32_Internal_Shdr
* section
;
8127 unsigned char * start
;
8128 FILE * file ATTRIBUTE_UNUSED
;
8130 unsigned char * end
= start
+ section
->sh_size
;
8132 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8136 DWARF2_External_ARange
* external
;
8137 DWARF2_Internal_ARange arange
;
8138 unsigned char * ranges
;
8139 unsigned long length
;
8140 unsigned long address
;
8143 external
= (DWARF2_External_ARange
*) start
;
8145 arange
.ar_length
= BYTE_GET (external
->ar_length
);
8146 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8147 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8148 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8149 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8151 if (arange
.ar_length
== 0xffffffff)
8153 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8157 if (arange
.ar_version
!= 2)
8159 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8163 printf (_(" Length: %ld\n"), arange
.ar_length
);
8164 printf (_(" Version: %d\n"), arange
.ar_version
);
8165 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8166 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8167 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8169 printf (_("\n Address Length\n"));
8171 ranges
= start
+ sizeof (* external
);
8173 /* Must pad to an alignment boundary that is twice the pointer size. */
8174 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
8176 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8180 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8182 ranges
+= arange
.ar_pointer_size
;
8184 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8186 ranges
+= arange
.ar_pointer_size
;
8188 /* A pair of zeros marks the end of the list. */
8189 if (address
== 0 && length
== 0)
8192 printf (" %8.8lx %lu\n", address
, length
);
8195 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8203 typedef struct Frame_Chunk
8205 struct Frame_Chunk
* next
;
8206 unsigned char * chunk_start
;
8208 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8209 short int * col_type
;
8211 char * augmentation
;
8212 unsigned int code_factor
;
8214 unsigned long pc_begin
;
8215 unsigned long pc_range
;
8219 unsigned char fde_encoding
;
8223 /* A marker for a col_type that means this column was never referenced
8224 in the frame info. */
8225 #define DW_CFA_unreferenced (-1)
8227 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8228 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8229 static int size_of_encoded_value
PARAMS ((int));
8232 frame_need_space (fc
, reg
)
8236 int prev
= fc
->ncols
;
8238 if (reg
< fc
->ncols
)
8241 fc
->ncols
= reg
+ 1;
8242 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8243 fc
->ncols
* sizeof (short int));
8244 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8245 fc
->ncols
* sizeof (int));
8247 while (prev
< fc
->ncols
)
8249 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8250 fc
->col_offset
[prev
] = 0;
8256 frame_display_row (fc
, need_col_headers
, max_regs
)
8258 int * need_col_headers
;
8264 if (* max_regs
< fc
->ncols
)
8265 * max_regs
= fc
->ncols
;
8267 if (* need_col_headers
)
8269 * need_col_headers
= 0;
8271 printf (" LOC CFA ");
8273 for (r
= 0; r
< * max_regs
; r
++)
8274 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8279 printf ("r%-4d", r
);
8285 printf ("%08lx ", fc
->pc_begin
);
8286 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8287 printf ("%-8s ", tmp
);
8289 for (r
= 0; r
< fc
->ncols
; r
++)
8291 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8293 switch (fc
->col_type
[r
])
8295 case DW_CFA_undefined
:
8298 case DW_CFA_same_value
:
8302 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8304 case DW_CFA_register
:
8305 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8308 strcpy (tmp
, "n/a");
8311 printf ("%-5s", tmp
);
8318 size_of_encoded_value (encoding
)
8321 switch (encoding
& 0x7)
8324 case 0: return is_32bit_elf
? 4 : 8;
8331 #define GET(N) byte_get (start, N); start += N
8332 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8333 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8336 display_debug_frames (section
, start
, file
)
8337 Elf32_Internal_Shdr
* section
;
8338 unsigned char * start
;
8339 FILE * file ATTRIBUTE_UNUSED
;
8341 unsigned char * end
= start
+ section
->sh_size
;
8342 unsigned char * section_start
= start
;
8343 Frame_Chunk
* chunks
= 0;
8344 Frame_Chunk
* remembered_state
= 0;
8346 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8349 int addr_size
= is_32bit_elf
? 4 : 8;
8351 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8355 unsigned char * saved_start
;
8356 unsigned char * block_end
;
8357 unsigned long length
;
8358 unsigned long cie_id
;
8361 int need_col_headers
= 1;
8362 unsigned char * augmentation_data
= NULL
;
8363 unsigned long augmentation_data_len
= 0;
8364 int encoded_ptr_size
= addr_size
;
8366 saved_start
= start
;
8367 length
= byte_get (start
, 4); start
+= 4;
8372 if (length
== 0xffffffff)
8374 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8378 block_end
= saved_start
+ length
+ 4;
8379 cie_id
= byte_get (start
, 4); start
+= 4;
8381 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8385 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8386 memset (fc
, 0, sizeof (Frame_Chunk
));
8390 fc
->chunk_start
= saved_start
;
8392 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8393 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8394 frame_need_space (fc
, max_regs
-1);
8398 fc
->augmentation
= start
;
8399 start
= strchr (start
, '\0') + 1;
8401 if (fc
->augmentation
[0] == 'z')
8403 fc
->code_factor
= LEB ();
8404 fc
->data_factor
= SLEB ();
8405 fc
->ra
= byte_get (start
, 1); start
+= 1;
8406 augmentation_data_len
= LEB ();
8407 augmentation_data
= start
;
8408 start
+= augmentation_data_len
;
8410 else if (strcmp (fc
->augmentation
, "eh") == 0)
8413 fc
->code_factor
= LEB ();
8414 fc
->data_factor
= SLEB ();
8415 fc
->ra
= byte_get (start
, 1); start
+= 1;
8419 fc
->code_factor
= LEB ();
8420 fc
->data_factor
= SLEB ();
8421 fc
->ra
= byte_get (start
, 1); start
+= 1;
8425 if (do_debug_frames_interp
)
8426 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8427 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8428 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8432 printf ("\n%08lx %08lx %08lx CIE\n",
8433 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8434 printf (" Version: %d\n", version
);
8435 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8436 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8437 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8438 printf (" Return address column: %d\n", fc
->ra
);
8440 if (augmentation_data_len
)
8443 printf (" Augmentation data: ");
8444 for (i
= 0; i
< augmentation_data_len
; ++i
)
8445 printf (" %02x", augmentation_data
[i
]);
8451 if (augmentation_data_len
)
8453 unsigned char *p
, *q
;
8454 p
= fc
->augmentation
+ 1;
8455 q
= augmentation_data
;
8462 q
+= 1 + size_of_encoded_value (*q
);
8464 fc
->fde_encoding
= *q
++;
8470 if (fc
->fde_encoding
)
8471 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8474 frame_need_space (fc
, fc
->ra
);
8478 unsigned char * look_for
;
8479 static Frame_Chunk fde_fc
;
8482 memset (fc
, 0, sizeof (Frame_Chunk
));
8484 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8486 for (cie
= chunks
; cie
; cie
= cie
->next
)
8487 if (cie
->chunk_start
== look_for
)
8492 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8493 cie_id
, saved_start
);
8496 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8497 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8498 frame_need_space (fc
, max_regs
- 1);
8500 fc
->augmentation
= "";
8501 fc
->fde_encoding
= 0;
8505 fc
->ncols
= cie
->ncols
;
8506 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8507 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8508 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8509 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8510 fc
->augmentation
= cie
->augmentation
;
8511 fc
->code_factor
= cie
->code_factor
;
8512 fc
->data_factor
= cie
->data_factor
;
8513 fc
->cfa_reg
= cie
->cfa_reg
;
8514 fc
->cfa_offset
= cie
->cfa_offset
;
8516 frame_need_space (fc
, max_regs
-1);
8517 fc
->fde_encoding
= cie
->fde_encoding
;
8520 if (fc
->fde_encoding
)
8521 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8523 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8524 start
+= encoded_ptr_size
;
8525 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8526 start
+= encoded_ptr_size
;
8528 if (cie
->augmentation
[0] == 'z')
8530 augmentation_data_len
= LEB ();
8531 augmentation_data
= start
;
8532 start
+= augmentation_data_len
;
8535 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8536 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8537 (unsigned long)(cie
->chunk_start
- section_start
),
8538 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8539 if (! do_debug_frames_interp
&& augmentation_data_len
)
8542 printf (" Augmentation data: ");
8543 for (i
= 0; i
< augmentation_data_len
; ++i
)
8544 printf (" %02x", augmentation_data
[i
]);
8550 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8551 about to interpret instructions for the chunk. */
8553 if (do_debug_frames_interp
)
8555 /* Start by making a pass over the chunk, allocating storage
8556 and taking note of what registers are used. */
8557 unsigned char * tmp
= start
;
8559 while (start
< block_end
)
8569 /* Warning: if you add any more cases to this switch, be
8570 sure to add them to the corresponding switch below. */
8573 case DW_CFA_advance_loc
:
8577 frame_need_space (fc
, opa
);
8578 fc
->col_type
[opa
] = DW_CFA_undefined
;
8580 case DW_CFA_restore
:
8581 frame_need_space (fc
, opa
);
8582 fc
->col_type
[opa
] = DW_CFA_undefined
;
8584 case DW_CFA_set_loc
:
8585 start
+= encoded_ptr_size
;
8587 case DW_CFA_advance_loc1
:
8590 case DW_CFA_advance_loc2
:
8593 case DW_CFA_advance_loc4
:
8596 case DW_CFA_offset_extended
:
8597 reg
= LEB (); LEB ();
8598 frame_need_space (fc
, reg
);
8599 fc
->col_type
[reg
] = DW_CFA_undefined
;
8601 case DW_CFA_restore_extended
:
8603 frame_need_space (fc
, reg
);
8604 fc
->col_type
[reg
] = DW_CFA_undefined
;
8606 case DW_CFA_undefined
:
8608 frame_need_space (fc
, reg
);
8609 fc
->col_type
[reg
] = DW_CFA_undefined
;
8611 case DW_CFA_same_value
:
8613 frame_need_space (fc
, reg
);
8614 fc
->col_type
[reg
] = DW_CFA_undefined
;
8616 case DW_CFA_register
:
8617 reg
= LEB (); LEB ();
8618 frame_need_space (fc
, reg
);
8619 fc
->col_type
[reg
] = DW_CFA_undefined
;
8621 case DW_CFA_def_cfa
:
8624 case DW_CFA_def_cfa_register
:
8627 case DW_CFA_def_cfa_offset
:
8630 case DW_CFA_offset_extended_sf
:
8631 reg
= LEB (); SLEB ();
8632 frame_need_space (fc
, reg
);
8633 fc
->col_type
[reg
] = DW_CFA_undefined
;
8635 case DW_CFA_def_cfa_sf
:
8638 case DW_CFA_def_cfa_offset_sf
:
8641 case DW_CFA_GNU_args_size
:
8644 case DW_CFA_GNU_negative_offset_extended
:
8645 reg
= LEB (); LEB ();
8646 frame_need_space (fc
, reg
);
8647 fc
->col_type
[reg
] = DW_CFA_undefined
;
8656 /* Now we know what registers are used, make a second pass over
8657 the chunk, this time actually printing out the info. */
8659 while (start
< block_end
)
8662 unsigned long ul
, reg
, roffs
;
8671 /* Warning: if you add any more cases to this switch, be
8672 sure to add them to the corresponding switch above. */
8675 case DW_CFA_advance_loc
:
8676 if (do_debug_frames_interp
)
8677 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8679 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8680 opa
* fc
->code_factor
,
8681 fc
->pc_begin
+ opa
* fc
->code_factor
);
8682 fc
->pc_begin
+= opa
* fc
->code_factor
;
8687 if (! do_debug_frames_interp
)
8688 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8689 opa
, roffs
* fc
->data_factor
);
8690 fc
->col_type
[opa
] = DW_CFA_offset
;
8691 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8694 case DW_CFA_restore
:
8695 if (! do_debug_frames_interp
)
8696 printf (" DW_CFA_restore: r%d\n", opa
);
8697 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8698 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8701 case DW_CFA_set_loc
:
8702 vma
= byte_get (start
, encoded_ptr_size
);
8703 start
+= encoded_ptr_size
;
8704 if (do_debug_frames_interp
)
8705 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8707 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8711 case DW_CFA_advance_loc1
:
8712 ofs
= byte_get (start
, 1); start
+= 1;
8713 if (do_debug_frames_interp
)
8714 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8716 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8717 ofs
* fc
->code_factor
,
8718 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8719 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8722 case DW_CFA_advance_loc2
:
8723 ofs
= byte_get (start
, 2); start
+= 2;
8724 if (do_debug_frames_interp
)
8725 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8727 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8728 ofs
* fc
->code_factor
,
8729 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8730 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8733 case DW_CFA_advance_loc4
:
8734 ofs
= byte_get (start
, 4); start
+= 4;
8735 if (do_debug_frames_interp
)
8736 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8738 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8739 ofs
* fc
->code_factor
,
8740 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8741 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8744 case DW_CFA_offset_extended
:
8747 if (! do_debug_frames_interp
)
8748 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8749 reg
, roffs
* fc
->data_factor
);
8750 fc
->col_type
[reg
] = DW_CFA_offset
;
8751 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8754 case DW_CFA_restore_extended
:
8756 if (! do_debug_frames_interp
)
8757 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8758 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8759 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8762 case DW_CFA_undefined
:
8764 if (! do_debug_frames_interp
)
8765 printf (" DW_CFA_undefined: r%ld\n", reg
);
8766 fc
->col_type
[reg
] = DW_CFA_undefined
;
8767 fc
->col_offset
[reg
] = 0;
8770 case DW_CFA_same_value
:
8772 if (! do_debug_frames_interp
)
8773 printf (" DW_CFA_same_value: r%ld\n", reg
);
8774 fc
->col_type
[reg
] = DW_CFA_same_value
;
8775 fc
->col_offset
[reg
] = 0;
8778 case DW_CFA_register
:
8781 if (! do_debug_frames_interp
)
8782 printf (" DW_CFA_register: r%ld\n", reg
);
8783 fc
->col_type
[reg
] = DW_CFA_register
;
8784 fc
->col_offset
[reg
] = roffs
;
8787 case DW_CFA_remember_state
:
8788 if (! do_debug_frames_interp
)
8789 printf (" DW_CFA_remember_state\n");
8790 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8791 rs
->ncols
= fc
->ncols
;
8792 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8793 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8794 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8795 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8796 rs
->next
= remembered_state
;
8797 remembered_state
= rs
;
8800 case DW_CFA_restore_state
:
8801 if (! do_debug_frames_interp
)
8802 printf (" DW_CFA_restore_state\n");
8803 rs
= remembered_state
;
8804 remembered_state
= rs
->next
;
8805 frame_need_space (fc
, rs
->ncols
-1);
8806 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8807 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8808 free (rs
->col_type
);
8809 free (rs
->col_offset
);
8813 case DW_CFA_def_cfa
:
8814 fc
->cfa_reg
= LEB ();
8815 fc
->cfa_offset
= LEB ();
8816 if (! do_debug_frames_interp
)
8817 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8818 fc
->cfa_reg
, fc
->cfa_offset
);
8821 case DW_CFA_def_cfa_register
:
8822 fc
->cfa_reg
= LEB ();
8823 if (! do_debug_frames_interp
)
8824 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8827 case DW_CFA_def_cfa_offset
:
8828 fc
->cfa_offset
= LEB ();
8829 if (! do_debug_frames_interp
)
8830 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8834 if (! do_debug_frames_interp
)
8835 printf (" DW_CFA_nop\n");
8838 case DW_CFA_offset_extended_sf
:
8841 frame_need_space (fc
, reg
);
8842 if (! do_debug_frames_interp
)
8843 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8844 reg
, l
* fc
->data_factor
);
8845 fc
->col_type
[reg
] = DW_CFA_offset
;
8846 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8849 case DW_CFA_def_cfa_sf
:
8850 fc
->cfa_reg
= LEB ();
8851 fc
->cfa_offset
= SLEB ();
8852 if (! do_debug_frames_interp
)
8853 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8854 fc
->cfa_reg
, fc
->cfa_offset
);
8857 case DW_CFA_def_cfa_offset_sf
:
8858 fc
->cfa_offset
= SLEB ();
8859 if (! do_debug_frames_interp
)
8860 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
8863 case DW_CFA_GNU_window_save
:
8864 if (! do_debug_frames_interp
)
8865 printf (" DW_CFA_GNU_window_save\n");
8868 case DW_CFA_GNU_args_size
:
8870 if (! do_debug_frames_interp
)
8871 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8874 case DW_CFA_GNU_negative_offset_extended
:
8877 frame_need_space (fc
, reg
);
8878 if (! do_debug_frames_interp
)
8879 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8880 reg
, l
* fc
->data_factor
);
8881 fc
->col_type
[reg
] = DW_CFA_offset
;
8882 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8885 /* FIXME: How do we handle these? */
8886 case DW_CFA_def_cfa_expression
:
8887 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
8891 case DW_CFA_expression
:
8892 fprintf (stderr
, "unsupported DW_CFA_expression\n");
8897 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8902 if (do_debug_frames_interp
)
8903 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8918 display_debug_not_supported (section
, start
, file
)
8919 Elf32_Internal_Shdr
* section
;
8920 unsigned char * start ATTRIBUTE_UNUSED
;
8921 FILE * file ATTRIBUTE_UNUSED
;
8923 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8924 SECTION_NAME (section
));
8929 /* Pre-scan the .debug_info section to record the size of address.
8930 When dumping the .debug_line, we use that size information, assuming
8931 that all compilation units have the same address size. */
8933 prescan_debug_info (section
, start
, file
)
8934 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8935 unsigned char * start
;
8936 FILE * file ATTRIBUTE_UNUSED
;
8938 DWARF2_External_CompUnit
* external
;
8940 external
= (DWARF2_External_CompUnit
*) start
;
8942 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8946 /* A structure containing the name of a debug section and a pointer
8947 to a function that can decode it. The third field is a prescan
8948 function to be run over the section before displaying any of the
8952 const char * const name
;
8953 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8954 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8958 { ".debug_abbrev", display_debug_abbrev
, NULL
},
8959 { ".debug_aranges", display_debug_aranges
, NULL
},
8960 { ".debug_frame", display_debug_frames
, NULL
},
8961 { ".debug_info", display_debug_info
, prescan_debug_info
},
8962 { ".debug_line", display_debug_lines
, NULL
},
8963 { ".debug_pubnames", display_debug_pubnames
, NULL
},
8964 { ".eh_frame", display_debug_frames
, NULL
},
8965 { ".debug_macinfo", display_debug_macinfo
, NULL
},
8966 { ".debug_str", display_debug_str
, NULL
},
8967 { ".debug_loc", display_debug_loc
, NULL
},
8968 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
8969 { ".debug_ranges", display_debug_not_supported
, NULL
},
8970 { ".debug_static_func", display_debug_not_supported
, NULL
},
8971 { ".debug_static_vars", display_debug_not_supported
, NULL
},
8972 { ".debug_types", display_debug_not_supported
, NULL
},
8973 { ".debug_weaknames", display_debug_not_supported
, NULL
}
8977 display_debug_section (section
, file
)
8978 Elf32_Internal_Shdr
* section
;
8981 char * name
= SECTION_NAME (section
);
8982 bfd_size_type length
;
8983 unsigned char * start
;
8986 length
= section
->sh_size
;
8989 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8993 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
8994 _("debug section data"));
8998 /* See if we know how to display the contents of this section. */
8999 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9000 name
= ".debug_info";
9002 for (i
= NUM_ELEM (debug_displays
); i
--;)
9003 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9005 debug_displays
[i
].display (section
, start
, file
);
9010 printf (_("Unrecognized debug section: %s\n"), name
);
9014 /* If we loaded in the abbrev section at some point,
9015 we must release it here. */
9022 process_section_contents (file
)
9025 Elf32_Internal_Shdr
* section
;
9031 /* Pre-scan the debug sections to find some debug information not
9032 present in some of them. For the .debug_line, we must find out the
9033 size of address (specified in .debug_info and .debug_aranges). */
9034 for (i
= 0, section
= section_headers
;
9035 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9038 char * name
= SECTION_NAME (section
);
9041 if (section
->sh_size
== 0)
9044 /* See if there is some pre-scan operation for this section. */
9045 for (j
= NUM_ELEM (debug_displays
); j
--;)
9046 if (strcmp (debug_displays
[j
].name
, name
) == 0)
9048 if (debug_displays
[j
].prescan
!= NULL
)
9050 bfd_size_type length
;
9051 unsigned char * start
;
9053 length
= section
->sh_size
;
9054 start
= ((unsigned char *)
9055 get_data (NULL
, file
, section
->sh_offset
, length
,
9056 _("debug section data")));
9060 debug_displays
[j
].prescan (section
, start
, file
);
9068 for (i
= 0, section
= section_headers
;
9069 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9072 #ifdef SUPPORT_DISASSEMBLY
9073 if (dump_sects
[i
] & DISASS_DUMP
)
9074 disassemble_section (section
, file
);
9076 if (dump_sects
[i
] & HEX_DUMP
)
9077 dump_section (section
, file
);
9079 if (dump_sects
[i
] & DEBUG_DUMP
)
9080 display_debug_section (section
, file
);
9083 if (i
< num_dump_sects
)
9084 warn (_("Some sections were not dumped because they do not exist!\n"));
9090 process_mips_fpe_exception (mask
)
9096 if (mask
& OEX_FPU_INEX
)
9097 fputs ("INEX", stdout
), first
= 0;
9098 if (mask
& OEX_FPU_UFLO
)
9099 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9100 if (mask
& OEX_FPU_OFLO
)
9101 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9102 if (mask
& OEX_FPU_DIV0
)
9103 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9104 if (mask
& OEX_FPU_INVAL
)
9105 printf ("%sINVAL", first
? "" : "|");
9108 fputs ("0", stdout
);
9112 process_mips_specific (file
)
9115 Elf_Internal_Dyn
* entry
;
9116 size_t liblist_offset
= 0;
9117 size_t liblistno
= 0;
9118 size_t conflictsno
= 0;
9119 size_t options_offset
= 0;
9120 size_t conflicts_offset
= 0;
9122 /* We have a lot of special sections. Thanks SGI! */
9123 if (dynamic_segment
== NULL
)
9124 /* No information available. */
9127 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9128 switch (entry
->d_tag
)
9130 case DT_MIPS_LIBLIST
:
9131 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
9133 case DT_MIPS_LIBLISTNO
:
9134 liblistno
= entry
->d_un
.d_val
;
9136 case DT_MIPS_OPTIONS
:
9137 options_offset
= entry
->d_un
.d_val
- loadaddr
;
9139 case DT_MIPS_CONFLICT
:
9140 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
9142 case DT_MIPS_CONFLICTNO
:
9143 conflictsno
= entry
->d_un
.d_val
;
9149 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9151 Elf32_External_Lib
* elib
;
9154 elib
= ((Elf32_External_Lib
*)
9155 get_data (NULL
, file
, liblist_offset
,
9156 liblistno
* sizeof (Elf32_External_Lib
),
9160 printf ("\nSection '.liblist' contains %lu entries:\n",
9161 (unsigned long) liblistno
);
9162 fputs (" Library Time Stamp Checksum Version Flags\n",
9165 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9172 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9173 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9174 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9175 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9176 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9178 tmp
= gmtime (&time
);
9179 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9180 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9181 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9183 printf ("%3lu: ", (unsigned long) cnt
);
9184 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9185 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9188 if (liblist
.l_flags
== 0)
9199 { " EXACT_MATCH", LL_EXACT_MATCH
},
9200 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9201 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9202 { " EXPORTS", LL_EXPORTS
},
9203 { " DELAY_LOAD", LL_DELAY_LOAD
},
9204 { " DELTA", LL_DELTA
}
9206 int flags
= liblist
.l_flags
;
9210 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9212 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9214 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9215 flags
^= l_flags_vals
[fcnt
].bit
;
9218 printf (" %#x", (unsigned int) flags
);
9228 if (options_offset
!= 0)
9230 Elf_External_Options
* eopt
;
9231 Elf_Internal_Shdr
* sect
= section_headers
;
9232 Elf_Internal_Options
* iopt
;
9233 Elf_Internal_Options
* option
;
9237 /* Find the section header so that we get the size. */
9238 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9241 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9242 sect
->sh_size
, _("options"));
9245 iopt
= ((Elf_Internal_Options
*)
9246 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
9249 error (_("Out of memory"));
9256 while (offset
< sect
->sh_size
)
9258 Elf_External_Options
* eoption
;
9260 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9262 option
->kind
= BYTE_GET (eoption
->kind
);
9263 option
->size
= BYTE_GET (eoption
->size
);
9264 option
->section
= BYTE_GET (eoption
->section
);
9265 option
->info
= BYTE_GET (eoption
->info
);
9267 offset
+= option
->size
;
9273 printf (_("\nSection '%s' contains %d entries:\n"),
9274 SECTION_NAME (sect
), cnt
);
9282 switch (option
->kind
)
9285 /* This shouldn't happen. */
9286 printf (" NULL %d %lx", option
->section
, option
->info
);
9289 printf (" REGINFO ");
9290 if (elf_header
.e_machine
== EM_MIPS
)
9293 Elf32_External_RegInfo
* ereg
;
9294 Elf32_RegInfo reginfo
;
9296 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9297 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9298 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9299 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9300 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9301 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9302 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9304 printf ("GPR %08lx GP 0x%lx\n",
9306 (unsigned long) reginfo
.ri_gp_value
);
9307 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9308 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9309 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9314 Elf64_External_RegInfo
* ereg
;
9315 Elf64_Internal_RegInfo reginfo
;
9317 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9318 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9319 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9320 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9321 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9322 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9323 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9325 printf ("GPR %08lx GP 0x",
9326 reginfo
.ri_gprmask
);
9327 printf_vma (reginfo
.ri_gp_value
);
9330 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9331 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9332 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9336 case ODK_EXCEPTIONS
:
9337 fputs (" EXCEPTIONS fpe_min(", stdout
);
9338 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9339 fputs (") fpe_max(", stdout
);
9340 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9341 fputs (")", stdout
);
9343 if (option
->info
& OEX_PAGE0
)
9344 fputs (" PAGE0", stdout
);
9345 if (option
->info
& OEX_SMM
)
9346 fputs (" SMM", stdout
);
9347 if (option
->info
& OEX_FPDBUG
)
9348 fputs (" FPDBUG", stdout
);
9349 if (option
->info
& OEX_DISMISS
)
9350 fputs (" DISMISS", stdout
);
9353 fputs (" PAD ", stdout
);
9354 if (option
->info
& OPAD_PREFIX
)
9355 fputs (" PREFIX", stdout
);
9356 if (option
->info
& OPAD_POSTFIX
)
9357 fputs (" POSTFIX", stdout
);
9358 if (option
->info
& OPAD_SYMBOL
)
9359 fputs (" SYMBOL", stdout
);
9362 fputs (" HWPATCH ", stdout
);
9363 if (option
->info
& OHW_R4KEOP
)
9364 fputs (" R4KEOP", stdout
);
9365 if (option
->info
& OHW_R8KPFETCH
)
9366 fputs (" R8KPFETCH", stdout
);
9367 if (option
->info
& OHW_R5KEOP
)
9368 fputs (" R5KEOP", stdout
);
9369 if (option
->info
& OHW_R5KCVTL
)
9370 fputs (" R5KCVTL", stdout
);
9373 fputs (" FILL ", stdout
);
9374 /* XXX Print content of info word? */
9377 fputs (" TAGS ", stdout
);
9378 /* XXX Print content of info word? */
9381 fputs (" HWAND ", stdout
);
9382 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9383 fputs (" R4KEOP_CHECKED", stdout
);
9384 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9385 fputs (" R4KEOP_CLEAN", stdout
);
9388 fputs (" HWOR ", 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 printf (" GP_GROUP %#06lx self-contained %#06lx",
9396 option
->info
& OGP_GROUP
,
9397 (option
->info
& OGP_SELF
) >> 16);
9400 printf (" IDENT %#06lx self-contained %#06lx",
9401 option
->info
& OGP_GROUP
,
9402 (option
->info
& OGP_SELF
) >> 16);
9405 /* This shouldn't happen. */
9406 printf (" %3d ??? %d %lx",
9407 option
->kind
, option
->section
, option
->info
);
9411 len
= sizeof (* eopt
);
9412 while (len
< option
->size
)
9413 if (((char *) option
)[len
] >= ' '
9414 && ((char *) option
)[len
] < 0x7f)
9415 printf ("%c", ((char *) option
)[len
++]);
9417 printf ("\\%03o", ((char *) option
)[len
++]);
9419 fputs ("\n", stdout
);
9427 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9429 Elf32_Conflict
* iconf
;
9432 if (dynamic_symbols
== NULL
)
9434 error (_("conflict list found without a dynamic symbol table"));
9438 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
9441 error (_("Out of memory"));
9447 Elf32_External_Conflict
* econf32
;
9449 econf32
= ((Elf32_External_Conflict
*)
9450 get_data (NULL
, file
, conflicts_offset
,
9451 conflictsno
* sizeof (* econf32
),
9456 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9457 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9463 Elf64_External_Conflict
* econf64
;
9465 econf64
= ((Elf64_External_Conflict
*)
9466 get_data (NULL
, file
, conflicts_offset
,
9467 conflictsno
* sizeof (* econf64
),
9472 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9473 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9478 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9479 (long) conflictsno
);
9480 puts (_(" Num: Index Value Name"));
9482 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9484 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9486 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9487 print_vma (psym
->st_value
, FULL_HEX
);
9489 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9500 process_gnu_liblist (file
)
9503 Elf_Internal_Shdr
* section
, * string_sec
;
9504 Elf32_External_Lib
* elib
;
9512 for (i
= 0, section
= section_headers
;
9513 i
< elf_header
.e_shnum
;
9516 switch (section
->sh_type
)
9518 case SHT_GNU_LIBLIST
:
9519 elib
= ((Elf32_External_Lib
*)
9520 get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9525 string_sec
= SECTION_HEADER (section
->sh_link
);
9527 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9528 string_sec
->sh_size
,
9529 _("liblist string table"));
9532 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9538 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9539 SECTION_NAME (section
),
9540 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9542 puts (" Library Time Stamp Checksum Version Flags");
9544 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9552 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9553 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9554 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9555 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9556 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9558 tmp
= gmtime (&time
);
9559 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9560 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9561 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9563 printf ("%3lu: ", (unsigned long) cnt
);
9565 printf ("%-20s", strtab
+ liblist
.l_name
);
9567 printf ("%-20.20s", strtab
+ liblist
.l_name
);
9568 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9569 liblist
.l_version
, liblist
.l_flags
);
9580 get_note_type (e_type
)
9583 static char buff
[64];
9587 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9588 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9589 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9590 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9591 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9592 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9593 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9594 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9595 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9596 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9597 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9599 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9605 get_netbsd_elfcore_note_type (e_type
)
9608 static char buff
[64];
9610 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9612 /* NetBSD core "procinfo" structure. */
9613 return _("NetBSD procinfo structure");
9616 /* As of Jan 2002 there are no other machine-independent notes
9617 defined for NetBSD core files. If the note type is less
9618 than the start of the machine-dependent note types, we don't
9621 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9623 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9627 switch (elf_header
.e_machine
)
9629 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9630 and PT_GETFPREGS == mach+2. */
9635 case EM_SPARC32PLUS
:
9639 case NT_NETBSDCORE_FIRSTMACH
+0:
9640 return _("PT_GETREGS (reg structure)");
9641 case NT_NETBSDCORE_FIRSTMACH
+2:
9642 return _("PT_GETFPREGS (fpreg structure)");
9648 /* On all other arch's, PT_GETREGS == mach+1 and
9649 PT_GETFPREGS == mach+3. */
9653 case NT_NETBSDCORE_FIRSTMACH
+1:
9654 return _("PT_GETREGS (reg structure)");
9655 case NT_NETBSDCORE_FIRSTMACH
+3:
9656 return _("PT_GETFPREGS (fpreg structure)");
9662 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9666 /* Note that by the ELF standard, the name field is already null byte
9667 terminated, and namesz includes the terminating null byte.
9668 I.E. the value of namesz for the name "FSF" is 4.
9670 If the value of namesz is zero, there is no name present. */
9672 process_note (pnote
)
9673 Elf32_Internal_Note
* pnote
;
9677 if (pnote
->namesz
== 0)
9679 /* If there is no note name, then use the default set of
9680 note type strings. */
9681 nt
= get_note_type (pnote
->type
);
9683 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9685 /* NetBSD-specific core file notes. */
9686 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9690 /* Don't recognize this note name; just use the default set of
9691 note type strings. */
9692 nt
= get_note_type (pnote
->type
);
9695 printf (" %s\t\t0x%08lx\t%s\n",
9696 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9703 process_corefile_note_segment (file
, offset
, length
)
9708 Elf_External_Note
* pnotes
;
9709 Elf_External_Note
* external
;
9715 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9722 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9723 (unsigned long) offset
, (unsigned long) length
);
9724 printf (_(" Owner\t\tData size\tDescription\n"));
9726 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9728 Elf_External_Note
* next
;
9729 Elf32_Internal_Note inote
;
9732 inote
.type
= BYTE_GET (external
->type
);
9733 inote
.namesz
= BYTE_GET (external
->namesz
);
9734 inote
.namedata
= external
->name
;
9735 inote
.descsz
= BYTE_GET (external
->descsz
);
9736 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9737 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9739 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9741 if (((char *) next
) > (((char *) pnotes
) + length
))
9743 warn (_("corrupt note found at offset %x into core notes\n"),
9744 ((char *) external
) - ((char *) pnotes
));
9745 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9746 inote
.type
, inote
.namesz
, inote
.descsz
);
9752 /* Verify that name is null terminated. It appears that at least
9753 one version of Linux (RedHat 6.0) generates corefiles that don't
9754 comply with the ELF spec by failing to include the null byte in
9756 if (inote
.namedata
[inote
.namesz
] != '\0')
9758 temp
= malloc (inote
.namesz
+ 1);
9762 error (_("Out of memory\n"));
9767 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9768 temp
[inote
.namesz
] = 0;
9770 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9771 inote
.namedata
= temp
;
9774 res
&= process_note (& inote
);
9789 process_corefile_note_segments (file
)
9792 Elf_Internal_Phdr
* program_headers
;
9793 Elf_Internal_Phdr
* segment
;
9797 program_headers
= (Elf_Internal_Phdr
*) malloc
9798 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9800 if (program_headers
== NULL
)
9802 error (_("Out of memory\n"));
9807 i
= get_32bit_program_headers (file
, program_headers
);
9809 i
= get_64bit_program_headers (file
, program_headers
);
9813 free (program_headers
);
9817 for (i
= 0, segment
= program_headers
;
9818 i
< elf_header
.e_phnum
;
9821 if (segment
->p_type
== PT_NOTE
)
9822 res
&= process_corefile_note_segment (file
,
9823 (bfd_vma
) segment
->p_offset
,
9824 (bfd_vma
) segment
->p_filesz
);
9827 free (program_headers
);
9833 process_corefile_contents (file
)
9836 /* If we have not been asked to display the notes then do nothing. */
9840 /* If file is not a core file then exit. */
9841 if (elf_header
.e_type
!= ET_CORE
)
9844 /* No program headers means no NOTE segment. */
9845 if (elf_header
.e_phnum
== 0)
9847 printf (_("No note segments present in the core file.\n"));
9851 return process_corefile_note_segments (file
);
9855 process_arch_specific (file
)
9861 switch (elf_header
.e_machine
)
9864 case EM_MIPS_RS3_LE
:
9865 return process_mips_specific (file
);
9874 get_file_header (file
)
9877 /* Read in the identity array. */
9878 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9881 /* Determine how to read the rest of the header. */
9882 switch (elf_header
.e_ident
[EI_DATA
])
9884 default: /* fall through */
9885 case ELFDATANONE
: /* fall through */
9886 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9887 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9890 /* For now we only support 32 bit and 64 bit ELF files. */
9891 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9893 /* Read in the rest of the header. */
9896 Elf32_External_Ehdr ehdr32
;
9898 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9901 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9902 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9903 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9904 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9905 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9906 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9907 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9908 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9909 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9910 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9911 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9912 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9913 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9917 Elf64_External_Ehdr ehdr64
;
9919 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9920 we will not be able to cope with the 64bit data found in
9921 64 ELF files. Detect this now and abort before we start
9922 overwritting things. */
9923 if (sizeof (bfd_vma
) < 8)
9925 error (_("This instance of readelf has been built without support for a\n\
9926 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9930 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9933 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9934 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9935 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9936 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9937 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9938 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9939 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9940 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9941 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9942 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9943 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9944 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9945 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9948 if (elf_header
.e_shoff
)
9950 /* There may be some extensions in the first section header. Don't
9951 bomb if we can't read it. */
9953 get_32bit_section_headers (file
, 1);
9955 get_64bit_section_headers (file
, 1);
9962 process_file (file_name
)
9966 struct stat statbuf
;
9969 if (stat (file_name
, & statbuf
) < 0)
9971 error (_("Cannot stat input file %s.\n"), file_name
);
9975 file
= fopen (file_name
, "rb");
9978 error (_("Input file %s not found.\n"), file_name
);
9982 if (! get_file_header (file
))
9984 error (_("%s: Failed to read file header\n"), file_name
);
9989 /* Initialise per file variables. */
9990 for (i
= NUM_ELEM (version_info
); i
--;)
9991 version_info
[i
] = 0;
9993 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9994 dynamic_info
[i
] = 0;
9996 /* Process the file. */
9998 printf (_("\nFile: %s\n"), file_name
);
10000 if (! process_file_header ())
10006 process_section_headers (file
);
10008 process_program_headers (file
);
10010 process_dynamic_segment (file
);
10012 process_relocs (file
);
10014 process_unwind (file
);
10016 process_symbol_table (file
);
10018 process_syminfo (file
);
10020 process_version_sections (file
);
10022 process_section_contents (file
);
10024 process_corefile_contents (file
);
10026 process_gnu_liblist (file
);
10028 process_arch_specific (file
);
10032 if (section_headers
)
10034 free (section_headers
);
10035 section_headers
= NULL
;
10040 free (string_table
);
10041 string_table
= NULL
;
10042 string_table_length
= 0;
10045 if (dynamic_strings
)
10047 free (dynamic_strings
);
10048 dynamic_strings
= NULL
;
10051 if (dynamic_symbols
)
10053 free (dynamic_symbols
);
10054 dynamic_symbols
= NULL
;
10055 num_dynamic_syms
= 0;
10058 if (dynamic_syminfo
)
10060 free (dynamic_syminfo
);
10061 dynamic_syminfo
= NULL
;
10067 #ifdef SUPPORT_DISASSEMBLY
10068 /* Needed by the i386 disassembler. For extra credit, someone could
10069 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10073 print_address (unsigned int addr
, FILE * outfile
)
10075 fprintf (outfile
,"0x%8.8x", addr
);
10078 /* Needed by the i386 disassembler. */
10080 db_task_printsym (unsigned int addr
)
10082 print_address (addr
, stderr
);
10086 int main
PARAMS ((int, char **));
10095 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10096 setlocale (LC_MESSAGES
, "");
10098 #if defined (HAVE_SETLOCALE)
10099 setlocale (LC_CTYPE
, "");
10101 bindtextdomain (PACKAGE
, LOCALEDIR
);
10102 textdomain (PACKAGE
);
10104 parse_args (argc
, argv
);
10106 if (optind
< (argc
- 1))
10110 while (optind
< argc
)
10111 err
|= process_file (argv
[optind
++]);
10113 if (dump_sects
!= NULL
)