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"
68 #include "elf/mcore.h"
71 #include "elf/mn10200.h"
72 #include "elf/mn10300.h"
78 #include "elf/sparc.h"
80 #include "elf/x86-64.h"
81 #include "elf/xstormy16.h"
86 char * program_name
= "readelf";
87 unsigned int dynamic_addr
;
88 bfd_size_type dynamic_size
;
89 unsigned int rela_addr
;
90 unsigned int rela_size
;
91 char * dynamic_strings
;
93 unsigned long string_table_length
;
94 unsigned long num_dynamic_syms
;
95 Elf_Internal_Sym
* dynamic_symbols
;
96 Elf_Internal_Syminfo
* dynamic_syminfo
;
97 unsigned long dynamic_syminfo_offset
;
98 unsigned int dynamic_syminfo_nent
;
99 char program_interpreter
[64];
100 int dynamic_info
[DT_JMPREL
+ 1];
101 int version_info
[16];
103 Elf_Internal_Ehdr elf_header
;
104 Elf_Internal_Shdr
* section_headers
;
105 Elf_Internal_Dyn
* dynamic_segment
;
106 Elf_Internal_Shdr
* symtab_shndx_hdr
;
114 int do_using_dynamic
;
122 int do_debug_abbrevs
;
124 int do_debug_pubnames
;
125 int do_debug_aranges
;
127 int do_debug_frames_interp
;
128 int do_debug_macinfo
;
135 /* A dynamic array of flags indicating which sections require dumping. */
136 char * dump_sects
= NULL
;
137 unsigned int num_dump_sects
= 0;
139 #define HEX_DUMP (1 << 0)
140 #define DISASS_DUMP (1 << 1)
141 #define DEBUG_DUMP (1 << 2)
143 /* How to rpint a vma value. */
144 typedef enum print_mode
156 /* Forward declarations for dumb compilers. */
157 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
158 static void print_symbol
PARAMS ((int, char *));
159 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
160 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
161 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
162 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
163 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
164 static const char * get_ppc64_dynamic_type
PARAMS ((unsigned long));
165 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
166 static const char * get_dynamic_type
PARAMS ((unsigned long));
167 static int slurp_rela_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**, unsigned long *));
168 static int slurp_rel_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel
**, unsigned long *));
169 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
170 static char * get_file_type
PARAMS ((unsigned));
171 static char * get_machine_name
PARAMS ((unsigned));
172 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
173 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
174 static const char * get_mips_segment_type
PARAMS ((unsigned long));
175 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
176 static const char * get_ia64_segment_type
PARAMS ((unsigned long));
177 static const char * get_segment_type
PARAMS ((unsigned long));
178 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
179 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
180 static const char * get_ia64_section_type_name
PARAMS ((unsigned int));
181 static const char * get_section_type_name
PARAMS ((unsigned int));
182 static const char * get_symbol_binding
PARAMS ((unsigned int));
183 static const char * get_symbol_type
PARAMS ((unsigned int));
184 static const char * get_symbol_visibility
PARAMS ((unsigned int));
185 static const char * get_symbol_index_type
PARAMS ((unsigned int));
186 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
187 static void usage
PARAMS ((void));
188 static void parse_args
PARAMS ((int, char **));
189 static int process_file_header
PARAMS ((void));
190 static int process_program_headers
PARAMS ((FILE *));
191 static int process_section_headers
PARAMS ((FILE *));
192 static int process_unwind
PARAMS ((FILE *));
193 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
194 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
195 static int process_dynamic_segment
PARAMS ((FILE *));
196 static int process_symbol_table
PARAMS ((FILE *));
197 static int process_syminfo
PARAMS ((FILE *));
198 static int process_section_contents
PARAMS ((FILE *));
199 static void process_mips_fpe_exception
PARAMS ((int));
200 static int process_mips_specific
PARAMS ((FILE *));
201 static int process_file
PARAMS ((char *));
202 static int process_relocs
PARAMS ((FILE *));
203 static int process_version_sections
PARAMS ((FILE *));
204 static char * get_ver_flags
PARAMS ((unsigned int));
205 static int get_32bit_section_headers
PARAMS ((FILE *, unsigned int));
206 static int get_64bit_section_headers
PARAMS ((FILE *, unsigned int));
207 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
208 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
209 static int get_file_header
PARAMS ((FILE *));
210 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
211 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
212 static const char * get_elf_section_flags
PARAMS ((bfd_vma
));
213 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
214 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
215 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
216 #ifdef SUPPORT_DISASSEMBLY
217 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
219 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
220 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
221 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
222 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
223 static int prescan_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
224 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
225 static int display_debug_pubnames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
226 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
227 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
228 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
229 static int display_debug_macinfo
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
230 static int display_debug_str
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
231 static int display_debug_loc
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
232 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
233 static void load_debug_str
PARAMS ((FILE *));
234 static void free_debug_str
PARAMS ((void));
235 static const char * fetch_indirect_string
PARAMS ((unsigned long));
236 static void load_debug_loc
PARAMS ((FILE *));
237 static void free_debug_loc
PARAMS ((void));
238 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
239 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
240 static void reset_state_machine
PARAMS ((int));
241 static char * get_TAG_name
PARAMS ((unsigned long));
242 static char * get_AT_name
PARAMS ((unsigned long));
243 static char * get_FORM_name
PARAMS ((unsigned long));
244 static void free_abbrevs
PARAMS ((void));
245 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
246 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
247 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
248 static unsigned char * read_and_display_attr_value
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
249 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
250 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
251 static void request_dump
PARAMS ((unsigned int, int));
252 static const char * get_elf_class
PARAMS ((unsigned int));
253 static const char * get_data_encoding
PARAMS ((unsigned int));
254 static const char * get_osabi_name
PARAMS ((unsigned int));
255 static int guess_is_rela
PARAMS ((unsigned long));
256 static const char * get_note_type
PARAMS ((unsigned int));
257 static const char * get_netbsd_elfcore_note_type
PARAMS ((unsigned int));
258 static int process_note
PARAMS ((Elf32_Internal_Note
*));
259 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
260 static int process_corefile_note_segments
PARAMS ((FILE *));
261 static int process_corefile_contents
PARAMS ((FILE *));
262 static int process_arch_specific
PARAMS ((FILE *));
264 typedef int Elf32_Word
;
272 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
273 ((X)->sh_name >= string_table_length \
274 ? "<corrupt>" : string_table + (X)->sh_name))
276 /* Given st_shndx I, map to section_headers index. */
277 #define SECTION_HEADER_INDEX(I) \
278 ((I) < SHN_LORESERVE \
280 : ((I) <= SHN_HIRESERVE \
282 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
284 /* Reverse of the above. */
285 #define SECTION_HEADER_NUM(N) \
286 ((N) < SHN_LORESERVE \
288 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
290 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
292 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
294 #define BYTE_GET(field) byte_get (field, sizeof (field))
296 /* If we can support a 64 bit data type then BFD64 should be defined
297 and sizeof (bfd_vma) == 8. In this case when translating from an
298 external 8 byte field to an internal field, we can assume that the
299 internal field is also 8 bytes wide and so we can extract all the data.
300 If, however, BFD64 is not defined, then we must assume that the
301 internal data structure only has 4 byte wide fields that are the
302 equivalent of the 8 byte wide external counterparts, and so we must
303 truncate the data. */
305 #define BYTE_GET8(field) byte_get (field, -8)
307 #define BYTE_GET8(field) byte_get (field, 8)
310 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
312 #define GET_ELF_SYMBOLS(file, section) \
313 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
314 : get_64bit_elf_symbols (file, section))
318 error
VPARAMS ((const char *message
, ...))
320 VA_OPEN (args
, message
);
321 VA_FIXEDARG (args
, const char *, message
);
323 fprintf (stderr
, _("%s: Error: "), program_name
);
324 vfprintf (stderr
, message
, args
);
329 warn
VPARAMS ((const char *message
, ...))
331 VA_OPEN (args
, message
);
332 VA_FIXEDARG (args
, const char *, message
);
334 fprintf (stderr
, _("%s: Warning: "), program_name
);
335 vfprintf (stderr
, message
, args
);
339 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
342 get_data (var
, file
, offset
, size
, reason
)
354 if (fseek (file
, offset
, SEEK_SET
))
356 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
363 mvar
= (PTR
) malloc (size
);
367 error (_("Out of memory allocating %d bytes for %s\n"),
373 if (fread (mvar
, size
, 1, file
) != 1)
375 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
385 byte_get_little_endian (field
, size
)
386 unsigned char * field
;
395 return ((unsigned int) (field
[0]))
396 | (((unsigned int) (field
[1])) << 8);
400 /* We want to extract data from an 8 byte wide field and
401 place it into a 4 byte wide field. Since this is a little
402 endian source we can juts use the 4 byte extraction code. */
406 return ((unsigned long) (field
[0]))
407 | (((unsigned long) (field
[1])) << 8)
408 | (((unsigned long) (field
[2])) << 16)
409 | (((unsigned long) (field
[3])) << 24);
414 /* This is a special case, generated by the BYTE_GET8 macro.
415 It means that we are loading an 8 byte value from a field
416 in an external structure into an 8 byte value in a field
417 in an internal strcuture. */
418 return ((bfd_vma
) (field
[0]))
419 | (((bfd_vma
) (field
[1])) << 8)
420 | (((bfd_vma
) (field
[2])) << 16)
421 | (((bfd_vma
) (field
[3])) << 24)
422 | (((bfd_vma
) (field
[4])) << 32)
423 | (((bfd_vma
) (field
[5])) << 40)
424 | (((bfd_vma
) (field
[6])) << 48)
425 | (((bfd_vma
) (field
[7])) << 56);
428 error (_("Unhandled data length: %d\n"), size
);
433 /* Print a VMA value. */
435 print_vma (vma
, mode
)
445 case FULL_HEX
: printf ("0x"); /* drop through */
446 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
447 case PREFIX_HEX
: printf ("0x"); /* drop through */
448 case HEX
: printf ("%lx", (unsigned long) vma
); break;
449 case DEC
: printf ("%ld", (unsigned long) vma
); break;
450 case DEC_5
: printf ("%5ld", (long) vma
); break;
451 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
472 #if BFD_HOST_64BIT_LONG
475 if (_bfd_int64_high (vma
))
476 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
478 printf ("%lx", _bfd_int64_low (vma
));
483 #if BFD_HOST_64BIT_LONG
486 if (_bfd_int64_high (vma
))
488 printf ("++%ld", _bfd_int64_low (vma
));
490 printf ("%ld", _bfd_int64_low (vma
));
495 #if BFD_HOST_64BIT_LONG
496 printf ("%5ld", vma
);
498 if (_bfd_int64_high (vma
))
500 printf ("++%ld", _bfd_int64_low (vma
));
502 printf ("%5ld", _bfd_int64_low (vma
));
507 #if BFD_HOST_64BIT_LONG
510 if (_bfd_int64_high (vma
))
512 printf ("++%lu", _bfd_int64_low (vma
));
514 printf ("%lu", _bfd_int64_low (vma
));
522 /* Display a symbol on stdout. If do_wide is not true then
523 format the symbol to be at most WIDTH characters,
524 truhncating as necessary. If WIDTH is negative then
525 format the string to be exactly - WIDTH characters,
526 truncating or padding as necessary. */
529 print_symbol (width
, symbol
)
536 printf ("%-*.*s", width
, width
, symbol
);
538 printf ("%-.*s", width
, symbol
);
542 byte_get_big_endian (field
, size
)
543 unsigned char * field
;
552 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
555 return ((unsigned long) (field
[3]))
556 | (((unsigned long) (field
[2])) << 8)
557 | (((unsigned long) (field
[1])) << 16)
558 | (((unsigned long) (field
[0])) << 24);
562 /* Although we are extracing data from an 8 byte wide field, we
563 are returning only 4 bytes of data. */
564 return ((unsigned long) (field
[7]))
565 | (((unsigned long) (field
[6])) << 8)
566 | (((unsigned long) (field
[5])) << 16)
567 | (((unsigned long) (field
[4])) << 24);
571 /* This is a special case, generated by the BYTE_GET8 macro.
572 It means that we are loading an 8 byte value from a field
573 in an external structure into an 8 byte value in a field
574 in an internal strcuture. */
575 return ((bfd_vma
) (field
[7]))
576 | (((bfd_vma
) (field
[6])) << 8)
577 | (((bfd_vma
) (field
[5])) << 16)
578 | (((bfd_vma
) (field
[4])) << 24)
579 | (((bfd_vma
) (field
[3])) << 32)
580 | (((bfd_vma
) (field
[2])) << 40)
581 | (((bfd_vma
) (field
[1])) << 48)
582 | (((bfd_vma
) (field
[0])) << 56);
586 error (_("Unhandled data length: %d\n"), size
);
591 /* Guess the relocation size commonly used by the specific machines. */
594 guess_is_rela (e_machine
)
595 unsigned long e_machine
;
599 /* Targets that use REL relocations. */
614 /* Targets that use RELA relocations. */
629 case EM_CYGNUS_MN10200
:
631 case EM_CYGNUS_MN10300
:
668 warn (_("Don't know about relocations on this machine architecture\n"));
674 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
676 unsigned long rel_offset
;
677 unsigned long rel_size
;
678 Elf_Internal_Rela
**relasp
;
679 unsigned long *nrelasp
;
681 Elf_Internal_Rela
*relas
;
682 unsigned long nrelas
;
687 Elf32_External_Rela
* erelas
;
689 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
690 rel_size
, _("relocs"));
694 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
696 relas
= (Elf_Internal_Rela
*)
697 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
701 error(_("out of memory parsing relocs"));
705 for (i
= 0; i
< nrelas
; i
++)
707 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
708 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
709 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
716 Elf64_External_Rela
* erelas
;
718 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
719 rel_size
, _("relocs"));
723 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
725 relas
= (Elf_Internal_Rela
*)
726 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
730 error(_("out of memory parsing relocs"));
734 for (i
= 0; i
< nrelas
; i
++)
736 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
737 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
738 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
749 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
751 unsigned long rel_offset
;
752 unsigned long rel_size
;
753 Elf_Internal_Rel
**relsp
;
754 unsigned long *nrelsp
;
756 Elf_Internal_Rel
*rels
;
762 Elf32_External_Rel
* erels
;
764 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
765 rel_size
, _("relocs"));
769 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
771 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
775 error(_("out of memory parsing relocs"));
779 for (i
= 0; i
< nrels
; i
++)
781 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
782 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
789 Elf64_External_Rel
* erels
;
791 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
792 rel_size
, _("relocs"));
796 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
798 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
802 error(_("out of memory parsing relocs"));
806 for (i
= 0; i
< nrels
; i
++)
808 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
809 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
819 /* Display the contents of the relocation data found at the specified offset. */
821 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
823 unsigned long rel_offset
;
824 unsigned long rel_size
;
825 Elf_Internal_Sym
* symtab
;
831 Elf_Internal_Rel
* rels
;
832 Elf_Internal_Rela
* relas
;
835 if (is_rela
== UNKNOWN
)
836 is_rela
= guess_is_rela (elf_header
.e_machine
);
840 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &relas
, &rel_size
))
845 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
854 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
856 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
861 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
863 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
871 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
873 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
878 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
880 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
884 for (i
= 0; i
< rel_size
; i
++)
887 const char * rtype2
= NULL
;
888 const char * rtype3
= NULL
;
891 bfd_vma symtab_index
;
893 bfd_vma type2
= (bfd_vma
) NULL
;
894 bfd_vma type3
= (bfd_vma
) NULL
;
898 offset
= relas
[i
].r_offset
;
899 info
= relas
[i
].r_info
;
903 offset
= rels
[i
].r_offset
;
904 info
= rels
[i
].r_info
;
909 type
= ELF32_R_TYPE (info
);
910 symtab_index
= ELF32_R_SYM (info
);
914 if (elf_header
.e_machine
== EM_MIPS
)
916 type
= ELF64_MIPS_R_TYPE (info
);
917 type2
= ELF64_MIPS_R_TYPE2 (info
);
918 type3
= ELF64_MIPS_R_TYPE3 (info
);
920 else if (elf_header
.e_machine
== EM_SPARCV9
)
921 type
= ELF64_R_TYPE_ID (info
);
923 type
= ELF64_R_TYPE (info
);
924 /* The #ifdef BFD64 below is to prevent a compile time warning.
925 We know that if we do not have a 64 bit data type that we
926 will never execute this code anyway. */
928 symtab_index
= ELF64_R_SYM (info
);
934 #ifdef _bfd_int64_low
935 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
937 printf ("%8.8lx %8.8lx ", offset
, info
);
942 #ifdef _bfd_int64_low
944 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
945 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
946 _bfd_int64_high (offset
),
947 _bfd_int64_low (offset
),
948 _bfd_int64_high (info
),
949 _bfd_int64_low (info
));
952 ? "%16.16lx %16.16lx "
953 : "%12.12lx %12.12lx ",
958 switch (elf_header
.e_machine
)
966 rtype
= elf_m32r_reloc_type (type
);
971 rtype
= elf_i386_reloc_type (type
);
975 rtype
= elf_m68k_reloc_type (type
);
979 rtype
= elf_i960_reloc_type (type
);
984 rtype
= elf_avr_reloc_type (type
);
991 rtype
= elf_sparc_reloc_type (type
);
996 rtype
= v850_reloc_type (type
);
1000 case EM_CYGNUS_D10V
:
1001 rtype
= elf_d10v_reloc_type (type
);
1005 case EM_CYGNUS_D30V
:
1006 rtype
= elf_d30v_reloc_type (type
);
1010 rtype
= elf_sh_reloc_type (type
);
1014 case EM_CYGNUS_MN10300
:
1015 rtype
= elf_mn10300_reloc_type (type
);
1019 case EM_CYGNUS_MN10200
:
1020 rtype
= elf_mn10200_reloc_type (type
);
1024 case EM_CYGNUS_FR30
:
1025 rtype
= elf_fr30_reloc_type (type
);
1029 rtype
= elf_mcore_reloc_type (type
);
1033 rtype
= elf_mmix_reloc_type (type
);
1038 rtype
= elf_ppc_reloc_type (type
);
1042 case EM_MIPS_RS3_LE
:
1043 rtype
= elf_mips_reloc_type (type
);
1046 rtype2
= elf_mips_reloc_type (type2
);
1047 rtype3
= elf_mips_reloc_type (type3
);
1052 rtype
= elf_alpha_reloc_type (type
);
1056 rtype
= elf_arm_reloc_type (type
);
1060 rtype
= elf_arc_reloc_type (type
);
1064 rtype
= elf_hppa_reloc_type (type
);
1070 rtype
= elf_h8_reloc_type (type
);
1075 rtype
= elf_or32_reloc_type (type
);
1080 rtype
= elf_pj_reloc_type (type
);
1083 rtype
= elf_ia64_reloc_type (type
);
1087 rtype
= elf_cris_reloc_type (type
);
1091 rtype
= elf_i860_reloc_type (type
);
1095 rtype
= elf_x86_64_reloc_type (type
);
1100 rtype
= elf_s390_reloc_type (type
);
1104 rtype
= elf_xstormy16_reloc_type (type
);
1109 #ifdef _bfd_int64_low
1110 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1112 printf (_("unrecognized: %-7lx"), type
);
1115 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1119 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1120 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1123 Elf_Internal_Sym
* psym
;
1125 psym
= symtab
+ symtab_index
;
1128 print_vma (psym
->st_value
, LONG_HEX
);
1129 printf (is_32bit_elf
? " " : " ");
1131 if (psym
->st_name
== 0)
1132 print_symbol (22, SECTION_NAME (section_headers
+ psym
->st_shndx
));
1133 else if (strtab
== NULL
)
1134 printf (_("<string table index %3ld>"), psym
->st_name
);
1136 print_symbol (22, strtab
+ psym
->st_name
);
1139 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
1144 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1145 print_vma (relas
[i
].r_addend
, LONG_HEX
);
1148 if (elf_header
.e_machine
== EM_SPARCV9
1149 && !strcmp (rtype
, "R_SPARC_OLO10"))
1150 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1154 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1156 printf (" Type2: ");
1159 #ifdef _bfd_int64_low
1160 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1162 printf (_("unrecognized: %-7lx"), type2
);
1165 printf ("%-17.17s", rtype2
);
1167 printf("\n Type3: ");
1170 #ifdef _bfd_int64_low
1171 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1173 printf (_("unrecognized: %-7lx"), type3
);
1176 printf ("%-17.17s", rtype3
);
1191 get_mips_dynamic_type (type
)
1196 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1197 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1198 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1199 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1200 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1201 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1202 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1203 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1204 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1205 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1206 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1207 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1208 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1209 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1210 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1211 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1212 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1213 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1214 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1215 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1216 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1217 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1218 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1219 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1220 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1221 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1222 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1223 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1224 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1225 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1226 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1227 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1228 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1229 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1230 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1231 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1232 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1233 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1234 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1235 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1236 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1237 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1238 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1245 get_sparc64_dynamic_type (type
)
1250 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1257 get_ppc64_dynamic_type (type
)
1262 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1263 case DT_PPC64_OPD
: return "PPC64_OPD";
1264 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1271 get_parisc_dynamic_type (type
)
1276 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1277 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1278 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1279 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1280 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1281 case DT_HP_PREINIT
: return "HP_PREINIT";
1282 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1283 case DT_HP_NEEDED
: return "HP_NEEDED";
1284 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1285 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1286 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1287 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1288 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1295 get_dynamic_type (type
)
1298 static char buff
[32];
1302 case DT_NULL
: return "NULL";
1303 case DT_NEEDED
: return "NEEDED";
1304 case DT_PLTRELSZ
: return "PLTRELSZ";
1305 case DT_PLTGOT
: return "PLTGOT";
1306 case DT_HASH
: return "HASH";
1307 case DT_STRTAB
: return "STRTAB";
1308 case DT_SYMTAB
: return "SYMTAB";
1309 case DT_RELA
: return "RELA";
1310 case DT_RELASZ
: return "RELASZ";
1311 case DT_RELAENT
: return "RELAENT";
1312 case DT_STRSZ
: return "STRSZ";
1313 case DT_SYMENT
: return "SYMENT";
1314 case DT_INIT
: return "INIT";
1315 case DT_FINI
: return "FINI";
1316 case DT_SONAME
: return "SONAME";
1317 case DT_RPATH
: return "RPATH";
1318 case DT_SYMBOLIC
: return "SYMBOLIC";
1319 case DT_REL
: return "REL";
1320 case DT_RELSZ
: return "RELSZ";
1321 case DT_RELENT
: return "RELENT";
1322 case DT_PLTREL
: return "PLTREL";
1323 case DT_DEBUG
: return "DEBUG";
1324 case DT_TEXTREL
: return "TEXTREL";
1325 case DT_JMPREL
: return "JMPREL";
1326 case DT_BIND_NOW
: return "BIND_NOW";
1327 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1328 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1329 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1330 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1331 case DT_RUNPATH
: return "RUNPATH";
1332 case DT_FLAGS
: return "FLAGS";
1334 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1335 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1337 case DT_CHECKSUM
: return "CHECKSUM";
1338 case DT_PLTPADSZ
: return "PLTPADSZ";
1339 case DT_MOVEENT
: return "MOVEENT";
1340 case DT_MOVESZ
: return "MOVESZ";
1341 case DT_FEATURE
: return "FEATURE";
1342 case DT_POSFLAG_1
: return "POSFLAG_1";
1343 case DT_SYMINSZ
: return "SYMINSZ";
1344 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1346 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1347 case DT_CONFIG
: return "CONFIG";
1348 case DT_DEPAUDIT
: return "DEPAUDIT";
1349 case DT_AUDIT
: return "AUDIT";
1350 case DT_PLTPAD
: return "PLTPAD";
1351 case DT_MOVETAB
: return "MOVETAB";
1352 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1354 case DT_VERSYM
: return "VERSYM";
1356 case DT_RELACOUNT
: return "RELACOUNT";
1357 case DT_RELCOUNT
: return "RELCOUNT";
1358 case DT_FLAGS_1
: return "FLAGS_1";
1359 case DT_VERDEF
: return "VERDEF";
1360 case DT_VERDEFNUM
: return "VERDEFNUM";
1361 case DT_VERNEED
: return "VERNEED";
1362 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1364 case DT_AUXILIARY
: return "AUXILIARY";
1365 case DT_USED
: return "USED";
1366 case DT_FILTER
: return "FILTER";
1369 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1371 const char * result
;
1373 switch (elf_header
.e_machine
)
1376 case EM_MIPS_RS3_LE
:
1377 result
= get_mips_dynamic_type (type
);
1380 result
= get_sparc64_dynamic_type (type
);
1383 result
= get_ppc64_dynamic_type (type
);
1393 sprintf (buff
, _("Processor Specific: %lx"), type
);
1395 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1397 const char * result
;
1399 switch (elf_header
.e_machine
)
1402 result
= get_parisc_dynamic_type (type
);
1412 sprintf (buff
, _("Operating System specific: %lx"), type
);
1415 sprintf (buff
, _("<unknown>: %lx"), type
);
1422 get_file_type (e_type
)
1425 static char buff
[32];
1429 case ET_NONE
: return _("NONE (None)");
1430 case ET_REL
: return _("REL (Relocatable file)");
1431 case ET_EXEC
: return _("EXEC (Executable file)");
1432 case ET_DYN
: return _("DYN (Shared object file)");
1433 case ET_CORE
: return _("CORE (Core file)");
1436 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1437 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1438 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1439 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1441 sprintf (buff
, _("<unknown>: %x"), e_type
);
1447 get_machine_name (e_machine
)
1450 static char buff
[64]; /* XXX */
1454 case EM_NONE
: return _("None");
1455 case EM_M32
: return "WE32100";
1456 case EM_SPARC
: return "Sparc";
1457 case EM_386
: return "Intel 80386";
1458 case EM_68K
: return "MC68000";
1459 case EM_88K
: return "MC88000";
1460 case EM_486
: return "Intel 80486";
1461 case EM_860
: return "Intel 80860";
1462 case EM_MIPS
: return "MIPS R3000";
1463 case EM_S370
: return "IBM System/370";
1464 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1465 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1466 case EM_PARISC
: return "HPPA";
1467 case EM_PPC_OLD
: return "Power PC (old)";
1468 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1469 case EM_960
: return "Intel 90860";
1470 case EM_PPC
: return "PowerPC";
1471 case EM_PPC64
: return "PowerPC64";
1472 case EM_V800
: return "NEC V800";
1473 case EM_FR20
: return "Fujitsu FR20";
1474 case EM_RH32
: return "TRW RH32";
1475 case EM_MCORE
: return "MCORE";
1476 case EM_ARM
: return "ARM";
1477 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1478 case EM_SH
: return "Hitachi SH";
1479 case EM_SPARCV9
: return "Sparc v9";
1480 case EM_TRICORE
: return "Siemens Tricore";
1481 case EM_ARC
: return "ARC";
1482 case EM_H8_300
: return "Hitachi H8/300";
1483 case EM_H8_300H
: return "Hitachi H8/300H";
1484 case EM_H8S
: return "Hitachi H8S";
1485 case EM_H8_500
: return "Hitachi H8/500";
1486 case EM_IA_64
: return "Intel IA-64";
1487 case EM_MIPS_X
: return "Stanford MIPS-X";
1488 case EM_COLDFIRE
: return "Motorola Coldfire";
1489 case EM_68HC12
: return "Motorola M68HC12";
1490 case EM_ALPHA
: return "Alpha";
1491 case EM_CYGNUS_D10V
:
1492 case EM_D10V
: return "d10v";
1493 case EM_CYGNUS_D30V
:
1494 case EM_D30V
: return "d30v";
1495 case EM_CYGNUS_M32R
:
1496 case EM_M32R
: return "Mitsubishi M32r";
1497 case EM_CYGNUS_V850
:
1498 case EM_V850
: return "NEC v850";
1499 case EM_CYGNUS_MN10300
:
1500 case EM_MN10300
: return "mn10300";
1501 case EM_CYGNUS_MN10200
:
1502 case EM_MN10200
: return "mn10200";
1503 case EM_CYGNUS_FR30
:
1504 case EM_FR30
: return "Fujitsu FR30";
1506 case EM_PJ
: return "picoJava";
1507 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1508 case EM_PCP
: return "Siemens PCP";
1509 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1510 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1511 case EM_STARCORE
: return "Motorola Star*Core processor";
1512 case EM_ME16
: return "Toyota ME16 processor";
1513 case EM_ST100
: return "STMicroelectronics ST100 processor";
1514 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1515 case EM_FX66
: return "Siemens FX66 microcontroller";
1516 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1517 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1518 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1519 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1520 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1521 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1522 case EM_SVX
: return "Silicon Graphics SVx";
1523 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1524 case EM_VAX
: return "Digital VAX";
1526 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1527 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1528 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1529 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1530 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1531 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1532 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1533 case EM_PRISM
: return "SiTera Prism";
1534 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1536 case EM_S390
: return "IBM S/390";
1537 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1539 case EM_OR32
: return "OpenRISC";
1541 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1547 decode_ARM_machine_flags (e_flags
, buf
)
1554 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1555 e_flags
&= ~ EF_ARM_EABIMASK
;
1557 /* Handle "generic" ARM flags. */
1558 if (e_flags
& EF_ARM_RELEXEC
)
1560 strcat (buf
, ", relocatable executable");
1561 e_flags
&= ~ EF_ARM_RELEXEC
;
1564 if (e_flags
& EF_ARM_HASENTRY
)
1566 strcat (buf
, ", has entry point");
1567 e_flags
&= ~ EF_ARM_HASENTRY
;
1570 /* Now handle EABI specific flags. */
1574 strcat (buf
, ", <unrecognized EABI>");
1579 case EF_ARM_EABI_VER1
:
1580 strcat (buf
, ", Version1 EABI");
1585 /* Process flags one bit at a time. */
1586 flag
= e_flags
& - e_flags
;
1591 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1592 strcat (buf
, ", sorted symbol tables");
1602 case EF_ARM_EABI_VER2
:
1603 strcat (buf
, ", Version2 EABI");
1608 /* Process flags one bit at a time. */
1609 flag
= e_flags
& - e_flags
;
1614 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1615 strcat (buf
, ", sorted symbol tables");
1618 case EF_ARM_DYNSYMSUSESEGIDX
:
1619 strcat (buf
, ", dynamic symbols use segment index");
1622 case EF_ARM_MAPSYMSFIRST
:
1623 strcat (buf
, ", mapping symbols precede others");
1633 case EF_ARM_EABI_UNKNOWN
:
1634 strcat (buf
, ", GNU EABI");
1639 /* Process flags one bit at a time. */
1640 flag
= e_flags
& - e_flags
;
1645 case EF_ARM_INTERWORK
:
1646 strcat (buf
, ", interworking enabled");
1649 case EF_ARM_APCS_26
:
1650 strcat (buf
, ", uses APCS/26");
1653 case EF_ARM_APCS_FLOAT
:
1654 strcat (buf
, ", uses APCS/float");
1658 strcat (buf
, ", position independent");
1662 strcat (buf
, ", 8 bit structure alignment");
1665 case EF_ARM_NEW_ABI
:
1666 strcat (buf
, ", uses new ABI");
1669 case EF_ARM_OLD_ABI
:
1670 strcat (buf
, ", uses old ABI");
1673 case EF_ARM_SOFT_FLOAT
:
1674 strcat (buf
, ", software FP");
1685 strcat (buf
,", <unknown>");
1689 get_machine_flags (e_flags
, e_machine
)
1693 static char buf
[1024];
1705 decode_ARM_machine_flags (e_flags
, buf
);
1709 if (e_flags
& EF_CPU32
)
1710 strcat (buf
, ", cpu32");
1711 if (e_flags
& EF_M68000
)
1712 strcat (buf
, ", m68000");
1716 if (e_flags
& EF_PPC_EMB
)
1717 strcat (buf
, ", emb");
1719 if (e_flags
& EF_PPC_RELOCATABLE
)
1720 strcat (buf
, ", relocatable");
1722 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1723 strcat (buf
, ", relocatable-lib");
1727 case EM_CYGNUS_V850
:
1728 switch (e_flags
& EF_V850_ARCH
)
1731 strcat (buf
, ", v850e");
1734 strcat (buf
, ", v850ea");
1737 strcat (buf
, ", v850");
1740 strcat (buf
, ", unknown v850 architecture variant");
1746 case EM_CYGNUS_M32R
:
1747 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1748 strcat (buf
, ", m32r");
1753 case EM_MIPS_RS3_LE
:
1754 if (e_flags
& EF_MIPS_NOREORDER
)
1755 strcat (buf
, ", noreorder");
1757 if (e_flags
& EF_MIPS_PIC
)
1758 strcat (buf
, ", pic");
1760 if (e_flags
& EF_MIPS_CPIC
)
1761 strcat (buf
, ", cpic");
1763 if (e_flags
& EF_MIPS_UCODE
)
1764 strcat (buf
, ", ugen_reserved");
1766 if (e_flags
& EF_MIPS_ABI2
)
1767 strcat (buf
, ", abi2");
1769 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1770 strcat (buf
, ", odk first");
1772 if (e_flags
& EF_MIPS_32BITMODE
)
1773 strcat (buf
, ", 32bitmode");
1775 switch ((e_flags
& EF_MIPS_MACH
))
1777 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1778 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1779 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1780 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1781 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1782 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1784 /* We simply ignore the field in this case to avoid confusion:
1785 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1788 default: strcat (buf
, ", unknown CPU"); break;
1791 switch ((e_flags
& EF_MIPS_ABI
))
1793 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1794 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1795 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1796 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1798 /* We simply ignore the field in this case to avoid confusion:
1799 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1800 This means it is likely to be an o32 file, but not for
1803 default: strcat (buf
, ", unknown ABI"); break;
1806 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1807 strcat (buf
, ", mdmx");
1809 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1810 strcat (buf
, ", mips16");
1812 switch ((e_flags
& EF_MIPS_ARCH
))
1814 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1815 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1816 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1817 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1818 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1819 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1820 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1821 default: strcat (buf
, ", unknown ISA"); break;
1827 if (e_flags
& EF_SPARC_32PLUS
)
1828 strcat (buf
, ", v8+");
1830 if (e_flags
& EF_SPARC_SUN_US1
)
1831 strcat (buf
, ", ultrasparcI");
1833 if (e_flags
& EF_SPARC_SUN_US3
)
1834 strcat (buf
, ", ultrasparcIII");
1836 if (e_flags
& EF_SPARC_HAL_R1
)
1837 strcat (buf
, ", halr1");
1839 if (e_flags
& EF_SPARC_LEDATA
)
1840 strcat (buf
, ", ledata");
1842 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1843 strcat (buf
, ", tso");
1845 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1846 strcat (buf
, ", pso");
1848 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1849 strcat (buf
, ", rmo");
1853 switch (e_flags
& EF_PARISC_ARCH
)
1855 case EFA_PARISC_1_0
:
1856 strcpy (buf
, ", PA-RISC 1.0");
1858 case EFA_PARISC_1_1
:
1859 strcpy (buf
, ", PA-RISC 1.1");
1861 case EFA_PARISC_2_0
:
1862 strcpy (buf
, ", PA-RISC 2.0");
1867 if (e_flags
& EF_PARISC_TRAPNIL
)
1868 strcat (buf
, ", trapnil");
1869 if (e_flags
& EF_PARISC_EXT
)
1870 strcat (buf
, ", ext");
1871 if (e_flags
& EF_PARISC_LSB
)
1872 strcat (buf
, ", lsb");
1873 if (e_flags
& EF_PARISC_WIDE
)
1874 strcat (buf
, ", wide");
1875 if (e_flags
& EF_PARISC_NO_KABP
)
1876 strcat (buf
, ", no kabp");
1877 if (e_flags
& EF_PARISC_LAZYSWAP
)
1878 strcat (buf
, ", lazyswap");
1883 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1884 strcat (buf
, ", new calling convention");
1886 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1887 strcat (buf
, ", gnu calling convention");
1891 if ((e_flags
& EF_IA_64_ABI64
))
1892 strcat (buf
, ", 64-bit");
1894 strcat (buf
, ", 32-bit");
1895 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1896 strcat (buf
, ", reduced fp model");
1897 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1898 strcat (buf
, ", no function descriptors, constant gp");
1899 else if ((e_flags
& EF_IA_64_CONS_GP
))
1900 strcat (buf
, ", constant gp");
1901 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1902 strcat (buf
, ", absolute");
1911 get_mips_segment_type (type
)
1916 case PT_MIPS_REGINFO
:
1918 case PT_MIPS_RTPROC
:
1920 case PT_MIPS_OPTIONS
:
1930 get_parisc_segment_type (type
)
1935 case PT_HP_TLS
: return "HP_TLS";
1936 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1937 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1938 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1939 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1940 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1941 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1942 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1943 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1944 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1945 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1946 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1947 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1948 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1957 get_ia64_segment_type (type
)
1962 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
1963 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
1964 case PT_HP_TLS
: return "HP_TLS";
1965 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
1966 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
1967 case PT_IA_64_HP_STACK
: return "HP_STACK";
1976 get_segment_type (p_type
)
1977 unsigned long p_type
;
1979 static char buff
[32];
1983 case PT_NULL
: return "NULL";
1984 case PT_LOAD
: return "LOAD";
1985 case PT_DYNAMIC
: return "DYNAMIC";
1986 case PT_INTERP
: return "INTERP";
1987 case PT_NOTE
: return "NOTE";
1988 case PT_SHLIB
: return "SHLIB";
1989 case PT_PHDR
: return "PHDR";
1990 case PT_TLS
: return "TLS";
1992 case PT_GNU_EH_FRAME
:
1993 return "GNU_EH_FRAME";
1996 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1998 const char * result
;
2000 switch (elf_header
.e_machine
)
2003 case EM_MIPS_RS3_LE
:
2004 result
= get_mips_segment_type (p_type
);
2007 result
= get_parisc_segment_type (p_type
);
2010 result
= get_ia64_segment_type (p_type
);
2020 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2022 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2024 const char * result
;
2026 switch (elf_header
.e_machine
)
2029 result
= get_parisc_segment_type (p_type
);
2032 result
= get_ia64_segment_type (p_type
);
2042 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2045 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2052 get_mips_section_type_name (sh_type
)
2053 unsigned int sh_type
;
2057 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2058 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2059 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2060 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2061 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2062 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2063 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2064 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2065 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2066 case SHT_MIPS_RELD
: return "MIPS_RELD";
2067 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2068 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2069 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2070 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2071 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2072 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2073 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2074 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2075 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2076 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2077 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2078 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2079 case SHT_MIPS_LINE
: return "MIPS_LINE";
2080 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2081 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2082 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2083 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2084 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2085 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2086 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2087 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2088 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2089 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2090 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2091 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2092 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2093 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2094 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2095 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2103 get_parisc_section_type_name (sh_type
)
2104 unsigned int sh_type
;
2108 case SHT_PARISC_EXT
: return "PARISC_EXT";
2109 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2110 case SHT_PARISC_DOC
: return "PARISC_DOC";
2118 get_ia64_section_type_name (sh_type
)
2119 unsigned int sh_type
;
2123 case SHT_IA_64_EXT
: return "IA_64_EXT";
2124 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2132 get_section_type_name (sh_type
)
2133 unsigned int sh_type
;
2135 static char buff
[32];
2139 case SHT_NULL
: return "NULL";
2140 case SHT_PROGBITS
: return "PROGBITS";
2141 case SHT_SYMTAB
: return "SYMTAB";
2142 case SHT_STRTAB
: return "STRTAB";
2143 case SHT_RELA
: return "RELA";
2144 case SHT_HASH
: return "HASH";
2145 case SHT_DYNAMIC
: return "DYNAMIC";
2146 case SHT_NOTE
: return "NOTE";
2147 case SHT_NOBITS
: return "NOBITS";
2148 case SHT_REL
: return "REL";
2149 case SHT_SHLIB
: return "SHLIB";
2150 case SHT_DYNSYM
: return "DYNSYM";
2151 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2152 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2153 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2154 case SHT_GROUP
: return "GROUP";
2155 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2156 case SHT_GNU_verdef
: return "VERDEF";
2157 case SHT_GNU_verneed
: return "VERNEED";
2158 case SHT_GNU_versym
: return "VERSYM";
2159 case 0x6ffffff0: return "VERSYM";
2160 case 0x6ffffffc: return "VERDEF";
2161 case 0x7ffffffd: return "AUXILIARY";
2162 case 0x7fffffff: return "FILTER";
2165 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2167 const char * result
;
2169 switch (elf_header
.e_machine
)
2172 case EM_MIPS_RS3_LE
:
2173 result
= get_mips_section_type_name (sh_type
);
2176 result
= get_parisc_section_type_name (sh_type
);
2179 result
= get_ia64_section_type_name (sh_type
);
2189 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2191 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2192 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2193 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2194 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2196 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2202 struct option options
[] =
2204 {"all", no_argument
, 0, 'a'},
2205 {"file-header", no_argument
, 0, 'h'},
2206 {"program-headers", no_argument
, 0, 'l'},
2207 {"headers", no_argument
, 0, 'e'},
2208 {"histogram", no_argument
, 0, 'I'},
2209 {"segments", no_argument
, 0, 'l'},
2210 {"sections", no_argument
, 0, 'S'},
2211 {"section-headers", no_argument
, 0, 'S'},
2212 {"symbols", no_argument
, 0, 's'},
2213 {"syms", no_argument
, 0, 's'},
2214 {"relocs", no_argument
, 0, 'r'},
2215 {"notes", no_argument
, 0, 'n'},
2216 {"dynamic", no_argument
, 0, 'd'},
2217 {"arch-specific", no_argument
, 0, 'A'},
2218 {"version-info", no_argument
, 0, 'V'},
2219 {"use-dynamic", no_argument
, 0, 'D'},
2220 {"hex-dump", required_argument
, 0, 'x'},
2221 {"debug-dump", optional_argument
, 0, 'w'},
2222 {"unwind", no_argument
, 0, 'u'},
2223 #ifdef SUPPORT_DISASSEMBLY
2224 {"instruction-dump", required_argument
, 0, 'i'},
2227 {"version", no_argument
, 0, 'v'},
2228 {"wide", no_argument
, 0, 'W'},
2229 {"help", no_argument
, 0, 'H'},
2230 {0, no_argument
, 0, 0}
2236 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2237 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2238 fprintf (stdout
, _(" Options are:\n\
2239 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2240 -h --file-header Display the ELF file header\n\
2241 -l --program-headers Display the program headers\n\
2242 --segments An alias for --program-headers\n\
2243 -S --section-headers Display the sections' header\n\
2244 --sections An alias for --section-headers\n\
2245 -e --headers Equivalent to: -h -l -S\n\
2246 -s --syms Display the symbol table\n\
2247 --symbols An alias for --syms\n\
2248 -n --notes Display the core notes (if present)\n\
2249 -r --relocs Display the relocations (if present)\n\
2250 -u --unwind Display the unwind info (if present)\n\
2251 -d --dynamic Display the dynamic segment (if present)\n\
2252 -V --version-info Display the version sections (if present)\n\
2253 -A --arch-specific Display architecture specific information (if any).\n\
2254 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2255 -x --hex-dump=<number> Dump the contents of section <number>\n\
2256 -w --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2257 Display the contents of DWARF2 debug sections\n"));
2258 #ifdef SUPPORT_DISASSEMBLY
2259 fprintf (stdout
, _("\
2260 -i --instruction-dump=<number>\n\
2261 Disassemble the contents of section <number>\n"));
2263 fprintf (stdout
, _("\
2264 -I --histogram Display histogram of bucket list lengths\n\
2265 -W --wide Allow output width to exceed 80 characters\n\
2266 -H --help Display this information\n\
2267 -v --version Display the version number of readelf\n"));
2268 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2274 request_dump (section
, type
)
2275 unsigned int section
;
2278 if (section
>= num_dump_sects
)
2280 char * new_dump_sects
;
2282 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2284 if (new_dump_sects
== NULL
)
2285 error (_("Out of memory allocating dump request table."));
2288 /* Copy current flag settings. */
2289 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2293 dump_sects
= new_dump_sects
;
2294 num_dump_sects
= section
+ 1;
2299 dump_sects
[section
] |= type
;
2305 parse_args (argc
, argv
)
2314 while ((c
= getopt_long
2315 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2351 do_using_dynamic
++;
2382 section
= strtoul (optarg
, & cp
, 0);
2383 if (! * cp
&& section
>= 0)
2385 request_dump (section
, HEX_DUMP
);
2395 unsigned int index
= 0;
2399 while (optarg
[index
])
2400 switch (optarg
[index
++])
2409 do_debug_abbrevs
= 1;
2419 do_debug_pubnames
= 1;
2424 do_debug_aranges
= 1;
2428 do_debug_frames_interp
= 1;
2430 do_debug_frames
= 1;
2435 do_debug_macinfo
= 1;
2449 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2454 #ifdef SUPPORT_DISASSEMBLY
2457 section
= strtoul (optarg
, & cp
, 0);
2458 if (! * cp
&& section
>= 0)
2460 request_dump (section
, DISASS_DUMP
);
2466 print_version (program_name
);
2476 /* xgettext:c-format */
2477 error (_("Invalid option '-%c'\n"), c
);
2484 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2485 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2486 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2490 warn (_("Nothing to do.\n"));
2496 get_elf_class (elf_class
)
2497 unsigned int elf_class
;
2499 static char buff
[32];
2503 case ELFCLASSNONE
: return _("none");
2504 case ELFCLASS32
: return "ELF32";
2505 case ELFCLASS64
: return "ELF64";
2507 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2513 get_data_encoding (encoding
)
2514 unsigned int encoding
;
2516 static char buff
[32];
2520 case ELFDATANONE
: return _("none");
2521 case ELFDATA2LSB
: return _("2's complement, little endian");
2522 case ELFDATA2MSB
: return _("2's complement, big endian");
2524 sprintf (buff
, _("<unknown: %x>"), encoding
);
2530 get_osabi_name (osabi
)
2533 static char buff
[32];
2537 case ELFOSABI_NONE
: return "UNIX - System V";
2538 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2539 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2540 case ELFOSABI_LINUX
: return "UNIX - Linux";
2541 case ELFOSABI_HURD
: return "GNU/Hurd";
2542 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2543 case ELFOSABI_AIX
: return "UNIX - AIX";
2544 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2545 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2546 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2547 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2548 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2549 case ELFOSABI_STANDALONE
: return _("Standalone App");
2550 case ELFOSABI_ARM
: return "ARM";
2552 sprintf (buff
, _("<unknown: %x>"), osabi
);
2557 /* Decode the data held in 'elf_header'. */
2559 process_file_header ()
2561 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2562 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2563 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2564 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2567 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2575 printf (_("ELF Header:\n"));
2576 printf (_(" Magic: "));
2577 for (i
= 0; i
< EI_NIDENT
; i
++)
2578 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2580 printf (_(" Class: %s\n"),
2581 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2582 printf (_(" Data: %s\n"),
2583 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2584 printf (_(" Version: %d %s\n"),
2585 elf_header
.e_ident
[EI_VERSION
],
2586 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2588 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2591 printf (_(" OS/ABI: %s\n"),
2592 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2593 printf (_(" ABI Version: %d\n"),
2594 elf_header
.e_ident
[EI_ABIVERSION
]);
2595 printf (_(" Type: %s\n"),
2596 get_file_type (elf_header
.e_type
));
2597 printf (_(" Machine: %s\n"),
2598 get_machine_name (elf_header
.e_machine
));
2599 printf (_(" Version: 0x%lx\n"),
2600 (unsigned long) elf_header
.e_version
);
2602 printf (_(" Entry point address: "));
2603 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2604 printf (_("\n Start of program headers: "));
2605 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2606 printf (_(" (bytes into file)\n Start of section headers: "));
2607 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2608 printf (_(" (bytes into file)\n"));
2610 printf (_(" Flags: 0x%lx%s\n"),
2611 (unsigned long) elf_header
.e_flags
,
2612 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2613 printf (_(" Size of this header: %ld (bytes)\n"),
2614 (long) elf_header
.e_ehsize
);
2615 printf (_(" Size of program headers: %ld (bytes)\n"),
2616 (long) elf_header
.e_phentsize
);
2617 printf (_(" Number of program headers: %ld\n"),
2618 (long) elf_header
.e_phnum
);
2619 printf (_(" Size of section headers: %ld (bytes)\n"),
2620 (long) elf_header
.e_shentsize
);
2621 printf (_(" Number of section headers: %ld"),
2622 (long) elf_header
.e_shnum
);
2623 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2624 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2625 putc ('\n', stdout
);
2626 printf (_(" Section header string table index: %ld"),
2627 (long) elf_header
.e_shstrndx
);
2628 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2629 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2630 putc ('\n', stdout
);
2633 if (section_headers
!= NULL
)
2635 if (elf_header
.e_shnum
== 0)
2636 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2637 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2638 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2639 free (section_headers
);
2640 section_headers
= NULL
;
2648 get_32bit_program_headers (file
, program_headers
)
2650 Elf_Internal_Phdr
* program_headers
;
2652 Elf32_External_Phdr
* phdrs
;
2653 Elf32_External_Phdr
* external
;
2654 Elf32_Internal_Phdr
* internal
;
2657 phdrs
= ((Elf32_External_Phdr
*)
2658 get_data (NULL
, file
, elf_header
.e_phoff
,
2659 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2660 _("program headers")));
2664 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2665 i
< elf_header
.e_phnum
;
2666 i
++, internal
++, external
++)
2668 internal
->p_type
= BYTE_GET (external
->p_type
);
2669 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2670 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2671 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2672 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2673 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2674 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2675 internal
->p_align
= BYTE_GET (external
->p_align
);
2684 get_64bit_program_headers (file
, program_headers
)
2686 Elf_Internal_Phdr
* program_headers
;
2688 Elf64_External_Phdr
* phdrs
;
2689 Elf64_External_Phdr
* external
;
2690 Elf64_Internal_Phdr
* internal
;
2693 phdrs
= ((Elf64_External_Phdr
*)
2694 get_data (NULL
, file
, elf_header
.e_phoff
,
2695 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2696 _("program headers")));
2700 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2701 i
< elf_header
.e_phnum
;
2702 i
++, internal
++, external
++)
2704 internal
->p_type
= BYTE_GET (external
->p_type
);
2705 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2706 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2707 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2708 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2709 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2710 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2711 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2720 process_program_headers (file
)
2723 Elf_Internal_Phdr
* program_headers
;
2724 Elf_Internal_Phdr
* segment
;
2727 if (elf_header
.e_phnum
== 0)
2730 printf (_("\nThere are no program headers in this file.\n"));
2734 if (do_segments
&& !do_header
)
2736 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2737 printf (_("Entry point "));
2738 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2739 printf (_("\nThere are %d program headers, starting at offset "),
2740 elf_header
.e_phnum
);
2741 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2745 program_headers
= (Elf_Internal_Phdr
*) malloc
2746 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2748 if (program_headers
== NULL
)
2750 error (_("Out of memory\n"));
2755 i
= get_32bit_program_headers (file
, program_headers
);
2757 i
= get_64bit_program_headers (file
, program_headers
);
2761 free (program_headers
);
2767 if (elf_header
.e_phnum
> 1)
2768 printf (_("\nProgram Headers:\n"));
2770 printf (_("\nProgram Headers:\n"));
2774 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2777 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2781 (_(" Type Offset VirtAddr PhysAddr\n"));
2783 (_(" FileSiz MemSiz Flags Align\n"));
2791 for (i
= 0, segment
= program_headers
;
2792 i
< elf_header
.e_phnum
;
2797 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2801 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2802 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2803 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2804 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2805 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2807 (segment
->p_flags
& PF_R
? 'R' : ' '),
2808 (segment
->p_flags
& PF_W
? 'W' : ' '),
2809 (segment
->p_flags
& PF_X
? 'E' : ' '));
2810 printf ("%#lx", (unsigned long) segment
->p_align
);
2814 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2815 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2818 print_vma (segment
->p_offset
, FULL_HEX
);
2822 print_vma (segment
->p_vaddr
, FULL_HEX
);
2824 print_vma (segment
->p_paddr
, FULL_HEX
);
2827 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
2828 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
2831 print_vma (segment
->p_filesz
, FULL_HEX
);
2835 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
2836 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
2839 print_vma (segment
->p_offset
, FULL_HEX
);
2843 (segment
->p_flags
& PF_R
? 'R' : ' '),
2844 (segment
->p_flags
& PF_W
? 'W' : ' '),
2845 (segment
->p_flags
& PF_X
? 'E' : ' '));
2847 if ((unsigned long) segment
->p_align
== segment
->p_align
)
2848 printf ("%#lx", (unsigned long) segment
->p_align
);
2851 print_vma (segment
->p_align
, PREFIX_HEX
);
2856 print_vma (segment
->p_offset
, FULL_HEX
);
2858 print_vma (segment
->p_vaddr
, FULL_HEX
);
2860 print_vma (segment
->p_paddr
, FULL_HEX
);
2862 print_vma (segment
->p_filesz
, FULL_HEX
);
2864 print_vma (segment
->p_memsz
, FULL_HEX
);
2866 (segment
->p_flags
& PF_R
? 'R' : ' '),
2867 (segment
->p_flags
& PF_W
? 'W' : ' '),
2868 (segment
->p_flags
& PF_X
? 'E' : ' '));
2869 print_vma (segment
->p_align
, HEX
);
2873 switch (segment
->p_type
)
2877 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2878 - (segment
->p_offset
& 0xfffff000);
2883 error (_("more than one dynamic segment\n"));
2885 dynamic_addr
= segment
->p_offset
;
2886 dynamic_size
= segment
->p_filesz
;
2890 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2891 error (_("Unable to find program interpreter name\n"));
2894 program_interpreter
[0] = 0;
2895 fscanf (file
, "%63s", program_interpreter
);
2898 printf (_("\n [Requesting program interpreter: %s]"),
2899 program_interpreter
);
2905 putc ('\n', stdout
);
2914 if (do_segments
&& section_headers
!= NULL
)
2916 printf (_("\n Section to Segment mapping:\n"));
2917 printf (_(" Segment Sections...\n"));
2919 assert (string_table
!= NULL
);
2921 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2924 Elf_Internal_Shdr
* section
;
2926 segment
= program_headers
+ i
;
2927 section
= section_headers
;
2929 printf (" %2.2d ", i
);
2931 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
2933 if (section
->sh_size
> 0
2934 /* Compare allocated sections by VMA, unallocated
2935 sections by file offset. */
2936 && (section
->sh_flags
& SHF_ALLOC
2937 ? (section
->sh_addr
>= segment
->p_vaddr
2938 && section
->sh_addr
+ section
->sh_size
2939 <= segment
->p_vaddr
+ segment
->p_memsz
)
2940 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2941 && (section
->sh_offset
+ section
->sh_size
2942 <= segment
->p_offset
+ segment
->p_filesz
))))
2943 printf ("%s ", SECTION_NAME (section
));
2950 free (program_headers
);
2957 get_32bit_section_headers (file
, num
)
2961 Elf32_External_Shdr
* shdrs
;
2962 Elf32_Internal_Shdr
* internal
;
2965 shdrs
= ((Elf32_External_Shdr
*)
2966 get_data (NULL
, file
, elf_header
.e_shoff
,
2967 elf_header
.e_shentsize
* num
,
2968 _("section headers")));
2972 section_headers
= ((Elf_Internal_Shdr
*)
2973 malloc (num
* sizeof (Elf_Internal_Shdr
)));
2975 if (section_headers
== NULL
)
2977 error (_("Out of memory\n"));
2981 for (i
= 0, internal
= section_headers
;
2985 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2986 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2987 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2988 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2989 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2990 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2991 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2992 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2993 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2994 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3003 get_64bit_section_headers (file
, num
)
3007 Elf64_External_Shdr
* shdrs
;
3008 Elf64_Internal_Shdr
* internal
;
3011 shdrs
= ((Elf64_External_Shdr
*)
3012 get_data (NULL
, file
, elf_header
.e_shoff
,
3013 elf_header
.e_shentsize
* num
,
3014 _("section headers")));
3018 section_headers
= ((Elf_Internal_Shdr
*)
3019 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3021 if (section_headers
== NULL
)
3023 error (_("Out of memory\n"));
3027 for (i
= 0, internal
= section_headers
;
3031 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3032 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3033 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3034 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3035 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3036 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3037 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3038 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3039 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3040 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3048 static Elf_Internal_Sym
*
3049 get_32bit_elf_symbols (file
, section
)
3051 Elf_Internal_Shdr
*section
;
3053 unsigned long number
;
3054 Elf32_External_Sym
* esyms
;
3055 Elf_External_Sym_Shndx
*shndx
;
3056 Elf_Internal_Sym
* isyms
;
3057 Elf_Internal_Sym
* psym
;
3060 esyms
= ((Elf32_External_Sym
*)
3061 get_data (NULL
, file
, section
->sh_offset
,
3062 section
->sh_size
, _("symbols")));
3067 if (symtab_shndx_hdr
!= NULL
3068 && (symtab_shndx_hdr
->sh_link
3069 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3071 shndx
= ((Elf_External_Sym_Shndx
*)
3072 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3073 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3081 number
= section
->sh_size
/ section
->sh_entsize
;
3082 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3086 error (_("Out of memory\n"));
3093 for (j
= 0, psym
= isyms
;
3097 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3098 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3099 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3100 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3101 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3103 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3104 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3105 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3115 static Elf_Internal_Sym
*
3116 get_64bit_elf_symbols (file
, section
)
3118 Elf_Internal_Shdr
*section
;
3120 unsigned long number
;
3121 Elf64_External_Sym
* esyms
;
3122 Elf_External_Sym_Shndx
*shndx
;
3123 Elf_Internal_Sym
* isyms
;
3124 Elf_Internal_Sym
* psym
;
3127 esyms
= ((Elf64_External_Sym
*)
3128 get_data (NULL
, file
, section
->sh_offset
,
3129 section
->sh_size
, _("symbols")));
3134 if (symtab_shndx_hdr
!= NULL
3135 && (symtab_shndx_hdr
->sh_link
3136 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3138 shndx
= ((Elf_External_Sym_Shndx
*)
3139 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3140 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3148 number
= section
->sh_size
/ section
->sh_entsize
;
3149 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3153 error (_("Out of memory\n"));
3160 for (j
= 0, psym
= isyms
;
3164 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3165 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3166 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3167 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3168 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3170 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3171 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3172 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3183 get_elf_section_flags (sh_flags
)
3186 static char buff
[32];
3194 flag
= sh_flags
& - sh_flags
;
3199 case SHF_WRITE
: strcat (buff
, "W"); break;
3200 case SHF_ALLOC
: strcat (buff
, "A"); break;
3201 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3202 case SHF_MERGE
: strcat (buff
, "M"); break;
3203 case SHF_STRINGS
: strcat (buff
, "S"); break;
3204 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3205 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3206 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3207 case SHF_GROUP
: strcat (buff
, "G"); break;
3208 case SHF_TLS
: strcat (buff
, "T"); break;
3211 if (flag
& SHF_MASKOS
)
3214 sh_flags
&= ~ SHF_MASKOS
;
3216 else if (flag
& SHF_MASKPROC
)
3219 sh_flags
&= ~ SHF_MASKPROC
;
3231 process_section_headers (file
)
3234 Elf_Internal_Shdr
* section
;
3237 section_headers
= NULL
;
3239 if (elf_header
.e_shnum
== 0)
3242 printf (_("\nThere are no sections in this file.\n"));
3247 if (do_sections
&& !do_header
)
3248 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3249 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3253 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3256 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3259 /* Read in the string table, so that we have names to display. */
3260 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3262 if (section
->sh_size
!= 0)
3264 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3265 section
->sh_size
, _("string table"));
3267 string_table_length
= section
->sh_size
;
3270 /* Scan the sections for the dynamic symbol table
3271 and dynamic string table and debug sections. */
3272 dynamic_symbols
= NULL
;
3273 dynamic_strings
= NULL
;
3274 dynamic_syminfo
= NULL
;
3276 for (i
= 0, section
= section_headers
;
3277 i
< elf_header
.e_shnum
;
3280 char * name
= SECTION_NAME (section
);
3282 if (section
->sh_type
== SHT_DYNSYM
)
3284 if (dynamic_symbols
!= NULL
)
3286 error (_("File contains multiple dynamic symbol tables\n"));
3290 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3291 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3293 else if (section
->sh_type
== SHT_STRTAB
3294 && strcmp (name
, ".dynstr") == 0)
3296 if (dynamic_strings
!= NULL
)
3298 error (_("File contains multiple dynamic string tables\n"));
3302 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3304 _("dynamic strings"));
3306 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3308 if (symtab_shndx_hdr
!= NULL
)
3310 error (_("File contains multiple symtab shndx tables\n"));
3313 symtab_shndx_hdr
= section
;
3315 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3316 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3317 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3319 && strncmp (name
, ".debug_", 7) == 0)
3324 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3325 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3326 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3327 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3328 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3329 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3330 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3331 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3332 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3334 request_dump (i
, DEBUG_DUMP
);
3336 /* linkonce section to be combined with .debug_info at link time. */
3337 else if ((do_debugging
|| do_debug_info
)
3338 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3339 request_dump (i
, DEBUG_DUMP
);
3340 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3341 request_dump (i
, DEBUG_DUMP
);
3347 if (elf_header
.e_shnum
> 1)
3348 printf (_("\nSection Headers:\n"));
3350 printf (_("\nSection Header:\n"));
3354 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3357 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3360 printf (_(" [Nr] Name Type Address Offset\n"));
3361 printf (_(" Size EntSize Flags Link Info Align\n"));
3364 for (i
= 0, section
= section_headers
;
3365 i
< elf_header
.e_shnum
;
3368 printf (" [%2u] %-17.17s %-15.15s ",
3369 SECTION_HEADER_NUM (i
),
3370 SECTION_NAME (section
),
3371 get_section_type_name (section
->sh_type
));
3375 print_vma (section
->sh_addr
, LONG_HEX
);
3377 printf ( " %6.6lx %6.6lx %2.2lx",
3378 (unsigned long) section
->sh_offset
,
3379 (unsigned long) section
->sh_size
,
3380 (unsigned long) section
->sh_entsize
);
3382 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3384 printf ("%2ld %3lx %2ld\n",
3385 (unsigned long) section
->sh_link
,
3386 (unsigned long) section
->sh_info
,
3387 (unsigned long) section
->sh_addralign
);
3391 print_vma (section
->sh_addr
, LONG_HEX
);
3393 if ((long) section
->sh_offset
== section
->sh_offset
)
3394 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3398 print_vma (section
->sh_offset
, LONG_HEX
);
3401 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3402 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3406 print_vma (section
->sh_size
, LONG_HEX
);
3409 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3410 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3414 print_vma (section
->sh_entsize
, LONG_HEX
);
3417 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3419 printf ("%2ld %3lx ",
3420 (unsigned long) section
->sh_link
,
3421 (unsigned long) section
->sh_info
);
3423 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3424 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3427 print_vma (section
->sh_addralign
, DEC
);
3434 print_vma (section
->sh_addr
, LONG_HEX
);
3435 if ((long) section
->sh_offset
== section
->sh_offset
)
3436 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3440 print_vma (section
->sh_offset
, LONG_HEX
);
3443 print_vma (section
->sh_size
, LONG_HEX
);
3445 print_vma (section
->sh_entsize
, LONG_HEX
);
3447 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3449 printf (" %2ld %3lx %ld\n",
3450 (unsigned long) section
->sh_link
,
3451 (unsigned long) section
->sh_info
,
3452 (unsigned long) section
->sh_addralign
);
3456 printf (_("Key to Flags:\n\
3457 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3458 I (info), L (link order), G (group), x (unknown)\n\
3459 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3464 /* Process the reloc section. */
3466 process_relocs (file
)
3469 unsigned long rel_size
;
3470 unsigned long rel_offset
;
3476 if (do_using_dynamic
)
3478 int is_rela
= FALSE
;
3483 if (dynamic_info
[DT_REL
])
3485 rel_offset
= dynamic_info
[DT_REL
];
3486 rel_size
= dynamic_info
[DT_RELSZ
];
3489 else if (dynamic_info
[DT_RELA
])
3491 rel_offset
= dynamic_info
[DT_RELA
];
3492 rel_size
= dynamic_info
[DT_RELASZ
];
3495 else if (dynamic_info
[DT_JMPREL
])
3497 rel_offset
= dynamic_info
[DT_JMPREL
];
3498 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3500 switch (dynamic_info
[DT_PLTREL
])
3517 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3518 rel_offset
, rel_size
);
3520 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3521 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3524 printf (_("\nThere are no dynamic relocations in this file.\n"));
3528 Elf32_Internal_Shdr
* section
;
3532 for (i
= 0, section
= section_headers
;
3533 i
< elf_header
.e_shnum
;
3536 if ( section
->sh_type
!= SHT_RELA
3537 && section
->sh_type
!= SHT_REL
)
3540 rel_offset
= section
->sh_offset
;
3541 rel_size
= section
->sh_size
;
3545 Elf32_Internal_Shdr
* strsec
;
3546 Elf_Internal_Sym
* symtab
;
3549 unsigned long nsyms
;
3551 printf (_("\nRelocation section "));
3553 if (string_table
== NULL
)
3554 printf ("%d", section
->sh_name
);
3556 printf (_("'%s'"), SECTION_NAME (section
));
3558 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3559 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3564 if (section
->sh_link
)
3566 Elf32_Internal_Shdr
* symsec
;
3568 symsec
= SECTION_HEADER (section
->sh_link
);
3569 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3570 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3575 strsec
= SECTION_HEADER (symsec
->sh_link
);
3577 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3581 is_rela
= section
->sh_type
== SHT_RELA
;
3583 dump_relocations (file
, rel_offset
, rel_size
,
3584 symtab
, nsyms
, strtab
, is_rela
);
3596 printf (_("\nThere are no relocations in this file.\n"));
3602 #include "unwind-ia64.h"
3604 /* An absolute address consists of a section and an offset. If the
3605 section is NULL, the offset itself is the address, otherwise, the
3606 address equals to LOAD_ADDRESS(section) + offset. */
3610 unsigned short section
;
3616 struct unw_table_entry
3618 struct absaddr start
;
3620 struct absaddr info
;
3622 *table
; /* Unwind table. */
3623 unsigned long table_len
; /* Length of unwind table. */
3624 unsigned char * info
; /* Unwind info. */
3625 unsigned long info_size
; /* Size of unwind info. */
3626 bfd_vma info_addr
; /* starting address of unwind info. */
3627 bfd_vma seg_base
; /* Starting address of segment. */
3628 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3629 unsigned long nsyms
; /* Number of symbols. */
3630 char * strtab
; /* The string table. */
3631 unsigned long strtab_size
; /* Size of string table. */
3634 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3635 struct absaddr
, const char **,
3637 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3638 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3639 Elf32_Internal_Shdr
*));
3642 find_symbol_for_address (aux
, addr
, symname
, offset
)
3643 struct unw_aux_info
*aux
;
3644 struct absaddr addr
;
3645 const char **symname
;
3648 bfd_vma dist
= (bfd_vma
) 0x100000;
3649 Elf_Internal_Sym
*sym
, *best
= NULL
;
3652 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3654 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3655 && sym
->st_name
!= 0
3656 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3657 && addr
.offset
>= sym
->st_value
3658 && addr
.offset
- sym
->st_value
< dist
)
3661 dist
= addr
.offset
- sym
->st_value
;
3668 *symname
= (best
->st_name
>= aux
->strtab_size
3669 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3674 *offset
= addr
.offset
;
3678 dump_ia64_unwind (aux
)
3679 struct unw_aux_info
*aux
;
3682 struct unw_table_entry
* tp
;
3685 addr_size
= is_32bit_elf
? 4 : 8;
3687 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3691 const unsigned char * dp
;
3692 const unsigned char * head
;
3693 const char * procname
;
3695 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3697 fputs ("\n<", stdout
);
3701 fputs (procname
, stdout
);
3704 printf ("+%lx", (unsigned long) offset
);
3707 fputs (">: [", stdout
);
3708 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3709 fputc ('-', stdout
);
3710 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3711 printf ("), info at +0x%lx\n",
3712 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3714 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3715 stamp
= BYTE_GET8 ((unsigned char *) head
);
3717 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3718 (unsigned) UNW_VER (stamp
),
3719 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3720 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3721 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3722 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3724 if (UNW_VER (stamp
) != 1)
3726 printf ("\tUnknown version.\n");
3731 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3732 dp
= unw_decode (dp
, in_body
, & in_body
);
3737 slurp_ia64_unwind_table (file
, aux
, sec
)
3739 struct unw_aux_info
*aux
;
3740 Elf32_Internal_Shdr
*sec
;
3742 unsigned long size
, addr_size
, nrelas
, i
;
3743 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3744 struct unw_table_entry
*tep
;
3745 Elf32_Internal_Shdr
*relsec
;
3746 Elf_Internal_Rela
*rela
, *rp
;
3747 unsigned char *table
, *tp
;
3748 Elf_Internal_Sym
*sym
;
3749 const char *relname
;
3752 addr_size
= is_32bit_elf
? 4 : 8;
3754 /* First, find the starting address of the segment that includes
3757 if (elf_header
.e_phnum
)
3759 prog_hdrs
= (Elf_Internal_Phdr
*)
3760 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3763 result
= get_32bit_program_headers (file
, prog_hdrs
);
3765 result
= get_64bit_program_headers (file
, prog_hdrs
);
3773 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3775 if (seg
->p_type
!= PT_LOAD
)
3778 if (sec
->sh_addr
>= seg
->p_vaddr
3779 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3781 aux
->seg_base
= seg
->p_vaddr
;
3789 /* Second, build the unwind table from the contents of the unwind section: */
3790 size
= sec
->sh_size
;
3791 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3792 size
, _("unwind table"));
3796 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3797 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3799 tep
->start
.section
= SHN_UNDEF
;
3800 tep
->end
.section
= SHN_UNDEF
;
3801 tep
->info
.section
= SHN_UNDEF
;
3804 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3805 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3806 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3810 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3811 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3812 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3814 tep
->start
.offset
+= aux
->seg_base
;
3815 tep
->end
.offset
+= aux
->seg_base
;
3816 tep
->info
.offset
+= aux
->seg_base
;
3820 /* Third, apply any relocations to the unwind table: */
3822 for (relsec
= section_headers
;
3823 relsec
< section_headers
+ elf_header
.e_shnum
;
3826 if (relsec
->sh_type
!= SHT_RELA
3827 || SECTION_HEADER (relsec
->sh_info
) != sec
)
3830 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3834 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3838 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3839 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3841 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3843 warn (_("Skipping unexpected symbol type %u\n"),
3844 ELF32_ST_TYPE (sym
->st_info
));
3850 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3851 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3853 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3855 warn (_("Skipping unexpected symbol type %u\n"),
3856 ELF64_ST_TYPE (sym
->st_info
));
3861 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
3863 warn (_("Skipping unexpected relocation type %s\n"), relname
);
3867 i
= rp
->r_offset
/ (3 * addr_size
);
3869 switch (rp
->r_offset
/addr_size
% 3)
3872 aux
->table
[i
].start
.section
= sym
->st_shndx
;
3873 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
3876 aux
->table
[i
].end
.section
= sym
->st_shndx
;
3877 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
3880 aux
->table
[i
].info
.section
= sym
->st_shndx
;
3881 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
3891 aux
->table_len
= size
/ (3 * addr_size
);
3896 process_unwind (file
)
3899 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
3900 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
3901 struct unw_aux_info aux
;
3906 if (elf_header
.e_machine
!= EM_IA_64
)
3908 printf (_("\nThere are no unwind sections in this file.\n"));
3912 memset (& aux
, 0, sizeof (aux
));
3914 addr_size
= is_32bit_elf
? 4 : 8;
3916 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
3918 if (sec
->sh_type
== SHT_SYMTAB
)
3920 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
3921 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
3923 strsec
= SECTION_HEADER (sec
->sh_link
);
3924 aux
.strtab_size
= strsec
->sh_size
;
3925 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3926 aux
.strtab_size
, _("string table"));
3928 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3933 printf (_("\nThere are no unwind sections in this file.\n"));
3935 while (unwcount
-- > 0)
3940 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
3941 i
< elf_header
.e_shnum
; ++i
, ++sec
)
3942 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3949 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
3951 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
3954 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3955 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
3956 suffix
= SECTION_NAME (unwsec
) + len
;
3957 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3959 if (strncmp (SECTION_NAME (sec
),
3960 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
3961 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3966 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3967 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3968 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
3969 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
3971 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
3973 suffix
= SECTION_NAME (unwsec
) + len
;
3974 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3976 if (strncmp (SECTION_NAME (sec
),
3977 ELF_STRING_ia64_unwind_info
, len2
) == 0
3978 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3982 if (i
== elf_header
.e_shnum
)
3984 printf (_("\nCould not find unwind info section for "));
3986 if (string_table
== NULL
)
3987 printf ("%d", unwsec
->sh_name
);
3989 printf (_("'%s'"), SECTION_NAME (unwsec
));
3993 aux
.info_size
= sec
->sh_size
;
3994 aux
.info_addr
= sec
->sh_addr
;
3995 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3996 aux
.info_size
, _("unwind info"));
3998 printf (_("\nUnwind section "));
4000 if (string_table
== NULL
)
4001 printf ("%d", unwsec
->sh_name
);
4003 printf (_("'%s'"), SECTION_NAME (unwsec
));
4005 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4006 (unsigned long) unwsec
->sh_offset
,
4007 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4009 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4011 if (aux
.table_len
> 0)
4012 dump_ia64_unwind (& aux
);
4015 free ((char *) aux
.table
);
4017 free ((char *) aux
.info
);
4026 free ((char *) aux
.strtab
);
4032 dynamic_segment_mips_val (entry
)
4033 Elf_Internal_Dyn
* entry
;
4035 switch (entry
->d_tag
)
4038 if (entry
->d_un
.d_val
== 0)
4042 static const char * opts
[] =
4044 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4045 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4046 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4047 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4052 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
4053 if (entry
->d_un
.d_val
& (1 << cnt
))
4055 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4062 case DT_MIPS_IVERSION
:
4063 if (dynamic_strings
!= NULL
)
4064 printf ("Interface Version: %s\n",
4065 dynamic_strings
+ entry
->d_un
.d_val
);
4067 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4070 case DT_MIPS_TIME_STAMP
:
4075 time_t time
= entry
->d_un
.d_val
;
4076 tmp
= gmtime (&time
);
4077 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4078 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4079 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4080 printf ("Time Stamp: %s\n", timebuf
);
4084 case DT_MIPS_RLD_VERSION
:
4085 case DT_MIPS_LOCAL_GOTNO
:
4086 case DT_MIPS_CONFLICTNO
:
4087 case DT_MIPS_LIBLISTNO
:
4088 case DT_MIPS_SYMTABNO
:
4089 case DT_MIPS_UNREFEXTNO
:
4090 case DT_MIPS_HIPAGENO
:
4091 case DT_MIPS_DELTA_CLASS_NO
:
4092 case DT_MIPS_DELTA_INSTANCE_NO
:
4093 case DT_MIPS_DELTA_RELOC_NO
:
4094 case DT_MIPS_DELTA_SYM_NO
:
4095 case DT_MIPS_DELTA_CLASSSYM_NO
:
4096 case DT_MIPS_COMPACT_SIZE
:
4097 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4101 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4107 dynamic_segment_parisc_val (entry
)
4108 Elf_Internal_Dyn
* entry
;
4110 switch (entry
->d_tag
)
4112 case DT_HP_DLD_FLAGS
:
4121 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4122 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4123 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4124 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4125 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4126 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4127 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4128 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4129 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4130 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4131 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4135 bfd_vma val
= entry
->d_un
.d_val
;
4137 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4138 if (val
& flags
[cnt
].bit
)
4142 fputs (flags
[cnt
].str
, stdout
);
4144 val
^= flags
[cnt
].bit
;
4147 if (val
!= 0 || first
)
4151 print_vma (val
, HEX
);
4157 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4163 get_32bit_dynamic_segment (file
)
4166 Elf32_External_Dyn
* edyn
;
4167 Elf_Internal_Dyn
* entry
;
4170 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4171 dynamic_size
, _("dynamic segment"));
4175 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4176 how large this .dynamic is now. We can do this even before the byte
4177 swapping since the DT_NULL tag is recognizable. */
4179 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4182 dynamic_segment
= (Elf_Internal_Dyn
*)
4183 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4185 if (dynamic_segment
== NULL
)
4187 error (_("Out of memory\n"));
4192 for (i
= 0, entry
= dynamic_segment
;
4196 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4197 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4206 get_64bit_dynamic_segment (file
)
4209 Elf64_External_Dyn
* edyn
;
4210 Elf_Internal_Dyn
* entry
;
4213 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4214 dynamic_size
, _("dynamic segment"));
4218 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4219 how large this .dynamic is now. We can do this even before the byte
4220 swapping since the DT_NULL tag is recognizable. */
4222 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4225 dynamic_segment
= (Elf_Internal_Dyn
*)
4226 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4228 if (dynamic_segment
== NULL
)
4230 error (_("Out of memory\n"));
4235 for (i
= 0, entry
= dynamic_segment
;
4239 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4240 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4249 get_dynamic_flags (flags
)
4252 static char buff
[128];
4260 flag
= flags
& - flags
;
4268 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4269 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4270 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4271 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4272 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4273 default: strcpy (p
, "unknown"); break;
4276 p
= strchr (p
, '\0');
4281 /* Parse and display the contents of the dynamic segment. */
4283 process_dynamic_segment (file
)
4286 Elf_Internal_Dyn
* entry
;
4289 if (dynamic_size
== 0)
4292 printf (_("\nThere is no dynamic segment in this file.\n"));
4299 if (! get_32bit_dynamic_segment (file
))
4302 else if (! get_64bit_dynamic_segment (file
))
4305 /* Find the appropriate symbol table. */
4306 if (dynamic_symbols
== NULL
)
4308 for (i
= 0, entry
= dynamic_segment
;
4312 Elf32_Internal_Shdr section
;
4314 if (entry
->d_tag
!= DT_SYMTAB
)
4317 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4319 /* Since we do not know how big the symbol table is,
4320 we default to reading in the entire file (!) and
4321 processing that. This is overkill, I know, but it
4323 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4325 if (fseek (file
, 0, SEEK_END
))
4326 error (_("Unable to seek to end of file!"));
4328 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4330 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4332 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4334 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4335 if (num_dynamic_syms
< 1)
4337 error (_("Unable to determine the number of symbols to load\n"));
4341 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4345 /* Similarly find a string table. */
4346 if (dynamic_strings
== NULL
)
4348 for (i
= 0, entry
= dynamic_segment
;
4352 unsigned long offset
;
4355 if (entry
->d_tag
!= DT_STRTAB
)
4358 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4360 /* Since we do not know how big the string table is,
4361 we default to reading in the entire file (!) and
4362 processing that. This is overkill, I know, but it
4365 offset
= entry
->d_un
.d_val
- loadaddr
;
4366 if (fseek (file
, 0, SEEK_END
))
4367 error (_("Unable to seek to end of file\n"));
4368 str_tab_len
= ftell (file
) - offset
;
4370 if (str_tab_len
< 1)
4373 (_("Unable to determine the length of the dynamic string table\n"));
4377 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4378 _("dynamic string table"));
4383 /* And find the syminfo section if available. */
4384 if (dynamic_syminfo
== NULL
)
4386 unsigned int syminsz
= 0;
4388 for (i
= 0, entry
= dynamic_segment
;
4392 if (entry
->d_tag
== DT_SYMINENT
)
4394 /* Note: these braces are necessary to avoid a syntax
4395 error from the SunOS4 C compiler. */
4396 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4398 else if (entry
->d_tag
== DT_SYMINSZ
)
4399 syminsz
= entry
->d_un
.d_val
;
4400 else if (entry
->d_tag
== DT_SYMINFO
)
4401 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4404 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4406 Elf_External_Syminfo
* extsyminfo
;
4407 Elf_Internal_Syminfo
* syminfo
;
4409 /* There is a syminfo section. Read the data. */
4410 extsyminfo
= ((Elf_External_Syminfo
*)
4411 get_data (NULL
, file
, dynamic_syminfo_offset
,
4412 syminsz
, _("symbol information")));
4416 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4417 if (dynamic_syminfo
== NULL
)
4419 error (_("Out of memory\n"));
4423 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4424 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4427 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4428 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4435 if (do_dynamic
&& dynamic_addr
)
4436 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4437 dynamic_addr
, (long) dynamic_size
);
4439 printf (_(" Tag Type Name/Value\n"));
4441 for (i
= 0, entry
= dynamic_segment
;
4450 print_vma (entry
->d_tag
, FULL_HEX
);
4451 dtype
= get_dynamic_type (entry
->d_tag
);
4452 printf (" (%s)%*s", dtype
,
4453 ((is_32bit_elf
? 27 : 19)
4454 - (int) strlen (dtype
)),
4458 switch (entry
->d_tag
)
4462 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4472 switch (entry
->d_tag
)
4475 printf (_("Auxiliary library"));
4479 printf (_("Filter library"));
4483 printf (_("Configuration file"));
4487 printf (_("Dependency audit library"));
4491 printf (_("Audit library"));
4495 if (dynamic_strings
)
4496 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4500 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4509 printf (_("Flags:"));
4510 if (entry
->d_un
.d_val
== 0)
4511 printf (_(" None\n"));
4514 unsigned long int val
= entry
->d_un
.d_val
;
4515 if (val
& DTF_1_PARINIT
)
4517 printf (" PARINIT");
4518 val
^= DTF_1_PARINIT
;
4520 if (val
& DTF_1_CONFEXP
)
4522 printf (" CONFEXP");
4523 val
^= DTF_1_CONFEXP
;
4526 printf (" %lx", val
);
4535 printf (_("Flags:"));
4536 if (entry
->d_un
.d_val
== 0)
4537 printf (_(" None\n"));
4540 unsigned long int val
= entry
->d_un
.d_val
;
4541 if (val
& DF_P1_LAZYLOAD
)
4543 printf (" LAZYLOAD");
4544 val
^= DF_P1_LAZYLOAD
;
4546 if (val
& DF_P1_GROUPPERM
)
4548 printf (" GROUPPERM");
4549 val
^= DF_P1_GROUPPERM
;
4552 printf (" %lx", val
);
4561 printf (_("Flags:"));
4562 if (entry
->d_un
.d_val
== 0)
4563 printf (_(" None\n"));
4566 unsigned long int val
= entry
->d_un
.d_val
;
4572 if (val
& DF_1_GLOBAL
)
4577 if (val
& DF_1_GROUP
)
4582 if (val
& DF_1_NODELETE
)
4584 printf (" NODELETE");
4585 val
^= DF_1_NODELETE
;
4587 if (val
& DF_1_LOADFLTR
)
4589 printf (" LOADFLTR");
4590 val
^= DF_1_LOADFLTR
;
4592 if (val
& DF_1_INITFIRST
)
4594 printf (" INITFIRST");
4595 val
^= DF_1_INITFIRST
;
4597 if (val
& DF_1_NOOPEN
)
4602 if (val
& DF_1_ORIGIN
)
4607 if (val
& DF_1_DIRECT
)
4612 if (val
& DF_1_TRANS
)
4617 if (val
& DF_1_INTERPOSE
)
4619 printf (" INTERPOSE");
4620 val
^= DF_1_INTERPOSE
;
4622 if (val
& DF_1_NODEFLIB
)
4624 printf (" NODEFLIB");
4625 val
^= DF_1_NODEFLIB
;
4627 if (val
& DF_1_NODUMP
)
4632 if (val
& DF_1_CONLFAT
)
4634 printf (" CONLFAT");
4635 val
^= DF_1_CONLFAT
;
4638 printf (" %lx", val
);
4646 puts (get_dynamic_type (entry
->d_un
.d_val
));
4666 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4672 if (dynamic_strings
== NULL
)
4675 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4679 switch (entry
->d_tag
)
4682 printf (_("Shared library: [%s]"), name
);
4684 if (strcmp (name
, program_interpreter
) == 0)
4685 printf (_(" program interpreter"));
4689 printf (_("Library soname: [%s]"), name
);
4693 printf (_("Library rpath: [%s]"), name
);
4697 printf (_("Library runpath: [%s]"), name
);
4701 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4706 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4722 case DT_INIT_ARRAYSZ
:
4723 case DT_FINI_ARRAYSZ
:
4726 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4727 printf (" (bytes)\n");
4737 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4750 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4754 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4758 printf (_("Not needed object: [%s]\n"), name
);
4763 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4769 /* The value of this entry is ignored. */
4773 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4774 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4779 switch (elf_header
.e_machine
)
4782 case EM_MIPS_RS3_LE
:
4783 dynamic_segment_mips_val (entry
);
4786 dynamic_segment_parisc_val (entry
);
4789 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4801 get_ver_flags (flags
)
4804 static char buff
[32];
4811 if (flags
& VER_FLG_BASE
)
4812 strcat (buff
, "BASE ");
4814 if (flags
& VER_FLG_WEAK
)
4816 if (flags
& VER_FLG_BASE
)
4817 strcat (buff
, "| ");
4819 strcat (buff
, "WEAK ");
4822 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4823 strcat (buff
, "| <unknown>");
4828 /* Display the contents of the version sections. */
4830 process_version_sections (file
)
4833 Elf32_Internal_Shdr
* section
;
4840 for (i
= 0, section
= section_headers
;
4841 i
< elf_header
.e_shnum
;
4844 switch (section
->sh_type
)
4846 case SHT_GNU_verdef
:
4848 Elf_External_Verdef
* edefs
;
4855 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4856 SECTION_NAME (section
), section
->sh_info
);
4858 printf (_(" Addr: 0x"));
4859 printf_vma (section
->sh_addr
);
4860 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4861 (unsigned long) section
->sh_offset
, section
->sh_link
,
4862 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
4864 edefs
= ((Elf_External_Verdef
*)
4865 get_data (NULL
, file
, section
->sh_offset
,
4867 _("version definition section")));
4871 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
4874 Elf_External_Verdef
* edef
;
4875 Elf_Internal_Verdef ent
;
4876 Elf_External_Verdaux
* eaux
;
4877 Elf_Internal_Verdaux aux
;
4881 vstart
= ((char *) edefs
) + idx
;
4883 edef
= (Elf_External_Verdef
*) vstart
;
4885 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
4886 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
4887 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
4888 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
4889 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
4890 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
4891 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
4893 printf (_(" %#06x: Rev: %d Flags: %s"),
4894 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
4896 printf (_(" Index: %d Cnt: %d "),
4897 ent
.vd_ndx
, ent
.vd_cnt
);
4899 vstart
+= ent
.vd_aux
;
4901 eaux
= (Elf_External_Verdaux
*) vstart
;
4903 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4904 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4906 if (dynamic_strings
)
4907 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
4909 printf (_("Name index: %ld\n"), aux
.vda_name
);
4911 isum
= idx
+ ent
.vd_aux
;
4913 for (j
= 1; j
< ent
.vd_cnt
; j
++)
4915 isum
+= aux
.vda_next
;
4916 vstart
+= aux
.vda_next
;
4918 eaux
= (Elf_External_Verdaux
*) vstart
;
4920 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4921 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4923 if (dynamic_strings
)
4924 printf (_(" %#06x: Parent %d: %s\n"),
4925 isum
, j
, dynamic_strings
+ aux
.vda_name
);
4927 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4928 isum
, j
, aux
.vda_name
);
4938 case SHT_GNU_verneed
:
4940 Elf_External_Verneed
* eneed
;
4946 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4947 SECTION_NAME (section
), section
->sh_info
);
4949 printf (_(" Addr: 0x"));
4950 printf_vma (section
->sh_addr
);
4951 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4952 (unsigned long) section
->sh_offset
, section
->sh_link
,
4953 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
4955 eneed
= ((Elf_External_Verneed
*)
4956 get_data (NULL
, file
, section
->sh_offset
,
4957 section
->sh_size
, _("version need section")));
4961 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
4963 Elf_External_Verneed
* entry
;
4964 Elf_Internal_Verneed ent
;
4969 vstart
= ((char *) eneed
) + idx
;
4971 entry
= (Elf_External_Verneed
*) vstart
;
4973 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
4974 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
4975 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
4976 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
4977 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
4979 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
4981 if (dynamic_strings
)
4982 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
4984 printf (_(" File: %lx"), ent
.vn_file
);
4986 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
4988 vstart
+= ent
.vn_aux
;
4990 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
4992 Elf_External_Vernaux
* eaux
;
4993 Elf_Internal_Vernaux aux
;
4995 eaux
= (Elf_External_Vernaux
*) vstart
;
4997 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
4998 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
4999 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5000 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5001 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5003 if (dynamic_strings
)
5004 printf (_(" %#06x: Name: %s"),
5005 isum
, dynamic_strings
+ aux
.vna_name
);
5007 printf (_(" %#06x: Name index: %lx"),
5008 isum
, aux
.vna_name
);
5010 printf (_(" Flags: %s Version: %d\n"),
5011 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5013 isum
+= aux
.vna_next
;
5014 vstart
+= aux
.vna_next
;
5024 case SHT_GNU_versym
:
5026 Elf32_Internal_Shdr
* link_section
;
5029 unsigned char * edata
;
5030 unsigned short * data
;
5032 Elf_Internal_Sym
* symbols
;
5033 Elf32_Internal_Shdr
* string_sec
;
5035 link_section
= SECTION_HEADER (section
->sh_link
);
5036 total
= section
->sh_size
/ section
->sh_entsize
;
5040 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5042 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5044 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5045 string_sec
->sh_size
,
5046 _("version string table"));
5050 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5051 SECTION_NAME (section
), total
);
5053 printf (_(" Addr: "));
5054 printf_vma (section
->sh_addr
);
5055 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5056 (unsigned long) section
->sh_offset
, section
->sh_link
,
5057 SECTION_NAME (link_section
));
5061 get_data (NULL
, file
,
5062 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5063 total
* sizeof (short), _("version symbol data")));
5070 data
= (unsigned short *) malloc (total
* sizeof (short));
5072 for (cnt
= total
; cnt
--;)
5073 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5078 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5081 int check_def
, check_need
;
5084 printf (" %03x:", cnt
);
5086 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5087 switch (data
[cnt
+ j
])
5090 fputs (_(" 0 (*local*) "), stdout
);
5094 fputs (_(" 1 (*global*) "), stdout
);
5098 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5099 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5103 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5106 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5113 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5115 Elf_Internal_Verneed ivn
;
5116 unsigned long offset
;
5118 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5123 Elf_Internal_Vernaux ivna
;
5124 Elf_External_Verneed evn
;
5125 Elf_External_Vernaux evna
;
5126 unsigned long a_off
;
5128 get_data (&evn
, file
, offset
, sizeof (evn
),
5131 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5132 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5134 a_off
= offset
+ ivn
.vn_aux
;
5138 get_data (&evna
, file
, a_off
, sizeof (evna
),
5139 _("version need aux (2)"));
5141 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5142 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5144 a_off
+= ivna
.vna_next
;
5146 while (ivna
.vna_other
!= data
[cnt
+ j
]
5147 && ivna
.vna_next
!= 0);
5149 if (ivna
.vna_other
== data
[cnt
+ j
])
5151 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5153 name
= strtab
+ ivna
.vna_name
;
5154 nn
+= printf ("(%s%-*s",
5156 12 - (int) strlen (name
),
5162 offset
+= ivn
.vn_next
;
5164 while (ivn
.vn_next
);
5167 if (check_def
&& data
[cnt
+ j
] != 0x8001
5168 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5170 Elf_Internal_Verdef ivd
;
5171 Elf_External_Verdef evd
;
5172 unsigned long offset
;
5174 offset
= version_info
5175 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
5179 get_data (&evd
, file
, offset
, sizeof (evd
),
5182 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5183 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5185 offset
+= ivd
.vd_next
;
5187 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5188 && ivd
.vd_next
!= 0);
5190 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5192 Elf_External_Verdaux evda
;
5193 Elf_Internal_Verdaux ivda
;
5195 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5197 get_data (&evda
, file
,
5198 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5199 sizeof (evda
), _("version def aux"));
5201 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5203 name
= strtab
+ ivda
.vda_name
;
5204 nn
+= printf ("(%s%-*s",
5206 12 - (int) strlen (name
),
5212 printf ("%*c", 18 - nn
, ' ');
5230 printf (_("\nNo version information found in this file.\n"));
5236 get_symbol_binding (binding
)
5237 unsigned int binding
;
5239 static char buff
[32];
5243 case STB_LOCAL
: return "LOCAL";
5244 case STB_GLOBAL
: return "GLOBAL";
5245 case STB_WEAK
: return "WEAK";
5247 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5248 sprintf (buff
, _("<processor specific>: %d"), binding
);
5249 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5250 sprintf (buff
, _("<OS specific>: %d"), binding
);
5252 sprintf (buff
, _("<unknown>: %d"), binding
);
5258 get_symbol_type (type
)
5261 static char buff
[32];
5265 case STT_NOTYPE
: return "NOTYPE";
5266 case STT_OBJECT
: return "OBJECT";
5267 case STT_FUNC
: return "FUNC";
5268 case STT_SECTION
: return "SECTION";
5269 case STT_FILE
: return "FILE";
5270 case STT_COMMON
: return "COMMON";
5271 case STT_TLS
: return "TLS";
5273 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5275 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5276 return "THUMB_FUNC";
5278 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5281 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5282 return "PARISC_MILLI";
5284 sprintf (buff
, _("<processor specific>: %d"), type
);
5286 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5288 if (elf_header
.e_machine
== EM_PARISC
)
5290 if (type
== STT_HP_OPAQUE
)
5292 if (type
== STT_HP_STUB
)
5296 sprintf (buff
, _("<OS specific>: %d"), type
);
5299 sprintf (buff
, _("<unknown>: %d"), type
);
5305 get_symbol_visibility (visibility
)
5306 unsigned int visibility
;
5310 case STV_DEFAULT
: return "DEFAULT";
5311 case STV_INTERNAL
: return "INTERNAL";
5312 case STV_HIDDEN
: return "HIDDEN";
5313 case STV_PROTECTED
: return "PROTECTED";
5319 get_symbol_index_type (type
)
5324 case SHN_UNDEF
: return "UND";
5325 case SHN_ABS
: return "ABS";
5326 case SHN_COMMON
: return "COM";
5328 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5330 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5332 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5336 static char buff
[32];
5338 sprintf (buff
, "%3d", type
);
5345 get_dynamic_data (file
, number
)
5347 unsigned int number
;
5349 unsigned char * e_data
;
5352 e_data
= (unsigned char *) malloc (number
* 4);
5356 error (_("Out of memory\n"));
5360 if (fread (e_data
, 4, number
, file
) != number
)
5362 error (_("Unable to read in dynamic data\n"));
5366 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5370 error (_("Out of memory\n"));
5376 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5383 /* Dump the symbol table. */
5385 process_symbol_table (file
)
5388 Elf32_Internal_Shdr
* section
;
5389 unsigned char nb
[4];
5390 unsigned char nc
[4];
5393 int * buckets
= NULL
;
5394 int * chains
= NULL
;
5396 if (! do_syms
&& !do_histogram
)
5399 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5402 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5404 error (_("Unable to seek to start of dynamic information"));
5408 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5410 error (_("Failed to read in number of buckets\n"));
5414 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5416 error (_("Failed to read in number of chains\n"));
5420 nbuckets
= byte_get (nb
, 4);
5421 nchains
= byte_get (nc
, 4);
5423 buckets
= get_dynamic_data (file
, nbuckets
);
5424 chains
= get_dynamic_data (file
, nchains
);
5426 if (buckets
== NULL
|| chains
== NULL
)
5431 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5436 printf (_("\nSymbol table for image:\n"));
5438 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5440 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5442 for (hn
= 0; hn
< nbuckets
; hn
++)
5447 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5449 Elf_Internal_Sym
* psym
;
5451 psym
= dynamic_symbols
+ si
;
5453 printf (" %3d %3d: ", si
, hn
);
5454 print_vma (psym
->st_value
, LONG_HEX
);
5456 print_vma (psym
->st_size
, DEC_5
);
5458 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5459 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5460 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5461 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5462 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5467 else if (do_syms
&& !do_using_dynamic
)
5471 for (i
= 0, section
= section_headers
;
5472 i
< elf_header
.e_shnum
;
5477 Elf_Internal_Sym
* symtab
;
5478 Elf_Internal_Sym
* psym
;
5481 if ( section
->sh_type
!= SHT_SYMTAB
5482 && section
->sh_type
!= SHT_DYNSYM
)
5485 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5486 SECTION_NAME (section
),
5487 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5489 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5491 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5493 symtab
= GET_ELF_SYMBOLS (file
, section
);
5497 if (section
->sh_link
== elf_header
.e_shstrndx
)
5498 strtab
= string_table
;
5501 Elf32_Internal_Shdr
* string_sec
;
5503 string_sec
= SECTION_HEADER (section
->sh_link
);
5505 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5506 string_sec
->sh_size
,
5510 for (si
= 0, psym
= symtab
;
5511 si
< section
->sh_size
/ section
->sh_entsize
;
5514 printf ("%6d: ", si
);
5515 print_vma (psym
->st_value
, LONG_HEX
);
5517 print_vma (psym
->st_size
, DEC_5
);
5518 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5519 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5520 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5521 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5522 print_symbol (25, strtab
+ psym
->st_name
);
5524 if (section
->sh_type
== SHT_DYNSYM
&&
5525 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5527 unsigned char data
[2];
5528 unsigned short vers_data
;
5529 unsigned long offset
;
5533 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5536 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5537 sizeof (data
), _("version data"));
5539 vers_data
= byte_get (data
, 2);
5541 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5544 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5546 if ((vers_data
& 0x8000) || vers_data
> 1)
5548 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5549 && (is_nobits
|| ! check_def
))
5551 Elf_External_Verneed evn
;
5552 Elf_Internal_Verneed ivn
;
5553 Elf_Internal_Vernaux ivna
;
5555 /* We must test both. */
5556 offset
= version_info
5557 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5561 unsigned long vna_off
;
5563 get_data (&evn
, file
, offset
, sizeof (evn
),
5566 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5567 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5569 vna_off
= offset
+ ivn
.vn_aux
;
5573 Elf_External_Vernaux evna
;
5575 get_data (&evna
, file
, vna_off
,
5577 _("version need aux (3)"));
5579 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5580 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5581 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5583 vna_off
+= ivna
.vna_next
;
5585 while (ivna
.vna_other
!= vers_data
5586 && ivna
.vna_next
!= 0);
5588 if (ivna
.vna_other
== vers_data
)
5591 offset
+= ivn
.vn_next
;
5593 while (ivn
.vn_next
!= 0);
5595 if (ivna
.vna_other
== vers_data
)
5598 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5601 else if (! is_nobits
)
5602 error (_("bad dynamic symbol"));
5609 if (vers_data
!= 0x8001
5610 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5612 Elf_Internal_Verdef ivd
;
5613 Elf_Internal_Verdaux ivda
;
5614 Elf_External_Verdaux evda
;
5615 unsigned long offset
;
5618 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5623 Elf_External_Verdef evd
;
5625 get_data (&evd
, file
, offset
, sizeof (evd
),
5628 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5629 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5630 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5632 offset
+= ivd
.vd_next
;
5634 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5635 && ivd
.vd_next
!= 0);
5637 offset
-= ivd
.vd_next
;
5638 offset
+= ivd
.vd_aux
;
5640 get_data (&evda
, file
, offset
, sizeof (evda
),
5641 _("version def aux"));
5643 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5645 if (psym
->st_name
!= ivda
.vda_name
)
5646 printf ((vers_data
& 0x8000)
5648 strtab
+ ivda
.vda_name
);
5658 if (strtab
!= string_table
)
5664 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5666 if (do_histogram
&& buckets
!= NULL
)
5673 int nzero_counts
= 0;
5676 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5678 printf (_(" Length Number %% of total Coverage\n"));
5680 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5681 if (lengths
== NULL
)
5683 error (_("Out of memory"));
5686 for (hn
= 0; hn
< nbuckets
; ++hn
)
5691 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5694 if (maxlength
< ++lengths
[hn
])
5699 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5702 error (_("Out of memory"));
5706 for (hn
= 0; hn
< nbuckets
; ++hn
)
5707 ++ counts
[lengths
[hn
]];
5711 printf (" 0 %-10d (%5.1f%%)\n",
5712 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5713 for (si
= 1; si
<= maxlength
; ++si
)
5715 nzero_counts
+= counts
[si
] * si
;
5716 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5717 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5718 (nzero_counts
* 100.0) / nsyms
);
5726 if (buckets
!= NULL
)
5736 process_syminfo (file
)
5737 FILE * file ATTRIBUTE_UNUSED
;
5741 if (dynamic_syminfo
== NULL
5743 /* No syminfo, this is ok. */
5746 /* There better should be a dynamic symbol section. */
5747 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5751 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5752 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5754 printf (_(" Num: Name BoundTo Flags\n"));
5755 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5757 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5759 printf ("%4d: ", i
);
5760 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5763 switch (dynamic_syminfo
[i
].si_boundto
)
5765 case SYMINFO_BT_SELF
:
5766 fputs ("SELF ", stdout
);
5768 case SYMINFO_BT_PARENT
:
5769 fputs ("PARENT ", stdout
);
5772 if (dynamic_syminfo
[i
].si_boundto
> 0
5773 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5775 print_symbol (10, dynamic_strings
5777 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5781 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5785 if (flags
& SYMINFO_FLG_DIRECT
)
5787 if (flags
& SYMINFO_FLG_PASSTHRU
)
5788 printf (" PASSTHRU");
5789 if (flags
& SYMINFO_FLG_COPY
)
5791 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5792 printf (" LAZYLOAD");
5800 #ifdef SUPPORT_DISASSEMBLY
5802 disassemble_section (section
, file
)
5803 Elf32_Internal_Shdr
* section
;
5806 printf (_("\nAssembly dump of section %s\n"),
5807 SECTION_NAME (section
));
5809 /* XXX -- to be done --- XXX */
5816 dump_section (section
, file
)
5817 Elf32_Internal_Shdr
* section
;
5820 bfd_size_type bytes
;
5822 unsigned char * data
;
5823 unsigned char * start
;
5825 bytes
= section
->sh_size
;
5829 printf (_("\nSection '%s' has no data to dump.\n"),
5830 SECTION_NAME (section
));
5834 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5836 addr
= section
->sh_addr
;
5838 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
5851 lbytes
= (bytes
> 16 ? 16 : bytes
);
5853 printf (" 0x%8.8lx ", (unsigned long) addr
);
5855 switch (elf_header
.e_ident
[EI_DATA
])
5859 for (j
= 15; j
>= 0; j
--)
5862 printf ("%2.2x", data
[j
]);
5872 for (j
= 0; j
< 16; j
++)
5875 printf ("%2.2x", data
[j
]);
5885 for (j
= 0; j
< lbytes
; j
++)
5888 if (k
>= ' ' && k
< 0x80)
5907 static unsigned long int
5908 read_leb128 (data
, length_return
, sign
)
5909 unsigned char * data
;
5910 int * length_return
;
5913 unsigned long int result
= 0;
5914 unsigned int num_read
= 0;
5923 result
|= (byte
& 0x7f) << shift
;
5928 while (byte
& 0x80);
5930 if (length_return
!= NULL
)
5931 * length_return
= num_read
;
5933 if (sign
&& (shift
< 32) && (byte
& 0x40))
5934 result
|= -1 << shift
;
5939 typedef struct State_Machine_Registers
5941 unsigned long address
;
5944 unsigned int column
;
5948 /* This variable hold the number of the last entry seen
5949 in the File Table. */
5950 unsigned int last_file_entry
;
5953 static SMR state_machine_regs
;
5956 reset_state_machine (is_stmt
)
5959 state_machine_regs
.address
= 0;
5960 state_machine_regs
.file
= 1;
5961 state_machine_regs
.line
= 1;
5962 state_machine_regs
.column
= 0;
5963 state_machine_regs
.is_stmt
= is_stmt
;
5964 state_machine_regs
.basic_block
= 0;
5965 state_machine_regs
.end_sequence
= 0;
5966 state_machine_regs
.last_file_entry
= 0;
5969 /* Handled an extend line op. Returns true if this is the end
5972 process_extended_line_op (data
, is_stmt
, pointer_size
)
5973 unsigned char * data
;
5977 unsigned char op_code
;
5980 unsigned char * name
;
5983 len
= read_leb128 (data
, & bytes_read
, 0);
5988 warn (_("badly formed extended line op encountered!\n"));
5993 op_code
= * data
++;
5995 printf (_(" Extended opcode %d: "), op_code
);
5999 case DW_LNE_end_sequence
:
6000 printf (_("End of Sequence\n\n"));
6001 reset_state_machine (is_stmt
);
6004 case DW_LNE_set_address
:
6005 adr
= byte_get (data
, pointer_size
);
6006 printf (_("set Address to 0x%lx\n"), adr
);
6007 state_machine_regs
.address
= adr
;
6010 case DW_LNE_define_file
:
6011 printf (_(" define new File Table entry\n"));
6012 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6014 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6016 data
+= strlen ((char *) data
) + 1;
6017 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6019 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6021 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6022 printf (_("%s\n\n"), name
);
6026 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6033 /* Size of pointers in the .debug_line section. This information is not
6034 really present in that section. It's obtained before dumping the debug
6035 sections by doing some pre-scan of the .debug_info section. */
6036 static int debug_line_pointer_size
= 4;
6039 display_debug_lines (section
, start
, file
)
6040 Elf32_Internal_Shdr
* section
;
6041 unsigned char * start
;
6042 FILE * file ATTRIBUTE_UNUSED
;
6044 DWARF2_External_LineInfo
* external
;
6045 DWARF2_Internal_LineInfo info
;
6046 unsigned char * standard_opcodes
;
6047 unsigned char * data
= start
;
6048 unsigned char * end
= start
+ section
->sh_size
;
6049 unsigned char * end_of_sequence
;
6052 printf (_("\nDump of debug contents of section %s:\n\n"),
6053 SECTION_NAME (section
));
6057 external
= (DWARF2_External_LineInfo
*) data
;
6059 /* Check the length of the block. */
6060 info
.li_length
= BYTE_GET (external
->li_length
);
6062 if (info
.li_length
== 0xffffffff)
6064 warn (_("64-bit DWARF line info is not supported yet.\n"));
6068 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6071 (_("The line info appears to be corrupt - the section is too small\n"));
6075 /* Check its version number. */
6076 info
.li_version
= BYTE_GET (external
->li_version
);
6077 if (info
.li_version
!= 2)
6079 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6083 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6084 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6085 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6086 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6087 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6088 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6090 /* Sign extend the line base field. */
6091 info
.li_line_base
<<= 24;
6092 info
.li_line_base
>>= 24;
6094 printf (_(" Length: %ld\n"), info
.li_length
);
6095 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6096 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6097 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6098 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6099 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6100 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6101 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6103 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6105 reset_state_machine (info
.li_default_is_stmt
);
6107 /* Display the contents of the Opcodes table. */
6108 standard_opcodes
= data
+ sizeof (* external
);
6110 printf (_("\n Opcodes:\n"));
6112 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6113 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6115 /* Display the contents of the Directory table. */
6116 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6119 printf (_("\n The Directory Table is empty.\n"));
6122 printf (_("\n The Directory Table:\n"));
6126 printf (_(" %s\n"), data
);
6128 data
+= strlen ((char *) data
) + 1;
6132 /* Skip the NUL at the end of the table. */
6135 /* Display the contents of the File Name table. */
6137 printf (_("\n The File Name Table is empty.\n"));
6140 printf (_("\n The File Name Table:\n"));
6141 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6145 unsigned char * name
;
6148 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6151 data
+= strlen ((char *) data
) + 1;
6153 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6155 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6157 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6159 printf (_("%s\n"), name
);
6163 /* Skip the NUL at the end of the table. */
6166 /* Now display the statements. */
6167 printf (_("\n Line Number Statements:\n"));
6170 while (data
< end_of_sequence
)
6172 unsigned char op_code
;
6176 op_code
= * data
++;
6178 if (op_code
>= info
.li_opcode_base
)
6180 op_code
-= info
.li_opcode_base
;
6181 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6182 state_machine_regs
.address
+= adv
;
6183 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6184 op_code
, adv
, state_machine_regs
.address
);
6185 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6186 state_machine_regs
.line
+= adv
;
6187 printf (_(" and Line by %d to %d\n"),
6188 adv
, state_machine_regs
.line
);
6190 else switch (op_code
)
6192 case DW_LNS_extended_op
:
6193 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6194 debug_line_pointer_size
);
6198 printf (_(" Copy\n"));
6201 case DW_LNS_advance_pc
:
6202 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6204 state_machine_regs
.address
+= adv
;
6205 printf (_(" Advance PC by %d to %lx\n"), adv
,
6206 state_machine_regs
.address
);
6209 case DW_LNS_advance_line
:
6210 adv
= read_leb128 (data
, & bytes_read
, 1);
6212 state_machine_regs
.line
+= adv
;
6213 printf (_(" Advance Line by %d to %d\n"), adv
,
6214 state_machine_regs
.line
);
6217 case DW_LNS_set_file
:
6218 adv
= read_leb128 (data
, & bytes_read
, 0);
6220 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6222 state_machine_regs
.file
= adv
;
6225 case DW_LNS_set_column
:
6226 adv
= read_leb128 (data
, & bytes_read
, 0);
6228 printf (_(" Set column to %d\n"), adv
);
6229 state_machine_regs
.column
= adv
;
6232 case DW_LNS_negate_stmt
:
6233 adv
= state_machine_regs
.is_stmt
;
6235 printf (_(" Set is_stmt to %d\n"), adv
);
6236 state_machine_regs
.is_stmt
= adv
;
6239 case DW_LNS_set_basic_block
:
6240 printf (_(" Set basic block\n"));
6241 state_machine_regs
.basic_block
= 1;
6244 case DW_LNS_const_add_pc
:
6245 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6246 * info
.li_min_insn_length
);
6247 state_machine_regs
.address
+= adv
;
6248 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6249 state_machine_regs
.address
);
6252 case DW_LNS_fixed_advance_pc
:
6253 adv
= byte_get (data
, 2);
6255 state_machine_regs
.address
+= adv
;
6256 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6257 adv
, state_machine_regs
.address
);
6260 case DW_LNS_set_prologue_end
:
6261 printf (_(" Set prologue_end to true\n"));
6264 case DW_LNS_set_epilogue_begin
:
6265 printf (_(" Set epilogue_begin to true\n"));
6268 case DW_LNS_set_isa
:
6269 adv
= read_leb128 (data
, & bytes_read
, 0);
6271 printf (_(" Set ISA to %d\n"), adv
);
6275 printf (_(" Unknown opcode %d with operands: "), op_code
);
6278 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6280 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6281 i
== 1 ? "" : ", ");
6296 display_debug_pubnames (section
, start
, file
)
6297 Elf32_Internal_Shdr
* section
;
6298 unsigned char * start
;
6299 FILE * file ATTRIBUTE_UNUSED
;
6301 DWARF2_External_PubNames
* external
;
6302 DWARF2_Internal_PubNames pubnames
;
6303 unsigned char * end
;
6305 end
= start
+ section
->sh_size
;
6307 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6311 unsigned char * data
;
6312 unsigned long offset
;
6314 external
= (DWARF2_External_PubNames
*) start
;
6316 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6317 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6318 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6319 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6321 data
= start
+ sizeof (* external
);
6322 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6324 if (pubnames
.pn_length
== 0xffffffff)
6326 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6330 if (pubnames
.pn_version
!= 2)
6332 static int warned
= 0;
6336 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6343 printf (_(" Length: %ld\n"),
6344 pubnames
.pn_length
);
6345 printf (_(" Version: %d\n"),
6346 pubnames
.pn_version
);
6347 printf (_(" Offset into .debug_info section: %ld\n"),
6348 pubnames
.pn_offset
);
6349 printf (_(" Size of area in .debug_info section: %ld\n"),
6352 printf (_("\n Offset\tName\n"));
6356 offset
= byte_get (data
, 4);
6361 printf (" %ld\t\t%s\n", offset
, data
);
6362 data
+= strlen ((char *) data
) + 1;
6365 while (offset
!= 0);
6378 case DW_TAG_padding
: return "DW_TAG_padding";
6379 case DW_TAG_array_type
: return "DW_TAG_array_type";
6380 case DW_TAG_class_type
: return "DW_TAG_class_type";
6381 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6382 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6383 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6384 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6385 case DW_TAG_label
: return "DW_TAG_label";
6386 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6387 case DW_TAG_member
: return "DW_TAG_member";
6388 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6389 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6390 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6391 case DW_TAG_string_type
: return "DW_TAG_string_type";
6392 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6393 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6394 case DW_TAG_typedef
: return "DW_TAG_typedef";
6395 case DW_TAG_union_type
: return "DW_TAG_union_type";
6396 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6397 case DW_TAG_variant
: return "DW_TAG_variant";
6398 case DW_TAG_common_block
: return "DW_TAG_common_block";
6399 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6400 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6401 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6402 case DW_TAG_module
: return "DW_TAG_module";
6403 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6404 case DW_TAG_set_type
: return "DW_TAG_set_type";
6405 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6406 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6407 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6408 case DW_TAG_base_type
: return "DW_TAG_base_type";
6409 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6410 case DW_TAG_const_type
: return "DW_TAG_const_type";
6411 case DW_TAG_constant
: return "DW_TAG_constant";
6412 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6413 case DW_TAG_file_type
: return "DW_TAG_file_type";
6414 case DW_TAG_friend
: return "DW_TAG_friend";
6415 case DW_TAG_namelist
: return "DW_TAG_namelist";
6416 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6417 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6418 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6419 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6420 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6421 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6422 case DW_TAG_try_block
: return "DW_TAG_try_block";
6423 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6424 case DW_TAG_variable
: return "DW_TAG_variable";
6425 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6426 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6427 case DW_TAG_format_label
: return "DW_TAG_format_label";
6428 case DW_TAG_function_template
: return "DW_TAG_function_template";
6429 case DW_TAG_class_template
: return "DW_TAG_class_template";
6430 /* DWARF 2.1 values. */
6431 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6432 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6433 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6434 case DW_TAG_namespace
: return "DW_TAG_namespace";
6435 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6436 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6437 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6438 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6441 static char buffer
[100];
6443 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6450 get_AT_name (attribute
)
6451 unsigned long attribute
;
6455 case DW_AT_sibling
: return "DW_AT_sibling";
6456 case DW_AT_location
: return "DW_AT_location";
6457 case DW_AT_name
: return "DW_AT_name";
6458 case DW_AT_ordering
: return "DW_AT_ordering";
6459 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6460 case DW_AT_byte_size
: return "DW_AT_byte_size";
6461 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6462 case DW_AT_bit_size
: return "DW_AT_bit_size";
6463 case DW_AT_element_list
: return "DW_AT_element_list";
6464 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6465 case DW_AT_low_pc
: return "DW_AT_low_pc";
6466 case DW_AT_high_pc
: return "DW_AT_high_pc";
6467 case DW_AT_language
: return "DW_AT_language";
6468 case DW_AT_member
: return "DW_AT_member";
6469 case DW_AT_discr
: return "DW_AT_discr";
6470 case DW_AT_discr_value
: return "DW_AT_discr_value";
6471 case DW_AT_visibility
: return "DW_AT_visibility";
6472 case DW_AT_import
: return "DW_AT_import";
6473 case DW_AT_string_length
: return "DW_AT_string_length";
6474 case DW_AT_common_reference
: return "DW_AT_common_reference";
6475 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6476 case DW_AT_const_value
: return "DW_AT_const_value";
6477 case DW_AT_containing_type
: return "DW_AT_containing_type";
6478 case DW_AT_default_value
: return "DW_AT_default_value";
6479 case DW_AT_inline
: return "DW_AT_inline";
6480 case DW_AT_is_optional
: return "DW_AT_is_optional";
6481 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6482 case DW_AT_producer
: return "DW_AT_producer";
6483 case DW_AT_prototyped
: return "DW_AT_prototyped";
6484 case DW_AT_return_addr
: return "DW_AT_return_addr";
6485 case DW_AT_start_scope
: return "DW_AT_start_scope";
6486 case DW_AT_stride_size
: return "DW_AT_stride_size";
6487 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6488 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6489 case DW_AT_accessibility
: return "DW_AT_accessibility";
6490 case DW_AT_address_class
: return "DW_AT_address_class";
6491 case DW_AT_artificial
: return "DW_AT_artificial";
6492 case DW_AT_base_types
: return "DW_AT_base_types";
6493 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6494 case DW_AT_count
: return "DW_AT_count";
6495 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6496 case DW_AT_decl_column
: return "DW_AT_decl_column";
6497 case DW_AT_decl_file
: return "DW_AT_decl_file";
6498 case DW_AT_decl_line
: return "DW_AT_decl_line";
6499 case DW_AT_declaration
: return "DW_AT_declaration";
6500 case DW_AT_discr_list
: return "DW_AT_discr_list";
6501 case DW_AT_encoding
: return "DW_AT_encoding";
6502 case DW_AT_external
: return "DW_AT_external";
6503 case DW_AT_frame_base
: return "DW_AT_frame_base";
6504 case DW_AT_friend
: return "DW_AT_friend";
6505 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6506 case DW_AT_macro_info
: return "DW_AT_macro_info";
6507 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6508 case DW_AT_priority
: return "DW_AT_priority";
6509 case DW_AT_segment
: return "DW_AT_segment";
6510 case DW_AT_specification
: return "DW_AT_specification";
6511 case DW_AT_static_link
: return "DW_AT_static_link";
6512 case DW_AT_type
: return "DW_AT_type";
6513 case DW_AT_use_location
: return "DW_AT_use_location";
6514 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6515 case DW_AT_virtuality
: return "DW_AT_virtuality";
6516 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6517 /* DWARF 2.1 values. */
6518 case DW_AT_allocated
: return "DW_AT_allocated";
6519 case DW_AT_associated
: return "DW_AT_associated";
6520 case DW_AT_data_location
: return "DW_AT_data_location";
6521 case DW_AT_stride
: return "DW_AT_stride";
6522 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6523 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6524 case DW_AT_extension
: return "DW_AT_extension";
6525 case DW_AT_ranges
: return "DW_AT_ranges";
6526 case DW_AT_trampoline
: return "DW_AT_trampoline";
6527 case DW_AT_call_column
: return "DW_AT_call_column";
6528 case DW_AT_call_file
: return "DW_AT_call_file";
6529 case DW_AT_call_line
: return "DW_AT_call_line";
6530 /* SGI/MIPS extensions. */
6531 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6532 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6533 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6534 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6535 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6536 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6537 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6538 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6539 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6540 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6541 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6542 /* GNU extensions. */
6543 case DW_AT_sf_names
: return "DW_AT_sf_names";
6544 case DW_AT_src_info
: return "DW_AT_src_info";
6545 case DW_AT_mac_info
: return "DW_AT_mac_info";
6546 case DW_AT_src_coords
: return "DW_AT_src_coords";
6547 case DW_AT_body_begin
: return "DW_AT_body_begin";
6548 case DW_AT_body_end
: return "DW_AT_body_end";
6549 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6552 static char buffer
[100];
6554 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6561 get_FORM_name (form
)
6566 case DW_FORM_addr
: return "DW_FORM_addr";
6567 case DW_FORM_block2
: return "DW_FORM_block2";
6568 case DW_FORM_block4
: return "DW_FORM_block4";
6569 case DW_FORM_data2
: return "DW_FORM_data2";
6570 case DW_FORM_data4
: return "DW_FORM_data4";
6571 case DW_FORM_data8
: return "DW_FORM_data8";
6572 case DW_FORM_string
: return "DW_FORM_string";
6573 case DW_FORM_block
: return "DW_FORM_block";
6574 case DW_FORM_block1
: return "DW_FORM_block1";
6575 case DW_FORM_data1
: return "DW_FORM_data1";
6576 case DW_FORM_flag
: return "DW_FORM_flag";
6577 case DW_FORM_sdata
: return "DW_FORM_sdata";
6578 case DW_FORM_strp
: return "DW_FORM_strp";
6579 case DW_FORM_udata
: return "DW_FORM_udata";
6580 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6581 case DW_FORM_ref1
: return "DW_FORM_ref1";
6582 case DW_FORM_ref2
: return "DW_FORM_ref2";
6583 case DW_FORM_ref4
: return "DW_FORM_ref4";
6584 case DW_FORM_ref8
: return "DW_FORM_ref8";
6585 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6586 case DW_FORM_indirect
: return "DW_FORM_indirect";
6589 static char buffer
[100];
6591 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6597 /* FIXME: There are better and more effiecint ways to handle
6598 these structures. For now though, I just want something that
6599 is simple to implement. */
6600 typedef struct abbrev_attr
6602 unsigned long attribute
;
6604 struct abbrev_attr
* next
;
6608 typedef struct abbrev_entry
6610 unsigned long entry
;
6613 struct abbrev_attr
* first_attr
;
6614 struct abbrev_attr
* last_attr
;
6615 struct abbrev_entry
* next
;
6619 static abbrev_entry
* first_abbrev
= NULL
;
6620 static abbrev_entry
* last_abbrev
= NULL
;
6623 free_abbrevs
PARAMS ((void))
6625 abbrev_entry
* abbrev
;
6627 for (abbrev
= first_abbrev
; abbrev
;)
6629 abbrev_entry
* next
= abbrev
->next
;
6632 for (attr
= abbrev
->first_attr
; attr
;)
6634 abbrev_attr
* next
= attr
->next
;
6644 last_abbrev
= first_abbrev
= NULL
;
6648 add_abbrev (number
, tag
, children
)
6649 unsigned long number
;
6653 abbrev_entry
* entry
;
6655 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6661 entry
->entry
= number
;
6663 entry
->children
= children
;
6664 entry
->first_attr
= NULL
;
6665 entry
->last_attr
= NULL
;
6668 if (first_abbrev
== NULL
)
6669 first_abbrev
= entry
;
6671 last_abbrev
->next
= entry
;
6673 last_abbrev
= entry
;
6677 add_abbrev_attr (attribute
, form
)
6678 unsigned long attribute
;
6683 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6689 attr
->attribute
= attribute
;
6693 if (last_abbrev
->first_attr
== NULL
)
6694 last_abbrev
->first_attr
= attr
;
6696 last_abbrev
->last_attr
->next
= attr
;
6698 last_abbrev
->last_attr
= attr
;
6701 /* Processes the (partial) contents of a .debug_abbrev section.
6702 Returns NULL if the end of the section was encountered.
6703 Returns the address after the last byte read if the end of
6704 an abbreviation set was found. */
6706 static unsigned char *
6707 process_abbrev_section (start
, end
)
6708 unsigned char * start
;
6709 unsigned char * end
;
6711 if (first_abbrev
!= NULL
)
6717 unsigned long entry
;
6719 unsigned long attribute
;
6722 entry
= read_leb128 (start
, & bytes_read
, 0);
6723 start
+= bytes_read
;
6725 /* A single zero is supposed to end the section according
6726 to the standard. If there's more, then signal that to
6729 return start
== end
? NULL
: start
;
6731 tag
= read_leb128 (start
, & bytes_read
, 0);
6732 start
+= bytes_read
;
6734 children
= * start
++;
6736 add_abbrev (entry
, tag
, children
);
6742 attribute
= read_leb128 (start
, & bytes_read
, 0);
6743 start
+= bytes_read
;
6745 form
= read_leb128 (start
, & bytes_read
, 0);
6746 start
+= bytes_read
;
6749 add_abbrev_attr (attribute
, form
);
6751 while (attribute
!= 0);
6759 display_debug_macinfo (section
, start
, file
)
6760 Elf32_Internal_Shdr
* section
;
6761 unsigned char * start
;
6762 FILE * file ATTRIBUTE_UNUSED
;
6764 unsigned char * end
= start
+ section
->sh_size
;
6765 unsigned char * curr
= start
;
6766 unsigned int bytes_read
;
6767 enum dwarf_macinfo_record_type op
;
6769 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6773 unsigned int lineno
;
6774 const char * string
;
6781 case DW_MACINFO_start_file
:
6783 unsigned int filenum
;
6785 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6787 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6790 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6794 case DW_MACINFO_end_file
:
6795 printf (_(" DW_MACINFO_end_file\n"));
6798 case DW_MACINFO_define
:
6799 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6802 curr
+= strlen (string
) + 1;
6803 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6806 case DW_MACINFO_undef
:
6807 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6810 curr
+= strlen (string
) + 1;
6811 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
6814 case DW_MACINFO_vendor_ext
:
6816 unsigned int constant
;
6818 constant
= read_leb128 (curr
, & bytes_read
, 0);
6821 curr
+= strlen (string
) + 1;
6822 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
6833 display_debug_abbrev (section
, start
, file
)
6834 Elf32_Internal_Shdr
* section
;
6835 unsigned char * start
;
6836 FILE * file ATTRIBUTE_UNUSED
;
6838 abbrev_entry
* entry
;
6839 unsigned char * end
= start
+ section
->sh_size
;
6841 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6845 start
= process_abbrev_section (start
, end
);
6847 if (first_abbrev
== NULL
)
6850 printf (_(" Number TAG\n"));
6852 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
6856 printf (_(" %ld %s [%s]\n"),
6858 get_TAG_name (entry
->tag
),
6859 entry
->children
? _("has children") : _("no children"));
6861 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6863 printf (_(" %-18s %s\n"),
6864 get_AT_name (attr
->attribute
),
6865 get_FORM_name (attr
->form
));
6879 static unsigned char *
6880 display_block (data
, length
)
6881 unsigned char * data
;
6882 unsigned long length
;
6884 printf (_(" %lu byte block: "), length
);
6887 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
6893 decode_location_expression (data
, pointer_size
, length
)
6894 unsigned char * data
;
6895 unsigned int pointer_size
;
6896 unsigned long length
;
6900 unsigned long uvalue
;
6901 unsigned char * end
= data
+ length
;
6910 printf ("DW_OP_addr: %lx",
6911 (unsigned long) byte_get (data
, pointer_size
));
6912 data
+= pointer_size
;
6915 printf ("DW_OP_deref");
6918 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
6921 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
6924 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
6928 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
6932 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
6936 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
6940 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
6941 (unsigned long) byte_get (data
+ 4, 4));
6945 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
6946 (long) byte_get (data
+ 4, 4));
6950 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
6954 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
6958 printf ("DW_OP_dup");
6961 printf ("DW_OP_drop");
6964 printf ("DW_OP_over");
6967 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
6970 printf ("DW_OP_swap");
6973 printf ("DW_OP_rot");
6976 printf ("DW_OP_xderef");
6979 printf ("DW_OP_abs");
6982 printf ("DW_OP_and");
6985 printf ("DW_OP_div");
6988 printf ("DW_OP_minus");
6991 printf ("DW_OP_mod");
6994 printf ("DW_OP_mul");
6997 printf ("DW_OP_neg");
7000 printf ("DW_OP_not");
7003 printf ("DW_OP_or");
7006 printf ("DW_OP_plus");
7008 case DW_OP_plus_uconst
:
7009 printf ("DW_OP_plus_uconst: %lu",
7010 read_leb128 (data
, &bytes_read
, 0));
7014 printf ("DW_OP_shl");
7017 printf ("DW_OP_shr");
7020 printf ("DW_OP_shra");
7023 printf ("DW_OP_xor");
7026 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7030 printf ("DW_OP_eq");
7033 printf ("DW_OP_ge");
7036 printf ("DW_OP_gt");
7039 printf ("DW_OP_le");
7042 printf ("DW_OP_lt");
7045 printf ("DW_OP_ne");
7048 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7084 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7119 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7154 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7155 read_leb128 (data
, &bytes_read
, 1));
7160 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7164 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7168 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7170 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7171 read_leb128 (data
, &bytes_read
, 1));
7175 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7178 case DW_OP_deref_size
:
7179 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7181 case DW_OP_xderef_size
:
7182 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7185 printf ("DW_OP_nop");
7188 /* DWARF 2.1 extensions. */
7189 case DW_OP_push_object_address
:
7190 printf ("DW_OP_push_object_address");
7193 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7197 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7201 printf ("DW_OP_calli");
7205 if (op
>= DW_OP_lo_user
7206 && op
<= DW_OP_hi_user
)
7207 printf (_("(User defined location op)"));
7209 printf (_("(Unknown location op)"));
7210 /* No way to tell where the next op is, so just bail. */
7214 /* Separate the ops. */
7219 static const char * debug_loc_contents
;
7220 static bfd_vma debug_loc_size
;
7223 load_debug_loc (file
)
7226 Elf32_Internal_Shdr
* sec
;
7229 /* If it is already loaded, do nothing. */
7230 if (debug_loc_contents
!= NULL
)
7233 /* Locate the .debug_loc section. */
7234 for (i
= 0, sec
= section_headers
;
7235 i
< elf_header
.e_shnum
;
7237 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7240 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7243 debug_loc_size
= sec
->sh_size
;
7245 debug_loc_contents
= ((char *)
7246 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7247 _("debug_loc section data")));
7253 if (debug_loc_contents
== NULL
)
7256 free ((char *) debug_loc_contents
);
7257 debug_loc_contents
= NULL
;
7263 display_debug_loc (section
, start
, file
)
7264 Elf32_Internal_Shdr
* section
;
7265 unsigned char * start
;
7266 FILE * file ATTRIBUTE_UNUSED
;
7268 unsigned char *section_end
;
7269 unsigned long bytes
;
7270 unsigned char *section_begin
= start
;
7273 addr
= section
->sh_addr
;
7274 bytes
= section
->sh_size
;
7275 section_end
= start
+ bytes
;
7278 printf (_("\nThe .debug_loc section is empty.\n"));
7281 printf (_("Contents of the .debug_loc section:\n\n"));
7282 printf (_("\n Offset Begin End Expression\n"));
7283 while (start
< section_end
)
7285 unsigned long begin
;
7287 unsigned short length
;
7288 unsigned long offset
;
7290 offset
= start
- section_begin
;
7294 /* Normally, the lists in the debug_loc section are related to a
7295 given compilation unit, and thus, we would use the
7296 pointer size of that compilation unit. However, since we are
7297 displaying it seperately here, we either have to store
7298 pointer sizes of all compilation units, or assume they don't
7299 change. We assume, like the debug_line display, that
7300 it doesn't change. */
7301 begin
= byte_get (start
, debug_line_pointer_size
);
7302 start
+= debug_line_pointer_size
;
7303 end
= byte_get (start
, debug_line_pointer_size
);
7304 start
+= debug_line_pointer_size
;
7306 if (begin
== 0 && end
== 0)
7312 length
= byte_get (start
, 2);
7315 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7316 decode_location_expression (start
, debug_line_pointer_size
, length
);
7326 static const char * debug_str_contents
;
7327 static bfd_vma debug_str_size
;
7330 load_debug_str (file
)
7333 Elf32_Internal_Shdr
* sec
;
7336 /* If it is already loaded, do nothing. */
7337 if (debug_str_contents
!= NULL
)
7340 /* Locate the .debug_str section. */
7341 for (i
= 0, sec
= section_headers
;
7342 i
< elf_header
.e_shnum
;
7344 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7347 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7350 debug_str_size
= sec
->sh_size
;
7352 debug_str_contents
= ((char *)
7353 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7354 _("debug_str section data")));
7360 if (debug_str_contents
== NULL
)
7363 free ((char *) debug_str_contents
);
7364 debug_str_contents
= NULL
;
7369 fetch_indirect_string (offset
)
7370 unsigned long offset
;
7372 if (debug_str_contents
== NULL
)
7373 return _("<no .debug_str section>");
7375 if (offset
> debug_str_size
)
7376 return _("<offset is too big>");
7378 return debug_str_contents
+ offset
;
7383 display_debug_str (section
, start
, file
)
7384 Elf32_Internal_Shdr
* section
;
7385 unsigned char * start
;
7386 FILE * file ATTRIBUTE_UNUSED
;
7388 unsigned long bytes
;
7391 addr
= section
->sh_addr
;
7392 bytes
= section
->sh_size
;
7396 printf (_("\nThe .debug_str section is empty.\n"));
7400 printf (_("Contents of the .debug_str section:\n\n"));
7408 lbytes
= (bytes
> 16 ? 16 : bytes
);
7410 printf (" 0x%8.8lx ", (unsigned long) addr
);
7412 for (j
= 0; j
< 16; j
++)
7415 printf ("%2.2x", start
[j
]);
7423 for (j
= 0; j
< lbytes
; j
++)
7426 if (k
>= ' ' && k
< 0x80)
7443 static unsigned char *
7444 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7445 unsigned long attribute
;
7447 unsigned char * data
;
7448 unsigned long cu_offset
;
7449 unsigned long pointer_size
;
7451 unsigned long uvalue
= 0;
7452 unsigned char * block_start
= NULL
;
7460 case DW_FORM_ref_addr
:
7462 uvalue
= byte_get (data
, pointer_size
);
7463 data
+= pointer_size
;
7467 uvalue
= byte_get (data
, /* offset_size */ 4);
7468 data
+= /* offset_size */ 4;
7474 uvalue
= byte_get (data
++, 1);
7479 uvalue
= byte_get (data
, 2);
7485 uvalue
= byte_get (data
, 4);
7490 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7494 case DW_FORM_ref_udata
:
7496 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7500 case DW_FORM_indirect
:
7501 form
= read_leb128 (data
, & bytes_read
, 0);
7503 printf (" %s", get_FORM_name (form
));
7504 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7510 case DW_FORM_ref_addr
:
7511 printf (" <#%lx>", uvalue
);
7517 case DW_FORM_ref_udata
:
7518 printf (" <%lx>", uvalue
+ cu_offset
);
7522 printf (" %#lx", uvalue
);
7530 printf (" %ld", uvalue
);
7535 uvalue
= byte_get (data
, 4);
7536 printf (" %lx", uvalue
);
7537 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7541 case DW_FORM_string
:
7542 printf (" %s", data
);
7543 data
+= strlen ((char *) data
) + 1;
7547 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7548 block_start
= data
+ bytes_read
;
7549 data
= display_block (block_start
, uvalue
);
7552 case DW_FORM_block1
:
7553 uvalue
= byte_get (data
, 1);
7554 block_start
= data
+ 1;
7555 data
= display_block (block_start
, uvalue
);
7558 case DW_FORM_block2
:
7559 uvalue
= byte_get (data
, 2);
7560 block_start
= data
+ 2;
7561 data
= display_block (block_start
, uvalue
);
7564 case DW_FORM_block4
:
7565 uvalue
= byte_get (data
, 4);
7566 block_start
= data
+ 4;
7567 data
= display_block (block_start
, uvalue
);
7571 printf (_(" (indirect string, offset: 0x%lx): "), uvalue
);
7572 printf (fetch_indirect_string (uvalue
));
7575 case DW_FORM_indirect
:
7576 /* Handled above. */
7580 warn (_("Unrecognized form: %d\n"), form
);
7584 /* For some attributes we can display futher information. */
7593 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7594 case DW_INL_inlined
: printf (_("(inlined)")); break;
7595 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7596 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7597 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7601 case DW_AT_language
:
7604 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7605 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7606 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7607 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7608 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7609 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7610 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7611 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7612 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7613 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7614 /* DWARF 2.1 values. */
7615 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7616 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7617 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7618 /* MIPS extension. */
7619 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7620 default: printf ("(Unknown: %lx)", uvalue
); break;
7624 case DW_AT_encoding
:
7627 case DW_ATE_void
: printf ("(void)"); break;
7628 case DW_ATE_address
: printf ("(machine address)"); break;
7629 case DW_ATE_boolean
: printf ("(boolean)"); break;
7630 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7631 case DW_ATE_float
: printf ("(float)"); break;
7632 case DW_ATE_signed
: printf ("(signed)"); break;
7633 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7634 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7635 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7636 /* DWARF 2.1 value. */
7637 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7639 if (uvalue
>= DW_ATE_lo_user
7640 && uvalue
<= DW_ATE_hi_user
)
7641 printf ("(user defined type)");
7643 printf ("(unknown type)");
7648 case DW_AT_accessibility
:
7651 case DW_ACCESS_public
: printf ("(public)"); break;
7652 case DW_ACCESS_protected
: printf ("(protected)"); break;
7653 case DW_ACCESS_private
: printf ("(private)"); break;
7654 default: printf ("(unknown accessibility)"); break;
7658 case DW_AT_visibility
:
7661 case DW_VIS_local
: printf ("(local)"); break;
7662 case DW_VIS_exported
: printf ("(exported)"); break;
7663 case DW_VIS_qualified
: printf ("(qualified)"); break;
7664 default: printf ("(unknown visibility)"); break;
7668 case DW_AT_virtuality
:
7671 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7672 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7673 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7674 default: printf ("(unknown virtuality)"); break;
7678 case DW_AT_identifier_case
:
7681 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7682 case DW_ID_up_case
: printf ("(up_case)"); break;
7683 case DW_ID_down_case
: printf ("(down_case)"); break;
7684 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7685 default: printf ("(unknown case)"); break;
7689 case DW_AT_calling_convention
:
7692 case DW_CC_normal
: printf ("(normal)"); break;
7693 case DW_CC_program
: printf ("(program)"); break;
7694 case DW_CC_nocall
: printf ("(nocall)"); break;
7696 if (uvalue
>= DW_CC_lo_user
7697 && uvalue
<= DW_CC_hi_user
)
7698 printf ("(user defined)");
7700 printf ("(unknown convention)");
7704 case DW_AT_ordering
:
7707 case -1: printf ("(undefined)"); break;
7708 case 0: printf ("(row major)"); break;
7709 case 1: printf ("(column major)"); break;
7713 case DW_AT_frame_base
:
7714 case DW_AT_location
:
7715 case DW_AT_data_member_location
:
7716 case DW_AT_vtable_elem_location
:
7717 case DW_AT_allocated
:
7718 case DW_AT_associated
:
7719 case DW_AT_data_location
:
7721 case DW_AT_upper_bound
:
7722 case DW_AT_lower_bound
:
7726 decode_location_expression (block_start
, pointer_size
, uvalue
);
7729 else if (form
== DW_FORM_data4
)
7732 printf ("location list");
7744 static unsigned char *
7745 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7746 unsigned long attribute
;
7748 unsigned char * data
;
7749 unsigned long cu_offset
;
7750 unsigned long pointer_size
;
7752 printf (" %-18s:", get_AT_name (attribute
));
7753 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7760 display_debug_info (section
, start
, file
)
7761 Elf32_Internal_Shdr
* section
;
7762 unsigned char * start
;
7765 unsigned char * end
= start
+ section
->sh_size
;
7766 unsigned char * section_begin
= start
;
7768 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7770 load_debug_str (file
);
7771 load_debug_loc (file
);
7775 DWARF2_External_CompUnit
* external
;
7776 DWARF2_Internal_CompUnit compunit
;
7777 Elf32_Internal_Shdr
* relsec
;
7778 unsigned char * tags
;
7781 unsigned long cu_offset
;
7783 external
= (DWARF2_External_CompUnit
*) start
;
7785 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7786 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7787 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7788 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7790 if (compunit
.cu_length
== 0xffffffff)
7792 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7796 /* Check for RELA relocations in the abbrev_offset address, and
7798 for (relsec
= section_headers
;
7799 relsec
< section_headers
+ elf_header
.e_shnum
;
7802 unsigned long nrelas
;
7803 Elf_Internal_Rela
*rela
, *rp
;
7804 Elf32_Internal_Shdr
*symsec
;
7805 Elf_Internal_Sym
*symtab
;
7806 Elf_Internal_Sym
*sym
;
7808 if (relsec
->sh_type
!= SHT_RELA
7809 || SECTION_HEADER (relsec
->sh_info
) != section
)
7812 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7816 symsec
= SECTION_HEADER (relsec
->sh_link
);
7817 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7819 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7822 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
7828 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7830 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7832 warn (_("Skipping unexpected symbol type %u\n"),
7833 ELF32_ST_TYPE (sym
->st_info
));
7839 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7841 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7843 warn (_("Skipping unexpected symbol type %u\n"),
7844 ELF64_ST_TYPE (sym
->st_info
));
7849 compunit
.cu_abbrev_offset
+= rp
->r_addend
;
7857 tags
= start
+ sizeof (* external
);
7858 cu_offset
= start
- section_begin
;
7859 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
7861 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
7862 printf (_(" Length: %ld\n"), compunit
.cu_length
);
7863 printf (_(" Version: %d\n"), compunit
.cu_version
);
7864 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
7865 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
7867 if (compunit
.cu_version
!= 2)
7869 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7875 /* Read in the abbrevs used by this compilation unit. */
7878 Elf32_Internal_Shdr
* sec
;
7879 unsigned char * begin
;
7881 /* Locate the .debug_abbrev section and process it. */
7882 for (i
= 0, sec
= section_headers
;
7883 i
< elf_header
.e_shnum
;
7885 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
7888 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7890 warn (_("Unable to locate .debug_abbrev section!\n"));
7894 begin
= ((unsigned char *)
7895 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7896 _("debug_abbrev section data")));
7900 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
7901 begin
+ sec
->sh_size
);
7907 while (tags
< start
)
7910 unsigned long abbrev_number
;
7911 abbrev_entry
* entry
;
7914 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
7917 /* A null DIE marks the end of a list of children. */
7918 if (abbrev_number
== 0)
7924 /* Scan through the abbreviation list until we reach the
7926 for (entry
= first_abbrev
;
7927 entry
&& entry
->entry
!= abbrev_number
;
7928 entry
= entry
->next
)
7933 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7938 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7940 (unsigned long) (tags
- section_begin
- bytes_read
),
7942 get_TAG_name (entry
->tag
));
7944 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7945 tags
= read_and_display_attr (attr
->attribute
,
7948 compunit
.cu_pointer_size
);
7950 if (entry
->children
)
7964 display_debug_aranges (section
, start
, file
)
7965 Elf32_Internal_Shdr
* section
;
7966 unsigned char * start
;
7967 FILE * file ATTRIBUTE_UNUSED
;
7969 unsigned char * end
= start
+ section
->sh_size
;
7971 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7975 DWARF2_External_ARange
* external
;
7976 DWARF2_Internal_ARange arange
;
7977 unsigned char * ranges
;
7978 unsigned long length
;
7979 unsigned long address
;
7982 external
= (DWARF2_External_ARange
*) start
;
7984 arange
.ar_length
= BYTE_GET (external
->ar_length
);
7985 arange
.ar_version
= BYTE_GET (external
->ar_version
);
7986 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
7987 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
7988 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
7990 if (arange
.ar_length
== 0xffffffff)
7992 warn (_("64-bit DWARF aranges are not supported yet.\n"));
7996 if (arange
.ar_version
!= 2)
7998 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8002 printf (_(" Length: %ld\n"), arange
.ar_length
);
8003 printf (_(" Version: %d\n"), arange
.ar_version
);
8004 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8005 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8006 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8008 printf (_("\n Address Length\n"));
8010 ranges
= start
+ sizeof (* external
);
8012 /* Must pad to an alignment boundary that is twice the pointer size. */
8013 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
8015 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8019 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8021 ranges
+= arange
.ar_pointer_size
;
8023 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8025 ranges
+= arange
.ar_pointer_size
;
8027 /* A pair of zeros marks the end of the list. */
8028 if (address
== 0 && length
== 0)
8031 printf (" %8.8lx %lu\n", address
, length
);
8034 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8042 typedef struct Frame_Chunk
8044 struct Frame_Chunk
* next
;
8045 unsigned char * chunk_start
;
8047 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8048 short int * col_type
;
8050 char * augmentation
;
8051 unsigned int code_factor
;
8053 unsigned long pc_begin
;
8054 unsigned long pc_range
;
8058 unsigned char fde_encoding
;
8062 /* A marker for a col_type that means this column was never referenced
8063 in the frame info. */
8064 #define DW_CFA_unreferenced (-1)
8066 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8067 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8068 static int size_of_encoded_value
PARAMS ((int));
8071 frame_need_space (fc
, reg
)
8075 int prev
= fc
->ncols
;
8077 if (reg
< fc
->ncols
)
8080 fc
->ncols
= reg
+ 1;
8081 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8082 fc
->ncols
* sizeof (short int));
8083 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8084 fc
->ncols
* sizeof (int));
8086 while (prev
< fc
->ncols
)
8088 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8089 fc
->col_offset
[prev
] = 0;
8095 frame_display_row (fc
, need_col_headers
, max_regs
)
8097 int * need_col_headers
;
8103 if (* max_regs
< fc
->ncols
)
8104 * max_regs
= fc
->ncols
;
8106 if (* need_col_headers
)
8108 * need_col_headers
= 0;
8110 printf (" LOC CFA ");
8112 for (r
= 0; r
< * max_regs
; r
++)
8113 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8118 printf ("r%-4d", r
);
8124 printf ("%08lx ", fc
->pc_begin
);
8125 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8126 printf ("%-8s ", tmp
);
8128 for (r
= 0; r
< fc
->ncols
; r
++)
8130 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8132 switch (fc
->col_type
[r
])
8134 case DW_CFA_undefined
:
8137 case DW_CFA_same_value
:
8141 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8143 case DW_CFA_register
:
8144 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8147 strcpy (tmp
, "n/a");
8150 printf ("%-5s", tmp
);
8157 size_of_encoded_value (encoding
)
8160 switch (encoding
& 0x7)
8163 case 0: return is_32bit_elf
? 4 : 8;
8170 #define GET(N) byte_get (start, N); start += N
8171 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8172 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8175 display_debug_frames (section
, start
, file
)
8176 Elf32_Internal_Shdr
* section
;
8177 unsigned char * start
;
8178 FILE * file ATTRIBUTE_UNUSED
;
8180 unsigned char * end
= start
+ section
->sh_size
;
8181 unsigned char * section_start
= start
;
8182 Frame_Chunk
* chunks
= 0;
8183 Frame_Chunk
* remembered_state
= 0;
8185 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8188 int addr_size
= is_32bit_elf
? 4 : 8;
8190 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8194 unsigned char * saved_start
;
8195 unsigned char * block_end
;
8196 unsigned long length
;
8197 unsigned long cie_id
;
8200 int need_col_headers
= 1;
8201 unsigned char * augmentation_data
= NULL
;
8202 unsigned long augmentation_data_len
= 0;
8203 int encoded_ptr_size
= addr_size
;
8205 saved_start
= start
;
8206 length
= byte_get (start
, 4); start
+= 4;
8211 if (length
== 0xffffffff)
8213 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8217 block_end
= saved_start
+ length
+ 4;
8218 cie_id
= byte_get (start
, 4); start
+= 4;
8220 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8224 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8225 memset (fc
, 0, sizeof (Frame_Chunk
));
8229 fc
->chunk_start
= saved_start
;
8231 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8232 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8233 frame_need_space (fc
, max_regs
-1);
8237 fc
->augmentation
= start
;
8238 start
= strchr (start
, '\0') + 1;
8240 if (fc
->augmentation
[0] == 'z')
8242 fc
->code_factor
= LEB ();
8243 fc
->data_factor
= SLEB ();
8244 fc
->ra
= byte_get (start
, 1); start
+= 1;
8245 augmentation_data_len
= LEB ();
8246 augmentation_data
= start
;
8247 start
+= augmentation_data_len
;
8249 else if (strcmp (fc
->augmentation
, "eh") == 0)
8252 fc
->code_factor
= LEB ();
8253 fc
->data_factor
= SLEB ();
8254 fc
->ra
= byte_get (start
, 1); start
+= 1;
8258 fc
->code_factor
= LEB ();
8259 fc
->data_factor
= SLEB ();
8260 fc
->ra
= byte_get (start
, 1); start
+= 1;
8264 if (do_debug_frames_interp
)
8265 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8266 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8267 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8271 printf ("\n%08lx %08lx %08lx CIE\n",
8272 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8273 printf (" Version: %d\n", version
);
8274 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8275 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8276 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8277 printf (" Return address column: %d\n", fc
->ra
);
8279 if (augmentation_data_len
)
8282 printf (" Augmentation data: ");
8283 for (i
= 0; i
< augmentation_data_len
; ++i
)
8284 printf (" %02x", augmentation_data
[i
]);
8290 if (augmentation_data_len
)
8292 unsigned char *p
, *q
;
8293 p
= fc
->augmentation
+ 1;
8294 q
= augmentation_data
;
8301 q
+= 1 + size_of_encoded_value (*q
);
8303 fc
->fde_encoding
= *q
++;
8309 if (fc
->fde_encoding
)
8310 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8313 frame_need_space (fc
, fc
->ra
);
8317 unsigned char * look_for
;
8318 static Frame_Chunk fde_fc
;
8321 memset (fc
, 0, sizeof (Frame_Chunk
));
8323 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8325 for (cie
= chunks
; cie
; cie
= cie
->next
)
8326 if (cie
->chunk_start
== look_for
)
8331 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8332 cie_id
, saved_start
);
8335 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8336 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8337 frame_need_space (fc
, max_regs
- 1);
8339 fc
->augmentation
= "";
8340 fc
->fde_encoding
= 0;
8344 fc
->ncols
= cie
->ncols
;
8345 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8346 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8347 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8348 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8349 fc
->augmentation
= cie
->augmentation
;
8350 fc
->code_factor
= cie
->code_factor
;
8351 fc
->data_factor
= cie
->data_factor
;
8352 fc
->cfa_reg
= cie
->cfa_reg
;
8353 fc
->cfa_offset
= cie
->cfa_offset
;
8355 frame_need_space (fc
, max_regs
-1);
8356 fc
->fde_encoding
= cie
->fde_encoding
;
8359 if (fc
->fde_encoding
)
8360 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8362 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8363 start
+= encoded_ptr_size
;
8364 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8365 start
+= encoded_ptr_size
;
8367 if (cie
->augmentation
[0] == 'z')
8369 augmentation_data_len
= LEB ();
8370 augmentation_data
= start
;
8371 start
+= augmentation_data_len
;
8374 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8375 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8376 (unsigned long)(cie
->chunk_start
- section_start
),
8377 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8378 if (! do_debug_frames_interp
&& augmentation_data_len
)
8381 printf (" Augmentation data: ");
8382 for (i
= 0; i
< augmentation_data_len
; ++i
)
8383 printf (" %02x", augmentation_data
[i
]);
8389 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8390 about to interpret instructions for the chunk. */
8392 if (do_debug_frames_interp
)
8394 /* Start by making a pass over the chunk, allocating storage
8395 and taking note of what registers are used. */
8396 unsigned char * tmp
= start
;
8398 while (start
< block_end
)
8408 /* Warning: if you add any more cases to this switch, be
8409 sure to add them to the corresponding switch below. */
8412 case DW_CFA_advance_loc
:
8416 frame_need_space (fc
, opa
);
8417 fc
->col_type
[opa
] = DW_CFA_undefined
;
8419 case DW_CFA_restore
:
8420 frame_need_space (fc
, opa
);
8421 fc
->col_type
[opa
] = DW_CFA_undefined
;
8423 case DW_CFA_set_loc
:
8424 start
+= encoded_ptr_size
;
8426 case DW_CFA_advance_loc1
:
8429 case DW_CFA_advance_loc2
:
8432 case DW_CFA_advance_loc4
:
8435 case DW_CFA_offset_extended
:
8436 reg
= LEB (); LEB ();
8437 frame_need_space (fc
, reg
);
8438 fc
->col_type
[reg
] = DW_CFA_undefined
;
8440 case DW_CFA_restore_extended
:
8442 frame_need_space (fc
, reg
);
8443 fc
->col_type
[reg
] = DW_CFA_undefined
;
8445 case DW_CFA_undefined
:
8447 frame_need_space (fc
, reg
);
8448 fc
->col_type
[reg
] = DW_CFA_undefined
;
8450 case DW_CFA_same_value
:
8452 frame_need_space (fc
, reg
);
8453 fc
->col_type
[reg
] = DW_CFA_undefined
;
8455 case DW_CFA_register
:
8456 reg
= LEB (); LEB ();
8457 frame_need_space (fc
, reg
);
8458 fc
->col_type
[reg
] = DW_CFA_undefined
;
8460 case DW_CFA_def_cfa
:
8463 case DW_CFA_def_cfa_register
:
8466 case DW_CFA_def_cfa_offset
:
8469 #ifndef DW_CFA_GNU_args_size
8470 #define DW_CFA_GNU_args_size 0x2e
8472 case DW_CFA_GNU_args_size
:
8475 #ifndef DW_CFA_GNU_negative_offset_extended
8476 #define DW_CFA_GNU_negative_offset_extended 0x2f
8478 case DW_CFA_GNU_negative_offset_extended
:
8479 reg
= LEB (); LEB ();
8480 frame_need_space (fc
, reg
);
8481 fc
->col_type
[reg
] = DW_CFA_undefined
;
8490 /* Now we know what registers are used, make a second pass over
8491 the chunk, this time actually printing out the info. */
8493 while (start
< block_end
)
8496 unsigned long ul
, reg
, roffs
;
8505 /* Warning: if you add any more cases to this switch, be
8506 sure to add them to the corresponding switch above. */
8509 case DW_CFA_advance_loc
:
8510 if (do_debug_frames_interp
)
8511 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8513 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8514 opa
* fc
->code_factor
,
8515 fc
->pc_begin
+ opa
* fc
->code_factor
);
8516 fc
->pc_begin
+= opa
* fc
->code_factor
;
8521 if (! do_debug_frames_interp
)
8522 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8523 opa
, roffs
* fc
->data_factor
);
8524 fc
->col_type
[opa
] = DW_CFA_offset
;
8525 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8528 case DW_CFA_restore
:
8529 if (! do_debug_frames_interp
)
8530 printf (" DW_CFA_restore: r%d\n", opa
);
8531 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8532 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8535 case DW_CFA_set_loc
:
8536 vma
= byte_get (start
, encoded_ptr_size
);
8537 start
+= encoded_ptr_size
;
8538 if (do_debug_frames_interp
)
8539 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8541 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8545 case DW_CFA_advance_loc1
:
8546 ofs
= byte_get (start
, 1); start
+= 1;
8547 if (do_debug_frames_interp
)
8548 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8550 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8551 ofs
* fc
->code_factor
,
8552 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8553 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8556 case DW_CFA_advance_loc2
:
8557 ofs
= byte_get (start
, 2); start
+= 2;
8558 if (do_debug_frames_interp
)
8559 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8561 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8562 ofs
* fc
->code_factor
,
8563 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8564 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8567 case DW_CFA_advance_loc4
:
8568 ofs
= byte_get (start
, 4); start
+= 4;
8569 if (do_debug_frames_interp
)
8570 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8572 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8573 ofs
* fc
->code_factor
,
8574 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8575 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8578 case DW_CFA_offset_extended
:
8581 if (! do_debug_frames_interp
)
8582 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8583 reg
, roffs
* fc
->data_factor
);
8584 fc
->col_type
[reg
] = DW_CFA_offset
;
8585 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8588 case DW_CFA_restore_extended
:
8590 if (! do_debug_frames_interp
)
8591 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8592 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8593 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8596 case DW_CFA_undefined
:
8598 if (! do_debug_frames_interp
)
8599 printf (" DW_CFA_undefined: r%ld\n", reg
);
8600 fc
->col_type
[reg
] = DW_CFA_undefined
;
8601 fc
->col_offset
[reg
] = 0;
8604 case DW_CFA_same_value
:
8606 if (! do_debug_frames_interp
)
8607 printf (" DW_CFA_same_value: r%ld\n", reg
);
8608 fc
->col_type
[reg
] = DW_CFA_same_value
;
8609 fc
->col_offset
[reg
] = 0;
8612 case DW_CFA_register
:
8615 if (! do_debug_frames_interp
)
8616 printf (" DW_CFA_register: r%ld\n", reg
);
8617 fc
->col_type
[reg
] = DW_CFA_register
;
8618 fc
->col_offset
[reg
] = roffs
;
8621 case DW_CFA_remember_state
:
8622 if (! do_debug_frames_interp
)
8623 printf (" DW_CFA_remember_state\n");
8624 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8625 rs
->ncols
= fc
->ncols
;
8626 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8627 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8628 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8629 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8630 rs
->next
= remembered_state
;
8631 remembered_state
= rs
;
8634 case DW_CFA_restore_state
:
8635 if (! do_debug_frames_interp
)
8636 printf (" DW_CFA_restore_state\n");
8637 rs
= remembered_state
;
8638 remembered_state
= rs
->next
;
8639 frame_need_space (fc
, rs
->ncols
-1);
8640 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8641 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8642 free (rs
->col_type
);
8643 free (rs
->col_offset
);
8647 case DW_CFA_def_cfa
:
8648 fc
->cfa_reg
= LEB ();
8649 fc
->cfa_offset
= LEB ();
8650 if (! do_debug_frames_interp
)
8651 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8652 fc
->cfa_reg
, fc
->cfa_offset
);
8655 case DW_CFA_def_cfa_register
:
8656 fc
->cfa_reg
= LEB ();
8657 if (! do_debug_frames_interp
)
8658 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8661 case DW_CFA_def_cfa_offset
:
8662 fc
->cfa_offset
= LEB ();
8663 if (! do_debug_frames_interp
)
8664 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8668 if (! do_debug_frames_interp
)
8669 printf (" DW_CFA_nop\n");
8672 #ifndef DW_CFA_GNU_window_save
8673 #define DW_CFA_GNU_window_save 0x2d
8675 case DW_CFA_GNU_window_save
:
8676 if (! do_debug_frames_interp
)
8677 printf (" DW_CFA_GNU_window_save\n");
8680 case DW_CFA_GNU_args_size
:
8682 if (! do_debug_frames_interp
)
8683 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8686 case DW_CFA_GNU_negative_offset_extended
:
8689 frame_need_space (fc
, reg
);
8690 if (! do_debug_frames_interp
)
8691 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8692 reg
, l
* fc
->data_factor
);
8693 fc
->col_type
[reg
] = DW_CFA_offset
;
8694 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8698 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8703 if (do_debug_frames_interp
)
8704 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8719 display_debug_not_supported (section
, start
, file
)
8720 Elf32_Internal_Shdr
* section
;
8721 unsigned char * start ATTRIBUTE_UNUSED
;
8722 FILE * file ATTRIBUTE_UNUSED
;
8724 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8725 SECTION_NAME (section
));
8730 /* Pre-scan the .debug_info section to record the size of address.
8731 When dumping the .debug_line, we use that size information, assuming
8732 that all compilation units have the same address size. */
8734 prescan_debug_info (section
, start
, file
)
8735 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8736 unsigned char * start
;
8737 FILE * file ATTRIBUTE_UNUSED
;
8739 DWARF2_External_CompUnit
* external
;
8741 external
= (DWARF2_External_CompUnit
*) start
;
8743 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8747 /* A structure containing the name of a debug section and a pointer
8748 to a function that can decode it. The third field is a prescan
8749 function to be run over the section before displaying any of the
8753 const char * const name
;
8754 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8755 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8759 { ".debug_abbrev", display_debug_abbrev
, NULL
},
8760 { ".debug_aranges", display_debug_aranges
, NULL
},
8761 { ".debug_frame", display_debug_frames
, NULL
},
8762 { ".debug_info", display_debug_info
, prescan_debug_info
},
8763 { ".debug_line", display_debug_lines
, NULL
},
8764 { ".debug_pubnames", display_debug_pubnames
, NULL
},
8765 { ".eh_frame", display_debug_frames
, NULL
},
8766 { ".debug_macinfo", display_debug_macinfo
, NULL
},
8767 { ".debug_str", display_debug_str
, NULL
},
8768 { ".debug_loc", display_debug_loc
, NULL
},
8769 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
8770 { ".debug_ranges", display_debug_not_supported
, NULL
},
8771 { ".debug_static_func", display_debug_not_supported
, NULL
},
8772 { ".debug_static_vars", display_debug_not_supported
, NULL
},
8773 { ".debug_types", display_debug_not_supported
, NULL
},
8774 { ".debug_weaknames", display_debug_not_supported
, NULL
}
8778 display_debug_section (section
, file
)
8779 Elf32_Internal_Shdr
* section
;
8782 char * name
= SECTION_NAME (section
);
8783 bfd_size_type length
;
8784 unsigned char * start
;
8787 length
= section
->sh_size
;
8790 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8794 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
8795 _("debug section data"));
8799 /* See if we know how to display the contents of this section. */
8800 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
8801 name
= ".debug_info";
8803 for (i
= NUM_ELEM (debug_displays
); i
--;)
8804 if (strcmp (debug_displays
[i
].name
, name
) == 0)
8806 debug_displays
[i
].display (section
, start
, file
);
8811 printf (_("Unrecognized debug section: %s\n"), name
);
8815 /* If we loaded in the abbrev section at some point,
8816 we must release it here. */
8823 process_section_contents (file
)
8826 Elf32_Internal_Shdr
* section
;
8832 /* Pre-scan the debug sections to find some debug information not
8833 present in some of them. For the .debug_line, we must find out the
8834 size of address (specified in .debug_info and .debug_aranges). */
8835 for (i
= 0, section
= section_headers
;
8836 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8839 char * name
= SECTION_NAME (section
);
8842 if (section
->sh_size
== 0)
8845 /* See if there is some pre-scan operation for this section. */
8846 for (j
= NUM_ELEM (debug_displays
); j
--;)
8847 if (strcmp (debug_displays
[j
].name
, name
) == 0)
8849 if (debug_displays
[j
].prescan
!= NULL
)
8851 bfd_size_type length
;
8852 unsigned char * start
;
8854 length
= section
->sh_size
;
8855 start
= ((unsigned char *)
8856 get_data (NULL
, file
, section
->sh_offset
, length
,
8857 _("debug section data")));
8861 debug_displays
[j
].prescan (section
, start
, file
);
8869 for (i
= 0, section
= section_headers
;
8870 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8873 #ifdef SUPPORT_DISASSEMBLY
8874 if (dump_sects
[i
] & DISASS_DUMP
)
8875 disassemble_section (section
, file
);
8877 if (dump_sects
[i
] & HEX_DUMP
)
8878 dump_section (section
, file
);
8880 if (dump_sects
[i
] & DEBUG_DUMP
)
8881 display_debug_section (section
, file
);
8884 if (i
< num_dump_sects
)
8885 warn (_("Some sections were not dumped because they do not exist!\n"));
8891 process_mips_fpe_exception (mask
)
8897 if (mask
& OEX_FPU_INEX
)
8898 fputs ("INEX", stdout
), first
= 0;
8899 if (mask
& OEX_FPU_UFLO
)
8900 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8901 if (mask
& OEX_FPU_OFLO
)
8902 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8903 if (mask
& OEX_FPU_DIV0
)
8904 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8905 if (mask
& OEX_FPU_INVAL
)
8906 printf ("%sINVAL", first
? "" : "|");
8909 fputs ("0", stdout
);
8913 process_mips_specific (file
)
8916 Elf_Internal_Dyn
* entry
;
8917 size_t liblist_offset
= 0;
8918 size_t liblistno
= 0;
8919 size_t conflictsno
= 0;
8920 size_t options_offset
= 0;
8921 size_t conflicts_offset
= 0;
8923 /* We have a lot of special sections. Thanks SGI! */
8924 if (dynamic_segment
== NULL
)
8925 /* No information available. */
8928 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
8929 switch (entry
->d_tag
)
8931 case DT_MIPS_LIBLIST
:
8932 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
8934 case DT_MIPS_LIBLISTNO
:
8935 liblistno
= entry
->d_un
.d_val
;
8937 case DT_MIPS_OPTIONS
:
8938 options_offset
= entry
->d_un
.d_val
- loadaddr
;
8940 case DT_MIPS_CONFLICT
:
8941 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
8943 case DT_MIPS_CONFLICTNO
:
8944 conflictsno
= entry
->d_un
.d_val
;
8950 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8952 Elf32_External_Lib
* elib
;
8955 elib
= ((Elf32_External_Lib
*)
8956 get_data (NULL
, file
, liblist_offset
,
8957 liblistno
* sizeof (Elf32_External_Lib
),
8961 printf ("\nSection '.liblist' contains %lu entries:\n",
8962 (unsigned long) liblistno
);
8963 fputs (" Library Time Stamp Checksum Version Flags\n",
8966 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8973 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8974 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8975 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8976 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8977 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8979 tmp
= gmtime (&time
);
8980 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
8981 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8982 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8984 printf ("%3lu: ", (unsigned long) cnt
);
8985 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
8986 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
8989 if (liblist
.l_flags
== 0)
9000 { " EXACT_MATCH", LL_EXACT_MATCH
},
9001 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9002 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9003 { " EXPORTS", LL_EXPORTS
},
9004 { " DELAY_LOAD", LL_DELAY_LOAD
},
9005 { " DELTA", LL_DELTA
}
9007 int flags
= liblist
.l_flags
;
9011 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9013 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9015 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9016 flags
^= l_flags_vals
[fcnt
].bit
;
9019 printf (" %#x", (unsigned int) flags
);
9029 if (options_offset
!= 0)
9031 Elf_External_Options
* eopt
;
9032 Elf_Internal_Shdr
* sect
= section_headers
;
9033 Elf_Internal_Options
* iopt
;
9034 Elf_Internal_Options
* option
;
9038 /* Find the section header so that we get the size. */
9039 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9042 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9043 sect
->sh_size
, _("options"));
9046 iopt
= ((Elf_Internal_Options
*)
9047 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
9050 error (_("Out of memory"));
9057 while (offset
< sect
->sh_size
)
9059 Elf_External_Options
* eoption
;
9061 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9063 option
->kind
= BYTE_GET (eoption
->kind
);
9064 option
->size
= BYTE_GET (eoption
->size
);
9065 option
->section
= BYTE_GET (eoption
->section
);
9066 option
->info
= BYTE_GET (eoption
->info
);
9068 offset
+= option
->size
;
9074 printf (_("\nSection '%s' contains %d entries:\n"),
9075 SECTION_NAME (sect
), cnt
);
9083 switch (option
->kind
)
9086 /* This shouldn't happen. */
9087 printf (" NULL %d %lx", option
->section
, option
->info
);
9090 printf (" REGINFO ");
9091 if (elf_header
.e_machine
== EM_MIPS
)
9094 Elf32_External_RegInfo
* ereg
;
9095 Elf32_RegInfo reginfo
;
9097 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9098 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9099 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9100 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9101 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9102 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9103 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9105 printf ("GPR %08lx GP 0x%lx\n",
9107 (unsigned long) reginfo
.ri_gp_value
);
9108 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9109 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9110 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9115 Elf64_External_RegInfo
* ereg
;
9116 Elf64_Internal_RegInfo reginfo
;
9118 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9119 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9120 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9121 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9122 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9123 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9124 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9126 printf ("GPR %08lx GP 0x",
9127 reginfo
.ri_gprmask
);
9128 printf_vma (reginfo
.ri_gp_value
);
9131 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9132 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9133 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9137 case ODK_EXCEPTIONS
:
9138 fputs (" EXCEPTIONS fpe_min(", stdout
);
9139 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9140 fputs (") fpe_max(", stdout
);
9141 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9142 fputs (")", stdout
);
9144 if (option
->info
& OEX_PAGE0
)
9145 fputs (" PAGE0", stdout
);
9146 if (option
->info
& OEX_SMM
)
9147 fputs (" SMM", stdout
);
9148 if (option
->info
& OEX_FPDBUG
)
9149 fputs (" FPDBUG", stdout
);
9150 if (option
->info
& OEX_DISMISS
)
9151 fputs (" DISMISS", stdout
);
9154 fputs (" PAD ", stdout
);
9155 if (option
->info
& OPAD_PREFIX
)
9156 fputs (" PREFIX", stdout
);
9157 if (option
->info
& OPAD_POSTFIX
)
9158 fputs (" POSTFIX", stdout
);
9159 if (option
->info
& OPAD_SYMBOL
)
9160 fputs (" SYMBOL", stdout
);
9163 fputs (" HWPATCH ", stdout
);
9164 if (option
->info
& OHW_R4KEOP
)
9165 fputs (" R4KEOP", stdout
);
9166 if (option
->info
& OHW_R8KPFETCH
)
9167 fputs (" R8KPFETCH", stdout
);
9168 if (option
->info
& OHW_R5KEOP
)
9169 fputs (" R5KEOP", stdout
);
9170 if (option
->info
& OHW_R5KCVTL
)
9171 fputs (" R5KCVTL", stdout
);
9174 fputs (" FILL ", stdout
);
9175 /* XXX Print content of info word? */
9178 fputs (" TAGS ", stdout
);
9179 /* XXX Print content of info word? */
9182 fputs (" HWAND ", stdout
);
9183 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9184 fputs (" R4KEOP_CHECKED", stdout
);
9185 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9186 fputs (" R4KEOP_CLEAN", stdout
);
9189 fputs (" HWOR ", stdout
);
9190 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9191 fputs (" R4KEOP_CHECKED", stdout
);
9192 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9193 fputs (" R4KEOP_CLEAN", stdout
);
9196 printf (" GP_GROUP %#06lx self-contained %#06lx",
9197 option
->info
& OGP_GROUP
,
9198 (option
->info
& OGP_SELF
) >> 16);
9201 printf (" IDENT %#06lx self-contained %#06lx",
9202 option
->info
& OGP_GROUP
,
9203 (option
->info
& OGP_SELF
) >> 16);
9206 /* This shouldn't happen. */
9207 printf (" %3d ??? %d %lx",
9208 option
->kind
, option
->section
, option
->info
);
9212 len
= sizeof (* eopt
);
9213 while (len
< option
->size
)
9214 if (((char *) option
)[len
] >= ' '
9215 && ((char *) option
)[len
] < 0x7f)
9216 printf ("%c", ((char *) option
)[len
++]);
9218 printf ("\\%03o", ((char *) option
)[len
++]);
9220 fputs ("\n", stdout
);
9228 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9230 Elf32_Conflict
* iconf
;
9233 if (dynamic_symbols
== NULL
)
9235 error (_("conflict list found without a dynamic symbol table"));
9239 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
9242 error (_("Out of memory"));
9248 Elf32_External_Conflict
* econf32
;
9250 econf32
= ((Elf32_External_Conflict
*)
9251 get_data (NULL
, file
, conflicts_offset
,
9252 conflictsno
* sizeof (* econf32
),
9257 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9258 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9264 Elf64_External_Conflict
* econf64
;
9266 econf64
= ((Elf64_External_Conflict
*)
9267 get_data (NULL
, file
, conflicts_offset
,
9268 conflictsno
* sizeof (* econf64
),
9273 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9274 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9279 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9280 (long) conflictsno
);
9281 puts (_(" Num: Index Value Name"));
9283 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9285 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9287 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9288 print_vma (psym
->st_value
, FULL_HEX
);
9290 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9301 get_note_type (e_type
)
9304 static char buff
[64];
9308 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9309 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9310 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9311 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9312 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9313 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9314 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9315 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9316 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9317 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9318 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9320 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9326 get_netbsd_elfcore_note_type (e_type
)
9329 static char buff
[64];
9331 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9333 /* NetBSD core "procinfo" structure. */
9334 return _("NetBSD procinfo structure");
9337 /* As of Jan 2002 there are no other machine-independent notes
9338 defined for NetBSD core files. If the note type is less
9339 than the start of the machine-dependent note types, we don't
9342 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9344 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9348 switch (elf_header
.e_machine
)
9350 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9351 and PT_GETFPREGS == mach+2. */
9356 case EM_SPARC32PLUS
:
9360 case NT_NETBSDCORE_FIRSTMACH
+0:
9361 return _("PT_GETREGS (reg structure)");
9362 case NT_NETBSDCORE_FIRSTMACH
+2:
9363 return _("PT_GETFPREGS (fpreg structure)");
9369 /* On all other arch's, PT_GETREGS == mach+1 and
9370 PT_GETFPREGS == mach+3. */
9374 case NT_NETBSDCORE_FIRSTMACH
+1:
9375 return _("PT_GETREGS (reg structure)");
9376 case NT_NETBSDCORE_FIRSTMACH
+3:
9377 return _("PT_GETFPREGS (fpreg structure)");
9383 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9387 /* Note that by the ELF standard, the name field is already null byte
9388 terminated, and namesz includes the terminating null byte.
9389 I.E. the value of namesz for the name "FSF" is 4.
9391 If the value of namesz is zero, there is no name present. */
9393 process_note (pnote
)
9394 Elf32_Internal_Note
* pnote
;
9398 if (pnote
->namesz
== 0)
9400 /* If there is no note name, then use the default set of
9401 note type strings. */
9402 nt
= get_note_type (pnote
->type
);
9404 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9406 /* NetBSD-specific core file notes. */
9407 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9411 /* Don't recognize this note name; just use the default set of
9412 note type strings. */
9413 nt
= get_note_type (pnote
->type
);
9416 printf (" %s\t\t0x%08lx\t%s\n",
9417 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9424 process_corefile_note_segment (file
, offset
, length
)
9429 Elf_External_Note
* pnotes
;
9430 Elf_External_Note
* external
;
9436 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9443 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9444 (unsigned long) offset
, (unsigned long) length
);
9445 printf (_(" Owner\t\tData size\tDescription\n"));
9447 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9449 Elf_External_Note
* next
;
9450 Elf32_Internal_Note inote
;
9453 inote
.type
= BYTE_GET (external
->type
);
9454 inote
.namesz
= BYTE_GET (external
->namesz
);
9455 inote
.namedata
= external
->name
;
9456 inote
.descsz
= BYTE_GET (external
->descsz
);
9457 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9458 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9460 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9462 if (((char *) next
) > (((char *) pnotes
) + length
))
9464 warn (_("corrupt note found at offset %x into core notes\n"),
9465 ((char *) external
) - ((char *) pnotes
));
9466 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9467 inote
.type
, inote
.namesz
, inote
.descsz
);
9473 /* Verify that name is null terminated. It appears that at least
9474 one version of Linux (RedHat 6.0) generates corefiles that don't
9475 comply with the ELF spec by failing to include the null byte in
9477 if (inote
.namedata
[inote
.namesz
] != '\0')
9479 temp
= malloc (inote
.namesz
+ 1);
9483 error (_("Out of memory\n"));
9488 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9489 temp
[inote
.namesz
] = 0;
9491 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9492 inote
.namedata
= temp
;
9495 res
&= process_note (& inote
);
9510 process_corefile_note_segments (file
)
9513 Elf_Internal_Phdr
* program_headers
;
9514 Elf_Internal_Phdr
* segment
;
9518 program_headers
= (Elf_Internal_Phdr
*) malloc
9519 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9521 if (program_headers
== NULL
)
9523 error (_("Out of memory\n"));
9528 i
= get_32bit_program_headers (file
, program_headers
);
9530 i
= get_64bit_program_headers (file
, program_headers
);
9534 free (program_headers
);
9538 for (i
= 0, segment
= program_headers
;
9539 i
< elf_header
.e_phnum
;
9542 if (segment
->p_type
== PT_NOTE
)
9543 res
&= process_corefile_note_segment (file
,
9544 (bfd_vma
) segment
->p_offset
,
9545 (bfd_vma
) segment
->p_filesz
);
9548 free (program_headers
);
9554 process_corefile_contents (file
)
9557 /* If we have not been asked to display the notes then do nothing. */
9561 /* If file is not a core file then exit. */
9562 if (elf_header
.e_type
!= ET_CORE
)
9565 /* No program headers means no NOTE segment. */
9566 if (elf_header
.e_phnum
== 0)
9568 printf (_("No note segments present in the core file.\n"));
9572 return process_corefile_note_segments (file
);
9576 process_arch_specific (file
)
9582 switch (elf_header
.e_machine
)
9585 case EM_MIPS_RS3_LE
:
9586 return process_mips_specific (file
);
9595 get_file_header (file
)
9598 /* Read in the identity array. */
9599 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9602 /* Determine how to read the rest of the header. */
9603 switch (elf_header
.e_ident
[EI_DATA
])
9605 default: /* fall through */
9606 case ELFDATANONE
: /* fall through */
9607 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9608 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9611 /* For now we only support 32 bit and 64 bit ELF files. */
9612 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9614 /* Read in the rest of the header. */
9617 Elf32_External_Ehdr ehdr32
;
9619 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9622 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9623 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9624 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9625 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9626 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9627 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9628 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9629 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9630 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9631 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9632 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9633 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9634 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9638 Elf64_External_Ehdr ehdr64
;
9640 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9641 we will not be able to cope with the 64bit data found in
9642 64 ELF files. Detect this now and abort before we start
9643 overwritting things. */
9644 if (sizeof (bfd_vma
) < 8)
9646 error (_("This instance of readelf has been built without support for a\n\
9647 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9651 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9654 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9655 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9656 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9657 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9658 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9659 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9660 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9661 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9662 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9663 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9664 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9665 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9666 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9669 /* There may be some extensions in the first section header. Don't
9670 bomb if we can't read it. */
9672 get_32bit_section_headers (file
, 1);
9674 get_64bit_section_headers (file
, 1);
9680 process_file (file_name
)
9684 struct stat statbuf
;
9687 if (stat (file_name
, & statbuf
) < 0)
9689 error (_("Cannot stat input file %s.\n"), file_name
);
9693 file
= fopen (file_name
, "rb");
9696 error (_("Input file %s not found.\n"), file_name
);
9700 if (! get_file_header (file
))
9702 error (_("%s: Failed to read file header\n"), file_name
);
9707 /* Initialise per file variables. */
9708 for (i
= NUM_ELEM (version_info
); i
--;)
9709 version_info
[i
] = 0;
9711 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9712 dynamic_info
[i
] = 0;
9714 /* Process the file. */
9716 printf (_("\nFile: %s\n"), file_name
);
9718 if (! process_file_header ())
9724 process_section_headers (file
);
9726 process_program_headers (file
);
9728 process_dynamic_segment (file
);
9730 process_relocs (file
);
9732 process_unwind (file
);
9734 process_symbol_table (file
);
9736 process_syminfo (file
);
9738 process_version_sections (file
);
9740 process_section_contents (file
);
9742 process_corefile_contents (file
);
9744 process_arch_specific (file
);
9748 if (section_headers
)
9750 free (section_headers
);
9751 section_headers
= NULL
;
9756 free (string_table
);
9757 string_table
= NULL
;
9758 string_table_length
= 0;
9761 if (dynamic_strings
)
9763 free (dynamic_strings
);
9764 dynamic_strings
= NULL
;
9767 if (dynamic_symbols
)
9769 free (dynamic_symbols
);
9770 dynamic_symbols
= NULL
;
9771 num_dynamic_syms
= 0;
9774 if (dynamic_syminfo
)
9776 free (dynamic_syminfo
);
9777 dynamic_syminfo
= NULL
;
9783 #ifdef SUPPORT_DISASSEMBLY
9784 /* Needed by the i386 disassembler. For extra credit, someone could
9785 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9789 print_address (unsigned int addr
, FILE * outfile
)
9791 fprintf (outfile
,"0x%8.8x", addr
);
9794 /* Needed by the i386 disassembler. */
9796 db_task_printsym (unsigned int addr
)
9798 print_address (addr
, stderr
);
9802 int main
PARAMS ((int, char **));
9811 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9812 setlocale (LC_MESSAGES
, "");
9814 #if defined (HAVE_SETLOCALE)
9815 setlocale (LC_CTYPE
, "");
9817 bindtextdomain (PACKAGE
, LOCALEDIR
);
9818 textdomain (PACKAGE
);
9820 parse_args (argc
, argv
);
9822 if (optind
< (argc
- 1))
9826 while (optind
< argc
)
9827 err
|= process_file (argv
[optind
++]);
9829 if (dump_sects
!= NULL
)