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_Rela
**, 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 ((Elf_Internal_Shdr
*, FILE *));
225 static int dump_section
PARAMS ((Elf_Internal_Shdr
*, FILE *));
226 static int display_debug_section
PARAMS ((Elf_Internal_Shdr
*, FILE *));
227 static int display_debug_info
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
228 static int display_debug_not_supported
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
229 static int prescan_debug_info
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
230 static int display_debug_lines
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
231 static int display_debug_pubnames
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
232 static int display_debug_abbrev
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
233 static int display_debug_aranges
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
234 static int display_debug_frames
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
235 static int display_debug_macinfo
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
236 static int display_debug_str
PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
237 static int display_debug_loc
PARAMS ((Elf_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 ((Elf_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_Rela
**relsp
;
765 unsigned long *nrelsp
;
767 Elf_Internal_Rela
*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_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
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
);
794 rels
[i
].r_addend
= 0;
801 Elf64_External_Rel
* erels
;
803 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
804 rel_size
, _("relocs"));
808 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
810 rels
= (Elf_Internal_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
814 error(_("out of memory parsing relocs"));
818 for (i
= 0; i
< nrels
; i
++)
820 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
821 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
822 rels
[i
].r_addend
= 0;
832 /* Display the contents of the relocation data found at the specified offset. */
834 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
836 unsigned long rel_offset
;
837 unsigned long rel_size
;
838 Elf_Internal_Sym
* symtab
;
844 Elf_Internal_Rela
* rels
;
847 if (is_rela
== UNKNOWN
)
848 is_rela
= guess_is_rela (elf_header
.e_machine
);
852 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
857 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
866 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
868 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
873 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
875 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
883 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
885 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
890 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
892 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
896 for (i
= 0; i
< rel_size
; i
++)
899 const char * rtype2
= NULL
;
900 const char * rtype3
= NULL
;
903 bfd_vma symtab_index
;
905 bfd_vma type2
= (bfd_vma
) NULL
;
906 bfd_vma type3
= (bfd_vma
) NULL
;
908 offset
= rels
[i
].r_offset
;
909 info
= rels
[i
].r_info
;
913 type
= ELF32_R_TYPE (info
);
914 symtab_index
= ELF32_R_SYM (info
);
918 if (elf_header
.e_machine
== EM_MIPS
)
920 type
= ELF64_MIPS_R_TYPE (info
);
921 type2
= ELF64_MIPS_R_TYPE2 (info
);
922 type3
= ELF64_MIPS_R_TYPE3 (info
);
924 else if (elf_header
.e_machine
== EM_SPARCV9
)
925 type
= ELF64_R_TYPE_ID (info
);
927 type
= ELF64_R_TYPE (info
);
928 /* The #ifdef BFD64 below is to prevent a compile time warning.
929 We know that if we do not have a 64 bit data type that we
930 will never execute this code anyway. */
932 symtab_index
= ELF64_R_SYM (info
);
938 #ifdef _bfd_int64_low
939 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
941 printf ("%8.8lx %8.8lx ", offset
, info
);
946 #ifdef _bfd_int64_low
948 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
949 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
950 _bfd_int64_high (offset
),
951 _bfd_int64_low (offset
),
952 _bfd_int64_high (info
),
953 _bfd_int64_low (info
));
956 ? "%16.16lx %16.16lx "
957 : "%12.12lx %12.12lx ",
962 switch (elf_header
.e_machine
)
970 rtype
= elf_m32r_reloc_type (type
);
975 rtype
= elf_i386_reloc_type (type
);
980 rtype
= elf_m68hc11_reloc_type (type
);
984 rtype
= elf_m68k_reloc_type (type
);
988 rtype
= elf_i960_reloc_type (type
);
993 rtype
= elf_avr_reloc_type (type
);
1000 rtype
= elf_sparc_reloc_type (type
);
1004 case EM_CYGNUS_V850
:
1005 rtype
= v850_reloc_type (type
);
1009 case EM_CYGNUS_D10V
:
1010 rtype
= elf_d10v_reloc_type (type
);
1014 case EM_CYGNUS_D30V
:
1015 rtype
= elf_d30v_reloc_type (type
);
1019 rtype
= elf_dlx_reloc_type (type
);
1023 rtype
= elf_sh_reloc_type (type
);
1027 case EM_CYGNUS_MN10300
:
1028 rtype
= elf_mn10300_reloc_type (type
);
1032 case EM_CYGNUS_MN10200
:
1033 rtype
= elf_mn10200_reloc_type (type
);
1037 case EM_CYGNUS_FR30
:
1038 rtype
= elf_fr30_reloc_type (type
);
1042 rtype
= elf_frv_reloc_type (type
);
1046 rtype
= elf_mcore_reloc_type (type
);
1050 rtype
= elf_mmix_reloc_type (type
);
1055 rtype
= elf_ppc_reloc_type (type
);
1059 case EM_MIPS_RS3_LE
:
1060 rtype
= elf_mips_reloc_type (type
);
1063 rtype2
= elf_mips_reloc_type (type2
);
1064 rtype3
= elf_mips_reloc_type (type3
);
1069 rtype
= elf_alpha_reloc_type (type
);
1073 rtype
= elf_arm_reloc_type (type
);
1077 rtype
= elf_arc_reloc_type (type
);
1081 rtype
= elf_hppa_reloc_type (type
);
1087 rtype
= elf_h8_reloc_type (type
);
1092 rtype
= elf_or32_reloc_type (type
);
1097 rtype
= elf_pj_reloc_type (type
);
1100 rtype
= elf_ia64_reloc_type (type
);
1104 rtype
= elf_cris_reloc_type (type
);
1108 rtype
= elf_i860_reloc_type (type
);
1112 rtype
= elf_x86_64_reloc_type (type
);
1116 rtype
= i370_reloc_type (type
);
1121 rtype
= elf_s390_reloc_type (type
);
1125 rtype
= elf_xstormy16_reloc_type (type
);
1129 rtype
= elf_vax_reloc_type (type
);
1134 rtype
= elf_ip2k_reloc_type (type
);
1139 #ifdef _bfd_int64_low
1140 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1142 printf (_("unrecognized: %-7lx"), type
);
1145 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1149 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1150 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1153 Elf_Internal_Sym
* psym
;
1155 psym
= symtab
+ symtab_index
;
1158 print_vma (psym
->st_value
, LONG_HEX
);
1159 printf (is_32bit_elf
? " " : " ");
1161 if (psym
->st_name
== 0)
1163 const char *sec_name
= "<null>";
1166 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1168 bfd_vma sec_index
= (bfd_vma
) -1;
1170 if (psym
->st_shndx
< SHN_LORESERVE
)
1171 sec_index
= psym
->st_shndx
;
1172 else if (psym
->st_shndx
> SHN_LORESERVE
)
1173 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1176 if (sec_index
!= (bfd_vma
) -1)
1177 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1178 else if (psym
->st_shndx
== SHN_ABS
)
1180 else if (psym
->st_shndx
== SHN_COMMON
)
1181 sec_name
= "COMMON";
1184 sprintf (name_buf
, "<section 0x%x>",
1185 (unsigned int) psym
->st_shndx
);
1186 sec_name
= name_buf
;
1189 print_symbol (22, sec_name
);
1191 else if (strtab
== NULL
)
1192 printf (_("<string table index %3ld>"), psym
->st_name
);
1194 print_symbol (22, strtab
+ psym
->st_name
);
1197 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1202 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1203 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1206 if (elf_header
.e_machine
== EM_SPARCV9
1207 && !strcmp (rtype
, "R_SPARC_OLO10"))
1208 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1212 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1214 printf (" Type2: ");
1217 #ifdef _bfd_int64_low
1218 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1220 printf (_("unrecognized: %-7lx"), type2
);
1223 printf ("%-17.17s", rtype2
);
1225 printf("\n Type3: ");
1228 #ifdef _bfd_int64_low
1229 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1231 printf (_("unrecognized: %-7lx"), type3
);
1234 printf ("%-17.17s", rtype3
);
1246 get_mips_dynamic_type (type
)
1251 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1252 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1253 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1254 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1255 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1256 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1257 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1258 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1259 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1260 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1261 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1262 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1263 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1264 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1265 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1266 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1267 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1268 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1269 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1270 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1271 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1272 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1273 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1274 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1275 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1276 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1277 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1278 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1279 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1280 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1281 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1282 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1283 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1284 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1285 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1286 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1287 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1288 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1289 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1290 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1291 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1292 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1293 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1300 get_sparc64_dynamic_type (type
)
1305 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1312 get_ppc64_dynamic_type (type
)
1317 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1318 case DT_PPC64_OPD
: return "PPC64_OPD";
1319 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1326 get_parisc_dynamic_type (type
)
1331 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1332 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1333 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1334 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1335 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1336 case DT_HP_PREINIT
: return "HP_PREINIT";
1337 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1338 case DT_HP_NEEDED
: return "HP_NEEDED";
1339 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1340 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1341 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1342 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1343 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1350 get_dynamic_type (type
)
1353 static char buff
[32];
1357 case DT_NULL
: return "NULL";
1358 case DT_NEEDED
: return "NEEDED";
1359 case DT_PLTRELSZ
: return "PLTRELSZ";
1360 case DT_PLTGOT
: return "PLTGOT";
1361 case DT_HASH
: return "HASH";
1362 case DT_STRTAB
: return "STRTAB";
1363 case DT_SYMTAB
: return "SYMTAB";
1364 case DT_RELA
: return "RELA";
1365 case DT_RELASZ
: return "RELASZ";
1366 case DT_RELAENT
: return "RELAENT";
1367 case DT_STRSZ
: return "STRSZ";
1368 case DT_SYMENT
: return "SYMENT";
1369 case DT_INIT
: return "INIT";
1370 case DT_FINI
: return "FINI";
1371 case DT_SONAME
: return "SONAME";
1372 case DT_RPATH
: return "RPATH";
1373 case DT_SYMBOLIC
: return "SYMBOLIC";
1374 case DT_REL
: return "REL";
1375 case DT_RELSZ
: return "RELSZ";
1376 case DT_RELENT
: return "RELENT";
1377 case DT_PLTREL
: return "PLTREL";
1378 case DT_DEBUG
: return "DEBUG";
1379 case DT_TEXTREL
: return "TEXTREL";
1380 case DT_JMPREL
: return "JMPREL";
1381 case DT_BIND_NOW
: return "BIND_NOW";
1382 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1383 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1384 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1385 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1386 case DT_RUNPATH
: return "RUNPATH";
1387 case DT_FLAGS
: return "FLAGS";
1389 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1390 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1392 case DT_CHECKSUM
: return "CHECKSUM";
1393 case DT_PLTPADSZ
: return "PLTPADSZ";
1394 case DT_MOVEENT
: return "MOVEENT";
1395 case DT_MOVESZ
: return "MOVESZ";
1396 case DT_FEATURE
: return "FEATURE";
1397 case DT_POSFLAG_1
: return "POSFLAG_1";
1398 case DT_SYMINSZ
: return "SYMINSZ";
1399 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1401 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1402 case DT_CONFIG
: return "CONFIG";
1403 case DT_DEPAUDIT
: return "DEPAUDIT";
1404 case DT_AUDIT
: return "AUDIT";
1405 case DT_PLTPAD
: return "PLTPAD";
1406 case DT_MOVETAB
: return "MOVETAB";
1407 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1409 case DT_VERSYM
: return "VERSYM";
1411 case DT_RELACOUNT
: return "RELACOUNT";
1412 case DT_RELCOUNT
: return "RELCOUNT";
1413 case DT_FLAGS_1
: return "FLAGS_1";
1414 case DT_VERDEF
: return "VERDEF";
1415 case DT_VERDEFNUM
: return "VERDEFNUM";
1416 case DT_VERNEED
: return "VERNEED";
1417 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1419 case DT_AUXILIARY
: return "AUXILIARY";
1420 case DT_USED
: return "USED";
1421 case DT_FILTER
: return "FILTER";
1423 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1424 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1425 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1426 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1427 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1430 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1432 const char * result
;
1434 switch (elf_header
.e_machine
)
1437 case EM_MIPS_RS3_LE
:
1438 result
= get_mips_dynamic_type (type
);
1441 result
= get_sparc64_dynamic_type (type
);
1444 result
= get_ppc64_dynamic_type (type
);
1454 sprintf (buff
, _("Processor Specific: %lx"), type
);
1456 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1458 const char * result
;
1460 switch (elf_header
.e_machine
)
1463 result
= get_parisc_dynamic_type (type
);
1473 sprintf (buff
, _("Operating System specific: %lx"), type
);
1476 sprintf (buff
, _("<unknown>: %lx"), type
);
1483 get_file_type (e_type
)
1486 static char buff
[32];
1490 case ET_NONE
: return _("NONE (None)");
1491 case ET_REL
: return _("REL (Relocatable file)");
1492 case ET_EXEC
: return _("EXEC (Executable file)");
1493 case ET_DYN
: return _("DYN (Shared object file)");
1494 case ET_CORE
: return _("CORE (Core file)");
1497 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1498 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1499 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1500 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1502 sprintf (buff
, _("<unknown>: %x"), e_type
);
1508 get_machine_name (e_machine
)
1511 static char buff
[64]; /* XXX */
1515 case EM_NONE
: return _("None");
1516 case EM_M32
: return "WE32100";
1517 case EM_SPARC
: return "Sparc";
1518 case EM_386
: return "Intel 80386";
1519 case EM_68K
: return "MC68000";
1520 case EM_88K
: return "MC88000";
1521 case EM_486
: return "Intel 80486";
1522 case EM_860
: return "Intel 80860";
1523 case EM_MIPS
: return "MIPS R3000";
1524 case EM_S370
: return "IBM System/370";
1525 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1526 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1527 case EM_PARISC
: return "HPPA";
1528 case EM_PPC_OLD
: return "Power PC (old)";
1529 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1530 case EM_960
: return "Intel 90860";
1531 case EM_PPC
: return "PowerPC";
1532 case EM_PPC64
: return "PowerPC64";
1533 case EM_V800
: return "NEC V800";
1534 case EM_FR20
: return "Fujitsu FR20";
1535 case EM_RH32
: return "TRW RH32";
1536 case EM_MCORE
: return "MCORE";
1537 case EM_ARM
: return "ARM";
1538 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1539 case EM_SH
: return "Hitachi SH";
1540 case EM_SPARCV9
: return "Sparc v9";
1541 case EM_TRICORE
: return "Siemens Tricore";
1542 case EM_ARC
: return "ARC";
1543 case EM_H8_300
: return "Hitachi H8/300";
1544 case EM_H8_300H
: return "Hitachi H8/300H";
1545 case EM_H8S
: return "Hitachi H8S";
1546 case EM_H8_500
: return "Hitachi H8/500";
1547 case EM_IA_64
: return "Intel IA-64";
1548 case EM_MIPS_X
: return "Stanford MIPS-X";
1549 case EM_COLDFIRE
: return "Motorola Coldfire";
1550 case EM_68HC12
: return "Motorola M68HC12";
1551 case EM_ALPHA
: return "Alpha";
1552 case EM_CYGNUS_D10V
:
1553 case EM_D10V
: return "d10v";
1554 case EM_CYGNUS_D30V
:
1555 case EM_D30V
: return "d30v";
1556 case EM_CYGNUS_M32R
:
1557 case EM_M32R
: return "Mitsubishi M32r";
1558 case EM_CYGNUS_V850
:
1559 case EM_V850
: return "NEC v850";
1560 case EM_CYGNUS_MN10300
:
1561 case EM_MN10300
: return "mn10300";
1562 case EM_CYGNUS_MN10200
:
1563 case EM_MN10200
: return "mn10200";
1564 case EM_CYGNUS_FR30
:
1565 case EM_FR30
: return "Fujitsu FR30";
1566 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1568 case EM_PJ
: return "picoJava";
1569 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1570 case EM_PCP
: return "Siemens PCP";
1571 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1572 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1573 case EM_STARCORE
: return "Motorola Star*Core processor";
1574 case EM_ME16
: return "Toyota ME16 processor";
1575 case EM_ST100
: return "STMicroelectronics ST100 processor";
1576 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1577 case EM_FX66
: return "Siemens FX66 microcontroller";
1578 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1579 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1580 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1581 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1582 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1583 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1584 case EM_SVX
: return "Silicon Graphics SVx";
1585 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1586 case EM_VAX
: return "Digital VAX";
1588 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1589 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1590 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1591 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1592 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1593 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1594 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1595 case EM_PRISM
: return "SiTera Prism";
1596 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1598 case EM_S390
: return "IBM S/390";
1599 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1601 case EM_OR32
: return "OpenRISC";
1602 case EM_DLX
: return "OpenDLX";
1604 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1606 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1612 decode_ARM_machine_flags (e_flags
, buf
)
1619 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1620 e_flags
&= ~ EF_ARM_EABIMASK
;
1622 /* Handle "generic" ARM flags. */
1623 if (e_flags
& EF_ARM_RELEXEC
)
1625 strcat (buf
, ", relocatable executable");
1626 e_flags
&= ~ EF_ARM_RELEXEC
;
1629 if (e_flags
& EF_ARM_HASENTRY
)
1631 strcat (buf
, ", has entry point");
1632 e_flags
&= ~ EF_ARM_HASENTRY
;
1635 /* Now handle EABI specific flags. */
1639 strcat (buf
, ", <unrecognized EABI>");
1644 case EF_ARM_EABI_VER1
:
1645 strcat (buf
, ", Version1 EABI");
1650 /* Process flags one bit at a time. */
1651 flag
= e_flags
& - e_flags
;
1656 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1657 strcat (buf
, ", sorted symbol tables");
1667 case EF_ARM_EABI_VER2
:
1668 strcat (buf
, ", Version2 EABI");
1673 /* Process flags one bit at a time. */
1674 flag
= e_flags
& - e_flags
;
1679 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1680 strcat (buf
, ", sorted symbol tables");
1683 case EF_ARM_DYNSYMSUSESEGIDX
:
1684 strcat (buf
, ", dynamic symbols use segment index");
1687 case EF_ARM_MAPSYMSFIRST
:
1688 strcat (buf
, ", mapping symbols precede others");
1698 case EF_ARM_EABI_UNKNOWN
:
1699 strcat (buf
, ", GNU EABI");
1704 /* Process flags one bit at a time. */
1705 flag
= e_flags
& - e_flags
;
1710 case EF_ARM_INTERWORK
:
1711 strcat (buf
, ", interworking enabled");
1714 case EF_ARM_APCS_26
:
1715 strcat (buf
, ", uses APCS/26");
1718 case EF_ARM_APCS_FLOAT
:
1719 strcat (buf
, ", uses APCS/float");
1723 strcat (buf
, ", position independent");
1727 strcat (buf
, ", 8 bit structure alignment");
1730 case EF_ARM_NEW_ABI
:
1731 strcat (buf
, ", uses new ABI");
1734 case EF_ARM_OLD_ABI
:
1735 strcat (buf
, ", uses old ABI");
1738 case EF_ARM_SOFT_FLOAT
:
1739 strcat (buf
, ", software FP");
1750 strcat (buf
,", <unknown>");
1754 get_machine_flags (e_flags
, e_machine
)
1758 static char buf
[1024];
1770 decode_ARM_machine_flags (e_flags
, buf
);
1774 if (e_flags
& EF_CPU32
)
1775 strcat (buf
, ", cpu32");
1776 if (e_flags
& EF_M68000
)
1777 strcat (buf
, ", m68000");
1781 if (e_flags
& EF_PPC_EMB
)
1782 strcat (buf
, ", emb");
1784 if (e_flags
& EF_PPC_RELOCATABLE
)
1785 strcat (buf
, ", relocatable");
1787 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1788 strcat (buf
, ", relocatable-lib");
1792 case EM_CYGNUS_V850
:
1793 switch (e_flags
& EF_V850_ARCH
)
1796 strcat (buf
, ", v850e");
1799 strcat (buf
, ", v850");
1802 strcat (buf
, ", unknown v850 architecture variant");
1808 case EM_CYGNUS_M32R
:
1809 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1810 strcat (buf
, ", m32r");
1815 case EM_MIPS_RS3_LE
:
1816 if (e_flags
& EF_MIPS_NOREORDER
)
1817 strcat (buf
, ", noreorder");
1819 if (e_flags
& EF_MIPS_PIC
)
1820 strcat (buf
, ", pic");
1822 if (e_flags
& EF_MIPS_CPIC
)
1823 strcat (buf
, ", cpic");
1825 if (e_flags
& EF_MIPS_UCODE
)
1826 strcat (buf
, ", ugen_reserved");
1828 if (e_flags
& EF_MIPS_ABI2
)
1829 strcat (buf
, ", abi2");
1831 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1832 strcat (buf
, ", odk first");
1834 if (e_flags
& EF_MIPS_32BITMODE
)
1835 strcat (buf
, ", 32bitmode");
1837 switch ((e_flags
& EF_MIPS_MACH
))
1839 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1840 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1841 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1842 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1843 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1844 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1845 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1846 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1847 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1849 /* We simply ignore the field in this case to avoid confusion:
1850 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1853 default: strcat (buf
, ", unknown CPU"); break;
1856 switch ((e_flags
& EF_MIPS_ABI
))
1858 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1859 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1860 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1861 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1863 /* We simply ignore the field in this case to avoid confusion:
1864 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1865 This means it is likely to be an o32 file, but not for
1868 default: strcat (buf
, ", unknown ABI"); break;
1871 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1872 strcat (buf
, ", mdmx");
1874 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1875 strcat (buf
, ", mips16");
1877 switch ((e_flags
& EF_MIPS_ARCH
))
1879 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1880 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1881 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1882 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1883 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1884 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1885 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1886 default: strcat (buf
, ", unknown ISA"); break;
1892 if (e_flags
& EF_SPARC_32PLUS
)
1893 strcat (buf
, ", v8+");
1895 if (e_flags
& EF_SPARC_SUN_US1
)
1896 strcat (buf
, ", ultrasparcI");
1898 if (e_flags
& EF_SPARC_SUN_US3
)
1899 strcat (buf
, ", ultrasparcIII");
1901 if (e_flags
& EF_SPARC_HAL_R1
)
1902 strcat (buf
, ", halr1");
1904 if (e_flags
& EF_SPARC_LEDATA
)
1905 strcat (buf
, ", ledata");
1907 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1908 strcat (buf
, ", tso");
1910 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1911 strcat (buf
, ", pso");
1913 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1914 strcat (buf
, ", rmo");
1918 switch (e_flags
& EF_PARISC_ARCH
)
1920 case EFA_PARISC_1_0
:
1921 strcpy (buf
, ", PA-RISC 1.0");
1923 case EFA_PARISC_1_1
:
1924 strcpy (buf
, ", PA-RISC 1.1");
1926 case EFA_PARISC_2_0
:
1927 strcpy (buf
, ", PA-RISC 2.0");
1932 if (e_flags
& EF_PARISC_TRAPNIL
)
1933 strcat (buf
, ", trapnil");
1934 if (e_flags
& EF_PARISC_EXT
)
1935 strcat (buf
, ", ext");
1936 if (e_flags
& EF_PARISC_LSB
)
1937 strcat (buf
, ", lsb");
1938 if (e_flags
& EF_PARISC_WIDE
)
1939 strcat (buf
, ", wide");
1940 if (e_flags
& EF_PARISC_NO_KABP
)
1941 strcat (buf
, ", no kabp");
1942 if (e_flags
& EF_PARISC_LAZYSWAP
)
1943 strcat (buf
, ", lazyswap");
1948 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1949 strcat (buf
, ", new calling convention");
1951 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1952 strcat (buf
, ", gnu calling convention");
1956 if ((e_flags
& EF_IA_64_ABI64
))
1957 strcat (buf
, ", 64-bit");
1959 strcat (buf
, ", 32-bit");
1960 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1961 strcat (buf
, ", reduced fp model");
1962 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1963 strcat (buf
, ", no function descriptors, constant gp");
1964 else if ((e_flags
& EF_IA_64_CONS_GP
))
1965 strcat (buf
, ", constant gp");
1966 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1967 strcat (buf
, ", absolute");
1971 if ((e_flags
& EF_VAX_NONPIC
))
1972 strcat (buf
, ", non-PIC");
1973 if ((e_flags
& EF_VAX_DFLOAT
))
1974 strcat (buf
, ", D-Float");
1975 if ((e_flags
& EF_VAX_GFLOAT
))
1976 strcat (buf
, ", G-Float");
1985 get_mips_segment_type (type
)
1990 case PT_MIPS_REGINFO
:
1992 case PT_MIPS_RTPROC
:
1994 case PT_MIPS_OPTIONS
:
2004 get_parisc_segment_type (type
)
2009 case PT_HP_TLS
: return "HP_TLS";
2010 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2011 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2012 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2013 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2014 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2015 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2016 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2017 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2018 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2019 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2020 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2021 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2022 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2031 get_ia64_segment_type (type
)
2036 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2037 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2038 case PT_HP_TLS
: return "HP_TLS";
2039 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2040 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2041 case PT_IA_64_HP_STACK
: return "HP_STACK";
2050 get_segment_type (p_type
)
2051 unsigned long p_type
;
2053 static char buff
[32];
2057 case PT_NULL
: return "NULL";
2058 case PT_LOAD
: return "LOAD";
2059 case PT_DYNAMIC
: return "DYNAMIC";
2060 case PT_INTERP
: return "INTERP";
2061 case PT_NOTE
: return "NOTE";
2062 case PT_SHLIB
: return "SHLIB";
2063 case PT_PHDR
: return "PHDR";
2064 case PT_TLS
: return "TLS";
2066 case PT_GNU_EH_FRAME
:
2067 return "GNU_EH_FRAME";
2070 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2072 const char * result
;
2074 switch (elf_header
.e_machine
)
2077 case EM_MIPS_RS3_LE
:
2078 result
= get_mips_segment_type (p_type
);
2081 result
= get_parisc_segment_type (p_type
);
2084 result
= get_ia64_segment_type (p_type
);
2094 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2096 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2098 const char * result
;
2100 switch (elf_header
.e_machine
)
2103 result
= get_parisc_segment_type (p_type
);
2106 result
= get_ia64_segment_type (p_type
);
2116 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2119 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2126 get_mips_section_type_name (sh_type
)
2127 unsigned int sh_type
;
2131 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2132 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2133 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2134 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2135 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2136 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2137 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2138 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2139 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2140 case SHT_MIPS_RELD
: return "MIPS_RELD";
2141 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2142 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2143 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2144 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2145 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2146 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2147 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2148 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2149 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2150 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2151 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2152 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2153 case SHT_MIPS_LINE
: return "MIPS_LINE";
2154 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2155 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2156 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2157 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2158 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2159 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2160 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2161 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2162 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2163 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2164 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2165 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2166 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2167 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2168 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2169 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2177 get_parisc_section_type_name (sh_type
)
2178 unsigned int sh_type
;
2182 case SHT_PARISC_EXT
: return "PARISC_EXT";
2183 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2184 case SHT_PARISC_DOC
: return "PARISC_DOC";
2192 get_ia64_section_type_name (sh_type
)
2193 unsigned int sh_type
;
2197 case SHT_IA_64_EXT
: return "IA_64_EXT";
2198 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2206 get_section_type_name (sh_type
)
2207 unsigned int sh_type
;
2209 static char buff
[32];
2213 case SHT_NULL
: return "NULL";
2214 case SHT_PROGBITS
: return "PROGBITS";
2215 case SHT_SYMTAB
: return "SYMTAB";
2216 case SHT_STRTAB
: return "STRTAB";
2217 case SHT_RELA
: return "RELA";
2218 case SHT_HASH
: return "HASH";
2219 case SHT_DYNAMIC
: return "DYNAMIC";
2220 case SHT_NOTE
: return "NOTE";
2221 case SHT_NOBITS
: return "NOBITS";
2222 case SHT_REL
: return "REL";
2223 case SHT_SHLIB
: return "SHLIB";
2224 case SHT_DYNSYM
: return "DYNSYM";
2225 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2226 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2227 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2228 case SHT_GROUP
: return "GROUP";
2229 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2230 case SHT_GNU_verdef
: return "VERDEF";
2231 case SHT_GNU_verneed
: return "VERNEED";
2232 case SHT_GNU_versym
: return "VERSYM";
2233 case 0x6ffffff0: return "VERSYM";
2234 case 0x6ffffffc: return "VERDEF";
2235 case 0x7ffffffd: return "AUXILIARY";
2236 case 0x7fffffff: return "FILTER";
2237 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2240 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2242 const char * result
;
2244 switch (elf_header
.e_machine
)
2247 case EM_MIPS_RS3_LE
:
2248 result
= get_mips_section_type_name (sh_type
);
2251 result
= get_parisc_section_type_name (sh_type
);
2254 result
= get_ia64_section_type_name (sh_type
);
2264 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2266 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2267 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2268 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2269 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2271 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2277 #define OPTION_DEBUG_DUMP 512
2279 struct option options
[] =
2281 {"all", no_argument
, 0, 'a'},
2282 {"file-header", no_argument
, 0, 'h'},
2283 {"program-headers", no_argument
, 0, 'l'},
2284 {"headers", no_argument
, 0, 'e'},
2285 {"histogram", no_argument
, 0, 'I'},
2286 {"segments", no_argument
, 0, 'l'},
2287 {"sections", no_argument
, 0, 'S'},
2288 {"section-headers", no_argument
, 0, 'S'},
2289 {"symbols", no_argument
, 0, 's'},
2290 {"syms", no_argument
, 0, 's'},
2291 {"relocs", no_argument
, 0, 'r'},
2292 {"notes", no_argument
, 0, 'n'},
2293 {"dynamic", no_argument
, 0, 'd'},
2294 {"arch-specific", no_argument
, 0, 'A'},
2295 {"version-info", no_argument
, 0, 'V'},
2296 {"use-dynamic", no_argument
, 0, 'D'},
2297 {"hex-dump", required_argument
, 0, 'x'},
2298 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2299 {"unwind", no_argument
, 0, 'u'},
2300 #ifdef SUPPORT_DISASSEMBLY
2301 {"instruction-dump", required_argument
, 0, 'i'},
2304 {"version", no_argument
, 0, 'v'},
2305 {"wide", no_argument
, 0, 'W'},
2306 {"help", no_argument
, 0, 'H'},
2307 {0, no_argument
, 0, 0}
2313 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2314 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2315 fprintf (stdout
, _(" Options are:\n\
2316 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2317 -h --file-header Display the ELF file header\n\
2318 -l --program-headers Display the program headers\n\
2319 --segments An alias for --program-headers\n\
2320 -S --section-headers Display the sections' header\n\
2321 --sections An alias for --section-headers\n\
2322 -e --headers Equivalent to: -h -l -S\n\
2323 -s --syms Display the symbol table\n\
2324 --symbols An alias for --syms\n\
2325 -n --notes Display the core notes (if present)\n\
2326 -r --relocs Display the relocations (if present)\n\
2327 -u --unwind Display the unwind info (if present)\n\
2328 -d --dynamic Display the dynamic segment (if present)\n\
2329 -V --version-info Display the version sections (if present)\n\
2330 -A --arch-specific Display architecture specific information (if any).\n\
2331 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2332 -x --hex-dump=<number> Dump the contents of section <number>\n\
2333 -w[liaprmfFso] or\n\
2334 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2335 Display the contents of DWARF2 debug sections\n"));
2336 #ifdef SUPPORT_DISASSEMBLY
2337 fprintf (stdout
, _("\
2338 -i --instruction-dump=<number>\n\
2339 Disassemble the contents of section <number>\n"));
2341 fprintf (stdout
, _("\
2342 -I --histogram Display histogram of bucket list lengths\n\
2343 -W --wide Allow output width to exceed 80 characters\n\
2344 -H --help Display this information\n\
2345 -v --version Display the version number of readelf\n"));
2346 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2352 request_dump (section
, type
)
2353 unsigned int section
;
2356 if (section
>= num_dump_sects
)
2358 char * new_dump_sects
;
2360 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2362 if (new_dump_sects
== NULL
)
2363 error (_("Out of memory allocating dump request table."));
2366 /* Copy current flag settings. */
2367 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2371 dump_sects
= new_dump_sects
;
2372 num_dump_sects
= section
+ 1;
2377 dump_sects
[section
] |= type
;
2383 parse_args (argc
, argv
)
2392 while ((c
= getopt_long
2393 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2429 do_using_dynamic
++;
2460 section
= strtoul (optarg
, & cp
, 0);
2461 if (! * cp
&& section
>= 0)
2463 request_dump (section
, HEX_DUMP
);
2473 unsigned int index
= 0;
2477 while (optarg
[index
])
2478 switch (optarg
[index
++])
2487 do_debug_abbrevs
= 1;
2497 do_debug_pubnames
= 1;
2502 do_debug_aranges
= 1;
2506 do_debug_frames_interp
= 1;
2508 do_debug_frames
= 1;
2513 do_debug_macinfo
= 1;
2527 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2532 case OPTION_DEBUG_DUMP
:
2538 static const char *debug_dump_opt
[]
2539 = { "line", "info", "abbrev", "pubnames", "ranges",
2540 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2549 for (index
= 0; debug_dump_opt
[index
]; index
++)
2551 size_t len
= strlen (debug_dump_opt
[index
]);
2553 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2554 && (p
[len
] == ',' || p
[len
] == '\0'))
2563 do_debug_abbrevs
= 1;
2574 do_debug_pubnames
= 1;
2578 do_debug_aranges
= 1;
2583 do_debug_frames_interp
= 1;
2584 do_debug_frames
= 1;
2588 do_debug_macinfo
= 1;
2601 if (debug_dump_opt
[index
] == NULL
)
2603 warn (_("Unrecognized debug option '%s'\n"), p
);
2604 p
= strchr (p
, ',');
2614 #ifdef SUPPORT_DISASSEMBLY
2617 section
= strtoul (optarg
, & cp
, 0);
2618 if (! * cp
&& section
>= 0)
2620 request_dump (section
, DISASS_DUMP
);
2626 print_version (program_name
);
2636 /* xgettext:c-format */
2637 error (_("Invalid option '-%c'\n"), c
);
2644 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2645 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2646 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2650 warn (_("Nothing to do.\n"));
2656 get_elf_class (elf_class
)
2657 unsigned int elf_class
;
2659 static char buff
[32];
2663 case ELFCLASSNONE
: return _("none");
2664 case ELFCLASS32
: return "ELF32";
2665 case ELFCLASS64
: return "ELF64";
2667 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2673 get_data_encoding (encoding
)
2674 unsigned int encoding
;
2676 static char buff
[32];
2680 case ELFDATANONE
: return _("none");
2681 case ELFDATA2LSB
: return _("2's complement, little endian");
2682 case ELFDATA2MSB
: return _("2's complement, big endian");
2684 sprintf (buff
, _("<unknown: %x>"), encoding
);
2690 get_osabi_name (osabi
)
2693 static char buff
[32];
2697 case ELFOSABI_NONE
: return "UNIX - System V";
2698 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2699 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2700 case ELFOSABI_LINUX
: return "UNIX - Linux";
2701 case ELFOSABI_HURD
: return "GNU/Hurd";
2702 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2703 case ELFOSABI_AIX
: return "UNIX - AIX";
2704 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2705 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2706 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2707 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2708 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2709 case ELFOSABI_STANDALONE
: return _("Standalone App");
2710 case ELFOSABI_ARM
: return "ARM";
2712 sprintf (buff
, _("<unknown: %x>"), osabi
);
2717 /* Decode the data held in 'elf_header'. */
2719 process_file_header ()
2721 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2722 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2723 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2724 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2727 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2735 printf (_("ELF Header:\n"));
2736 printf (_(" Magic: "));
2737 for (i
= 0; i
< EI_NIDENT
; i
++)
2738 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2740 printf (_(" Class: %s\n"),
2741 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2742 printf (_(" Data: %s\n"),
2743 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2744 printf (_(" Version: %d %s\n"),
2745 elf_header
.e_ident
[EI_VERSION
],
2746 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2748 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2751 printf (_(" OS/ABI: %s\n"),
2752 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2753 printf (_(" ABI Version: %d\n"),
2754 elf_header
.e_ident
[EI_ABIVERSION
]);
2755 printf (_(" Type: %s\n"),
2756 get_file_type (elf_header
.e_type
));
2757 printf (_(" Machine: %s\n"),
2758 get_machine_name (elf_header
.e_machine
));
2759 printf (_(" Version: 0x%lx\n"),
2760 (unsigned long) elf_header
.e_version
);
2762 printf (_(" Entry point address: "));
2763 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2764 printf (_("\n Start of program headers: "));
2765 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2766 printf (_(" (bytes into file)\n Start of section headers: "));
2767 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2768 printf (_(" (bytes into file)\n"));
2770 printf (_(" Flags: 0x%lx%s\n"),
2771 (unsigned long) elf_header
.e_flags
,
2772 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2773 printf (_(" Size of this header: %ld (bytes)\n"),
2774 (long) elf_header
.e_ehsize
);
2775 printf (_(" Size of program headers: %ld (bytes)\n"),
2776 (long) elf_header
.e_phentsize
);
2777 printf (_(" Number of program headers: %ld\n"),
2778 (long) elf_header
.e_phnum
);
2779 printf (_(" Size of section headers: %ld (bytes)\n"),
2780 (long) elf_header
.e_shentsize
);
2781 printf (_(" Number of section headers: %ld"),
2782 (long) elf_header
.e_shnum
);
2783 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2784 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2785 putc ('\n', stdout
);
2786 printf (_(" Section header string table index: %ld"),
2787 (long) elf_header
.e_shstrndx
);
2788 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2789 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2790 putc ('\n', stdout
);
2793 if (section_headers
!= NULL
)
2795 if (elf_header
.e_shnum
== 0)
2796 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2797 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2798 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2799 free (section_headers
);
2800 section_headers
= NULL
;
2808 get_32bit_program_headers (file
, program_headers
)
2810 Elf_Internal_Phdr
* program_headers
;
2812 Elf32_External_Phdr
* phdrs
;
2813 Elf32_External_Phdr
* external
;
2814 Elf_Internal_Phdr
* internal
;
2817 phdrs
= ((Elf32_External_Phdr
*)
2818 get_data (NULL
, file
, elf_header
.e_phoff
,
2819 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2820 _("program headers")));
2824 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2825 i
< elf_header
.e_phnum
;
2826 i
++, internal
++, external
++)
2828 internal
->p_type
= BYTE_GET (external
->p_type
);
2829 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2830 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2831 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2832 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2833 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2834 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2835 internal
->p_align
= BYTE_GET (external
->p_align
);
2844 get_64bit_program_headers (file
, program_headers
)
2846 Elf_Internal_Phdr
* program_headers
;
2848 Elf64_External_Phdr
* phdrs
;
2849 Elf64_External_Phdr
* external
;
2850 Elf_Internal_Phdr
* internal
;
2853 phdrs
= ((Elf64_External_Phdr
*)
2854 get_data (NULL
, file
, elf_header
.e_phoff
,
2855 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2856 _("program headers")));
2860 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2861 i
< elf_header
.e_phnum
;
2862 i
++, internal
++, external
++)
2864 internal
->p_type
= BYTE_GET (external
->p_type
);
2865 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2866 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2867 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2868 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2869 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2870 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2871 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2879 /* Returns 1 if the program headers were loaded. */
2882 process_program_headers (file
)
2885 Elf_Internal_Phdr
* program_headers
;
2886 Elf_Internal_Phdr
* segment
;
2889 if (elf_header
.e_phnum
== 0)
2892 printf (_("\nThere are no program headers in this file.\n"));
2896 if (do_segments
&& !do_header
)
2898 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2899 printf (_("Entry point "));
2900 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2901 printf (_("\nThere are %d program headers, starting at offset "),
2902 elf_header
.e_phnum
);
2903 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2907 program_headers
= (Elf_Internal_Phdr
*) malloc
2908 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2910 if (program_headers
== NULL
)
2912 error (_("Out of memory\n"));
2917 i
= get_32bit_program_headers (file
, program_headers
);
2919 i
= get_64bit_program_headers (file
, program_headers
);
2923 free (program_headers
);
2929 if (elf_header
.e_phnum
> 1)
2930 printf (_("\nProgram Headers:\n"));
2932 printf (_("\nProgram Headers:\n"));
2936 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2939 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2943 (_(" Type Offset VirtAddr PhysAddr\n"));
2945 (_(" FileSiz MemSiz Flags Align\n"));
2953 for (i
= 0, segment
= program_headers
;
2954 i
< elf_header
.e_phnum
;
2959 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2963 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2964 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2965 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2966 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2967 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2969 (segment
->p_flags
& PF_R
? 'R' : ' '),
2970 (segment
->p_flags
& PF_W
? 'W' : ' '),
2971 (segment
->p_flags
& PF_X
? 'E' : ' '));
2972 printf ("%#lx", (unsigned long) segment
->p_align
);
2976 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2977 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2980 print_vma (segment
->p_offset
, FULL_HEX
);
2984 print_vma (segment
->p_vaddr
, FULL_HEX
);
2986 print_vma (segment
->p_paddr
, FULL_HEX
);
2989 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
2990 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
2993 print_vma (segment
->p_filesz
, FULL_HEX
);
2997 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
2998 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3001 print_vma (segment
->p_offset
, FULL_HEX
);
3005 (segment
->p_flags
& PF_R
? 'R' : ' '),
3006 (segment
->p_flags
& PF_W
? 'W' : ' '),
3007 (segment
->p_flags
& PF_X
? 'E' : ' '));
3009 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3010 printf ("%#lx", (unsigned long) segment
->p_align
);
3013 print_vma (segment
->p_align
, PREFIX_HEX
);
3018 print_vma (segment
->p_offset
, FULL_HEX
);
3020 print_vma (segment
->p_vaddr
, FULL_HEX
);
3022 print_vma (segment
->p_paddr
, FULL_HEX
);
3024 print_vma (segment
->p_filesz
, FULL_HEX
);
3026 print_vma (segment
->p_memsz
, FULL_HEX
);
3028 (segment
->p_flags
& PF_R
? 'R' : ' '),
3029 (segment
->p_flags
& PF_W
? 'W' : ' '),
3030 (segment
->p_flags
& PF_X
? 'E' : ' '));
3031 print_vma (segment
->p_align
, HEX
);
3035 switch (segment
->p_type
)
3039 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
3040 - (segment
->p_offset
& 0xfffff000);
3045 error (_("more than one dynamic segment\n"));
3047 dynamic_addr
= segment
->p_offset
;
3048 dynamic_size
= segment
->p_filesz
;
3052 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
3053 error (_("Unable to find program interpreter name\n"));
3056 program_interpreter
[0] = 0;
3057 fscanf (file
, "%63s", program_interpreter
);
3060 printf (_("\n [Requesting program interpreter: %s]"),
3061 program_interpreter
);
3067 putc ('\n', stdout
);
3076 if (do_segments
&& section_headers
!= NULL
)
3078 printf (_("\n Section to Segment mapping:\n"));
3079 printf (_(" Segment Sections...\n"));
3081 assert (string_table
!= NULL
);
3083 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3086 Elf_Internal_Shdr
* section
;
3088 segment
= program_headers
+ i
;
3089 section
= section_headers
;
3091 printf (" %2.2d ", i
);
3093 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3095 if (section
->sh_size
> 0
3096 /* Compare allocated sections by VMA, unallocated
3097 sections by file offset. */
3098 && (section
->sh_flags
& SHF_ALLOC
3099 ? (section
->sh_addr
>= segment
->p_vaddr
3100 && section
->sh_addr
+ section
->sh_size
3101 <= segment
->p_vaddr
+ segment
->p_memsz
)
3102 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3103 && (section
->sh_offset
+ section
->sh_size
3104 <= segment
->p_offset
+ segment
->p_filesz
))))
3105 printf ("%s ", SECTION_NAME (section
));
3112 free (program_headers
);
3119 get_32bit_section_headers (file
, num
)
3123 Elf32_External_Shdr
* shdrs
;
3124 Elf_Internal_Shdr
* internal
;
3127 shdrs
= ((Elf32_External_Shdr
*)
3128 get_data (NULL
, file
, elf_header
.e_shoff
,
3129 elf_header
.e_shentsize
* num
,
3130 _("section headers")));
3134 section_headers
= ((Elf_Internal_Shdr
*)
3135 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3137 if (section_headers
== NULL
)
3139 error (_("Out of memory\n"));
3143 for (i
= 0, internal
= section_headers
;
3147 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3148 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3149 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3150 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3151 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3152 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3153 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3154 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3155 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3156 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3165 get_64bit_section_headers (file
, num
)
3169 Elf64_External_Shdr
* shdrs
;
3170 Elf_Internal_Shdr
* internal
;
3173 shdrs
= ((Elf64_External_Shdr
*)
3174 get_data (NULL
, file
, elf_header
.e_shoff
,
3175 elf_header
.e_shentsize
* num
,
3176 _("section headers")));
3180 section_headers
= ((Elf_Internal_Shdr
*)
3181 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3183 if (section_headers
== NULL
)
3185 error (_("Out of memory\n"));
3189 for (i
= 0, internal
= section_headers
;
3193 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3194 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3195 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3196 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3197 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3198 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3199 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3200 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3201 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3202 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3210 static Elf_Internal_Sym
*
3211 get_32bit_elf_symbols (file
, section
)
3213 Elf_Internal_Shdr
*section
;
3215 unsigned long number
;
3216 Elf32_External_Sym
* esyms
;
3217 Elf_External_Sym_Shndx
*shndx
;
3218 Elf_Internal_Sym
* isyms
;
3219 Elf_Internal_Sym
* psym
;
3222 esyms
= ((Elf32_External_Sym
*)
3223 get_data (NULL
, file
, section
->sh_offset
,
3224 section
->sh_size
, _("symbols")));
3229 if (symtab_shndx_hdr
!= NULL
3230 && (symtab_shndx_hdr
->sh_link
3231 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3233 shndx
= ((Elf_External_Sym_Shndx
*)
3234 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3235 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3243 number
= section
->sh_size
/ section
->sh_entsize
;
3244 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3248 error (_("Out of memory\n"));
3255 for (j
= 0, psym
= isyms
;
3259 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3260 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3261 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3262 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3263 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3265 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3266 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3267 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3277 static Elf_Internal_Sym
*
3278 get_64bit_elf_symbols (file
, section
)
3280 Elf_Internal_Shdr
*section
;
3282 unsigned long number
;
3283 Elf64_External_Sym
* esyms
;
3284 Elf_External_Sym_Shndx
*shndx
;
3285 Elf_Internal_Sym
* isyms
;
3286 Elf_Internal_Sym
* psym
;
3289 esyms
= ((Elf64_External_Sym
*)
3290 get_data (NULL
, file
, section
->sh_offset
,
3291 section
->sh_size
, _("symbols")));
3296 if (symtab_shndx_hdr
!= NULL
3297 && (symtab_shndx_hdr
->sh_link
3298 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3300 shndx
= ((Elf_External_Sym_Shndx
*)
3301 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3302 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3310 number
= section
->sh_size
/ section
->sh_entsize
;
3311 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3315 error (_("Out of memory\n"));
3322 for (j
= 0, psym
= isyms
;
3326 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3327 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3328 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3329 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3330 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3332 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3333 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3334 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3345 get_elf_section_flags (sh_flags
)
3348 static char buff
[32];
3356 flag
= sh_flags
& - sh_flags
;
3361 case SHF_WRITE
: strcat (buff
, "W"); break;
3362 case SHF_ALLOC
: strcat (buff
, "A"); break;
3363 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3364 case SHF_MERGE
: strcat (buff
, "M"); break;
3365 case SHF_STRINGS
: strcat (buff
, "S"); break;
3366 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3367 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3368 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3369 case SHF_GROUP
: strcat (buff
, "G"); break;
3370 case SHF_TLS
: strcat (buff
, "T"); break;
3373 if (flag
& SHF_MASKOS
)
3376 sh_flags
&= ~ SHF_MASKOS
;
3378 else if (flag
& SHF_MASKPROC
)
3381 sh_flags
&= ~ SHF_MASKPROC
;
3393 process_section_headers (file
)
3396 Elf_Internal_Shdr
* section
;
3399 section_headers
= NULL
;
3401 if (elf_header
.e_shnum
== 0)
3404 printf (_("\nThere are no sections in this file.\n"));
3409 if (do_sections
&& !do_header
)
3410 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3411 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3415 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3418 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3421 /* Read in the string table, so that we have names to display. */
3422 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3424 if (section
->sh_size
!= 0)
3426 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3427 section
->sh_size
, _("string table"));
3429 string_table_length
= section
->sh_size
;
3432 /* Scan the sections for the dynamic symbol table
3433 and dynamic string table and debug sections. */
3434 dynamic_symbols
= NULL
;
3435 dynamic_strings
= NULL
;
3436 dynamic_syminfo
= NULL
;
3437 symtab_shndx_hdr
= NULL
;
3439 for (i
= 0, section
= section_headers
;
3440 i
< elf_header
.e_shnum
;
3443 char * name
= SECTION_NAME (section
);
3445 if (section
->sh_type
== SHT_DYNSYM
)
3447 if (dynamic_symbols
!= NULL
)
3449 error (_("File contains multiple dynamic symbol tables\n"));
3453 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3454 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3456 else if (section
->sh_type
== SHT_STRTAB
3457 && strcmp (name
, ".dynstr") == 0)
3459 if (dynamic_strings
!= NULL
)
3461 error (_("File contains multiple dynamic string tables\n"));
3465 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3467 _("dynamic strings"));
3469 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3471 if (symtab_shndx_hdr
!= NULL
)
3473 error (_("File contains multiple symtab shndx tables\n"));
3476 symtab_shndx_hdr
= section
;
3478 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3479 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3480 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3482 && strncmp (name
, ".debug_", 7) == 0)
3487 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3488 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3489 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3490 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3491 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3492 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3493 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3494 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3495 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3497 request_dump (i
, DEBUG_DUMP
);
3499 /* linkonce section to be combined with .debug_info at link time. */
3500 else if ((do_debugging
|| do_debug_info
)
3501 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3502 request_dump (i
, DEBUG_DUMP
);
3503 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3504 request_dump (i
, DEBUG_DUMP
);
3510 if (elf_header
.e_shnum
> 1)
3511 printf (_("\nSection Headers:\n"));
3513 printf (_("\nSection Header:\n"));
3517 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3520 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3523 printf (_(" [Nr] Name Type Address Offset\n"));
3524 printf (_(" Size EntSize Flags Link Info Align\n"));
3527 for (i
= 0, section
= section_headers
;
3528 i
< elf_header
.e_shnum
;
3531 printf (" [%2u] %-17.17s %-15.15s ",
3532 SECTION_HEADER_NUM (i
),
3533 SECTION_NAME (section
),
3534 get_section_type_name (section
->sh_type
));
3538 print_vma (section
->sh_addr
, LONG_HEX
);
3540 printf ( " %6.6lx %6.6lx %2.2lx",
3541 (unsigned long) section
->sh_offset
,
3542 (unsigned long) section
->sh_size
,
3543 (unsigned long) section
->sh_entsize
);
3545 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3547 printf ("%2ld %3lx %2ld\n",
3548 (unsigned long) section
->sh_link
,
3549 (unsigned long) section
->sh_info
,
3550 (unsigned long) section
->sh_addralign
);
3554 print_vma (section
->sh_addr
, LONG_HEX
);
3556 if ((long) section
->sh_offset
== section
->sh_offset
)
3557 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3561 print_vma (section
->sh_offset
, LONG_HEX
);
3564 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3565 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3569 print_vma (section
->sh_size
, LONG_HEX
);
3572 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3573 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3577 print_vma (section
->sh_entsize
, LONG_HEX
);
3580 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3582 printf ("%2ld %3lx ",
3583 (unsigned long) section
->sh_link
,
3584 (unsigned long) section
->sh_info
);
3586 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3587 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3590 print_vma (section
->sh_addralign
, DEC
);
3597 print_vma (section
->sh_addr
, LONG_HEX
);
3598 if ((long) section
->sh_offset
== section
->sh_offset
)
3599 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3603 print_vma (section
->sh_offset
, LONG_HEX
);
3606 print_vma (section
->sh_size
, LONG_HEX
);
3608 print_vma (section
->sh_entsize
, LONG_HEX
);
3610 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3612 printf (" %2ld %3lx %ld\n",
3613 (unsigned long) section
->sh_link
,
3614 (unsigned long) section
->sh_info
,
3615 (unsigned long) section
->sh_addralign
);
3619 printf (_("Key to Flags:\n\
3620 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3621 I (info), L (link order), G (group), x (unknown)\n\
3622 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3627 /* Process the reloc section. */
3629 process_relocs (file
)
3632 unsigned long rel_size
;
3633 unsigned long rel_offset
;
3639 if (do_using_dynamic
)
3641 int is_rela
= FALSE
;
3646 if (dynamic_info
[DT_REL
])
3648 rel_offset
= dynamic_info
[DT_REL
];
3649 rel_size
= dynamic_info
[DT_RELSZ
];
3652 else if (dynamic_info
[DT_RELA
])
3654 rel_offset
= dynamic_info
[DT_RELA
];
3655 rel_size
= dynamic_info
[DT_RELASZ
];
3658 else if (dynamic_info
[DT_JMPREL
])
3660 rel_offset
= dynamic_info
[DT_JMPREL
];
3661 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3663 switch (dynamic_info
[DT_PLTREL
])
3680 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3681 rel_offset
, rel_size
);
3683 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3684 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3687 printf (_("\nThere are no dynamic relocations in this file.\n"));
3691 Elf_Internal_Shdr
* section
;
3695 for (i
= 0, section
= section_headers
;
3696 i
< elf_header
.e_shnum
;
3699 if ( section
->sh_type
!= SHT_RELA
3700 && section
->sh_type
!= SHT_REL
)
3703 rel_offset
= section
->sh_offset
;
3704 rel_size
= section
->sh_size
;
3708 Elf_Internal_Shdr
* strsec
;
3709 Elf_Internal_Sym
* symtab
;
3712 unsigned long nsyms
;
3714 printf (_("\nRelocation section "));
3716 if (string_table
== NULL
)
3717 printf ("%d", section
->sh_name
);
3719 printf (_("'%s'"), SECTION_NAME (section
));
3721 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3722 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3727 if (section
->sh_link
)
3729 Elf_Internal_Shdr
* symsec
;
3731 symsec
= SECTION_HEADER (section
->sh_link
);
3732 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3733 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3738 strsec
= SECTION_HEADER (symsec
->sh_link
);
3740 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3744 is_rela
= section
->sh_type
== SHT_RELA
;
3746 dump_relocations (file
, rel_offset
, rel_size
,
3747 symtab
, nsyms
, strtab
, is_rela
);
3759 printf (_("\nThere are no relocations in this file.\n"));
3765 #include "unwind-ia64.h"
3767 /* An absolute address consists of a section and an offset. If the
3768 section is NULL, the offset itself is the address, otherwise, the
3769 address equals to LOAD_ADDRESS(section) + offset. */
3773 unsigned short section
;
3779 struct unw_table_entry
3781 struct absaddr start
;
3783 struct absaddr info
;
3785 *table
; /* Unwind table. */
3786 unsigned long table_len
; /* Length of unwind table. */
3787 unsigned char * info
; /* Unwind info. */
3788 unsigned long info_size
; /* Size of unwind info. */
3789 bfd_vma info_addr
; /* starting address of unwind info. */
3790 bfd_vma seg_base
; /* Starting address of segment. */
3791 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3792 unsigned long nsyms
; /* Number of symbols. */
3793 char * strtab
; /* The string table. */
3794 unsigned long strtab_size
; /* Size of string table. */
3797 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3798 struct absaddr
, const char **,
3800 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3801 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3802 Elf_Internal_Shdr
*));
3805 find_symbol_for_address (aux
, addr
, symname
, offset
)
3806 struct unw_aux_info
*aux
;
3807 struct absaddr addr
;
3808 const char **symname
;
3811 bfd_vma dist
= (bfd_vma
) 0x100000;
3812 Elf_Internal_Sym
*sym
, *best
= NULL
;
3815 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3817 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3818 && sym
->st_name
!= 0
3819 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3820 && addr
.offset
>= sym
->st_value
3821 && addr
.offset
- sym
->st_value
< dist
)
3824 dist
= addr
.offset
- sym
->st_value
;
3831 *symname
= (best
->st_name
>= aux
->strtab_size
3832 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3837 *offset
= addr
.offset
;
3841 dump_ia64_unwind (aux
)
3842 struct unw_aux_info
*aux
;
3845 struct unw_table_entry
* tp
;
3848 addr_size
= is_32bit_elf
? 4 : 8;
3850 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3854 const unsigned char * dp
;
3855 const unsigned char * head
;
3856 const char * procname
;
3858 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3860 fputs ("\n<", stdout
);
3864 fputs (procname
, stdout
);
3867 printf ("+%lx", (unsigned long) offset
);
3870 fputs (">: [", stdout
);
3871 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3872 fputc ('-', stdout
);
3873 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3874 printf ("], info at +0x%lx\n",
3875 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3877 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3878 stamp
= BYTE_GET8 ((unsigned char *) head
);
3880 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
3881 (unsigned) UNW_VER (stamp
),
3882 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3883 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3884 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3885 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3887 if (UNW_VER (stamp
) != 1)
3889 printf ("\tUnknown version.\n");
3894 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3895 dp
= unw_decode (dp
, in_body
, & in_body
);
3900 slurp_ia64_unwind_table (file
, aux
, sec
)
3902 struct unw_aux_info
*aux
;
3903 Elf_Internal_Shdr
*sec
;
3905 unsigned long size
, addr_size
, nrelas
, i
;
3906 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3907 struct unw_table_entry
*tep
;
3908 Elf_Internal_Shdr
*relsec
;
3909 Elf_Internal_Rela
*rela
, *rp
;
3910 unsigned char *table
, *tp
;
3911 Elf_Internal_Sym
*sym
;
3912 const char *relname
;
3915 addr_size
= is_32bit_elf
? 4 : 8;
3917 /* First, find the starting address of the segment that includes
3920 if (elf_header
.e_phnum
)
3922 prog_hdrs
= (Elf_Internal_Phdr
*)
3923 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3926 result
= get_32bit_program_headers (file
, prog_hdrs
);
3928 result
= get_64bit_program_headers (file
, prog_hdrs
);
3936 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3938 if (seg
->p_type
!= PT_LOAD
)
3941 if (sec
->sh_addr
>= seg
->p_vaddr
3942 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3944 aux
->seg_base
= seg
->p_vaddr
;
3952 /* Second, build the unwind table from the contents of the unwind section: */
3953 size
= sec
->sh_size
;
3954 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3955 size
, _("unwind table"));
3959 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3960 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3962 tep
->start
.section
= SHN_UNDEF
;
3963 tep
->end
.section
= SHN_UNDEF
;
3964 tep
->info
.section
= SHN_UNDEF
;
3967 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3968 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3969 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3973 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3974 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3975 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3977 tep
->start
.offset
+= aux
->seg_base
;
3978 tep
->end
.offset
+= aux
->seg_base
;
3979 tep
->info
.offset
+= aux
->seg_base
;
3983 /* Third, apply any relocations to the unwind table: */
3985 for (relsec
= section_headers
;
3986 relsec
< section_headers
+ elf_header
.e_shnum
;
3989 if (relsec
->sh_type
!= SHT_RELA
3990 || SECTION_HEADER (relsec
->sh_info
) != sec
)
3993 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3997 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4001 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4002 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4004 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4006 warn (_("Skipping unexpected symbol type %u\n"),
4007 ELF32_ST_TYPE (sym
->st_info
));
4013 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4014 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4016 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4018 warn (_("Skipping unexpected symbol type %u\n"),
4019 ELF64_ST_TYPE (sym
->st_info
));
4024 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4026 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4030 i
= rp
->r_offset
/ (3 * addr_size
);
4032 switch (rp
->r_offset
/addr_size
% 3)
4035 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4036 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4039 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4040 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4043 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4044 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4054 aux
->table_len
= size
/ (3 * addr_size
);
4059 process_unwind (file
)
4062 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4063 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4064 struct unw_aux_info aux
;
4069 if (elf_header
.e_machine
!= EM_IA_64
)
4071 printf (_("\nThere are no unwind sections in this file.\n"));
4075 memset (& aux
, 0, sizeof (aux
));
4077 addr_size
= is_32bit_elf
? 4 : 8;
4079 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4081 if (sec
->sh_type
== SHT_SYMTAB
)
4083 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4084 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4086 strsec
= SECTION_HEADER (sec
->sh_link
);
4087 aux
.strtab_size
= strsec
->sh_size
;
4088 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4089 aux
.strtab_size
, _("string table"));
4091 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4096 printf (_("\nThere are no unwind sections in this file.\n"));
4098 while (unwcount
-- > 0)
4103 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4104 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4105 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4112 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4114 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
4117 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4118 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4119 suffix
= SECTION_NAME (unwsec
) + len
;
4120 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4122 if (strncmp (SECTION_NAME (sec
),
4123 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4124 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4129 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4130 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4131 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4132 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4134 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4136 suffix
= SECTION_NAME (unwsec
) + len
;
4137 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4139 if (strncmp (SECTION_NAME (sec
),
4140 ELF_STRING_ia64_unwind_info
, len2
) == 0
4141 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4145 if (i
== elf_header
.e_shnum
)
4147 printf (_("\nCould not find unwind info section for "));
4149 if (string_table
== NULL
)
4150 printf ("%d", unwsec
->sh_name
);
4152 printf (_("'%s'"), SECTION_NAME (unwsec
));
4156 aux
.info_size
= sec
->sh_size
;
4157 aux
.info_addr
= sec
->sh_addr
;
4158 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4159 aux
.info_size
, _("unwind info"));
4161 printf (_("\nUnwind section "));
4163 if (string_table
== NULL
)
4164 printf ("%d", unwsec
->sh_name
);
4166 printf (_("'%s'"), SECTION_NAME (unwsec
));
4168 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4169 (unsigned long) unwsec
->sh_offset
,
4170 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4172 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4174 if (aux
.table_len
> 0)
4175 dump_ia64_unwind (& aux
);
4178 free ((char *) aux
.table
);
4180 free ((char *) aux
.info
);
4189 free ((char *) aux
.strtab
);
4195 dynamic_segment_mips_val (entry
)
4196 Elf_Internal_Dyn
* entry
;
4198 switch (entry
->d_tag
)
4201 if (entry
->d_un
.d_val
== 0)
4205 static const char * opts
[] =
4207 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4208 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4209 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4210 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4215 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
4216 if (entry
->d_un
.d_val
& (1 << cnt
))
4218 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4225 case DT_MIPS_IVERSION
:
4226 if (dynamic_strings
!= NULL
)
4227 printf ("Interface Version: %s\n",
4228 dynamic_strings
+ entry
->d_un
.d_val
);
4230 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4233 case DT_MIPS_TIME_STAMP
:
4238 time_t time
= entry
->d_un
.d_val
;
4239 tmp
= gmtime (&time
);
4240 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4241 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4242 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4243 printf ("Time Stamp: %s\n", timebuf
);
4247 case DT_MIPS_RLD_VERSION
:
4248 case DT_MIPS_LOCAL_GOTNO
:
4249 case DT_MIPS_CONFLICTNO
:
4250 case DT_MIPS_LIBLISTNO
:
4251 case DT_MIPS_SYMTABNO
:
4252 case DT_MIPS_UNREFEXTNO
:
4253 case DT_MIPS_HIPAGENO
:
4254 case DT_MIPS_DELTA_CLASS_NO
:
4255 case DT_MIPS_DELTA_INSTANCE_NO
:
4256 case DT_MIPS_DELTA_RELOC_NO
:
4257 case DT_MIPS_DELTA_SYM_NO
:
4258 case DT_MIPS_DELTA_CLASSSYM_NO
:
4259 case DT_MIPS_COMPACT_SIZE
:
4260 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4264 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4270 dynamic_segment_parisc_val (entry
)
4271 Elf_Internal_Dyn
* entry
;
4273 switch (entry
->d_tag
)
4275 case DT_HP_DLD_FLAGS
:
4284 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4285 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4286 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4287 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4288 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4289 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4290 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4291 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4292 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4293 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4294 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4298 bfd_vma val
= entry
->d_un
.d_val
;
4300 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4301 if (val
& flags
[cnt
].bit
)
4305 fputs (flags
[cnt
].str
, stdout
);
4307 val
^= flags
[cnt
].bit
;
4310 if (val
!= 0 || first
)
4314 print_vma (val
, HEX
);
4320 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4327 get_32bit_dynamic_segment (file
)
4330 Elf32_External_Dyn
* edyn
;
4331 Elf_Internal_Dyn
* entry
;
4334 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4335 dynamic_size
, _("dynamic segment"));
4339 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4340 how large this .dynamic is now. We can do this even before the byte
4341 swapping since the DT_NULL tag is recognizable. */
4343 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4346 dynamic_segment
= (Elf_Internal_Dyn
*)
4347 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4349 if (dynamic_segment
== NULL
)
4351 error (_("Out of memory\n"));
4356 for (i
= 0, entry
= dynamic_segment
;
4360 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4361 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4370 get_64bit_dynamic_segment (file
)
4373 Elf64_External_Dyn
* edyn
;
4374 Elf_Internal_Dyn
* entry
;
4377 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4378 dynamic_size
, _("dynamic segment"));
4382 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4383 how large this .dynamic is now. We can do this even before the byte
4384 swapping since the DT_NULL tag is recognizable. */
4386 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4389 dynamic_segment
= (Elf_Internal_Dyn
*)
4390 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4392 if (dynamic_segment
== NULL
)
4394 error (_("Out of memory\n"));
4399 for (i
= 0, entry
= dynamic_segment
;
4403 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4404 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4413 get_dynamic_flags (flags
)
4416 static char buff
[128];
4424 flag
= flags
& - flags
;
4432 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4433 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4434 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4435 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4436 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4437 default: strcpy (p
, "unknown"); break;
4440 p
= strchr (p
, '\0');
4445 /* Parse and display the contents of the dynamic segment. */
4447 process_dynamic_segment (file
)
4450 Elf_Internal_Dyn
* entry
;
4453 if (dynamic_size
== 0)
4456 printf (_("\nThere is no dynamic segment in this file.\n"));
4463 if (! get_32bit_dynamic_segment (file
))
4466 else if (! get_64bit_dynamic_segment (file
))
4469 /* Find the appropriate symbol table. */
4470 if (dynamic_symbols
== NULL
)
4472 for (i
= 0, entry
= dynamic_segment
;
4476 Elf_Internal_Shdr section
;
4478 if (entry
->d_tag
!= DT_SYMTAB
)
4481 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4483 /* Since we do not know how big the symbol table is,
4484 we default to reading in the entire file (!) and
4485 processing that. This is overkill, I know, but it
4487 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4489 if (fseek (file
, 0, SEEK_END
))
4490 error (_("Unable to seek to end of file!"));
4492 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4494 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4496 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4498 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4499 if (num_dynamic_syms
< 1)
4501 error (_("Unable to determine the number of symbols to load\n"));
4505 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4509 /* Similarly find a string table. */
4510 if (dynamic_strings
== NULL
)
4512 for (i
= 0, entry
= dynamic_segment
;
4516 unsigned long offset
;
4519 if (entry
->d_tag
!= DT_STRTAB
)
4522 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4524 /* Since we do not know how big the string table is,
4525 we default to reading in the entire file (!) and
4526 processing that. This is overkill, I know, but it
4529 offset
= entry
->d_un
.d_val
- loadaddr
;
4530 if (fseek (file
, 0, SEEK_END
))
4531 error (_("Unable to seek to end of file\n"));
4532 str_tab_len
= ftell (file
) - offset
;
4534 if (str_tab_len
< 1)
4537 (_("Unable to determine the length of the dynamic string table\n"));
4541 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4542 _("dynamic string table"));
4547 /* And find the syminfo section if available. */
4548 if (dynamic_syminfo
== NULL
)
4550 unsigned int syminsz
= 0;
4552 for (i
= 0, entry
= dynamic_segment
;
4556 if (entry
->d_tag
== DT_SYMINENT
)
4558 /* Note: these braces are necessary to avoid a syntax
4559 error from the SunOS4 C compiler. */
4560 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4562 else if (entry
->d_tag
== DT_SYMINSZ
)
4563 syminsz
= entry
->d_un
.d_val
;
4564 else if (entry
->d_tag
== DT_SYMINFO
)
4565 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4568 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4570 Elf_External_Syminfo
* extsyminfo
;
4571 Elf_Internal_Syminfo
* syminfo
;
4573 /* There is a syminfo section. Read the data. */
4574 extsyminfo
= ((Elf_External_Syminfo
*)
4575 get_data (NULL
, file
, dynamic_syminfo_offset
,
4576 syminsz
, _("symbol information")));
4580 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4581 if (dynamic_syminfo
== NULL
)
4583 error (_("Out of memory\n"));
4587 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4588 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4591 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4592 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4599 if (do_dynamic
&& dynamic_addr
)
4600 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4601 dynamic_addr
, (long) dynamic_size
);
4603 printf (_(" Tag Type Name/Value\n"));
4605 for (i
= 0, entry
= dynamic_segment
;
4614 print_vma (entry
->d_tag
, FULL_HEX
);
4615 dtype
= get_dynamic_type (entry
->d_tag
);
4616 printf (" (%s)%*s", dtype
,
4617 ((is_32bit_elf
? 27 : 19)
4618 - (int) strlen (dtype
)),
4622 switch (entry
->d_tag
)
4626 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4636 switch (entry
->d_tag
)
4639 printf (_("Auxiliary library"));
4643 printf (_("Filter library"));
4647 printf (_("Configuration file"));
4651 printf (_("Dependency audit library"));
4655 printf (_("Audit library"));
4659 if (dynamic_strings
)
4660 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4664 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4673 printf (_("Flags:"));
4675 if (entry
->d_un
.d_val
== 0)
4676 printf (_(" None\n"));
4679 unsigned long int val
= entry
->d_un
.d_val
;
4681 if (val
& DTF_1_PARINIT
)
4683 printf (" PARINIT");
4684 val
^= DTF_1_PARINIT
;
4686 if (val
& DTF_1_CONFEXP
)
4688 printf (" CONFEXP");
4689 val
^= DTF_1_CONFEXP
;
4692 printf (" %lx", val
);
4701 printf (_("Flags:"));
4703 if (entry
->d_un
.d_val
== 0)
4704 printf (_(" None\n"));
4707 unsigned long int val
= entry
->d_un
.d_val
;
4709 if (val
& DF_P1_LAZYLOAD
)
4711 printf (" LAZYLOAD");
4712 val
^= DF_P1_LAZYLOAD
;
4714 if (val
& DF_P1_GROUPPERM
)
4716 printf (" GROUPPERM");
4717 val
^= DF_P1_GROUPPERM
;
4720 printf (" %lx", val
);
4729 printf (_("Flags:"));
4730 if (entry
->d_un
.d_val
== 0)
4731 printf (_(" None\n"));
4734 unsigned long int val
= entry
->d_un
.d_val
;
4741 if (val
& DF_1_GLOBAL
)
4746 if (val
& DF_1_GROUP
)
4751 if (val
& DF_1_NODELETE
)
4753 printf (" NODELETE");
4754 val
^= DF_1_NODELETE
;
4756 if (val
& DF_1_LOADFLTR
)
4758 printf (" LOADFLTR");
4759 val
^= DF_1_LOADFLTR
;
4761 if (val
& DF_1_INITFIRST
)
4763 printf (" INITFIRST");
4764 val
^= DF_1_INITFIRST
;
4766 if (val
& DF_1_NOOPEN
)
4771 if (val
& DF_1_ORIGIN
)
4776 if (val
& DF_1_DIRECT
)
4781 if (val
& DF_1_TRANS
)
4786 if (val
& DF_1_INTERPOSE
)
4788 printf (" INTERPOSE");
4789 val
^= DF_1_INTERPOSE
;
4791 if (val
& DF_1_NODEFLIB
)
4793 printf (" NODEFLIB");
4794 val
^= DF_1_NODEFLIB
;
4796 if (val
& DF_1_NODUMP
)
4801 if (val
& DF_1_CONLFAT
)
4803 printf (" CONLFAT");
4804 val
^= DF_1_CONLFAT
;
4807 printf (" %lx", val
);
4815 puts (get_dynamic_type (entry
->d_un
.d_val
));
4835 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4841 if (dynamic_strings
== NULL
)
4844 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4848 switch (entry
->d_tag
)
4851 printf (_("Shared library: [%s]"), name
);
4853 if (strcmp (name
, program_interpreter
) == 0)
4854 printf (_(" program interpreter"));
4858 printf (_("Library soname: [%s]"), name
);
4862 printf (_("Library rpath: [%s]"), name
);
4866 printf (_("Library runpath: [%s]"), name
);
4870 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4875 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4891 case DT_INIT_ARRAYSZ
:
4892 case DT_FINI_ARRAYSZ
:
4893 case DT_GNU_CONFLICTSZ
:
4894 case DT_GNU_LIBLISTSZ
:
4897 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4898 printf (" (bytes)\n");
4908 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4921 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4925 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4929 printf (_("Not needed object: [%s]\n"), name
);
4934 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4940 /* The value of this entry is ignored. */
4945 case DT_GNU_PRELINKED
:
4949 time_t time
= entry
->d_un
.d_val
;
4951 tmp
= gmtime (&time
);
4952 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
4953 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4954 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4960 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4961 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4966 switch (elf_header
.e_machine
)
4969 case EM_MIPS_RS3_LE
:
4970 dynamic_segment_mips_val (entry
);
4973 dynamic_segment_parisc_val (entry
);
4976 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4988 get_ver_flags (flags
)
4991 static char buff
[32];
4998 if (flags
& VER_FLG_BASE
)
4999 strcat (buff
, "BASE ");
5001 if (flags
& VER_FLG_WEAK
)
5003 if (flags
& VER_FLG_BASE
)
5004 strcat (buff
, "| ");
5006 strcat (buff
, "WEAK ");
5009 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5010 strcat (buff
, "| <unknown>");
5015 /* Display the contents of the version sections. */
5017 process_version_sections (file
)
5020 Elf_Internal_Shdr
* section
;
5027 for (i
= 0, section
= section_headers
;
5028 i
< elf_header
.e_shnum
;
5031 switch (section
->sh_type
)
5033 case SHT_GNU_verdef
:
5035 Elf_External_Verdef
* edefs
;
5042 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5043 SECTION_NAME (section
), section
->sh_info
);
5045 printf (_(" Addr: 0x"));
5046 printf_vma (section
->sh_addr
);
5047 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5048 (unsigned long) section
->sh_offset
, section
->sh_link
,
5049 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5051 edefs
= ((Elf_External_Verdef
*)
5052 get_data (NULL
, file
, section
->sh_offset
,
5054 _("version definition section")));
5058 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
5061 Elf_External_Verdef
* edef
;
5062 Elf_Internal_Verdef ent
;
5063 Elf_External_Verdaux
* eaux
;
5064 Elf_Internal_Verdaux aux
;
5068 vstart
= ((char *) edefs
) + idx
;
5070 edef
= (Elf_External_Verdef
*) vstart
;
5072 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5073 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5074 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5075 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5076 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5077 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5078 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5080 printf (_(" %#06x: Rev: %d Flags: %s"),
5081 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5083 printf (_(" Index: %d Cnt: %d "),
5084 ent
.vd_ndx
, ent
.vd_cnt
);
5086 vstart
+= ent
.vd_aux
;
5088 eaux
= (Elf_External_Verdaux
*) vstart
;
5090 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5091 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5093 if (dynamic_strings
)
5094 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5096 printf (_("Name index: %ld\n"), aux
.vda_name
);
5098 isum
= idx
+ ent
.vd_aux
;
5100 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5102 isum
+= aux
.vda_next
;
5103 vstart
+= aux
.vda_next
;
5105 eaux
= (Elf_External_Verdaux
*) vstart
;
5107 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5108 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5110 if (dynamic_strings
)
5111 printf (_(" %#06x: Parent %d: %s\n"),
5112 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5114 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5115 isum
, j
, aux
.vda_name
);
5125 case SHT_GNU_verneed
:
5127 Elf_External_Verneed
* eneed
;
5133 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5134 SECTION_NAME (section
), section
->sh_info
);
5136 printf (_(" Addr: 0x"));
5137 printf_vma (section
->sh_addr
);
5138 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5139 (unsigned long) section
->sh_offset
, section
->sh_link
,
5140 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5142 eneed
= ((Elf_External_Verneed
*)
5143 get_data (NULL
, file
, section
->sh_offset
,
5144 section
->sh_size
, _("version need section")));
5148 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5150 Elf_External_Verneed
* entry
;
5151 Elf_Internal_Verneed ent
;
5156 vstart
= ((char *) eneed
) + idx
;
5158 entry
= (Elf_External_Verneed
*) vstart
;
5160 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5161 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5162 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5163 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5164 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5166 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5168 if (dynamic_strings
)
5169 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5171 printf (_(" File: %lx"), ent
.vn_file
);
5173 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5175 vstart
+= ent
.vn_aux
;
5177 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5179 Elf_External_Vernaux
* eaux
;
5180 Elf_Internal_Vernaux aux
;
5182 eaux
= (Elf_External_Vernaux
*) vstart
;
5184 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5185 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5186 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5187 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5188 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5190 if (dynamic_strings
)
5191 printf (_(" %#06x: Name: %s"),
5192 isum
, dynamic_strings
+ aux
.vna_name
);
5194 printf (_(" %#06x: Name index: %lx"),
5195 isum
, aux
.vna_name
);
5197 printf (_(" Flags: %s Version: %d\n"),
5198 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5200 isum
+= aux
.vna_next
;
5201 vstart
+= aux
.vna_next
;
5211 case SHT_GNU_versym
:
5213 Elf_Internal_Shdr
* link_section
;
5216 unsigned char * edata
;
5217 unsigned short * data
;
5219 Elf_Internal_Sym
* symbols
;
5220 Elf_Internal_Shdr
* string_sec
;
5222 link_section
= SECTION_HEADER (section
->sh_link
);
5223 total
= section
->sh_size
/ section
->sh_entsize
;
5227 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5229 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5231 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5232 string_sec
->sh_size
,
5233 _("version string table"));
5237 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5238 SECTION_NAME (section
), total
);
5240 printf (_(" Addr: "));
5241 printf_vma (section
->sh_addr
);
5242 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5243 (unsigned long) section
->sh_offset
, section
->sh_link
,
5244 SECTION_NAME (link_section
));
5248 get_data (NULL
, file
,
5249 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5250 total
* sizeof (short), _("version symbol data")));
5257 data
= (unsigned short *) malloc (total
* sizeof (short));
5259 for (cnt
= total
; cnt
--;)
5260 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5265 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5268 int check_def
, check_need
;
5271 printf (" %03x:", cnt
);
5273 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5274 switch (data
[cnt
+ j
])
5277 fputs (_(" 0 (*local*) "), stdout
);
5281 fputs (_(" 1 (*global*) "), stdout
);
5285 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5286 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5290 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5293 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5300 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5302 Elf_Internal_Verneed ivn
;
5303 unsigned long offset
;
5305 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5310 Elf_Internal_Vernaux ivna
;
5311 Elf_External_Verneed evn
;
5312 Elf_External_Vernaux evna
;
5313 unsigned long a_off
;
5315 get_data (&evn
, file
, offset
, sizeof (evn
),
5318 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5319 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5321 a_off
= offset
+ ivn
.vn_aux
;
5325 get_data (&evna
, file
, a_off
, sizeof (evna
),
5326 _("version need aux (2)"));
5328 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5329 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5331 a_off
+= ivna
.vna_next
;
5333 while (ivna
.vna_other
!= data
[cnt
+ j
]
5334 && ivna
.vna_next
!= 0);
5336 if (ivna
.vna_other
== data
[cnt
+ j
])
5338 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5340 name
= strtab
+ ivna
.vna_name
;
5341 nn
+= printf ("(%s%-*s",
5343 12 - (int) strlen (name
),
5349 offset
+= ivn
.vn_next
;
5351 while (ivn
.vn_next
);
5354 if (check_def
&& data
[cnt
+ j
] != 0x8001
5355 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5357 Elf_Internal_Verdef ivd
;
5358 Elf_External_Verdef evd
;
5359 unsigned long offset
;
5361 offset
= version_info
5362 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
5366 get_data (&evd
, file
, offset
, sizeof (evd
),
5369 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5370 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5372 offset
+= ivd
.vd_next
;
5374 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5375 && ivd
.vd_next
!= 0);
5377 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5379 Elf_External_Verdaux evda
;
5380 Elf_Internal_Verdaux ivda
;
5382 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5384 get_data (&evda
, file
,
5385 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5386 sizeof (evda
), _("version def aux"));
5388 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5390 name
= strtab
+ ivda
.vda_name
;
5391 nn
+= printf ("(%s%-*s",
5393 12 - (int) strlen (name
),
5399 printf ("%*c", 18 - nn
, ' ');
5417 printf (_("\nNo version information found in this file.\n"));
5423 get_symbol_binding (binding
)
5424 unsigned int binding
;
5426 static char buff
[32];
5430 case STB_LOCAL
: return "LOCAL";
5431 case STB_GLOBAL
: return "GLOBAL";
5432 case STB_WEAK
: return "WEAK";
5434 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5435 sprintf (buff
, _("<processor specific>: %d"), binding
);
5436 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5437 sprintf (buff
, _("<OS specific>: %d"), binding
);
5439 sprintf (buff
, _("<unknown>: %d"), binding
);
5445 get_symbol_type (type
)
5448 static char buff
[32];
5452 case STT_NOTYPE
: return "NOTYPE";
5453 case STT_OBJECT
: return "OBJECT";
5454 case STT_FUNC
: return "FUNC";
5455 case STT_SECTION
: return "SECTION";
5456 case STT_FILE
: return "FILE";
5457 case STT_COMMON
: return "COMMON";
5458 case STT_TLS
: return "TLS";
5460 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5462 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5463 return "THUMB_FUNC";
5465 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5468 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5469 return "PARISC_MILLI";
5471 sprintf (buff
, _("<processor specific>: %d"), type
);
5473 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5475 if (elf_header
.e_machine
== EM_PARISC
)
5477 if (type
== STT_HP_OPAQUE
)
5479 if (type
== STT_HP_STUB
)
5483 sprintf (buff
, _("<OS specific>: %d"), type
);
5486 sprintf (buff
, _("<unknown>: %d"), type
);
5492 get_symbol_visibility (visibility
)
5493 unsigned int visibility
;
5497 case STV_DEFAULT
: return "DEFAULT";
5498 case STV_INTERNAL
: return "INTERNAL";
5499 case STV_HIDDEN
: return "HIDDEN";
5500 case STV_PROTECTED
: return "PROTECTED";
5506 get_symbol_index_type (type
)
5509 static char buff
[32];
5513 case SHN_UNDEF
: return "UND";
5514 case SHN_ABS
: return "ABS";
5515 case SHN_COMMON
: return "COM";
5517 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5518 sprintf (buff
, "PRC[0x%04x]", type
);
5519 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5520 sprintf (buff
, "OS [0x%04x]", type
);
5521 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5522 sprintf (buff
, "RSV[0x%04x]", type
);
5524 sprintf (buff
, "%3d", type
);
5532 get_dynamic_data (file
, number
)
5534 unsigned int number
;
5536 unsigned char * e_data
;
5539 e_data
= (unsigned char *) malloc (number
* 4);
5543 error (_("Out of memory\n"));
5547 if (fread (e_data
, 4, number
, file
) != number
)
5549 error (_("Unable to read in dynamic data\n"));
5553 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5557 error (_("Out of memory\n"));
5563 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5570 /* Dump the symbol table. */
5572 process_symbol_table (file
)
5575 Elf_Internal_Shdr
* section
;
5576 unsigned char nb
[4];
5577 unsigned char nc
[4];
5580 int * buckets
= NULL
;
5581 int * chains
= NULL
;
5583 if (! do_syms
&& !do_histogram
)
5586 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5589 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5591 error (_("Unable to seek to start of dynamic information"));
5595 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5597 error (_("Failed to read in number of buckets\n"));
5601 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5603 error (_("Failed to read in number of chains\n"));
5607 nbuckets
= byte_get (nb
, 4);
5608 nchains
= byte_get (nc
, 4);
5610 buckets
= get_dynamic_data (file
, nbuckets
);
5611 chains
= get_dynamic_data (file
, nchains
);
5613 if (buckets
== NULL
|| chains
== NULL
)
5618 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5623 printf (_("\nSymbol table for image:\n"));
5625 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5627 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5629 for (hn
= 0; hn
< nbuckets
; hn
++)
5634 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5636 Elf_Internal_Sym
* psym
;
5638 psym
= dynamic_symbols
+ si
;
5640 printf (" %3d %3d: ", si
, hn
);
5641 print_vma (psym
->st_value
, LONG_HEX
);
5643 print_vma (psym
->st_size
, DEC_5
);
5645 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5646 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5647 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5648 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5649 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5654 else if (do_syms
&& !do_using_dynamic
)
5658 for (i
= 0, section
= section_headers
;
5659 i
< elf_header
.e_shnum
;
5664 Elf_Internal_Sym
* symtab
;
5665 Elf_Internal_Sym
* psym
;
5668 if ( section
->sh_type
!= SHT_SYMTAB
5669 && section
->sh_type
!= SHT_DYNSYM
)
5672 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5673 SECTION_NAME (section
),
5674 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5676 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5678 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5680 symtab
= GET_ELF_SYMBOLS (file
, section
);
5684 if (section
->sh_link
== elf_header
.e_shstrndx
)
5685 strtab
= string_table
;
5688 Elf_Internal_Shdr
* string_sec
;
5690 string_sec
= SECTION_HEADER (section
->sh_link
);
5692 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5693 string_sec
->sh_size
,
5697 for (si
= 0, psym
= symtab
;
5698 si
< section
->sh_size
/ section
->sh_entsize
;
5701 printf ("%6d: ", si
);
5702 print_vma (psym
->st_value
, LONG_HEX
);
5704 print_vma (psym
->st_size
, DEC_5
);
5705 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5706 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5707 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5708 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5709 print_symbol (25, strtab
+ psym
->st_name
);
5711 if (section
->sh_type
== SHT_DYNSYM
&&
5712 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5714 unsigned char data
[2];
5715 unsigned short vers_data
;
5716 unsigned long offset
;
5720 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5723 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5724 sizeof (data
), _("version data"));
5726 vers_data
= byte_get (data
, 2);
5728 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5731 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5733 if ((vers_data
& 0x8000) || vers_data
> 1)
5735 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5736 && (is_nobits
|| ! check_def
))
5738 Elf_External_Verneed evn
;
5739 Elf_Internal_Verneed ivn
;
5740 Elf_Internal_Vernaux ivna
;
5742 /* We must test both. */
5743 offset
= version_info
5744 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5748 unsigned long vna_off
;
5750 get_data (&evn
, file
, offset
, sizeof (evn
),
5753 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5754 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5756 vna_off
= offset
+ ivn
.vn_aux
;
5760 Elf_External_Vernaux evna
;
5762 get_data (&evna
, file
, vna_off
,
5764 _("version need aux (3)"));
5766 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5767 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5768 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5770 vna_off
+= ivna
.vna_next
;
5772 while (ivna
.vna_other
!= vers_data
5773 && ivna
.vna_next
!= 0);
5775 if (ivna
.vna_other
== vers_data
)
5778 offset
+= ivn
.vn_next
;
5780 while (ivn
.vn_next
!= 0);
5782 if (ivna
.vna_other
== vers_data
)
5785 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5788 else if (! is_nobits
)
5789 error (_("bad dynamic symbol"));
5796 if (vers_data
!= 0x8001
5797 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5799 Elf_Internal_Verdef ivd
;
5800 Elf_Internal_Verdaux ivda
;
5801 Elf_External_Verdaux evda
;
5802 unsigned long offset
;
5805 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5810 Elf_External_Verdef evd
;
5812 get_data (&evd
, file
, offset
, sizeof (evd
),
5815 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5816 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5817 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5819 offset
+= ivd
.vd_next
;
5821 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5822 && ivd
.vd_next
!= 0);
5824 offset
-= ivd
.vd_next
;
5825 offset
+= ivd
.vd_aux
;
5827 get_data (&evda
, file
, offset
, sizeof (evda
),
5828 _("version def aux"));
5830 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5832 if (psym
->st_name
!= ivda
.vda_name
)
5833 printf ((vers_data
& 0x8000)
5835 strtab
+ ivda
.vda_name
);
5845 if (strtab
!= string_table
)
5851 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5853 if (do_histogram
&& buckets
!= NULL
)
5860 int nzero_counts
= 0;
5863 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5865 printf (_(" Length Number %% of total Coverage\n"));
5867 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5868 if (lengths
== NULL
)
5870 error (_("Out of memory"));
5873 for (hn
= 0; hn
< nbuckets
; ++hn
)
5878 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5881 if (maxlength
< ++lengths
[hn
])
5886 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5889 error (_("Out of memory"));
5893 for (hn
= 0; hn
< nbuckets
; ++hn
)
5894 ++ counts
[lengths
[hn
]];
5898 printf (" 0 %-10d (%5.1f%%)\n",
5899 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5900 for (si
= 1; si
<= maxlength
; ++si
)
5902 nzero_counts
+= counts
[si
] * si
;
5903 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5904 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5905 (nzero_counts
* 100.0) / nsyms
);
5913 if (buckets
!= NULL
)
5923 process_syminfo (file
)
5924 FILE * file ATTRIBUTE_UNUSED
;
5928 if (dynamic_syminfo
== NULL
5930 /* No syminfo, this is ok. */
5933 /* There better should be a dynamic symbol section. */
5934 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5938 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5939 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5941 printf (_(" Num: Name BoundTo Flags\n"));
5942 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5944 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5946 printf ("%4d: ", i
);
5947 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5950 switch (dynamic_syminfo
[i
].si_boundto
)
5952 case SYMINFO_BT_SELF
:
5953 fputs ("SELF ", stdout
);
5955 case SYMINFO_BT_PARENT
:
5956 fputs ("PARENT ", stdout
);
5959 if (dynamic_syminfo
[i
].si_boundto
> 0
5960 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5962 print_symbol (10, dynamic_strings
5964 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5968 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5972 if (flags
& SYMINFO_FLG_DIRECT
)
5974 if (flags
& SYMINFO_FLG_PASSTHRU
)
5975 printf (" PASSTHRU");
5976 if (flags
& SYMINFO_FLG_COPY
)
5978 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5979 printf (" LAZYLOAD");
5987 #ifdef SUPPORT_DISASSEMBLY
5989 disassemble_section (section
, file
)
5990 Elf_Internal_Shdr
* section
;
5993 printf (_("\nAssembly dump of section %s\n"),
5994 SECTION_NAME (section
));
5996 /* XXX -- to be done --- XXX */
6003 dump_section (section
, file
)
6004 Elf_Internal_Shdr
* section
;
6007 bfd_size_type bytes
;
6009 unsigned char * data
;
6010 unsigned char * start
;
6012 bytes
= section
->sh_size
;
6016 printf (_("\nSection '%s' has no data to dump.\n"),
6017 SECTION_NAME (section
));
6021 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6023 addr
= section
->sh_addr
;
6025 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
6038 lbytes
= (bytes
> 16 ? 16 : bytes
);
6040 printf (" 0x%8.8lx ", (unsigned long) addr
);
6042 switch (elf_header
.e_ident
[EI_DATA
])
6046 for (j
= 15; j
>= 0; j
--)
6049 printf ("%2.2x", data
[j
]);
6059 for (j
= 0; j
< 16; j
++)
6062 printf ("%2.2x", data
[j
]);
6072 for (j
= 0; j
< lbytes
; j
++)
6075 if (k
>= ' ' && k
< 0x80)
6094 static unsigned long int
6095 read_leb128 (data
, length_return
, sign
)
6096 unsigned char * data
;
6097 int * length_return
;
6100 unsigned long int result
= 0;
6101 unsigned int num_read
= 0;
6110 result
|= (byte
& 0x7f) << shift
;
6115 while (byte
& 0x80);
6117 if (length_return
!= NULL
)
6118 * length_return
= num_read
;
6120 if (sign
&& (shift
< 32) && (byte
& 0x40))
6121 result
|= -1 << shift
;
6126 typedef struct State_Machine_Registers
6128 unsigned long address
;
6131 unsigned int column
;
6135 /* This variable hold the number of the last entry seen
6136 in the File Table. */
6137 unsigned int last_file_entry
;
6140 static SMR state_machine_regs
;
6143 reset_state_machine (is_stmt
)
6146 state_machine_regs
.address
= 0;
6147 state_machine_regs
.file
= 1;
6148 state_machine_regs
.line
= 1;
6149 state_machine_regs
.column
= 0;
6150 state_machine_regs
.is_stmt
= is_stmt
;
6151 state_machine_regs
.basic_block
= 0;
6152 state_machine_regs
.end_sequence
= 0;
6153 state_machine_regs
.last_file_entry
= 0;
6156 /* Handled an extend line op. Returns true if this is the end
6159 process_extended_line_op (data
, is_stmt
, pointer_size
)
6160 unsigned char * data
;
6164 unsigned char op_code
;
6167 unsigned char * name
;
6170 len
= read_leb128 (data
, & bytes_read
, 0);
6175 warn (_("badly formed extended line op encountered!\n"));
6180 op_code
= * data
++;
6182 printf (_(" Extended opcode %d: "), op_code
);
6186 case DW_LNE_end_sequence
:
6187 printf (_("End of Sequence\n\n"));
6188 reset_state_machine (is_stmt
);
6191 case DW_LNE_set_address
:
6192 adr
= byte_get (data
, pointer_size
);
6193 printf (_("set Address to 0x%lx\n"), adr
);
6194 state_machine_regs
.address
= adr
;
6197 case DW_LNE_define_file
:
6198 printf (_(" define new File Table entry\n"));
6199 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6201 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6203 data
+= strlen ((char *) data
) + 1;
6204 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6206 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6208 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6209 printf (_("%s\n\n"), name
);
6213 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6220 /* Size of pointers in the .debug_line section. This information is not
6221 really present in that section. It's obtained before dumping the debug
6222 sections by doing some pre-scan of the .debug_info section. */
6223 static int debug_line_pointer_size
= 4;
6226 display_debug_lines (section
, start
, file
)
6227 Elf_Internal_Shdr
* section
;
6228 unsigned char * start
;
6229 FILE * file ATTRIBUTE_UNUSED
;
6231 DWARF2_External_LineInfo
* external
;
6232 DWARF2_Internal_LineInfo info
;
6233 unsigned char * standard_opcodes
;
6234 unsigned char * data
= start
;
6235 unsigned char * end
= start
+ section
->sh_size
;
6236 unsigned char * end_of_sequence
;
6239 printf (_("\nDump of debug contents of section %s:\n\n"),
6240 SECTION_NAME (section
));
6244 external
= (DWARF2_External_LineInfo
*) data
;
6246 /* Check the length of the block. */
6247 info
.li_length
= BYTE_GET (external
->li_length
);
6249 if (info
.li_length
== 0xffffffff)
6251 warn (_("64-bit DWARF line info is not supported yet.\n"));
6255 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6258 (_("The line info appears to be corrupt - the section is too small\n"));
6262 /* Check its version number. */
6263 info
.li_version
= BYTE_GET (external
->li_version
);
6264 if (info
.li_version
!= 2)
6266 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6270 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6271 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6272 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6273 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6274 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6275 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6277 /* Sign extend the line base field. */
6278 info
.li_line_base
<<= 24;
6279 info
.li_line_base
>>= 24;
6281 printf (_(" Length: %ld\n"), info
.li_length
);
6282 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6283 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6284 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6285 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6286 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6287 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6288 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6290 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6292 reset_state_machine (info
.li_default_is_stmt
);
6294 /* Display the contents of the Opcodes table. */
6295 standard_opcodes
= data
+ sizeof (* external
);
6297 printf (_("\n Opcodes:\n"));
6299 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6300 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6302 /* Display the contents of the Directory table. */
6303 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6306 printf (_("\n The Directory Table is empty.\n"));
6309 printf (_("\n The Directory Table:\n"));
6313 printf (_(" %s\n"), data
);
6315 data
+= strlen ((char *) data
) + 1;
6319 /* Skip the NUL at the end of the table. */
6322 /* Display the contents of the File Name table. */
6324 printf (_("\n The File Name Table is empty.\n"));
6327 printf (_("\n The File Name Table:\n"));
6328 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6332 unsigned char * name
;
6335 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6338 data
+= strlen ((char *) data
) + 1;
6340 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6342 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6344 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6346 printf (_("%s\n"), name
);
6350 /* Skip the NUL at the end of the table. */
6353 /* Now display the statements. */
6354 printf (_("\n Line Number Statements:\n"));
6357 while (data
< end_of_sequence
)
6359 unsigned char op_code
;
6363 op_code
= * data
++;
6365 if (op_code
>= info
.li_opcode_base
)
6367 op_code
-= info
.li_opcode_base
;
6368 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6369 state_machine_regs
.address
+= adv
;
6370 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6371 op_code
, adv
, state_machine_regs
.address
);
6372 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6373 state_machine_regs
.line
+= adv
;
6374 printf (_(" and Line by %d to %d\n"),
6375 adv
, state_machine_regs
.line
);
6377 else switch (op_code
)
6379 case DW_LNS_extended_op
:
6380 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6381 debug_line_pointer_size
);
6385 printf (_(" Copy\n"));
6388 case DW_LNS_advance_pc
:
6389 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6391 state_machine_regs
.address
+= adv
;
6392 printf (_(" Advance PC by %d to %lx\n"), adv
,
6393 state_machine_regs
.address
);
6396 case DW_LNS_advance_line
:
6397 adv
= read_leb128 (data
, & bytes_read
, 1);
6399 state_machine_regs
.line
+= adv
;
6400 printf (_(" Advance Line by %d to %d\n"), adv
,
6401 state_machine_regs
.line
);
6404 case DW_LNS_set_file
:
6405 adv
= read_leb128 (data
, & bytes_read
, 0);
6407 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6409 state_machine_regs
.file
= adv
;
6412 case DW_LNS_set_column
:
6413 adv
= read_leb128 (data
, & bytes_read
, 0);
6415 printf (_(" Set column to %d\n"), adv
);
6416 state_machine_regs
.column
= adv
;
6419 case DW_LNS_negate_stmt
:
6420 adv
= state_machine_regs
.is_stmt
;
6422 printf (_(" Set is_stmt to %d\n"), adv
);
6423 state_machine_regs
.is_stmt
= adv
;
6426 case DW_LNS_set_basic_block
:
6427 printf (_(" Set basic block\n"));
6428 state_machine_regs
.basic_block
= 1;
6431 case DW_LNS_const_add_pc
:
6432 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6433 * info
.li_min_insn_length
);
6434 state_machine_regs
.address
+= adv
;
6435 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6436 state_machine_regs
.address
);
6439 case DW_LNS_fixed_advance_pc
:
6440 adv
= byte_get (data
, 2);
6442 state_machine_regs
.address
+= adv
;
6443 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6444 adv
, state_machine_regs
.address
);
6447 case DW_LNS_set_prologue_end
:
6448 printf (_(" Set prologue_end to true\n"));
6451 case DW_LNS_set_epilogue_begin
:
6452 printf (_(" Set epilogue_begin to true\n"));
6455 case DW_LNS_set_isa
:
6456 adv
= read_leb128 (data
, & bytes_read
, 0);
6458 printf (_(" Set ISA to %d\n"), adv
);
6462 printf (_(" Unknown opcode %d with operands: "), op_code
);
6465 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6467 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6468 i
== 1 ? "" : ", ");
6483 display_debug_pubnames (section
, start
, file
)
6484 Elf_Internal_Shdr
* section
;
6485 unsigned char * start
;
6486 FILE * file ATTRIBUTE_UNUSED
;
6488 DWARF2_External_PubNames
* external
;
6489 DWARF2_Internal_PubNames pubnames
;
6490 unsigned char * end
;
6492 end
= start
+ section
->sh_size
;
6494 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6498 unsigned char * data
;
6499 unsigned long offset
;
6501 external
= (DWARF2_External_PubNames
*) start
;
6503 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6504 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6505 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6506 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6508 data
= start
+ sizeof (* external
);
6509 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6511 if (pubnames
.pn_length
== 0xffffffff)
6513 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6517 if (pubnames
.pn_version
!= 2)
6519 static int warned
= 0;
6523 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6530 printf (_(" Length: %ld\n"),
6531 pubnames
.pn_length
);
6532 printf (_(" Version: %d\n"),
6533 pubnames
.pn_version
);
6534 printf (_(" Offset into .debug_info section: %ld\n"),
6535 pubnames
.pn_offset
);
6536 printf (_(" Size of area in .debug_info section: %ld\n"),
6539 printf (_("\n Offset\tName\n"));
6543 offset
= byte_get (data
, 4);
6548 printf (" %ld\t\t%s\n", offset
, data
);
6549 data
+= strlen ((char *) data
) + 1;
6552 while (offset
!= 0);
6565 case DW_TAG_padding
: return "DW_TAG_padding";
6566 case DW_TAG_array_type
: return "DW_TAG_array_type";
6567 case DW_TAG_class_type
: return "DW_TAG_class_type";
6568 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6569 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6570 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6571 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6572 case DW_TAG_label
: return "DW_TAG_label";
6573 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6574 case DW_TAG_member
: return "DW_TAG_member";
6575 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6576 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6577 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6578 case DW_TAG_string_type
: return "DW_TAG_string_type";
6579 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6580 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6581 case DW_TAG_typedef
: return "DW_TAG_typedef";
6582 case DW_TAG_union_type
: return "DW_TAG_union_type";
6583 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6584 case DW_TAG_variant
: return "DW_TAG_variant";
6585 case DW_TAG_common_block
: return "DW_TAG_common_block";
6586 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6587 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6588 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6589 case DW_TAG_module
: return "DW_TAG_module";
6590 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6591 case DW_TAG_set_type
: return "DW_TAG_set_type";
6592 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6593 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6594 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6595 case DW_TAG_base_type
: return "DW_TAG_base_type";
6596 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6597 case DW_TAG_const_type
: return "DW_TAG_const_type";
6598 case DW_TAG_constant
: return "DW_TAG_constant";
6599 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6600 case DW_TAG_file_type
: return "DW_TAG_file_type";
6601 case DW_TAG_friend
: return "DW_TAG_friend";
6602 case DW_TAG_namelist
: return "DW_TAG_namelist";
6603 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6604 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6605 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6606 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6607 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6608 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6609 case DW_TAG_try_block
: return "DW_TAG_try_block";
6610 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6611 case DW_TAG_variable
: return "DW_TAG_variable";
6612 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6613 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6614 case DW_TAG_format_label
: return "DW_TAG_format_label";
6615 case DW_TAG_function_template
: return "DW_TAG_function_template";
6616 case DW_TAG_class_template
: return "DW_TAG_class_template";
6617 /* DWARF 2.1 values. */
6618 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6619 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6620 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6621 case DW_TAG_namespace
: return "DW_TAG_namespace";
6622 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6623 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6624 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6625 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6628 static char buffer
[100];
6630 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6637 get_AT_name (attribute
)
6638 unsigned long attribute
;
6642 case DW_AT_sibling
: return "DW_AT_sibling";
6643 case DW_AT_location
: return "DW_AT_location";
6644 case DW_AT_name
: return "DW_AT_name";
6645 case DW_AT_ordering
: return "DW_AT_ordering";
6646 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6647 case DW_AT_byte_size
: return "DW_AT_byte_size";
6648 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6649 case DW_AT_bit_size
: return "DW_AT_bit_size";
6650 case DW_AT_element_list
: return "DW_AT_element_list";
6651 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6652 case DW_AT_low_pc
: return "DW_AT_low_pc";
6653 case DW_AT_high_pc
: return "DW_AT_high_pc";
6654 case DW_AT_language
: return "DW_AT_language";
6655 case DW_AT_member
: return "DW_AT_member";
6656 case DW_AT_discr
: return "DW_AT_discr";
6657 case DW_AT_discr_value
: return "DW_AT_discr_value";
6658 case DW_AT_visibility
: return "DW_AT_visibility";
6659 case DW_AT_import
: return "DW_AT_import";
6660 case DW_AT_string_length
: return "DW_AT_string_length";
6661 case DW_AT_common_reference
: return "DW_AT_common_reference";
6662 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6663 case DW_AT_const_value
: return "DW_AT_const_value";
6664 case DW_AT_containing_type
: return "DW_AT_containing_type";
6665 case DW_AT_default_value
: return "DW_AT_default_value";
6666 case DW_AT_inline
: return "DW_AT_inline";
6667 case DW_AT_is_optional
: return "DW_AT_is_optional";
6668 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6669 case DW_AT_producer
: return "DW_AT_producer";
6670 case DW_AT_prototyped
: return "DW_AT_prototyped";
6671 case DW_AT_return_addr
: return "DW_AT_return_addr";
6672 case DW_AT_start_scope
: return "DW_AT_start_scope";
6673 case DW_AT_stride_size
: return "DW_AT_stride_size";
6674 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6675 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6676 case DW_AT_accessibility
: return "DW_AT_accessibility";
6677 case DW_AT_address_class
: return "DW_AT_address_class";
6678 case DW_AT_artificial
: return "DW_AT_artificial";
6679 case DW_AT_base_types
: return "DW_AT_base_types";
6680 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6681 case DW_AT_count
: return "DW_AT_count";
6682 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6683 case DW_AT_decl_column
: return "DW_AT_decl_column";
6684 case DW_AT_decl_file
: return "DW_AT_decl_file";
6685 case DW_AT_decl_line
: return "DW_AT_decl_line";
6686 case DW_AT_declaration
: return "DW_AT_declaration";
6687 case DW_AT_discr_list
: return "DW_AT_discr_list";
6688 case DW_AT_encoding
: return "DW_AT_encoding";
6689 case DW_AT_external
: return "DW_AT_external";
6690 case DW_AT_frame_base
: return "DW_AT_frame_base";
6691 case DW_AT_friend
: return "DW_AT_friend";
6692 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6693 case DW_AT_macro_info
: return "DW_AT_macro_info";
6694 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6695 case DW_AT_priority
: return "DW_AT_priority";
6696 case DW_AT_segment
: return "DW_AT_segment";
6697 case DW_AT_specification
: return "DW_AT_specification";
6698 case DW_AT_static_link
: return "DW_AT_static_link";
6699 case DW_AT_type
: return "DW_AT_type";
6700 case DW_AT_use_location
: return "DW_AT_use_location";
6701 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6702 case DW_AT_virtuality
: return "DW_AT_virtuality";
6703 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6704 /* DWARF 2.1 values. */
6705 case DW_AT_allocated
: return "DW_AT_allocated";
6706 case DW_AT_associated
: return "DW_AT_associated";
6707 case DW_AT_data_location
: return "DW_AT_data_location";
6708 case DW_AT_stride
: return "DW_AT_stride";
6709 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6710 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6711 case DW_AT_extension
: return "DW_AT_extension";
6712 case DW_AT_ranges
: return "DW_AT_ranges";
6713 case DW_AT_trampoline
: return "DW_AT_trampoline";
6714 case DW_AT_call_column
: return "DW_AT_call_column";
6715 case DW_AT_call_file
: return "DW_AT_call_file";
6716 case DW_AT_call_line
: return "DW_AT_call_line";
6717 /* SGI/MIPS extensions. */
6718 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6719 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6720 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6721 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6722 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6723 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6724 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6725 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6726 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6727 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6728 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6729 /* GNU extensions. */
6730 case DW_AT_sf_names
: return "DW_AT_sf_names";
6731 case DW_AT_src_info
: return "DW_AT_src_info";
6732 case DW_AT_mac_info
: return "DW_AT_mac_info";
6733 case DW_AT_src_coords
: return "DW_AT_src_coords";
6734 case DW_AT_body_begin
: return "DW_AT_body_begin";
6735 case DW_AT_body_end
: return "DW_AT_body_end";
6736 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6739 static char buffer
[100];
6741 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6748 get_FORM_name (form
)
6753 case DW_FORM_addr
: return "DW_FORM_addr";
6754 case DW_FORM_block2
: return "DW_FORM_block2";
6755 case DW_FORM_block4
: return "DW_FORM_block4";
6756 case DW_FORM_data2
: return "DW_FORM_data2";
6757 case DW_FORM_data4
: return "DW_FORM_data4";
6758 case DW_FORM_data8
: return "DW_FORM_data8";
6759 case DW_FORM_string
: return "DW_FORM_string";
6760 case DW_FORM_block
: return "DW_FORM_block";
6761 case DW_FORM_block1
: return "DW_FORM_block1";
6762 case DW_FORM_data1
: return "DW_FORM_data1";
6763 case DW_FORM_flag
: return "DW_FORM_flag";
6764 case DW_FORM_sdata
: return "DW_FORM_sdata";
6765 case DW_FORM_strp
: return "DW_FORM_strp";
6766 case DW_FORM_udata
: return "DW_FORM_udata";
6767 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6768 case DW_FORM_ref1
: return "DW_FORM_ref1";
6769 case DW_FORM_ref2
: return "DW_FORM_ref2";
6770 case DW_FORM_ref4
: return "DW_FORM_ref4";
6771 case DW_FORM_ref8
: return "DW_FORM_ref8";
6772 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6773 case DW_FORM_indirect
: return "DW_FORM_indirect";
6776 static char buffer
[100];
6778 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6784 /* FIXME: There are better and more effiecint ways to handle
6785 these structures. For now though, I just want something that
6786 is simple to implement. */
6787 typedef struct abbrev_attr
6789 unsigned long attribute
;
6791 struct abbrev_attr
* next
;
6795 typedef struct abbrev_entry
6797 unsigned long entry
;
6800 struct abbrev_attr
* first_attr
;
6801 struct abbrev_attr
* last_attr
;
6802 struct abbrev_entry
* next
;
6806 static abbrev_entry
* first_abbrev
= NULL
;
6807 static abbrev_entry
* last_abbrev
= NULL
;
6810 free_abbrevs
PARAMS ((void))
6812 abbrev_entry
* abbrev
;
6814 for (abbrev
= first_abbrev
; abbrev
;)
6816 abbrev_entry
* next
= abbrev
->next
;
6819 for (attr
= abbrev
->first_attr
; attr
;)
6821 abbrev_attr
* next
= attr
->next
;
6831 last_abbrev
= first_abbrev
= NULL
;
6835 add_abbrev (number
, tag
, children
)
6836 unsigned long number
;
6840 abbrev_entry
* entry
;
6842 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6848 entry
->entry
= number
;
6850 entry
->children
= children
;
6851 entry
->first_attr
= NULL
;
6852 entry
->last_attr
= NULL
;
6855 if (first_abbrev
== NULL
)
6856 first_abbrev
= entry
;
6858 last_abbrev
->next
= entry
;
6860 last_abbrev
= entry
;
6864 add_abbrev_attr (attribute
, form
)
6865 unsigned long attribute
;
6870 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6876 attr
->attribute
= attribute
;
6880 if (last_abbrev
->first_attr
== NULL
)
6881 last_abbrev
->first_attr
= attr
;
6883 last_abbrev
->last_attr
->next
= attr
;
6885 last_abbrev
->last_attr
= attr
;
6888 /* Processes the (partial) contents of a .debug_abbrev section.
6889 Returns NULL if the end of the section was encountered.
6890 Returns the address after the last byte read if the end of
6891 an abbreviation set was found. */
6893 static unsigned char *
6894 process_abbrev_section (start
, end
)
6895 unsigned char * start
;
6896 unsigned char * end
;
6898 if (first_abbrev
!= NULL
)
6904 unsigned long entry
;
6906 unsigned long attribute
;
6909 entry
= read_leb128 (start
, & bytes_read
, 0);
6910 start
+= bytes_read
;
6912 /* A single zero is supposed to end the section according
6913 to the standard. If there's more, then signal that to
6916 return start
== end
? NULL
: start
;
6918 tag
= read_leb128 (start
, & bytes_read
, 0);
6919 start
+= bytes_read
;
6921 children
= * start
++;
6923 add_abbrev (entry
, tag
, children
);
6929 attribute
= read_leb128 (start
, & bytes_read
, 0);
6930 start
+= bytes_read
;
6932 form
= read_leb128 (start
, & bytes_read
, 0);
6933 start
+= bytes_read
;
6936 add_abbrev_attr (attribute
, form
);
6938 while (attribute
!= 0);
6946 display_debug_macinfo (section
, start
, file
)
6947 Elf_Internal_Shdr
* section
;
6948 unsigned char * start
;
6949 FILE * file ATTRIBUTE_UNUSED
;
6951 unsigned char * end
= start
+ section
->sh_size
;
6952 unsigned char * curr
= start
;
6953 unsigned int bytes_read
;
6954 enum dwarf_macinfo_record_type op
;
6956 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6960 unsigned int lineno
;
6961 const char * string
;
6968 case DW_MACINFO_start_file
:
6970 unsigned int filenum
;
6972 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6974 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6977 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6981 case DW_MACINFO_end_file
:
6982 printf (_(" DW_MACINFO_end_file\n"));
6985 case DW_MACINFO_define
:
6986 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6989 curr
+= strlen (string
) + 1;
6990 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6993 case DW_MACINFO_undef
:
6994 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6997 curr
+= strlen (string
) + 1;
6998 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7001 case DW_MACINFO_vendor_ext
:
7003 unsigned int constant
;
7005 constant
= read_leb128 (curr
, & bytes_read
, 0);
7008 curr
+= strlen (string
) + 1;
7009 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7020 display_debug_abbrev (section
, start
, file
)
7021 Elf_Internal_Shdr
* section
;
7022 unsigned char * start
;
7023 FILE * file ATTRIBUTE_UNUSED
;
7025 abbrev_entry
* entry
;
7026 unsigned char * end
= start
+ section
->sh_size
;
7028 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7032 start
= process_abbrev_section (start
, end
);
7034 if (first_abbrev
== NULL
)
7037 printf (_(" Number TAG\n"));
7039 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7043 printf (_(" %ld %s [%s]\n"),
7045 get_TAG_name (entry
->tag
),
7046 entry
->children
? _("has children") : _("no children"));
7048 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7050 printf (_(" %-18s %s\n"),
7051 get_AT_name (attr
->attribute
),
7052 get_FORM_name (attr
->form
));
7066 static unsigned char *
7067 display_block (data
, length
)
7068 unsigned char * data
;
7069 unsigned long length
;
7071 printf (_(" %lu byte block: "), length
);
7074 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7080 decode_location_expression (data
, pointer_size
, length
)
7081 unsigned char * data
;
7082 unsigned int pointer_size
;
7083 unsigned long length
;
7087 unsigned long uvalue
;
7088 unsigned char * end
= data
+ length
;
7097 printf ("DW_OP_addr: %lx",
7098 (unsigned long) byte_get (data
, pointer_size
));
7099 data
+= pointer_size
;
7102 printf ("DW_OP_deref");
7105 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7108 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7111 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7115 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7119 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7123 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7127 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7128 (unsigned long) byte_get (data
+ 4, 4));
7132 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7133 (long) byte_get (data
+ 4, 4));
7137 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7141 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7145 printf ("DW_OP_dup");
7148 printf ("DW_OP_drop");
7151 printf ("DW_OP_over");
7154 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7157 printf ("DW_OP_swap");
7160 printf ("DW_OP_rot");
7163 printf ("DW_OP_xderef");
7166 printf ("DW_OP_abs");
7169 printf ("DW_OP_and");
7172 printf ("DW_OP_div");
7175 printf ("DW_OP_minus");
7178 printf ("DW_OP_mod");
7181 printf ("DW_OP_mul");
7184 printf ("DW_OP_neg");
7187 printf ("DW_OP_not");
7190 printf ("DW_OP_or");
7193 printf ("DW_OP_plus");
7195 case DW_OP_plus_uconst
:
7196 printf ("DW_OP_plus_uconst: %lu",
7197 read_leb128 (data
, &bytes_read
, 0));
7201 printf ("DW_OP_shl");
7204 printf ("DW_OP_shr");
7207 printf ("DW_OP_shra");
7210 printf ("DW_OP_xor");
7213 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7217 printf ("DW_OP_eq");
7220 printf ("DW_OP_ge");
7223 printf ("DW_OP_gt");
7226 printf ("DW_OP_le");
7229 printf ("DW_OP_lt");
7232 printf ("DW_OP_ne");
7235 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7271 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7306 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7341 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7342 read_leb128 (data
, &bytes_read
, 1));
7347 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7351 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7355 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7357 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7358 read_leb128 (data
, &bytes_read
, 1));
7362 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7365 case DW_OP_deref_size
:
7366 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7368 case DW_OP_xderef_size
:
7369 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7372 printf ("DW_OP_nop");
7375 /* DWARF 3 extensions. */
7376 case DW_OP_push_object_address
:
7377 printf ("DW_OP_push_object_address");
7380 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7384 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7387 case DW_OP_call_ref
:
7388 printf ("DW_OP_call_ref");
7391 /* GNU extensions. */
7392 case DW_OP_GNU_push_tls_address
:
7393 printf ("DW_OP_GNU_push_tls_address");
7397 if (op
>= DW_OP_lo_user
7398 && op
<= DW_OP_hi_user
)
7399 printf (_("(User defined location op)"));
7401 printf (_("(Unknown location op)"));
7402 /* No way to tell where the next op is, so just bail. */
7406 /* Separate the ops. */
7411 static const char * debug_loc_contents
;
7412 static bfd_vma debug_loc_size
;
7415 load_debug_loc (file
)
7418 Elf_Internal_Shdr
* sec
;
7421 /* If it is already loaded, do nothing. */
7422 if (debug_loc_contents
!= NULL
)
7425 /* Locate the .debug_loc section. */
7426 for (i
= 0, sec
= section_headers
;
7427 i
< elf_header
.e_shnum
;
7429 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7432 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7435 debug_loc_size
= sec
->sh_size
;
7437 debug_loc_contents
= ((char *)
7438 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7439 _("debug_loc section data")));
7445 if (debug_loc_contents
== NULL
)
7448 free ((char *) debug_loc_contents
);
7449 debug_loc_contents
= NULL
;
7455 display_debug_loc (section
, start
, file
)
7456 Elf_Internal_Shdr
* section
;
7457 unsigned char * start
;
7458 FILE * file ATTRIBUTE_UNUSED
;
7460 unsigned char *section_end
;
7461 unsigned long bytes
;
7462 unsigned char *section_begin
= start
;
7465 addr
= section
->sh_addr
;
7466 bytes
= section
->sh_size
;
7467 section_end
= start
+ bytes
;
7471 printf (_("\nThe .debug_loc section is empty.\n"));
7475 printf (_("Contents of the .debug_loc section:\n\n"));
7476 printf (_("\n Offset Begin End Expression\n"));
7478 while (start
< section_end
)
7480 unsigned long begin
;
7482 unsigned short length
;
7483 unsigned long offset
;
7485 offset
= start
- section_begin
;
7489 /* Normally, the lists in the debug_loc section are related to a
7490 given compilation unit, and thus, we would use the
7491 pointer size of that compilation unit. However, since we are
7492 displaying it seperately here, we either have to store
7493 pointer sizes of all compilation units, or assume they don't
7494 change. We assume, like the debug_line display, that
7495 it doesn't change. */
7496 begin
= byte_get (start
, debug_line_pointer_size
);
7497 start
+= debug_line_pointer_size
;
7498 end
= byte_get (start
, debug_line_pointer_size
);
7499 start
+= debug_line_pointer_size
;
7501 if (begin
== 0 && end
== 0)
7507 length
= byte_get (start
, 2);
7510 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7511 decode_location_expression (start
, debug_line_pointer_size
, length
);
7521 static const char * debug_str_contents
;
7522 static bfd_vma debug_str_size
;
7525 load_debug_str (file
)
7528 Elf_Internal_Shdr
* sec
;
7531 /* If it is already loaded, do nothing. */
7532 if (debug_str_contents
!= NULL
)
7535 /* Locate the .debug_str section. */
7536 for (i
= 0, sec
= section_headers
;
7537 i
< elf_header
.e_shnum
;
7539 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7542 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7545 debug_str_size
= sec
->sh_size
;
7547 debug_str_contents
= ((char *)
7548 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7549 _("debug_str section data")));
7555 if (debug_str_contents
== NULL
)
7558 free ((char *) debug_str_contents
);
7559 debug_str_contents
= NULL
;
7564 fetch_indirect_string (offset
)
7565 unsigned long offset
;
7567 if (debug_str_contents
== NULL
)
7568 return _("<no .debug_str section>");
7570 if (offset
> debug_str_size
)
7571 return _("<offset is too big>");
7573 return debug_str_contents
+ offset
;
7577 display_debug_str (section
, start
, file
)
7578 Elf_Internal_Shdr
* section
;
7579 unsigned char * start
;
7580 FILE * file ATTRIBUTE_UNUSED
;
7582 unsigned long bytes
;
7585 addr
= section
->sh_addr
;
7586 bytes
= section
->sh_size
;
7590 printf (_("\nThe .debug_str section is empty.\n"));
7594 printf (_("Contents of the .debug_str section:\n\n"));
7602 lbytes
= (bytes
> 16 ? 16 : bytes
);
7604 printf (" 0x%8.8lx ", (unsigned long) addr
);
7606 for (j
= 0; j
< 16; j
++)
7609 printf ("%2.2x", start
[j
]);
7617 for (j
= 0; j
< lbytes
; j
++)
7620 if (k
>= ' ' && k
< 0x80)
7636 static unsigned char *
7637 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7638 unsigned long attribute
;
7640 unsigned char * data
;
7641 unsigned long cu_offset
;
7642 unsigned long pointer_size
;
7644 unsigned long uvalue
= 0;
7645 unsigned char * block_start
= NULL
;
7653 case DW_FORM_ref_addr
:
7655 uvalue
= byte_get (data
, pointer_size
);
7656 data
+= pointer_size
;
7660 uvalue
= byte_get (data
, /* offset_size */ 4);
7661 data
+= /* offset_size */ 4;
7667 uvalue
= byte_get (data
++, 1);
7672 uvalue
= byte_get (data
, 2);
7678 uvalue
= byte_get (data
, 4);
7683 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7687 case DW_FORM_ref_udata
:
7689 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7693 case DW_FORM_indirect
:
7694 form
= read_leb128 (data
, & bytes_read
, 0);
7696 printf (" %s", get_FORM_name (form
));
7697 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7703 case DW_FORM_ref_addr
:
7704 printf (" <#%lx>", uvalue
);
7710 case DW_FORM_ref_udata
:
7711 printf (" <%lx>", uvalue
+ cu_offset
);
7715 printf (" %#lx", uvalue
);
7723 printf (" %ld", uvalue
);
7728 uvalue
= byte_get (data
, 4);
7729 printf (" %lx", uvalue
);
7730 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7734 case DW_FORM_string
:
7735 printf (" %s", data
);
7736 data
+= strlen ((char *) data
) + 1;
7740 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7741 block_start
= data
+ bytes_read
;
7742 data
= display_block (block_start
, uvalue
);
7745 case DW_FORM_block1
:
7746 uvalue
= byte_get (data
, 1);
7747 block_start
= data
+ 1;
7748 data
= display_block (block_start
, uvalue
);
7751 case DW_FORM_block2
:
7752 uvalue
= byte_get (data
, 2);
7753 block_start
= data
+ 2;
7754 data
= display_block (block_start
, uvalue
);
7757 case DW_FORM_block4
:
7758 uvalue
= byte_get (data
, 4);
7759 block_start
= data
+ 4;
7760 data
= display_block (block_start
, uvalue
);
7764 printf (_(" (indirect string, offset: 0x%lx): %s"),
7765 uvalue
, fetch_indirect_string (uvalue
));
7768 case DW_FORM_indirect
:
7769 /* Handled above. */
7773 warn (_("Unrecognized form: %d\n"), form
);
7777 /* For some attributes we can display futher information. */
7786 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7787 case DW_INL_inlined
: printf (_("(inlined)")); break;
7788 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7789 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7790 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7794 case DW_AT_language
:
7797 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7798 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7799 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7800 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7801 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7802 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7803 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7804 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7805 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7806 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7807 /* DWARF 2.1 values. */
7808 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7809 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7810 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7811 /* MIPS extension. */
7812 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7813 default: printf ("(Unknown: %lx)", uvalue
); break;
7817 case DW_AT_encoding
:
7820 case DW_ATE_void
: printf ("(void)"); break;
7821 case DW_ATE_address
: printf ("(machine address)"); break;
7822 case DW_ATE_boolean
: printf ("(boolean)"); break;
7823 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7824 case DW_ATE_float
: printf ("(float)"); break;
7825 case DW_ATE_signed
: printf ("(signed)"); break;
7826 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7827 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7828 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7829 /* DWARF 2.1 value. */
7830 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7832 if (uvalue
>= DW_ATE_lo_user
7833 && uvalue
<= DW_ATE_hi_user
)
7834 printf ("(user defined type)");
7836 printf ("(unknown type)");
7841 case DW_AT_accessibility
:
7844 case DW_ACCESS_public
: printf ("(public)"); break;
7845 case DW_ACCESS_protected
: printf ("(protected)"); break;
7846 case DW_ACCESS_private
: printf ("(private)"); break;
7847 default: printf ("(unknown accessibility)"); break;
7851 case DW_AT_visibility
:
7854 case DW_VIS_local
: printf ("(local)"); break;
7855 case DW_VIS_exported
: printf ("(exported)"); break;
7856 case DW_VIS_qualified
: printf ("(qualified)"); break;
7857 default: printf ("(unknown visibility)"); break;
7861 case DW_AT_virtuality
:
7864 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7865 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7866 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7867 default: printf ("(unknown virtuality)"); break;
7871 case DW_AT_identifier_case
:
7874 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7875 case DW_ID_up_case
: printf ("(up_case)"); break;
7876 case DW_ID_down_case
: printf ("(down_case)"); break;
7877 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7878 default: printf ("(unknown case)"); break;
7882 case DW_AT_calling_convention
:
7885 case DW_CC_normal
: printf ("(normal)"); break;
7886 case DW_CC_program
: printf ("(program)"); break;
7887 case DW_CC_nocall
: printf ("(nocall)"); break;
7889 if (uvalue
>= DW_CC_lo_user
7890 && uvalue
<= DW_CC_hi_user
)
7891 printf ("(user defined)");
7893 printf ("(unknown convention)");
7897 case DW_AT_ordering
:
7900 case -1: printf ("(undefined)"); break;
7901 case 0: printf ("(row major)"); break;
7902 case 1: printf ("(column major)"); break;
7906 case DW_AT_frame_base
:
7907 case DW_AT_location
:
7908 case DW_AT_data_member_location
:
7909 case DW_AT_vtable_elem_location
:
7910 case DW_AT_allocated
:
7911 case DW_AT_associated
:
7912 case DW_AT_data_location
:
7914 case DW_AT_upper_bound
:
7915 case DW_AT_lower_bound
:
7919 decode_location_expression (block_start
, pointer_size
, uvalue
);
7922 else if (form
== DW_FORM_data4
)
7925 printf ("location list");
7937 static unsigned char *
7938 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7939 unsigned long attribute
;
7941 unsigned char * data
;
7942 unsigned long cu_offset
;
7943 unsigned long pointer_size
;
7945 printf (" %-18s:", get_AT_name (attribute
));
7946 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7953 display_debug_info (section
, start
, file
)
7954 Elf_Internal_Shdr
* section
;
7955 unsigned char * start
;
7958 unsigned char * end
= start
+ section
->sh_size
;
7959 unsigned char * section_begin
= start
;
7961 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7963 load_debug_str (file
);
7964 load_debug_loc (file
);
7968 DWARF2_External_CompUnit
* external
;
7969 DWARF2_Internal_CompUnit compunit
;
7970 Elf_Internal_Shdr
* relsec
;
7971 unsigned char * tags
;
7974 unsigned long cu_offset
;
7976 external
= (DWARF2_External_CompUnit
*) start
;
7978 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7979 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7980 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7981 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7983 if (compunit
.cu_length
== 0xffffffff)
7985 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7989 /* Check for RELA relocations in the
7990 abbrev_offset address, and apply them. */
7991 for (relsec
= section_headers
;
7992 relsec
< section_headers
+ elf_header
.e_shnum
;
7995 unsigned long nrelas
;
7996 Elf_Internal_Rela
*rela
, *rp
;
7997 Elf_Internal_Shdr
*symsec
;
7998 Elf_Internal_Sym
*symtab
;
7999 Elf_Internal_Sym
*sym
;
8001 if (relsec
->sh_type
!= SHT_RELA
8002 || SECTION_HEADER (relsec
->sh_info
) != section
8003 || relsec
->sh_size
== 0)
8006 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8010 symsec
= SECTION_HEADER (relsec
->sh_link
);
8011 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8013 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8016 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
8022 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8024 if (ELF32_R_SYM (rp
->r_info
) != 0
8025 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8027 warn (_("Skipping unexpected symbol type %u\n"),
8028 ELF32_ST_TYPE (sym
->st_info
));
8034 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8036 if (ELF64_R_SYM (rp
->r_info
) != 0
8037 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8039 warn (_("Skipping unexpected symbol type %u\n"),
8040 ELF64_ST_TYPE (sym
->st_info
));
8045 compunit
.cu_abbrev_offset
= rp
->r_addend
;
8053 tags
= start
+ sizeof (* external
);
8054 cu_offset
= start
- section_begin
;
8055 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
8057 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8058 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8059 printf (_(" Version: %d\n"), compunit
.cu_version
);
8060 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8061 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8063 if (compunit
.cu_version
!= 2)
8065 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8071 /* Read in the abbrevs used by this compilation unit. */
8073 Elf_Internal_Shdr
* sec
;
8074 unsigned char * begin
;
8076 /* Locate the .debug_abbrev section and process it. */
8077 for (i
= 0, sec
= section_headers
;
8078 i
< elf_header
.e_shnum
;
8080 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
8083 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
8085 warn (_("Unable to locate .debug_abbrev section!\n"));
8089 begin
= ((unsigned char *)
8090 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8091 _("debug_abbrev section data")));
8095 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8096 begin
+ sec
->sh_size
);
8102 while (tags
< start
)
8105 unsigned long abbrev_number
;
8106 abbrev_entry
* entry
;
8109 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8112 /* A null DIE marks the end of a list of children. */
8113 if (abbrev_number
== 0)
8119 /* Scan through the abbreviation list until we reach the
8121 for (entry
= first_abbrev
;
8122 entry
&& entry
->entry
!= abbrev_number
;
8123 entry
= entry
->next
)
8128 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8133 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8135 (unsigned long) (tags
- section_begin
- bytes_read
),
8137 get_TAG_name (entry
->tag
));
8139 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8140 tags
= read_and_display_attr (attr
->attribute
,
8143 compunit
.cu_pointer_size
);
8145 if (entry
->children
)
8159 display_debug_aranges (section
, start
, file
)
8160 Elf_Internal_Shdr
* section
;
8161 unsigned char * start
;
8162 FILE * file ATTRIBUTE_UNUSED
;
8164 unsigned char * end
= start
+ section
->sh_size
;
8166 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8170 DWARF2_External_ARange
* external
;
8171 DWARF2_Internal_ARange arange
;
8172 unsigned char * ranges
;
8173 unsigned long length
;
8174 unsigned long address
;
8177 external
= (DWARF2_External_ARange
*) start
;
8179 arange
.ar_length
= BYTE_GET (external
->ar_length
);
8180 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8181 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8182 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8183 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8185 if (arange
.ar_length
== 0xffffffff)
8187 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8191 if (arange
.ar_version
!= 2)
8193 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8197 printf (_(" Length: %ld\n"), arange
.ar_length
);
8198 printf (_(" Version: %d\n"), arange
.ar_version
);
8199 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8200 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8201 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8203 printf (_("\n Address Length\n"));
8205 ranges
= start
+ sizeof (* external
);
8207 /* Must pad to an alignment boundary that is twice the pointer size. */
8208 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
8210 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8214 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8216 ranges
+= arange
.ar_pointer_size
;
8218 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8220 ranges
+= arange
.ar_pointer_size
;
8222 /* A pair of zeros marks the end of the list. */
8223 if (address
== 0 && length
== 0)
8226 printf (" %8.8lx %lu\n", address
, length
);
8229 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8237 typedef struct Frame_Chunk
8239 struct Frame_Chunk
* next
;
8240 unsigned char * chunk_start
;
8242 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8243 short int * col_type
;
8245 char * augmentation
;
8246 unsigned int code_factor
;
8248 unsigned long pc_begin
;
8249 unsigned long pc_range
;
8253 unsigned char fde_encoding
;
8257 /* A marker for a col_type that means this column was never referenced
8258 in the frame info. */
8259 #define DW_CFA_unreferenced (-1)
8261 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8262 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8263 static int size_of_encoded_value
PARAMS ((int));
8266 frame_need_space (fc
, reg
)
8270 int prev
= fc
->ncols
;
8272 if (reg
< fc
->ncols
)
8275 fc
->ncols
= reg
+ 1;
8276 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8277 fc
->ncols
* sizeof (short int));
8278 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8279 fc
->ncols
* sizeof (int));
8281 while (prev
< fc
->ncols
)
8283 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8284 fc
->col_offset
[prev
] = 0;
8290 frame_display_row (fc
, need_col_headers
, max_regs
)
8292 int * need_col_headers
;
8298 if (* max_regs
< fc
->ncols
)
8299 * max_regs
= fc
->ncols
;
8301 if (* need_col_headers
)
8303 * need_col_headers
= 0;
8305 printf (" LOC CFA ");
8307 for (r
= 0; r
< * max_regs
; r
++)
8308 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8313 printf ("r%-4d", r
);
8319 printf ("%08lx ", fc
->pc_begin
);
8320 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8321 printf ("%-8s ", tmp
);
8323 for (r
= 0; r
< fc
->ncols
; r
++)
8325 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8327 switch (fc
->col_type
[r
])
8329 case DW_CFA_undefined
:
8332 case DW_CFA_same_value
:
8336 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8338 case DW_CFA_register
:
8339 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8342 strcpy (tmp
, "n/a");
8345 printf ("%-5s", tmp
);
8352 size_of_encoded_value (encoding
)
8355 switch (encoding
& 0x7)
8358 case 0: return is_32bit_elf
? 4 : 8;
8365 #define GET(N) byte_get (start, N); start += N
8366 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8367 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8370 display_debug_frames (section
, start
, file
)
8371 Elf_Internal_Shdr
* section
;
8372 unsigned char * start
;
8373 FILE * file ATTRIBUTE_UNUSED
;
8375 unsigned char * end
= start
+ section
->sh_size
;
8376 unsigned char * section_start
= start
;
8377 Frame_Chunk
* chunks
= 0;
8378 Frame_Chunk
* remembered_state
= 0;
8380 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8383 int addr_size
= is_32bit_elf
? 4 : 8;
8385 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8389 unsigned char * saved_start
;
8390 unsigned char * block_end
;
8391 unsigned long length
;
8392 unsigned long cie_id
;
8395 int need_col_headers
= 1;
8396 unsigned char * augmentation_data
= NULL
;
8397 unsigned long augmentation_data_len
= 0;
8398 int encoded_ptr_size
= addr_size
;
8400 saved_start
= start
;
8401 length
= byte_get (start
, 4); start
+= 4;
8405 printf ("\n%08lx ZERO terminator\n\n",
8406 (unsigned long)(saved_start
- section_start
));
8410 if (length
== 0xffffffff)
8412 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8416 block_end
= saved_start
+ length
+ 4;
8417 cie_id
= byte_get (start
, 4); start
+= 4;
8419 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8423 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8424 memset (fc
, 0, sizeof (Frame_Chunk
));
8428 fc
->chunk_start
= saved_start
;
8430 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8431 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8432 frame_need_space (fc
, max_regs
-1);
8436 fc
->augmentation
= start
;
8437 start
= strchr (start
, '\0') + 1;
8439 if (fc
->augmentation
[0] == 'z')
8441 fc
->code_factor
= LEB ();
8442 fc
->data_factor
= SLEB ();
8443 fc
->ra
= byte_get (start
, 1); start
+= 1;
8444 augmentation_data_len
= LEB ();
8445 augmentation_data
= start
;
8446 start
+= augmentation_data_len
;
8448 else if (strcmp (fc
->augmentation
, "eh") == 0)
8451 fc
->code_factor
= LEB ();
8452 fc
->data_factor
= SLEB ();
8453 fc
->ra
= byte_get (start
, 1); start
+= 1;
8457 fc
->code_factor
= LEB ();
8458 fc
->data_factor
= SLEB ();
8459 fc
->ra
= byte_get (start
, 1); start
+= 1;
8463 if (do_debug_frames_interp
)
8464 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8465 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8466 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8470 printf ("\n%08lx %08lx %08lx CIE\n",
8471 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8472 printf (" Version: %d\n", version
);
8473 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8474 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8475 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8476 printf (" Return address column: %d\n", fc
->ra
);
8478 if (augmentation_data_len
)
8481 printf (" Augmentation data: ");
8482 for (i
= 0; i
< augmentation_data_len
; ++i
)
8483 printf (" %02x", augmentation_data
[i
]);
8489 if (augmentation_data_len
)
8491 unsigned char *p
, *q
;
8492 p
= fc
->augmentation
+ 1;
8493 q
= augmentation_data
;
8500 q
+= 1 + size_of_encoded_value (*q
);
8502 fc
->fde_encoding
= *q
++;
8508 if (fc
->fde_encoding
)
8509 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8512 frame_need_space (fc
, fc
->ra
);
8516 unsigned char * look_for
;
8517 static Frame_Chunk fde_fc
;
8520 memset (fc
, 0, sizeof (Frame_Chunk
));
8522 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8524 for (cie
= chunks
; cie
; cie
= cie
->next
)
8525 if (cie
->chunk_start
== look_for
)
8530 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8531 cie_id
, saved_start
);
8534 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8535 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8536 frame_need_space (fc
, max_regs
- 1);
8538 fc
->augmentation
= "";
8539 fc
->fde_encoding
= 0;
8543 fc
->ncols
= cie
->ncols
;
8544 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8545 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8546 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8547 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8548 fc
->augmentation
= cie
->augmentation
;
8549 fc
->code_factor
= cie
->code_factor
;
8550 fc
->data_factor
= cie
->data_factor
;
8551 fc
->cfa_reg
= cie
->cfa_reg
;
8552 fc
->cfa_offset
= cie
->cfa_offset
;
8554 frame_need_space (fc
, max_regs
-1);
8555 fc
->fde_encoding
= cie
->fde_encoding
;
8558 if (fc
->fde_encoding
)
8559 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8561 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8562 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8563 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
8564 start
+= encoded_ptr_size
;
8565 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8566 start
+= encoded_ptr_size
;
8568 if (cie
->augmentation
[0] == 'z')
8570 augmentation_data_len
= LEB ();
8571 augmentation_data
= start
;
8572 start
+= augmentation_data_len
;
8575 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8576 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8577 (unsigned long)(cie
->chunk_start
- section_start
),
8578 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8579 if (! do_debug_frames_interp
&& augmentation_data_len
)
8582 printf (" Augmentation data: ");
8583 for (i
= 0; i
< augmentation_data_len
; ++i
)
8584 printf (" %02x", augmentation_data
[i
]);
8590 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8591 about to interpret instructions for the chunk. */
8593 if (do_debug_frames_interp
)
8595 /* Start by making a pass over the chunk, allocating storage
8596 and taking note of what registers are used. */
8597 unsigned char * tmp
= start
;
8599 while (start
< block_end
)
8609 /* Warning: if you add any more cases to this switch, be
8610 sure to add them to the corresponding switch below. */
8613 case DW_CFA_advance_loc
:
8617 frame_need_space (fc
, opa
);
8618 fc
->col_type
[opa
] = DW_CFA_undefined
;
8620 case DW_CFA_restore
:
8621 frame_need_space (fc
, opa
);
8622 fc
->col_type
[opa
] = DW_CFA_undefined
;
8624 case DW_CFA_set_loc
:
8625 start
+= encoded_ptr_size
;
8627 case DW_CFA_advance_loc1
:
8630 case DW_CFA_advance_loc2
:
8633 case DW_CFA_advance_loc4
:
8636 case DW_CFA_offset_extended
:
8637 reg
= LEB (); LEB ();
8638 frame_need_space (fc
, reg
);
8639 fc
->col_type
[reg
] = DW_CFA_undefined
;
8641 case DW_CFA_restore_extended
:
8643 frame_need_space (fc
, reg
);
8644 fc
->col_type
[reg
] = DW_CFA_undefined
;
8646 case DW_CFA_undefined
:
8648 frame_need_space (fc
, reg
);
8649 fc
->col_type
[reg
] = DW_CFA_undefined
;
8651 case DW_CFA_same_value
:
8653 frame_need_space (fc
, reg
);
8654 fc
->col_type
[reg
] = DW_CFA_undefined
;
8656 case DW_CFA_register
:
8657 reg
= LEB (); LEB ();
8658 frame_need_space (fc
, reg
);
8659 fc
->col_type
[reg
] = DW_CFA_undefined
;
8661 case DW_CFA_def_cfa
:
8664 case DW_CFA_def_cfa_register
:
8667 case DW_CFA_def_cfa_offset
:
8670 case DW_CFA_offset_extended_sf
:
8671 reg
= LEB (); SLEB ();
8672 frame_need_space (fc
, reg
);
8673 fc
->col_type
[reg
] = DW_CFA_undefined
;
8675 case DW_CFA_def_cfa_sf
:
8678 case DW_CFA_def_cfa_offset_sf
:
8681 case DW_CFA_GNU_args_size
:
8684 case DW_CFA_GNU_negative_offset_extended
:
8685 reg
= LEB (); LEB ();
8686 frame_need_space (fc
, reg
);
8687 fc
->col_type
[reg
] = DW_CFA_undefined
;
8696 /* Now we know what registers are used, make a second pass over
8697 the chunk, this time actually printing out the info. */
8699 while (start
< block_end
)
8702 unsigned long ul
, reg
, roffs
;
8711 /* Warning: if you add any more cases to this switch, be
8712 sure to add them to the corresponding switch above. */
8715 case DW_CFA_advance_loc
:
8716 if (do_debug_frames_interp
)
8717 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8719 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8720 opa
* fc
->code_factor
,
8721 fc
->pc_begin
+ opa
* fc
->code_factor
);
8722 fc
->pc_begin
+= opa
* fc
->code_factor
;
8727 if (! do_debug_frames_interp
)
8728 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8729 opa
, roffs
* fc
->data_factor
);
8730 fc
->col_type
[opa
] = DW_CFA_offset
;
8731 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8734 case DW_CFA_restore
:
8735 if (! do_debug_frames_interp
)
8736 printf (" DW_CFA_restore: r%d\n", opa
);
8737 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8738 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8741 case DW_CFA_set_loc
:
8742 vma
= byte_get (start
, encoded_ptr_size
);
8743 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8744 vma
+= section
->sh_addr
+ (start
- section_start
);
8745 start
+= encoded_ptr_size
;
8746 if (do_debug_frames_interp
)
8747 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8749 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8753 case DW_CFA_advance_loc1
:
8754 ofs
= byte_get (start
, 1); start
+= 1;
8755 if (do_debug_frames_interp
)
8756 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8758 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8759 ofs
* fc
->code_factor
,
8760 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8761 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8764 case DW_CFA_advance_loc2
:
8765 ofs
= byte_get (start
, 2); start
+= 2;
8766 if (do_debug_frames_interp
)
8767 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8769 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8770 ofs
* fc
->code_factor
,
8771 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8772 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8775 case DW_CFA_advance_loc4
:
8776 ofs
= byte_get (start
, 4); start
+= 4;
8777 if (do_debug_frames_interp
)
8778 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8780 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8781 ofs
* fc
->code_factor
,
8782 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8783 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8786 case DW_CFA_offset_extended
:
8789 if (! do_debug_frames_interp
)
8790 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8791 reg
, roffs
* fc
->data_factor
);
8792 fc
->col_type
[reg
] = DW_CFA_offset
;
8793 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8796 case DW_CFA_restore_extended
:
8798 if (! do_debug_frames_interp
)
8799 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8800 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8801 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8804 case DW_CFA_undefined
:
8806 if (! do_debug_frames_interp
)
8807 printf (" DW_CFA_undefined: r%ld\n", reg
);
8808 fc
->col_type
[reg
] = DW_CFA_undefined
;
8809 fc
->col_offset
[reg
] = 0;
8812 case DW_CFA_same_value
:
8814 if (! do_debug_frames_interp
)
8815 printf (" DW_CFA_same_value: r%ld\n", reg
);
8816 fc
->col_type
[reg
] = DW_CFA_same_value
;
8817 fc
->col_offset
[reg
] = 0;
8820 case DW_CFA_register
:
8823 if (! do_debug_frames_interp
)
8824 printf (" DW_CFA_register: r%ld\n", reg
);
8825 fc
->col_type
[reg
] = DW_CFA_register
;
8826 fc
->col_offset
[reg
] = roffs
;
8829 case DW_CFA_remember_state
:
8830 if (! do_debug_frames_interp
)
8831 printf (" DW_CFA_remember_state\n");
8832 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8833 rs
->ncols
= fc
->ncols
;
8834 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8835 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8836 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8837 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8838 rs
->next
= remembered_state
;
8839 remembered_state
= rs
;
8842 case DW_CFA_restore_state
:
8843 if (! do_debug_frames_interp
)
8844 printf (" DW_CFA_restore_state\n");
8845 rs
= remembered_state
;
8846 remembered_state
= rs
->next
;
8847 frame_need_space (fc
, rs
->ncols
-1);
8848 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8849 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8850 free (rs
->col_type
);
8851 free (rs
->col_offset
);
8855 case DW_CFA_def_cfa
:
8856 fc
->cfa_reg
= LEB ();
8857 fc
->cfa_offset
= LEB ();
8858 if (! do_debug_frames_interp
)
8859 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8860 fc
->cfa_reg
, fc
->cfa_offset
);
8863 case DW_CFA_def_cfa_register
:
8864 fc
->cfa_reg
= LEB ();
8865 if (! do_debug_frames_interp
)
8866 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8869 case DW_CFA_def_cfa_offset
:
8870 fc
->cfa_offset
= LEB ();
8871 if (! do_debug_frames_interp
)
8872 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8876 if (! do_debug_frames_interp
)
8877 printf (" DW_CFA_nop\n");
8880 case DW_CFA_offset_extended_sf
:
8883 frame_need_space (fc
, reg
);
8884 if (! do_debug_frames_interp
)
8885 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8886 reg
, l
* fc
->data_factor
);
8887 fc
->col_type
[reg
] = DW_CFA_offset
;
8888 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8891 case DW_CFA_def_cfa_sf
:
8892 fc
->cfa_reg
= LEB ();
8893 fc
->cfa_offset
= SLEB ();
8894 if (! do_debug_frames_interp
)
8895 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8896 fc
->cfa_reg
, fc
->cfa_offset
);
8899 case DW_CFA_def_cfa_offset_sf
:
8900 fc
->cfa_offset
= SLEB ();
8901 if (! do_debug_frames_interp
)
8902 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
8905 case DW_CFA_GNU_window_save
:
8906 if (! do_debug_frames_interp
)
8907 printf (" DW_CFA_GNU_window_save\n");
8910 case DW_CFA_GNU_args_size
:
8912 if (! do_debug_frames_interp
)
8913 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8916 case DW_CFA_GNU_negative_offset_extended
:
8919 frame_need_space (fc
, reg
);
8920 if (! do_debug_frames_interp
)
8921 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8922 reg
, l
* fc
->data_factor
);
8923 fc
->col_type
[reg
] = DW_CFA_offset
;
8924 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8927 /* FIXME: How do we handle these? */
8928 case DW_CFA_def_cfa_expression
:
8929 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
8933 case DW_CFA_expression
:
8934 fprintf (stderr
, "unsupported DW_CFA_expression\n");
8939 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8944 if (do_debug_frames_interp
)
8945 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8960 display_debug_not_supported (section
, start
, file
)
8961 Elf_Internal_Shdr
* section
;
8962 unsigned char * start ATTRIBUTE_UNUSED
;
8963 FILE * file ATTRIBUTE_UNUSED
;
8965 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8966 SECTION_NAME (section
));
8971 /* Pre-scan the .debug_info section to record the size of address.
8972 When dumping the .debug_line, we use that size information, assuming
8973 that all compilation units have the same address size. */
8975 prescan_debug_info (section
, start
, file
)
8976 Elf_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8977 unsigned char * start
;
8978 FILE * file ATTRIBUTE_UNUSED
;
8980 DWARF2_External_CompUnit
* external
;
8982 external
= (DWARF2_External_CompUnit
*) start
;
8984 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8988 /* A structure containing the name of a debug section and a pointer
8989 to a function that can decode it. The third field is a prescan
8990 function to be run over the section before displaying any of the
8994 const char * const name
;
8995 int (* display
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
8996 int (* prescan
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
9000 { ".debug_abbrev", display_debug_abbrev
, NULL
},
9001 { ".debug_aranges", display_debug_aranges
, NULL
},
9002 { ".debug_frame", display_debug_frames
, NULL
},
9003 { ".debug_info", display_debug_info
, prescan_debug_info
},
9004 { ".debug_line", display_debug_lines
, NULL
},
9005 { ".debug_pubnames", display_debug_pubnames
, NULL
},
9006 { ".eh_frame", display_debug_frames
, NULL
},
9007 { ".debug_macinfo", display_debug_macinfo
, NULL
},
9008 { ".debug_str", display_debug_str
, NULL
},
9009 { ".debug_loc", display_debug_loc
, NULL
},
9010 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
9011 { ".debug_ranges", display_debug_not_supported
, NULL
},
9012 { ".debug_static_func", display_debug_not_supported
, NULL
},
9013 { ".debug_static_vars", display_debug_not_supported
, NULL
},
9014 { ".debug_types", display_debug_not_supported
, NULL
},
9015 { ".debug_weaknames", display_debug_not_supported
, NULL
}
9019 display_debug_section (section
, file
)
9020 Elf_Internal_Shdr
* section
;
9023 char * name
= SECTION_NAME (section
);
9024 bfd_size_type length
;
9025 unsigned char * start
;
9028 length
= section
->sh_size
;
9031 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9035 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
9036 _("debug section data"));
9040 /* See if we know how to display the contents of this section. */
9041 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9042 name
= ".debug_info";
9044 for (i
= NUM_ELEM (debug_displays
); i
--;)
9045 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9047 debug_displays
[i
].display (section
, start
, file
);
9052 printf (_("Unrecognized debug section: %s\n"), name
);
9056 /* If we loaded in the abbrev section at some point,
9057 we must release it here. */
9064 process_section_contents (file
)
9067 Elf_Internal_Shdr
* section
;
9073 /* Pre-scan the debug sections to find some debug information not
9074 present in some of them. For the .debug_line, we must find out the
9075 size of address (specified in .debug_info and .debug_aranges). */
9076 for (i
= 0, section
= section_headers
;
9077 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9080 char * name
= SECTION_NAME (section
);
9083 if (section
->sh_size
== 0)
9086 /* See if there is some pre-scan operation for this section. */
9087 for (j
= NUM_ELEM (debug_displays
); j
--;)
9088 if (strcmp (debug_displays
[j
].name
, name
) == 0)
9090 if (debug_displays
[j
].prescan
!= NULL
)
9092 bfd_size_type length
;
9093 unsigned char * start
;
9095 length
= section
->sh_size
;
9096 start
= ((unsigned char *)
9097 get_data (NULL
, file
, section
->sh_offset
, length
,
9098 _("debug section data")));
9102 debug_displays
[j
].prescan (section
, start
, file
);
9110 for (i
= 0, section
= section_headers
;
9111 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9114 #ifdef SUPPORT_DISASSEMBLY
9115 if (dump_sects
[i
] & DISASS_DUMP
)
9116 disassemble_section (section
, file
);
9118 if (dump_sects
[i
] & HEX_DUMP
)
9119 dump_section (section
, file
);
9121 if (dump_sects
[i
] & DEBUG_DUMP
)
9122 display_debug_section (section
, file
);
9125 if (i
< num_dump_sects
)
9126 warn (_("Some sections were not dumped because they do not exist!\n"));
9132 process_mips_fpe_exception (mask
)
9138 if (mask
& OEX_FPU_INEX
)
9139 fputs ("INEX", stdout
), first
= 0;
9140 if (mask
& OEX_FPU_UFLO
)
9141 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9142 if (mask
& OEX_FPU_OFLO
)
9143 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9144 if (mask
& OEX_FPU_DIV0
)
9145 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9146 if (mask
& OEX_FPU_INVAL
)
9147 printf ("%sINVAL", first
? "" : "|");
9150 fputs ("0", stdout
);
9154 process_mips_specific (file
)
9157 Elf_Internal_Dyn
* entry
;
9158 size_t liblist_offset
= 0;
9159 size_t liblistno
= 0;
9160 size_t conflictsno
= 0;
9161 size_t options_offset
= 0;
9162 size_t conflicts_offset
= 0;
9164 /* We have a lot of special sections. Thanks SGI! */
9165 if (dynamic_segment
== NULL
)
9166 /* No information available. */
9169 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9170 switch (entry
->d_tag
)
9172 case DT_MIPS_LIBLIST
:
9173 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
9175 case DT_MIPS_LIBLISTNO
:
9176 liblistno
= entry
->d_un
.d_val
;
9178 case DT_MIPS_OPTIONS
:
9179 options_offset
= entry
->d_un
.d_val
- loadaddr
;
9181 case DT_MIPS_CONFLICT
:
9182 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
9184 case DT_MIPS_CONFLICTNO
:
9185 conflictsno
= entry
->d_un
.d_val
;
9191 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9193 Elf32_External_Lib
* elib
;
9196 elib
= ((Elf32_External_Lib
*)
9197 get_data (NULL
, file
, liblist_offset
,
9198 liblistno
* sizeof (Elf32_External_Lib
),
9202 printf ("\nSection '.liblist' contains %lu entries:\n",
9203 (unsigned long) liblistno
);
9204 fputs (" Library Time Stamp Checksum Version Flags\n",
9207 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9214 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9215 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9216 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9217 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9218 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9220 tmp
= gmtime (&time
);
9221 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9222 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9223 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9225 printf ("%3lu: ", (unsigned long) cnt
);
9226 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9227 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9230 if (liblist
.l_flags
== 0)
9241 { " EXACT_MATCH", LL_EXACT_MATCH
},
9242 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9243 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9244 { " EXPORTS", LL_EXPORTS
},
9245 { " DELAY_LOAD", LL_DELAY_LOAD
},
9246 { " DELTA", LL_DELTA
}
9248 int flags
= liblist
.l_flags
;
9252 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9254 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9256 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9257 flags
^= l_flags_vals
[fcnt
].bit
;
9260 printf (" %#x", (unsigned int) flags
);
9270 if (options_offset
!= 0)
9272 Elf_External_Options
* eopt
;
9273 Elf_Internal_Shdr
* sect
= section_headers
;
9274 Elf_Internal_Options
* iopt
;
9275 Elf_Internal_Options
* option
;
9279 /* Find the section header so that we get the size. */
9280 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9283 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9284 sect
->sh_size
, _("options"));
9287 iopt
= ((Elf_Internal_Options
*)
9288 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
9291 error (_("Out of memory"));
9298 while (offset
< sect
->sh_size
)
9300 Elf_External_Options
* eoption
;
9302 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9304 option
->kind
= BYTE_GET (eoption
->kind
);
9305 option
->size
= BYTE_GET (eoption
->size
);
9306 option
->section
= BYTE_GET (eoption
->section
);
9307 option
->info
= BYTE_GET (eoption
->info
);
9309 offset
+= option
->size
;
9315 printf (_("\nSection '%s' contains %d entries:\n"),
9316 SECTION_NAME (sect
), cnt
);
9324 switch (option
->kind
)
9327 /* This shouldn't happen. */
9328 printf (" NULL %d %lx", option
->section
, option
->info
);
9331 printf (" REGINFO ");
9332 if (elf_header
.e_machine
== EM_MIPS
)
9335 Elf32_External_RegInfo
* ereg
;
9336 Elf32_RegInfo reginfo
;
9338 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9339 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9340 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9341 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9342 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9343 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9344 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9346 printf ("GPR %08lx GP 0x%lx\n",
9348 (unsigned long) reginfo
.ri_gp_value
);
9349 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9350 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9351 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9356 Elf64_External_RegInfo
* ereg
;
9357 Elf64_Internal_RegInfo reginfo
;
9359 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9360 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9361 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9362 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9363 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9364 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9365 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9367 printf ("GPR %08lx GP 0x",
9368 reginfo
.ri_gprmask
);
9369 printf_vma (reginfo
.ri_gp_value
);
9372 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9373 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9374 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9378 case ODK_EXCEPTIONS
:
9379 fputs (" EXCEPTIONS fpe_min(", stdout
);
9380 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9381 fputs (") fpe_max(", stdout
);
9382 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9383 fputs (")", stdout
);
9385 if (option
->info
& OEX_PAGE0
)
9386 fputs (" PAGE0", stdout
);
9387 if (option
->info
& OEX_SMM
)
9388 fputs (" SMM", stdout
);
9389 if (option
->info
& OEX_FPDBUG
)
9390 fputs (" FPDBUG", stdout
);
9391 if (option
->info
& OEX_DISMISS
)
9392 fputs (" DISMISS", stdout
);
9395 fputs (" PAD ", stdout
);
9396 if (option
->info
& OPAD_PREFIX
)
9397 fputs (" PREFIX", stdout
);
9398 if (option
->info
& OPAD_POSTFIX
)
9399 fputs (" POSTFIX", stdout
);
9400 if (option
->info
& OPAD_SYMBOL
)
9401 fputs (" SYMBOL", stdout
);
9404 fputs (" HWPATCH ", stdout
);
9405 if (option
->info
& OHW_R4KEOP
)
9406 fputs (" R4KEOP", stdout
);
9407 if (option
->info
& OHW_R8KPFETCH
)
9408 fputs (" R8KPFETCH", stdout
);
9409 if (option
->info
& OHW_R5KEOP
)
9410 fputs (" R5KEOP", stdout
);
9411 if (option
->info
& OHW_R5KCVTL
)
9412 fputs (" R5KCVTL", stdout
);
9415 fputs (" FILL ", stdout
);
9416 /* XXX Print content of info word? */
9419 fputs (" TAGS ", stdout
);
9420 /* XXX Print content of info word? */
9423 fputs (" HWAND ", stdout
);
9424 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9425 fputs (" R4KEOP_CHECKED", stdout
);
9426 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9427 fputs (" R4KEOP_CLEAN", stdout
);
9430 fputs (" HWOR ", stdout
);
9431 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9432 fputs (" R4KEOP_CHECKED", stdout
);
9433 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9434 fputs (" R4KEOP_CLEAN", stdout
);
9437 printf (" GP_GROUP %#06lx self-contained %#06lx",
9438 option
->info
& OGP_GROUP
,
9439 (option
->info
& OGP_SELF
) >> 16);
9442 printf (" IDENT %#06lx self-contained %#06lx",
9443 option
->info
& OGP_GROUP
,
9444 (option
->info
& OGP_SELF
) >> 16);
9447 /* This shouldn't happen. */
9448 printf (" %3d ??? %d %lx",
9449 option
->kind
, option
->section
, option
->info
);
9453 len
= sizeof (* eopt
);
9454 while (len
< option
->size
)
9455 if (((char *) option
)[len
] >= ' '
9456 && ((char *) option
)[len
] < 0x7f)
9457 printf ("%c", ((char *) option
)[len
++]);
9459 printf ("\\%03o", ((char *) option
)[len
++]);
9461 fputs ("\n", stdout
);
9469 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9471 Elf32_Conflict
* iconf
;
9474 if (dynamic_symbols
== NULL
)
9476 error (_("conflict list found without a dynamic symbol table"));
9480 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
9483 error (_("Out of memory"));
9489 Elf32_External_Conflict
* econf32
;
9491 econf32
= ((Elf32_External_Conflict
*)
9492 get_data (NULL
, file
, conflicts_offset
,
9493 conflictsno
* sizeof (* econf32
),
9498 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9499 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9505 Elf64_External_Conflict
* econf64
;
9507 econf64
= ((Elf64_External_Conflict
*)
9508 get_data (NULL
, file
, conflicts_offset
,
9509 conflictsno
* sizeof (* econf64
),
9514 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9515 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9520 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9521 (long) conflictsno
);
9522 puts (_(" Num: Index Value Name"));
9524 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9526 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9528 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9529 print_vma (psym
->st_value
, FULL_HEX
);
9531 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9542 process_gnu_liblist (file
)
9545 Elf_Internal_Shdr
* section
, * string_sec
;
9546 Elf32_External_Lib
* elib
;
9554 for (i
= 0, section
= section_headers
;
9555 i
< elf_header
.e_shnum
;
9558 switch (section
->sh_type
)
9560 case SHT_GNU_LIBLIST
:
9561 elib
= ((Elf32_External_Lib
*)
9562 get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9567 string_sec
= SECTION_HEADER (section
->sh_link
);
9569 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9570 string_sec
->sh_size
,
9571 _("liblist string table"));
9574 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9580 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9581 SECTION_NAME (section
),
9582 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9584 puts (" Library Time Stamp Checksum Version Flags");
9586 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9594 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9595 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9596 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9597 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9598 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9600 tmp
= gmtime (&time
);
9601 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9602 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9603 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9605 printf ("%3lu: ", (unsigned long) cnt
);
9607 printf ("%-20s", strtab
+ liblist
.l_name
);
9609 printf ("%-20.20s", strtab
+ liblist
.l_name
);
9610 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9611 liblist
.l_version
, liblist
.l_flags
);
9622 get_note_type (e_type
)
9625 static char buff
[64];
9629 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9630 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9631 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9632 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9633 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9634 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9635 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9636 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9637 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9638 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9639 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9641 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9647 get_netbsd_elfcore_note_type (e_type
)
9650 static char buff
[64];
9652 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9654 /* NetBSD core "procinfo" structure. */
9655 return _("NetBSD procinfo structure");
9658 /* As of Jan 2002 there are no other machine-independent notes
9659 defined for NetBSD core files. If the note type is less
9660 than the start of the machine-dependent note types, we don't
9663 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9665 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9669 switch (elf_header
.e_machine
)
9671 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9672 and PT_GETFPREGS == mach+2. */
9677 case EM_SPARC32PLUS
:
9681 case NT_NETBSDCORE_FIRSTMACH
+0:
9682 return _("PT_GETREGS (reg structure)");
9683 case NT_NETBSDCORE_FIRSTMACH
+2:
9684 return _("PT_GETFPREGS (fpreg structure)");
9690 /* On all other arch's, PT_GETREGS == mach+1 and
9691 PT_GETFPREGS == mach+3. */
9695 case NT_NETBSDCORE_FIRSTMACH
+1:
9696 return _("PT_GETREGS (reg structure)");
9697 case NT_NETBSDCORE_FIRSTMACH
+3:
9698 return _("PT_GETFPREGS (fpreg structure)");
9704 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9708 /* Note that by the ELF standard, the name field is already null byte
9709 terminated, and namesz includes the terminating null byte.
9710 I.E. the value of namesz for the name "FSF" is 4.
9712 If the value of namesz is zero, there is no name present. */
9714 process_note (pnote
)
9715 Elf_Internal_Note
* pnote
;
9719 if (pnote
->namesz
== 0)
9721 /* If there is no note name, then use the default set of
9722 note type strings. */
9723 nt
= get_note_type (pnote
->type
);
9725 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9727 /* NetBSD-specific core file notes. */
9728 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9732 /* Don't recognize this note name; just use the default set of
9733 note type strings. */
9734 nt
= get_note_type (pnote
->type
);
9737 printf (" %s\t\t0x%08lx\t%s\n",
9738 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9745 process_corefile_note_segment (file
, offset
, length
)
9750 Elf_External_Note
* pnotes
;
9751 Elf_External_Note
* external
;
9757 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9764 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9765 (unsigned long) offset
, (unsigned long) length
);
9766 printf (_(" Owner\t\tData size\tDescription\n"));
9768 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9770 Elf_External_Note
* next
;
9771 Elf_Internal_Note inote
;
9774 inote
.type
= BYTE_GET (external
->type
);
9775 inote
.namesz
= BYTE_GET (external
->namesz
);
9776 inote
.namedata
= external
->name
;
9777 inote
.descsz
= BYTE_GET (external
->descsz
);
9778 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9779 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9781 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9783 if (((char *) next
) > (((char *) pnotes
) + length
))
9785 warn (_("corrupt note found at offset %x into core notes\n"),
9786 ((char *) external
) - ((char *) pnotes
));
9787 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9788 inote
.type
, inote
.namesz
, inote
.descsz
);
9794 /* Verify that name is null terminated. It appears that at least
9795 one version of Linux (RedHat 6.0) generates corefiles that don't
9796 comply with the ELF spec by failing to include the null byte in
9798 if (inote
.namedata
[inote
.namesz
] != '\0')
9800 temp
= malloc (inote
.namesz
+ 1);
9804 error (_("Out of memory\n"));
9809 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9810 temp
[inote
.namesz
] = 0;
9812 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9813 inote
.namedata
= temp
;
9816 res
&= process_note (& inote
);
9831 process_corefile_note_segments (file
)
9834 Elf_Internal_Phdr
* program_headers
;
9835 Elf_Internal_Phdr
* segment
;
9839 program_headers
= (Elf_Internal_Phdr
*) malloc
9840 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9842 if (program_headers
== NULL
)
9844 error (_("Out of memory\n"));
9849 i
= get_32bit_program_headers (file
, program_headers
);
9851 i
= get_64bit_program_headers (file
, program_headers
);
9855 free (program_headers
);
9859 for (i
= 0, segment
= program_headers
;
9860 i
< elf_header
.e_phnum
;
9863 if (segment
->p_type
== PT_NOTE
)
9864 res
&= process_corefile_note_segment (file
,
9865 (bfd_vma
) segment
->p_offset
,
9866 (bfd_vma
) segment
->p_filesz
);
9869 free (program_headers
);
9875 process_corefile_contents (file
)
9878 /* If we have not been asked to display the notes then do nothing. */
9882 /* If file is not a core file then exit. */
9883 if (elf_header
.e_type
!= ET_CORE
)
9886 /* No program headers means no NOTE segment. */
9887 if (elf_header
.e_phnum
== 0)
9889 printf (_("No note segments present in the core file.\n"));
9893 return process_corefile_note_segments (file
);
9897 process_arch_specific (file
)
9903 switch (elf_header
.e_machine
)
9906 case EM_MIPS_RS3_LE
:
9907 return process_mips_specific (file
);
9916 get_file_header (file
)
9919 /* Read in the identity array. */
9920 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9923 /* Determine how to read the rest of the header. */
9924 switch (elf_header
.e_ident
[EI_DATA
])
9926 default: /* fall through */
9927 case ELFDATANONE
: /* fall through */
9928 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9929 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9932 /* For now we only support 32 bit and 64 bit ELF files. */
9933 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9935 /* Read in the rest of the header. */
9938 Elf32_External_Ehdr ehdr32
;
9940 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9943 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9944 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9945 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9946 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9947 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9948 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9949 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9950 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9951 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9952 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9953 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9954 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9955 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9959 Elf64_External_Ehdr ehdr64
;
9961 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9962 we will not be able to cope with the 64bit data found in
9963 64 ELF files. Detect this now and abort before we start
9964 overwritting things. */
9965 if (sizeof (bfd_vma
) < 8)
9967 error (_("This instance of readelf has been built without support for a\n\
9968 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9972 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9975 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9976 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9977 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9978 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9979 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9980 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9981 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9982 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9983 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9984 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9985 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9986 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9987 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9990 if (elf_header
.e_shoff
)
9992 /* There may be some extensions in the first section header. Don't
9993 bomb if we can't read it. */
9995 get_32bit_section_headers (file
, 1);
9997 get_64bit_section_headers (file
, 1);
10004 process_file (file_name
)
10008 struct stat statbuf
;
10011 if (stat (file_name
, & statbuf
) < 0)
10013 error (_("Cannot stat input file %s.\n"), file_name
);
10017 file
= fopen (file_name
, "rb");
10020 error (_("Input file %s not found.\n"), file_name
);
10024 if (! get_file_header (file
))
10026 error (_("%s: Failed to read file header\n"), file_name
);
10031 /* Initialise per file variables. */
10032 for (i
= NUM_ELEM (version_info
); i
--;)
10033 version_info
[i
] = 0;
10035 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10036 dynamic_info
[i
] = 0;
10038 /* Process the file. */
10040 printf (_("\nFile: %s\n"), file_name
);
10042 if (! process_file_header ())
10048 if (! process_section_headers (file
))
10050 /* Without loaded section headers we
10051 cannot process lots of things. */
10052 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10054 if (! do_using_dynamic
)
10055 do_syms
= do_reloc
= 0;
10058 if (process_program_headers (file
))
10059 process_dynamic_segment (file
);
10061 process_relocs (file
);
10063 process_unwind (file
);
10065 process_symbol_table (file
);
10067 process_syminfo (file
);
10069 process_version_sections (file
);
10071 process_section_contents (file
);
10073 process_corefile_contents (file
);
10075 process_gnu_liblist (file
);
10077 process_arch_specific (file
);
10081 if (section_headers
)
10083 free (section_headers
);
10084 section_headers
= NULL
;
10089 free (string_table
);
10090 string_table
= NULL
;
10091 string_table_length
= 0;
10094 if (dynamic_strings
)
10096 free (dynamic_strings
);
10097 dynamic_strings
= NULL
;
10100 if (dynamic_symbols
)
10102 free (dynamic_symbols
);
10103 dynamic_symbols
= NULL
;
10104 num_dynamic_syms
= 0;
10107 if (dynamic_syminfo
)
10109 free (dynamic_syminfo
);
10110 dynamic_syminfo
= NULL
;
10116 #ifdef SUPPORT_DISASSEMBLY
10117 /* Needed by the i386 disassembler. For extra credit, someone could
10118 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10122 print_address (unsigned int addr
, FILE * outfile
)
10124 fprintf (outfile
,"0x%8.8x", addr
);
10127 /* Needed by the i386 disassembler. */
10129 db_task_printsym (unsigned int addr
)
10131 print_address (addr
, stderr
);
10135 int main
PARAMS ((int, char **));
10144 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10145 setlocale (LC_MESSAGES
, "");
10147 #if defined (HAVE_SETLOCALE)
10148 setlocale (LC_CTYPE
, "");
10150 bindtextdomain (PACKAGE
, LOCALEDIR
);
10151 textdomain (PACKAGE
);
10153 parse_args (argc
, argv
);
10155 if (optind
< (argc
- 1))
10159 while (optind
< argc
)
10160 err
|= process_file (argv
[optind
++]);
10162 if (dump_sects
!= NULL
)