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, const 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 just 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
)
541 printf ("%s", 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)
1170 const char *sec_name
= "<null>";
1173 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1175 bfd_vma sec_index
= (bfd_vma
) -1;
1177 if (psym
->st_shndx
< SHN_LORESERVE
)
1178 sec_index
= psym
->st_shndx
;
1179 else if (psym
->st_shndx
> SHN_LORESERVE
)
1180 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1183 if (sec_index
!= (bfd_vma
) -1)
1184 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1185 else if (psym
->st_shndx
== SHN_ABS
)
1187 else if (psym
->st_shndx
== SHN_COMMON
)
1188 sec_name
= "COMMON";
1191 sprintf (name_buf
, "<section 0x%x>",
1192 (unsigned int) psym
->st_shndx
);
1193 sec_name
= name_buf
;
1196 print_symbol (22, sec_name
);
1198 else if (strtab
== NULL
)
1199 printf (_("<string table index %3ld>"), psym
->st_name
);
1201 print_symbol (22, strtab
+ psym
->st_name
);
1204 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
1209 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1210 print_vma (relas
[i
].r_addend
, LONG_HEX
);
1213 if (elf_header
.e_machine
== EM_SPARCV9
1214 && !strcmp (rtype
, "R_SPARC_OLO10"))
1215 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1219 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1221 printf (" Type2: ");
1224 #ifdef _bfd_int64_low
1225 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1227 printf (_("unrecognized: %-7lx"), type2
);
1230 printf ("%-17.17s", rtype2
);
1232 printf("\n Type3: ");
1235 #ifdef _bfd_int64_low
1236 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1238 printf (_("unrecognized: %-7lx"), type3
);
1241 printf ("%-17.17s", rtype3
);
1256 get_mips_dynamic_type (type
)
1261 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1262 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1263 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1264 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1265 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1266 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1267 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1268 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1269 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1270 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1271 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1272 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1273 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1274 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1275 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1276 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1277 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1278 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1279 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1280 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1281 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1282 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1283 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1284 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1285 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1286 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1287 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1288 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1289 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1290 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1291 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1292 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1293 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1294 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1295 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1296 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1297 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1298 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1299 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1300 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1301 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1302 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1303 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1310 get_sparc64_dynamic_type (type
)
1315 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1322 get_ppc64_dynamic_type (type
)
1327 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1328 case DT_PPC64_OPD
: return "PPC64_OPD";
1329 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1336 get_parisc_dynamic_type (type
)
1341 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1342 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1343 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1344 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1345 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1346 case DT_HP_PREINIT
: return "HP_PREINIT";
1347 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1348 case DT_HP_NEEDED
: return "HP_NEEDED";
1349 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1350 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1351 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1352 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1353 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1360 get_dynamic_type (type
)
1363 static char buff
[32];
1367 case DT_NULL
: return "NULL";
1368 case DT_NEEDED
: return "NEEDED";
1369 case DT_PLTRELSZ
: return "PLTRELSZ";
1370 case DT_PLTGOT
: return "PLTGOT";
1371 case DT_HASH
: return "HASH";
1372 case DT_STRTAB
: return "STRTAB";
1373 case DT_SYMTAB
: return "SYMTAB";
1374 case DT_RELA
: return "RELA";
1375 case DT_RELASZ
: return "RELASZ";
1376 case DT_RELAENT
: return "RELAENT";
1377 case DT_STRSZ
: return "STRSZ";
1378 case DT_SYMENT
: return "SYMENT";
1379 case DT_INIT
: return "INIT";
1380 case DT_FINI
: return "FINI";
1381 case DT_SONAME
: return "SONAME";
1382 case DT_RPATH
: return "RPATH";
1383 case DT_SYMBOLIC
: return "SYMBOLIC";
1384 case DT_REL
: return "REL";
1385 case DT_RELSZ
: return "RELSZ";
1386 case DT_RELENT
: return "RELENT";
1387 case DT_PLTREL
: return "PLTREL";
1388 case DT_DEBUG
: return "DEBUG";
1389 case DT_TEXTREL
: return "TEXTREL";
1390 case DT_JMPREL
: return "JMPREL";
1391 case DT_BIND_NOW
: return "BIND_NOW";
1392 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1393 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1394 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1395 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1396 case DT_RUNPATH
: return "RUNPATH";
1397 case DT_FLAGS
: return "FLAGS";
1399 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1400 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1402 case DT_CHECKSUM
: return "CHECKSUM";
1403 case DT_PLTPADSZ
: return "PLTPADSZ";
1404 case DT_MOVEENT
: return "MOVEENT";
1405 case DT_MOVESZ
: return "MOVESZ";
1406 case DT_FEATURE
: return "FEATURE";
1407 case DT_POSFLAG_1
: return "POSFLAG_1";
1408 case DT_SYMINSZ
: return "SYMINSZ";
1409 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1411 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1412 case DT_CONFIG
: return "CONFIG";
1413 case DT_DEPAUDIT
: return "DEPAUDIT";
1414 case DT_AUDIT
: return "AUDIT";
1415 case DT_PLTPAD
: return "PLTPAD";
1416 case DT_MOVETAB
: return "MOVETAB";
1417 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1419 case DT_VERSYM
: return "VERSYM";
1421 case DT_RELACOUNT
: return "RELACOUNT";
1422 case DT_RELCOUNT
: return "RELCOUNT";
1423 case DT_FLAGS_1
: return "FLAGS_1";
1424 case DT_VERDEF
: return "VERDEF";
1425 case DT_VERDEFNUM
: return "VERDEFNUM";
1426 case DT_VERNEED
: return "VERNEED";
1427 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1429 case DT_AUXILIARY
: return "AUXILIARY";
1430 case DT_USED
: return "USED";
1431 case DT_FILTER
: return "FILTER";
1433 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1434 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1435 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1436 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1437 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1440 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1442 const char * result
;
1444 switch (elf_header
.e_machine
)
1447 case EM_MIPS_RS3_LE
:
1448 result
= get_mips_dynamic_type (type
);
1451 result
= get_sparc64_dynamic_type (type
);
1454 result
= get_ppc64_dynamic_type (type
);
1464 sprintf (buff
, _("Processor Specific: %lx"), type
);
1466 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1468 const char * result
;
1470 switch (elf_header
.e_machine
)
1473 result
= get_parisc_dynamic_type (type
);
1483 sprintf (buff
, _("Operating System specific: %lx"), type
);
1486 sprintf (buff
, _("<unknown>: %lx"), type
);
1493 get_file_type (e_type
)
1496 static char buff
[32];
1500 case ET_NONE
: return _("NONE (None)");
1501 case ET_REL
: return _("REL (Relocatable file)");
1502 case ET_EXEC
: return _("EXEC (Executable file)");
1503 case ET_DYN
: return _("DYN (Shared object file)");
1504 case ET_CORE
: return _("CORE (Core file)");
1507 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1508 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1509 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1510 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1512 sprintf (buff
, _("<unknown>: %x"), e_type
);
1518 get_machine_name (e_machine
)
1521 static char buff
[64]; /* XXX */
1525 case EM_NONE
: return _("None");
1526 case EM_M32
: return "WE32100";
1527 case EM_SPARC
: return "Sparc";
1528 case EM_386
: return "Intel 80386";
1529 case EM_68K
: return "MC68000";
1530 case EM_88K
: return "MC88000";
1531 case EM_486
: return "Intel 80486";
1532 case EM_860
: return "Intel 80860";
1533 case EM_MIPS
: return "MIPS R3000";
1534 case EM_S370
: return "IBM System/370";
1535 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1536 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1537 case EM_PARISC
: return "HPPA";
1538 case EM_PPC_OLD
: return "Power PC (old)";
1539 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1540 case EM_960
: return "Intel 90860";
1541 case EM_PPC
: return "PowerPC";
1542 case EM_PPC64
: return "PowerPC64";
1543 case EM_V800
: return "NEC V800";
1544 case EM_FR20
: return "Fujitsu FR20";
1545 case EM_RH32
: return "TRW RH32";
1546 case EM_MCORE
: return "MCORE";
1547 case EM_ARM
: return "ARM";
1548 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1549 case EM_SH
: return "Hitachi SH";
1550 case EM_SPARCV9
: return "Sparc v9";
1551 case EM_TRICORE
: return "Siemens Tricore";
1552 case EM_ARC
: return "ARC";
1553 case EM_H8_300
: return "Hitachi H8/300";
1554 case EM_H8_300H
: return "Hitachi H8/300H";
1555 case EM_H8S
: return "Hitachi H8S";
1556 case EM_H8_500
: return "Hitachi H8/500";
1557 case EM_IA_64
: return "Intel IA-64";
1558 case EM_MIPS_X
: return "Stanford MIPS-X";
1559 case EM_COLDFIRE
: return "Motorola Coldfire";
1560 case EM_68HC12
: return "Motorola M68HC12";
1561 case EM_ALPHA
: return "Alpha";
1562 case EM_CYGNUS_D10V
:
1563 case EM_D10V
: return "d10v";
1564 case EM_CYGNUS_D30V
:
1565 case EM_D30V
: return "d30v";
1566 case EM_CYGNUS_M32R
:
1567 case EM_M32R
: return "Mitsubishi M32r";
1568 case EM_CYGNUS_V850
:
1569 case EM_V850
: return "NEC v850";
1570 case EM_CYGNUS_MN10300
:
1571 case EM_MN10300
: return "mn10300";
1572 case EM_CYGNUS_MN10200
:
1573 case EM_MN10200
: return "mn10200";
1574 case EM_CYGNUS_FR30
:
1575 case EM_FR30
: return "Fujitsu FR30";
1576 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1578 case EM_PJ
: return "picoJava";
1579 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1580 case EM_PCP
: return "Siemens PCP";
1581 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1582 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1583 case EM_STARCORE
: return "Motorola Star*Core processor";
1584 case EM_ME16
: return "Toyota ME16 processor";
1585 case EM_ST100
: return "STMicroelectronics ST100 processor";
1586 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1587 case EM_FX66
: return "Siemens FX66 microcontroller";
1588 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1589 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1590 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1591 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1592 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1593 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1594 case EM_SVX
: return "Silicon Graphics SVx";
1595 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1596 case EM_VAX
: return "Digital VAX";
1598 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1599 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1600 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1601 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1602 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1603 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1604 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1605 case EM_PRISM
: return "SiTera Prism";
1606 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1608 case EM_S390
: return "IBM S/390";
1609 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1611 case EM_OR32
: return "OpenRISC";
1612 case EM_DLX
: return "OpenDLX";
1614 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1616 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1622 decode_ARM_machine_flags (e_flags
, buf
)
1629 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1630 e_flags
&= ~ EF_ARM_EABIMASK
;
1632 /* Handle "generic" ARM flags. */
1633 if (e_flags
& EF_ARM_RELEXEC
)
1635 strcat (buf
, ", relocatable executable");
1636 e_flags
&= ~ EF_ARM_RELEXEC
;
1639 if (e_flags
& EF_ARM_HASENTRY
)
1641 strcat (buf
, ", has entry point");
1642 e_flags
&= ~ EF_ARM_HASENTRY
;
1645 /* Now handle EABI specific flags. */
1649 strcat (buf
, ", <unrecognized EABI>");
1654 case EF_ARM_EABI_VER1
:
1655 strcat (buf
, ", Version1 EABI");
1660 /* Process flags one bit at a time. */
1661 flag
= e_flags
& - e_flags
;
1666 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1667 strcat (buf
, ", sorted symbol tables");
1677 case EF_ARM_EABI_VER2
:
1678 strcat (buf
, ", Version2 EABI");
1683 /* Process flags one bit at a time. */
1684 flag
= e_flags
& - e_flags
;
1689 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1690 strcat (buf
, ", sorted symbol tables");
1693 case EF_ARM_DYNSYMSUSESEGIDX
:
1694 strcat (buf
, ", dynamic symbols use segment index");
1697 case EF_ARM_MAPSYMSFIRST
:
1698 strcat (buf
, ", mapping symbols precede others");
1708 case EF_ARM_EABI_UNKNOWN
:
1709 strcat (buf
, ", GNU EABI");
1714 /* Process flags one bit at a time. */
1715 flag
= e_flags
& - e_flags
;
1720 case EF_ARM_INTERWORK
:
1721 strcat (buf
, ", interworking enabled");
1724 case EF_ARM_APCS_26
:
1725 strcat (buf
, ", uses APCS/26");
1728 case EF_ARM_APCS_FLOAT
:
1729 strcat (buf
, ", uses APCS/float");
1733 strcat (buf
, ", position independent");
1737 strcat (buf
, ", 8 bit structure alignment");
1740 case EF_ARM_NEW_ABI
:
1741 strcat (buf
, ", uses new ABI");
1744 case EF_ARM_OLD_ABI
:
1745 strcat (buf
, ", uses old ABI");
1748 case EF_ARM_SOFT_FLOAT
:
1749 strcat (buf
, ", software FP");
1760 strcat (buf
,", <unknown>");
1764 get_machine_flags (e_flags
, e_machine
)
1768 static char buf
[1024];
1780 decode_ARM_machine_flags (e_flags
, buf
);
1784 if (e_flags
& EF_CPU32
)
1785 strcat (buf
, ", cpu32");
1786 if (e_flags
& EF_M68000
)
1787 strcat (buf
, ", m68000");
1791 if (e_flags
& EF_PPC_EMB
)
1792 strcat (buf
, ", emb");
1794 if (e_flags
& EF_PPC_RELOCATABLE
)
1795 strcat (buf
, ", relocatable");
1797 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1798 strcat (buf
, ", relocatable-lib");
1802 case EM_CYGNUS_V850
:
1803 switch (e_flags
& EF_V850_ARCH
)
1806 strcat (buf
, ", v850e");
1809 strcat (buf
, ", v850");
1812 strcat (buf
, ", unknown v850 architecture variant");
1818 case EM_CYGNUS_M32R
:
1819 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1820 strcat (buf
, ", m32r");
1825 case EM_MIPS_RS3_LE
:
1826 if (e_flags
& EF_MIPS_NOREORDER
)
1827 strcat (buf
, ", noreorder");
1829 if (e_flags
& EF_MIPS_PIC
)
1830 strcat (buf
, ", pic");
1832 if (e_flags
& EF_MIPS_CPIC
)
1833 strcat (buf
, ", cpic");
1835 if (e_flags
& EF_MIPS_UCODE
)
1836 strcat (buf
, ", ugen_reserved");
1838 if (e_flags
& EF_MIPS_ABI2
)
1839 strcat (buf
, ", abi2");
1841 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1842 strcat (buf
, ", odk first");
1844 if (e_flags
& EF_MIPS_32BITMODE
)
1845 strcat (buf
, ", 32bitmode");
1847 switch ((e_flags
& EF_MIPS_MACH
))
1849 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1850 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1851 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1852 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1853 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1854 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1855 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1856 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1857 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1859 /* We simply ignore the field in this case to avoid confusion:
1860 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1863 default: strcat (buf
, ", unknown CPU"); break;
1866 switch ((e_flags
& EF_MIPS_ABI
))
1868 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1869 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1870 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1871 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1873 /* We simply ignore the field in this case to avoid confusion:
1874 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1875 This means it is likely to be an o32 file, but not for
1878 default: strcat (buf
, ", unknown ABI"); break;
1881 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1882 strcat (buf
, ", mdmx");
1884 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1885 strcat (buf
, ", mips16");
1887 switch ((e_flags
& EF_MIPS_ARCH
))
1889 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1890 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1891 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1892 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1893 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1894 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1895 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1896 default: strcat (buf
, ", unknown ISA"); break;
1902 if (e_flags
& EF_SPARC_32PLUS
)
1903 strcat (buf
, ", v8+");
1905 if (e_flags
& EF_SPARC_SUN_US1
)
1906 strcat (buf
, ", ultrasparcI");
1908 if (e_flags
& EF_SPARC_SUN_US3
)
1909 strcat (buf
, ", ultrasparcIII");
1911 if (e_flags
& EF_SPARC_HAL_R1
)
1912 strcat (buf
, ", halr1");
1914 if (e_flags
& EF_SPARC_LEDATA
)
1915 strcat (buf
, ", ledata");
1917 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1918 strcat (buf
, ", tso");
1920 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1921 strcat (buf
, ", pso");
1923 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1924 strcat (buf
, ", rmo");
1928 switch (e_flags
& EF_PARISC_ARCH
)
1930 case EFA_PARISC_1_0
:
1931 strcpy (buf
, ", PA-RISC 1.0");
1933 case EFA_PARISC_1_1
:
1934 strcpy (buf
, ", PA-RISC 1.1");
1936 case EFA_PARISC_2_0
:
1937 strcpy (buf
, ", PA-RISC 2.0");
1942 if (e_flags
& EF_PARISC_TRAPNIL
)
1943 strcat (buf
, ", trapnil");
1944 if (e_flags
& EF_PARISC_EXT
)
1945 strcat (buf
, ", ext");
1946 if (e_flags
& EF_PARISC_LSB
)
1947 strcat (buf
, ", lsb");
1948 if (e_flags
& EF_PARISC_WIDE
)
1949 strcat (buf
, ", wide");
1950 if (e_flags
& EF_PARISC_NO_KABP
)
1951 strcat (buf
, ", no kabp");
1952 if (e_flags
& EF_PARISC_LAZYSWAP
)
1953 strcat (buf
, ", lazyswap");
1958 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1959 strcat (buf
, ", new calling convention");
1961 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1962 strcat (buf
, ", gnu calling convention");
1966 if ((e_flags
& EF_IA_64_ABI64
))
1967 strcat (buf
, ", 64-bit");
1969 strcat (buf
, ", 32-bit");
1970 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1971 strcat (buf
, ", reduced fp model");
1972 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1973 strcat (buf
, ", no function descriptors, constant gp");
1974 else if ((e_flags
& EF_IA_64_CONS_GP
))
1975 strcat (buf
, ", constant gp");
1976 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1977 strcat (buf
, ", absolute");
1981 if ((e_flags
& EF_VAX_NONPIC
))
1982 strcat (buf
, ", non-PIC");
1983 if ((e_flags
& EF_VAX_DFLOAT
))
1984 strcat (buf
, ", D-Float");
1985 if ((e_flags
& EF_VAX_GFLOAT
))
1986 strcat (buf
, ", G-Float");
1995 get_mips_segment_type (type
)
2000 case PT_MIPS_REGINFO
:
2002 case PT_MIPS_RTPROC
:
2004 case PT_MIPS_OPTIONS
:
2014 get_parisc_segment_type (type
)
2019 case PT_HP_TLS
: return "HP_TLS";
2020 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2021 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2022 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2023 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2024 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2025 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2026 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2027 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2028 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2029 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2030 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2031 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2032 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2041 get_ia64_segment_type (type
)
2046 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2047 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2048 case PT_HP_TLS
: return "HP_TLS";
2049 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2050 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2051 case PT_IA_64_HP_STACK
: return "HP_STACK";
2060 get_segment_type (p_type
)
2061 unsigned long p_type
;
2063 static char buff
[32];
2067 case PT_NULL
: return "NULL";
2068 case PT_LOAD
: return "LOAD";
2069 case PT_DYNAMIC
: return "DYNAMIC";
2070 case PT_INTERP
: return "INTERP";
2071 case PT_NOTE
: return "NOTE";
2072 case PT_SHLIB
: return "SHLIB";
2073 case PT_PHDR
: return "PHDR";
2074 case PT_TLS
: return "TLS";
2076 case PT_GNU_EH_FRAME
:
2077 return "GNU_EH_FRAME";
2080 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2082 const char * result
;
2084 switch (elf_header
.e_machine
)
2087 case EM_MIPS_RS3_LE
:
2088 result
= get_mips_segment_type (p_type
);
2091 result
= get_parisc_segment_type (p_type
);
2094 result
= get_ia64_segment_type (p_type
);
2104 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2106 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2108 const char * result
;
2110 switch (elf_header
.e_machine
)
2113 result
= get_parisc_segment_type (p_type
);
2116 result
= get_ia64_segment_type (p_type
);
2126 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2129 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2136 get_mips_section_type_name (sh_type
)
2137 unsigned int sh_type
;
2141 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2142 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2143 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2144 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2145 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2146 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2147 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2148 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2149 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2150 case SHT_MIPS_RELD
: return "MIPS_RELD";
2151 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2152 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2153 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2154 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2155 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2156 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2157 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2158 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2159 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2160 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2161 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2162 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2163 case SHT_MIPS_LINE
: return "MIPS_LINE";
2164 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2165 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2166 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2167 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2168 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2169 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2170 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2171 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2172 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2173 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2174 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2175 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2176 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2177 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2178 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2179 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2187 get_parisc_section_type_name (sh_type
)
2188 unsigned int sh_type
;
2192 case SHT_PARISC_EXT
: return "PARISC_EXT";
2193 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2194 case SHT_PARISC_DOC
: return "PARISC_DOC";
2202 get_ia64_section_type_name (sh_type
)
2203 unsigned int sh_type
;
2207 case SHT_IA_64_EXT
: return "IA_64_EXT";
2208 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2216 get_section_type_name (sh_type
)
2217 unsigned int sh_type
;
2219 static char buff
[32];
2223 case SHT_NULL
: return "NULL";
2224 case SHT_PROGBITS
: return "PROGBITS";
2225 case SHT_SYMTAB
: return "SYMTAB";
2226 case SHT_STRTAB
: return "STRTAB";
2227 case SHT_RELA
: return "RELA";
2228 case SHT_HASH
: return "HASH";
2229 case SHT_DYNAMIC
: return "DYNAMIC";
2230 case SHT_NOTE
: return "NOTE";
2231 case SHT_NOBITS
: return "NOBITS";
2232 case SHT_REL
: return "REL";
2233 case SHT_SHLIB
: return "SHLIB";
2234 case SHT_DYNSYM
: return "DYNSYM";
2235 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2236 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2237 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2238 case SHT_GROUP
: return "GROUP";
2239 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2240 case SHT_GNU_verdef
: return "VERDEF";
2241 case SHT_GNU_verneed
: return "VERNEED";
2242 case SHT_GNU_versym
: return "VERSYM";
2243 case 0x6ffffff0: return "VERSYM";
2244 case 0x6ffffffc: return "VERDEF";
2245 case 0x7ffffffd: return "AUXILIARY";
2246 case 0x7fffffff: return "FILTER";
2247 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2250 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2252 const char * result
;
2254 switch (elf_header
.e_machine
)
2257 case EM_MIPS_RS3_LE
:
2258 result
= get_mips_section_type_name (sh_type
);
2261 result
= get_parisc_section_type_name (sh_type
);
2264 result
= get_ia64_section_type_name (sh_type
);
2274 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2276 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2277 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2278 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2279 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2281 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2287 #define OPTION_DEBUG_DUMP 512
2289 struct option options
[] =
2291 {"all", no_argument
, 0, 'a'},
2292 {"file-header", no_argument
, 0, 'h'},
2293 {"program-headers", no_argument
, 0, 'l'},
2294 {"headers", no_argument
, 0, 'e'},
2295 {"histogram", no_argument
, 0, 'I'},
2296 {"segments", no_argument
, 0, 'l'},
2297 {"sections", no_argument
, 0, 'S'},
2298 {"section-headers", no_argument
, 0, 'S'},
2299 {"symbols", no_argument
, 0, 's'},
2300 {"syms", no_argument
, 0, 's'},
2301 {"relocs", no_argument
, 0, 'r'},
2302 {"notes", no_argument
, 0, 'n'},
2303 {"dynamic", no_argument
, 0, 'd'},
2304 {"arch-specific", no_argument
, 0, 'A'},
2305 {"version-info", no_argument
, 0, 'V'},
2306 {"use-dynamic", no_argument
, 0, 'D'},
2307 {"hex-dump", required_argument
, 0, 'x'},
2308 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2309 {"unwind", no_argument
, 0, 'u'},
2310 #ifdef SUPPORT_DISASSEMBLY
2311 {"instruction-dump", required_argument
, 0, 'i'},
2314 {"version", no_argument
, 0, 'v'},
2315 {"wide", no_argument
, 0, 'W'},
2316 {"help", no_argument
, 0, 'H'},
2317 {0, no_argument
, 0, 0}
2323 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2324 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2325 fprintf (stdout
, _(" Options are:\n\
2326 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2327 -h --file-header Display the ELF file header\n\
2328 -l --program-headers Display the program headers\n\
2329 --segments An alias for --program-headers\n\
2330 -S --section-headers Display the sections' header\n\
2331 --sections An alias for --section-headers\n\
2332 -e --headers Equivalent to: -h -l -S\n\
2333 -s --syms Display the symbol table\n\
2334 --symbols An alias for --syms\n\
2335 -n --notes Display the core notes (if present)\n\
2336 -r --relocs Display the relocations (if present)\n\
2337 -u --unwind Display the unwind info (if present)\n\
2338 -d --dynamic Display the dynamic segment (if present)\n\
2339 -V --version-info Display the version sections (if present)\n\
2340 -A --arch-specific Display architecture specific information (if any).\n\
2341 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2342 -x --hex-dump=<number> Dump the contents of section <number>\n\
2343 -w[liaprmfFso] or\n\
2344 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2345 Display the contents of DWARF2 debug sections\n"));
2346 #ifdef SUPPORT_DISASSEMBLY
2347 fprintf (stdout
, _("\
2348 -i --instruction-dump=<number>\n\
2349 Disassemble the contents of section <number>\n"));
2351 fprintf (stdout
, _("\
2352 -I --histogram Display histogram of bucket list lengths\n\
2353 -W --wide Allow output width to exceed 80 characters\n\
2354 -H --help Display this information\n\
2355 -v --version Display the version number of readelf\n"));
2356 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2362 request_dump (section
, type
)
2363 unsigned int section
;
2366 if (section
>= num_dump_sects
)
2368 char * new_dump_sects
;
2370 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2372 if (new_dump_sects
== NULL
)
2373 error (_("Out of memory allocating dump request table."));
2376 /* Copy current flag settings. */
2377 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2381 dump_sects
= new_dump_sects
;
2382 num_dump_sects
= section
+ 1;
2387 dump_sects
[section
] |= type
;
2393 parse_args (argc
, argv
)
2402 while ((c
= getopt_long
2403 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2439 do_using_dynamic
++;
2470 section
= strtoul (optarg
, & cp
, 0);
2471 if (! * cp
&& section
>= 0)
2473 request_dump (section
, HEX_DUMP
);
2483 unsigned int index
= 0;
2487 while (optarg
[index
])
2488 switch (optarg
[index
++])
2497 do_debug_abbrevs
= 1;
2507 do_debug_pubnames
= 1;
2512 do_debug_aranges
= 1;
2516 do_debug_frames_interp
= 1;
2518 do_debug_frames
= 1;
2523 do_debug_macinfo
= 1;
2537 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2542 case OPTION_DEBUG_DUMP
:
2548 static const char *debug_dump_opt
[]
2549 = { "line", "info", "abbrev", "pubnames", "ranges",
2550 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2559 for (index
= 0; debug_dump_opt
[index
]; index
++)
2561 size_t len
= strlen (debug_dump_opt
[index
]);
2563 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2564 && (p
[len
] == ',' || p
[len
] == '\0'))
2573 do_debug_abbrevs
= 1;
2584 do_debug_pubnames
= 1;
2588 do_debug_aranges
= 1;
2593 do_debug_frames_interp
= 1;
2594 do_debug_frames
= 1;
2598 do_debug_macinfo
= 1;
2611 if (debug_dump_opt
[index
] == NULL
)
2613 warn (_("Unrecognized debug option '%s'\n"), p
);
2614 p
= strchr (p
, ',');
2624 #ifdef SUPPORT_DISASSEMBLY
2627 section
= strtoul (optarg
, & cp
, 0);
2628 if (! * cp
&& section
>= 0)
2630 request_dump (section
, DISASS_DUMP
);
2636 print_version (program_name
);
2646 /* xgettext:c-format */
2647 error (_("Invalid option '-%c'\n"), c
);
2654 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2655 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2656 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2660 warn (_("Nothing to do.\n"));
2666 get_elf_class (elf_class
)
2667 unsigned int elf_class
;
2669 static char buff
[32];
2673 case ELFCLASSNONE
: return _("none");
2674 case ELFCLASS32
: return "ELF32";
2675 case ELFCLASS64
: return "ELF64";
2677 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2683 get_data_encoding (encoding
)
2684 unsigned int encoding
;
2686 static char buff
[32];
2690 case ELFDATANONE
: return _("none");
2691 case ELFDATA2LSB
: return _("2's complement, little endian");
2692 case ELFDATA2MSB
: return _("2's complement, big endian");
2694 sprintf (buff
, _("<unknown: %x>"), encoding
);
2700 get_osabi_name (osabi
)
2703 static char buff
[32];
2707 case ELFOSABI_NONE
: return "UNIX - System V";
2708 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2709 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2710 case ELFOSABI_LINUX
: return "UNIX - Linux";
2711 case ELFOSABI_HURD
: return "GNU/Hurd";
2712 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2713 case ELFOSABI_AIX
: return "UNIX - AIX";
2714 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2715 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2716 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2717 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2718 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2719 case ELFOSABI_STANDALONE
: return _("Standalone App");
2720 case ELFOSABI_ARM
: return "ARM";
2722 sprintf (buff
, _("<unknown: %x>"), osabi
);
2727 /* Decode the data held in 'elf_header'. */
2729 process_file_header ()
2731 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2732 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2733 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2734 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2737 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2745 printf (_("ELF Header:\n"));
2746 printf (_(" Magic: "));
2747 for (i
= 0; i
< EI_NIDENT
; i
++)
2748 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2750 printf (_(" Class: %s\n"),
2751 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2752 printf (_(" Data: %s\n"),
2753 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2754 printf (_(" Version: %d %s\n"),
2755 elf_header
.e_ident
[EI_VERSION
],
2756 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2758 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2761 printf (_(" OS/ABI: %s\n"),
2762 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2763 printf (_(" ABI Version: %d\n"),
2764 elf_header
.e_ident
[EI_ABIVERSION
]);
2765 printf (_(" Type: %s\n"),
2766 get_file_type (elf_header
.e_type
));
2767 printf (_(" Machine: %s\n"),
2768 get_machine_name (elf_header
.e_machine
));
2769 printf (_(" Version: 0x%lx\n"),
2770 (unsigned long) elf_header
.e_version
);
2772 printf (_(" Entry point address: "));
2773 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2774 printf (_("\n Start of program headers: "));
2775 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2776 printf (_(" (bytes into file)\n Start of section headers: "));
2777 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2778 printf (_(" (bytes into file)\n"));
2780 printf (_(" Flags: 0x%lx%s\n"),
2781 (unsigned long) elf_header
.e_flags
,
2782 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2783 printf (_(" Size of this header: %ld (bytes)\n"),
2784 (long) elf_header
.e_ehsize
);
2785 printf (_(" Size of program headers: %ld (bytes)\n"),
2786 (long) elf_header
.e_phentsize
);
2787 printf (_(" Number of program headers: %ld\n"),
2788 (long) elf_header
.e_phnum
);
2789 printf (_(" Size of section headers: %ld (bytes)\n"),
2790 (long) elf_header
.e_shentsize
);
2791 printf (_(" Number of section headers: %ld"),
2792 (long) elf_header
.e_shnum
);
2793 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2794 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2795 putc ('\n', stdout
);
2796 printf (_(" Section header string table index: %ld"),
2797 (long) elf_header
.e_shstrndx
);
2798 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2799 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2800 putc ('\n', stdout
);
2803 if (section_headers
!= NULL
)
2805 if (elf_header
.e_shnum
== 0)
2806 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2807 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2808 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2809 free (section_headers
);
2810 section_headers
= NULL
;
2818 get_32bit_program_headers (file
, program_headers
)
2820 Elf_Internal_Phdr
* program_headers
;
2822 Elf32_External_Phdr
* phdrs
;
2823 Elf32_External_Phdr
* external
;
2824 Elf32_Internal_Phdr
* internal
;
2827 phdrs
= ((Elf32_External_Phdr
*)
2828 get_data (NULL
, file
, elf_header
.e_phoff
,
2829 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2830 _("program headers")));
2834 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2835 i
< elf_header
.e_phnum
;
2836 i
++, internal
++, external
++)
2838 internal
->p_type
= BYTE_GET (external
->p_type
);
2839 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2840 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2841 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2842 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2843 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2844 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2845 internal
->p_align
= BYTE_GET (external
->p_align
);
2854 get_64bit_program_headers (file
, program_headers
)
2856 Elf_Internal_Phdr
* program_headers
;
2858 Elf64_External_Phdr
* phdrs
;
2859 Elf64_External_Phdr
* external
;
2860 Elf64_Internal_Phdr
* internal
;
2863 phdrs
= ((Elf64_External_Phdr
*)
2864 get_data (NULL
, file
, elf_header
.e_phoff
,
2865 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2866 _("program headers")));
2870 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2871 i
< elf_header
.e_phnum
;
2872 i
++, internal
++, external
++)
2874 internal
->p_type
= BYTE_GET (external
->p_type
);
2875 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2876 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2877 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2878 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2879 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2880 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2881 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2889 /* Returns 1 if the program headers were loaded. */
2892 process_program_headers (file
)
2895 Elf_Internal_Phdr
* program_headers
;
2896 Elf_Internal_Phdr
* segment
;
2899 if (elf_header
.e_phnum
== 0)
2902 printf (_("\nThere are no program headers in this file.\n"));
2906 if (do_segments
&& !do_header
)
2908 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2909 printf (_("Entry point "));
2910 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2911 printf (_("\nThere are %d program headers, starting at offset "),
2912 elf_header
.e_phnum
);
2913 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2917 program_headers
= (Elf_Internal_Phdr
*) malloc
2918 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2920 if (program_headers
== NULL
)
2922 error (_("Out of memory\n"));
2927 i
= get_32bit_program_headers (file
, program_headers
);
2929 i
= get_64bit_program_headers (file
, program_headers
);
2933 free (program_headers
);
2939 if (elf_header
.e_phnum
> 1)
2940 printf (_("\nProgram Headers:\n"));
2942 printf (_("\nProgram Headers:\n"));
2946 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2949 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2953 (_(" Type Offset VirtAddr PhysAddr\n"));
2955 (_(" FileSiz MemSiz Flags Align\n"));
2963 for (i
= 0, segment
= program_headers
;
2964 i
< elf_header
.e_phnum
;
2969 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2973 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2974 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2975 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2976 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2977 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2979 (segment
->p_flags
& PF_R
? 'R' : ' '),
2980 (segment
->p_flags
& PF_W
? 'W' : ' '),
2981 (segment
->p_flags
& PF_X
? 'E' : ' '));
2982 printf ("%#lx", (unsigned long) segment
->p_align
);
2986 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2987 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2990 print_vma (segment
->p_offset
, FULL_HEX
);
2994 print_vma (segment
->p_vaddr
, FULL_HEX
);
2996 print_vma (segment
->p_paddr
, FULL_HEX
);
2999 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3000 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3003 print_vma (segment
->p_filesz
, FULL_HEX
);
3007 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3008 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3011 print_vma (segment
->p_offset
, FULL_HEX
);
3015 (segment
->p_flags
& PF_R
? 'R' : ' '),
3016 (segment
->p_flags
& PF_W
? 'W' : ' '),
3017 (segment
->p_flags
& PF_X
? 'E' : ' '));
3019 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3020 printf ("%#lx", (unsigned long) segment
->p_align
);
3023 print_vma (segment
->p_align
, PREFIX_HEX
);
3028 print_vma (segment
->p_offset
, FULL_HEX
);
3030 print_vma (segment
->p_vaddr
, FULL_HEX
);
3032 print_vma (segment
->p_paddr
, FULL_HEX
);
3034 print_vma (segment
->p_filesz
, FULL_HEX
);
3036 print_vma (segment
->p_memsz
, FULL_HEX
);
3038 (segment
->p_flags
& PF_R
? 'R' : ' '),
3039 (segment
->p_flags
& PF_W
? 'W' : ' '),
3040 (segment
->p_flags
& PF_X
? 'E' : ' '));
3041 print_vma (segment
->p_align
, HEX
);
3045 switch (segment
->p_type
)
3049 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
3050 - (segment
->p_offset
& 0xfffff000);
3055 error (_("more than one dynamic segment\n"));
3057 dynamic_addr
= segment
->p_offset
;
3058 dynamic_size
= segment
->p_filesz
;
3062 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
3063 error (_("Unable to find program interpreter name\n"));
3066 program_interpreter
[0] = 0;
3067 fscanf (file
, "%63s", program_interpreter
);
3070 printf (_("\n [Requesting program interpreter: %s]"),
3071 program_interpreter
);
3077 putc ('\n', stdout
);
3086 if (do_segments
&& section_headers
!= NULL
)
3088 printf (_("\n Section to Segment mapping:\n"));
3089 printf (_(" Segment Sections...\n"));
3091 assert (string_table
!= NULL
);
3093 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3096 Elf_Internal_Shdr
* section
;
3098 segment
= program_headers
+ i
;
3099 section
= section_headers
;
3101 printf (" %2.2d ", i
);
3103 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3105 if (section
->sh_size
> 0
3106 /* Compare allocated sections by VMA, unallocated
3107 sections by file offset. */
3108 && (section
->sh_flags
& SHF_ALLOC
3109 ? (section
->sh_addr
>= segment
->p_vaddr
3110 && section
->sh_addr
+ section
->sh_size
3111 <= segment
->p_vaddr
+ segment
->p_memsz
)
3112 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3113 && (section
->sh_offset
+ section
->sh_size
3114 <= segment
->p_offset
+ segment
->p_filesz
))))
3115 printf ("%s ", SECTION_NAME (section
));
3122 free (program_headers
);
3129 get_32bit_section_headers (file
, num
)
3133 Elf32_External_Shdr
* shdrs
;
3134 Elf32_Internal_Shdr
* internal
;
3137 shdrs
= ((Elf32_External_Shdr
*)
3138 get_data (NULL
, file
, elf_header
.e_shoff
,
3139 elf_header
.e_shentsize
* num
,
3140 _("section headers")));
3144 section_headers
= ((Elf_Internal_Shdr
*)
3145 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3147 if (section_headers
== NULL
)
3149 error (_("Out of memory\n"));
3153 for (i
= 0, internal
= section_headers
;
3157 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3158 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3159 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3160 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3161 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3162 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3163 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3164 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3165 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3166 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3175 get_64bit_section_headers (file
, num
)
3179 Elf64_External_Shdr
* shdrs
;
3180 Elf64_Internal_Shdr
* internal
;
3183 shdrs
= ((Elf64_External_Shdr
*)
3184 get_data (NULL
, file
, elf_header
.e_shoff
,
3185 elf_header
.e_shentsize
* num
,
3186 _("section headers")));
3190 section_headers
= ((Elf_Internal_Shdr
*)
3191 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3193 if (section_headers
== NULL
)
3195 error (_("Out of memory\n"));
3199 for (i
= 0, internal
= section_headers
;
3203 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3204 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3205 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3206 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3207 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3208 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3209 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3210 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3211 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3212 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3220 static Elf_Internal_Sym
*
3221 get_32bit_elf_symbols (file
, section
)
3223 Elf_Internal_Shdr
*section
;
3225 unsigned long number
;
3226 Elf32_External_Sym
* esyms
;
3227 Elf_External_Sym_Shndx
*shndx
;
3228 Elf_Internal_Sym
* isyms
;
3229 Elf_Internal_Sym
* psym
;
3232 esyms
= ((Elf32_External_Sym
*)
3233 get_data (NULL
, file
, section
->sh_offset
,
3234 section
->sh_size
, _("symbols")));
3239 if (symtab_shndx_hdr
!= NULL
3240 && (symtab_shndx_hdr
->sh_link
3241 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3243 shndx
= ((Elf_External_Sym_Shndx
*)
3244 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3245 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3253 number
= section
->sh_size
/ section
->sh_entsize
;
3254 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3258 error (_("Out of memory\n"));
3265 for (j
= 0, psym
= isyms
;
3269 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3270 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3271 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3272 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3273 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3275 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3276 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3277 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3287 static Elf_Internal_Sym
*
3288 get_64bit_elf_symbols (file
, section
)
3290 Elf_Internal_Shdr
*section
;
3292 unsigned long number
;
3293 Elf64_External_Sym
* esyms
;
3294 Elf_External_Sym_Shndx
*shndx
;
3295 Elf_Internal_Sym
* isyms
;
3296 Elf_Internal_Sym
* psym
;
3299 esyms
= ((Elf64_External_Sym
*)
3300 get_data (NULL
, file
, section
->sh_offset
,
3301 section
->sh_size
, _("symbols")));
3306 if (symtab_shndx_hdr
!= NULL
3307 && (symtab_shndx_hdr
->sh_link
3308 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3310 shndx
= ((Elf_External_Sym_Shndx
*)
3311 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3312 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3320 number
= section
->sh_size
/ section
->sh_entsize
;
3321 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3325 error (_("Out of memory\n"));
3332 for (j
= 0, psym
= isyms
;
3336 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3337 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3338 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3339 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3340 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3342 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3343 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3344 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3355 get_elf_section_flags (sh_flags
)
3358 static char buff
[32];
3366 flag
= sh_flags
& - sh_flags
;
3371 case SHF_WRITE
: strcat (buff
, "W"); break;
3372 case SHF_ALLOC
: strcat (buff
, "A"); break;
3373 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3374 case SHF_MERGE
: strcat (buff
, "M"); break;
3375 case SHF_STRINGS
: strcat (buff
, "S"); break;
3376 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3377 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3378 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3379 case SHF_GROUP
: strcat (buff
, "G"); break;
3380 case SHF_TLS
: strcat (buff
, "T"); break;
3383 if (flag
& SHF_MASKOS
)
3386 sh_flags
&= ~ SHF_MASKOS
;
3388 else if (flag
& SHF_MASKPROC
)
3391 sh_flags
&= ~ SHF_MASKPROC
;
3403 process_section_headers (file
)
3406 Elf_Internal_Shdr
* section
;
3409 section_headers
= NULL
;
3411 if (elf_header
.e_shnum
== 0)
3414 printf (_("\nThere are no sections in this file.\n"));
3419 if (do_sections
&& !do_header
)
3420 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3421 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3425 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3428 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3431 /* Read in the string table, so that we have names to display. */
3432 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3434 if (section
->sh_size
!= 0)
3436 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3437 section
->sh_size
, _("string table"));
3439 string_table_length
= section
->sh_size
;
3442 /* Scan the sections for the dynamic symbol table
3443 and dynamic string table and debug sections. */
3444 dynamic_symbols
= NULL
;
3445 dynamic_strings
= NULL
;
3446 dynamic_syminfo
= NULL
;
3447 symtab_shndx_hdr
= NULL
;
3449 for (i
= 0, section
= section_headers
;
3450 i
< elf_header
.e_shnum
;
3453 char * name
= SECTION_NAME (section
);
3455 if (section
->sh_type
== SHT_DYNSYM
)
3457 if (dynamic_symbols
!= NULL
)
3459 error (_("File contains multiple dynamic symbol tables\n"));
3463 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3464 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3466 else if (section
->sh_type
== SHT_STRTAB
3467 && strcmp (name
, ".dynstr") == 0)
3469 if (dynamic_strings
!= NULL
)
3471 error (_("File contains multiple dynamic string tables\n"));
3475 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3477 _("dynamic strings"));
3479 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3481 if (symtab_shndx_hdr
!= NULL
)
3483 error (_("File contains multiple symtab shndx tables\n"));
3486 symtab_shndx_hdr
= section
;
3488 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3489 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3490 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3492 && strncmp (name
, ".debug_", 7) == 0)
3497 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3498 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3499 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3500 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3501 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3502 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3503 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3504 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3505 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3507 request_dump (i
, DEBUG_DUMP
);
3509 /* linkonce section to be combined with .debug_info at link time. */
3510 else if ((do_debugging
|| do_debug_info
)
3511 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3512 request_dump (i
, DEBUG_DUMP
);
3513 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3514 request_dump (i
, DEBUG_DUMP
);
3520 if (elf_header
.e_shnum
> 1)
3521 printf (_("\nSection Headers:\n"));
3523 printf (_("\nSection Header:\n"));
3527 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3530 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3533 printf (_(" [Nr] Name Type Address Offset\n"));
3534 printf (_(" Size EntSize Flags Link Info Align\n"));
3537 for (i
= 0, section
= section_headers
;
3538 i
< elf_header
.e_shnum
;
3541 printf (" [%2u] %-17.17s %-15.15s ",
3542 SECTION_HEADER_NUM (i
),
3543 SECTION_NAME (section
),
3544 get_section_type_name (section
->sh_type
));
3548 print_vma (section
->sh_addr
, LONG_HEX
);
3550 printf ( " %6.6lx %6.6lx %2.2lx",
3551 (unsigned long) section
->sh_offset
,
3552 (unsigned long) section
->sh_size
,
3553 (unsigned long) section
->sh_entsize
);
3555 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3557 printf ("%2ld %3lx %2ld\n",
3558 (unsigned long) section
->sh_link
,
3559 (unsigned long) section
->sh_info
,
3560 (unsigned long) section
->sh_addralign
);
3564 print_vma (section
->sh_addr
, LONG_HEX
);
3566 if ((long) section
->sh_offset
== section
->sh_offset
)
3567 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3571 print_vma (section
->sh_offset
, LONG_HEX
);
3574 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3575 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3579 print_vma (section
->sh_size
, LONG_HEX
);
3582 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3583 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3587 print_vma (section
->sh_entsize
, LONG_HEX
);
3590 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3592 printf ("%2ld %3lx ",
3593 (unsigned long) section
->sh_link
,
3594 (unsigned long) section
->sh_info
);
3596 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3597 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3600 print_vma (section
->sh_addralign
, DEC
);
3607 print_vma (section
->sh_addr
, LONG_HEX
);
3608 if ((long) section
->sh_offset
== section
->sh_offset
)
3609 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3613 print_vma (section
->sh_offset
, LONG_HEX
);
3616 print_vma (section
->sh_size
, LONG_HEX
);
3618 print_vma (section
->sh_entsize
, LONG_HEX
);
3620 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3622 printf (" %2ld %3lx %ld\n",
3623 (unsigned long) section
->sh_link
,
3624 (unsigned long) section
->sh_info
,
3625 (unsigned long) section
->sh_addralign
);
3629 printf (_("Key to Flags:\n\
3630 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3631 I (info), L (link order), G (group), x (unknown)\n\
3632 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3637 /* Process the reloc section. */
3639 process_relocs (file
)
3642 unsigned long rel_size
;
3643 unsigned long rel_offset
;
3649 if (do_using_dynamic
)
3651 int is_rela
= FALSE
;
3656 if (dynamic_info
[DT_REL
])
3658 rel_offset
= dynamic_info
[DT_REL
];
3659 rel_size
= dynamic_info
[DT_RELSZ
];
3662 else if (dynamic_info
[DT_RELA
])
3664 rel_offset
= dynamic_info
[DT_RELA
];
3665 rel_size
= dynamic_info
[DT_RELASZ
];
3668 else if (dynamic_info
[DT_JMPREL
])
3670 rel_offset
= dynamic_info
[DT_JMPREL
];
3671 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3673 switch (dynamic_info
[DT_PLTREL
])
3690 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3691 rel_offset
, rel_size
);
3693 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3694 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3697 printf (_("\nThere are no dynamic relocations in this file.\n"));
3701 Elf32_Internal_Shdr
* section
;
3705 for (i
= 0, section
= section_headers
;
3706 i
< elf_header
.e_shnum
;
3709 if ( section
->sh_type
!= SHT_RELA
3710 && section
->sh_type
!= SHT_REL
)
3713 rel_offset
= section
->sh_offset
;
3714 rel_size
= section
->sh_size
;
3718 Elf32_Internal_Shdr
* strsec
;
3719 Elf_Internal_Sym
* symtab
;
3722 unsigned long nsyms
;
3724 printf (_("\nRelocation section "));
3726 if (string_table
== NULL
)
3727 printf ("%d", section
->sh_name
);
3729 printf (_("'%s'"), SECTION_NAME (section
));
3731 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3732 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3737 if (section
->sh_link
)
3739 Elf32_Internal_Shdr
* symsec
;
3741 symsec
= SECTION_HEADER (section
->sh_link
);
3742 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3743 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3748 strsec
= SECTION_HEADER (symsec
->sh_link
);
3750 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3754 is_rela
= section
->sh_type
== SHT_RELA
;
3756 dump_relocations (file
, rel_offset
, rel_size
,
3757 symtab
, nsyms
, strtab
, is_rela
);
3769 printf (_("\nThere are no relocations in this file.\n"));
3775 #include "unwind-ia64.h"
3777 /* An absolute address consists of a section and an offset. If the
3778 section is NULL, the offset itself is the address, otherwise, the
3779 address equals to LOAD_ADDRESS(section) + offset. */
3783 unsigned short section
;
3789 struct unw_table_entry
3791 struct absaddr start
;
3793 struct absaddr info
;
3795 *table
; /* Unwind table. */
3796 unsigned long table_len
; /* Length of unwind table. */
3797 unsigned char * info
; /* Unwind info. */
3798 unsigned long info_size
; /* Size of unwind info. */
3799 bfd_vma info_addr
; /* starting address of unwind info. */
3800 bfd_vma seg_base
; /* Starting address of segment. */
3801 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3802 unsigned long nsyms
; /* Number of symbols. */
3803 char * strtab
; /* The string table. */
3804 unsigned long strtab_size
; /* Size of string table. */
3807 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3808 struct absaddr
, const char **,
3810 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3811 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3812 Elf32_Internal_Shdr
*));
3815 find_symbol_for_address (aux
, addr
, symname
, offset
)
3816 struct unw_aux_info
*aux
;
3817 struct absaddr addr
;
3818 const char **symname
;
3821 bfd_vma dist
= (bfd_vma
) 0x100000;
3822 Elf_Internal_Sym
*sym
, *best
= NULL
;
3825 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3827 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3828 && sym
->st_name
!= 0
3829 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3830 && addr
.offset
>= sym
->st_value
3831 && addr
.offset
- sym
->st_value
< dist
)
3834 dist
= addr
.offset
- sym
->st_value
;
3841 *symname
= (best
->st_name
>= aux
->strtab_size
3842 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3847 *offset
= addr
.offset
;
3851 dump_ia64_unwind (aux
)
3852 struct unw_aux_info
*aux
;
3855 struct unw_table_entry
* tp
;
3858 addr_size
= is_32bit_elf
? 4 : 8;
3860 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3864 const unsigned char * dp
;
3865 const unsigned char * head
;
3866 const char * procname
;
3868 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3870 fputs ("\n<", stdout
);
3874 fputs (procname
, stdout
);
3877 printf ("+%lx", (unsigned long) offset
);
3880 fputs (">: [", stdout
);
3881 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3882 fputc ('-', stdout
);
3883 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3884 printf ("], info at +0x%lx\n",
3885 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3887 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3888 stamp
= BYTE_GET8 ((unsigned char *) head
);
3890 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
3891 (unsigned) UNW_VER (stamp
),
3892 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3893 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3894 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3895 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3897 if (UNW_VER (stamp
) != 1)
3899 printf ("\tUnknown version.\n");
3904 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3905 dp
= unw_decode (dp
, in_body
, & in_body
);
3910 slurp_ia64_unwind_table (file
, aux
, sec
)
3912 struct unw_aux_info
*aux
;
3913 Elf32_Internal_Shdr
*sec
;
3915 unsigned long size
, addr_size
, nrelas
, i
;
3916 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3917 struct unw_table_entry
*tep
;
3918 Elf32_Internal_Shdr
*relsec
;
3919 Elf_Internal_Rela
*rela
, *rp
;
3920 unsigned char *table
, *tp
;
3921 Elf_Internal_Sym
*sym
;
3922 const char *relname
;
3925 addr_size
= is_32bit_elf
? 4 : 8;
3927 /* First, find the starting address of the segment that includes
3930 if (elf_header
.e_phnum
)
3932 prog_hdrs
= (Elf_Internal_Phdr
*)
3933 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3936 result
= get_32bit_program_headers (file
, prog_hdrs
);
3938 result
= get_64bit_program_headers (file
, prog_hdrs
);
3946 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3948 if (seg
->p_type
!= PT_LOAD
)
3951 if (sec
->sh_addr
>= seg
->p_vaddr
3952 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3954 aux
->seg_base
= seg
->p_vaddr
;
3962 /* Second, build the unwind table from the contents of the unwind section: */
3963 size
= sec
->sh_size
;
3964 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3965 size
, _("unwind table"));
3969 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3970 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3972 tep
->start
.section
= SHN_UNDEF
;
3973 tep
->end
.section
= SHN_UNDEF
;
3974 tep
->info
.section
= SHN_UNDEF
;
3977 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3978 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3979 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3983 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3984 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3985 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3987 tep
->start
.offset
+= aux
->seg_base
;
3988 tep
->end
.offset
+= aux
->seg_base
;
3989 tep
->info
.offset
+= aux
->seg_base
;
3993 /* Third, apply any relocations to the unwind table: */
3995 for (relsec
= section_headers
;
3996 relsec
< section_headers
+ elf_header
.e_shnum
;
3999 if (relsec
->sh_type
!= SHT_RELA
4000 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4003 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4007 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4011 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4012 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4014 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4016 warn (_("Skipping unexpected symbol type %u\n"),
4017 ELF32_ST_TYPE (sym
->st_info
));
4023 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4024 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4026 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4028 warn (_("Skipping unexpected symbol type %u\n"),
4029 ELF64_ST_TYPE (sym
->st_info
));
4034 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4036 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4040 i
= rp
->r_offset
/ (3 * addr_size
);
4042 switch (rp
->r_offset
/addr_size
% 3)
4045 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4046 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4049 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4050 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4053 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4054 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4064 aux
->table_len
= size
/ (3 * addr_size
);
4069 process_unwind (file
)
4072 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4073 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4074 struct unw_aux_info aux
;
4079 if (elf_header
.e_machine
!= EM_IA_64
)
4081 printf (_("\nThere are no unwind sections in this file.\n"));
4085 memset (& aux
, 0, sizeof (aux
));
4087 addr_size
= is_32bit_elf
? 4 : 8;
4089 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4091 if (sec
->sh_type
== SHT_SYMTAB
)
4093 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4094 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4096 strsec
= SECTION_HEADER (sec
->sh_link
);
4097 aux
.strtab_size
= strsec
->sh_size
;
4098 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4099 aux
.strtab_size
, _("string table"));
4101 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4106 printf (_("\nThere are no unwind sections in this file.\n"));
4108 while (unwcount
-- > 0)
4113 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4114 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4115 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4122 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4124 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
4127 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4128 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4129 suffix
= SECTION_NAME (unwsec
) + len
;
4130 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4132 if (strncmp (SECTION_NAME (sec
),
4133 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4134 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4139 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4140 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4141 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4142 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4144 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4146 suffix
= SECTION_NAME (unwsec
) + len
;
4147 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4149 if (strncmp (SECTION_NAME (sec
),
4150 ELF_STRING_ia64_unwind_info
, len2
) == 0
4151 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4155 if (i
== elf_header
.e_shnum
)
4157 printf (_("\nCould not find unwind info section for "));
4159 if (string_table
== NULL
)
4160 printf ("%d", unwsec
->sh_name
);
4162 printf (_("'%s'"), SECTION_NAME (unwsec
));
4166 aux
.info_size
= sec
->sh_size
;
4167 aux
.info_addr
= sec
->sh_addr
;
4168 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4169 aux
.info_size
, _("unwind info"));
4171 printf (_("\nUnwind section "));
4173 if (string_table
== NULL
)
4174 printf ("%d", unwsec
->sh_name
);
4176 printf (_("'%s'"), SECTION_NAME (unwsec
));
4178 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4179 (unsigned long) unwsec
->sh_offset
,
4180 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4182 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4184 if (aux
.table_len
> 0)
4185 dump_ia64_unwind (& aux
);
4188 free ((char *) aux
.table
);
4190 free ((char *) aux
.info
);
4199 free ((char *) aux
.strtab
);
4205 dynamic_segment_mips_val (entry
)
4206 Elf_Internal_Dyn
* entry
;
4208 switch (entry
->d_tag
)
4211 if (entry
->d_un
.d_val
== 0)
4215 static const char * opts
[] =
4217 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4218 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4219 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4220 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4225 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
4226 if (entry
->d_un
.d_val
& (1 << cnt
))
4228 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4235 case DT_MIPS_IVERSION
:
4236 if (dynamic_strings
!= NULL
)
4237 printf ("Interface Version: %s\n",
4238 dynamic_strings
+ entry
->d_un
.d_val
);
4240 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4243 case DT_MIPS_TIME_STAMP
:
4248 time_t time
= entry
->d_un
.d_val
;
4249 tmp
= gmtime (&time
);
4250 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4251 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4252 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4253 printf ("Time Stamp: %s\n", timebuf
);
4257 case DT_MIPS_RLD_VERSION
:
4258 case DT_MIPS_LOCAL_GOTNO
:
4259 case DT_MIPS_CONFLICTNO
:
4260 case DT_MIPS_LIBLISTNO
:
4261 case DT_MIPS_SYMTABNO
:
4262 case DT_MIPS_UNREFEXTNO
:
4263 case DT_MIPS_HIPAGENO
:
4264 case DT_MIPS_DELTA_CLASS_NO
:
4265 case DT_MIPS_DELTA_INSTANCE_NO
:
4266 case DT_MIPS_DELTA_RELOC_NO
:
4267 case DT_MIPS_DELTA_SYM_NO
:
4268 case DT_MIPS_DELTA_CLASSSYM_NO
:
4269 case DT_MIPS_COMPACT_SIZE
:
4270 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4274 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4280 dynamic_segment_parisc_val (entry
)
4281 Elf_Internal_Dyn
* entry
;
4283 switch (entry
->d_tag
)
4285 case DT_HP_DLD_FLAGS
:
4294 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4295 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4296 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4297 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4298 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4299 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4300 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4301 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4302 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4303 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4304 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4308 bfd_vma val
= entry
->d_un
.d_val
;
4310 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4311 if (val
& flags
[cnt
].bit
)
4315 fputs (flags
[cnt
].str
, stdout
);
4317 val
^= flags
[cnt
].bit
;
4320 if (val
!= 0 || first
)
4324 print_vma (val
, HEX
);
4330 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4337 get_32bit_dynamic_segment (file
)
4340 Elf32_External_Dyn
* edyn
;
4341 Elf_Internal_Dyn
* entry
;
4344 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4345 dynamic_size
, _("dynamic segment"));
4349 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4350 how large this .dynamic is now. We can do this even before the byte
4351 swapping since the DT_NULL tag is recognizable. */
4353 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4356 dynamic_segment
= (Elf_Internal_Dyn
*)
4357 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4359 if (dynamic_segment
== NULL
)
4361 error (_("Out of memory\n"));
4366 for (i
= 0, entry
= dynamic_segment
;
4370 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4371 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4380 get_64bit_dynamic_segment (file
)
4383 Elf64_External_Dyn
* edyn
;
4384 Elf_Internal_Dyn
* entry
;
4387 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4388 dynamic_size
, _("dynamic segment"));
4392 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4393 how large this .dynamic is now. We can do this even before the byte
4394 swapping since the DT_NULL tag is recognizable. */
4396 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4399 dynamic_segment
= (Elf_Internal_Dyn
*)
4400 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4402 if (dynamic_segment
== NULL
)
4404 error (_("Out of memory\n"));
4409 for (i
= 0, entry
= dynamic_segment
;
4413 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4414 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4423 get_dynamic_flags (flags
)
4426 static char buff
[128];
4434 flag
= flags
& - flags
;
4442 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4443 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4444 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4445 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4446 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4447 default: strcpy (p
, "unknown"); break;
4450 p
= strchr (p
, '\0');
4455 /* Parse and display the contents of the dynamic segment. */
4457 process_dynamic_segment (file
)
4460 Elf_Internal_Dyn
* entry
;
4463 if (dynamic_size
== 0)
4466 printf (_("\nThere is no dynamic segment in this file.\n"));
4473 if (! get_32bit_dynamic_segment (file
))
4476 else if (! get_64bit_dynamic_segment (file
))
4479 /* Find the appropriate symbol table. */
4480 if (dynamic_symbols
== NULL
)
4482 for (i
= 0, entry
= dynamic_segment
;
4486 Elf32_Internal_Shdr section
;
4488 if (entry
->d_tag
!= DT_SYMTAB
)
4491 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4493 /* Since we do not know how big the symbol table is,
4494 we default to reading in the entire file (!) and
4495 processing that. This is overkill, I know, but it
4497 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4499 if (fseek (file
, 0, SEEK_END
))
4500 error (_("Unable to seek to end of file!"));
4502 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4504 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4506 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4508 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4509 if (num_dynamic_syms
< 1)
4511 error (_("Unable to determine the number of symbols to load\n"));
4515 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4519 /* Similarly find a string table. */
4520 if (dynamic_strings
== NULL
)
4522 for (i
= 0, entry
= dynamic_segment
;
4526 unsigned long offset
;
4529 if (entry
->d_tag
!= DT_STRTAB
)
4532 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4534 /* Since we do not know how big the string table is,
4535 we default to reading in the entire file (!) and
4536 processing that. This is overkill, I know, but it
4539 offset
= entry
->d_un
.d_val
- loadaddr
;
4540 if (fseek (file
, 0, SEEK_END
))
4541 error (_("Unable to seek to end of file\n"));
4542 str_tab_len
= ftell (file
) - offset
;
4544 if (str_tab_len
< 1)
4547 (_("Unable to determine the length of the dynamic string table\n"));
4551 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4552 _("dynamic string table"));
4557 /* And find the syminfo section if available. */
4558 if (dynamic_syminfo
== NULL
)
4560 unsigned int syminsz
= 0;
4562 for (i
= 0, entry
= dynamic_segment
;
4566 if (entry
->d_tag
== DT_SYMINENT
)
4568 /* Note: these braces are necessary to avoid a syntax
4569 error from the SunOS4 C compiler. */
4570 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4572 else if (entry
->d_tag
== DT_SYMINSZ
)
4573 syminsz
= entry
->d_un
.d_val
;
4574 else if (entry
->d_tag
== DT_SYMINFO
)
4575 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4578 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4580 Elf_External_Syminfo
* extsyminfo
;
4581 Elf_Internal_Syminfo
* syminfo
;
4583 /* There is a syminfo section. Read the data. */
4584 extsyminfo
= ((Elf_External_Syminfo
*)
4585 get_data (NULL
, file
, dynamic_syminfo_offset
,
4586 syminsz
, _("symbol information")));
4590 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4591 if (dynamic_syminfo
== NULL
)
4593 error (_("Out of memory\n"));
4597 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4598 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4601 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4602 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4609 if (do_dynamic
&& dynamic_addr
)
4610 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4611 dynamic_addr
, (long) dynamic_size
);
4613 printf (_(" Tag Type Name/Value\n"));
4615 for (i
= 0, entry
= dynamic_segment
;
4624 print_vma (entry
->d_tag
, FULL_HEX
);
4625 dtype
= get_dynamic_type (entry
->d_tag
);
4626 printf (" (%s)%*s", dtype
,
4627 ((is_32bit_elf
? 27 : 19)
4628 - (int) strlen (dtype
)),
4632 switch (entry
->d_tag
)
4636 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4646 switch (entry
->d_tag
)
4649 printf (_("Auxiliary library"));
4653 printf (_("Filter library"));
4657 printf (_("Configuration file"));
4661 printf (_("Dependency audit library"));
4665 printf (_("Audit library"));
4669 if (dynamic_strings
)
4670 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4674 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4683 printf (_("Flags:"));
4685 if (entry
->d_un
.d_val
== 0)
4686 printf (_(" None\n"));
4689 unsigned long int val
= entry
->d_un
.d_val
;
4691 if (val
& DTF_1_PARINIT
)
4693 printf (" PARINIT");
4694 val
^= DTF_1_PARINIT
;
4696 if (val
& DTF_1_CONFEXP
)
4698 printf (" CONFEXP");
4699 val
^= DTF_1_CONFEXP
;
4702 printf (" %lx", val
);
4711 printf (_("Flags:"));
4713 if (entry
->d_un
.d_val
== 0)
4714 printf (_(" None\n"));
4717 unsigned long int val
= entry
->d_un
.d_val
;
4719 if (val
& DF_P1_LAZYLOAD
)
4721 printf (" LAZYLOAD");
4722 val
^= DF_P1_LAZYLOAD
;
4724 if (val
& DF_P1_GROUPPERM
)
4726 printf (" GROUPPERM");
4727 val
^= DF_P1_GROUPPERM
;
4730 printf (" %lx", val
);
4739 printf (_("Flags:"));
4740 if (entry
->d_un
.d_val
== 0)
4741 printf (_(" None\n"));
4744 unsigned long int val
= entry
->d_un
.d_val
;
4751 if (val
& DF_1_GLOBAL
)
4756 if (val
& DF_1_GROUP
)
4761 if (val
& DF_1_NODELETE
)
4763 printf (" NODELETE");
4764 val
^= DF_1_NODELETE
;
4766 if (val
& DF_1_LOADFLTR
)
4768 printf (" LOADFLTR");
4769 val
^= DF_1_LOADFLTR
;
4771 if (val
& DF_1_INITFIRST
)
4773 printf (" INITFIRST");
4774 val
^= DF_1_INITFIRST
;
4776 if (val
& DF_1_NOOPEN
)
4781 if (val
& DF_1_ORIGIN
)
4786 if (val
& DF_1_DIRECT
)
4791 if (val
& DF_1_TRANS
)
4796 if (val
& DF_1_INTERPOSE
)
4798 printf (" INTERPOSE");
4799 val
^= DF_1_INTERPOSE
;
4801 if (val
& DF_1_NODEFLIB
)
4803 printf (" NODEFLIB");
4804 val
^= DF_1_NODEFLIB
;
4806 if (val
& DF_1_NODUMP
)
4811 if (val
& DF_1_CONLFAT
)
4813 printf (" CONLFAT");
4814 val
^= DF_1_CONLFAT
;
4817 printf (" %lx", val
);
4825 puts (get_dynamic_type (entry
->d_un
.d_val
));
4845 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4851 if (dynamic_strings
== NULL
)
4854 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4858 switch (entry
->d_tag
)
4861 printf (_("Shared library: [%s]"), name
);
4863 if (strcmp (name
, program_interpreter
) == 0)
4864 printf (_(" program interpreter"));
4868 printf (_("Library soname: [%s]"), name
);
4872 printf (_("Library rpath: [%s]"), name
);
4876 printf (_("Library runpath: [%s]"), name
);
4880 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4885 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4901 case DT_INIT_ARRAYSZ
:
4902 case DT_FINI_ARRAYSZ
:
4903 case DT_GNU_CONFLICTSZ
:
4904 case DT_GNU_LIBLISTSZ
:
4907 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4908 printf (" (bytes)\n");
4918 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4931 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4935 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4939 printf (_("Not needed object: [%s]\n"), name
);
4944 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4950 /* The value of this entry is ignored. */
4955 case DT_GNU_PRELINKED
:
4959 time_t time
= entry
->d_un
.d_val
;
4961 tmp
= gmtime (&time
);
4962 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
4963 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4964 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4970 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4971 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4976 switch (elf_header
.e_machine
)
4979 case EM_MIPS_RS3_LE
:
4980 dynamic_segment_mips_val (entry
);
4983 dynamic_segment_parisc_val (entry
);
4986 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4998 get_ver_flags (flags
)
5001 static char buff
[32];
5008 if (flags
& VER_FLG_BASE
)
5009 strcat (buff
, "BASE ");
5011 if (flags
& VER_FLG_WEAK
)
5013 if (flags
& VER_FLG_BASE
)
5014 strcat (buff
, "| ");
5016 strcat (buff
, "WEAK ");
5019 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5020 strcat (buff
, "| <unknown>");
5025 /* Display the contents of the version sections. */
5027 process_version_sections (file
)
5030 Elf32_Internal_Shdr
* section
;
5037 for (i
= 0, section
= section_headers
;
5038 i
< elf_header
.e_shnum
;
5041 switch (section
->sh_type
)
5043 case SHT_GNU_verdef
:
5045 Elf_External_Verdef
* edefs
;
5052 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5053 SECTION_NAME (section
), section
->sh_info
);
5055 printf (_(" Addr: 0x"));
5056 printf_vma (section
->sh_addr
);
5057 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5058 (unsigned long) section
->sh_offset
, section
->sh_link
,
5059 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5061 edefs
= ((Elf_External_Verdef
*)
5062 get_data (NULL
, file
, section
->sh_offset
,
5064 _("version definition section")));
5068 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
5071 Elf_External_Verdef
* edef
;
5072 Elf_Internal_Verdef ent
;
5073 Elf_External_Verdaux
* eaux
;
5074 Elf_Internal_Verdaux aux
;
5078 vstart
= ((char *) edefs
) + idx
;
5080 edef
= (Elf_External_Verdef
*) vstart
;
5082 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5083 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5084 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5085 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5086 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5087 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5088 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5090 printf (_(" %#06x: Rev: %d Flags: %s"),
5091 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5093 printf (_(" Index: %d Cnt: %d "),
5094 ent
.vd_ndx
, ent
.vd_cnt
);
5096 vstart
+= ent
.vd_aux
;
5098 eaux
= (Elf_External_Verdaux
*) vstart
;
5100 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5101 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5103 if (dynamic_strings
)
5104 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5106 printf (_("Name index: %ld\n"), aux
.vda_name
);
5108 isum
= idx
+ ent
.vd_aux
;
5110 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5112 isum
+= aux
.vda_next
;
5113 vstart
+= aux
.vda_next
;
5115 eaux
= (Elf_External_Verdaux
*) vstart
;
5117 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5118 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5120 if (dynamic_strings
)
5121 printf (_(" %#06x: Parent %d: %s\n"),
5122 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5124 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5125 isum
, j
, aux
.vda_name
);
5135 case SHT_GNU_verneed
:
5137 Elf_External_Verneed
* eneed
;
5143 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5144 SECTION_NAME (section
), section
->sh_info
);
5146 printf (_(" Addr: 0x"));
5147 printf_vma (section
->sh_addr
);
5148 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5149 (unsigned long) section
->sh_offset
, section
->sh_link
,
5150 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5152 eneed
= ((Elf_External_Verneed
*)
5153 get_data (NULL
, file
, section
->sh_offset
,
5154 section
->sh_size
, _("version need section")));
5158 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5160 Elf_External_Verneed
* entry
;
5161 Elf_Internal_Verneed ent
;
5166 vstart
= ((char *) eneed
) + idx
;
5168 entry
= (Elf_External_Verneed
*) vstart
;
5170 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5171 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5172 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5173 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5174 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5176 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5178 if (dynamic_strings
)
5179 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5181 printf (_(" File: %lx"), ent
.vn_file
);
5183 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5185 vstart
+= ent
.vn_aux
;
5187 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5189 Elf_External_Vernaux
* eaux
;
5190 Elf_Internal_Vernaux aux
;
5192 eaux
= (Elf_External_Vernaux
*) vstart
;
5194 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5195 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5196 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5197 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5198 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5200 if (dynamic_strings
)
5201 printf (_(" %#06x: Name: %s"),
5202 isum
, dynamic_strings
+ aux
.vna_name
);
5204 printf (_(" %#06x: Name index: %lx"),
5205 isum
, aux
.vna_name
);
5207 printf (_(" Flags: %s Version: %d\n"),
5208 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5210 isum
+= aux
.vna_next
;
5211 vstart
+= aux
.vna_next
;
5221 case SHT_GNU_versym
:
5223 Elf32_Internal_Shdr
* link_section
;
5226 unsigned char * edata
;
5227 unsigned short * data
;
5229 Elf_Internal_Sym
* symbols
;
5230 Elf32_Internal_Shdr
* string_sec
;
5232 link_section
= SECTION_HEADER (section
->sh_link
);
5233 total
= section
->sh_size
/ section
->sh_entsize
;
5237 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5239 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5241 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5242 string_sec
->sh_size
,
5243 _("version string table"));
5247 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5248 SECTION_NAME (section
), total
);
5250 printf (_(" Addr: "));
5251 printf_vma (section
->sh_addr
);
5252 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5253 (unsigned long) section
->sh_offset
, section
->sh_link
,
5254 SECTION_NAME (link_section
));
5258 get_data (NULL
, file
,
5259 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5260 total
* sizeof (short), _("version symbol data")));
5267 data
= (unsigned short *) malloc (total
* sizeof (short));
5269 for (cnt
= total
; cnt
--;)
5270 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5275 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5278 int check_def
, check_need
;
5281 printf (" %03x:", cnt
);
5283 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5284 switch (data
[cnt
+ j
])
5287 fputs (_(" 0 (*local*) "), stdout
);
5291 fputs (_(" 1 (*global*) "), stdout
);
5295 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5296 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5300 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5303 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5310 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5312 Elf_Internal_Verneed ivn
;
5313 unsigned long offset
;
5315 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5320 Elf_Internal_Vernaux ivna
;
5321 Elf_External_Verneed evn
;
5322 Elf_External_Vernaux evna
;
5323 unsigned long a_off
;
5325 get_data (&evn
, file
, offset
, sizeof (evn
),
5328 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5329 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5331 a_off
= offset
+ ivn
.vn_aux
;
5335 get_data (&evna
, file
, a_off
, sizeof (evna
),
5336 _("version need aux (2)"));
5338 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5339 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5341 a_off
+= ivna
.vna_next
;
5343 while (ivna
.vna_other
!= data
[cnt
+ j
]
5344 && ivna
.vna_next
!= 0);
5346 if (ivna
.vna_other
== data
[cnt
+ j
])
5348 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5350 name
= strtab
+ ivna
.vna_name
;
5351 nn
+= printf ("(%s%-*s",
5353 12 - (int) strlen (name
),
5359 offset
+= ivn
.vn_next
;
5361 while (ivn
.vn_next
);
5364 if (check_def
&& data
[cnt
+ j
] != 0x8001
5365 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5367 Elf_Internal_Verdef ivd
;
5368 Elf_External_Verdef evd
;
5369 unsigned long offset
;
5371 offset
= version_info
5372 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
5376 get_data (&evd
, file
, offset
, sizeof (evd
),
5379 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5380 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5382 offset
+= ivd
.vd_next
;
5384 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5385 && ivd
.vd_next
!= 0);
5387 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5389 Elf_External_Verdaux evda
;
5390 Elf_Internal_Verdaux ivda
;
5392 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5394 get_data (&evda
, file
,
5395 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5396 sizeof (evda
), _("version def aux"));
5398 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5400 name
= strtab
+ ivda
.vda_name
;
5401 nn
+= printf ("(%s%-*s",
5403 12 - (int) strlen (name
),
5409 printf ("%*c", 18 - nn
, ' ');
5427 printf (_("\nNo version information found in this file.\n"));
5433 get_symbol_binding (binding
)
5434 unsigned int binding
;
5436 static char buff
[32];
5440 case STB_LOCAL
: return "LOCAL";
5441 case STB_GLOBAL
: return "GLOBAL";
5442 case STB_WEAK
: return "WEAK";
5444 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5445 sprintf (buff
, _("<processor specific>: %d"), binding
);
5446 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5447 sprintf (buff
, _("<OS specific>: %d"), binding
);
5449 sprintf (buff
, _("<unknown>: %d"), binding
);
5455 get_symbol_type (type
)
5458 static char buff
[32];
5462 case STT_NOTYPE
: return "NOTYPE";
5463 case STT_OBJECT
: return "OBJECT";
5464 case STT_FUNC
: return "FUNC";
5465 case STT_SECTION
: return "SECTION";
5466 case STT_FILE
: return "FILE";
5467 case STT_COMMON
: return "COMMON";
5468 case STT_TLS
: return "TLS";
5470 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5472 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5473 return "THUMB_FUNC";
5475 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5478 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5479 return "PARISC_MILLI";
5481 sprintf (buff
, _("<processor specific>: %d"), type
);
5483 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5485 if (elf_header
.e_machine
== EM_PARISC
)
5487 if (type
== STT_HP_OPAQUE
)
5489 if (type
== STT_HP_STUB
)
5493 sprintf (buff
, _("<OS specific>: %d"), type
);
5496 sprintf (buff
, _("<unknown>: %d"), type
);
5502 get_symbol_visibility (visibility
)
5503 unsigned int visibility
;
5507 case STV_DEFAULT
: return "DEFAULT";
5508 case STV_INTERNAL
: return "INTERNAL";
5509 case STV_HIDDEN
: return "HIDDEN";
5510 case STV_PROTECTED
: return "PROTECTED";
5516 get_symbol_index_type (type
)
5519 static char buff
[32];
5523 case SHN_UNDEF
: return "UND";
5524 case SHN_ABS
: return "ABS";
5525 case SHN_COMMON
: return "COM";
5527 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5528 sprintf (buff
, "PRC[0x%04x]", type
);
5529 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5530 sprintf (buff
, "OS [0x%04x]", type
);
5531 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5532 sprintf (buff
, "RSV[0x%04x]", type
);
5534 sprintf (buff
, "%3d", type
);
5542 get_dynamic_data (file
, number
)
5544 unsigned int number
;
5546 unsigned char * e_data
;
5549 e_data
= (unsigned char *) malloc (number
* 4);
5553 error (_("Out of memory\n"));
5557 if (fread (e_data
, 4, number
, file
) != number
)
5559 error (_("Unable to read in dynamic data\n"));
5563 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5567 error (_("Out of memory\n"));
5573 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5580 /* Dump the symbol table. */
5582 process_symbol_table (file
)
5585 Elf32_Internal_Shdr
* section
;
5586 unsigned char nb
[4];
5587 unsigned char nc
[4];
5590 int * buckets
= NULL
;
5591 int * chains
= NULL
;
5593 if (! do_syms
&& !do_histogram
)
5596 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5599 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5601 error (_("Unable to seek to start of dynamic information"));
5605 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5607 error (_("Failed to read in number of buckets\n"));
5611 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5613 error (_("Failed to read in number of chains\n"));
5617 nbuckets
= byte_get (nb
, 4);
5618 nchains
= byte_get (nc
, 4);
5620 buckets
= get_dynamic_data (file
, nbuckets
);
5621 chains
= get_dynamic_data (file
, nchains
);
5623 if (buckets
== NULL
|| chains
== NULL
)
5628 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5633 printf (_("\nSymbol table for image:\n"));
5635 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5637 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5639 for (hn
= 0; hn
< nbuckets
; hn
++)
5644 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5646 Elf_Internal_Sym
* psym
;
5648 psym
= dynamic_symbols
+ si
;
5650 printf (" %3d %3d: ", si
, hn
);
5651 print_vma (psym
->st_value
, LONG_HEX
);
5653 print_vma (psym
->st_size
, DEC_5
);
5655 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5656 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5657 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5658 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5659 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5664 else if (do_syms
&& !do_using_dynamic
)
5668 for (i
= 0, section
= section_headers
;
5669 i
< elf_header
.e_shnum
;
5674 Elf_Internal_Sym
* symtab
;
5675 Elf_Internal_Sym
* psym
;
5678 if ( section
->sh_type
!= SHT_SYMTAB
5679 && section
->sh_type
!= SHT_DYNSYM
)
5682 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5683 SECTION_NAME (section
),
5684 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5686 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5688 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5690 symtab
= GET_ELF_SYMBOLS (file
, section
);
5694 if (section
->sh_link
== elf_header
.e_shstrndx
)
5695 strtab
= string_table
;
5698 Elf32_Internal_Shdr
* string_sec
;
5700 string_sec
= SECTION_HEADER (section
->sh_link
);
5702 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5703 string_sec
->sh_size
,
5707 for (si
= 0, psym
= symtab
;
5708 si
< section
->sh_size
/ section
->sh_entsize
;
5711 printf ("%6d: ", si
);
5712 print_vma (psym
->st_value
, LONG_HEX
);
5714 print_vma (psym
->st_size
, DEC_5
);
5715 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5716 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5717 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5718 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5719 print_symbol (25, strtab
+ psym
->st_name
);
5721 if (section
->sh_type
== SHT_DYNSYM
&&
5722 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5724 unsigned char data
[2];
5725 unsigned short vers_data
;
5726 unsigned long offset
;
5730 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5733 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5734 sizeof (data
), _("version data"));
5736 vers_data
= byte_get (data
, 2);
5738 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5741 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5743 if ((vers_data
& 0x8000) || vers_data
> 1)
5745 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5746 && (is_nobits
|| ! check_def
))
5748 Elf_External_Verneed evn
;
5749 Elf_Internal_Verneed ivn
;
5750 Elf_Internal_Vernaux ivna
;
5752 /* We must test both. */
5753 offset
= version_info
5754 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5758 unsigned long vna_off
;
5760 get_data (&evn
, file
, offset
, sizeof (evn
),
5763 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5764 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5766 vna_off
= offset
+ ivn
.vn_aux
;
5770 Elf_External_Vernaux evna
;
5772 get_data (&evna
, file
, vna_off
,
5774 _("version need aux (3)"));
5776 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5777 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5778 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5780 vna_off
+= ivna
.vna_next
;
5782 while (ivna
.vna_other
!= vers_data
5783 && ivna
.vna_next
!= 0);
5785 if (ivna
.vna_other
== vers_data
)
5788 offset
+= ivn
.vn_next
;
5790 while (ivn
.vn_next
!= 0);
5792 if (ivna
.vna_other
== vers_data
)
5795 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5798 else if (! is_nobits
)
5799 error (_("bad dynamic symbol"));
5806 if (vers_data
!= 0x8001
5807 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5809 Elf_Internal_Verdef ivd
;
5810 Elf_Internal_Verdaux ivda
;
5811 Elf_External_Verdaux evda
;
5812 unsigned long offset
;
5815 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5820 Elf_External_Verdef evd
;
5822 get_data (&evd
, file
, offset
, sizeof (evd
),
5825 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5826 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5827 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5829 offset
+= ivd
.vd_next
;
5831 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5832 && ivd
.vd_next
!= 0);
5834 offset
-= ivd
.vd_next
;
5835 offset
+= ivd
.vd_aux
;
5837 get_data (&evda
, file
, offset
, sizeof (evda
),
5838 _("version def aux"));
5840 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5842 if (psym
->st_name
!= ivda
.vda_name
)
5843 printf ((vers_data
& 0x8000)
5845 strtab
+ ivda
.vda_name
);
5855 if (strtab
!= string_table
)
5861 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5863 if (do_histogram
&& buckets
!= NULL
)
5870 int nzero_counts
= 0;
5873 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5875 printf (_(" Length Number %% of total Coverage\n"));
5877 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5878 if (lengths
== NULL
)
5880 error (_("Out of memory"));
5883 for (hn
= 0; hn
< nbuckets
; ++hn
)
5888 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5891 if (maxlength
< ++lengths
[hn
])
5896 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5899 error (_("Out of memory"));
5903 for (hn
= 0; hn
< nbuckets
; ++hn
)
5904 ++ counts
[lengths
[hn
]];
5908 printf (" 0 %-10d (%5.1f%%)\n",
5909 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5910 for (si
= 1; si
<= maxlength
; ++si
)
5912 nzero_counts
+= counts
[si
] * si
;
5913 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5914 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5915 (nzero_counts
* 100.0) / nsyms
);
5923 if (buckets
!= NULL
)
5933 process_syminfo (file
)
5934 FILE * file ATTRIBUTE_UNUSED
;
5938 if (dynamic_syminfo
== NULL
5940 /* No syminfo, this is ok. */
5943 /* There better should be a dynamic symbol section. */
5944 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5948 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5949 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5951 printf (_(" Num: Name BoundTo Flags\n"));
5952 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5954 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5956 printf ("%4d: ", i
);
5957 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5960 switch (dynamic_syminfo
[i
].si_boundto
)
5962 case SYMINFO_BT_SELF
:
5963 fputs ("SELF ", stdout
);
5965 case SYMINFO_BT_PARENT
:
5966 fputs ("PARENT ", stdout
);
5969 if (dynamic_syminfo
[i
].si_boundto
> 0
5970 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5972 print_symbol (10, dynamic_strings
5974 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5978 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5982 if (flags
& SYMINFO_FLG_DIRECT
)
5984 if (flags
& SYMINFO_FLG_PASSTHRU
)
5985 printf (" PASSTHRU");
5986 if (flags
& SYMINFO_FLG_COPY
)
5988 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5989 printf (" LAZYLOAD");
5997 #ifdef SUPPORT_DISASSEMBLY
5999 disassemble_section (section
, file
)
6000 Elf32_Internal_Shdr
* section
;
6003 printf (_("\nAssembly dump of section %s\n"),
6004 SECTION_NAME (section
));
6006 /* XXX -- to be done --- XXX */
6013 dump_section (section
, file
)
6014 Elf32_Internal_Shdr
* section
;
6017 bfd_size_type bytes
;
6019 unsigned char * data
;
6020 unsigned char * start
;
6022 bytes
= section
->sh_size
;
6026 printf (_("\nSection '%s' has no data to dump.\n"),
6027 SECTION_NAME (section
));
6031 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6033 addr
= section
->sh_addr
;
6035 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
6048 lbytes
= (bytes
> 16 ? 16 : bytes
);
6050 printf (" 0x%8.8lx ", (unsigned long) addr
);
6052 switch (elf_header
.e_ident
[EI_DATA
])
6056 for (j
= 15; j
>= 0; j
--)
6059 printf ("%2.2x", data
[j
]);
6069 for (j
= 0; j
< 16; j
++)
6072 printf ("%2.2x", data
[j
]);
6082 for (j
= 0; j
< lbytes
; j
++)
6085 if (k
>= ' ' && k
< 0x80)
6104 static unsigned long int
6105 read_leb128 (data
, length_return
, sign
)
6106 unsigned char * data
;
6107 int * length_return
;
6110 unsigned long int result
= 0;
6111 unsigned int num_read
= 0;
6120 result
|= (byte
& 0x7f) << shift
;
6125 while (byte
& 0x80);
6127 if (length_return
!= NULL
)
6128 * length_return
= num_read
;
6130 if (sign
&& (shift
< 32) && (byte
& 0x40))
6131 result
|= -1 << shift
;
6136 typedef struct State_Machine_Registers
6138 unsigned long address
;
6141 unsigned int column
;
6145 /* This variable hold the number of the last entry seen
6146 in the File Table. */
6147 unsigned int last_file_entry
;
6150 static SMR state_machine_regs
;
6153 reset_state_machine (is_stmt
)
6156 state_machine_regs
.address
= 0;
6157 state_machine_regs
.file
= 1;
6158 state_machine_regs
.line
= 1;
6159 state_machine_regs
.column
= 0;
6160 state_machine_regs
.is_stmt
= is_stmt
;
6161 state_machine_regs
.basic_block
= 0;
6162 state_machine_regs
.end_sequence
= 0;
6163 state_machine_regs
.last_file_entry
= 0;
6166 /* Handled an extend line op. Returns true if this is the end
6169 process_extended_line_op (data
, is_stmt
, pointer_size
)
6170 unsigned char * data
;
6174 unsigned char op_code
;
6177 unsigned char * name
;
6180 len
= read_leb128 (data
, & bytes_read
, 0);
6185 warn (_("badly formed extended line op encountered!\n"));
6190 op_code
= * data
++;
6192 printf (_(" Extended opcode %d: "), op_code
);
6196 case DW_LNE_end_sequence
:
6197 printf (_("End of Sequence\n\n"));
6198 reset_state_machine (is_stmt
);
6201 case DW_LNE_set_address
:
6202 adr
= byte_get (data
, pointer_size
);
6203 printf (_("set Address to 0x%lx\n"), adr
);
6204 state_machine_regs
.address
= adr
;
6207 case DW_LNE_define_file
:
6208 printf (_(" define new File Table entry\n"));
6209 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6211 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6213 data
+= strlen ((char *) data
) + 1;
6214 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6216 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6218 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6219 printf (_("%s\n\n"), name
);
6223 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6230 /* Size of pointers in the .debug_line section. This information is not
6231 really present in that section. It's obtained before dumping the debug
6232 sections by doing some pre-scan of the .debug_info section. */
6233 static int debug_line_pointer_size
= 4;
6236 display_debug_lines (section
, start
, file
)
6237 Elf32_Internal_Shdr
* section
;
6238 unsigned char * start
;
6239 FILE * file ATTRIBUTE_UNUSED
;
6241 DWARF2_External_LineInfo
* external
;
6242 DWARF2_Internal_LineInfo info
;
6243 unsigned char * standard_opcodes
;
6244 unsigned char * data
= start
;
6245 unsigned char * end
= start
+ section
->sh_size
;
6246 unsigned char * end_of_sequence
;
6249 printf (_("\nDump of debug contents of section %s:\n\n"),
6250 SECTION_NAME (section
));
6254 external
= (DWARF2_External_LineInfo
*) data
;
6256 /* Check the length of the block. */
6257 info
.li_length
= BYTE_GET (external
->li_length
);
6259 if (info
.li_length
== 0xffffffff)
6261 warn (_("64-bit DWARF line info is not supported yet.\n"));
6265 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6268 (_("The line info appears to be corrupt - the section is too small\n"));
6272 /* Check its version number. */
6273 info
.li_version
= BYTE_GET (external
->li_version
);
6274 if (info
.li_version
!= 2)
6276 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6280 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6281 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6282 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6283 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6284 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6285 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6287 /* Sign extend the line base field. */
6288 info
.li_line_base
<<= 24;
6289 info
.li_line_base
>>= 24;
6291 printf (_(" Length: %ld\n"), info
.li_length
);
6292 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6293 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6294 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6295 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6296 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6297 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6298 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6300 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6302 reset_state_machine (info
.li_default_is_stmt
);
6304 /* Display the contents of the Opcodes table. */
6305 standard_opcodes
= data
+ sizeof (* external
);
6307 printf (_("\n Opcodes:\n"));
6309 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6310 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6312 /* Display the contents of the Directory table. */
6313 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6316 printf (_("\n The Directory Table is empty.\n"));
6319 printf (_("\n The Directory Table:\n"));
6323 printf (_(" %s\n"), data
);
6325 data
+= strlen ((char *) data
) + 1;
6329 /* Skip the NUL at the end of the table. */
6332 /* Display the contents of the File Name table. */
6334 printf (_("\n The File Name Table is empty.\n"));
6337 printf (_("\n The File Name Table:\n"));
6338 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6342 unsigned char * name
;
6345 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6348 data
+= strlen ((char *) data
) + 1;
6350 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6352 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6354 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6356 printf (_("%s\n"), name
);
6360 /* Skip the NUL at the end of the table. */
6363 /* Now display the statements. */
6364 printf (_("\n Line Number Statements:\n"));
6367 while (data
< end_of_sequence
)
6369 unsigned char op_code
;
6373 op_code
= * data
++;
6375 if (op_code
>= info
.li_opcode_base
)
6377 op_code
-= info
.li_opcode_base
;
6378 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6379 state_machine_regs
.address
+= adv
;
6380 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6381 op_code
, adv
, state_machine_regs
.address
);
6382 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6383 state_machine_regs
.line
+= adv
;
6384 printf (_(" and Line by %d to %d\n"),
6385 adv
, state_machine_regs
.line
);
6387 else switch (op_code
)
6389 case DW_LNS_extended_op
:
6390 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6391 debug_line_pointer_size
);
6395 printf (_(" Copy\n"));
6398 case DW_LNS_advance_pc
:
6399 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6401 state_machine_regs
.address
+= adv
;
6402 printf (_(" Advance PC by %d to %lx\n"), adv
,
6403 state_machine_regs
.address
);
6406 case DW_LNS_advance_line
:
6407 adv
= read_leb128 (data
, & bytes_read
, 1);
6409 state_machine_regs
.line
+= adv
;
6410 printf (_(" Advance Line by %d to %d\n"), adv
,
6411 state_machine_regs
.line
);
6414 case DW_LNS_set_file
:
6415 adv
= read_leb128 (data
, & bytes_read
, 0);
6417 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6419 state_machine_regs
.file
= adv
;
6422 case DW_LNS_set_column
:
6423 adv
= read_leb128 (data
, & bytes_read
, 0);
6425 printf (_(" Set column to %d\n"), adv
);
6426 state_machine_regs
.column
= adv
;
6429 case DW_LNS_negate_stmt
:
6430 adv
= state_machine_regs
.is_stmt
;
6432 printf (_(" Set is_stmt to %d\n"), adv
);
6433 state_machine_regs
.is_stmt
= adv
;
6436 case DW_LNS_set_basic_block
:
6437 printf (_(" Set basic block\n"));
6438 state_machine_regs
.basic_block
= 1;
6441 case DW_LNS_const_add_pc
:
6442 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6443 * info
.li_min_insn_length
);
6444 state_machine_regs
.address
+= adv
;
6445 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6446 state_machine_regs
.address
);
6449 case DW_LNS_fixed_advance_pc
:
6450 adv
= byte_get (data
, 2);
6452 state_machine_regs
.address
+= adv
;
6453 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6454 adv
, state_machine_regs
.address
);
6457 case DW_LNS_set_prologue_end
:
6458 printf (_(" Set prologue_end to true\n"));
6461 case DW_LNS_set_epilogue_begin
:
6462 printf (_(" Set epilogue_begin to true\n"));
6465 case DW_LNS_set_isa
:
6466 adv
= read_leb128 (data
, & bytes_read
, 0);
6468 printf (_(" Set ISA to %d\n"), adv
);
6472 printf (_(" Unknown opcode %d with operands: "), op_code
);
6475 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6477 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6478 i
== 1 ? "" : ", ");
6493 display_debug_pubnames (section
, start
, file
)
6494 Elf32_Internal_Shdr
* section
;
6495 unsigned char * start
;
6496 FILE * file ATTRIBUTE_UNUSED
;
6498 DWARF2_External_PubNames
* external
;
6499 DWARF2_Internal_PubNames pubnames
;
6500 unsigned char * end
;
6502 end
= start
+ section
->sh_size
;
6504 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6508 unsigned char * data
;
6509 unsigned long offset
;
6511 external
= (DWARF2_External_PubNames
*) start
;
6513 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6514 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6515 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6516 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6518 data
= start
+ sizeof (* external
);
6519 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6521 if (pubnames
.pn_length
== 0xffffffff)
6523 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6527 if (pubnames
.pn_version
!= 2)
6529 static int warned
= 0;
6533 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6540 printf (_(" Length: %ld\n"),
6541 pubnames
.pn_length
);
6542 printf (_(" Version: %d\n"),
6543 pubnames
.pn_version
);
6544 printf (_(" Offset into .debug_info section: %ld\n"),
6545 pubnames
.pn_offset
);
6546 printf (_(" Size of area in .debug_info section: %ld\n"),
6549 printf (_("\n Offset\tName\n"));
6553 offset
= byte_get (data
, 4);
6558 printf (" %ld\t\t%s\n", offset
, data
);
6559 data
+= strlen ((char *) data
) + 1;
6562 while (offset
!= 0);
6575 case DW_TAG_padding
: return "DW_TAG_padding";
6576 case DW_TAG_array_type
: return "DW_TAG_array_type";
6577 case DW_TAG_class_type
: return "DW_TAG_class_type";
6578 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6579 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6580 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6581 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6582 case DW_TAG_label
: return "DW_TAG_label";
6583 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6584 case DW_TAG_member
: return "DW_TAG_member";
6585 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6586 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6587 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6588 case DW_TAG_string_type
: return "DW_TAG_string_type";
6589 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6590 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6591 case DW_TAG_typedef
: return "DW_TAG_typedef";
6592 case DW_TAG_union_type
: return "DW_TAG_union_type";
6593 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6594 case DW_TAG_variant
: return "DW_TAG_variant";
6595 case DW_TAG_common_block
: return "DW_TAG_common_block";
6596 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6597 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6598 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6599 case DW_TAG_module
: return "DW_TAG_module";
6600 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6601 case DW_TAG_set_type
: return "DW_TAG_set_type";
6602 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6603 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6604 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6605 case DW_TAG_base_type
: return "DW_TAG_base_type";
6606 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6607 case DW_TAG_const_type
: return "DW_TAG_const_type";
6608 case DW_TAG_constant
: return "DW_TAG_constant";
6609 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6610 case DW_TAG_file_type
: return "DW_TAG_file_type";
6611 case DW_TAG_friend
: return "DW_TAG_friend";
6612 case DW_TAG_namelist
: return "DW_TAG_namelist";
6613 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6614 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6615 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6616 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6617 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6618 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6619 case DW_TAG_try_block
: return "DW_TAG_try_block";
6620 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6621 case DW_TAG_variable
: return "DW_TAG_variable";
6622 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6623 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6624 case DW_TAG_format_label
: return "DW_TAG_format_label";
6625 case DW_TAG_function_template
: return "DW_TAG_function_template";
6626 case DW_TAG_class_template
: return "DW_TAG_class_template";
6627 /* DWARF 2.1 values. */
6628 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6629 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6630 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6631 case DW_TAG_namespace
: return "DW_TAG_namespace";
6632 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6633 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6634 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6635 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6638 static char buffer
[100];
6640 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6647 get_AT_name (attribute
)
6648 unsigned long attribute
;
6652 case DW_AT_sibling
: return "DW_AT_sibling";
6653 case DW_AT_location
: return "DW_AT_location";
6654 case DW_AT_name
: return "DW_AT_name";
6655 case DW_AT_ordering
: return "DW_AT_ordering";
6656 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6657 case DW_AT_byte_size
: return "DW_AT_byte_size";
6658 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6659 case DW_AT_bit_size
: return "DW_AT_bit_size";
6660 case DW_AT_element_list
: return "DW_AT_element_list";
6661 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6662 case DW_AT_low_pc
: return "DW_AT_low_pc";
6663 case DW_AT_high_pc
: return "DW_AT_high_pc";
6664 case DW_AT_language
: return "DW_AT_language";
6665 case DW_AT_member
: return "DW_AT_member";
6666 case DW_AT_discr
: return "DW_AT_discr";
6667 case DW_AT_discr_value
: return "DW_AT_discr_value";
6668 case DW_AT_visibility
: return "DW_AT_visibility";
6669 case DW_AT_import
: return "DW_AT_import";
6670 case DW_AT_string_length
: return "DW_AT_string_length";
6671 case DW_AT_common_reference
: return "DW_AT_common_reference";
6672 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6673 case DW_AT_const_value
: return "DW_AT_const_value";
6674 case DW_AT_containing_type
: return "DW_AT_containing_type";
6675 case DW_AT_default_value
: return "DW_AT_default_value";
6676 case DW_AT_inline
: return "DW_AT_inline";
6677 case DW_AT_is_optional
: return "DW_AT_is_optional";
6678 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6679 case DW_AT_producer
: return "DW_AT_producer";
6680 case DW_AT_prototyped
: return "DW_AT_prototyped";
6681 case DW_AT_return_addr
: return "DW_AT_return_addr";
6682 case DW_AT_start_scope
: return "DW_AT_start_scope";
6683 case DW_AT_stride_size
: return "DW_AT_stride_size";
6684 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6685 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6686 case DW_AT_accessibility
: return "DW_AT_accessibility";
6687 case DW_AT_address_class
: return "DW_AT_address_class";
6688 case DW_AT_artificial
: return "DW_AT_artificial";
6689 case DW_AT_base_types
: return "DW_AT_base_types";
6690 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6691 case DW_AT_count
: return "DW_AT_count";
6692 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6693 case DW_AT_decl_column
: return "DW_AT_decl_column";
6694 case DW_AT_decl_file
: return "DW_AT_decl_file";
6695 case DW_AT_decl_line
: return "DW_AT_decl_line";
6696 case DW_AT_declaration
: return "DW_AT_declaration";
6697 case DW_AT_discr_list
: return "DW_AT_discr_list";
6698 case DW_AT_encoding
: return "DW_AT_encoding";
6699 case DW_AT_external
: return "DW_AT_external";
6700 case DW_AT_frame_base
: return "DW_AT_frame_base";
6701 case DW_AT_friend
: return "DW_AT_friend";
6702 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6703 case DW_AT_macro_info
: return "DW_AT_macro_info";
6704 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6705 case DW_AT_priority
: return "DW_AT_priority";
6706 case DW_AT_segment
: return "DW_AT_segment";
6707 case DW_AT_specification
: return "DW_AT_specification";
6708 case DW_AT_static_link
: return "DW_AT_static_link";
6709 case DW_AT_type
: return "DW_AT_type";
6710 case DW_AT_use_location
: return "DW_AT_use_location";
6711 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6712 case DW_AT_virtuality
: return "DW_AT_virtuality";
6713 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6714 /* DWARF 2.1 values. */
6715 case DW_AT_allocated
: return "DW_AT_allocated";
6716 case DW_AT_associated
: return "DW_AT_associated";
6717 case DW_AT_data_location
: return "DW_AT_data_location";
6718 case DW_AT_stride
: return "DW_AT_stride";
6719 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6720 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6721 case DW_AT_extension
: return "DW_AT_extension";
6722 case DW_AT_ranges
: return "DW_AT_ranges";
6723 case DW_AT_trampoline
: return "DW_AT_trampoline";
6724 case DW_AT_call_column
: return "DW_AT_call_column";
6725 case DW_AT_call_file
: return "DW_AT_call_file";
6726 case DW_AT_call_line
: return "DW_AT_call_line";
6727 /* SGI/MIPS extensions. */
6728 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6729 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6730 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6731 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6732 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6733 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6734 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6735 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6736 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6737 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6738 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6739 /* GNU extensions. */
6740 case DW_AT_sf_names
: return "DW_AT_sf_names";
6741 case DW_AT_src_info
: return "DW_AT_src_info";
6742 case DW_AT_mac_info
: return "DW_AT_mac_info";
6743 case DW_AT_src_coords
: return "DW_AT_src_coords";
6744 case DW_AT_body_begin
: return "DW_AT_body_begin";
6745 case DW_AT_body_end
: return "DW_AT_body_end";
6746 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6749 static char buffer
[100];
6751 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6758 get_FORM_name (form
)
6763 case DW_FORM_addr
: return "DW_FORM_addr";
6764 case DW_FORM_block2
: return "DW_FORM_block2";
6765 case DW_FORM_block4
: return "DW_FORM_block4";
6766 case DW_FORM_data2
: return "DW_FORM_data2";
6767 case DW_FORM_data4
: return "DW_FORM_data4";
6768 case DW_FORM_data8
: return "DW_FORM_data8";
6769 case DW_FORM_string
: return "DW_FORM_string";
6770 case DW_FORM_block
: return "DW_FORM_block";
6771 case DW_FORM_block1
: return "DW_FORM_block1";
6772 case DW_FORM_data1
: return "DW_FORM_data1";
6773 case DW_FORM_flag
: return "DW_FORM_flag";
6774 case DW_FORM_sdata
: return "DW_FORM_sdata";
6775 case DW_FORM_strp
: return "DW_FORM_strp";
6776 case DW_FORM_udata
: return "DW_FORM_udata";
6777 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6778 case DW_FORM_ref1
: return "DW_FORM_ref1";
6779 case DW_FORM_ref2
: return "DW_FORM_ref2";
6780 case DW_FORM_ref4
: return "DW_FORM_ref4";
6781 case DW_FORM_ref8
: return "DW_FORM_ref8";
6782 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6783 case DW_FORM_indirect
: return "DW_FORM_indirect";
6786 static char buffer
[100];
6788 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6794 /* FIXME: There are better and more effiecint ways to handle
6795 these structures. For now though, I just want something that
6796 is simple to implement. */
6797 typedef struct abbrev_attr
6799 unsigned long attribute
;
6801 struct abbrev_attr
* next
;
6805 typedef struct abbrev_entry
6807 unsigned long entry
;
6810 struct abbrev_attr
* first_attr
;
6811 struct abbrev_attr
* last_attr
;
6812 struct abbrev_entry
* next
;
6816 static abbrev_entry
* first_abbrev
= NULL
;
6817 static abbrev_entry
* last_abbrev
= NULL
;
6820 free_abbrevs
PARAMS ((void))
6822 abbrev_entry
* abbrev
;
6824 for (abbrev
= first_abbrev
; abbrev
;)
6826 abbrev_entry
* next
= abbrev
->next
;
6829 for (attr
= abbrev
->first_attr
; attr
;)
6831 abbrev_attr
* next
= attr
->next
;
6841 last_abbrev
= first_abbrev
= NULL
;
6845 add_abbrev (number
, tag
, children
)
6846 unsigned long number
;
6850 abbrev_entry
* entry
;
6852 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6858 entry
->entry
= number
;
6860 entry
->children
= children
;
6861 entry
->first_attr
= NULL
;
6862 entry
->last_attr
= NULL
;
6865 if (first_abbrev
== NULL
)
6866 first_abbrev
= entry
;
6868 last_abbrev
->next
= entry
;
6870 last_abbrev
= entry
;
6874 add_abbrev_attr (attribute
, form
)
6875 unsigned long attribute
;
6880 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6886 attr
->attribute
= attribute
;
6890 if (last_abbrev
->first_attr
== NULL
)
6891 last_abbrev
->first_attr
= attr
;
6893 last_abbrev
->last_attr
->next
= attr
;
6895 last_abbrev
->last_attr
= attr
;
6898 /* Processes the (partial) contents of a .debug_abbrev section.
6899 Returns NULL if the end of the section was encountered.
6900 Returns the address after the last byte read if the end of
6901 an abbreviation set was found. */
6903 static unsigned char *
6904 process_abbrev_section (start
, end
)
6905 unsigned char * start
;
6906 unsigned char * end
;
6908 if (first_abbrev
!= NULL
)
6914 unsigned long entry
;
6916 unsigned long attribute
;
6919 entry
= read_leb128 (start
, & bytes_read
, 0);
6920 start
+= bytes_read
;
6922 /* A single zero is supposed to end the section according
6923 to the standard. If there's more, then signal that to
6926 return start
== end
? NULL
: start
;
6928 tag
= read_leb128 (start
, & bytes_read
, 0);
6929 start
+= bytes_read
;
6931 children
= * start
++;
6933 add_abbrev (entry
, tag
, children
);
6939 attribute
= read_leb128 (start
, & bytes_read
, 0);
6940 start
+= bytes_read
;
6942 form
= read_leb128 (start
, & bytes_read
, 0);
6943 start
+= bytes_read
;
6946 add_abbrev_attr (attribute
, form
);
6948 while (attribute
!= 0);
6956 display_debug_macinfo (section
, start
, file
)
6957 Elf32_Internal_Shdr
* section
;
6958 unsigned char * start
;
6959 FILE * file ATTRIBUTE_UNUSED
;
6961 unsigned char * end
= start
+ section
->sh_size
;
6962 unsigned char * curr
= start
;
6963 unsigned int bytes_read
;
6964 enum dwarf_macinfo_record_type op
;
6966 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6970 unsigned int lineno
;
6971 const char * string
;
6978 case DW_MACINFO_start_file
:
6980 unsigned int filenum
;
6982 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6984 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6987 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6991 case DW_MACINFO_end_file
:
6992 printf (_(" DW_MACINFO_end_file\n"));
6995 case DW_MACINFO_define
:
6996 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6999 curr
+= strlen (string
) + 1;
7000 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7003 case DW_MACINFO_undef
:
7004 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7007 curr
+= strlen (string
) + 1;
7008 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7011 case DW_MACINFO_vendor_ext
:
7013 unsigned int constant
;
7015 constant
= read_leb128 (curr
, & bytes_read
, 0);
7018 curr
+= strlen (string
) + 1;
7019 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7030 display_debug_abbrev (section
, start
, file
)
7031 Elf32_Internal_Shdr
* section
;
7032 unsigned char * start
;
7033 FILE * file ATTRIBUTE_UNUSED
;
7035 abbrev_entry
* entry
;
7036 unsigned char * end
= start
+ section
->sh_size
;
7038 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7042 start
= process_abbrev_section (start
, end
);
7044 if (first_abbrev
== NULL
)
7047 printf (_(" Number TAG\n"));
7049 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7053 printf (_(" %ld %s [%s]\n"),
7055 get_TAG_name (entry
->tag
),
7056 entry
->children
? _("has children") : _("no children"));
7058 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7060 printf (_(" %-18s %s\n"),
7061 get_AT_name (attr
->attribute
),
7062 get_FORM_name (attr
->form
));
7076 static unsigned char *
7077 display_block (data
, length
)
7078 unsigned char * data
;
7079 unsigned long length
;
7081 printf (_(" %lu byte block: "), length
);
7084 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7090 decode_location_expression (data
, pointer_size
, length
)
7091 unsigned char * data
;
7092 unsigned int pointer_size
;
7093 unsigned long length
;
7097 unsigned long uvalue
;
7098 unsigned char * end
= data
+ length
;
7107 printf ("DW_OP_addr: %lx",
7108 (unsigned long) byte_get (data
, pointer_size
));
7109 data
+= pointer_size
;
7112 printf ("DW_OP_deref");
7115 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7118 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7121 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7125 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7129 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7133 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7137 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7138 (unsigned long) byte_get (data
+ 4, 4));
7142 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7143 (long) byte_get (data
+ 4, 4));
7147 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7151 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7155 printf ("DW_OP_dup");
7158 printf ("DW_OP_drop");
7161 printf ("DW_OP_over");
7164 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7167 printf ("DW_OP_swap");
7170 printf ("DW_OP_rot");
7173 printf ("DW_OP_xderef");
7176 printf ("DW_OP_abs");
7179 printf ("DW_OP_and");
7182 printf ("DW_OP_div");
7185 printf ("DW_OP_minus");
7188 printf ("DW_OP_mod");
7191 printf ("DW_OP_mul");
7194 printf ("DW_OP_neg");
7197 printf ("DW_OP_not");
7200 printf ("DW_OP_or");
7203 printf ("DW_OP_plus");
7205 case DW_OP_plus_uconst
:
7206 printf ("DW_OP_plus_uconst: %lu",
7207 read_leb128 (data
, &bytes_read
, 0));
7211 printf ("DW_OP_shl");
7214 printf ("DW_OP_shr");
7217 printf ("DW_OP_shra");
7220 printf ("DW_OP_xor");
7223 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7227 printf ("DW_OP_eq");
7230 printf ("DW_OP_ge");
7233 printf ("DW_OP_gt");
7236 printf ("DW_OP_le");
7239 printf ("DW_OP_lt");
7242 printf ("DW_OP_ne");
7245 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7281 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7316 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7351 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7352 read_leb128 (data
, &bytes_read
, 1));
7357 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7361 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7365 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7367 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7368 read_leb128 (data
, &bytes_read
, 1));
7372 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7375 case DW_OP_deref_size
:
7376 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7378 case DW_OP_xderef_size
:
7379 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7382 printf ("DW_OP_nop");
7385 /* DWARF 3 extensions. */
7386 case DW_OP_push_object_address
:
7387 printf ("DW_OP_push_object_address");
7390 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7394 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7397 case DW_OP_call_ref
:
7398 printf ("DW_OP_call_ref");
7401 /* GNU extensions. */
7402 case DW_OP_GNU_push_tls_address
:
7403 printf ("DW_OP_GNU_push_tls_address");
7407 if (op
>= DW_OP_lo_user
7408 && op
<= DW_OP_hi_user
)
7409 printf (_("(User defined location op)"));
7411 printf (_("(Unknown location op)"));
7412 /* No way to tell where the next op is, so just bail. */
7416 /* Separate the ops. */
7421 static const char * debug_loc_contents
;
7422 static bfd_vma debug_loc_size
;
7425 load_debug_loc (file
)
7428 Elf32_Internal_Shdr
* sec
;
7431 /* If it is already loaded, do nothing. */
7432 if (debug_loc_contents
!= NULL
)
7435 /* Locate the .debug_loc section. */
7436 for (i
= 0, sec
= section_headers
;
7437 i
< elf_header
.e_shnum
;
7439 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7442 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7445 debug_loc_size
= sec
->sh_size
;
7447 debug_loc_contents
= ((char *)
7448 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7449 _("debug_loc section data")));
7455 if (debug_loc_contents
== NULL
)
7458 free ((char *) debug_loc_contents
);
7459 debug_loc_contents
= NULL
;
7465 display_debug_loc (section
, start
, file
)
7466 Elf32_Internal_Shdr
* section
;
7467 unsigned char * start
;
7468 FILE * file ATTRIBUTE_UNUSED
;
7470 unsigned char *section_end
;
7471 unsigned long bytes
;
7472 unsigned char *section_begin
= start
;
7475 addr
= section
->sh_addr
;
7476 bytes
= section
->sh_size
;
7477 section_end
= start
+ bytes
;
7481 printf (_("\nThe .debug_loc section is empty.\n"));
7485 printf (_("Contents of the .debug_loc section:\n\n"));
7486 printf (_("\n Offset Begin End Expression\n"));
7488 while (start
< section_end
)
7490 unsigned long begin
;
7492 unsigned short length
;
7493 unsigned long offset
;
7495 offset
= start
- section_begin
;
7499 /* Normally, the lists in the debug_loc section are related to a
7500 given compilation unit, and thus, we would use the
7501 pointer size of that compilation unit. However, since we are
7502 displaying it seperately here, we either have to store
7503 pointer sizes of all compilation units, or assume they don't
7504 change. We assume, like the debug_line display, that
7505 it doesn't change. */
7506 begin
= byte_get (start
, debug_line_pointer_size
);
7507 start
+= debug_line_pointer_size
;
7508 end
= byte_get (start
, debug_line_pointer_size
);
7509 start
+= debug_line_pointer_size
;
7511 if (begin
== 0 && end
== 0)
7517 length
= byte_get (start
, 2);
7520 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7521 decode_location_expression (start
, debug_line_pointer_size
, length
);
7531 static const char * debug_str_contents
;
7532 static bfd_vma debug_str_size
;
7535 load_debug_str (file
)
7538 Elf32_Internal_Shdr
* sec
;
7541 /* If it is already loaded, do nothing. */
7542 if (debug_str_contents
!= NULL
)
7545 /* Locate the .debug_str section. */
7546 for (i
= 0, sec
= section_headers
;
7547 i
< elf_header
.e_shnum
;
7549 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7552 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7555 debug_str_size
= sec
->sh_size
;
7557 debug_str_contents
= ((char *)
7558 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7559 _("debug_str section data")));
7565 if (debug_str_contents
== NULL
)
7568 free ((char *) debug_str_contents
);
7569 debug_str_contents
= NULL
;
7574 fetch_indirect_string (offset
)
7575 unsigned long offset
;
7577 if (debug_str_contents
== NULL
)
7578 return _("<no .debug_str section>");
7580 if (offset
> debug_str_size
)
7581 return _("<offset is too big>");
7583 return debug_str_contents
+ offset
;
7587 display_debug_str (section
, start
, file
)
7588 Elf32_Internal_Shdr
* section
;
7589 unsigned char * start
;
7590 FILE * file ATTRIBUTE_UNUSED
;
7592 unsigned long bytes
;
7595 addr
= section
->sh_addr
;
7596 bytes
= section
->sh_size
;
7600 printf (_("\nThe .debug_str section is empty.\n"));
7604 printf (_("Contents of the .debug_str section:\n\n"));
7612 lbytes
= (bytes
> 16 ? 16 : bytes
);
7614 printf (" 0x%8.8lx ", (unsigned long) addr
);
7616 for (j
= 0; j
< 16; j
++)
7619 printf ("%2.2x", start
[j
]);
7627 for (j
= 0; j
< lbytes
; j
++)
7630 if (k
>= ' ' && k
< 0x80)
7646 static unsigned char *
7647 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7648 unsigned long attribute
;
7650 unsigned char * data
;
7651 unsigned long cu_offset
;
7652 unsigned long pointer_size
;
7654 unsigned long uvalue
= 0;
7655 unsigned char * block_start
= NULL
;
7663 case DW_FORM_ref_addr
:
7665 uvalue
= byte_get (data
, pointer_size
);
7666 data
+= pointer_size
;
7670 uvalue
= byte_get (data
, /* offset_size */ 4);
7671 data
+= /* offset_size */ 4;
7677 uvalue
= byte_get (data
++, 1);
7682 uvalue
= byte_get (data
, 2);
7688 uvalue
= byte_get (data
, 4);
7693 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7697 case DW_FORM_ref_udata
:
7699 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7703 case DW_FORM_indirect
:
7704 form
= read_leb128 (data
, & bytes_read
, 0);
7706 printf (" %s", get_FORM_name (form
));
7707 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7713 case DW_FORM_ref_addr
:
7714 printf (" <#%lx>", uvalue
);
7720 case DW_FORM_ref_udata
:
7721 printf (" <%lx>", uvalue
+ cu_offset
);
7725 printf (" %#lx", uvalue
);
7733 printf (" %ld", uvalue
);
7738 uvalue
= byte_get (data
, 4);
7739 printf (" %lx", uvalue
);
7740 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7744 case DW_FORM_string
:
7745 printf (" %s", data
);
7746 data
+= strlen ((char *) data
) + 1;
7750 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7751 block_start
= data
+ bytes_read
;
7752 data
= display_block (block_start
, uvalue
);
7755 case DW_FORM_block1
:
7756 uvalue
= byte_get (data
, 1);
7757 block_start
= data
+ 1;
7758 data
= display_block (block_start
, uvalue
);
7761 case DW_FORM_block2
:
7762 uvalue
= byte_get (data
, 2);
7763 block_start
= data
+ 2;
7764 data
= display_block (block_start
, uvalue
);
7767 case DW_FORM_block4
:
7768 uvalue
= byte_get (data
, 4);
7769 block_start
= data
+ 4;
7770 data
= display_block (block_start
, uvalue
);
7774 printf (_(" (indirect string, offset: 0x%lx): %s"),
7775 uvalue
, fetch_indirect_string (uvalue
));
7778 case DW_FORM_indirect
:
7779 /* Handled above. */
7783 warn (_("Unrecognized form: %d\n"), form
);
7787 /* For some attributes we can display futher information. */
7796 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7797 case DW_INL_inlined
: printf (_("(inlined)")); break;
7798 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7799 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7800 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7804 case DW_AT_language
:
7807 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7808 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7809 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7810 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7811 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7812 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7813 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7814 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7815 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7816 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7817 /* DWARF 2.1 values. */
7818 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7819 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7820 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7821 /* MIPS extension. */
7822 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7823 default: printf ("(Unknown: %lx)", uvalue
); break;
7827 case DW_AT_encoding
:
7830 case DW_ATE_void
: printf ("(void)"); break;
7831 case DW_ATE_address
: printf ("(machine address)"); break;
7832 case DW_ATE_boolean
: printf ("(boolean)"); break;
7833 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7834 case DW_ATE_float
: printf ("(float)"); break;
7835 case DW_ATE_signed
: printf ("(signed)"); break;
7836 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7837 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7838 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7839 /* DWARF 2.1 value. */
7840 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7842 if (uvalue
>= DW_ATE_lo_user
7843 && uvalue
<= DW_ATE_hi_user
)
7844 printf ("(user defined type)");
7846 printf ("(unknown type)");
7851 case DW_AT_accessibility
:
7854 case DW_ACCESS_public
: printf ("(public)"); break;
7855 case DW_ACCESS_protected
: printf ("(protected)"); break;
7856 case DW_ACCESS_private
: printf ("(private)"); break;
7857 default: printf ("(unknown accessibility)"); break;
7861 case DW_AT_visibility
:
7864 case DW_VIS_local
: printf ("(local)"); break;
7865 case DW_VIS_exported
: printf ("(exported)"); break;
7866 case DW_VIS_qualified
: printf ("(qualified)"); break;
7867 default: printf ("(unknown visibility)"); break;
7871 case DW_AT_virtuality
:
7874 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7875 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7876 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7877 default: printf ("(unknown virtuality)"); break;
7881 case DW_AT_identifier_case
:
7884 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7885 case DW_ID_up_case
: printf ("(up_case)"); break;
7886 case DW_ID_down_case
: printf ("(down_case)"); break;
7887 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7888 default: printf ("(unknown case)"); break;
7892 case DW_AT_calling_convention
:
7895 case DW_CC_normal
: printf ("(normal)"); break;
7896 case DW_CC_program
: printf ("(program)"); break;
7897 case DW_CC_nocall
: printf ("(nocall)"); break;
7899 if (uvalue
>= DW_CC_lo_user
7900 && uvalue
<= DW_CC_hi_user
)
7901 printf ("(user defined)");
7903 printf ("(unknown convention)");
7907 case DW_AT_ordering
:
7910 case -1: printf ("(undefined)"); break;
7911 case 0: printf ("(row major)"); break;
7912 case 1: printf ("(column major)"); break;
7916 case DW_AT_frame_base
:
7917 case DW_AT_location
:
7918 case DW_AT_data_member_location
:
7919 case DW_AT_vtable_elem_location
:
7920 case DW_AT_allocated
:
7921 case DW_AT_associated
:
7922 case DW_AT_data_location
:
7924 case DW_AT_upper_bound
:
7925 case DW_AT_lower_bound
:
7929 decode_location_expression (block_start
, pointer_size
, uvalue
);
7932 else if (form
== DW_FORM_data4
)
7935 printf ("location list");
7947 static unsigned char *
7948 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7949 unsigned long attribute
;
7951 unsigned char * data
;
7952 unsigned long cu_offset
;
7953 unsigned long pointer_size
;
7955 printf (" %-18s:", get_AT_name (attribute
));
7956 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7963 display_debug_info (section
, start
, file
)
7964 Elf32_Internal_Shdr
* section
;
7965 unsigned char * start
;
7968 unsigned char * end
= start
+ section
->sh_size
;
7969 unsigned char * section_begin
= start
;
7971 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7973 load_debug_str (file
);
7974 load_debug_loc (file
);
7978 DWARF2_External_CompUnit
* external
;
7979 DWARF2_Internal_CompUnit compunit
;
7980 Elf32_Internal_Shdr
* relsec
;
7981 unsigned char * tags
;
7984 unsigned long cu_offset
;
7986 external
= (DWARF2_External_CompUnit
*) start
;
7988 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7989 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7990 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7991 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7993 if (compunit
.cu_length
== 0xffffffff)
7995 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7999 /* Check for RELA relocations in the
8000 abbrev_offset address, and apply them. */
8001 for (relsec
= section_headers
;
8002 relsec
< section_headers
+ elf_header
.e_shnum
;
8005 unsigned long nrelas
;
8006 Elf_Internal_Rela
*rela
, *rp
;
8007 Elf32_Internal_Shdr
*symsec
;
8008 Elf_Internal_Sym
*symtab
;
8009 Elf_Internal_Sym
*sym
;
8011 if (relsec
->sh_type
!= SHT_RELA
8012 || SECTION_HEADER (relsec
->sh_info
) != section
8013 || relsec
->sh_size
== 0)
8016 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8020 symsec
= SECTION_HEADER (relsec
->sh_link
);
8021 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8023 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8026 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
8032 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8034 if (ELF32_R_SYM (rp
->r_info
) != 0
8035 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8037 warn (_("Skipping unexpected symbol type %u\n"),
8038 ELF32_ST_TYPE (sym
->st_info
));
8044 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8046 if (ELF64_R_SYM (rp
->r_info
) != 0
8047 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8049 warn (_("Skipping unexpected symbol type %u\n"),
8050 ELF64_ST_TYPE (sym
->st_info
));
8055 compunit
.cu_abbrev_offset
= rp
->r_addend
;
8063 tags
= start
+ sizeof (* external
);
8064 cu_offset
= start
- section_begin
;
8065 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
8067 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8068 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8069 printf (_(" Version: %d\n"), compunit
.cu_version
);
8070 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8071 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8073 if (compunit
.cu_version
!= 2)
8075 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8081 /* Read in the abbrevs used by this compilation unit. */
8083 Elf32_Internal_Shdr
* sec
;
8084 unsigned char * begin
;
8086 /* Locate the .debug_abbrev section and process it. */
8087 for (i
= 0, sec
= section_headers
;
8088 i
< elf_header
.e_shnum
;
8090 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
8093 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
8095 warn (_("Unable to locate .debug_abbrev section!\n"));
8099 begin
= ((unsigned char *)
8100 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8101 _("debug_abbrev section data")));
8105 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8106 begin
+ sec
->sh_size
);
8112 while (tags
< start
)
8115 unsigned long abbrev_number
;
8116 abbrev_entry
* entry
;
8119 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8122 /* A null DIE marks the end of a list of children. */
8123 if (abbrev_number
== 0)
8129 /* Scan through the abbreviation list until we reach the
8131 for (entry
= first_abbrev
;
8132 entry
&& entry
->entry
!= abbrev_number
;
8133 entry
= entry
->next
)
8138 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8143 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8145 (unsigned long) (tags
- section_begin
- bytes_read
),
8147 get_TAG_name (entry
->tag
));
8149 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8150 tags
= read_and_display_attr (attr
->attribute
,
8153 compunit
.cu_pointer_size
);
8155 if (entry
->children
)
8169 display_debug_aranges (section
, start
, file
)
8170 Elf32_Internal_Shdr
* section
;
8171 unsigned char * start
;
8172 FILE * file ATTRIBUTE_UNUSED
;
8174 unsigned char * end
= start
+ section
->sh_size
;
8176 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8180 DWARF2_External_ARange
* external
;
8181 DWARF2_Internal_ARange arange
;
8182 unsigned char * ranges
;
8183 unsigned long length
;
8184 unsigned long address
;
8187 external
= (DWARF2_External_ARange
*) start
;
8189 arange
.ar_length
= BYTE_GET (external
->ar_length
);
8190 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8191 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8192 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8193 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8195 if (arange
.ar_length
== 0xffffffff)
8197 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8201 if (arange
.ar_version
!= 2)
8203 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8207 printf (_(" Length: %ld\n"), arange
.ar_length
);
8208 printf (_(" Version: %d\n"), arange
.ar_version
);
8209 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8210 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8211 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8213 printf (_("\n Address Length\n"));
8215 ranges
= start
+ sizeof (* external
);
8217 /* Must pad to an alignment boundary that is twice the pointer size. */
8218 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
8220 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8224 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8226 ranges
+= arange
.ar_pointer_size
;
8228 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8230 ranges
+= arange
.ar_pointer_size
;
8232 /* A pair of zeros marks the end of the list. */
8233 if (address
== 0 && length
== 0)
8236 printf (" %8.8lx %lu\n", address
, length
);
8239 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8247 typedef struct Frame_Chunk
8249 struct Frame_Chunk
* next
;
8250 unsigned char * chunk_start
;
8252 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8253 short int * col_type
;
8255 char * augmentation
;
8256 unsigned int code_factor
;
8258 unsigned long pc_begin
;
8259 unsigned long pc_range
;
8263 unsigned char fde_encoding
;
8267 /* A marker for a col_type that means this column was never referenced
8268 in the frame info. */
8269 #define DW_CFA_unreferenced (-1)
8271 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8272 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8273 static int size_of_encoded_value
PARAMS ((int));
8276 frame_need_space (fc
, reg
)
8280 int prev
= fc
->ncols
;
8282 if (reg
< fc
->ncols
)
8285 fc
->ncols
= reg
+ 1;
8286 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8287 fc
->ncols
* sizeof (short int));
8288 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8289 fc
->ncols
* sizeof (int));
8291 while (prev
< fc
->ncols
)
8293 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8294 fc
->col_offset
[prev
] = 0;
8300 frame_display_row (fc
, need_col_headers
, max_regs
)
8302 int * need_col_headers
;
8308 if (* max_regs
< fc
->ncols
)
8309 * max_regs
= fc
->ncols
;
8311 if (* need_col_headers
)
8313 * need_col_headers
= 0;
8315 printf (" LOC CFA ");
8317 for (r
= 0; r
< * max_regs
; r
++)
8318 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8323 printf ("r%-4d", r
);
8329 printf ("%08lx ", fc
->pc_begin
);
8330 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8331 printf ("%-8s ", tmp
);
8333 for (r
= 0; r
< fc
->ncols
; r
++)
8335 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8337 switch (fc
->col_type
[r
])
8339 case DW_CFA_undefined
:
8342 case DW_CFA_same_value
:
8346 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8348 case DW_CFA_register
:
8349 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8352 strcpy (tmp
, "n/a");
8355 printf ("%-5s", tmp
);
8362 size_of_encoded_value (encoding
)
8365 switch (encoding
& 0x7)
8368 case 0: return is_32bit_elf
? 4 : 8;
8375 #define GET(N) byte_get (start, N); start += N
8376 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8377 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8380 display_debug_frames (section
, start
, file
)
8381 Elf32_Internal_Shdr
* section
;
8382 unsigned char * start
;
8383 FILE * file ATTRIBUTE_UNUSED
;
8385 unsigned char * end
= start
+ section
->sh_size
;
8386 unsigned char * section_start
= start
;
8387 Frame_Chunk
* chunks
= 0;
8388 Frame_Chunk
* remembered_state
= 0;
8390 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8393 int addr_size
= is_32bit_elf
? 4 : 8;
8395 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8399 unsigned char * saved_start
;
8400 unsigned char * block_end
;
8401 unsigned long length
;
8402 unsigned long cie_id
;
8405 int need_col_headers
= 1;
8406 unsigned char * augmentation_data
= NULL
;
8407 unsigned long augmentation_data_len
= 0;
8408 int encoded_ptr_size
= addr_size
;
8410 saved_start
= start
;
8411 length
= byte_get (start
, 4); start
+= 4;
8415 printf ("\n%08lx ZERO terminator\n\n",
8416 (unsigned long)(saved_start
- section_start
));
8420 if (length
== 0xffffffff)
8422 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8426 block_end
= saved_start
+ length
+ 4;
8427 cie_id
= byte_get (start
, 4); start
+= 4;
8429 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8433 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8434 memset (fc
, 0, sizeof (Frame_Chunk
));
8438 fc
->chunk_start
= saved_start
;
8440 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8441 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8442 frame_need_space (fc
, max_regs
-1);
8446 fc
->augmentation
= start
;
8447 start
= strchr (start
, '\0') + 1;
8449 if (fc
->augmentation
[0] == 'z')
8451 fc
->code_factor
= LEB ();
8452 fc
->data_factor
= SLEB ();
8453 fc
->ra
= byte_get (start
, 1); start
+= 1;
8454 augmentation_data_len
= LEB ();
8455 augmentation_data
= start
;
8456 start
+= augmentation_data_len
;
8458 else if (strcmp (fc
->augmentation
, "eh") == 0)
8461 fc
->code_factor
= LEB ();
8462 fc
->data_factor
= SLEB ();
8463 fc
->ra
= byte_get (start
, 1); start
+= 1;
8467 fc
->code_factor
= LEB ();
8468 fc
->data_factor
= SLEB ();
8469 fc
->ra
= byte_get (start
, 1); start
+= 1;
8473 if (do_debug_frames_interp
)
8474 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8475 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8476 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8480 printf ("\n%08lx %08lx %08lx CIE\n",
8481 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8482 printf (" Version: %d\n", version
);
8483 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8484 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8485 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8486 printf (" Return address column: %d\n", fc
->ra
);
8488 if (augmentation_data_len
)
8491 printf (" Augmentation data: ");
8492 for (i
= 0; i
< augmentation_data_len
; ++i
)
8493 printf (" %02x", augmentation_data
[i
]);
8499 if (augmentation_data_len
)
8501 unsigned char *p
, *q
;
8502 p
= fc
->augmentation
+ 1;
8503 q
= augmentation_data
;
8510 q
+= 1 + size_of_encoded_value (*q
);
8512 fc
->fde_encoding
= *q
++;
8518 if (fc
->fde_encoding
)
8519 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8522 frame_need_space (fc
, fc
->ra
);
8526 unsigned char * look_for
;
8527 static Frame_Chunk fde_fc
;
8530 memset (fc
, 0, sizeof (Frame_Chunk
));
8532 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8534 for (cie
= chunks
; cie
; cie
= cie
->next
)
8535 if (cie
->chunk_start
== look_for
)
8540 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8541 cie_id
, saved_start
);
8544 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8545 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8546 frame_need_space (fc
, max_regs
- 1);
8548 fc
->augmentation
= "";
8549 fc
->fde_encoding
= 0;
8553 fc
->ncols
= cie
->ncols
;
8554 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8555 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8556 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8557 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8558 fc
->augmentation
= cie
->augmentation
;
8559 fc
->code_factor
= cie
->code_factor
;
8560 fc
->data_factor
= cie
->data_factor
;
8561 fc
->cfa_reg
= cie
->cfa_reg
;
8562 fc
->cfa_offset
= cie
->cfa_offset
;
8564 frame_need_space (fc
, max_regs
-1);
8565 fc
->fde_encoding
= cie
->fde_encoding
;
8568 if (fc
->fde_encoding
)
8569 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8571 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8572 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8573 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
8574 start
+= encoded_ptr_size
;
8575 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8576 start
+= encoded_ptr_size
;
8578 if (cie
->augmentation
[0] == 'z')
8580 augmentation_data_len
= LEB ();
8581 augmentation_data
= start
;
8582 start
+= augmentation_data_len
;
8585 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8586 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8587 (unsigned long)(cie
->chunk_start
- section_start
),
8588 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8589 if (! do_debug_frames_interp
&& augmentation_data_len
)
8592 printf (" Augmentation data: ");
8593 for (i
= 0; i
< augmentation_data_len
; ++i
)
8594 printf (" %02x", augmentation_data
[i
]);
8600 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8601 about to interpret instructions for the chunk. */
8603 if (do_debug_frames_interp
)
8605 /* Start by making a pass over the chunk, allocating storage
8606 and taking note of what registers are used. */
8607 unsigned char * tmp
= start
;
8609 while (start
< block_end
)
8619 /* Warning: if you add any more cases to this switch, be
8620 sure to add them to the corresponding switch below. */
8623 case DW_CFA_advance_loc
:
8627 frame_need_space (fc
, opa
);
8628 fc
->col_type
[opa
] = DW_CFA_undefined
;
8630 case DW_CFA_restore
:
8631 frame_need_space (fc
, opa
);
8632 fc
->col_type
[opa
] = DW_CFA_undefined
;
8634 case DW_CFA_set_loc
:
8635 start
+= encoded_ptr_size
;
8637 case DW_CFA_advance_loc1
:
8640 case DW_CFA_advance_loc2
:
8643 case DW_CFA_advance_loc4
:
8646 case DW_CFA_offset_extended
:
8647 reg
= LEB (); LEB ();
8648 frame_need_space (fc
, reg
);
8649 fc
->col_type
[reg
] = DW_CFA_undefined
;
8651 case DW_CFA_restore_extended
:
8653 frame_need_space (fc
, reg
);
8654 fc
->col_type
[reg
] = DW_CFA_undefined
;
8656 case DW_CFA_undefined
:
8658 frame_need_space (fc
, reg
);
8659 fc
->col_type
[reg
] = DW_CFA_undefined
;
8661 case DW_CFA_same_value
:
8663 frame_need_space (fc
, reg
);
8664 fc
->col_type
[reg
] = DW_CFA_undefined
;
8666 case DW_CFA_register
:
8667 reg
= LEB (); LEB ();
8668 frame_need_space (fc
, reg
);
8669 fc
->col_type
[reg
] = DW_CFA_undefined
;
8671 case DW_CFA_def_cfa
:
8674 case DW_CFA_def_cfa_register
:
8677 case DW_CFA_def_cfa_offset
:
8680 case DW_CFA_offset_extended_sf
:
8681 reg
= LEB (); SLEB ();
8682 frame_need_space (fc
, reg
);
8683 fc
->col_type
[reg
] = DW_CFA_undefined
;
8685 case DW_CFA_def_cfa_sf
:
8688 case DW_CFA_def_cfa_offset_sf
:
8691 case DW_CFA_GNU_args_size
:
8694 case DW_CFA_GNU_negative_offset_extended
:
8695 reg
= LEB (); LEB ();
8696 frame_need_space (fc
, reg
);
8697 fc
->col_type
[reg
] = DW_CFA_undefined
;
8706 /* Now we know what registers are used, make a second pass over
8707 the chunk, this time actually printing out the info. */
8709 while (start
< block_end
)
8712 unsigned long ul
, reg
, roffs
;
8721 /* Warning: if you add any more cases to this switch, be
8722 sure to add them to the corresponding switch above. */
8725 case DW_CFA_advance_loc
:
8726 if (do_debug_frames_interp
)
8727 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8729 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8730 opa
* fc
->code_factor
,
8731 fc
->pc_begin
+ opa
* fc
->code_factor
);
8732 fc
->pc_begin
+= opa
* fc
->code_factor
;
8737 if (! do_debug_frames_interp
)
8738 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8739 opa
, roffs
* fc
->data_factor
);
8740 fc
->col_type
[opa
] = DW_CFA_offset
;
8741 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8744 case DW_CFA_restore
:
8745 if (! do_debug_frames_interp
)
8746 printf (" DW_CFA_restore: r%d\n", opa
);
8747 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8748 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8751 case DW_CFA_set_loc
:
8752 vma
= byte_get (start
, encoded_ptr_size
);
8753 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8754 vma
+= section
->sh_addr
+ (start
- section_start
);
8755 start
+= encoded_ptr_size
;
8756 if (do_debug_frames_interp
)
8757 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8759 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8763 case DW_CFA_advance_loc1
:
8764 ofs
= byte_get (start
, 1); start
+= 1;
8765 if (do_debug_frames_interp
)
8766 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8768 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8769 ofs
* fc
->code_factor
,
8770 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8771 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8774 case DW_CFA_advance_loc2
:
8775 ofs
= byte_get (start
, 2); start
+= 2;
8776 if (do_debug_frames_interp
)
8777 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8779 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8780 ofs
* fc
->code_factor
,
8781 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8782 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8785 case DW_CFA_advance_loc4
:
8786 ofs
= byte_get (start
, 4); start
+= 4;
8787 if (do_debug_frames_interp
)
8788 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8790 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8791 ofs
* fc
->code_factor
,
8792 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8793 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8796 case DW_CFA_offset_extended
:
8799 if (! do_debug_frames_interp
)
8800 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8801 reg
, roffs
* fc
->data_factor
);
8802 fc
->col_type
[reg
] = DW_CFA_offset
;
8803 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8806 case DW_CFA_restore_extended
:
8808 if (! do_debug_frames_interp
)
8809 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8810 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8811 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8814 case DW_CFA_undefined
:
8816 if (! do_debug_frames_interp
)
8817 printf (" DW_CFA_undefined: r%ld\n", reg
);
8818 fc
->col_type
[reg
] = DW_CFA_undefined
;
8819 fc
->col_offset
[reg
] = 0;
8822 case DW_CFA_same_value
:
8824 if (! do_debug_frames_interp
)
8825 printf (" DW_CFA_same_value: r%ld\n", reg
);
8826 fc
->col_type
[reg
] = DW_CFA_same_value
;
8827 fc
->col_offset
[reg
] = 0;
8830 case DW_CFA_register
:
8833 if (! do_debug_frames_interp
)
8834 printf (" DW_CFA_register: r%ld\n", reg
);
8835 fc
->col_type
[reg
] = DW_CFA_register
;
8836 fc
->col_offset
[reg
] = roffs
;
8839 case DW_CFA_remember_state
:
8840 if (! do_debug_frames_interp
)
8841 printf (" DW_CFA_remember_state\n");
8842 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8843 rs
->ncols
= fc
->ncols
;
8844 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8845 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8846 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8847 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8848 rs
->next
= remembered_state
;
8849 remembered_state
= rs
;
8852 case DW_CFA_restore_state
:
8853 if (! do_debug_frames_interp
)
8854 printf (" DW_CFA_restore_state\n");
8855 rs
= remembered_state
;
8856 remembered_state
= rs
->next
;
8857 frame_need_space (fc
, rs
->ncols
-1);
8858 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8859 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8860 free (rs
->col_type
);
8861 free (rs
->col_offset
);
8865 case DW_CFA_def_cfa
:
8866 fc
->cfa_reg
= LEB ();
8867 fc
->cfa_offset
= LEB ();
8868 if (! do_debug_frames_interp
)
8869 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8870 fc
->cfa_reg
, fc
->cfa_offset
);
8873 case DW_CFA_def_cfa_register
:
8874 fc
->cfa_reg
= LEB ();
8875 if (! do_debug_frames_interp
)
8876 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8879 case DW_CFA_def_cfa_offset
:
8880 fc
->cfa_offset
= LEB ();
8881 if (! do_debug_frames_interp
)
8882 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8886 if (! do_debug_frames_interp
)
8887 printf (" DW_CFA_nop\n");
8890 case DW_CFA_offset_extended_sf
:
8893 frame_need_space (fc
, reg
);
8894 if (! do_debug_frames_interp
)
8895 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8896 reg
, l
* fc
->data_factor
);
8897 fc
->col_type
[reg
] = DW_CFA_offset
;
8898 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8901 case DW_CFA_def_cfa_sf
:
8902 fc
->cfa_reg
= LEB ();
8903 fc
->cfa_offset
= SLEB ();
8904 if (! do_debug_frames_interp
)
8905 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8906 fc
->cfa_reg
, fc
->cfa_offset
);
8909 case DW_CFA_def_cfa_offset_sf
:
8910 fc
->cfa_offset
= SLEB ();
8911 if (! do_debug_frames_interp
)
8912 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
8915 case DW_CFA_GNU_window_save
:
8916 if (! do_debug_frames_interp
)
8917 printf (" DW_CFA_GNU_window_save\n");
8920 case DW_CFA_GNU_args_size
:
8922 if (! do_debug_frames_interp
)
8923 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8926 case DW_CFA_GNU_negative_offset_extended
:
8929 frame_need_space (fc
, reg
);
8930 if (! do_debug_frames_interp
)
8931 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8932 reg
, l
* fc
->data_factor
);
8933 fc
->col_type
[reg
] = DW_CFA_offset
;
8934 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8937 /* FIXME: How do we handle these? */
8938 case DW_CFA_def_cfa_expression
:
8939 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
8943 case DW_CFA_expression
:
8944 fprintf (stderr
, "unsupported DW_CFA_expression\n");
8949 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8954 if (do_debug_frames_interp
)
8955 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8970 display_debug_not_supported (section
, start
, file
)
8971 Elf32_Internal_Shdr
* section
;
8972 unsigned char * start ATTRIBUTE_UNUSED
;
8973 FILE * file ATTRIBUTE_UNUSED
;
8975 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8976 SECTION_NAME (section
));
8981 /* Pre-scan the .debug_info section to record the size of address.
8982 When dumping the .debug_line, we use that size information, assuming
8983 that all compilation units have the same address size. */
8985 prescan_debug_info (section
, start
, file
)
8986 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8987 unsigned char * start
;
8988 FILE * file ATTRIBUTE_UNUSED
;
8990 DWARF2_External_CompUnit
* external
;
8992 external
= (DWARF2_External_CompUnit
*) start
;
8994 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8998 /* A structure containing the name of a debug section and a pointer
8999 to a function that can decode it. The third field is a prescan
9000 function to be run over the section before displaying any of the
9004 const char * const name
;
9005 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
9006 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
9010 { ".debug_abbrev", display_debug_abbrev
, NULL
},
9011 { ".debug_aranges", display_debug_aranges
, NULL
},
9012 { ".debug_frame", display_debug_frames
, NULL
},
9013 { ".debug_info", display_debug_info
, prescan_debug_info
},
9014 { ".debug_line", display_debug_lines
, NULL
},
9015 { ".debug_pubnames", display_debug_pubnames
, NULL
},
9016 { ".eh_frame", display_debug_frames
, NULL
},
9017 { ".debug_macinfo", display_debug_macinfo
, NULL
},
9018 { ".debug_str", display_debug_str
, NULL
},
9019 { ".debug_loc", display_debug_loc
, NULL
},
9020 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
9021 { ".debug_ranges", display_debug_not_supported
, NULL
},
9022 { ".debug_static_func", display_debug_not_supported
, NULL
},
9023 { ".debug_static_vars", display_debug_not_supported
, NULL
},
9024 { ".debug_types", display_debug_not_supported
, NULL
},
9025 { ".debug_weaknames", display_debug_not_supported
, NULL
}
9029 display_debug_section (section
, file
)
9030 Elf32_Internal_Shdr
* section
;
9033 char * name
= SECTION_NAME (section
);
9034 bfd_size_type length
;
9035 unsigned char * start
;
9038 length
= section
->sh_size
;
9041 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9045 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
9046 _("debug section data"));
9050 /* See if we know how to display the contents of this section. */
9051 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9052 name
= ".debug_info";
9054 for (i
= NUM_ELEM (debug_displays
); i
--;)
9055 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9057 debug_displays
[i
].display (section
, start
, file
);
9062 printf (_("Unrecognized debug section: %s\n"), name
);
9066 /* If we loaded in the abbrev section at some point,
9067 we must release it here. */
9074 process_section_contents (file
)
9077 Elf32_Internal_Shdr
* section
;
9083 /* Pre-scan the debug sections to find some debug information not
9084 present in some of them. For the .debug_line, we must find out the
9085 size of address (specified in .debug_info and .debug_aranges). */
9086 for (i
= 0, section
= section_headers
;
9087 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9090 char * name
= SECTION_NAME (section
);
9093 if (section
->sh_size
== 0)
9096 /* See if there is some pre-scan operation for this section. */
9097 for (j
= NUM_ELEM (debug_displays
); j
--;)
9098 if (strcmp (debug_displays
[j
].name
, name
) == 0)
9100 if (debug_displays
[j
].prescan
!= NULL
)
9102 bfd_size_type length
;
9103 unsigned char * start
;
9105 length
= section
->sh_size
;
9106 start
= ((unsigned char *)
9107 get_data (NULL
, file
, section
->sh_offset
, length
,
9108 _("debug section data")));
9112 debug_displays
[j
].prescan (section
, start
, file
);
9120 for (i
= 0, section
= section_headers
;
9121 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9124 #ifdef SUPPORT_DISASSEMBLY
9125 if (dump_sects
[i
] & DISASS_DUMP
)
9126 disassemble_section (section
, file
);
9128 if (dump_sects
[i
] & HEX_DUMP
)
9129 dump_section (section
, file
);
9131 if (dump_sects
[i
] & DEBUG_DUMP
)
9132 display_debug_section (section
, file
);
9135 if (i
< num_dump_sects
)
9136 warn (_("Some sections were not dumped because they do not exist!\n"));
9142 process_mips_fpe_exception (mask
)
9148 if (mask
& OEX_FPU_INEX
)
9149 fputs ("INEX", stdout
), first
= 0;
9150 if (mask
& OEX_FPU_UFLO
)
9151 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9152 if (mask
& OEX_FPU_OFLO
)
9153 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9154 if (mask
& OEX_FPU_DIV0
)
9155 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9156 if (mask
& OEX_FPU_INVAL
)
9157 printf ("%sINVAL", first
? "" : "|");
9160 fputs ("0", stdout
);
9164 process_mips_specific (file
)
9167 Elf_Internal_Dyn
* entry
;
9168 size_t liblist_offset
= 0;
9169 size_t liblistno
= 0;
9170 size_t conflictsno
= 0;
9171 size_t options_offset
= 0;
9172 size_t conflicts_offset
= 0;
9174 /* We have a lot of special sections. Thanks SGI! */
9175 if (dynamic_segment
== NULL
)
9176 /* No information available. */
9179 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9180 switch (entry
->d_tag
)
9182 case DT_MIPS_LIBLIST
:
9183 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
9185 case DT_MIPS_LIBLISTNO
:
9186 liblistno
= entry
->d_un
.d_val
;
9188 case DT_MIPS_OPTIONS
:
9189 options_offset
= entry
->d_un
.d_val
- loadaddr
;
9191 case DT_MIPS_CONFLICT
:
9192 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
9194 case DT_MIPS_CONFLICTNO
:
9195 conflictsno
= entry
->d_un
.d_val
;
9201 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9203 Elf32_External_Lib
* elib
;
9206 elib
= ((Elf32_External_Lib
*)
9207 get_data (NULL
, file
, liblist_offset
,
9208 liblistno
* sizeof (Elf32_External_Lib
),
9212 printf ("\nSection '.liblist' contains %lu entries:\n",
9213 (unsigned long) liblistno
);
9214 fputs (" Library Time Stamp Checksum Version Flags\n",
9217 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9224 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9225 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9226 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9227 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9228 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9230 tmp
= gmtime (&time
);
9231 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9232 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9233 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9235 printf ("%3lu: ", (unsigned long) cnt
);
9236 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9237 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9240 if (liblist
.l_flags
== 0)
9251 { " EXACT_MATCH", LL_EXACT_MATCH
},
9252 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9253 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9254 { " EXPORTS", LL_EXPORTS
},
9255 { " DELAY_LOAD", LL_DELAY_LOAD
},
9256 { " DELTA", LL_DELTA
}
9258 int flags
= liblist
.l_flags
;
9262 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9264 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9266 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9267 flags
^= l_flags_vals
[fcnt
].bit
;
9270 printf (" %#x", (unsigned int) flags
);
9280 if (options_offset
!= 0)
9282 Elf_External_Options
* eopt
;
9283 Elf_Internal_Shdr
* sect
= section_headers
;
9284 Elf_Internal_Options
* iopt
;
9285 Elf_Internal_Options
* option
;
9289 /* Find the section header so that we get the size. */
9290 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9293 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9294 sect
->sh_size
, _("options"));
9297 iopt
= ((Elf_Internal_Options
*)
9298 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
9301 error (_("Out of memory"));
9308 while (offset
< sect
->sh_size
)
9310 Elf_External_Options
* eoption
;
9312 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9314 option
->kind
= BYTE_GET (eoption
->kind
);
9315 option
->size
= BYTE_GET (eoption
->size
);
9316 option
->section
= BYTE_GET (eoption
->section
);
9317 option
->info
= BYTE_GET (eoption
->info
);
9319 offset
+= option
->size
;
9325 printf (_("\nSection '%s' contains %d entries:\n"),
9326 SECTION_NAME (sect
), cnt
);
9334 switch (option
->kind
)
9337 /* This shouldn't happen. */
9338 printf (" NULL %d %lx", option
->section
, option
->info
);
9341 printf (" REGINFO ");
9342 if (elf_header
.e_machine
== EM_MIPS
)
9345 Elf32_External_RegInfo
* ereg
;
9346 Elf32_RegInfo reginfo
;
9348 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9349 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9350 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9351 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9352 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9353 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9354 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9356 printf ("GPR %08lx GP 0x%lx\n",
9358 (unsigned long) reginfo
.ri_gp_value
);
9359 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9360 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9361 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9366 Elf64_External_RegInfo
* ereg
;
9367 Elf64_Internal_RegInfo reginfo
;
9369 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9370 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9371 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9372 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9373 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9374 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9375 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9377 printf ("GPR %08lx GP 0x",
9378 reginfo
.ri_gprmask
);
9379 printf_vma (reginfo
.ri_gp_value
);
9382 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9383 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9384 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9388 case ODK_EXCEPTIONS
:
9389 fputs (" EXCEPTIONS fpe_min(", stdout
);
9390 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9391 fputs (") fpe_max(", stdout
);
9392 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9393 fputs (")", stdout
);
9395 if (option
->info
& OEX_PAGE0
)
9396 fputs (" PAGE0", stdout
);
9397 if (option
->info
& OEX_SMM
)
9398 fputs (" SMM", stdout
);
9399 if (option
->info
& OEX_FPDBUG
)
9400 fputs (" FPDBUG", stdout
);
9401 if (option
->info
& OEX_DISMISS
)
9402 fputs (" DISMISS", stdout
);
9405 fputs (" PAD ", stdout
);
9406 if (option
->info
& OPAD_PREFIX
)
9407 fputs (" PREFIX", stdout
);
9408 if (option
->info
& OPAD_POSTFIX
)
9409 fputs (" POSTFIX", stdout
);
9410 if (option
->info
& OPAD_SYMBOL
)
9411 fputs (" SYMBOL", stdout
);
9414 fputs (" HWPATCH ", stdout
);
9415 if (option
->info
& OHW_R4KEOP
)
9416 fputs (" R4KEOP", stdout
);
9417 if (option
->info
& OHW_R8KPFETCH
)
9418 fputs (" R8KPFETCH", stdout
);
9419 if (option
->info
& OHW_R5KEOP
)
9420 fputs (" R5KEOP", stdout
);
9421 if (option
->info
& OHW_R5KCVTL
)
9422 fputs (" R5KCVTL", stdout
);
9425 fputs (" FILL ", stdout
);
9426 /* XXX Print content of info word? */
9429 fputs (" TAGS ", stdout
);
9430 /* XXX Print content of info word? */
9433 fputs (" HWAND ", stdout
);
9434 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9435 fputs (" R4KEOP_CHECKED", stdout
);
9436 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9437 fputs (" R4KEOP_CLEAN", stdout
);
9440 fputs (" HWOR ", stdout
);
9441 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9442 fputs (" R4KEOP_CHECKED", stdout
);
9443 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9444 fputs (" R4KEOP_CLEAN", stdout
);
9447 printf (" GP_GROUP %#06lx self-contained %#06lx",
9448 option
->info
& OGP_GROUP
,
9449 (option
->info
& OGP_SELF
) >> 16);
9452 printf (" IDENT %#06lx self-contained %#06lx",
9453 option
->info
& OGP_GROUP
,
9454 (option
->info
& OGP_SELF
) >> 16);
9457 /* This shouldn't happen. */
9458 printf (" %3d ??? %d %lx",
9459 option
->kind
, option
->section
, option
->info
);
9463 len
= sizeof (* eopt
);
9464 while (len
< option
->size
)
9465 if (((char *) option
)[len
] >= ' '
9466 && ((char *) option
)[len
] < 0x7f)
9467 printf ("%c", ((char *) option
)[len
++]);
9469 printf ("\\%03o", ((char *) option
)[len
++]);
9471 fputs ("\n", stdout
);
9479 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9481 Elf32_Conflict
* iconf
;
9484 if (dynamic_symbols
== NULL
)
9486 error (_("conflict list found without a dynamic symbol table"));
9490 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
9493 error (_("Out of memory"));
9499 Elf32_External_Conflict
* econf32
;
9501 econf32
= ((Elf32_External_Conflict
*)
9502 get_data (NULL
, file
, conflicts_offset
,
9503 conflictsno
* sizeof (* econf32
),
9508 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9509 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9515 Elf64_External_Conflict
* econf64
;
9517 econf64
= ((Elf64_External_Conflict
*)
9518 get_data (NULL
, file
, conflicts_offset
,
9519 conflictsno
* sizeof (* econf64
),
9524 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9525 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9530 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9531 (long) conflictsno
);
9532 puts (_(" Num: Index Value Name"));
9534 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9536 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9538 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9539 print_vma (psym
->st_value
, FULL_HEX
);
9541 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9552 process_gnu_liblist (file
)
9555 Elf_Internal_Shdr
* section
, * string_sec
;
9556 Elf32_External_Lib
* elib
;
9564 for (i
= 0, section
= section_headers
;
9565 i
< elf_header
.e_shnum
;
9568 switch (section
->sh_type
)
9570 case SHT_GNU_LIBLIST
:
9571 elib
= ((Elf32_External_Lib
*)
9572 get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9577 string_sec
= SECTION_HEADER (section
->sh_link
);
9579 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9580 string_sec
->sh_size
,
9581 _("liblist string table"));
9584 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9590 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9591 SECTION_NAME (section
),
9592 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9594 puts (" Library Time Stamp Checksum Version Flags");
9596 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9604 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9605 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9606 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9607 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9608 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9610 tmp
= gmtime (&time
);
9611 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9612 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9613 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9615 printf ("%3lu: ", (unsigned long) cnt
);
9617 printf ("%-20s", strtab
+ liblist
.l_name
);
9619 printf ("%-20.20s", strtab
+ liblist
.l_name
);
9620 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9621 liblist
.l_version
, liblist
.l_flags
);
9632 get_note_type (e_type
)
9635 static char buff
[64];
9639 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9640 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9641 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9642 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9643 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9644 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9645 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9646 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9647 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9648 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9649 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9651 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9657 get_netbsd_elfcore_note_type (e_type
)
9660 static char buff
[64];
9662 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9664 /* NetBSD core "procinfo" structure. */
9665 return _("NetBSD procinfo structure");
9668 /* As of Jan 2002 there are no other machine-independent notes
9669 defined for NetBSD core files. If the note type is less
9670 than the start of the machine-dependent note types, we don't
9673 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9675 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9679 switch (elf_header
.e_machine
)
9681 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9682 and PT_GETFPREGS == mach+2. */
9687 case EM_SPARC32PLUS
:
9691 case NT_NETBSDCORE_FIRSTMACH
+0:
9692 return _("PT_GETREGS (reg structure)");
9693 case NT_NETBSDCORE_FIRSTMACH
+2:
9694 return _("PT_GETFPREGS (fpreg structure)");
9700 /* On all other arch's, PT_GETREGS == mach+1 and
9701 PT_GETFPREGS == mach+3. */
9705 case NT_NETBSDCORE_FIRSTMACH
+1:
9706 return _("PT_GETREGS (reg structure)");
9707 case NT_NETBSDCORE_FIRSTMACH
+3:
9708 return _("PT_GETFPREGS (fpreg structure)");
9714 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9718 /* Note that by the ELF standard, the name field is already null byte
9719 terminated, and namesz includes the terminating null byte.
9720 I.E. the value of namesz for the name "FSF" is 4.
9722 If the value of namesz is zero, there is no name present. */
9724 process_note (pnote
)
9725 Elf32_Internal_Note
* pnote
;
9729 if (pnote
->namesz
== 0)
9731 /* If there is no note name, then use the default set of
9732 note type strings. */
9733 nt
= get_note_type (pnote
->type
);
9735 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9737 /* NetBSD-specific core file notes. */
9738 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9742 /* Don't recognize this note name; just use the default set of
9743 note type strings. */
9744 nt
= get_note_type (pnote
->type
);
9747 printf (" %s\t\t0x%08lx\t%s\n",
9748 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9755 process_corefile_note_segment (file
, offset
, length
)
9760 Elf_External_Note
* pnotes
;
9761 Elf_External_Note
* external
;
9767 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9774 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9775 (unsigned long) offset
, (unsigned long) length
);
9776 printf (_(" Owner\t\tData size\tDescription\n"));
9778 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9780 Elf_External_Note
* next
;
9781 Elf32_Internal_Note inote
;
9784 inote
.type
= BYTE_GET (external
->type
);
9785 inote
.namesz
= BYTE_GET (external
->namesz
);
9786 inote
.namedata
= external
->name
;
9787 inote
.descsz
= BYTE_GET (external
->descsz
);
9788 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9789 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9791 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9793 if (((char *) next
) > (((char *) pnotes
) + length
))
9795 warn (_("corrupt note found at offset %x into core notes\n"),
9796 ((char *) external
) - ((char *) pnotes
));
9797 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9798 inote
.type
, inote
.namesz
, inote
.descsz
);
9804 /* Verify that name is null terminated. It appears that at least
9805 one version of Linux (RedHat 6.0) generates corefiles that don't
9806 comply with the ELF spec by failing to include the null byte in
9808 if (inote
.namedata
[inote
.namesz
] != '\0')
9810 temp
= malloc (inote
.namesz
+ 1);
9814 error (_("Out of memory\n"));
9819 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9820 temp
[inote
.namesz
] = 0;
9822 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9823 inote
.namedata
= temp
;
9826 res
&= process_note (& inote
);
9841 process_corefile_note_segments (file
)
9844 Elf_Internal_Phdr
* program_headers
;
9845 Elf_Internal_Phdr
* segment
;
9849 program_headers
= (Elf_Internal_Phdr
*) malloc
9850 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9852 if (program_headers
== NULL
)
9854 error (_("Out of memory\n"));
9859 i
= get_32bit_program_headers (file
, program_headers
);
9861 i
= get_64bit_program_headers (file
, program_headers
);
9865 free (program_headers
);
9869 for (i
= 0, segment
= program_headers
;
9870 i
< elf_header
.e_phnum
;
9873 if (segment
->p_type
== PT_NOTE
)
9874 res
&= process_corefile_note_segment (file
,
9875 (bfd_vma
) segment
->p_offset
,
9876 (bfd_vma
) segment
->p_filesz
);
9879 free (program_headers
);
9885 process_corefile_contents (file
)
9888 /* If we have not been asked to display the notes then do nothing. */
9892 /* If file is not a core file then exit. */
9893 if (elf_header
.e_type
!= ET_CORE
)
9896 /* No program headers means no NOTE segment. */
9897 if (elf_header
.e_phnum
== 0)
9899 printf (_("No note segments present in the core file.\n"));
9903 return process_corefile_note_segments (file
);
9907 process_arch_specific (file
)
9913 switch (elf_header
.e_machine
)
9916 case EM_MIPS_RS3_LE
:
9917 return process_mips_specific (file
);
9926 get_file_header (file
)
9929 /* Read in the identity array. */
9930 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9933 /* Determine how to read the rest of the header. */
9934 switch (elf_header
.e_ident
[EI_DATA
])
9936 default: /* fall through */
9937 case ELFDATANONE
: /* fall through */
9938 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9939 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9942 /* For now we only support 32 bit and 64 bit ELF files. */
9943 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9945 /* Read in the rest of the header. */
9948 Elf32_External_Ehdr ehdr32
;
9950 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9953 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9954 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9955 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9956 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9957 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9958 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9959 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9960 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9961 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9962 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9963 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9964 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9965 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9969 Elf64_External_Ehdr ehdr64
;
9971 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9972 we will not be able to cope with the 64bit data found in
9973 64 ELF files. Detect this now and abort before we start
9974 overwritting things. */
9975 if (sizeof (bfd_vma
) < 8)
9977 error (_("This instance of readelf has been built without support for a\n\
9978 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9982 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9985 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9986 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9987 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9988 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9989 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9990 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9991 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9992 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9993 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9994 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9995 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9996 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9997 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10000 if (elf_header
.e_shoff
)
10002 /* There may be some extensions in the first section header. Don't
10003 bomb if we can't read it. */
10005 get_32bit_section_headers (file
, 1);
10007 get_64bit_section_headers (file
, 1);
10014 process_file (file_name
)
10018 struct stat statbuf
;
10021 if (stat (file_name
, & statbuf
) < 0)
10023 error (_("Cannot stat input file %s.\n"), file_name
);
10027 file
= fopen (file_name
, "rb");
10030 error (_("Input file %s not found.\n"), file_name
);
10034 if (! get_file_header (file
))
10036 error (_("%s: Failed to read file header\n"), file_name
);
10041 /* Initialise per file variables. */
10042 for (i
= NUM_ELEM (version_info
); i
--;)
10043 version_info
[i
] = 0;
10045 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10046 dynamic_info
[i
] = 0;
10048 /* Process the file. */
10050 printf (_("\nFile: %s\n"), file_name
);
10052 if (! process_file_header ())
10058 if (! process_section_headers (file
))
10060 /* Without loaded section headers we
10061 cannot process lots of things. */
10062 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10064 if (! do_using_dynamic
)
10065 do_syms
= do_reloc
= 0;
10068 if (process_program_headers (file
))
10069 process_dynamic_segment (file
);
10071 process_relocs (file
);
10073 process_unwind (file
);
10075 process_symbol_table (file
);
10077 process_syminfo (file
);
10079 process_version_sections (file
);
10081 process_section_contents (file
);
10083 process_corefile_contents (file
);
10085 process_gnu_liblist (file
);
10087 process_arch_specific (file
);
10091 if (section_headers
)
10093 free (section_headers
);
10094 section_headers
= NULL
;
10099 free (string_table
);
10100 string_table
= NULL
;
10101 string_table_length
= 0;
10104 if (dynamic_strings
)
10106 free (dynamic_strings
);
10107 dynamic_strings
= NULL
;
10110 if (dynamic_symbols
)
10112 free (dynamic_symbols
);
10113 dynamic_symbols
= NULL
;
10114 num_dynamic_syms
= 0;
10117 if (dynamic_syminfo
)
10119 free (dynamic_syminfo
);
10120 dynamic_syminfo
= NULL
;
10126 #ifdef SUPPORT_DISASSEMBLY
10127 /* Needed by the i386 disassembler. For extra credit, someone could
10128 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10132 print_address (unsigned int addr
, FILE * outfile
)
10134 fprintf (outfile
,"0x%8.8x", addr
);
10137 /* Needed by the i386 disassembler. */
10139 db_task_printsym (unsigned int addr
)
10141 print_address (addr
, stderr
);
10145 int main
PARAMS ((int, char **));
10154 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10155 setlocale (LC_MESSAGES
, "");
10157 #if defined (HAVE_SETLOCALE)
10158 setlocale (LC_CTYPE
, "");
10160 bindtextdomain (PACKAGE
, LOCALEDIR
);
10161 textdomain (PACKAGE
);
10163 parse_args (argc
, argv
);
10165 if (optind
< (argc
- 1))
10169 while (optind
< argc
)
10170 err
|= process_file (argv
[optind
++]);
10172 if (dump_sects
!= NULL
)