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"
70 #include "elf/m68hc11.h"
71 #include "elf/mcore.h"
74 #include "elf/mn10200.h"
75 #include "elf/mn10300.h"
81 #include "elf/sparc.h"
83 #include "elf/x86-64.h"
84 #include "elf/xstormy16.h"
89 char * program_name
= "readelf";
90 unsigned int dynamic_addr
;
91 bfd_size_type dynamic_size
;
92 unsigned int rela_addr
;
93 unsigned int rela_size
;
94 char * dynamic_strings
;
96 unsigned long string_table_length
;
97 unsigned long num_dynamic_syms
;
98 Elf_Internal_Sym
* dynamic_symbols
;
99 Elf_Internal_Syminfo
* dynamic_syminfo
;
100 unsigned long dynamic_syminfo_offset
;
101 unsigned int dynamic_syminfo_nent
;
102 char program_interpreter
[64];
103 int dynamic_info
[DT_JMPREL
+ 1];
104 int version_info
[16];
106 Elf_Internal_Ehdr elf_header
;
107 Elf_Internal_Shdr
* section_headers
;
108 Elf_Internal_Dyn
* dynamic_segment
;
109 Elf_Internal_Shdr
* symtab_shndx_hdr
;
117 int do_using_dynamic
;
125 int do_debug_abbrevs
;
127 int do_debug_pubnames
;
128 int do_debug_aranges
;
130 int do_debug_frames_interp
;
131 int do_debug_macinfo
;
138 /* A dynamic array of flags indicating which sections require dumping. */
139 char * dump_sects
= NULL
;
140 unsigned int num_dump_sects
= 0;
142 #define HEX_DUMP (1 << 0)
143 #define DISASS_DUMP (1 << 1)
144 #define DEBUG_DUMP (1 << 2)
146 /* How to rpint a vma value. */
147 typedef enum print_mode
159 /* Forward declarations for dumb compilers. */
160 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
161 static void print_symbol
PARAMS ((int, char *));
162 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
163 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
164 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
165 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
166 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
167 static const char * get_ppc64_dynamic_type
PARAMS ((unsigned long));
168 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
169 static const char * get_dynamic_type
PARAMS ((unsigned long));
170 static int slurp_rela_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**, unsigned long *));
171 static int slurp_rel_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel
**, unsigned long *));
172 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
173 static char * get_file_type
PARAMS ((unsigned));
174 static char * get_machine_name
PARAMS ((unsigned));
175 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
176 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
177 static const char * get_mips_segment_type
PARAMS ((unsigned long));
178 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
179 static const char * get_ia64_segment_type
PARAMS ((unsigned long));
180 static const char * get_segment_type
PARAMS ((unsigned long));
181 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
182 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
183 static const char * get_ia64_section_type_name
PARAMS ((unsigned int));
184 static const char * get_section_type_name
PARAMS ((unsigned int));
185 static const char * get_symbol_binding
PARAMS ((unsigned int));
186 static const char * get_symbol_type
PARAMS ((unsigned int));
187 static const char * get_symbol_visibility
PARAMS ((unsigned int));
188 static const char * get_symbol_index_type
PARAMS ((unsigned int));
189 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
190 static void usage
PARAMS ((void));
191 static void parse_args
PARAMS ((int, char **));
192 static int process_file_header
PARAMS ((void));
193 static int process_program_headers
PARAMS ((FILE *));
194 static int process_section_headers
PARAMS ((FILE *));
195 static int process_unwind
PARAMS ((FILE *));
196 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
197 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
198 static int process_dynamic_segment
PARAMS ((FILE *));
199 static int process_symbol_table
PARAMS ((FILE *));
200 static int process_syminfo
PARAMS ((FILE *));
201 static int process_section_contents
PARAMS ((FILE *));
202 static void process_mips_fpe_exception
PARAMS ((int));
203 static int process_mips_specific
PARAMS ((FILE *));
204 static int process_file
PARAMS ((char *));
205 static int process_relocs
PARAMS ((FILE *));
206 static int process_version_sections
PARAMS ((FILE *));
207 static char * get_ver_flags
PARAMS ((unsigned int));
208 static int get_32bit_section_headers
PARAMS ((FILE *, unsigned int));
209 static int get_64bit_section_headers
PARAMS ((FILE *, unsigned int));
210 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
211 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
212 static int get_file_header
PARAMS ((FILE *));
213 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
214 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
215 static const char * get_elf_section_flags
PARAMS ((bfd_vma
));
216 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
217 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
218 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
219 #ifdef SUPPORT_DISASSEMBLY
220 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
222 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
223 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
224 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
225 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
226 static int prescan_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
227 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
228 static int display_debug_pubnames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
229 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
230 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
231 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
232 static int display_debug_macinfo
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
233 static int display_debug_str
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
234 static int display_debug_loc
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
235 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
236 static void load_debug_str
PARAMS ((FILE *));
237 static void free_debug_str
PARAMS ((void));
238 static const char * fetch_indirect_string
PARAMS ((unsigned long));
239 static void load_debug_loc
PARAMS ((FILE *));
240 static void free_debug_loc
PARAMS ((void));
241 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
242 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
243 static void reset_state_machine
PARAMS ((int));
244 static char * get_TAG_name
PARAMS ((unsigned long));
245 static char * get_AT_name
PARAMS ((unsigned long));
246 static char * get_FORM_name
PARAMS ((unsigned long));
247 static void free_abbrevs
PARAMS ((void));
248 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
249 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
250 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
251 static unsigned char * read_and_display_attr_value
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
252 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
253 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
254 static void request_dump
PARAMS ((unsigned int, int));
255 static const char * get_elf_class
PARAMS ((unsigned int));
256 static const char * get_data_encoding
PARAMS ((unsigned int));
257 static const char * get_osabi_name
PARAMS ((unsigned int));
258 static int guess_is_rela
PARAMS ((unsigned long));
259 static const char * get_note_type
PARAMS ((unsigned int));
260 static const char * get_netbsd_elfcore_note_type
PARAMS ((unsigned int));
261 static int process_note
PARAMS ((Elf32_Internal_Note
*));
262 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
263 static int process_corefile_note_segments
PARAMS ((FILE *));
264 static int process_corefile_contents
PARAMS ((FILE *));
265 static int process_arch_specific
PARAMS ((FILE *));
267 typedef int Elf32_Word
;
275 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
276 ((X)->sh_name >= string_table_length \
277 ? "<corrupt>" : string_table + (X)->sh_name))
279 /* Given st_shndx I, map to section_headers index. */
280 #define SECTION_HEADER_INDEX(I) \
281 ((I) < SHN_LORESERVE \
283 : ((I) <= SHN_HIRESERVE \
285 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
287 /* Reverse of the above. */
288 #define SECTION_HEADER_NUM(N) \
289 ((N) < SHN_LORESERVE \
291 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
293 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
295 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
297 #define BYTE_GET(field) byte_get (field, sizeof (field))
299 /* If we can support a 64 bit data type then BFD64 should be defined
300 and sizeof (bfd_vma) == 8. In this case when translating from an
301 external 8 byte field to an internal field, we can assume that the
302 internal field is also 8 bytes wide and so we can extract all the data.
303 If, however, BFD64 is not defined, then we must assume that the
304 internal data structure only has 4 byte wide fields that are the
305 equivalent of the 8 byte wide external counterparts, and so we must
306 truncate the data. */
308 #define BYTE_GET8(field) byte_get (field, -8)
310 #define BYTE_GET8(field) byte_get (field, 8)
313 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
315 #define GET_ELF_SYMBOLS(file, section) \
316 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
317 : get_64bit_elf_symbols (file, section))
321 error
VPARAMS ((const char *message
, ...))
323 VA_OPEN (args
, message
);
324 VA_FIXEDARG (args
, const char *, message
);
326 fprintf (stderr
, _("%s: Error: "), program_name
);
327 vfprintf (stderr
, message
, args
);
332 warn
VPARAMS ((const char *message
, ...))
334 VA_OPEN (args
, message
);
335 VA_FIXEDARG (args
, const char *, message
);
337 fprintf (stderr
, _("%s: Warning: "), program_name
);
338 vfprintf (stderr
, message
, args
);
342 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
345 get_data (var
, file
, offset
, size
, reason
)
357 if (fseek (file
, offset
, SEEK_SET
))
359 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
366 mvar
= (PTR
) malloc (size
);
370 error (_("Out of memory allocating %d bytes for %s\n"),
376 if (fread (mvar
, size
, 1, file
) != 1)
378 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
388 byte_get_little_endian (field
, size
)
389 unsigned char * field
;
398 return ((unsigned int) (field
[0]))
399 | (((unsigned int) (field
[1])) << 8);
403 /* We want to extract data from an 8 byte wide field and
404 place it into a 4 byte wide field. Since this is a little
405 endian source we can juts use the 4 byte extraction code. */
409 return ((unsigned long) (field
[0]))
410 | (((unsigned long) (field
[1])) << 8)
411 | (((unsigned long) (field
[2])) << 16)
412 | (((unsigned long) (field
[3])) << 24);
417 /* This is a special case, generated by the BYTE_GET8 macro.
418 It means that we are loading an 8 byte value from a field
419 in an external structure into an 8 byte value in a field
420 in an internal strcuture. */
421 return ((bfd_vma
) (field
[0]))
422 | (((bfd_vma
) (field
[1])) << 8)
423 | (((bfd_vma
) (field
[2])) << 16)
424 | (((bfd_vma
) (field
[3])) << 24)
425 | (((bfd_vma
) (field
[4])) << 32)
426 | (((bfd_vma
) (field
[5])) << 40)
427 | (((bfd_vma
) (field
[6])) << 48)
428 | (((bfd_vma
) (field
[7])) << 56);
431 error (_("Unhandled data length: %d\n"), size
);
436 /* Print a VMA value. */
438 print_vma (vma
, mode
)
448 case FULL_HEX
: printf ("0x"); /* drop through */
449 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
450 case PREFIX_HEX
: printf ("0x"); /* drop through */
451 case HEX
: printf ("%lx", (unsigned long) vma
); break;
452 case DEC
: printf ("%ld", (unsigned long) vma
); break;
453 case DEC_5
: printf ("%5ld", (long) vma
); break;
454 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
475 #if BFD_HOST_64BIT_LONG
478 if (_bfd_int64_high (vma
))
479 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
481 printf ("%lx", _bfd_int64_low (vma
));
486 #if BFD_HOST_64BIT_LONG
489 if (_bfd_int64_high (vma
))
491 printf ("++%ld", _bfd_int64_low (vma
));
493 printf ("%ld", _bfd_int64_low (vma
));
498 #if BFD_HOST_64BIT_LONG
499 printf ("%5ld", vma
);
501 if (_bfd_int64_high (vma
))
503 printf ("++%ld", _bfd_int64_low (vma
));
505 printf ("%5ld", _bfd_int64_low (vma
));
510 #if BFD_HOST_64BIT_LONG
513 if (_bfd_int64_high (vma
))
515 printf ("++%lu", _bfd_int64_low (vma
));
517 printf ("%lu", _bfd_int64_low (vma
));
525 /* Display a symbol on stdout. If do_wide is not true then
526 format the symbol to be at most WIDTH characters,
527 truhncating as necessary. If WIDTH is negative then
528 format the string to be exactly - WIDTH characters,
529 truncating or padding as necessary. */
532 print_symbol (width
, symbol
)
539 printf ("%-*.*s", width
, width
, symbol
);
541 printf ("%-.*s", width
, symbol
);
545 byte_get_big_endian (field
, size
)
546 unsigned char * field
;
555 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
558 return ((unsigned long) (field
[3]))
559 | (((unsigned long) (field
[2])) << 8)
560 | (((unsigned long) (field
[1])) << 16)
561 | (((unsigned long) (field
[0])) << 24);
565 /* Although we are extracing data from an 8 byte wide field, we
566 are returning only 4 bytes of data. */
567 return ((unsigned long) (field
[7]))
568 | (((unsigned long) (field
[6])) << 8)
569 | (((unsigned long) (field
[5])) << 16)
570 | (((unsigned long) (field
[4])) << 24);
574 /* This is a special case, generated by the BYTE_GET8 macro.
575 It means that we are loading an 8 byte value from a field
576 in an external structure into an 8 byte value in a field
577 in an internal strcuture. */
578 return ((bfd_vma
) (field
[7]))
579 | (((bfd_vma
) (field
[6])) << 8)
580 | (((bfd_vma
) (field
[5])) << 16)
581 | (((bfd_vma
) (field
[4])) << 24)
582 | (((bfd_vma
) (field
[3])) << 32)
583 | (((bfd_vma
) (field
[2])) << 40)
584 | (((bfd_vma
) (field
[1])) << 48)
585 | (((bfd_vma
) (field
[0])) << 56);
589 error (_("Unhandled data length: %d\n"), size
);
594 /* Guess the relocation size commonly used by the specific machines. */
597 guess_is_rela (e_machine
)
598 unsigned long e_machine
;
602 /* Targets that use REL relocations. */
618 /* Targets that use RELA relocations. */
633 case EM_CYGNUS_MN10200
:
635 case EM_CYGNUS_MN10300
:
673 warn (_("Don't know about relocations on this machine architecture\n"));
679 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
681 unsigned long rel_offset
;
682 unsigned long rel_size
;
683 Elf_Internal_Rela
**relasp
;
684 unsigned long *nrelasp
;
686 Elf_Internal_Rela
*relas
;
687 unsigned long nrelas
;
692 Elf32_External_Rela
* erelas
;
694 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
695 rel_size
, _("relocs"));
699 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
701 relas
= (Elf_Internal_Rela
*)
702 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
706 error(_("out of memory parsing relocs"));
710 for (i
= 0; i
< nrelas
; i
++)
712 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
713 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
714 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
721 Elf64_External_Rela
* erelas
;
723 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
724 rel_size
, _("relocs"));
728 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
730 relas
= (Elf_Internal_Rela
*)
731 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
735 error(_("out of memory parsing relocs"));
739 for (i
= 0; i
< nrelas
; i
++)
741 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
742 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
743 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
754 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
756 unsigned long rel_offset
;
757 unsigned long rel_size
;
758 Elf_Internal_Rel
**relsp
;
759 unsigned long *nrelsp
;
761 Elf_Internal_Rel
*rels
;
767 Elf32_External_Rel
* erels
;
769 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
770 rel_size
, _("relocs"));
774 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
776 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
780 error(_("out of memory parsing relocs"));
784 for (i
= 0; i
< nrels
; i
++)
786 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
787 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
794 Elf64_External_Rel
* erels
;
796 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
797 rel_size
, _("relocs"));
801 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
803 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
807 error(_("out of memory parsing relocs"));
811 for (i
= 0; i
< nrels
; i
++)
813 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
814 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
824 /* Display the contents of the relocation data found at the specified offset. */
826 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
828 unsigned long rel_offset
;
829 unsigned long rel_size
;
830 Elf_Internal_Sym
* symtab
;
836 Elf_Internal_Rel
* rels
;
837 Elf_Internal_Rela
* relas
;
840 if (is_rela
== UNKNOWN
)
841 is_rela
= guess_is_rela (elf_header
.e_machine
);
845 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &relas
, &rel_size
))
850 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
859 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
861 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
866 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
868 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
876 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
878 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
883 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
885 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
889 for (i
= 0; i
< rel_size
; i
++)
892 const char * rtype2
= NULL
;
893 const char * rtype3
= NULL
;
896 bfd_vma symtab_index
;
898 bfd_vma type2
= (bfd_vma
) NULL
;
899 bfd_vma type3
= (bfd_vma
) NULL
;
903 offset
= relas
[i
].r_offset
;
904 info
= relas
[i
].r_info
;
908 offset
= rels
[i
].r_offset
;
909 info
= rels
[i
].r_info
;
914 type
= ELF32_R_TYPE (info
);
915 symtab_index
= ELF32_R_SYM (info
);
919 if (elf_header
.e_machine
== EM_MIPS
)
921 type
= ELF64_MIPS_R_TYPE (info
);
922 type2
= ELF64_MIPS_R_TYPE2 (info
);
923 type3
= ELF64_MIPS_R_TYPE3 (info
);
925 else if (elf_header
.e_machine
== EM_SPARCV9
)
926 type
= ELF64_R_TYPE_ID (info
);
928 type
= ELF64_R_TYPE (info
);
929 /* The #ifdef BFD64 below is to prevent a compile time warning.
930 We know that if we do not have a 64 bit data type that we
931 will never execute this code anyway. */
933 symtab_index
= ELF64_R_SYM (info
);
939 #ifdef _bfd_int64_low
940 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
942 printf ("%8.8lx %8.8lx ", offset
, info
);
947 #ifdef _bfd_int64_low
949 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
950 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
951 _bfd_int64_high (offset
),
952 _bfd_int64_low (offset
),
953 _bfd_int64_high (info
),
954 _bfd_int64_low (info
));
957 ? "%16.16lx %16.16lx "
958 : "%12.12lx %12.12lx ",
963 switch (elf_header
.e_machine
)
971 rtype
= elf_m32r_reloc_type (type
);
976 rtype
= elf_i386_reloc_type (type
);
981 rtype
= elf_m68hc11_reloc_type (type
);
985 rtype
= elf_m68k_reloc_type (type
);
989 rtype
= elf_i960_reloc_type (type
);
994 rtype
= elf_avr_reloc_type (type
);
1001 rtype
= elf_sparc_reloc_type (type
);
1005 case EM_CYGNUS_V850
:
1006 rtype
= v850_reloc_type (type
);
1010 case EM_CYGNUS_D10V
:
1011 rtype
= elf_d10v_reloc_type (type
);
1015 case EM_CYGNUS_D30V
:
1016 rtype
= elf_d30v_reloc_type (type
);
1020 rtype
= elf_dlx_reloc_type (type
);
1024 rtype
= elf_sh_reloc_type (type
);
1028 case EM_CYGNUS_MN10300
:
1029 rtype
= elf_mn10300_reloc_type (type
);
1033 case EM_CYGNUS_MN10200
:
1034 rtype
= elf_mn10200_reloc_type (type
);
1038 case EM_CYGNUS_FR30
:
1039 rtype
= elf_fr30_reloc_type (type
);
1043 rtype
= elf_frv_reloc_type (type
);
1047 rtype
= elf_mcore_reloc_type (type
);
1051 rtype
= elf_mmix_reloc_type (type
);
1056 rtype
= elf_ppc_reloc_type (type
);
1060 case EM_MIPS_RS3_LE
:
1061 rtype
= elf_mips_reloc_type (type
);
1064 rtype2
= elf_mips_reloc_type (type2
);
1065 rtype3
= elf_mips_reloc_type (type3
);
1070 rtype
= elf_alpha_reloc_type (type
);
1074 rtype
= elf_arm_reloc_type (type
);
1078 rtype
= elf_arc_reloc_type (type
);
1082 rtype
= elf_hppa_reloc_type (type
);
1088 rtype
= elf_h8_reloc_type (type
);
1093 rtype
= elf_or32_reloc_type (type
);
1098 rtype
= elf_pj_reloc_type (type
);
1101 rtype
= elf_ia64_reloc_type (type
);
1105 rtype
= elf_cris_reloc_type (type
);
1109 rtype
= elf_i860_reloc_type (type
);
1113 rtype
= elf_x86_64_reloc_type (type
);
1118 rtype
= elf_s390_reloc_type (type
);
1122 rtype
= elf_xstormy16_reloc_type (type
);
1127 #ifdef _bfd_int64_low
1128 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1130 printf (_("unrecognized: %-7lx"), type
);
1133 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1137 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1138 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1141 Elf_Internal_Sym
* psym
;
1143 psym
= symtab
+ symtab_index
;
1146 print_vma (psym
->st_value
, LONG_HEX
);
1147 printf (is_32bit_elf
? " " : " ");
1149 if (psym
->st_name
== 0)
1150 print_symbol (22, SECTION_NAME (section_headers
+ psym
->st_shndx
));
1151 else if (strtab
== NULL
)
1152 printf (_("<string table index %3ld>"), psym
->st_name
);
1154 print_symbol (22, strtab
+ psym
->st_name
);
1157 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
1162 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1163 print_vma (relas
[i
].r_addend
, LONG_HEX
);
1166 if (elf_header
.e_machine
== EM_SPARCV9
1167 && !strcmp (rtype
, "R_SPARC_OLO10"))
1168 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1172 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1174 printf (" Type2: ");
1177 #ifdef _bfd_int64_low
1178 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1180 printf (_("unrecognized: %-7lx"), type2
);
1183 printf ("%-17.17s", rtype2
);
1185 printf("\n Type3: ");
1188 #ifdef _bfd_int64_low
1189 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1191 printf (_("unrecognized: %-7lx"), type3
);
1194 printf ("%-17.17s", rtype3
);
1209 get_mips_dynamic_type (type
)
1214 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1215 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1216 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1217 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1218 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1219 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1220 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1221 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1222 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1223 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1224 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1225 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1226 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1227 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1228 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1229 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1230 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1231 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1232 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1233 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1234 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1235 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1236 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1237 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1238 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1239 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1240 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1241 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1242 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1243 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1244 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1245 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1246 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1247 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1248 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1249 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1250 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1251 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1252 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1253 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1254 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1255 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1256 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1263 get_sparc64_dynamic_type (type
)
1268 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1275 get_ppc64_dynamic_type (type
)
1280 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1281 case DT_PPC64_OPD
: return "PPC64_OPD";
1282 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1289 get_parisc_dynamic_type (type
)
1294 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1295 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1296 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1297 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1298 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1299 case DT_HP_PREINIT
: return "HP_PREINIT";
1300 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1301 case DT_HP_NEEDED
: return "HP_NEEDED";
1302 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1303 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1304 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1305 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1306 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1313 get_dynamic_type (type
)
1316 static char buff
[32];
1320 case DT_NULL
: return "NULL";
1321 case DT_NEEDED
: return "NEEDED";
1322 case DT_PLTRELSZ
: return "PLTRELSZ";
1323 case DT_PLTGOT
: return "PLTGOT";
1324 case DT_HASH
: return "HASH";
1325 case DT_STRTAB
: return "STRTAB";
1326 case DT_SYMTAB
: return "SYMTAB";
1327 case DT_RELA
: return "RELA";
1328 case DT_RELASZ
: return "RELASZ";
1329 case DT_RELAENT
: return "RELAENT";
1330 case DT_STRSZ
: return "STRSZ";
1331 case DT_SYMENT
: return "SYMENT";
1332 case DT_INIT
: return "INIT";
1333 case DT_FINI
: return "FINI";
1334 case DT_SONAME
: return "SONAME";
1335 case DT_RPATH
: return "RPATH";
1336 case DT_SYMBOLIC
: return "SYMBOLIC";
1337 case DT_REL
: return "REL";
1338 case DT_RELSZ
: return "RELSZ";
1339 case DT_RELENT
: return "RELENT";
1340 case DT_PLTREL
: return "PLTREL";
1341 case DT_DEBUG
: return "DEBUG";
1342 case DT_TEXTREL
: return "TEXTREL";
1343 case DT_JMPREL
: return "JMPREL";
1344 case DT_BIND_NOW
: return "BIND_NOW";
1345 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1346 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1347 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1348 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1349 case DT_RUNPATH
: return "RUNPATH";
1350 case DT_FLAGS
: return "FLAGS";
1352 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1353 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1355 case DT_CHECKSUM
: return "CHECKSUM";
1356 case DT_PLTPADSZ
: return "PLTPADSZ";
1357 case DT_MOVEENT
: return "MOVEENT";
1358 case DT_MOVESZ
: return "MOVESZ";
1359 case DT_FEATURE
: return "FEATURE";
1360 case DT_POSFLAG_1
: return "POSFLAG_1";
1361 case DT_SYMINSZ
: return "SYMINSZ";
1362 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1364 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1365 case DT_CONFIG
: return "CONFIG";
1366 case DT_DEPAUDIT
: return "DEPAUDIT";
1367 case DT_AUDIT
: return "AUDIT";
1368 case DT_PLTPAD
: return "PLTPAD";
1369 case DT_MOVETAB
: return "MOVETAB";
1370 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1372 case DT_VERSYM
: return "VERSYM";
1374 case DT_RELACOUNT
: return "RELACOUNT";
1375 case DT_RELCOUNT
: return "RELCOUNT";
1376 case DT_FLAGS_1
: return "FLAGS_1";
1377 case DT_VERDEF
: return "VERDEF";
1378 case DT_VERDEFNUM
: return "VERDEFNUM";
1379 case DT_VERNEED
: return "VERNEED";
1380 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1382 case DT_AUXILIARY
: return "AUXILIARY";
1383 case DT_USED
: return "USED";
1384 case DT_FILTER
: return "FILTER";
1387 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1389 const char * result
;
1391 switch (elf_header
.e_machine
)
1394 case EM_MIPS_RS3_LE
:
1395 result
= get_mips_dynamic_type (type
);
1398 result
= get_sparc64_dynamic_type (type
);
1401 result
= get_ppc64_dynamic_type (type
);
1411 sprintf (buff
, _("Processor Specific: %lx"), type
);
1413 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1415 const char * result
;
1417 switch (elf_header
.e_machine
)
1420 result
= get_parisc_dynamic_type (type
);
1430 sprintf (buff
, _("Operating System specific: %lx"), type
);
1433 sprintf (buff
, _("<unknown>: %lx"), type
);
1440 get_file_type (e_type
)
1443 static char buff
[32];
1447 case ET_NONE
: return _("NONE (None)");
1448 case ET_REL
: return _("REL (Relocatable file)");
1449 case ET_EXEC
: return _("EXEC (Executable file)");
1450 case ET_DYN
: return _("DYN (Shared object file)");
1451 case ET_CORE
: return _("CORE (Core file)");
1454 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1455 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1456 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1457 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1459 sprintf (buff
, _("<unknown>: %x"), e_type
);
1465 get_machine_name (e_machine
)
1468 static char buff
[64]; /* XXX */
1472 case EM_NONE
: return _("None");
1473 case EM_M32
: return "WE32100";
1474 case EM_SPARC
: return "Sparc";
1475 case EM_386
: return "Intel 80386";
1476 case EM_68K
: return "MC68000";
1477 case EM_88K
: return "MC88000";
1478 case EM_486
: return "Intel 80486";
1479 case EM_860
: return "Intel 80860";
1480 case EM_MIPS
: return "MIPS R3000";
1481 case EM_S370
: return "IBM System/370";
1482 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1483 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1484 case EM_PARISC
: return "HPPA";
1485 case EM_PPC_OLD
: return "Power PC (old)";
1486 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1487 case EM_960
: return "Intel 90860";
1488 case EM_PPC
: return "PowerPC";
1489 case EM_PPC64
: return "PowerPC64";
1490 case EM_V800
: return "NEC V800";
1491 case EM_FR20
: return "Fujitsu FR20";
1492 case EM_RH32
: return "TRW RH32";
1493 case EM_MCORE
: return "MCORE";
1494 case EM_ARM
: return "ARM";
1495 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1496 case EM_SH
: return "Hitachi SH";
1497 case EM_SPARCV9
: return "Sparc v9";
1498 case EM_TRICORE
: return "Siemens Tricore";
1499 case EM_ARC
: return "ARC";
1500 case EM_H8_300
: return "Hitachi H8/300";
1501 case EM_H8_300H
: return "Hitachi H8/300H";
1502 case EM_H8S
: return "Hitachi H8S";
1503 case EM_H8_500
: return "Hitachi H8/500";
1504 case EM_IA_64
: return "Intel IA-64";
1505 case EM_MIPS_X
: return "Stanford MIPS-X";
1506 case EM_COLDFIRE
: return "Motorola Coldfire";
1507 case EM_68HC12
: return "Motorola M68HC12";
1508 case EM_ALPHA
: return "Alpha";
1509 case EM_CYGNUS_D10V
:
1510 case EM_D10V
: return "d10v";
1511 case EM_CYGNUS_D30V
:
1512 case EM_D30V
: return "d30v";
1513 case EM_CYGNUS_M32R
:
1514 case EM_M32R
: return "Mitsubishi M32r";
1515 case EM_CYGNUS_V850
:
1516 case EM_V850
: return "NEC v850";
1517 case EM_CYGNUS_MN10300
:
1518 case EM_MN10300
: return "mn10300";
1519 case EM_CYGNUS_MN10200
:
1520 case EM_MN10200
: return "mn10200";
1521 case EM_CYGNUS_FR30
:
1522 case EM_FR30
: return "Fujitsu FR30";
1523 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1525 case EM_PJ
: return "picoJava";
1526 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1527 case EM_PCP
: return "Siemens PCP";
1528 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1529 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1530 case EM_STARCORE
: return "Motorola Star*Core processor";
1531 case EM_ME16
: return "Toyota ME16 processor";
1532 case EM_ST100
: return "STMicroelectronics ST100 processor";
1533 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1534 case EM_FX66
: return "Siemens FX66 microcontroller";
1535 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1536 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1537 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1538 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1539 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1540 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1541 case EM_SVX
: return "Silicon Graphics SVx";
1542 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1543 case EM_VAX
: return "Digital VAX";
1545 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1546 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1547 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1548 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1549 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1550 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1551 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1552 case EM_PRISM
: return "SiTera Prism";
1553 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1555 case EM_S390
: return "IBM S/390";
1556 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1558 case EM_OR32
: return "OpenRISC";
1559 case EM_DLX
: return "OpenDLX";
1561 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1567 decode_ARM_machine_flags (e_flags
, buf
)
1574 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1575 e_flags
&= ~ EF_ARM_EABIMASK
;
1577 /* Handle "generic" ARM flags. */
1578 if (e_flags
& EF_ARM_RELEXEC
)
1580 strcat (buf
, ", relocatable executable");
1581 e_flags
&= ~ EF_ARM_RELEXEC
;
1584 if (e_flags
& EF_ARM_HASENTRY
)
1586 strcat (buf
, ", has entry point");
1587 e_flags
&= ~ EF_ARM_HASENTRY
;
1590 /* Now handle EABI specific flags. */
1594 strcat (buf
, ", <unrecognized EABI>");
1599 case EF_ARM_EABI_VER1
:
1600 strcat (buf
, ", Version1 EABI");
1605 /* Process flags one bit at a time. */
1606 flag
= e_flags
& - e_flags
;
1611 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1612 strcat (buf
, ", sorted symbol tables");
1622 case EF_ARM_EABI_VER2
:
1623 strcat (buf
, ", Version2 EABI");
1628 /* Process flags one bit at a time. */
1629 flag
= e_flags
& - e_flags
;
1634 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1635 strcat (buf
, ", sorted symbol tables");
1638 case EF_ARM_DYNSYMSUSESEGIDX
:
1639 strcat (buf
, ", dynamic symbols use segment index");
1642 case EF_ARM_MAPSYMSFIRST
:
1643 strcat (buf
, ", mapping symbols precede others");
1653 case EF_ARM_EABI_UNKNOWN
:
1654 strcat (buf
, ", GNU EABI");
1659 /* Process flags one bit at a time. */
1660 flag
= e_flags
& - e_flags
;
1665 case EF_ARM_INTERWORK
:
1666 strcat (buf
, ", interworking enabled");
1669 case EF_ARM_APCS_26
:
1670 strcat (buf
, ", uses APCS/26");
1673 case EF_ARM_APCS_FLOAT
:
1674 strcat (buf
, ", uses APCS/float");
1678 strcat (buf
, ", position independent");
1682 strcat (buf
, ", 8 bit structure alignment");
1685 case EF_ARM_NEW_ABI
:
1686 strcat (buf
, ", uses new ABI");
1689 case EF_ARM_OLD_ABI
:
1690 strcat (buf
, ", uses old ABI");
1693 case EF_ARM_SOFT_FLOAT
:
1694 strcat (buf
, ", software FP");
1705 strcat (buf
,", <unknown>");
1709 get_machine_flags (e_flags
, e_machine
)
1713 static char buf
[1024];
1725 decode_ARM_machine_flags (e_flags
, buf
);
1729 if (e_flags
& EF_CPU32
)
1730 strcat (buf
, ", cpu32");
1731 if (e_flags
& EF_M68000
)
1732 strcat (buf
, ", m68000");
1736 if (e_flags
& EF_PPC_EMB
)
1737 strcat (buf
, ", emb");
1739 if (e_flags
& EF_PPC_RELOCATABLE
)
1740 strcat (buf
, ", relocatable");
1742 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1743 strcat (buf
, ", relocatable-lib");
1747 case EM_CYGNUS_V850
:
1748 switch (e_flags
& EF_V850_ARCH
)
1751 strcat (buf
, ", v850e");
1754 strcat (buf
, ", v850ea");
1757 strcat (buf
, ", v850");
1760 strcat (buf
, ", unknown v850 architecture variant");
1766 case EM_CYGNUS_M32R
:
1767 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1768 strcat (buf
, ", m32r");
1773 case EM_MIPS_RS3_LE
:
1774 if (e_flags
& EF_MIPS_NOREORDER
)
1775 strcat (buf
, ", noreorder");
1777 if (e_flags
& EF_MIPS_PIC
)
1778 strcat (buf
, ", pic");
1780 if (e_flags
& EF_MIPS_CPIC
)
1781 strcat (buf
, ", cpic");
1783 if (e_flags
& EF_MIPS_UCODE
)
1784 strcat (buf
, ", ugen_reserved");
1786 if (e_flags
& EF_MIPS_ABI2
)
1787 strcat (buf
, ", abi2");
1789 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1790 strcat (buf
, ", odk first");
1792 if (e_flags
& EF_MIPS_32BITMODE
)
1793 strcat (buf
, ", 32bitmode");
1795 switch ((e_flags
& EF_MIPS_MACH
))
1797 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1798 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1799 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1800 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1801 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1802 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1804 /* We simply ignore the field in this case to avoid confusion:
1805 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1808 default: strcat (buf
, ", unknown CPU"); break;
1811 switch ((e_flags
& EF_MIPS_ABI
))
1813 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1814 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1815 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1816 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1818 /* We simply ignore the field in this case to avoid confusion:
1819 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1820 This means it is likely to be an o32 file, but not for
1823 default: strcat (buf
, ", unknown ABI"); break;
1826 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1827 strcat (buf
, ", mdmx");
1829 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1830 strcat (buf
, ", mips16");
1832 switch ((e_flags
& EF_MIPS_ARCH
))
1834 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1835 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1836 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1837 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1838 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1839 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1840 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1841 default: strcat (buf
, ", unknown ISA"); break;
1847 if (e_flags
& EF_SPARC_32PLUS
)
1848 strcat (buf
, ", v8+");
1850 if (e_flags
& EF_SPARC_SUN_US1
)
1851 strcat (buf
, ", ultrasparcI");
1853 if (e_flags
& EF_SPARC_SUN_US3
)
1854 strcat (buf
, ", ultrasparcIII");
1856 if (e_flags
& EF_SPARC_HAL_R1
)
1857 strcat (buf
, ", halr1");
1859 if (e_flags
& EF_SPARC_LEDATA
)
1860 strcat (buf
, ", ledata");
1862 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1863 strcat (buf
, ", tso");
1865 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1866 strcat (buf
, ", pso");
1868 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1869 strcat (buf
, ", rmo");
1873 switch (e_flags
& EF_PARISC_ARCH
)
1875 case EFA_PARISC_1_0
:
1876 strcpy (buf
, ", PA-RISC 1.0");
1878 case EFA_PARISC_1_1
:
1879 strcpy (buf
, ", PA-RISC 1.1");
1881 case EFA_PARISC_2_0
:
1882 strcpy (buf
, ", PA-RISC 2.0");
1887 if (e_flags
& EF_PARISC_TRAPNIL
)
1888 strcat (buf
, ", trapnil");
1889 if (e_flags
& EF_PARISC_EXT
)
1890 strcat (buf
, ", ext");
1891 if (e_flags
& EF_PARISC_LSB
)
1892 strcat (buf
, ", lsb");
1893 if (e_flags
& EF_PARISC_WIDE
)
1894 strcat (buf
, ", wide");
1895 if (e_flags
& EF_PARISC_NO_KABP
)
1896 strcat (buf
, ", no kabp");
1897 if (e_flags
& EF_PARISC_LAZYSWAP
)
1898 strcat (buf
, ", lazyswap");
1903 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1904 strcat (buf
, ", new calling convention");
1906 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1907 strcat (buf
, ", gnu calling convention");
1911 if ((e_flags
& EF_IA_64_ABI64
))
1912 strcat (buf
, ", 64-bit");
1914 strcat (buf
, ", 32-bit");
1915 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1916 strcat (buf
, ", reduced fp model");
1917 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1918 strcat (buf
, ", no function descriptors, constant gp");
1919 else if ((e_flags
& EF_IA_64_CONS_GP
))
1920 strcat (buf
, ", constant gp");
1921 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1922 strcat (buf
, ", absolute");
1931 get_mips_segment_type (type
)
1936 case PT_MIPS_REGINFO
:
1938 case PT_MIPS_RTPROC
:
1940 case PT_MIPS_OPTIONS
:
1950 get_parisc_segment_type (type
)
1955 case PT_HP_TLS
: return "HP_TLS";
1956 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1957 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1958 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1959 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1960 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1961 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1962 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1963 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1964 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1965 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1966 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1967 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1968 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1977 get_ia64_segment_type (type
)
1982 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
1983 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
1984 case PT_HP_TLS
: return "HP_TLS";
1985 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
1986 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
1987 case PT_IA_64_HP_STACK
: return "HP_STACK";
1996 get_segment_type (p_type
)
1997 unsigned long p_type
;
1999 static char buff
[32];
2003 case PT_NULL
: return "NULL";
2004 case PT_LOAD
: return "LOAD";
2005 case PT_DYNAMIC
: return "DYNAMIC";
2006 case PT_INTERP
: return "INTERP";
2007 case PT_NOTE
: return "NOTE";
2008 case PT_SHLIB
: return "SHLIB";
2009 case PT_PHDR
: return "PHDR";
2010 case PT_TLS
: return "TLS";
2012 case PT_GNU_EH_FRAME
:
2013 return "GNU_EH_FRAME";
2016 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2018 const char * result
;
2020 switch (elf_header
.e_machine
)
2023 case EM_MIPS_RS3_LE
:
2024 result
= get_mips_segment_type (p_type
);
2027 result
= get_parisc_segment_type (p_type
);
2030 result
= get_ia64_segment_type (p_type
);
2040 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2042 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2044 const char * result
;
2046 switch (elf_header
.e_machine
)
2049 result
= get_parisc_segment_type (p_type
);
2052 result
= get_ia64_segment_type (p_type
);
2062 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2065 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2072 get_mips_section_type_name (sh_type
)
2073 unsigned int sh_type
;
2077 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2078 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2079 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2080 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2081 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2082 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2083 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2084 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2085 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2086 case SHT_MIPS_RELD
: return "MIPS_RELD";
2087 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2088 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2089 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2090 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2091 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2092 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2093 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2094 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2095 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2096 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2097 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2098 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2099 case SHT_MIPS_LINE
: return "MIPS_LINE";
2100 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2101 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2102 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2103 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2104 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2105 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2106 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2107 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2108 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2109 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2110 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2111 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2112 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2113 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2114 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2115 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2123 get_parisc_section_type_name (sh_type
)
2124 unsigned int sh_type
;
2128 case SHT_PARISC_EXT
: return "PARISC_EXT";
2129 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2130 case SHT_PARISC_DOC
: return "PARISC_DOC";
2138 get_ia64_section_type_name (sh_type
)
2139 unsigned int sh_type
;
2143 case SHT_IA_64_EXT
: return "IA_64_EXT";
2144 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2152 get_section_type_name (sh_type
)
2153 unsigned int sh_type
;
2155 static char buff
[32];
2159 case SHT_NULL
: return "NULL";
2160 case SHT_PROGBITS
: return "PROGBITS";
2161 case SHT_SYMTAB
: return "SYMTAB";
2162 case SHT_STRTAB
: return "STRTAB";
2163 case SHT_RELA
: return "RELA";
2164 case SHT_HASH
: return "HASH";
2165 case SHT_DYNAMIC
: return "DYNAMIC";
2166 case SHT_NOTE
: return "NOTE";
2167 case SHT_NOBITS
: return "NOBITS";
2168 case SHT_REL
: return "REL";
2169 case SHT_SHLIB
: return "SHLIB";
2170 case SHT_DYNSYM
: return "DYNSYM";
2171 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2172 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2173 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2174 case SHT_GROUP
: return "GROUP";
2175 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2176 case SHT_GNU_verdef
: return "VERDEF";
2177 case SHT_GNU_verneed
: return "VERNEED";
2178 case SHT_GNU_versym
: return "VERSYM";
2179 case 0x6ffffff0: return "VERSYM";
2180 case 0x6ffffffc: return "VERDEF";
2181 case 0x7ffffffd: return "AUXILIARY";
2182 case 0x7fffffff: return "FILTER";
2185 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2187 const char * result
;
2189 switch (elf_header
.e_machine
)
2192 case EM_MIPS_RS3_LE
:
2193 result
= get_mips_section_type_name (sh_type
);
2196 result
= get_parisc_section_type_name (sh_type
);
2199 result
= get_ia64_section_type_name (sh_type
);
2209 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2211 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2212 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2213 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2214 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2216 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2222 struct option options
[] =
2224 {"all", no_argument
, 0, 'a'},
2225 {"file-header", no_argument
, 0, 'h'},
2226 {"program-headers", no_argument
, 0, 'l'},
2227 {"headers", no_argument
, 0, 'e'},
2228 {"histogram", no_argument
, 0, 'I'},
2229 {"segments", no_argument
, 0, 'l'},
2230 {"sections", no_argument
, 0, 'S'},
2231 {"section-headers", no_argument
, 0, 'S'},
2232 {"symbols", no_argument
, 0, 's'},
2233 {"syms", no_argument
, 0, 's'},
2234 {"relocs", no_argument
, 0, 'r'},
2235 {"notes", no_argument
, 0, 'n'},
2236 {"dynamic", no_argument
, 0, 'd'},
2237 {"arch-specific", no_argument
, 0, 'A'},
2238 {"version-info", no_argument
, 0, 'V'},
2239 {"use-dynamic", no_argument
, 0, 'D'},
2240 {"hex-dump", required_argument
, 0, 'x'},
2241 {"debug-dump", optional_argument
, 0, 'w'},
2242 {"unwind", no_argument
, 0, 'u'},
2243 #ifdef SUPPORT_DISASSEMBLY
2244 {"instruction-dump", required_argument
, 0, 'i'},
2247 {"version", no_argument
, 0, 'v'},
2248 {"wide", no_argument
, 0, 'W'},
2249 {"help", no_argument
, 0, 'H'},
2250 {0, no_argument
, 0, 0}
2256 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2257 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2258 fprintf (stdout
, _(" Options are:\n\
2259 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2260 -h --file-header Display the ELF file header\n\
2261 -l --program-headers Display the program headers\n\
2262 --segments An alias for --program-headers\n\
2263 -S --section-headers Display the sections' header\n\
2264 --sections An alias for --section-headers\n\
2265 -e --headers Equivalent to: -h -l -S\n\
2266 -s --syms Display the symbol table\n\
2267 --symbols An alias for --syms\n\
2268 -n --notes Display the core notes (if present)\n\
2269 -r --relocs Display the relocations (if present)\n\
2270 -u --unwind Display the unwind info (if present)\n\
2271 -d --dynamic Display the dynamic segment (if present)\n\
2272 -V --version-info Display the version sections (if present)\n\
2273 -A --arch-specific Display architecture specific information (if any).\n\
2274 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2275 -x --hex-dump=<number> Dump the contents of section <number>\n\
2276 -w --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2277 Display the contents of DWARF2 debug sections\n"));
2278 #ifdef SUPPORT_DISASSEMBLY
2279 fprintf (stdout
, _("\
2280 -i --instruction-dump=<number>\n\
2281 Disassemble the contents of section <number>\n"));
2283 fprintf (stdout
, _("\
2284 -I --histogram Display histogram of bucket list lengths\n\
2285 -W --wide Allow output width to exceed 80 characters\n\
2286 -H --help Display this information\n\
2287 -v --version Display the version number of readelf\n"));
2288 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2294 request_dump (section
, type
)
2295 unsigned int section
;
2298 if (section
>= num_dump_sects
)
2300 char * new_dump_sects
;
2302 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2304 if (new_dump_sects
== NULL
)
2305 error (_("Out of memory allocating dump request table."));
2308 /* Copy current flag settings. */
2309 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2313 dump_sects
= new_dump_sects
;
2314 num_dump_sects
= section
+ 1;
2319 dump_sects
[section
] |= type
;
2325 parse_args (argc
, argv
)
2334 while ((c
= getopt_long
2335 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2371 do_using_dynamic
++;
2402 section
= strtoul (optarg
, & cp
, 0);
2403 if (! * cp
&& section
>= 0)
2405 request_dump (section
, HEX_DUMP
);
2415 unsigned int index
= 0;
2419 while (optarg
[index
])
2420 switch (optarg
[index
++])
2429 do_debug_abbrevs
= 1;
2439 do_debug_pubnames
= 1;
2444 do_debug_aranges
= 1;
2448 do_debug_frames_interp
= 1;
2450 do_debug_frames
= 1;
2455 do_debug_macinfo
= 1;
2469 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2474 #ifdef SUPPORT_DISASSEMBLY
2477 section
= strtoul (optarg
, & cp
, 0);
2478 if (! * cp
&& section
>= 0)
2480 request_dump (section
, DISASS_DUMP
);
2486 print_version (program_name
);
2496 /* xgettext:c-format */
2497 error (_("Invalid option '-%c'\n"), c
);
2504 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2505 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2506 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2510 warn (_("Nothing to do.\n"));
2516 get_elf_class (elf_class
)
2517 unsigned int elf_class
;
2519 static char buff
[32];
2523 case ELFCLASSNONE
: return _("none");
2524 case ELFCLASS32
: return "ELF32";
2525 case ELFCLASS64
: return "ELF64";
2527 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2533 get_data_encoding (encoding
)
2534 unsigned int encoding
;
2536 static char buff
[32];
2540 case ELFDATANONE
: return _("none");
2541 case ELFDATA2LSB
: return _("2's complement, little endian");
2542 case ELFDATA2MSB
: return _("2's complement, big endian");
2544 sprintf (buff
, _("<unknown: %x>"), encoding
);
2550 get_osabi_name (osabi
)
2553 static char buff
[32];
2557 case ELFOSABI_NONE
: return "UNIX - System V";
2558 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2559 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2560 case ELFOSABI_LINUX
: return "UNIX - Linux";
2561 case ELFOSABI_HURD
: return "GNU/Hurd";
2562 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2563 case ELFOSABI_AIX
: return "UNIX - AIX";
2564 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2565 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2566 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2567 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2568 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2569 case ELFOSABI_STANDALONE
: return _("Standalone App");
2570 case ELFOSABI_ARM
: return "ARM";
2572 sprintf (buff
, _("<unknown: %x>"), osabi
);
2577 /* Decode the data held in 'elf_header'. */
2579 process_file_header ()
2581 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2582 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2583 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2584 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2587 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2595 printf (_("ELF Header:\n"));
2596 printf (_(" Magic: "));
2597 for (i
= 0; i
< EI_NIDENT
; i
++)
2598 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2600 printf (_(" Class: %s\n"),
2601 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2602 printf (_(" Data: %s\n"),
2603 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2604 printf (_(" Version: %d %s\n"),
2605 elf_header
.e_ident
[EI_VERSION
],
2606 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2608 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2611 printf (_(" OS/ABI: %s\n"),
2612 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2613 printf (_(" ABI Version: %d\n"),
2614 elf_header
.e_ident
[EI_ABIVERSION
]);
2615 printf (_(" Type: %s\n"),
2616 get_file_type (elf_header
.e_type
));
2617 printf (_(" Machine: %s\n"),
2618 get_machine_name (elf_header
.e_machine
));
2619 printf (_(" Version: 0x%lx\n"),
2620 (unsigned long) elf_header
.e_version
);
2622 printf (_(" Entry point address: "));
2623 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2624 printf (_("\n Start of program headers: "));
2625 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2626 printf (_(" (bytes into file)\n Start of section headers: "));
2627 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2628 printf (_(" (bytes into file)\n"));
2630 printf (_(" Flags: 0x%lx%s\n"),
2631 (unsigned long) elf_header
.e_flags
,
2632 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2633 printf (_(" Size of this header: %ld (bytes)\n"),
2634 (long) elf_header
.e_ehsize
);
2635 printf (_(" Size of program headers: %ld (bytes)\n"),
2636 (long) elf_header
.e_phentsize
);
2637 printf (_(" Number of program headers: %ld\n"),
2638 (long) elf_header
.e_phnum
);
2639 printf (_(" Size of section headers: %ld (bytes)\n"),
2640 (long) elf_header
.e_shentsize
);
2641 printf (_(" Number of section headers: %ld"),
2642 (long) elf_header
.e_shnum
);
2643 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2644 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2645 putc ('\n', stdout
);
2646 printf (_(" Section header string table index: %ld"),
2647 (long) elf_header
.e_shstrndx
);
2648 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2649 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2650 putc ('\n', stdout
);
2653 if (section_headers
!= NULL
)
2655 if (elf_header
.e_shnum
== 0)
2656 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2657 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2658 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2659 free (section_headers
);
2660 section_headers
= NULL
;
2668 get_32bit_program_headers (file
, program_headers
)
2670 Elf_Internal_Phdr
* program_headers
;
2672 Elf32_External_Phdr
* phdrs
;
2673 Elf32_External_Phdr
* external
;
2674 Elf32_Internal_Phdr
* internal
;
2677 phdrs
= ((Elf32_External_Phdr
*)
2678 get_data (NULL
, file
, elf_header
.e_phoff
,
2679 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2680 _("program headers")));
2684 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2685 i
< elf_header
.e_phnum
;
2686 i
++, internal
++, external
++)
2688 internal
->p_type
= BYTE_GET (external
->p_type
);
2689 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2690 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2691 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2692 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2693 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2694 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2695 internal
->p_align
= BYTE_GET (external
->p_align
);
2704 get_64bit_program_headers (file
, program_headers
)
2706 Elf_Internal_Phdr
* program_headers
;
2708 Elf64_External_Phdr
* phdrs
;
2709 Elf64_External_Phdr
* external
;
2710 Elf64_Internal_Phdr
* internal
;
2713 phdrs
= ((Elf64_External_Phdr
*)
2714 get_data (NULL
, file
, elf_header
.e_phoff
,
2715 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2716 _("program headers")));
2720 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2721 i
< elf_header
.e_phnum
;
2722 i
++, internal
++, external
++)
2724 internal
->p_type
= BYTE_GET (external
->p_type
);
2725 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2726 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2727 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2728 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2729 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2730 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2731 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2740 process_program_headers (file
)
2743 Elf_Internal_Phdr
* program_headers
;
2744 Elf_Internal_Phdr
* segment
;
2747 if (elf_header
.e_phnum
== 0)
2750 printf (_("\nThere are no program headers in this file.\n"));
2754 if (do_segments
&& !do_header
)
2756 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2757 printf (_("Entry point "));
2758 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2759 printf (_("\nThere are %d program headers, starting at offset "),
2760 elf_header
.e_phnum
);
2761 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2765 program_headers
= (Elf_Internal_Phdr
*) malloc
2766 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2768 if (program_headers
== NULL
)
2770 error (_("Out of memory\n"));
2775 i
= get_32bit_program_headers (file
, program_headers
);
2777 i
= get_64bit_program_headers (file
, program_headers
);
2781 free (program_headers
);
2787 if (elf_header
.e_phnum
> 1)
2788 printf (_("\nProgram Headers:\n"));
2790 printf (_("\nProgram Headers:\n"));
2794 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2797 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2801 (_(" Type Offset VirtAddr PhysAddr\n"));
2803 (_(" FileSiz MemSiz Flags Align\n"));
2811 for (i
= 0, segment
= program_headers
;
2812 i
< elf_header
.e_phnum
;
2817 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2821 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2822 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2823 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2824 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2825 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2827 (segment
->p_flags
& PF_R
? 'R' : ' '),
2828 (segment
->p_flags
& PF_W
? 'W' : ' '),
2829 (segment
->p_flags
& PF_X
? 'E' : ' '));
2830 printf ("%#lx", (unsigned long) segment
->p_align
);
2834 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2835 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2838 print_vma (segment
->p_offset
, FULL_HEX
);
2842 print_vma (segment
->p_vaddr
, FULL_HEX
);
2844 print_vma (segment
->p_paddr
, FULL_HEX
);
2847 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
2848 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
2851 print_vma (segment
->p_filesz
, FULL_HEX
);
2855 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
2856 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
2859 print_vma (segment
->p_offset
, FULL_HEX
);
2863 (segment
->p_flags
& PF_R
? 'R' : ' '),
2864 (segment
->p_flags
& PF_W
? 'W' : ' '),
2865 (segment
->p_flags
& PF_X
? 'E' : ' '));
2867 if ((unsigned long) segment
->p_align
== segment
->p_align
)
2868 printf ("%#lx", (unsigned long) segment
->p_align
);
2871 print_vma (segment
->p_align
, PREFIX_HEX
);
2876 print_vma (segment
->p_offset
, FULL_HEX
);
2878 print_vma (segment
->p_vaddr
, FULL_HEX
);
2880 print_vma (segment
->p_paddr
, FULL_HEX
);
2882 print_vma (segment
->p_filesz
, FULL_HEX
);
2884 print_vma (segment
->p_memsz
, FULL_HEX
);
2886 (segment
->p_flags
& PF_R
? 'R' : ' '),
2887 (segment
->p_flags
& PF_W
? 'W' : ' '),
2888 (segment
->p_flags
& PF_X
? 'E' : ' '));
2889 print_vma (segment
->p_align
, HEX
);
2893 switch (segment
->p_type
)
2897 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2898 - (segment
->p_offset
& 0xfffff000);
2903 error (_("more than one dynamic segment\n"));
2905 dynamic_addr
= segment
->p_offset
;
2906 dynamic_size
= segment
->p_filesz
;
2910 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2911 error (_("Unable to find program interpreter name\n"));
2914 program_interpreter
[0] = 0;
2915 fscanf (file
, "%63s", program_interpreter
);
2918 printf (_("\n [Requesting program interpreter: %s]"),
2919 program_interpreter
);
2925 putc ('\n', stdout
);
2934 if (do_segments
&& section_headers
!= NULL
)
2936 printf (_("\n Section to Segment mapping:\n"));
2937 printf (_(" Segment Sections...\n"));
2939 assert (string_table
!= NULL
);
2941 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2944 Elf_Internal_Shdr
* section
;
2946 segment
= program_headers
+ i
;
2947 section
= section_headers
;
2949 printf (" %2.2d ", i
);
2951 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
2953 if (section
->sh_size
> 0
2954 /* Compare allocated sections by VMA, unallocated
2955 sections by file offset. */
2956 && (section
->sh_flags
& SHF_ALLOC
2957 ? (section
->sh_addr
>= segment
->p_vaddr
2958 && section
->sh_addr
+ section
->sh_size
2959 <= segment
->p_vaddr
+ segment
->p_memsz
)
2960 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2961 && (section
->sh_offset
+ section
->sh_size
2962 <= segment
->p_offset
+ segment
->p_filesz
))))
2963 printf ("%s ", SECTION_NAME (section
));
2970 free (program_headers
);
2977 get_32bit_section_headers (file
, num
)
2981 Elf32_External_Shdr
* shdrs
;
2982 Elf32_Internal_Shdr
* internal
;
2985 shdrs
= ((Elf32_External_Shdr
*)
2986 get_data (NULL
, file
, elf_header
.e_shoff
,
2987 elf_header
.e_shentsize
* num
,
2988 _("section headers")));
2992 section_headers
= ((Elf_Internal_Shdr
*)
2993 malloc (num
* sizeof (Elf_Internal_Shdr
)));
2995 if (section_headers
== NULL
)
2997 error (_("Out of memory\n"));
3001 for (i
= 0, internal
= section_headers
;
3005 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3006 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3007 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3008 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3009 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3010 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3011 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3012 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3013 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3014 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3023 get_64bit_section_headers (file
, num
)
3027 Elf64_External_Shdr
* shdrs
;
3028 Elf64_Internal_Shdr
* internal
;
3031 shdrs
= ((Elf64_External_Shdr
*)
3032 get_data (NULL
, file
, elf_header
.e_shoff
,
3033 elf_header
.e_shentsize
* num
,
3034 _("section headers")));
3038 section_headers
= ((Elf_Internal_Shdr
*)
3039 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3041 if (section_headers
== NULL
)
3043 error (_("Out of memory\n"));
3047 for (i
= 0, internal
= section_headers
;
3051 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3052 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3053 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3054 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3055 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3056 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3057 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3058 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3059 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3060 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3068 static Elf_Internal_Sym
*
3069 get_32bit_elf_symbols (file
, section
)
3071 Elf_Internal_Shdr
*section
;
3073 unsigned long number
;
3074 Elf32_External_Sym
* esyms
;
3075 Elf_External_Sym_Shndx
*shndx
;
3076 Elf_Internal_Sym
* isyms
;
3077 Elf_Internal_Sym
* psym
;
3080 esyms
= ((Elf32_External_Sym
*)
3081 get_data (NULL
, file
, section
->sh_offset
,
3082 section
->sh_size
, _("symbols")));
3087 if (symtab_shndx_hdr
!= NULL
3088 && (symtab_shndx_hdr
->sh_link
3089 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3091 shndx
= ((Elf_External_Sym_Shndx
*)
3092 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3093 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3101 number
= section
->sh_size
/ section
->sh_entsize
;
3102 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3106 error (_("Out of memory\n"));
3113 for (j
= 0, psym
= isyms
;
3117 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3118 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3119 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3120 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3121 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3123 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3124 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3125 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3135 static Elf_Internal_Sym
*
3136 get_64bit_elf_symbols (file
, section
)
3138 Elf_Internal_Shdr
*section
;
3140 unsigned long number
;
3141 Elf64_External_Sym
* esyms
;
3142 Elf_External_Sym_Shndx
*shndx
;
3143 Elf_Internal_Sym
* isyms
;
3144 Elf_Internal_Sym
* psym
;
3147 esyms
= ((Elf64_External_Sym
*)
3148 get_data (NULL
, file
, section
->sh_offset
,
3149 section
->sh_size
, _("symbols")));
3154 if (symtab_shndx_hdr
!= NULL
3155 && (symtab_shndx_hdr
->sh_link
3156 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3158 shndx
= ((Elf_External_Sym_Shndx
*)
3159 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3160 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3168 number
= section
->sh_size
/ section
->sh_entsize
;
3169 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3173 error (_("Out of memory\n"));
3180 for (j
= 0, psym
= isyms
;
3184 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3185 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3186 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3187 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3188 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3190 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3191 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3192 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3203 get_elf_section_flags (sh_flags
)
3206 static char buff
[32];
3214 flag
= sh_flags
& - sh_flags
;
3219 case SHF_WRITE
: strcat (buff
, "W"); break;
3220 case SHF_ALLOC
: strcat (buff
, "A"); break;
3221 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3222 case SHF_MERGE
: strcat (buff
, "M"); break;
3223 case SHF_STRINGS
: strcat (buff
, "S"); break;
3224 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3225 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3226 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3227 case SHF_GROUP
: strcat (buff
, "G"); break;
3228 case SHF_TLS
: strcat (buff
, "T"); break;
3231 if (flag
& SHF_MASKOS
)
3234 sh_flags
&= ~ SHF_MASKOS
;
3236 else if (flag
& SHF_MASKPROC
)
3239 sh_flags
&= ~ SHF_MASKPROC
;
3251 process_section_headers (file
)
3254 Elf_Internal_Shdr
* section
;
3257 section_headers
= NULL
;
3259 if (elf_header
.e_shnum
== 0)
3262 printf (_("\nThere are no sections in this file.\n"));
3267 if (do_sections
&& !do_header
)
3268 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3269 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3273 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3276 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3279 /* Read in the string table, so that we have names to display. */
3280 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3282 if (section
->sh_size
!= 0)
3284 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3285 section
->sh_size
, _("string table"));
3287 string_table_length
= section
->sh_size
;
3290 /* Scan the sections for the dynamic symbol table
3291 and dynamic string table and debug sections. */
3292 dynamic_symbols
= NULL
;
3293 dynamic_strings
= NULL
;
3294 dynamic_syminfo
= NULL
;
3296 for (i
= 0, section
= section_headers
;
3297 i
< elf_header
.e_shnum
;
3300 char * name
= SECTION_NAME (section
);
3302 if (section
->sh_type
== SHT_DYNSYM
)
3304 if (dynamic_symbols
!= NULL
)
3306 error (_("File contains multiple dynamic symbol tables\n"));
3310 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3311 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3313 else if (section
->sh_type
== SHT_STRTAB
3314 && strcmp (name
, ".dynstr") == 0)
3316 if (dynamic_strings
!= NULL
)
3318 error (_("File contains multiple dynamic string tables\n"));
3322 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3324 _("dynamic strings"));
3326 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3328 if (symtab_shndx_hdr
!= NULL
)
3330 error (_("File contains multiple symtab shndx tables\n"));
3333 symtab_shndx_hdr
= section
;
3335 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3336 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3337 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3339 && strncmp (name
, ".debug_", 7) == 0)
3344 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3345 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3346 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3347 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3348 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3349 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3350 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3351 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3352 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3354 request_dump (i
, DEBUG_DUMP
);
3356 /* linkonce section to be combined with .debug_info at link time. */
3357 else if ((do_debugging
|| do_debug_info
)
3358 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3359 request_dump (i
, DEBUG_DUMP
);
3360 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3361 request_dump (i
, DEBUG_DUMP
);
3367 if (elf_header
.e_shnum
> 1)
3368 printf (_("\nSection Headers:\n"));
3370 printf (_("\nSection Header:\n"));
3374 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3377 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3380 printf (_(" [Nr] Name Type Address Offset\n"));
3381 printf (_(" Size EntSize Flags Link Info Align\n"));
3384 for (i
= 0, section
= section_headers
;
3385 i
< elf_header
.e_shnum
;
3388 printf (" [%2u] %-17.17s %-15.15s ",
3389 SECTION_HEADER_NUM (i
),
3390 SECTION_NAME (section
),
3391 get_section_type_name (section
->sh_type
));
3395 print_vma (section
->sh_addr
, LONG_HEX
);
3397 printf ( " %6.6lx %6.6lx %2.2lx",
3398 (unsigned long) section
->sh_offset
,
3399 (unsigned long) section
->sh_size
,
3400 (unsigned long) section
->sh_entsize
);
3402 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3404 printf ("%2ld %3lx %2ld\n",
3405 (unsigned long) section
->sh_link
,
3406 (unsigned long) section
->sh_info
,
3407 (unsigned long) section
->sh_addralign
);
3411 print_vma (section
->sh_addr
, LONG_HEX
);
3413 if ((long) section
->sh_offset
== section
->sh_offset
)
3414 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3418 print_vma (section
->sh_offset
, LONG_HEX
);
3421 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3422 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3426 print_vma (section
->sh_size
, LONG_HEX
);
3429 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3430 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3434 print_vma (section
->sh_entsize
, LONG_HEX
);
3437 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3439 printf ("%2ld %3lx ",
3440 (unsigned long) section
->sh_link
,
3441 (unsigned long) section
->sh_info
);
3443 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3444 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3447 print_vma (section
->sh_addralign
, DEC
);
3454 print_vma (section
->sh_addr
, LONG_HEX
);
3455 if ((long) section
->sh_offset
== section
->sh_offset
)
3456 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3460 print_vma (section
->sh_offset
, LONG_HEX
);
3463 print_vma (section
->sh_size
, LONG_HEX
);
3465 print_vma (section
->sh_entsize
, LONG_HEX
);
3467 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3469 printf (" %2ld %3lx %ld\n",
3470 (unsigned long) section
->sh_link
,
3471 (unsigned long) section
->sh_info
,
3472 (unsigned long) section
->sh_addralign
);
3476 printf (_("Key to Flags:\n\
3477 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3478 I (info), L (link order), G (group), x (unknown)\n\
3479 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3484 /* Process the reloc section. */
3486 process_relocs (file
)
3489 unsigned long rel_size
;
3490 unsigned long rel_offset
;
3496 if (do_using_dynamic
)
3498 int is_rela
= FALSE
;
3503 if (dynamic_info
[DT_REL
])
3505 rel_offset
= dynamic_info
[DT_REL
];
3506 rel_size
= dynamic_info
[DT_RELSZ
];
3509 else if (dynamic_info
[DT_RELA
])
3511 rel_offset
= dynamic_info
[DT_RELA
];
3512 rel_size
= dynamic_info
[DT_RELASZ
];
3515 else if (dynamic_info
[DT_JMPREL
])
3517 rel_offset
= dynamic_info
[DT_JMPREL
];
3518 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3520 switch (dynamic_info
[DT_PLTREL
])
3537 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3538 rel_offset
, rel_size
);
3540 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3541 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3544 printf (_("\nThere are no dynamic relocations in this file.\n"));
3548 Elf32_Internal_Shdr
* section
;
3552 for (i
= 0, section
= section_headers
;
3553 i
< elf_header
.e_shnum
;
3556 if ( section
->sh_type
!= SHT_RELA
3557 && section
->sh_type
!= SHT_REL
)
3560 rel_offset
= section
->sh_offset
;
3561 rel_size
= section
->sh_size
;
3565 Elf32_Internal_Shdr
* strsec
;
3566 Elf_Internal_Sym
* symtab
;
3569 unsigned long nsyms
;
3571 printf (_("\nRelocation section "));
3573 if (string_table
== NULL
)
3574 printf ("%d", section
->sh_name
);
3576 printf (_("'%s'"), SECTION_NAME (section
));
3578 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3579 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3584 if (section
->sh_link
)
3586 Elf32_Internal_Shdr
* symsec
;
3588 symsec
= SECTION_HEADER (section
->sh_link
);
3589 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3590 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3595 strsec
= SECTION_HEADER (symsec
->sh_link
);
3597 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3601 is_rela
= section
->sh_type
== SHT_RELA
;
3603 dump_relocations (file
, rel_offset
, rel_size
,
3604 symtab
, nsyms
, strtab
, is_rela
);
3616 printf (_("\nThere are no relocations in this file.\n"));
3622 #include "unwind-ia64.h"
3624 /* An absolute address consists of a section and an offset. If the
3625 section is NULL, the offset itself is the address, otherwise, the
3626 address equals to LOAD_ADDRESS(section) + offset. */
3630 unsigned short section
;
3636 struct unw_table_entry
3638 struct absaddr start
;
3640 struct absaddr info
;
3642 *table
; /* Unwind table. */
3643 unsigned long table_len
; /* Length of unwind table. */
3644 unsigned char * info
; /* Unwind info. */
3645 unsigned long info_size
; /* Size of unwind info. */
3646 bfd_vma info_addr
; /* starting address of unwind info. */
3647 bfd_vma seg_base
; /* Starting address of segment. */
3648 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3649 unsigned long nsyms
; /* Number of symbols. */
3650 char * strtab
; /* The string table. */
3651 unsigned long strtab_size
; /* Size of string table. */
3654 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3655 struct absaddr
, const char **,
3657 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3658 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3659 Elf32_Internal_Shdr
*));
3662 find_symbol_for_address (aux
, addr
, symname
, offset
)
3663 struct unw_aux_info
*aux
;
3664 struct absaddr addr
;
3665 const char **symname
;
3668 bfd_vma dist
= (bfd_vma
) 0x100000;
3669 Elf_Internal_Sym
*sym
, *best
= NULL
;
3672 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3674 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3675 && sym
->st_name
!= 0
3676 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3677 && addr
.offset
>= sym
->st_value
3678 && addr
.offset
- sym
->st_value
< dist
)
3681 dist
= addr
.offset
- sym
->st_value
;
3688 *symname
= (best
->st_name
>= aux
->strtab_size
3689 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3694 *offset
= addr
.offset
;
3698 dump_ia64_unwind (aux
)
3699 struct unw_aux_info
*aux
;
3702 struct unw_table_entry
* tp
;
3705 addr_size
= is_32bit_elf
? 4 : 8;
3707 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3711 const unsigned char * dp
;
3712 const unsigned char * head
;
3713 const char * procname
;
3715 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3717 fputs ("\n<", stdout
);
3721 fputs (procname
, stdout
);
3724 printf ("+%lx", (unsigned long) offset
);
3727 fputs (">: [", stdout
);
3728 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3729 fputc ('-', stdout
);
3730 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3731 printf ("), info at +0x%lx\n",
3732 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3734 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3735 stamp
= BYTE_GET8 ((unsigned char *) head
);
3737 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3738 (unsigned) UNW_VER (stamp
),
3739 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3740 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3741 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3742 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3744 if (UNW_VER (stamp
) != 1)
3746 printf ("\tUnknown version.\n");
3751 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3752 dp
= unw_decode (dp
, in_body
, & in_body
);
3757 slurp_ia64_unwind_table (file
, aux
, sec
)
3759 struct unw_aux_info
*aux
;
3760 Elf32_Internal_Shdr
*sec
;
3762 unsigned long size
, addr_size
, nrelas
, i
;
3763 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3764 struct unw_table_entry
*tep
;
3765 Elf32_Internal_Shdr
*relsec
;
3766 Elf_Internal_Rela
*rela
, *rp
;
3767 unsigned char *table
, *tp
;
3768 Elf_Internal_Sym
*sym
;
3769 const char *relname
;
3772 addr_size
= is_32bit_elf
? 4 : 8;
3774 /* First, find the starting address of the segment that includes
3777 if (elf_header
.e_phnum
)
3779 prog_hdrs
= (Elf_Internal_Phdr
*)
3780 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3783 result
= get_32bit_program_headers (file
, prog_hdrs
);
3785 result
= get_64bit_program_headers (file
, prog_hdrs
);
3793 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3795 if (seg
->p_type
!= PT_LOAD
)
3798 if (sec
->sh_addr
>= seg
->p_vaddr
3799 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3801 aux
->seg_base
= seg
->p_vaddr
;
3809 /* Second, build the unwind table from the contents of the unwind section: */
3810 size
= sec
->sh_size
;
3811 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3812 size
, _("unwind table"));
3816 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3817 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3819 tep
->start
.section
= SHN_UNDEF
;
3820 tep
->end
.section
= SHN_UNDEF
;
3821 tep
->info
.section
= SHN_UNDEF
;
3824 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3825 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3826 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3830 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3831 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3832 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3834 tep
->start
.offset
+= aux
->seg_base
;
3835 tep
->end
.offset
+= aux
->seg_base
;
3836 tep
->info
.offset
+= aux
->seg_base
;
3840 /* Third, apply any relocations to the unwind table: */
3842 for (relsec
= section_headers
;
3843 relsec
< section_headers
+ elf_header
.e_shnum
;
3846 if (relsec
->sh_type
!= SHT_RELA
3847 || SECTION_HEADER (relsec
->sh_info
) != sec
)
3850 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3854 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3858 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3859 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3861 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3863 warn (_("Skipping unexpected symbol type %u\n"),
3864 ELF32_ST_TYPE (sym
->st_info
));
3870 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3871 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3873 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3875 warn (_("Skipping unexpected symbol type %u\n"),
3876 ELF64_ST_TYPE (sym
->st_info
));
3881 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
3883 warn (_("Skipping unexpected relocation type %s\n"), relname
);
3887 i
= rp
->r_offset
/ (3 * addr_size
);
3889 switch (rp
->r_offset
/addr_size
% 3)
3892 aux
->table
[i
].start
.section
= sym
->st_shndx
;
3893 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
3896 aux
->table
[i
].end
.section
= sym
->st_shndx
;
3897 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
3900 aux
->table
[i
].info
.section
= sym
->st_shndx
;
3901 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
3911 aux
->table_len
= size
/ (3 * addr_size
);
3916 process_unwind (file
)
3919 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
3920 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
3921 struct unw_aux_info aux
;
3926 if (elf_header
.e_machine
!= EM_IA_64
)
3928 printf (_("\nThere are no unwind sections in this file.\n"));
3932 memset (& aux
, 0, sizeof (aux
));
3934 addr_size
= is_32bit_elf
? 4 : 8;
3936 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
3938 if (sec
->sh_type
== SHT_SYMTAB
)
3940 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
3941 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
3943 strsec
= SECTION_HEADER (sec
->sh_link
);
3944 aux
.strtab_size
= strsec
->sh_size
;
3945 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3946 aux
.strtab_size
, _("string table"));
3948 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3953 printf (_("\nThere are no unwind sections in this file.\n"));
3955 while (unwcount
-- > 0)
3960 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
3961 i
< elf_header
.e_shnum
; ++i
, ++sec
)
3962 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3969 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
3971 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
3974 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3975 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
3976 suffix
= SECTION_NAME (unwsec
) + len
;
3977 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3979 if (strncmp (SECTION_NAME (sec
),
3980 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
3981 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3986 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3987 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3988 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
3989 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
3991 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
3993 suffix
= SECTION_NAME (unwsec
) + len
;
3994 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3996 if (strncmp (SECTION_NAME (sec
),
3997 ELF_STRING_ia64_unwind_info
, len2
) == 0
3998 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4002 if (i
== elf_header
.e_shnum
)
4004 printf (_("\nCould not find unwind info section for "));
4006 if (string_table
== NULL
)
4007 printf ("%d", unwsec
->sh_name
);
4009 printf (_("'%s'"), SECTION_NAME (unwsec
));
4013 aux
.info_size
= sec
->sh_size
;
4014 aux
.info_addr
= sec
->sh_addr
;
4015 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4016 aux
.info_size
, _("unwind info"));
4018 printf (_("\nUnwind section "));
4020 if (string_table
== NULL
)
4021 printf ("%d", unwsec
->sh_name
);
4023 printf (_("'%s'"), SECTION_NAME (unwsec
));
4025 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4026 (unsigned long) unwsec
->sh_offset
,
4027 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4029 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4031 if (aux
.table_len
> 0)
4032 dump_ia64_unwind (& aux
);
4035 free ((char *) aux
.table
);
4037 free ((char *) aux
.info
);
4046 free ((char *) aux
.strtab
);
4052 dynamic_segment_mips_val (entry
)
4053 Elf_Internal_Dyn
* entry
;
4055 switch (entry
->d_tag
)
4058 if (entry
->d_un
.d_val
== 0)
4062 static const char * opts
[] =
4064 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4065 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4066 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4067 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4072 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
4073 if (entry
->d_un
.d_val
& (1 << cnt
))
4075 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4082 case DT_MIPS_IVERSION
:
4083 if (dynamic_strings
!= NULL
)
4084 printf ("Interface Version: %s\n",
4085 dynamic_strings
+ entry
->d_un
.d_val
);
4087 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4090 case DT_MIPS_TIME_STAMP
:
4095 time_t time
= entry
->d_un
.d_val
;
4096 tmp
= gmtime (&time
);
4097 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4098 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4099 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4100 printf ("Time Stamp: %s\n", timebuf
);
4104 case DT_MIPS_RLD_VERSION
:
4105 case DT_MIPS_LOCAL_GOTNO
:
4106 case DT_MIPS_CONFLICTNO
:
4107 case DT_MIPS_LIBLISTNO
:
4108 case DT_MIPS_SYMTABNO
:
4109 case DT_MIPS_UNREFEXTNO
:
4110 case DT_MIPS_HIPAGENO
:
4111 case DT_MIPS_DELTA_CLASS_NO
:
4112 case DT_MIPS_DELTA_INSTANCE_NO
:
4113 case DT_MIPS_DELTA_RELOC_NO
:
4114 case DT_MIPS_DELTA_SYM_NO
:
4115 case DT_MIPS_DELTA_CLASSSYM_NO
:
4116 case DT_MIPS_COMPACT_SIZE
:
4117 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4121 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4127 dynamic_segment_parisc_val (entry
)
4128 Elf_Internal_Dyn
* entry
;
4130 switch (entry
->d_tag
)
4132 case DT_HP_DLD_FLAGS
:
4141 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4142 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4143 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4144 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4145 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4146 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4147 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4148 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4149 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4150 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4151 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4155 bfd_vma val
= entry
->d_un
.d_val
;
4157 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4158 if (val
& flags
[cnt
].bit
)
4162 fputs (flags
[cnt
].str
, stdout
);
4164 val
^= flags
[cnt
].bit
;
4167 if (val
!= 0 || first
)
4171 print_vma (val
, HEX
);
4177 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4183 get_32bit_dynamic_segment (file
)
4186 Elf32_External_Dyn
* edyn
;
4187 Elf_Internal_Dyn
* entry
;
4190 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4191 dynamic_size
, _("dynamic segment"));
4195 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4196 how large this .dynamic is now. We can do this even before the byte
4197 swapping since the DT_NULL tag is recognizable. */
4199 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4202 dynamic_segment
= (Elf_Internal_Dyn
*)
4203 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4205 if (dynamic_segment
== NULL
)
4207 error (_("Out of memory\n"));
4212 for (i
= 0, entry
= dynamic_segment
;
4216 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4217 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4226 get_64bit_dynamic_segment (file
)
4229 Elf64_External_Dyn
* edyn
;
4230 Elf_Internal_Dyn
* entry
;
4233 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4234 dynamic_size
, _("dynamic segment"));
4238 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4239 how large this .dynamic is now. We can do this even before the byte
4240 swapping since the DT_NULL tag is recognizable. */
4242 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4245 dynamic_segment
= (Elf_Internal_Dyn
*)
4246 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4248 if (dynamic_segment
== NULL
)
4250 error (_("Out of memory\n"));
4255 for (i
= 0, entry
= dynamic_segment
;
4259 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4260 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4269 get_dynamic_flags (flags
)
4272 static char buff
[128];
4280 flag
= flags
& - flags
;
4288 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4289 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4290 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4291 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4292 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4293 default: strcpy (p
, "unknown"); break;
4296 p
= strchr (p
, '\0');
4301 /* Parse and display the contents of the dynamic segment. */
4303 process_dynamic_segment (file
)
4306 Elf_Internal_Dyn
* entry
;
4309 if (dynamic_size
== 0)
4312 printf (_("\nThere is no dynamic segment in this file.\n"));
4319 if (! get_32bit_dynamic_segment (file
))
4322 else if (! get_64bit_dynamic_segment (file
))
4325 /* Find the appropriate symbol table. */
4326 if (dynamic_symbols
== NULL
)
4328 for (i
= 0, entry
= dynamic_segment
;
4332 Elf32_Internal_Shdr section
;
4334 if (entry
->d_tag
!= DT_SYMTAB
)
4337 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4339 /* Since we do not know how big the symbol table is,
4340 we default to reading in the entire file (!) and
4341 processing that. This is overkill, I know, but it
4343 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4345 if (fseek (file
, 0, SEEK_END
))
4346 error (_("Unable to seek to end of file!"));
4348 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4350 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4352 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4354 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4355 if (num_dynamic_syms
< 1)
4357 error (_("Unable to determine the number of symbols to load\n"));
4361 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4365 /* Similarly find a string table. */
4366 if (dynamic_strings
== NULL
)
4368 for (i
= 0, entry
= dynamic_segment
;
4372 unsigned long offset
;
4375 if (entry
->d_tag
!= DT_STRTAB
)
4378 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4380 /* Since we do not know how big the string table is,
4381 we default to reading in the entire file (!) and
4382 processing that. This is overkill, I know, but it
4385 offset
= entry
->d_un
.d_val
- loadaddr
;
4386 if (fseek (file
, 0, SEEK_END
))
4387 error (_("Unable to seek to end of file\n"));
4388 str_tab_len
= ftell (file
) - offset
;
4390 if (str_tab_len
< 1)
4393 (_("Unable to determine the length of the dynamic string table\n"));
4397 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4398 _("dynamic string table"));
4403 /* And find the syminfo section if available. */
4404 if (dynamic_syminfo
== NULL
)
4406 unsigned int syminsz
= 0;
4408 for (i
= 0, entry
= dynamic_segment
;
4412 if (entry
->d_tag
== DT_SYMINENT
)
4414 /* Note: these braces are necessary to avoid a syntax
4415 error from the SunOS4 C compiler. */
4416 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4418 else if (entry
->d_tag
== DT_SYMINSZ
)
4419 syminsz
= entry
->d_un
.d_val
;
4420 else if (entry
->d_tag
== DT_SYMINFO
)
4421 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4424 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4426 Elf_External_Syminfo
* extsyminfo
;
4427 Elf_Internal_Syminfo
* syminfo
;
4429 /* There is a syminfo section. Read the data. */
4430 extsyminfo
= ((Elf_External_Syminfo
*)
4431 get_data (NULL
, file
, dynamic_syminfo_offset
,
4432 syminsz
, _("symbol information")));
4436 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4437 if (dynamic_syminfo
== NULL
)
4439 error (_("Out of memory\n"));
4443 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4444 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4447 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4448 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4455 if (do_dynamic
&& dynamic_addr
)
4456 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4457 dynamic_addr
, (long) dynamic_size
);
4459 printf (_(" Tag Type Name/Value\n"));
4461 for (i
= 0, entry
= dynamic_segment
;
4470 print_vma (entry
->d_tag
, FULL_HEX
);
4471 dtype
= get_dynamic_type (entry
->d_tag
);
4472 printf (" (%s)%*s", dtype
,
4473 ((is_32bit_elf
? 27 : 19)
4474 - (int) strlen (dtype
)),
4478 switch (entry
->d_tag
)
4482 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4492 switch (entry
->d_tag
)
4495 printf (_("Auxiliary library"));
4499 printf (_("Filter library"));
4503 printf (_("Configuration file"));
4507 printf (_("Dependency audit library"));
4511 printf (_("Audit library"));
4515 if (dynamic_strings
)
4516 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4520 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4529 printf (_("Flags:"));
4530 if (entry
->d_un
.d_val
== 0)
4531 printf (_(" None\n"));
4534 unsigned long int val
= entry
->d_un
.d_val
;
4535 if (val
& DTF_1_PARINIT
)
4537 printf (" PARINIT");
4538 val
^= DTF_1_PARINIT
;
4540 if (val
& DTF_1_CONFEXP
)
4542 printf (" CONFEXP");
4543 val
^= DTF_1_CONFEXP
;
4546 printf (" %lx", val
);
4555 printf (_("Flags:"));
4556 if (entry
->d_un
.d_val
== 0)
4557 printf (_(" None\n"));
4560 unsigned long int val
= entry
->d_un
.d_val
;
4561 if (val
& DF_P1_LAZYLOAD
)
4563 printf (" LAZYLOAD");
4564 val
^= DF_P1_LAZYLOAD
;
4566 if (val
& DF_P1_GROUPPERM
)
4568 printf (" GROUPPERM");
4569 val
^= DF_P1_GROUPPERM
;
4572 printf (" %lx", val
);
4581 printf (_("Flags:"));
4582 if (entry
->d_un
.d_val
== 0)
4583 printf (_(" None\n"));
4586 unsigned long int val
= entry
->d_un
.d_val
;
4592 if (val
& DF_1_GLOBAL
)
4597 if (val
& DF_1_GROUP
)
4602 if (val
& DF_1_NODELETE
)
4604 printf (" NODELETE");
4605 val
^= DF_1_NODELETE
;
4607 if (val
& DF_1_LOADFLTR
)
4609 printf (" LOADFLTR");
4610 val
^= DF_1_LOADFLTR
;
4612 if (val
& DF_1_INITFIRST
)
4614 printf (" INITFIRST");
4615 val
^= DF_1_INITFIRST
;
4617 if (val
& DF_1_NOOPEN
)
4622 if (val
& DF_1_ORIGIN
)
4627 if (val
& DF_1_DIRECT
)
4632 if (val
& DF_1_TRANS
)
4637 if (val
& DF_1_INTERPOSE
)
4639 printf (" INTERPOSE");
4640 val
^= DF_1_INTERPOSE
;
4642 if (val
& DF_1_NODEFLIB
)
4644 printf (" NODEFLIB");
4645 val
^= DF_1_NODEFLIB
;
4647 if (val
& DF_1_NODUMP
)
4652 if (val
& DF_1_CONLFAT
)
4654 printf (" CONLFAT");
4655 val
^= DF_1_CONLFAT
;
4658 printf (" %lx", val
);
4666 puts (get_dynamic_type (entry
->d_un
.d_val
));
4686 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4692 if (dynamic_strings
== NULL
)
4695 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4699 switch (entry
->d_tag
)
4702 printf (_("Shared library: [%s]"), name
);
4704 if (strcmp (name
, program_interpreter
) == 0)
4705 printf (_(" program interpreter"));
4709 printf (_("Library soname: [%s]"), name
);
4713 printf (_("Library rpath: [%s]"), name
);
4717 printf (_("Library runpath: [%s]"), name
);
4721 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4726 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4742 case DT_INIT_ARRAYSZ
:
4743 case DT_FINI_ARRAYSZ
:
4746 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4747 printf (" (bytes)\n");
4757 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4770 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4774 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4778 printf (_("Not needed object: [%s]\n"), name
);
4783 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4789 /* The value of this entry is ignored. */
4793 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4794 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4799 switch (elf_header
.e_machine
)
4802 case EM_MIPS_RS3_LE
:
4803 dynamic_segment_mips_val (entry
);
4806 dynamic_segment_parisc_val (entry
);
4809 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4821 get_ver_flags (flags
)
4824 static char buff
[32];
4831 if (flags
& VER_FLG_BASE
)
4832 strcat (buff
, "BASE ");
4834 if (flags
& VER_FLG_WEAK
)
4836 if (flags
& VER_FLG_BASE
)
4837 strcat (buff
, "| ");
4839 strcat (buff
, "WEAK ");
4842 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4843 strcat (buff
, "| <unknown>");
4848 /* Display the contents of the version sections. */
4850 process_version_sections (file
)
4853 Elf32_Internal_Shdr
* section
;
4860 for (i
= 0, section
= section_headers
;
4861 i
< elf_header
.e_shnum
;
4864 switch (section
->sh_type
)
4866 case SHT_GNU_verdef
:
4868 Elf_External_Verdef
* edefs
;
4875 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4876 SECTION_NAME (section
), section
->sh_info
);
4878 printf (_(" Addr: 0x"));
4879 printf_vma (section
->sh_addr
);
4880 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4881 (unsigned long) section
->sh_offset
, section
->sh_link
,
4882 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
4884 edefs
= ((Elf_External_Verdef
*)
4885 get_data (NULL
, file
, section
->sh_offset
,
4887 _("version definition section")));
4891 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
4894 Elf_External_Verdef
* edef
;
4895 Elf_Internal_Verdef ent
;
4896 Elf_External_Verdaux
* eaux
;
4897 Elf_Internal_Verdaux aux
;
4901 vstart
= ((char *) edefs
) + idx
;
4903 edef
= (Elf_External_Verdef
*) vstart
;
4905 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
4906 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
4907 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
4908 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
4909 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
4910 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
4911 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
4913 printf (_(" %#06x: Rev: %d Flags: %s"),
4914 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
4916 printf (_(" Index: %d Cnt: %d "),
4917 ent
.vd_ndx
, ent
.vd_cnt
);
4919 vstart
+= ent
.vd_aux
;
4921 eaux
= (Elf_External_Verdaux
*) vstart
;
4923 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4924 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4926 if (dynamic_strings
)
4927 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
4929 printf (_("Name index: %ld\n"), aux
.vda_name
);
4931 isum
= idx
+ ent
.vd_aux
;
4933 for (j
= 1; j
< ent
.vd_cnt
; j
++)
4935 isum
+= aux
.vda_next
;
4936 vstart
+= aux
.vda_next
;
4938 eaux
= (Elf_External_Verdaux
*) vstart
;
4940 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4941 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4943 if (dynamic_strings
)
4944 printf (_(" %#06x: Parent %d: %s\n"),
4945 isum
, j
, dynamic_strings
+ aux
.vda_name
);
4947 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4948 isum
, j
, aux
.vda_name
);
4958 case SHT_GNU_verneed
:
4960 Elf_External_Verneed
* eneed
;
4966 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4967 SECTION_NAME (section
), section
->sh_info
);
4969 printf (_(" Addr: 0x"));
4970 printf_vma (section
->sh_addr
);
4971 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4972 (unsigned long) section
->sh_offset
, section
->sh_link
,
4973 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
4975 eneed
= ((Elf_External_Verneed
*)
4976 get_data (NULL
, file
, section
->sh_offset
,
4977 section
->sh_size
, _("version need section")));
4981 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
4983 Elf_External_Verneed
* entry
;
4984 Elf_Internal_Verneed ent
;
4989 vstart
= ((char *) eneed
) + idx
;
4991 entry
= (Elf_External_Verneed
*) vstart
;
4993 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
4994 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
4995 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
4996 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
4997 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
4999 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5001 if (dynamic_strings
)
5002 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5004 printf (_(" File: %lx"), ent
.vn_file
);
5006 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5008 vstart
+= ent
.vn_aux
;
5010 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5012 Elf_External_Vernaux
* eaux
;
5013 Elf_Internal_Vernaux aux
;
5015 eaux
= (Elf_External_Vernaux
*) vstart
;
5017 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5018 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5019 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5020 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5021 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5023 if (dynamic_strings
)
5024 printf (_(" %#06x: Name: %s"),
5025 isum
, dynamic_strings
+ aux
.vna_name
);
5027 printf (_(" %#06x: Name index: %lx"),
5028 isum
, aux
.vna_name
);
5030 printf (_(" Flags: %s Version: %d\n"),
5031 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5033 isum
+= aux
.vna_next
;
5034 vstart
+= aux
.vna_next
;
5044 case SHT_GNU_versym
:
5046 Elf32_Internal_Shdr
* link_section
;
5049 unsigned char * edata
;
5050 unsigned short * data
;
5052 Elf_Internal_Sym
* symbols
;
5053 Elf32_Internal_Shdr
* string_sec
;
5055 link_section
= SECTION_HEADER (section
->sh_link
);
5056 total
= section
->sh_size
/ section
->sh_entsize
;
5060 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5062 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5064 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5065 string_sec
->sh_size
,
5066 _("version string table"));
5070 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5071 SECTION_NAME (section
), total
);
5073 printf (_(" Addr: "));
5074 printf_vma (section
->sh_addr
);
5075 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5076 (unsigned long) section
->sh_offset
, section
->sh_link
,
5077 SECTION_NAME (link_section
));
5081 get_data (NULL
, file
,
5082 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5083 total
* sizeof (short), _("version symbol data")));
5090 data
= (unsigned short *) malloc (total
* sizeof (short));
5092 for (cnt
= total
; cnt
--;)
5093 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5098 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5101 int check_def
, check_need
;
5104 printf (" %03x:", cnt
);
5106 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5107 switch (data
[cnt
+ j
])
5110 fputs (_(" 0 (*local*) "), stdout
);
5114 fputs (_(" 1 (*global*) "), stdout
);
5118 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5119 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5123 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5126 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5133 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5135 Elf_Internal_Verneed ivn
;
5136 unsigned long offset
;
5138 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5143 Elf_Internal_Vernaux ivna
;
5144 Elf_External_Verneed evn
;
5145 Elf_External_Vernaux evna
;
5146 unsigned long a_off
;
5148 get_data (&evn
, file
, offset
, sizeof (evn
),
5151 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5152 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5154 a_off
= offset
+ ivn
.vn_aux
;
5158 get_data (&evna
, file
, a_off
, sizeof (evna
),
5159 _("version need aux (2)"));
5161 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5162 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5164 a_off
+= ivna
.vna_next
;
5166 while (ivna
.vna_other
!= data
[cnt
+ j
]
5167 && ivna
.vna_next
!= 0);
5169 if (ivna
.vna_other
== data
[cnt
+ j
])
5171 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5173 name
= strtab
+ ivna
.vna_name
;
5174 nn
+= printf ("(%s%-*s",
5176 12 - (int) strlen (name
),
5182 offset
+= ivn
.vn_next
;
5184 while (ivn
.vn_next
);
5187 if (check_def
&& data
[cnt
+ j
] != 0x8001
5188 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5190 Elf_Internal_Verdef ivd
;
5191 Elf_External_Verdef evd
;
5192 unsigned long offset
;
5194 offset
= version_info
5195 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
5199 get_data (&evd
, file
, offset
, sizeof (evd
),
5202 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5203 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5205 offset
+= ivd
.vd_next
;
5207 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5208 && ivd
.vd_next
!= 0);
5210 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5212 Elf_External_Verdaux evda
;
5213 Elf_Internal_Verdaux ivda
;
5215 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5217 get_data (&evda
, file
,
5218 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5219 sizeof (evda
), _("version def aux"));
5221 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5223 name
= strtab
+ ivda
.vda_name
;
5224 nn
+= printf ("(%s%-*s",
5226 12 - (int) strlen (name
),
5232 printf ("%*c", 18 - nn
, ' ');
5250 printf (_("\nNo version information found in this file.\n"));
5256 get_symbol_binding (binding
)
5257 unsigned int binding
;
5259 static char buff
[32];
5263 case STB_LOCAL
: return "LOCAL";
5264 case STB_GLOBAL
: return "GLOBAL";
5265 case STB_WEAK
: return "WEAK";
5267 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5268 sprintf (buff
, _("<processor specific>: %d"), binding
);
5269 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5270 sprintf (buff
, _("<OS specific>: %d"), binding
);
5272 sprintf (buff
, _("<unknown>: %d"), binding
);
5278 get_symbol_type (type
)
5281 static char buff
[32];
5285 case STT_NOTYPE
: return "NOTYPE";
5286 case STT_OBJECT
: return "OBJECT";
5287 case STT_FUNC
: return "FUNC";
5288 case STT_SECTION
: return "SECTION";
5289 case STT_FILE
: return "FILE";
5290 case STT_COMMON
: return "COMMON";
5291 case STT_TLS
: return "TLS";
5293 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5295 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5296 return "THUMB_FUNC";
5298 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5301 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5302 return "PARISC_MILLI";
5304 sprintf (buff
, _("<processor specific>: %d"), type
);
5306 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5308 if (elf_header
.e_machine
== EM_PARISC
)
5310 if (type
== STT_HP_OPAQUE
)
5312 if (type
== STT_HP_STUB
)
5316 sprintf (buff
, _("<OS specific>: %d"), type
);
5319 sprintf (buff
, _("<unknown>: %d"), type
);
5325 get_symbol_visibility (visibility
)
5326 unsigned int visibility
;
5330 case STV_DEFAULT
: return "DEFAULT";
5331 case STV_INTERNAL
: return "INTERNAL";
5332 case STV_HIDDEN
: return "HIDDEN";
5333 case STV_PROTECTED
: return "PROTECTED";
5339 get_symbol_index_type (type
)
5344 case SHN_UNDEF
: return "UND";
5345 case SHN_ABS
: return "ABS";
5346 case SHN_COMMON
: return "COM";
5348 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5350 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5352 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5356 static char buff
[32];
5358 sprintf (buff
, "%3d", type
);
5365 get_dynamic_data (file
, number
)
5367 unsigned int number
;
5369 unsigned char * e_data
;
5372 e_data
= (unsigned char *) malloc (number
* 4);
5376 error (_("Out of memory\n"));
5380 if (fread (e_data
, 4, number
, file
) != number
)
5382 error (_("Unable to read in dynamic data\n"));
5386 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5390 error (_("Out of memory\n"));
5396 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5403 /* Dump the symbol table. */
5405 process_symbol_table (file
)
5408 Elf32_Internal_Shdr
* section
;
5409 unsigned char nb
[4];
5410 unsigned char nc
[4];
5413 int * buckets
= NULL
;
5414 int * chains
= NULL
;
5416 if (! do_syms
&& !do_histogram
)
5419 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5422 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5424 error (_("Unable to seek to start of dynamic information"));
5428 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5430 error (_("Failed to read in number of buckets\n"));
5434 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5436 error (_("Failed to read in number of chains\n"));
5440 nbuckets
= byte_get (nb
, 4);
5441 nchains
= byte_get (nc
, 4);
5443 buckets
= get_dynamic_data (file
, nbuckets
);
5444 chains
= get_dynamic_data (file
, nchains
);
5446 if (buckets
== NULL
|| chains
== NULL
)
5451 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5456 printf (_("\nSymbol table for image:\n"));
5458 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5460 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5462 for (hn
= 0; hn
< nbuckets
; hn
++)
5467 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5469 Elf_Internal_Sym
* psym
;
5471 psym
= dynamic_symbols
+ si
;
5473 printf (" %3d %3d: ", si
, hn
);
5474 print_vma (psym
->st_value
, LONG_HEX
);
5476 print_vma (psym
->st_size
, DEC_5
);
5478 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5479 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5480 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5481 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5482 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5487 else if (do_syms
&& !do_using_dynamic
)
5491 for (i
= 0, section
= section_headers
;
5492 i
< elf_header
.e_shnum
;
5497 Elf_Internal_Sym
* symtab
;
5498 Elf_Internal_Sym
* psym
;
5501 if ( section
->sh_type
!= SHT_SYMTAB
5502 && section
->sh_type
!= SHT_DYNSYM
)
5505 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5506 SECTION_NAME (section
),
5507 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5509 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5511 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5513 symtab
= GET_ELF_SYMBOLS (file
, section
);
5517 if (section
->sh_link
== elf_header
.e_shstrndx
)
5518 strtab
= string_table
;
5521 Elf32_Internal_Shdr
* string_sec
;
5523 string_sec
= SECTION_HEADER (section
->sh_link
);
5525 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5526 string_sec
->sh_size
,
5530 for (si
= 0, psym
= symtab
;
5531 si
< section
->sh_size
/ section
->sh_entsize
;
5534 printf ("%6d: ", si
);
5535 print_vma (psym
->st_value
, LONG_HEX
);
5537 print_vma (psym
->st_size
, DEC_5
);
5538 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5539 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5540 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5541 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5542 print_symbol (25, strtab
+ psym
->st_name
);
5544 if (section
->sh_type
== SHT_DYNSYM
&&
5545 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5547 unsigned char data
[2];
5548 unsigned short vers_data
;
5549 unsigned long offset
;
5553 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5556 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5557 sizeof (data
), _("version data"));
5559 vers_data
= byte_get (data
, 2);
5561 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5564 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5566 if ((vers_data
& 0x8000) || vers_data
> 1)
5568 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5569 && (is_nobits
|| ! check_def
))
5571 Elf_External_Verneed evn
;
5572 Elf_Internal_Verneed ivn
;
5573 Elf_Internal_Vernaux ivna
;
5575 /* We must test both. */
5576 offset
= version_info
5577 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5581 unsigned long vna_off
;
5583 get_data (&evn
, file
, offset
, sizeof (evn
),
5586 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5587 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5589 vna_off
= offset
+ ivn
.vn_aux
;
5593 Elf_External_Vernaux evna
;
5595 get_data (&evna
, file
, vna_off
,
5597 _("version need aux (3)"));
5599 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5600 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5601 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5603 vna_off
+= ivna
.vna_next
;
5605 while (ivna
.vna_other
!= vers_data
5606 && ivna
.vna_next
!= 0);
5608 if (ivna
.vna_other
== vers_data
)
5611 offset
+= ivn
.vn_next
;
5613 while (ivn
.vn_next
!= 0);
5615 if (ivna
.vna_other
== vers_data
)
5618 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5621 else if (! is_nobits
)
5622 error (_("bad dynamic symbol"));
5629 if (vers_data
!= 0x8001
5630 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5632 Elf_Internal_Verdef ivd
;
5633 Elf_Internal_Verdaux ivda
;
5634 Elf_External_Verdaux evda
;
5635 unsigned long offset
;
5638 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5643 Elf_External_Verdef evd
;
5645 get_data (&evd
, file
, offset
, sizeof (evd
),
5648 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5649 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5650 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5652 offset
+= ivd
.vd_next
;
5654 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5655 && ivd
.vd_next
!= 0);
5657 offset
-= ivd
.vd_next
;
5658 offset
+= ivd
.vd_aux
;
5660 get_data (&evda
, file
, offset
, sizeof (evda
),
5661 _("version def aux"));
5663 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5665 if (psym
->st_name
!= ivda
.vda_name
)
5666 printf ((vers_data
& 0x8000)
5668 strtab
+ ivda
.vda_name
);
5678 if (strtab
!= string_table
)
5684 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5686 if (do_histogram
&& buckets
!= NULL
)
5693 int nzero_counts
= 0;
5696 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5698 printf (_(" Length Number %% of total Coverage\n"));
5700 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5701 if (lengths
== NULL
)
5703 error (_("Out of memory"));
5706 for (hn
= 0; hn
< nbuckets
; ++hn
)
5711 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5714 if (maxlength
< ++lengths
[hn
])
5719 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5722 error (_("Out of memory"));
5726 for (hn
= 0; hn
< nbuckets
; ++hn
)
5727 ++ counts
[lengths
[hn
]];
5731 printf (" 0 %-10d (%5.1f%%)\n",
5732 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5733 for (si
= 1; si
<= maxlength
; ++si
)
5735 nzero_counts
+= counts
[si
] * si
;
5736 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5737 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5738 (nzero_counts
* 100.0) / nsyms
);
5746 if (buckets
!= NULL
)
5756 process_syminfo (file
)
5757 FILE * file ATTRIBUTE_UNUSED
;
5761 if (dynamic_syminfo
== NULL
5763 /* No syminfo, this is ok. */
5766 /* There better should be a dynamic symbol section. */
5767 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5771 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5772 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5774 printf (_(" Num: Name BoundTo Flags\n"));
5775 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5777 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5779 printf ("%4d: ", i
);
5780 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5783 switch (dynamic_syminfo
[i
].si_boundto
)
5785 case SYMINFO_BT_SELF
:
5786 fputs ("SELF ", stdout
);
5788 case SYMINFO_BT_PARENT
:
5789 fputs ("PARENT ", stdout
);
5792 if (dynamic_syminfo
[i
].si_boundto
> 0
5793 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5795 print_symbol (10, dynamic_strings
5797 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5801 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5805 if (flags
& SYMINFO_FLG_DIRECT
)
5807 if (flags
& SYMINFO_FLG_PASSTHRU
)
5808 printf (" PASSTHRU");
5809 if (flags
& SYMINFO_FLG_COPY
)
5811 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5812 printf (" LAZYLOAD");
5820 #ifdef SUPPORT_DISASSEMBLY
5822 disassemble_section (section
, file
)
5823 Elf32_Internal_Shdr
* section
;
5826 printf (_("\nAssembly dump of section %s\n"),
5827 SECTION_NAME (section
));
5829 /* XXX -- to be done --- XXX */
5836 dump_section (section
, file
)
5837 Elf32_Internal_Shdr
* section
;
5840 bfd_size_type bytes
;
5842 unsigned char * data
;
5843 unsigned char * start
;
5845 bytes
= section
->sh_size
;
5849 printf (_("\nSection '%s' has no data to dump.\n"),
5850 SECTION_NAME (section
));
5854 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5856 addr
= section
->sh_addr
;
5858 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
5871 lbytes
= (bytes
> 16 ? 16 : bytes
);
5873 printf (" 0x%8.8lx ", (unsigned long) addr
);
5875 switch (elf_header
.e_ident
[EI_DATA
])
5879 for (j
= 15; j
>= 0; j
--)
5882 printf ("%2.2x", data
[j
]);
5892 for (j
= 0; j
< 16; j
++)
5895 printf ("%2.2x", data
[j
]);
5905 for (j
= 0; j
< lbytes
; j
++)
5908 if (k
>= ' ' && k
< 0x80)
5927 static unsigned long int
5928 read_leb128 (data
, length_return
, sign
)
5929 unsigned char * data
;
5930 int * length_return
;
5933 unsigned long int result
= 0;
5934 unsigned int num_read
= 0;
5943 result
|= (byte
& 0x7f) << shift
;
5948 while (byte
& 0x80);
5950 if (length_return
!= NULL
)
5951 * length_return
= num_read
;
5953 if (sign
&& (shift
< 32) && (byte
& 0x40))
5954 result
|= -1 << shift
;
5959 typedef struct State_Machine_Registers
5961 unsigned long address
;
5964 unsigned int column
;
5968 /* This variable hold the number of the last entry seen
5969 in the File Table. */
5970 unsigned int last_file_entry
;
5973 static SMR state_machine_regs
;
5976 reset_state_machine (is_stmt
)
5979 state_machine_regs
.address
= 0;
5980 state_machine_regs
.file
= 1;
5981 state_machine_regs
.line
= 1;
5982 state_machine_regs
.column
= 0;
5983 state_machine_regs
.is_stmt
= is_stmt
;
5984 state_machine_regs
.basic_block
= 0;
5985 state_machine_regs
.end_sequence
= 0;
5986 state_machine_regs
.last_file_entry
= 0;
5989 /* Handled an extend line op. Returns true if this is the end
5992 process_extended_line_op (data
, is_stmt
, pointer_size
)
5993 unsigned char * data
;
5997 unsigned char op_code
;
6000 unsigned char * name
;
6003 len
= read_leb128 (data
, & bytes_read
, 0);
6008 warn (_("badly formed extended line op encountered!\n"));
6013 op_code
= * data
++;
6015 printf (_(" Extended opcode %d: "), op_code
);
6019 case DW_LNE_end_sequence
:
6020 printf (_("End of Sequence\n\n"));
6021 reset_state_machine (is_stmt
);
6024 case DW_LNE_set_address
:
6025 adr
= byte_get (data
, pointer_size
);
6026 printf (_("set Address to 0x%lx\n"), adr
);
6027 state_machine_regs
.address
= adr
;
6030 case DW_LNE_define_file
:
6031 printf (_(" define new File Table entry\n"));
6032 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6034 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6036 data
+= strlen ((char *) data
) + 1;
6037 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6039 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6041 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6042 printf (_("%s\n\n"), name
);
6046 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6053 /* Size of pointers in the .debug_line section. This information is not
6054 really present in that section. It's obtained before dumping the debug
6055 sections by doing some pre-scan of the .debug_info section. */
6056 static int debug_line_pointer_size
= 4;
6059 display_debug_lines (section
, start
, file
)
6060 Elf32_Internal_Shdr
* section
;
6061 unsigned char * start
;
6062 FILE * file ATTRIBUTE_UNUSED
;
6064 DWARF2_External_LineInfo
* external
;
6065 DWARF2_Internal_LineInfo info
;
6066 unsigned char * standard_opcodes
;
6067 unsigned char * data
= start
;
6068 unsigned char * end
= start
+ section
->sh_size
;
6069 unsigned char * end_of_sequence
;
6072 printf (_("\nDump of debug contents of section %s:\n\n"),
6073 SECTION_NAME (section
));
6077 external
= (DWARF2_External_LineInfo
*) data
;
6079 /* Check the length of the block. */
6080 info
.li_length
= BYTE_GET (external
->li_length
);
6082 if (info
.li_length
== 0xffffffff)
6084 warn (_("64-bit DWARF line info is not supported yet.\n"));
6088 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6091 (_("The line info appears to be corrupt - the section is too small\n"));
6095 /* Check its version number. */
6096 info
.li_version
= BYTE_GET (external
->li_version
);
6097 if (info
.li_version
!= 2)
6099 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6103 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6104 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6105 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6106 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6107 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6108 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6110 /* Sign extend the line base field. */
6111 info
.li_line_base
<<= 24;
6112 info
.li_line_base
>>= 24;
6114 printf (_(" Length: %ld\n"), info
.li_length
);
6115 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6116 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6117 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6118 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6119 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6120 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6121 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6123 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6125 reset_state_machine (info
.li_default_is_stmt
);
6127 /* Display the contents of the Opcodes table. */
6128 standard_opcodes
= data
+ sizeof (* external
);
6130 printf (_("\n Opcodes:\n"));
6132 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6133 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6135 /* Display the contents of the Directory table. */
6136 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6139 printf (_("\n The Directory Table is empty.\n"));
6142 printf (_("\n The Directory Table:\n"));
6146 printf (_(" %s\n"), data
);
6148 data
+= strlen ((char *) data
) + 1;
6152 /* Skip the NUL at the end of the table. */
6155 /* Display the contents of the File Name table. */
6157 printf (_("\n The File Name Table is empty.\n"));
6160 printf (_("\n The File Name Table:\n"));
6161 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6165 unsigned char * name
;
6168 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6171 data
+= strlen ((char *) data
) + 1;
6173 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6175 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6177 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6179 printf (_("%s\n"), name
);
6183 /* Skip the NUL at the end of the table. */
6186 /* Now display the statements. */
6187 printf (_("\n Line Number Statements:\n"));
6190 while (data
< end_of_sequence
)
6192 unsigned char op_code
;
6196 op_code
= * data
++;
6198 if (op_code
>= info
.li_opcode_base
)
6200 op_code
-= info
.li_opcode_base
;
6201 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6202 state_machine_regs
.address
+= adv
;
6203 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6204 op_code
, adv
, state_machine_regs
.address
);
6205 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6206 state_machine_regs
.line
+= adv
;
6207 printf (_(" and Line by %d to %d\n"),
6208 adv
, state_machine_regs
.line
);
6210 else switch (op_code
)
6212 case DW_LNS_extended_op
:
6213 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6214 debug_line_pointer_size
);
6218 printf (_(" Copy\n"));
6221 case DW_LNS_advance_pc
:
6222 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6224 state_machine_regs
.address
+= adv
;
6225 printf (_(" Advance PC by %d to %lx\n"), adv
,
6226 state_machine_regs
.address
);
6229 case DW_LNS_advance_line
:
6230 adv
= read_leb128 (data
, & bytes_read
, 1);
6232 state_machine_regs
.line
+= adv
;
6233 printf (_(" Advance Line by %d to %d\n"), adv
,
6234 state_machine_regs
.line
);
6237 case DW_LNS_set_file
:
6238 adv
= read_leb128 (data
, & bytes_read
, 0);
6240 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6242 state_machine_regs
.file
= adv
;
6245 case DW_LNS_set_column
:
6246 adv
= read_leb128 (data
, & bytes_read
, 0);
6248 printf (_(" Set column to %d\n"), adv
);
6249 state_machine_regs
.column
= adv
;
6252 case DW_LNS_negate_stmt
:
6253 adv
= state_machine_regs
.is_stmt
;
6255 printf (_(" Set is_stmt to %d\n"), adv
);
6256 state_machine_regs
.is_stmt
= adv
;
6259 case DW_LNS_set_basic_block
:
6260 printf (_(" Set basic block\n"));
6261 state_machine_regs
.basic_block
= 1;
6264 case DW_LNS_const_add_pc
:
6265 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6266 * info
.li_min_insn_length
);
6267 state_machine_regs
.address
+= adv
;
6268 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6269 state_machine_regs
.address
);
6272 case DW_LNS_fixed_advance_pc
:
6273 adv
= byte_get (data
, 2);
6275 state_machine_regs
.address
+= adv
;
6276 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6277 adv
, state_machine_regs
.address
);
6280 case DW_LNS_set_prologue_end
:
6281 printf (_(" Set prologue_end to true\n"));
6284 case DW_LNS_set_epilogue_begin
:
6285 printf (_(" Set epilogue_begin to true\n"));
6288 case DW_LNS_set_isa
:
6289 adv
= read_leb128 (data
, & bytes_read
, 0);
6291 printf (_(" Set ISA to %d\n"), adv
);
6295 printf (_(" Unknown opcode %d with operands: "), op_code
);
6298 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6300 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6301 i
== 1 ? "" : ", ");
6316 display_debug_pubnames (section
, start
, file
)
6317 Elf32_Internal_Shdr
* section
;
6318 unsigned char * start
;
6319 FILE * file ATTRIBUTE_UNUSED
;
6321 DWARF2_External_PubNames
* external
;
6322 DWARF2_Internal_PubNames pubnames
;
6323 unsigned char * end
;
6325 end
= start
+ section
->sh_size
;
6327 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6331 unsigned char * data
;
6332 unsigned long offset
;
6334 external
= (DWARF2_External_PubNames
*) start
;
6336 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6337 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6338 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6339 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6341 data
= start
+ sizeof (* external
);
6342 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6344 if (pubnames
.pn_length
== 0xffffffff)
6346 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6350 if (pubnames
.pn_version
!= 2)
6352 static int warned
= 0;
6356 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6363 printf (_(" Length: %ld\n"),
6364 pubnames
.pn_length
);
6365 printf (_(" Version: %d\n"),
6366 pubnames
.pn_version
);
6367 printf (_(" Offset into .debug_info section: %ld\n"),
6368 pubnames
.pn_offset
);
6369 printf (_(" Size of area in .debug_info section: %ld\n"),
6372 printf (_("\n Offset\tName\n"));
6376 offset
= byte_get (data
, 4);
6381 printf (" %ld\t\t%s\n", offset
, data
);
6382 data
+= strlen ((char *) data
) + 1;
6385 while (offset
!= 0);
6398 case DW_TAG_padding
: return "DW_TAG_padding";
6399 case DW_TAG_array_type
: return "DW_TAG_array_type";
6400 case DW_TAG_class_type
: return "DW_TAG_class_type";
6401 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6402 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6403 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6404 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6405 case DW_TAG_label
: return "DW_TAG_label";
6406 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6407 case DW_TAG_member
: return "DW_TAG_member";
6408 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6409 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6410 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6411 case DW_TAG_string_type
: return "DW_TAG_string_type";
6412 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6413 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6414 case DW_TAG_typedef
: return "DW_TAG_typedef";
6415 case DW_TAG_union_type
: return "DW_TAG_union_type";
6416 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6417 case DW_TAG_variant
: return "DW_TAG_variant";
6418 case DW_TAG_common_block
: return "DW_TAG_common_block";
6419 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6420 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6421 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6422 case DW_TAG_module
: return "DW_TAG_module";
6423 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6424 case DW_TAG_set_type
: return "DW_TAG_set_type";
6425 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6426 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6427 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6428 case DW_TAG_base_type
: return "DW_TAG_base_type";
6429 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6430 case DW_TAG_const_type
: return "DW_TAG_const_type";
6431 case DW_TAG_constant
: return "DW_TAG_constant";
6432 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6433 case DW_TAG_file_type
: return "DW_TAG_file_type";
6434 case DW_TAG_friend
: return "DW_TAG_friend";
6435 case DW_TAG_namelist
: return "DW_TAG_namelist";
6436 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6437 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6438 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6439 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6440 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6441 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6442 case DW_TAG_try_block
: return "DW_TAG_try_block";
6443 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6444 case DW_TAG_variable
: return "DW_TAG_variable";
6445 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6446 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6447 case DW_TAG_format_label
: return "DW_TAG_format_label";
6448 case DW_TAG_function_template
: return "DW_TAG_function_template";
6449 case DW_TAG_class_template
: return "DW_TAG_class_template";
6450 /* DWARF 2.1 values. */
6451 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6452 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6453 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6454 case DW_TAG_namespace
: return "DW_TAG_namespace";
6455 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6456 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6457 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6458 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6461 static char buffer
[100];
6463 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6470 get_AT_name (attribute
)
6471 unsigned long attribute
;
6475 case DW_AT_sibling
: return "DW_AT_sibling";
6476 case DW_AT_location
: return "DW_AT_location";
6477 case DW_AT_name
: return "DW_AT_name";
6478 case DW_AT_ordering
: return "DW_AT_ordering";
6479 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6480 case DW_AT_byte_size
: return "DW_AT_byte_size";
6481 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6482 case DW_AT_bit_size
: return "DW_AT_bit_size";
6483 case DW_AT_element_list
: return "DW_AT_element_list";
6484 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6485 case DW_AT_low_pc
: return "DW_AT_low_pc";
6486 case DW_AT_high_pc
: return "DW_AT_high_pc";
6487 case DW_AT_language
: return "DW_AT_language";
6488 case DW_AT_member
: return "DW_AT_member";
6489 case DW_AT_discr
: return "DW_AT_discr";
6490 case DW_AT_discr_value
: return "DW_AT_discr_value";
6491 case DW_AT_visibility
: return "DW_AT_visibility";
6492 case DW_AT_import
: return "DW_AT_import";
6493 case DW_AT_string_length
: return "DW_AT_string_length";
6494 case DW_AT_common_reference
: return "DW_AT_common_reference";
6495 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6496 case DW_AT_const_value
: return "DW_AT_const_value";
6497 case DW_AT_containing_type
: return "DW_AT_containing_type";
6498 case DW_AT_default_value
: return "DW_AT_default_value";
6499 case DW_AT_inline
: return "DW_AT_inline";
6500 case DW_AT_is_optional
: return "DW_AT_is_optional";
6501 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6502 case DW_AT_producer
: return "DW_AT_producer";
6503 case DW_AT_prototyped
: return "DW_AT_prototyped";
6504 case DW_AT_return_addr
: return "DW_AT_return_addr";
6505 case DW_AT_start_scope
: return "DW_AT_start_scope";
6506 case DW_AT_stride_size
: return "DW_AT_stride_size";
6507 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6508 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6509 case DW_AT_accessibility
: return "DW_AT_accessibility";
6510 case DW_AT_address_class
: return "DW_AT_address_class";
6511 case DW_AT_artificial
: return "DW_AT_artificial";
6512 case DW_AT_base_types
: return "DW_AT_base_types";
6513 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6514 case DW_AT_count
: return "DW_AT_count";
6515 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6516 case DW_AT_decl_column
: return "DW_AT_decl_column";
6517 case DW_AT_decl_file
: return "DW_AT_decl_file";
6518 case DW_AT_decl_line
: return "DW_AT_decl_line";
6519 case DW_AT_declaration
: return "DW_AT_declaration";
6520 case DW_AT_discr_list
: return "DW_AT_discr_list";
6521 case DW_AT_encoding
: return "DW_AT_encoding";
6522 case DW_AT_external
: return "DW_AT_external";
6523 case DW_AT_frame_base
: return "DW_AT_frame_base";
6524 case DW_AT_friend
: return "DW_AT_friend";
6525 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6526 case DW_AT_macro_info
: return "DW_AT_macro_info";
6527 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6528 case DW_AT_priority
: return "DW_AT_priority";
6529 case DW_AT_segment
: return "DW_AT_segment";
6530 case DW_AT_specification
: return "DW_AT_specification";
6531 case DW_AT_static_link
: return "DW_AT_static_link";
6532 case DW_AT_type
: return "DW_AT_type";
6533 case DW_AT_use_location
: return "DW_AT_use_location";
6534 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6535 case DW_AT_virtuality
: return "DW_AT_virtuality";
6536 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6537 /* DWARF 2.1 values. */
6538 case DW_AT_allocated
: return "DW_AT_allocated";
6539 case DW_AT_associated
: return "DW_AT_associated";
6540 case DW_AT_data_location
: return "DW_AT_data_location";
6541 case DW_AT_stride
: return "DW_AT_stride";
6542 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6543 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6544 case DW_AT_extension
: return "DW_AT_extension";
6545 case DW_AT_ranges
: return "DW_AT_ranges";
6546 case DW_AT_trampoline
: return "DW_AT_trampoline";
6547 case DW_AT_call_column
: return "DW_AT_call_column";
6548 case DW_AT_call_file
: return "DW_AT_call_file";
6549 case DW_AT_call_line
: return "DW_AT_call_line";
6550 /* SGI/MIPS extensions. */
6551 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6552 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6553 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6554 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6555 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6556 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6557 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6558 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6559 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6560 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6561 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6562 /* GNU extensions. */
6563 case DW_AT_sf_names
: return "DW_AT_sf_names";
6564 case DW_AT_src_info
: return "DW_AT_src_info";
6565 case DW_AT_mac_info
: return "DW_AT_mac_info";
6566 case DW_AT_src_coords
: return "DW_AT_src_coords";
6567 case DW_AT_body_begin
: return "DW_AT_body_begin";
6568 case DW_AT_body_end
: return "DW_AT_body_end";
6569 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6572 static char buffer
[100];
6574 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6581 get_FORM_name (form
)
6586 case DW_FORM_addr
: return "DW_FORM_addr";
6587 case DW_FORM_block2
: return "DW_FORM_block2";
6588 case DW_FORM_block4
: return "DW_FORM_block4";
6589 case DW_FORM_data2
: return "DW_FORM_data2";
6590 case DW_FORM_data4
: return "DW_FORM_data4";
6591 case DW_FORM_data8
: return "DW_FORM_data8";
6592 case DW_FORM_string
: return "DW_FORM_string";
6593 case DW_FORM_block
: return "DW_FORM_block";
6594 case DW_FORM_block1
: return "DW_FORM_block1";
6595 case DW_FORM_data1
: return "DW_FORM_data1";
6596 case DW_FORM_flag
: return "DW_FORM_flag";
6597 case DW_FORM_sdata
: return "DW_FORM_sdata";
6598 case DW_FORM_strp
: return "DW_FORM_strp";
6599 case DW_FORM_udata
: return "DW_FORM_udata";
6600 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6601 case DW_FORM_ref1
: return "DW_FORM_ref1";
6602 case DW_FORM_ref2
: return "DW_FORM_ref2";
6603 case DW_FORM_ref4
: return "DW_FORM_ref4";
6604 case DW_FORM_ref8
: return "DW_FORM_ref8";
6605 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6606 case DW_FORM_indirect
: return "DW_FORM_indirect";
6609 static char buffer
[100];
6611 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6617 /* FIXME: There are better and more effiecint ways to handle
6618 these structures. For now though, I just want something that
6619 is simple to implement. */
6620 typedef struct abbrev_attr
6622 unsigned long attribute
;
6624 struct abbrev_attr
* next
;
6628 typedef struct abbrev_entry
6630 unsigned long entry
;
6633 struct abbrev_attr
* first_attr
;
6634 struct abbrev_attr
* last_attr
;
6635 struct abbrev_entry
* next
;
6639 static abbrev_entry
* first_abbrev
= NULL
;
6640 static abbrev_entry
* last_abbrev
= NULL
;
6643 free_abbrevs
PARAMS ((void))
6645 abbrev_entry
* abbrev
;
6647 for (abbrev
= first_abbrev
; abbrev
;)
6649 abbrev_entry
* next
= abbrev
->next
;
6652 for (attr
= abbrev
->first_attr
; attr
;)
6654 abbrev_attr
* next
= attr
->next
;
6664 last_abbrev
= first_abbrev
= NULL
;
6668 add_abbrev (number
, tag
, children
)
6669 unsigned long number
;
6673 abbrev_entry
* entry
;
6675 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6681 entry
->entry
= number
;
6683 entry
->children
= children
;
6684 entry
->first_attr
= NULL
;
6685 entry
->last_attr
= NULL
;
6688 if (first_abbrev
== NULL
)
6689 first_abbrev
= entry
;
6691 last_abbrev
->next
= entry
;
6693 last_abbrev
= entry
;
6697 add_abbrev_attr (attribute
, form
)
6698 unsigned long attribute
;
6703 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6709 attr
->attribute
= attribute
;
6713 if (last_abbrev
->first_attr
== NULL
)
6714 last_abbrev
->first_attr
= attr
;
6716 last_abbrev
->last_attr
->next
= attr
;
6718 last_abbrev
->last_attr
= attr
;
6721 /* Processes the (partial) contents of a .debug_abbrev section.
6722 Returns NULL if the end of the section was encountered.
6723 Returns the address after the last byte read if the end of
6724 an abbreviation set was found. */
6726 static unsigned char *
6727 process_abbrev_section (start
, end
)
6728 unsigned char * start
;
6729 unsigned char * end
;
6731 if (first_abbrev
!= NULL
)
6737 unsigned long entry
;
6739 unsigned long attribute
;
6742 entry
= read_leb128 (start
, & bytes_read
, 0);
6743 start
+= bytes_read
;
6745 /* A single zero is supposed to end the section according
6746 to the standard. If there's more, then signal that to
6749 return start
== end
? NULL
: start
;
6751 tag
= read_leb128 (start
, & bytes_read
, 0);
6752 start
+= bytes_read
;
6754 children
= * start
++;
6756 add_abbrev (entry
, tag
, children
);
6762 attribute
= read_leb128 (start
, & bytes_read
, 0);
6763 start
+= bytes_read
;
6765 form
= read_leb128 (start
, & bytes_read
, 0);
6766 start
+= bytes_read
;
6769 add_abbrev_attr (attribute
, form
);
6771 while (attribute
!= 0);
6779 display_debug_macinfo (section
, start
, file
)
6780 Elf32_Internal_Shdr
* section
;
6781 unsigned char * start
;
6782 FILE * file ATTRIBUTE_UNUSED
;
6784 unsigned char * end
= start
+ section
->sh_size
;
6785 unsigned char * curr
= start
;
6786 unsigned int bytes_read
;
6787 enum dwarf_macinfo_record_type op
;
6789 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6793 unsigned int lineno
;
6794 const char * string
;
6801 case DW_MACINFO_start_file
:
6803 unsigned int filenum
;
6805 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6807 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6810 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6814 case DW_MACINFO_end_file
:
6815 printf (_(" DW_MACINFO_end_file\n"));
6818 case DW_MACINFO_define
:
6819 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6822 curr
+= strlen (string
) + 1;
6823 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6826 case DW_MACINFO_undef
:
6827 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6830 curr
+= strlen (string
) + 1;
6831 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
6834 case DW_MACINFO_vendor_ext
:
6836 unsigned int constant
;
6838 constant
= read_leb128 (curr
, & bytes_read
, 0);
6841 curr
+= strlen (string
) + 1;
6842 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
6853 display_debug_abbrev (section
, start
, file
)
6854 Elf32_Internal_Shdr
* section
;
6855 unsigned char * start
;
6856 FILE * file ATTRIBUTE_UNUSED
;
6858 abbrev_entry
* entry
;
6859 unsigned char * end
= start
+ section
->sh_size
;
6861 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6865 start
= process_abbrev_section (start
, end
);
6867 if (first_abbrev
== NULL
)
6870 printf (_(" Number TAG\n"));
6872 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
6876 printf (_(" %ld %s [%s]\n"),
6878 get_TAG_name (entry
->tag
),
6879 entry
->children
? _("has children") : _("no children"));
6881 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6883 printf (_(" %-18s %s\n"),
6884 get_AT_name (attr
->attribute
),
6885 get_FORM_name (attr
->form
));
6899 static unsigned char *
6900 display_block (data
, length
)
6901 unsigned char * data
;
6902 unsigned long length
;
6904 printf (_(" %lu byte block: "), length
);
6907 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
6913 decode_location_expression (data
, pointer_size
, length
)
6914 unsigned char * data
;
6915 unsigned int pointer_size
;
6916 unsigned long length
;
6920 unsigned long uvalue
;
6921 unsigned char * end
= data
+ length
;
6930 printf ("DW_OP_addr: %lx",
6931 (unsigned long) byte_get (data
, pointer_size
));
6932 data
+= pointer_size
;
6935 printf ("DW_OP_deref");
6938 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
6941 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
6944 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
6948 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
6952 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
6956 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
6960 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
6961 (unsigned long) byte_get (data
+ 4, 4));
6965 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
6966 (long) byte_get (data
+ 4, 4));
6970 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
6974 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
6978 printf ("DW_OP_dup");
6981 printf ("DW_OP_drop");
6984 printf ("DW_OP_over");
6987 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
6990 printf ("DW_OP_swap");
6993 printf ("DW_OP_rot");
6996 printf ("DW_OP_xderef");
6999 printf ("DW_OP_abs");
7002 printf ("DW_OP_and");
7005 printf ("DW_OP_div");
7008 printf ("DW_OP_minus");
7011 printf ("DW_OP_mod");
7014 printf ("DW_OP_mul");
7017 printf ("DW_OP_neg");
7020 printf ("DW_OP_not");
7023 printf ("DW_OP_or");
7026 printf ("DW_OP_plus");
7028 case DW_OP_plus_uconst
:
7029 printf ("DW_OP_plus_uconst: %lu",
7030 read_leb128 (data
, &bytes_read
, 0));
7034 printf ("DW_OP_shl");
7037 printf ("DW_OP_shr");
7040 printf ("DW_OP_shra");
7043 printf ("DW_OP_xor");
7046 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7050 printf ("DW_OP_eq");
7053 printf ("DW_OP_ge");
7056 printf ("DW_OP_gt");
7059 printf ("DW_OP_le");
7062 printf ("DW_OP_lt");
7065 printf ("DW_OP_ne");
7068 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7104 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7139 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7174 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7175 read_leb128 (data
, &bytes_read
, 1));
7180 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7184 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7188 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7190 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7191 read_leb128 (data
, &bytes_read
, 1));
7195 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7198 case DW_OP_deref_size
:
7199 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7201 case DW_OP_xderef_size
:
7202 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7205 printf ("DW_OP_nop");
7208 /* DWARF 2.1 extensions. */
7209 case DW_OP_push_object_address
:
7210 printf ("DW_OP_push_object_address");
7213 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7217 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7221 printf ("DW_OP_calli");
7225 if (op
>= DW_OP_lo_user
7226 && op
<= DW_OP_hi_user
)
7227 printf (_("(User defined location op)"));
7229 printf (_("(Unknown location op)"));
7230 /* No way to tell where the next op is, so just bail. */
7234 /* Separate the ops. */
7239 static const char * debug_loc_contents
;
7240 static bfd_vma debug_loc_size
;
7243 load_debug_loc (file
)
7246 Elf32_Internal_Shdr
* sec
;
7249 /* If it is already loaded, do nothing. */
7250 if (debug_loc_contents
!= NULL
)
7253 /* Locate the .debug_loc section. */
7254 for (i
= 0, sec
= section_headers
;
7255 i
< elf_header
.e_shnum
;
7257 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7260 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7263 debug_loc_size
= sec
->sh_size
;
7265 debug_loc_contents
= ((char *)
7266 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7267 _("debug_loc section data")));
7273 if (debug_loc_contents
== NULL
)
7276 free ((char *) debug_loc_contents
);
7277 debug_loc_contents
= NULL
;
7283 display_debug_loc (section
, start
, file
)
7284 Elf32_Internal_Shdr
* section
;
7285 unsigned char * start
;
7286 FILE * file ATTRIBUTE_UNUSED
;
7288 unsigned char *section_end
;
7289 unsigned long bytes
;
7290 unsigned char *section_begin
= start
;
7293 addr
= section
->sh_addr
;
7294 bytes
= section
->sh_size
;
7295 section_end
= start
+ bytes
;
7298 printf (_("\nThe .debug_loc section is empty.\n"));
7301 printf (_("Contents of the .debug_loc section:\n\n"));
7302 printf (_("\n Offset Begin End Expression\n"));
7303 while (start
< section_end
)
7305 unsigned long begin
;
7307 unsigned short length
;
7308 unsigned long offset
;
7310 offset
= start
- section_begin
;
7314 /* Normally, the lists in the debug_loc section are related to a
7315 given compilation unit, and thus, we would use the
7316 pointer size of that compilation unit. However, since we are
7317 displaying it seperately here, we either have to store
7318 pointer sizes of all compilation units, or assume they don't
7319 change. We assume, like the debug_line display, that
7320 it doesn't change. */
7321 begin
= byte_get (start
, debug_line_pointer_size
);
7322 start
+= debug_line_pointer_size
;
7323 end
= byte_get (start
, debug_line_pointer_size
);
7324 start
+= debug_line_pointer_size
;
7326 if (begin
== 0 && end
== 0)
7332 length
= byte_get (start
, 2);
7335 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7336 decode_location_expression (start
, debug_line_pointer_size
, length
);
7346 static const char * debug_str_contents
;
7347 static bfd_vma debug_str_size
;
7350 load_debug_str (file
)
7353 Elf32_Internal_Shdr
* sec
;
7356 /* If it is already loaded, do nothing. */
7357 if (debug_str_contents
!= NULL
)
7360 /* Locate the .debug_str section. */
7361 for (i
= 0, sec
= section_headers
;
7362 i
< elf_header
.e_shnum
;
7364 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7367 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7370 debug_str_size
= sec
->sh_size
;
7372 debug_str_contents
= ((char *)
7373 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7374 _("debug_str section data")));
7380 if (debug_str_contents
== NULL
)
7383 free ((char *) debug_str_contents
);
7384 debug_str_contents
= NULL
;
7389 fetch_indirect_string (offset
)
7390 unsigned long offset
;
7392 if (debug_str_contents
== NULL
)
7393 return _("<no .debug_str section>");
7395 if (offset
> debug_str_size
)
7396 return _("<offset is too big>");
7398 return debug_str_contents
+ offset
;
7403 display_debug_str (section
, start
, file
)
7404 Elf32_Internal_Shdr
* section
;
7405 unsigned char * start
;
7406 FILE * file ATTRIBUTE_UNUSED
;
7408 unsigned long bytes
;
7411 addr
= section
->sh_addr
;
7412 bytes
= section
->sh_size
;
7416 printf (_("\nThe .debug_str section is empty.\n"));
7420 printf (_("Contents of the .debug_str section:\n\n"));
7428 lbytes
= (bytes
> 16 ? 16 : bytes
);
7430 printf (" 0x%8.8lx ", (unsigned long) addr
);
7432 for (j
= 0; j
< 16; j
++)
7435 printf ("%2.2x", start
[j
]);
7443 for (j
= 0; j
< lbytes
; j
++)
7446 if (k
>= ' ' && k
< 0x80)
7463 static unsigned char *
7464 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7465 unsigned long attribute
;
7467 unsigned char * data
;
7468 unsigned long cu_offset
;
7469 unsigned long pointer_size
;
7471 unsigned long uvalue
= 0;
7472 unsigned char * block_start
= NULL
;
7480 case DW_FORM_ref_addr
:
7482 uvalue
= byte_get (data
, pointer_size
);
7483 data
+= pointer_size
;
7487 uvalue
= byte_get (data
, /* offset_size */ 4);
7488 data
+= /* offset_size */ 4;
7494 uvalue
= byte_get (data
++, 1);
7499 uvalue
= byte_get (data
, 2);
7505 uvalue
= byte_get (data
, 4);
7510 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7514 case DW_FORM_ref_udata
:
7516 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7520 case DW_FORM_indirect
:
7521 form
= read_leb128 (data
, & bytes_read
, 0);
7523 printf (" %s", get_FORM_name (form
));
7524 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7530 case DW_FORM_ref_addr
:
7531 printf (" <#%lx>", uvalue
);
7537 case DW_FORM_ref_udata
:
7538 printf (" <%lx>", uvalue
+ cu_offset
);
7542 printf (" %#lx", uvalue
);
7550 printf (" %ld", uvalue
);
7555 uvalue
= byte_get (data
, 4);
7556 printf (" %lx", uvalue
);
7557 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7561 case DW_FORM_string
:
7562 printf (" %s", data
);
7563 data
+= strlen ((char *) data
) + 1;
7567 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7568 block_start
= data
+ bytes_read
;
7569 data
= display_block (block_start
, uvalue
);
7572 case DW_FORM_block1
:
7573 uvalue
= byte_get (data
, 1);
7574 block_start
= data
+ 1;
7575 data
= display_block (block_start
, uvalue
);
7578 case DW_FORM_block2
:
7579 uvalue
= byte_get (data
, 2);
7580 block_start
= data
+ 2;
7581 data
= display_block (block_start
, uvalue
);
7584 case DW_FORM_block4
:
7585 uvalue
= byte_get (data
, 4);
7586 block_start
= data
+ 4;
7587 data
= display_block (block_start
, uvalue
);
7591 printf (_(" (indirect string, offset: 0x%lx): "), uvalue
);
7592 printf (fetch_indirect_string (uvalue
));
7595 case DW_FORM_indirect
:
7596 /* Handled above. */
7600 warn (_("Unrecognized form: %d\n"), form
);
7604 /* For some attributes we can display futher information. */
7613 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7614 case DW_INL_inlined
: printf (_("(inlined)")); break;
7615 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7616 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7617 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7621 case DW_AT_language
:
7624 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7625 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7626 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7627 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7628 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7629 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7630 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7631 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7632 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7633 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7634 /* DWARF 2.1 values. */
7635 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7636 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7637 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7638 /* MIPS extension. */
7639 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7640 default: printf ("(Unknown: %lx)", uvalue
); break;
7644 case DW_AT_encoding
:
7647 case DW_ATE_void
: printf ("(void)"); break;
7648 case DW_ATE_address
: printf ("(machine address)"); break;
7649 case DW_ATE_boolean
: printf ("(boolean)"); break;
7650 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7651 case DW_ATE_float
: printf ("(float)"); break;
7652 case DW_ATE_signed
: printf ("(signed)"); break;
7653 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7654 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7655 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7656 /* DWARF 2.1 value. */
7657 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7659 if (uvalue
>= DW_ATE_lo_user
7660 && uvalue
<= DW_ATE_hi_user
)
7661 printf ("(user defined type)");
7663 printf ("(unknown type)");
7668 case DW_AT_accessibility
:
7671 case DW_ACCESS_public
: printf ("(public)"); break;
7672 case DW_ACCESS_protected
: printf ("(protected)"); break;
7673 case DW_ACCESS_private
: printf ("(private)"); break;
7674 default: printf ("(unknown accessibility)"); break;
7678 case DW_AT_visibility
:
7681 case DW_VIS_local
: printf ("(local)"); break;
7682 case DW_VIS_exported
: printf ("(exported)"); break;
7683 case DW_VIS_qualified
: printf ("(qualified)"); break;
7684 default: printf ("(unknown visibility)"); break;
7688 case DW_AT_virtuality
:
7691 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7692 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7693 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7694 default: printf ("(unknown virtuality)"); break;
7698 case DW_AT_identifier_case
:
7701 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7702 case DW_ID_up_case
: printf ("(up_case)"); break;
7703 case DW_ID_down_case
: printf ("(down_case)"); break;
7704 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7705 default: printf ("(unknown case)"); break;
7709 case DW_AT_calling_convention
:
7712 case DW_CC_normal
: printf ("(normal)"); break;
7713 case DW_CC_program
: printf ("(program)"); break;
7714 case DW_CC_nocall
: printf ("(nocall)"); break;
7716 if (uvalue
>= DW_CC_lo_user
7717 && uvalue
<= DW_CC_hi_user
)
7718 printf ("(user defined)");
7720 printf ("(unknown convention)");
7724 case DW_AT_ordering
:
7727 case -1: printf ("(undefined)"); break;
7728 case 0: printf ("(row major)"); break;
7729 case 1: printf ("(column major)"); break;
7733 case DW_AT_frame_base
:
7734 case DW_AT_location
:
7735 case DW_AT_data_member_location
:
7736 case DW_AT_vtable_elem_location
:
7737 case DW_AT_allocated
:
7738 case DW_AT_associated
:
7739 case DW_AT_data_location
:
7741 case DW_AT_upper_bound
:
7742 case DW_AT_lower_bound
:
7746 decode_location_expression (block_start
, pointer_size
, uvalue
);
7749 else if (form
== DW_FORM_data4
)
7752 printf ("location list");
7764 static unsigned char *
7765 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7766 unsigned long attribute
;
7768 unsigned char * data
;
7769 unsigned long cu_offset
;
7770 unsigned long pointer_size
;
7772 printf (" %-18s:", get_AT_name (attribute
));
7773 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7780 display_debug_info (section
, start
, file
)
7781 Elf32_Internal_Shdr
* section
;
7782 unsigned char * start
;
7785 unsigned char * end
= start
+ section
->sh_size
;
7786 unsigned char * section_begin
= start
;
7788 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7790 load_debug_str (file
);
7791 load_debug_loc (file
);
7795 DWARF2_External_CompUnit
* external
;
7796 DWARF2_Internal_CompUnit compunit
;
7797 Elf32_Internal_Shdr
* relsec
;
7798 unsigned char * tags
;
7801 unsigned long cu_offset
;
7803 external
= (DWARF2_External_CompUnit
*) start
;
7805 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7806 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7807 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7808 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7810 if (compunit
.cu_length
== 0xffffffff)
7812 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7816 /* Check for RELA relocations in the abbrev_offset address, and
7818 for (relsec
= section_headers
;
7819 relsec
< section_headers
+ elf_header
.e_shnum
;
7822 unsigned long nrelas
;
7823 Elf_Internal_Rela
*rela
, *rp
;
7824 Elf32_Internal_Shdr
*symsec
;
7825 Elf_Internal_Sym
*symtab
;
7826 Elf_Internal_Sym
*sym
;
7828 if (relsec
->sh_type
!= SHT_RELA
7829 || SECTION_HEADER (relsec
->sh_info
) != section
)
7832 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7836 symsec
= SECTION_HEADER (relsec
->sh_link
);
7837 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7839 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7842 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
7848 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7850 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7852 warn (_("Skipping unexpected symbol type %u\n"),
7853 ELF32_ST_TYPE (sym
->st_info
));
7859 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7861 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7863 warn (_("Skipping unexpected symbol type %u\n"),
7864 ELF64_ST_TYPE (sym
->st_info
));
7869 compunit
.cu_abbrev_offset
+= rp
->r_addend
;
7877 tags
= start
+ sizeof (* external
);
7878 cu_offset
= start
- section_begin
;
7879 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
7881 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
7882 printf (_(" Length: %ld\n"), compunit
.cu_length
);
7883 printf (_(" Version: %d\n"), compunit
.cu_version
);
7884 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
7885 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
7887 if (compunit
.cu_version
!= 2)
7889 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7895 /* Read in the abbrevs used by this compilation unit. */
7898 Elf32_Internal_Shdr
* sec
;
7899 unsigned char * begin
;
7901 /* Locate the .debug_abbrev section and process it. */
7902 for (i
= 0, sec
= section_headers
;
7903 i
< elf_header
.e_shnum
;
7905 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
7908 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7910 warn (_("Unable to locate .debug_abbrev section!\n"));
7914 begin
= ((unsigned char *)
7915 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7916 _("debug_abbrev section data")));
7920 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
7921 begin
+ sec
->sh_size
);
7927 while (tags
< start
)
7930 unsigned long abbrev_number
;
7931 abbrev_entry
* entry
;
7934 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
7937 /* A null DIE marks the end of a list of children. */
7938 if (abbrev_number
== 0)
7944 /* Scan through the abbreviation list until we reach the
7946 for (entry
= first_abbrev
;
7947 entry
&& entry
->entry
!= abbrev_number
;
7948 entry
= entry
->next
)
7953 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7958 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7960 (unsigned long) (tags
- section_begin
- bytes_read
),
7962 get_TAG_name (entry
->tag
));
7964 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7965 tags
= read_and_display_attr (attr
->attribute
,
7968 compunit
.cu_pointer_size
);
7970 if (entry
->children
)
7984 display_debug_aranges (section
, start
, file
)
7985 Elf32_Internal_Shdr
* section
;
7986 unsigned char * start
;
7987 FILE * file ATTRIBUTE_UNUSED
;
7989 unsigned char * end
= start
+ section
->sh_size
;
7991 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7995 DWARF2_External_ARange
* external
;
7996 DWARF2_Internal_ARange arange
;
7997 unsigned char * ranges
;
7998 unsigned long length
;
7999 unsigned long address
;
8002 external
= (DWARF2_External_ARange
*) start
;
8004 arange
.ar_length
= BYTE_GET (external
->ar_length
);
8005 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8006 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8007 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8008 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8010 if (arange
.ar_length
== 0xffffffff)
8012 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8016 if (arange
.ar_version
!= 2)
8018 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8022 printf (_(" Length: %ld\n"), arange
.ar_length
);
8023 printf (_(" Version: %d\n"), arange
.ar_version
);
8024 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8025 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8026 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8028 printf (_("\n Address Length\n"));
8030 ranges
= start
+ sizeof (* external
);
8032 /* Must pad to an alignment boundary that is twice the pointer size. */
8033 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
8035 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8039 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8041 ranges
+= arange
.ar_pointer_size
;
8043 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8045 ranges
+= arange
.ar_pointer_size
;
8047 /* A pair of zeros marks the end of the list. */
8048 if (address
== 0 && length
== 0)
8051 printf (" %8.8lx %lu\n", address
, length
);
8054 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8062 typedef struct Frame_Chunk
8064 struct Frame_Chunk
* next
;
8065 unsigned char * chunk_start
;
8067 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8068 short int * col_type
;
8070 char * augmentation
;
8071 unsigned int code_factor
;
8073 unsigned long pc_begin
;
8074 unsigned long pc_range
;
8078 unsigned char fde_encoding
;
8082 /* A marker for a col_type that means this column was never referenced
8083 in the frame info. */
8084 #define DW_CFA_unreferenced (-1)
8086 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8087 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8088 static int size_of_encoded_value
PARAMS ((int));
8091 frame_need_space (fc
, reg
)
8095 int prev
= fc
->ncols
;
8097 if (reg
< fc
->ncols
)
8100 fc
->ncols
= reg
+ 1;
8101 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8102 fc
->ncols
* sizeof (short int));
8103 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8104 fc
->ncols
* sizeof (int));
8106 while (prev
< fc
->ncols
)
8108 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8109 fc
->col_offset
[prev
] = 0;
8115 frame_display_row (fc
, need_col_headers
, max_regs
)
8117 int * need_col_headers
;
8123 if (* max_regs
< fc
->ncols
)
8124 * max_regs
= fc
->ncols
;
8126 if (* need_col_headers
)
8128 * need_col_headers
= 0;
8130 printf (" LOC CFA ");
8132 for (r
= 0; r
< * max_regs
; r
++)
8133 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8138 printf ("r%-4d", r
);
8144 printf ("%08lx ", fc
->pc_begin
);
8145 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8146 printf ("%-8s ", tmp
);
8148 for (r
= 0; r
< fc
->ncols
; r
++)
8150 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8152 switch (fc
->col_type
[r
])
8154 case DW_CFA_undefined
:
8157 case DW_CFA_same_value
:
8161 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8163 case DW_CFA_register
:
8164 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8167 strcpy (tmp
, "n/a");
8170 printf ("%-5s", tmp
);
8177 size_of_encoded_value (encoding
)
8180 switch (encoding
& 0x7)
8183 case 0: return is_32bit_elf
? 4 : 8;
8190 #define GET(N) byte_get (start, N); start += N
8191 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8192 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8195 display_debug_frames (section
, start
, file
)
8196 Elf32_Internal_Shdr
* section
;
8197 unsigned char * start
;
8198 FILE * file ATTRIBUTE_UNUSED
;
8200 unsigned char * end
= start
+ section
->sh_size
;
8201 unsigned char * section_start
= start
;
8202 Frame_Chunk
* chunks
= 0;
8203 Frame_Chunk
* remembered_state
= 0;
8205 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8208 int addr_size
= is_32bit_elf
? 4 : 8;
8210 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8214 unsigned char * saved_start
;
8215 unsigned char * block_end
;
8216 unsigned long length
;
8217 unsigned long cie_id
;
8220 int need_col_headers
= 1;
8221 unsigned char * augmentation_data
= NULL
;
8222 unsigned long augmentation_data_len
= 0;
8223 int encoded_ptr_size
= addr_size
;
8225 saved_start
= start
;
8226 length
= byte_get (start
, 4); start
+= 4;
8231 if (length
== 0xffffffff)
8233 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8237 block_end
= saved_start
+ length
+ 4;
8238 cie_id
= byte_get (start
, 4); start
+= 4;
8240 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8244 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8245 memset (fc
, 0, sizeof (Frame_Chunk
));
8249 fc
->chunk_start
= saved_start
;
8251 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8252 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8253 frame_need_space (fc
, max_regs
-1);
8257 fc
->augmentation
= start
;
8258 start
= strchr (start
, '\0') + 1;
8260 if (fc
->augmentation
[0] == 'z')
8262 fc
->code_factor
= LEB ();
8263 fc
->data_factor
= SLEB ();
8264 fc
->ra
= byte_get (start
, 1); start
+= 1;
8265 augmentation_data_len
= LEB ();
8266 augmentation_data
= start
;
8267 start
+= augmentation_data_len
;
8269 else if (strcmp (fc
->augmentation
, "eh") == 0)
8272 fc
->code_factor
= LEB ();
8273 fc
->data_factor
= SLEB ();
8274 fc
->ra
= byte_get (start
, 1); start
+= 1;
8278 fc
->code_factor
= LEB ();
8279 fc
->data_factor
= SLEB ();
8280 fc
->ra
= byte_get (start
, 1); start
+= 1;
8284 if (do_debug_frames_interp
)
8285 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8286 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8287 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8291 printf ("\n%08lx %08lx %08lx CIE\n",
8292 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8293 printf (" Version: %d\n", version
);
8294 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8295 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8296 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8297 printf (" Return address column: %d\n", fc
->ra
);
8299 if (augmentation_data_len
)
8302 printf (" Augmentation data: ");
8303 for (i
= 0; i
< augmentation_data_len
; ++i
)
8304 printf (" %02x", augmentation_data
[i
]);
8310 if (augmentation_data_len
)
8312 unsigned char *p
, *q
;
8313 p
= fc
->augmentation
+ 1;
8314 q
= augmentation_data
;
8321 q
+= 1 + size_of_encoded_value (*q
);
8323 fc
->fde_encoding
= *q
++;
8329 if (fc
->fde_encoding
)
8330 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8333 frame_need_space (fc
, fc
->ra
);
8337 unsigned char * look_for
;
8338 static Frame_Chunk fde_fc
;
8341 memset (fc
, 0, sizeof (Frame_Chunk
));
8343 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8345 for (cie
= chunks
; cie
; cie
= cie
->next
)
8346 if (cie
->chunk_start
== look_for
)
8351 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8352 cie_id
, saved_start
);
8355 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8356 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8357 frame_need_space (fc
, max_regs
- 1);
8359 fc
->augmentation
= "";
8360 fc
->fde_encoding
= 0;
8364 fc
->ncols
= cie
->ncols
;
8365 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8366 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8367 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8368 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8369 fc
->augmentation
= cie
->augmentation
;
8370 fc
->code_factor
= cie
->code_factor
;
8371 fc
->data_factor
= cie
->data_factor
;
8372 fc
->cfa_reg
= cie
->cfa_reg
;
8373 fc
->cfa_offset
= cie
->cfa_offset
;
8375 frame_need_space (fc
, max_regs
-1);
8376 fc
->fde_encoding
= cie
->fde_encoding
;
8379 if (fc
->fde_encoding
)
8380 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8382 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8383 start
+= encoded_ptr_size
;
8384 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8385 start
+= encoded_ptr_size
;
8387 if (cie
->augmentation
[0] == 'z')
8389 augmentation_data_len
= LEB ();
8390 augmentation_data
= start
;
8391 start
+= augmentation_data_len
;
8394 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8395 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8396 (unsigned long)(cie
->chunk_start
- section_start
),
8397 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8398 if (! do_debug_frames_interp
&& augmentation_data_len
)
8401 printf (" Augmentation data: ");
8402 for (i
= 0; i
< augmentation_data_len
; ++i
)
8403 printf (" %02x", augmentation_data
[i
]);
8409 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8410 about to interpret instructions for the chunk. */
8412 if (do_debug_frames_interp
)
8414 /* Start by making a pass over the chunk, allocating storage
8415 and taking note of what registers are used. */
8416 unsigned char * tmp
= start
;
8418 while (start
< block_end
)
8428 /* Warning: if you add any more cases to this switch, be
8429 sure to add them to the corresponding switch below. */
8432 case DW_CFA_advance_loc
:
8436 frame_need_space (fc
, opa
);
8437 fc
->col_type
[opa
] = DW_CFA_undefined
;
8439 case DW_CFA_restore
:
8440 frame_need_space (fc
, opa
);
8441 fc
->col_type
[opa
] = DW_CFA_undefined
;
8443 case DW_CFA_set_loc
:
8444 start
+= encoded_ptr_size
;
8446 case DW_CFA_advance_loc1
:
8449 case DW_CFA_advance_loc2
:
8452 case DW_CFA_advance_loc4
:
8455 case DW_CFA_offset_extended
:
8456 reg
= LEB (); LEB ();
8457 frame_need_space (fc
, reg
);
8458 fc
->col_type
[reg
] = DW_CFA_undefined
;
8460 case DW_CFA_restore_extended
:
8462 frame_need_space (fc
, reg
);
8463 fc
->col_type
[reg
] = DW_CFA_undefined
;
8465 case DW_CFA_undefined
:
8467 frame_need_space (fc
, reg
);
8468 fc
->col_type
[reg
] = DW_CFA_undefined
;
8470 case DW_CFA_same_value
:
8472 frame_need_space (fc
, reg
);
8473 fc
->col_type
[reg
] = DW_CFA_undefined
;
8475 case DW_CFA_register
:
8476 reg
= LEB (); LEB ();
8477 frame_need_space (fc
, reg
);
8478 fc
->col_type
[reg
] = DW_CFA_undefined
;
8480 case DW_CFA_def_cfa
:
8483 case DW_CFA_def_cfa_register
:
8486 case DW_CFA_def_cfa_offset
:
8489 case DW_CFA_offset_extended_sf
:
8490 reg
= LEB (); SLEB ();
8491 frame_need_space (fc
, reg
);
8492 fc
->col_type
[reg
] = DW_CFA_undefined
;
8494 case DW_CFA_def_cfa_sf
:
8497 case DW_CFA_def_cfa_offset_sf
:
8500 case DW_CFA_GNU_args_size
:
8503 case DW_CFA_GNU_negative_offset_extended
:
8504 reg
= LEB (); LEB ();
8505 frame_need_space (fc
, reg
);
8506 fc
->col_type
[reg
] = DW_CFA_undefined
;
8515 /* Now we know what registers are used, make a second pass over
8516 the chunk, this time actually printing out the info. */
8518 while (start
< block_end
)
8521 unsigned long ul
, reg
, roffs
;
8530 /* Warning: if you add any more cases to this switch, be
8531 sure to add them to the corresponding switch above. */
8534 case DW_CFA_advance_loc
:
8535 if (do_debug_frames_interp
)
8536 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8538 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8539 opa
* fc
->code_factor
,
8540 fc
->pc_begin
+ opa
* fc
->code_factor
);
8541 fc
->pc_begin
+= opa
* fc
->code_factor
;
8546 if (! do_debug_frames_interp
)
8547 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8548 opa
, roffs
* fc
->data_factor
);
8549 fc
->col_type
[opa
] = DW_CFA_offset
;
8550 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8553 case DW_CFA_restore
:
8554 if (! do_debug_frames_interp
)
8555 printf (" DW_CFA_restore: r%d\n", opa
);
8556 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8557 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8560 case DW_CFA_set_loc
:
8561 vma
= byte_get (start
, encoded_ptr_size
);
8562 start
+= encoded_ptr_size
;
8563 if (do_debug_frames_interp
)
8564 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8566 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8570 case DW_CFA_advance_loc1
:
8571 ofs
= byte_get (start
, 1); start
+= 1;
8572 if (do_debug_frames_interp
)
8573 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8575 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8576 ofs
* fc
->code_factor
,
8577 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8578 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8581 case DW_CFA_advance_loc2
:
8582 ofs
= byte_get (start
, 2); start
+= 2;
8583 if (do_debug_frames_interp
)
8584 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8586 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8587 ofs
* fc
->code_factor
,
8588 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8589 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8592 case DW_CFA_advance_loc4
:
8593 ofs
= byte_get (start
, 4); start
+= 4;
8594 if (do_debug_frames_interp
)
8595 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8597 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8598 ofs
* fc
->code_factor
,
8599 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8600 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8603 case DW_CFA_offset_extended
:
8606 if (! do_debug_frames_interp
)
8607 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8608 reg
, roffs
* fc
->data_factor
);
8609 fc
->col_type
[reg
] = DW_CFA_offset
;
8610 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8613 case DW_CFA_restore_extended
:
8615 if (! do_debug_frames_interp
)
8616 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8617 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8618 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8621 case DW_CFA_undefined
:
8623 if (! do_debug_frames_interp
)
8624 printf (" DW_CFA_undefined: r%ld\n", reg
);
8625 fc
->col_type
[reg
] = DW_CFA_undefined
;
8626 fc
->col_offset
[reg
] = 0;
8629 case DW_CFA_same_value
:
8631 if (! do_debug_frames_interp
)
8632 printf (" DW_CFA_same_value: r%ld\n", reg
);
8633 fc
->col_type
[reg
] = DW_CFA_same_value
;
8634 fc
->col_offset
[reg
] = 0;
8637 case DW_CFA_register
:
8640 if (! do_debug_frames_interp
)
8641 printf (" DW_CFA_register: r%ld\n", reg
);
8642 fc
->col_type
[reg
] = DW_CFA_register
;
8643 fc
->col_offset
[reg
] = roffs
;
8646 case DW_CFA_remember_state
:
8647 if (! do_debug_frames_interp
)
8648 printf (" DW_CFA_remember_state\n");
8649 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8650 rs
->ncols
= fc
->ncols
;
8651 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8652 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8653 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8654 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8655 rs
->next
= remembered_state
;
8656 remembered_state
= rs
;
8659 case DW_CFA_restore_state
:
8660 if (! do_debug_frames_interp
)
8661 printf (" DW_CFA_restore_state\n");
8662 rs
= remembered_state
;
8663 remembered_state
= rs
->next
;
8664 frame_need_space (fc
, rs
->ncols
-1);
8665 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8666 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8667 free (rs
->col_type
);
8668 free (rs
->col_offset
);
8672 case DW_CFA_def_cfa
:
8673 fc
->cfa_reg
= LEB ();
8674 fc
->cfa_offset
= LEB ();
8675 if (! do_debug_frames_interp
)
8676 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8677 fc
->cfa_reg
, fc
->cfa_offset
);
8680 case DW_CFA_def_cfa_register
:
8681 fc
->cfa_reg
= LEB ();
8682 if (! do_debug_frames_interp
)
8683 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8686 case DW_CFA_def_cfa_offset
:
8687 fc
->cfa_offset
= LEB ();
8688 if (! do_debug_frames_interp
)
8689 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8693 if (! do_debug_frames_interp
)
8694 printf (" DW_CFA_nop\n");
8697 case DW_CFA_offset_extended_sf
:
8700 frame_need_space (fc
, reg
);
8701 if (! do_debug_frames_interp
)
8702 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8703 reg
, l
* fc
->data_factor
);
8704 fc
->col_type
[reg
] = DW_CFA_offset
;
8705 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8708 case DW_CFA_def_cfa_sf
:
8709 fc
->cfa_reg
= LEB ();
8710 fc
->cfa_offset
= SLEB ();
8711 if (! do_debug_frames_interp
)
8712 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8713 fc
->cfa_reg
, fc
->cfa_offset
);
8716 case DW_CFA_def_cfa_offset_sf
:
8717 fc
->cfa_offset
= SLEB ();
8718 if (! do_debug_frames_interp
)
8719 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
8722 case DW_CFA_GNU_window_save
:
8723 if (! do_debug_frames_interp
)
8724 printf (" DW_CFA_GNU_window_save\n");
8727 case DW_CFA_GNU_args_size
:
8729 if (! do_debug_frames_interp
)
8730 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8733 case DW_CFA_GNU_negative_offset_extended
:
8736 frame_need_space (fc
, reg
);
8737 if (! do_debug_frames_interp
)
8738 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8739 reg
, l
* fc
->data_factor
);
8740 fc
->col_type
[reg
] = DW_CFA_offset
;
8741 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8744 /* FIXME: How do we handle these? */
8745 case DW_CFA_def_cfa_expression
:
8746 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
8750 case DW_CFA_expression
:
8751 fprintf (stderr
, "unsupported DW_CFA_expression\n");
8756 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8761 if (do_debug_frames_interp
)
8762 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8777 display_debug_not_supported (section
, start
, file
)
8778 Elf32_Internal_Shdr
* section
;
8779 unsigned char * start ATTRIBUTE_UNUSED
;
8780 FILE * file ATTRIBUTE_UNUSED
;
8782 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8783 SECTION_NAME (section
));
8788 /* Pre-scan the .debug_info section to record the size of address.
8789 When dumping the .debug_line, we use that size information, assuming
8790 that all compilation units have the same address size. */
8792 prescan_debug_info (section
, start
, file
)
8793 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8794 unsigned char * start
;
8795 FILE * file ATTRIBUTE_UNUSED
;
8797 DWARF2_External_CompUnit
* external
;
8799 external
= (DWARF2_External_CompUnit
*) start
;
8801 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8805 /* A structure containing the name of a debug section and a pointer
8806 to a function that can decode it. The third field is a prescan
8807 function to be run over the section before displaying any of the
8811 const char * const name
;
8812 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8813 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8817 { ".debug_abbrev", display_debug_abbrev
, NULL
},
8818 { ".debug_aranges", display_debug_aranges
, NULL
},
8819 { ".debug_frame", display_debug_frames
, NULL
},
8820 { ".debug_info", display_debug_info
, prescan_debug_info
},
8821 { ".debug_line", display_debug_lines
, NULL
},
8822 { ".debug_pubnames", display_debug_pubnames
, NULL
},
8823 { ".eh_frame", display_debug_frames
, NULL
},
8824 { ".debug_macinfo", display_debug_macinfo
, NULL
},
8825 { ".debug_str", display_debug_str
, NULL
},
8826 { ".debug_loc", display_debug_loc
, NULL
},
8827 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
8828 { ".debug_ranges", display_debug_not_supported
, NULL
},
8829 { ".debug_static_func", display_debug_not_supported
, NULL
},
8830 { ".debug_static_vars", display_debug_not_supported
, NULL
},
8831 { ".debug_types", display_debug_not_supported
, NULL
},
8832 { ".debug_weaknames", display_debug_not_supported
, NULL
}
8836 display_debug_section (section
, file
)
8837 Elf32_Internal_Shdr
* section
;
8840 char * name
= SECTION_NAME (section
);
8841 bfd_size_type length
;
8842 unsigned char * start
;
8845 length
= section
->sh_size
;
8848 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8852 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
8853 _("debug section data"));
8857 /* See if we know how to display the contents of this section. */
8858 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
8859 name
= ".debug_info";
8861 for (i
= NUM_ELEM (debug_displays
); i
--;)
8862 if (strcmp (debug_displays
[i
].name
, name
) == 0)
8864 debug_displays
[i
].display (section
, start
, file
);
8869 printf (_("Unrecognized debug section: %s\n"), name
);
8873 /* If we loaded in the abbrev section at some point,
8874 we must release it here. */
8881 process_section_contents (file
)
8884 Elf32_Internal_Shdr
* section
;
8890 /* Pre-scan the debug sections to find some debug information not
8891 present in some of them. For the .debug_line, we must find out the
8892 size of address (specified in .debug_info and .debug_aranges). */
8893 for (i
= 0, section
= section_headers
;
8894 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8897 char * name
= SECTION_NAME (section
);
8900 if (section
->sh_size
== 0)
8903 /* See if there is some pre-scan operation for this section. */
8904 for (j
= NUM_ELEM (debug_displays
); j
--;)
8905 if (strcmp (debug_displays
[j
].name
, name
) == 0)
8907 if (debug_displays
[j
].prescan
!= NULL
)
8909 bfd_size_type length
;
8910 unsigned char * start
;
8912 length
= section
->sh_size
;
8913 start
= ((unsigned char *)
8914 get_data (NULL
, file
, section
->sh_offset
, length
,
8915 _("debug section data")));
8919 debug_displays
[j
].prescan (section
, start
, file
);
8927 for (i
= 0, section
= section_headers
;
8928 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8931 #ifdef SUPPORT_DISASSEMBLY
8932 if (dump_sects
[i
] & DISASS_DUMP
)
8933 disassemble_section (section
, file
);
8935 if (dump_sects
[i
] & HEX_DUMP
)
8936 dump_section (section
, file
);
8938 if (dump_sects
[i
] & DEBUG_DUMP
)
8939 display_debug_section (section
, file
);
8942 if (i
< num_dump_sects
)
8943 warn (_("Some sections were not dumped because they do not exist!\n"));
8949 process_mips_fpe_exception (mask
)
8955 if (mask
& OEX_FPU_INEX
)
8956 fputs ("INEX", stdout
), first
= 0;
8957 if (mask
& OEX_FPU_UFLO
)
8958 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8959 if (mask
& OEX_FPU_OFLO
)
8960 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8961 if (mask
& OEX_FPU_DIV0
)
8962 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8963 if (mask
& OEX_FPU_INVAL
)
8964 printf ("%sINVAL", first
? "" : "|");
8967 fputs ("0", stdout
);
8971 process_mips_specific (file
)
8974 Elf_Internal_Dyn
* entry
;
8975 size_t liblist_offset
= 0;
8976 size_t liblistno
= 0;
8977 size_t conflictsno
= 0;
8978 size_t options_offset
= 0;
8979 size_t conflicts_offset
= 0;
8981 /* We have a lot of special sections. Thanks SGI! */
8982 if (dynamic_segment
== NULL
)
8983 /* No information available. */
8986 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
8987 switch (entry
->d_tag
)
8989 case DT_MIPS_LIBLIST
:
8990 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
8992 case DT_MIPS_LIBLISTNO
:
8993 liblistno
= entry
->d_un
.d_val
;
8995 case DT_MIPS_OPTIONS
:
8996 options_offset
= entry
->d_un
.d_val
- loadaddr
;
8998 case DT_MIPS_CONFLICT
:
8999 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
9001 case DT_MIPS_CONFLICTNO
:
9002 conflictsno
= entry
->d_un
.d_val
;
9008 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9010 Elf32_External_Lib
* elib
;
9013 elib
= ((Elf32_External_Lib
*)
9014 get_data (NULL
, file
, liblist_offset
,
9015 liblistno
* sizeof (Elf32_External_Lib
),
9019 printf ("\nSection '.liblist' contains %lu entries:\n",
9020 (unsigned long) liblistno
);
9021 fputs (" Library Time Stamp Checksum Version Flags\n",
9024 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9031 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9032 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9033 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9034 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9035 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9037 tmp
= gmtime (&time
);
9038 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9039 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9040 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9042 printf ("%3lu: ", (unsigned long) cnt
);
9043 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9044 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9047 if (liblist
.l_flags
== 0)
9058 { " EXACT_MATCH", LL_EXACT_MATCH
},
9059 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9060 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9061 { " EXPORTS", LL_EXPORTS
},
9062 { " DELAY_LOAD", LL_DELAY_LOAD
},
9063 { " DELTA", LL_DELTA
}
9065 int flags
= liblist
.l_flags
;
9069 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9071 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9073 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9074 flags
^= l_flags_vals
[fcnt
].bit
;
9077 printf (" %#x", (unsigned int) flags
);
9087 if (options_offset
!= 0)
9089 Elf_External_Options
* eopt
;
9090 Elf_Internal_Shdr
* sect
= section_headers
;
9091 Elf_Internal_Options
* iopt
;
9092 Elf_Internal_Options
* option
;
9096 /* Find the section header so that we get the size. */
9097 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9100 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9101 sect
->sh_size
, _("options"));
9104 iopt
= ((Elf_Internal_Options
*)
9105 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
9108 error (_("Out of memory"));
9115 while (offset
< sect
->sh_size
)
9117 Elf_External_Options
* eoption
;
9119 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9121 option
->kind
= BYTE_GET (eoption
->kind
);
9122 option
->size
= BYTE_GET (eoption
->size
);
9123 option
->section
= BYTE_GET (eoption
->section
);
9124 option
->info
= BYTE_GET (eoption
->info
);
9126 offset
+= option
->size
;
9132 printf (_("\nSection '%s' contains %d entries:\n"),
9133 SECTION_NAME (sect
), cnt
);
9141 switch (option
->kind
)
9144 /* This shouldn't happen. */
9145 printf (" NULL %d %lx", option
->section
, option
->info
);
9148 printf (" REGINFO ");
9149 if (elf_header
.e_machine
== EM_MIPS
)
9152 Elf32_External_RegInfo
* ereg
;
9153 Elf32_RegInfo reginfo
;
9155 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9156 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9157 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9158 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9159 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9160 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9161 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9163 printf ("GPR %08lx GP 0x%lx\n",
9165 (unsigned long) reginfo
.ri_gp_value
);
9166 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9167 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9168 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9173 Elf64_External_RegInfo
* ereg
;
9174 Elf64_Internal_RegInfo reginfo
;
9176 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9177 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9178 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9179 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9180 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9181 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9182 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9184 printf ("GPR %08lx GP 0x",
9185 reginfo
.ri_gprmask
);
9186 printf_vma (reginfo
.ri_gp_value
);
9189 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9190 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9191 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9195 case ODK_EXCEPTIONS
:
9196 fputs (" EXCEPTIONS fpe_min(", stdout
);
9197 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9198 fputs (") fpe_max(", stdout
);
9199 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9200 fputs (")", stdout
);
9202 if (option
->info
& OEX_PAGE0
)
9203 fputs (" PAGE0", stdout
);
9204 if (option
->info
& OEX_SMM
)
9205 fputs (" SMM", stdout
);
9206 if (option
->info
& OEX_FPDBUG
)
9207 fputs (" FPDBUG", stdout
);
9208 if (option
->info
& OEX_DISMISS
)
9209 fputs (" DISMISS", stdout
);
9212 fputs (" PAD ", stdout
);
9213 if (option
->info
& OPAD_PREFIX
)
9214 fputs (" PREFIX", stdout
);
9215 if (option
->info
& OPAD_POSTFIX
)
9216 fputs (" POSTFIX", stdout
);
9217 if (option
->info
& OPAD_SYMBOL
)
9218 fputs (" SYMBOL", stdout
);
9221 fputs (" HWPATCH ", stdout
);
9222 if (option
->info
& OHW_R4KEOP
)
9223 fputs (" R4KEOP", stdout
);
9224 if (option
->info
& OHW_R8KPFETCH
)
9225 fputs (" R8KPFETCH", stdout
);
9226 if (option
->info
& OHW_R5KEOP
)
9227 fputs (" R5KEOP", stdout
);
9228 if (option
->info
& OHW_R5KCVTL
)
9229 fputs (" R5KCVTL", stdout
);
9232 fputs (" FILL ", stdout
);
9233 /* XXX Print content of info word? */
9236 fputs (" TAGS ", stdout
);
9237 /* XXX Print content of info word? */
9240 fputs (" HWAND ", stdout
);
9241 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9242 fputs (" R4KEOP_CHECKED", stdout
);
9243 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9244 fputs (" R4KEOP_CLEAN", stdout
);
9247 fputs (" HWOR ", stdout
);
9248 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9249 fputs (" R4KEOP_CHECKED", stdout
);
9250 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9251 fputs (" R4KEOP_CLEAN", stdout
);
9254 printf (" GP_GROUP %#06lx self-contained %#06lx",
9255 option
->info
& OGP_GROUP
,
9256 (option
->info
& OGP_SELF
) >> 16);
9259 printf (" IDENT %#06lx self-contained %#06lx",
9260 option
->info
& OGP_GROUP
,
9261 (option
->info
& OGP_SELF
) >> 16);
9264 /* This shouldn't happen. */
9265 printf (" %3d ??? %d %lx",
9266 option
->kind
, option
->section
, option
->info
);
9270 len
= sizeof (* eopt
);
9271 while (len
< option
->size
)
9272 if (((char *) option
)[len
] >= ' '
9273 && ((char *) option
)[len
] < 0x7f)
9274 printf ("%c", ((char *) option
)[len
++]);
9276 printf ("\\%03o", ((char *) option
)[len
++]);
9278 fputs ("\n", stdout
);
9286 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9288 Elf32_Conflict
* iconf
;
9291 if (dynamic_symbols
== NULL
)
9293 error (_("conflict list found without a dynamic symbol table"));
9297 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
9300 error (_("Out of memory"));
9306 Elf32_External_Conflict
* econf32
;
9308 econf32
= ((Elf32_External_Conflict
*)
9309 get_data (NULL
, file
, conflicts_offset
,
9310 conflictsno
* sizeof (* econf32
),
9315 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9316 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9322 Elf64_External_Conflict
* econf64
;
9324 econf64
= ((Elf64_External_Conflict
*)
9325 get_data (NULL
, file
, conflicts_offset
,
9326 conflictsno
* sizeof (* econf64
),
9331 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9332 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9337 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9338 (long) conflictsno
);
9339 puts (_(" Num: Index Value Name"));
9341 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9343 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9345 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9346 print_vma (psym
->st_value
, FULL_HEX
);
9348 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9359 get_note_type (e_type
)
9362 static char buff
[64];
9366 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9367 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9368 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9369 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9370 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9371 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9372 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9373 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9374 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9375 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9376 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9378 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9384 get_netbsd_elfcore_note_type (e_type
)
9387 static char buff
[64];
9389 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9391 /* NetBSD core "procinfo" structure. */
9392 return _("NetBSD procinfo structure");
9395 /* As of Jan 2002 there are no other machine-independent notes
9396 defined for NetBSD core files. If the note type is less
9397 than the start of the machine-dependent note types, we don't
9400 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9402 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9406 switch (elf_header
.e_machine
)
9408 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9409 and PT_GETFPREGS == mach+2. */
9414 case EM_SPARC32PLUS
:
9418 case NT_NETBSDCORE_FIRSTMACH
+0:
9419 return _("PT_GETREGS (reg structure)");
9420 case NT_NETBSDCORE_FIRSTMACH
+2:
9421 return _("PT_GETFPREGS (fpreg structure)");
9427 /* On all other arch's, PT_GETREGS == mach+1 and
9428 PT_GETFPREGS == mach+3. */
9432 case NT_NETBSDCORE_FIRSTMACH
+1:
9433 return _("PT_GETREGS (reg structure)");
9434 case NT_NETBSDCORE_FIRSTMACH
+3:
9435 return _("PT_GETFPREGS (fpreg structure)");
9441 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9445 /* Note that by the ELF standard, the name field is already null byte
9446 terminated, and namesz includes the terminating null byte.
9447 I.E. the value of namesz for the name "FSF" is 4.
9449 If the value of namesz is zero, there is no name present. */
9451 process_note (pnote
)
9452 Elf32_Internal_Note
* pnote
;
9456 if (pnote
->namesz
== 0)
9458 /* If there is no note name, then use the default set of
9459 note type strings. */
9460 nt
= get_note_type (pnote
->type
);
9462 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9464 /* NetBSD-specific core file notes. */
9465 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9469 /* Don't recognize this note name; just use the default set of
9470 note type strings. */
9471 nt
= get_note_type (pnote
->type
);
9474 printf (" %s\t\t0x%08lx\t%s\n",
9475 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9482 process_corefile_note_segment (file
, offset
, length
)
9487 Elf_External_Note
* pnotes
;
9488 Elf_External_Note
* external
;
9494 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9501 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9502 (unsigned long) offset
, (unsigned long) length
);
9503 printf (_(" Owner\t\tData size\tDescription\n"));
9505 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9507 Elf_External_Note
* next
;
9508 Elf32_Internal_Note inote
;
9511 inote
.type
= BYTE_GET (external
->type
);
9512 inote
.namesz
= BYTE_GET (external
->namesz
);
9513 inote
.namedata
= external
->name
;
9514 inote
.descsz
= BYTE_GET (external
->descsz
);
9515 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9516 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9518 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9520 if (((char *) next
) > (((char *) pnotes
) + length
))
9522 warn (_("corrupt note found at offset %x into core notes\n"),
9523 ((char *) external
) - ((char *) pnotes
));
9524 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9525 inote
.type
, inote
.namesz
, inote
.descsz
);
9531 /* Verify that name is null terminated. It appears that at least
9532 one version of Linux (RedHat 6.0) generates corefiles that don't
9533 comply with the ELF spec by failing to include the null byte in
9535 if (inote
.namedata
[inote
.namesz
] != '\0')
9537 temp
= malloc (inote
.namesz
+ 1);
9541 error (_("Out of memory\n"));
9546 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9547 temp
[inote
.namesz
] = 0;
9549 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9550 inote
.namedata
= temp
;
9553 res
&= process_note (& inote
);
9568 process_corefile_note_segments (file
)
9571 Elf_Internal_Phdr
* program_headers
;
9572 Elf_Internal_Phdr
* segment
;
9576 program_headers
= (Elf_Internal_Phdr
*) malloc
9577 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9579 if (program_headers
== NULL
)
9581 error (_("Out of memory\n"));
9586 i
= get_32bit_program_headers (file
, program_headers
);
9588 i
= get_64bit_program_headers (file
, program_headers
);
9592 free (program_headers
);
9596 for (i
= 0, segment
= program_headers
;
9597 i
< elf_header
.e_phnum
;
9600 if (segment
->p_type
== PT_NOTE
)
9601 res
&= process_corefile_note_segment (file
,
9602 (bfd_vma
) segment
->p_offset
,
9603 (bfd_vma
) segment
->p_filesz
);
9606 free (program_headers
);
9612 process_corefile_contents (file
)
9615 /* If we have not been asked to display the notes then do nothing. */
9619 /* If file is not a core file then exit. */
9620 if (elf_header
.e_type
!= ET_CORE
)
9623 /* No program headers means no NOTE segment. */
9624 if (elf_header
.e_phnum
== 0)
9626 printf (_("No note segments present in the core file.\n"));
9630 return process_corefile_note_segments (file
);
9634 process_arch_specific (file
)
9640 switch (elf_header
.e_machine
)
9643 case EM_MIPS_RS3_LE
:
9644 return process_mips_specific (file
);
9653 get_file_header (file
)
9656 /* Read in the identity array. */
9657 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9660 /* Determine how to read the rest of the header. */
9661 switch (elf_header
.e_ident
[EI_DATA
])
9663 default: /* fall through */
9664 case ELFDATANONE
: /* fall through */
9665 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9666 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9669 /* For now we only support 32 bit and 64 bit ELF files. */
9670 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9672 /* Read in the rest of the header. */
9675 Elf32_External_Ehdr ehdr32
;
9677 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9680 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9681 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9682 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9683 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9684 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9685 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9686 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9687 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9688 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9689 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9690 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9691 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9692 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9696 Elf64_External_Ehdr ehdr64
;
9698 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9699 we will not be able to cope with the 64bit data found in
9700 64 ELF files. Detect this now and abort before we start
9701 overwritting things. */
9702 if (sizeof (bfd_vma
) < 8)
9704 error (_("This instance of readelf has been built without support for a\n\
9705 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9709 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9712 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9713 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9714 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9715 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9716 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9717 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9718 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9719 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9720 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9721 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9722 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9723 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9724 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9727 if (elf_header
.e_shoff
)
9729 /* There may be some extensions in the first section header. Don't
9730 bomb if we can't read it. */
9732 get_32bit_section_headers (file
, 1);
9734 get_64bit_section_headers (file
, 1);
9741 process_file (file_name
)
9745 struct stat statbuf
;
9748 if (stat (file_name
, & statbuf
) < 0)
9750 error (_("Cannot stat input file %s.\n"), file_name
);
9754 file
= fopen (file_name
, "rb");
9757 error (_("Input file %s not found.\n"), file_name
);
9761 if (! get_file_header (file
))
9763 error (_("%s: Failed to read file header\n"), file_name
);
9768 /* Initialise per file variables. */
9769 for (i
= NUM_ELEM (version_info
); i
--;)
9770 version_info
[i
] = 0;
9772 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9773 dynamic_info
[i
] = 0;
9775 /* Process the file. */
9777 printf (_("\nFile: %s\n"), file_name
);
9779 if (! process_file_header ())
9785 process_section_headers (file
);
9787 process_program_headers (file
);
9789 process_dynamic_segment (file
);
9791 process_relocs (file
);
9793 process_unwind (file
);
9795 process_symbol_table (file
);
9797 process_syminfo (file
);
9799 process_version_sections (file
);
9801 process_section_contents (file
);
9803 process_corefile_contents (file
);
9805 process_arch_specific (file
);
9809 if (section_headers
)
9811 free (section_headers
);
9812 section_headers
= NULL
;
9817 free (string_table
);
9818 string_table
= NULL
;
9819 string_table_length
= 0;
9822 if (dynamic_strings
)
9824 free (dynamic_strings
);
9825 dynamic_strings
= NULL
;
9828 if (dynamic_symbols
)
9830 free (dynamic_symbols
);
9831 dynamic_symbols
= NULL
;
9832 num_dynamic_syms
= 0;
9835 if (dynamic_syminfo
)
9837 free (dynamic_syminfo
);
9838 dynamic_syminfo
= NULL
;
9844 #ifdef SUPPORT_DISASSEMBLY
9845 /* Needed by the i386 disassembler. For extra credit, someone could
9846 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9850 print_address (unsigned int addr
, FILE * outfile
)
9852 fprintf (outfile
,"0x%8.8x", addr
);
9855 /* Needed by the i386 disassembler. */
9857 db_task_printsym (unsigned int addr
)
9859 print_address (addr
, stderr
);
9863 int main
PARAMS ((int, char **));
9872 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9873 setlocale (LC_MESSAGES
, "");
9875 #if defined (HAVE_SETLOCALE)
9876 setlocale (LC_CTYPE
, "");
9878 bindtextdomain (PACKAGE
, LOCALEDIR
);
9879 textdomain (PACKAGE
);
9881 parse_args (argc
, argv
);
9883 if (optind
< (argc
- 1))
9887 while (optind
< argc
)
9888 err
|= process_file (argv
[optind
++]);
9890 if (dump_sects
!= NULL
)