1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we belive that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
52 #include "elf/alpha.h"
70 #include "elf/mcore.h"
73 #include "elf/mn10200.h"
74 #include "elf/mn10300.h"
80 #include "elf/sparc.h"
82 #include "elf/x86-64.h"
83 #include "elf/xstormy16.h"
88 char * program_name
= "readelf";
89 unsigned int dynamic_addr
;
90 bfd_size_type dynamic_size
;
91 unsigned int rela_addr
;
92 unsigned int rela_size
;
93 char * dynamic_strings
;
95 unsigned long string_table_length
;
96 unsigned long num_dynamic_syms
;
97 Elf_Internal_Sym
* dynamic_symbols
;
98 Elf_Internal_Syminfo
* dynamic_syminfo
;
99 unsigned long dynamic_syminfo_offset
;
100 unsigned int dynamic_syminfo_nent
;
101 char program_interpreter
[64];
102 int dynamic_info
[DT_JMPREL
+ 1];
103 int version_info
[16];
105 Elf_Internal_Ehdr elf_header
;
106 Elf_Internal_Shdr
* section_headers
;
107 Elf_Internal_Dyn
* dynamic_segment
;
108 Elf_Internal_Shdr
* symtab_shndx_hdr
;
116 int do_using_dynamic
;
124 int do_debug_abbrevs
;
126 int do_debug_pubnames
;
127 int do_debug_aranges
;
129 int do_debug_frames_interp
;
130 int do_debug_macinfo
;
137 /* A dynamic array of flags indicating which sections require dumping. */
138 char * dump_sects
= NULL
;
139 unsigned int num_dump_sects
= 0;
141 #define HEX_DUMP (1 << 0)
142 #define DISASS_DUMP (1 << 1)
143 #define DEBUG_DUMP (1 << 2)
145 /* How to rpint a vma value. */
146 typedef enum print_mode
158 /* Forward declarations for dumb compilers. */
159 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
160 static void print_symbol
PARAMS ((int, char *));
161 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
162 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
163 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
164 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
165 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
166 static const char * get_ppc64_dynamic_type
PARAMS ((unsigned long));
167 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
168 static const char * get_dynamic_type
PARAMS ((unsigned long));
169 static int slurp_rela_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**, unsigned long *));
170 static int slurp_rel_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel
**, unsigned long *));
171 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
172 static char * get_file_type
PARAMS ((unsigned));
173 static char * get_machine_name
PARAMS ((unsigned));
174 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
175 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
176 static const char * get_mips_segment_type
PARAMS ((unsigned long));
177 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
178 static const char * get_ia64_segment_type
PARAMS ((unsigned long));
179 static const char * get_segment_type
PARAMS ((unsigned long));
180 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
181 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
182 static const char * get_ia64_section_type_name
PARAMS ((unsigned int));
183 static const char * get_section_type_name
PARAMS ((unsigned int));
184 static const char * get_symbol_binding
PARAMS ((unsigned int));
185 static const char * get_symbol_type
PARAMS ((unsigned int));
186 static const char * get_symbol_visibility
PARAMS ((unsigned int));
187 static const char * get_symbol_index_type
PARAMS ((unsigned int));
188 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
189 static void usage
PARAMS ((void));
190 static void parse_args
PARAMS ((int, char **));
191 static int process_file_header
PARAMS ((void));
192 static int process_program_headers
PARAMS ((FILE *));
193 static int process_section_headers
PARAMS ((FILE *));
194 static int process_unwind
PARAMS ((FILE *));
195 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
196 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
197 static int process_dynamic_segment
PARAMS ((FILE *));
198 static int process_symbol_table
PARAMS ((FILE *));
199 static int process_syminfo
PARAMS ((FILE *));
200 static int process_section_contents
PARAMS ((FILE *));
201 static void process_mips_fpe_exception
PARAMS ((int));
202 static int process_mips_specific
PARAMS ((FILE *));
203 static int process_file
PARAMS ((char *));
204 static int process_relocs
PARAMS ((FILE *));
205 static int process_version_sections
PARAMS ((FILE *));
206 static char * get_ver_flags
PARAMS ((unsigned int));
207 static int get_32bit_section_headers
PARAMS ((FILE *, unsigned int));
208 static int get_64bit_section_headers
PARAMS ((FILE *, unsigned int));
209 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
210 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
211 static int get_file_header
PARAMS ((FILE *));
212 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
213 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
214 static const char * get_elf_section_flags
PARAMS ((bfd_vma
));
215 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
216 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
217 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
218 #ifdef SUPPORT_DISASSEMBLY
219 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
221 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
222 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
223 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
224 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
225 static int prescan_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
226 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
227 static int display_debug_pubnames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
228 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
229 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
230 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
231 static int display_debug_macinfo
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
232 static int display_debug_str
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
233 static int display_debug_loc
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
234 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
235 static void load_debug_str
PARAMS ((FILE *));
236 static void free_debug_str
PARAMS ((void));
237 static const char * fetch_indirect_string
PARAMS ((unsigned long));
238 static void load_debug_loc
PARAMS ((FILE *));
239 static void free_debug_loc
PARAMS ((void));
240 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
241 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
242 static void reset_state_machine
PARAMS ((int));
243 static char * get_TAG_name
PARAMS ((unsigned long));
244 static char * get_AT_name
PARAMS ((unsigned long));
245 static char * get_FORM_name
PARAMS ((unsigned long));
246 static void free_abbrevs
PARAMS ((void));
247 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
248 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
249 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
250 static unsigned char * read_and_display_attr_value
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
251 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
252 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
253 static void request_dump
PARAMS ((unsigned int, int));
254 static const char * get_elf_class
PARAMS ((unsigned int));
255 static const char * get_data_encoding
PARAMS ((unsigned int));
256 static const char * get_osabi_name
PARAMS ((unsigned int));
257 static int guess_is_rela
PARAMS ((unsigned long));
258 static const char * get_note_type
PARAMS ((unsigned int));
259 static const char * get_netbsd_elfcore_note_type
PARAMS ((unsigned int));
260 static int process_note
PARAMS ((Elf32_Internal_Note
*));
261 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
262 static int process_corefile_note_segments
PARAMS ((FILE *));
263 static int process_corefile_contents
PARAMS ((FILE *));
264 static int process_arch_specific
PARAMS ((FILE *));
266 typedef int Elf32_Word
;
274 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
275 ((X)->sh_name >= string_table_length \
276 ? "<corrupt>" : string_table + (X)->sh_name))
278 /* Given st_shndx I, map to section_headers index. */
279 #define SECTION_HEADER_INDEX(I) \
280 ((I) < SHN_LORESERVE \
282 : ((I) <= SHN_HIRESERVE \
284 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
286 /* Reverse of the above. */
287 #define SECTION_HEADER_NUM(N) \
288 ((N) < SHN_LORESERVE \
290 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
292 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
294 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
296 #define BYTE_GET(field) byte_get (field, sizeof (field))
298 /* If we can support a 64 bit data type then BFD64 should be defined
299 and sizeof (bfd_vma) == 8. In this case when translating from an
300 external 8 byte field to an internal field, we can assume that the
301 internal field is also 8 bytes wide and so we can extract all the data.
302 If, however, BFD64 is not defined, then we must assume that the
303 internal data structure only has 4 byte wide fields that are the
304 equivalent of the 8 byte wide external counterparts, and so we must
305 truncate the data. */
307 #define BYTE_GET8(field) byte_get (field, -8)
309 #define BYTE_GET8(field) byte_get (field, 8)
312 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
314 #define GET_ELF_SYMBOLS(file, section) \
315 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
316 : get_64bit_elf_symbols (file, section))
320 error
VPARAMS ((const char *message
, ...))
322 VA_OPEN (args
, message
);
323 VA_FIXEDARG (args
, const char *, message
);
325 fprintf (stderr
, _("%s: Error: "), program_name
);
326 vfprintf (stderr
, message
, args
);
331 warn
VPARAMS ((const char *message
, ...))
333 VA_OPEN (args
, message
);
334 VA_FIXEDARG (args
, const char *, message
);
336 fprintf (stderr
, _("%s: Warning: "), program_name
);
337 vfprintf (stderr
, message
, args
);
341 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
344 get_data (var
, file
, offset
, size
, reason
)
356 if (fseek (file
, offset
, SEEK_SET
))
358 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
365 mvar
= (PTR
) malloc (size
);
369 error (_("Out of memory allocating %d bytes for %s\n"),
375 if (fread (mvar
, size
, 1, file
) != 1)
377 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
387 byte_get_little_endian (field
, size
)
388 unsigned char * field
;
397 return ((unsigned int) (field
[0]))
398 | (((unsigned int) (field
[1])) << 8);
402 /* We want to extract data from an 8 byte wide field and
403 place it into a 4 byte wide field. Since this is a little
404 endian source we can juts use the 4 byte extraction code. */
408 return ((unsigned long) (field
[0]))
409 | (((unsigned long) (field
[1])) << 8)
410 | (((unsigned long) (field
[2])) << 16)
411 | (((unsigned long) (field
[3])) << 24);
416 /* This is a special case, generated by the BYTE_GET8 macro.
417 It means that we are loading an 8 byte value from a field
418 in an external structure into an 8 byte value in a field
419 in an internal strcuture. */
420 return ((bfd_vma
) (field
[0]))
421 | (((bfd_vma
) (field
[1])) << 8)
422 | (((bfd_vma
) (field
[2])) << 16)
423 | (((bfd_vma
) (field
[3])) << 24)
424 | (((bfd_vma
) (field
[4])) << 32)
425 | (((bfd_vma
) (field
[5])) << 40)
426 | (((bfd_vma
) (field
[6])) << 48)
427 | (((bfd_vma
) (field
[7])) << 56);
430 error (_("Unhandled data length: %d\n"), size
);
435 /* Print a VMA value. */
437 print_vma (vma
, mode
)
447 case FULL_HEX
: printf ("0x"); /* drop through */
448 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
449 case PREFIX_HEX
: printf ("0x"); /* drop through */
450 case HEX
: printf ("%lx", (unsigned long) vma
); break;
451 case DEC
: printf ("%ld", (unsigned long) vma
); break;
452 case DEC_5
: printf ("%5ld", (long) vma
); break;
453 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
474 #if BFD_HOST_64BIT_LONG
477 if (_bfd_int64_high (vma
))
478 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
480 printf ("%lx", _bfd_int64_low (vma
));
485 #if BFD_HOST_64BIT_LONG
488 if (_bfd_int64_high (vma
))
490 printf ("++%ld", _bfd_int64_low (vma
));
492 printf ("%ld", _bfd_int64_low (vma
));
497 #if BFD_HOST_64BIT_LONG
498 printf ("%5ld", vma
);
500 if (_bfd_int64_high (vma
))
502 printf ("++%ld", _bfd_int64_low (vma
));
504 printf ("%5ld", _bfd_int64_low (vma
));
509 #if BFD_HOST_64BIT_LONG
512 if (_bfd_int64_high (vma
))
514 printf ("++%lu", _bfd_int64_low (vma
));
516 printf ("%lu", _bfd_int64_low (vma
));
524 /* Display a symbol on stdout. If do_wide is not true then
525 format the symbol to be at most WIDTH characters,
526 truhncating as necessary. If WIDTH is negative then
527 format the string to be exactly - WIDTH characters,
528 truncating or padding as necessary. */
531 print_symbol (width
, symbol
)
538 printf ("%-*.*s", width
, width
, symbol
);
540 printf ("%-.*s", width
, symbol
);
544 byte_get_big_endian (field
, size
)
545 unsigned char * field
;
554 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
557 return ((unsigned long) (field
[3]))
558 | (((unsigned long) (field
[2])) << 8)
559 | (((unsigned long) (field
[1])) << 16)
560 | (((unsigned long) (field
[0])) << 24);
564 /* Although we are extracing data from an 8 byte wide field, we
565 are returning only 4 bytes of data. */
566 return ((unsigned long) (field
[7]))
567 | (((unsigned long) (field
[6])) << 8)
568 | (((unsigned long) (field
[5])) << 16)
569 | (((unsigned long) (field
[4])) << 24);
573 /* This is a special case, generated by the BYTE_GET8 macro.
574 It means that we are loading an 8 byte value from a field
575 in an external structure into an 8 byte value in a field
576 in an internal strcuture. */
577 return ((bfd_vma
) (field
[7]))
578 | (((bfd_vma
) (field
[6])) << 8)
579 | (((bfd_vma
) (field
[5])) << 16)
580 | (((bfd_vma
) (field
[4])) << 24)
581 | (((bfd_vma
) (field
[3])) << 32)
582 | (((bfd_vma
) (field
[2])) << 40)
583 | (((bfd_vma
) (field
[1])) << 48)
584 | (((bfd_vma
) (field
[0])) << 56);
588 error (_("Unhandled data length: %d\n"), size
);
593 /* Guess the relocation size commonly used by the specific machines. */
596 guess_is_rela (e_machine
)
597 unsigned long e_machine
;
601 /* Targets that use REL relocations. */
617 /* Targets that use RELA relocations. */
632 case EM_CYGNUS_MN10200
:
634 case EM_CYGNUS_MN10300
:
672 warn (_("Don't know about relocations on this machine architecture\n"));
678 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
680 unsigned long rel_offset
;
681 unsigned long rel_size
;
682 Elf_Internal_Rela
**relasp
;
683 unsigned long *nrelasp
;
685 Elf_Internal_Rela
*relas
;
686 unsigned long nrelas
;
691 Elf32_External_Rela
* erelas
;
693 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
694 rel_size
, _("relocs"));
698 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
700 relas
= (Elf_Internal_Rela
*)
701 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
705 error(_("out of memory parsing relocs"));
709 for (i
= 0; i
< nrelas
; i
++)
711 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
712 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
713 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
720 Elf64_External_Rela
* erelas
;
722 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
723 rel_size
, _("relocs"));
727 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
729 relas
= (Elf_Internal_Rela
*)
730 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
734 error(_("out of memory parsing relocs"));
738 for (i
= 0; i
< nrelas
; i
++)
740 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
741 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
742 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
753 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
755 unsigned long rel_offset
;
756 unsigned long rel_size
;
757 Elf_Internal_Rel
**relsp
;
758 unsigned long *nrelsp
;
760 Elf_Internal_Rel
*rels
;
766 Elf32_External_Rel
* erels
;
768 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
769 rel_size
, _("relocs"));
773 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
775 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
779 error(_("out of memory parsing relocs"));
783 for (i
= 0; i
< nrels
; i
++)
785 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
786 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
793 Elf64_External_Rel
* erels
;
795 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
796 rel_size
, _("relocs"));
800 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
802 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
806 error(_("out of memory parsing relocs"));
810 for (i
= 0; i
< nrels
; i
++)
812 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
813 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
823 /* Display the contents of the relocation data found at the specified offset. */
825 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
827 unsigned long rel_offset
;
828 unsigned long rel_size
;
829 Elf_Internal_Sym
* symtab
;
835 Elf_Internal_Rel
* rels
;
836 Elf_Internal_Rela
* relas
;
839 if (is_rela
== UNKNOWN
)
840 is_rela
= guess_is_rela (elf_header
.e_machine
);
844 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &relas
, &rel_size
))
849 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
858 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
860 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
865 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
867 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
875 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
877 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
882 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
884 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
888 for (i
= 0; i
< rel_size
; i
++)
891 const char * rtype2
= NULL
;
892 const char * rtype3
= NULL
;
895 bfd_vma symtab_index
;
897 bfd_vma type2
= (bfd_vma
) NULL
;
898 bfd_vma type3
= (bfd_vma
) NULL
;
902 offset
= relas
[i
].r_offset
;
903 info
= relas
[i
].r_info
;
907 offset
= rels
[i
].r_offset
;
908 info
= rels
[i
].r_info
;
913 type
= ELF32_R_TYPE (info
);
914 symtab_index
= ELF32_R_SYM (info
);
918 if (elf_header
.e_machine
== EM_MIPS
)
920 type
= ELF64_MIPS_R_TYPE (info
);
921 type2
= ELF64_MIPS_R_TYPE2 (info
);
922 type3
= ELF64_MIPS_R_TYPE3 (info
);
924 else if (elf_header
.e_machine
== EM_SPARCV9
)
925 type
= ELF64_R_TYPE_ID (info
);
927 type
= ELF64_R_TYPE (info
);
928 /* The #ifdef BFD64 below is to prevent a compile time warning.
929 We know that if we do not have a 64 bit data type that we
930 will never execute this code anyway. */
932 symtab_index
= ELF64_R_SYM (info
);
938 #ifdef _bfd_int64_low
939 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
941 printf ("%8.8lx %8.8lx ", offset
, info
);
946 #ifdef _bfd_int64_low
948 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
949 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
950 _bfd_int64_high (offset
),
951 _bfd_int64_low (offset
),
952 _bfd_int64_high (info
),
953 _bfd_int64_low (info
));
956 ? "%16.16lx %16.16lx "
957 : "%12.12lx %12.12lx ",
962 switch (elf_header
.e_machine
)
970 rtype
= elf_m32r_reloc_type (type
);
975 rtype
= elf_i386_reloc_type (type
);
979 rtype
= elf_m68k_reloc_type (type
);
983 rtype
= elf_i960_reloc_type (type
);
988 rtype
= elf_avr_reloc_type (type
);
995 rtype
= elf_sparc_reloc_type (type
);
1000 rtype
= v850_reloc_type (type
);
1004 case EM_CYGNUS_D10V
:
1005 rtype
= elf_d10v_reloc_type (type
);
1009 case EM_CYGNUS_D30V
:
1010 rtype
= elf_d30v_reloc_type (type
);
1014 rtype
= elf_dlx_reloc_type (type
);
1018 rtype
= elf_sh_reloc_type (type
);
1022 case EM_CYGNUS_MN10300
:
1023 rtype
= elf_mn10300_reloc_type (type
);
1027 case EM_CYGNUS_MN10200
:
1028 rtype
= elf_mn10200_reloc_type (type
);
1032 case EM_CYGNUS_FR30
:
1033 rtype
= elf_fr30_reloc_type (type
);
1037 rtype
= elf_frv_reloc_type (type
);
1041 rtype
= elf_mcore_reloc_type (type
);
1045 rtype
= elf_mmix_reloc_type (type
);
1050 rtype
= elf_ppc_reloc_type (type
);
1054 case EM_MIPS_RS3_LE
:
1055 rtype
= elf_mips_reloc_type (type
);
1058 rtype2
= elf_mips_reloc_type (type2
);
1059 rtype3
= elf_mips_reloc_type (type3
);
1064 rtype
= elf_alpha_reloc_type (type
);
1068 rtype
= elf_arm_reloc_type (type
);
1072 rtype
= elf_arc_reloc_type (type
);
1076 rtype
= elf_hppa_reloc_type (type
);
1082 rtype
= elf_h8_reloc_type (type
);
1087 rtype
= elf_or32_reloc_type (type
);
1092 rtype
= elf_pj_reloc_type (type
);
1095 rtype
= elf_ia64_reloc_type (type
);
1099 rtype
= elf_cris_reloc_type (type
);
1103 rtype
= elf_i860_reloc_type (type
);
1107 rtype
= elf_x86_64_reloc_type (type
);
1112 rtype
= elf_s390_reloc_type (type
);
1116 rtype
= elf_xstormy16_reloc_type (type
);
1121 #ifdef _bfd_int64_low
1122 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1124 printf (_("unrecognized: %-7lx"), type
);
1127 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1131 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1132 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1135 Elf_Internal_Sym
* psym
;
1137 psym
= symtab
+ symtab_index
;
1140 print_vma (psym
->st_value
, LONG_HEX
);
1141 printf (is_32bit_elf
? " " : " ");
1143 if (psym
->st_name
== 0)
1144 print_symbol (22, SECTION_NAME (section_headers
+ psym
->st_shndx
));
1145 else if (strtab
== NULL
)
1146 printf (_("<string table index %3ld>"), psym
->st_name
);
1148 print_symbol (22, strtab
+ psym
->st_name
);
1151 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
1156 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1157 print_vma (relas
[i
].r_addend
, LONG_HEX
);
1160 if (elf_header
.e_machine
== EM_SPARCV9
1161 && !strcmp (rtype
, "R_SPARC_OLO10"))
1162 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1166 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1168 printf (" Type2: ");
1171 #ifdef _bfd_int64_low
1172 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1174 printf (_("unrecognized: %-7lx"), type2
);
1177 printf ("%-17.17s", rtype2
);
1179 printf("\n Type3: ");
1182 #ifdef _bfd_int64_low
1183 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1185 printf (_("unrecognized: %-7lx"), type3
);
1188 printf ("%-17.17s", rtype3
);
1203 get_mips_dynamic_type (type
)
1208 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1209 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1210 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1211 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1212 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1213 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1214 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1215 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1216 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1217 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1218 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1219 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1220 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1221 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1222 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1223 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1224 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1225 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1226 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1227 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1228 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1229 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1230 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1231 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1232 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1233 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1234 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1235 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1236 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1237 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1238 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1239 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1240 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1241 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1242 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1243 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1244 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1245 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1246 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1247 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1248 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1249 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1250 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1257 get_sparc64_dynamic_type (type
)
1262 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1269 get_ppc64_dynamic_type (type
)
1274 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1275 case DT_PPC64_OPD
: return "PPC64_OPD";
1276 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1283 get_parisc_dynamic_type (type
)
1288 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1289 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1290 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1291 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1292 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1293 case DT_HP_PREINIT
: return "HP_PREINIT";
1294 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1295 case DT_HP_NEEDED
: return "HP_NEEDED";
1296 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1297 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1298 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1299 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1300 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1307 get_dynamic_type (type
)
1310 static char buff
[32];
1314 case DT_NULL
: return "NULL";
1315 case DT_NEEDED
: return "NEEDED";
1316 case DT_PLTRELSZ
: return "PLTRELSZ";
1317 case DT_PLTGOT
: return "PLTGOT";
1318 case DT_HASH
: return "HASH";
1319 case DT_STRTAB
: return "STRTAB";
1320 case DT_SYMTAB
: return "SYMTAB";
1321 case DT_RELA
: return "RELA";
1322 case DT_RELASZ
: return "RELASZ";
1323 case DT_RELAENT
: return "RELAENT";
1324 case DT_STRSZ
: return "STRSZ";
1325 case DT_SYMENT
: return "SYMENT";
1326 case DT_INIT
: return "INIT";
1327 case DT_FINI
: return "FINI";
1328 case DT_SONAME
: return "SONAME";
1329 case DT_RPATH
: return "RPATH";
1330 case DT_SYMBOLIC
: return "SYMBOLIC";
1331 case DT_REL
: return "REL";
1332 case DT_RELSZ
: return "RELSZ";
1333 case DT_RELENT
: return "RELENT";
1334 case DT_PLTREL
: return "PLTREL";
1335 case DT_DEBUG
: return "DEBUG";
1336 case DT_TEXTREL
: return "TEXTREL";
1337 case DT_JMPREL
: return "JMPREL";
1338 case DT_BIND_NOW
: return "BIND_NOW";
1339 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1340 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1341 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1342 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1343 case DT_RUNPATH
: return "RUNPATH";
1344 case DT_FLAGS
: return "FLAGS";
1346 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1347 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1349 case DT_CHECKSUM
: return "CHECKSUM";
1350 case DT_PLTPADSZ
: return "PLTPADSZ";
1351 case DT_MOVEENT
: return "MOVEENT";
1352 case DT_MOVESZ
: return "MOVESZ";
1353 case DT_FEATURE
: return "FEATURE";
1354 case DT_POSFLAG_1
: return "POSFLAG_1";
1355 case DT_SYMINSZ
: return "SYMINSZ";
1356 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1358 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1359 case DT_CONFIG
: return "CONFIG";
1360 case DT_DEPAUDIT
: return "DEPAUDIT";
1361 case DT_AUDIT
: return "AUDIT";
1362 case DT_PLTPAD
: return "PLTPAD";
1363 case DT_MOVETAB
: return "MOVETAB";
1364 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1366 case DT_VERSYM
: return "VERSYM";
1368 case DT_RELACOUNT
: return "RELACOUNT";
1369 case DT_RELCOUNT
: return "RELCOUNT";
1370 case DT_FLAGS_1
: return "FLAGS_1";
1371 case DT_VERDEF
: return "VERDEF";
1372 case DT_VERDEFNUM
: return "VERDEFNUM";
1373 case DT_VERNEED
: return "VERNEED";
1374 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1376 case DT_AUXILIARY
: return "AUXILIARY";
1377 case DT_USED
: return "USED";
1378 case DT_FILTER
: return "FILTER";
1381 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1383 const char * result
;
1385 switch (elf_header
.e_machine
)
1388 case EM_MIPS_RS3_LE
:
1389 result
= get_mips_dynamic_type (type
);
1392 result
= get_sparc64_dynamic_type (type
);
1395 result
= get_ppc64_dynamic_type (type
);
1405 sprintf (buff
, _("Processor Specific: %lx"), type
);
1407 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1409 const char * result
;
1411 switch (elf_header
.e_machine
)
1414 result
= get_parisc_dynamic_type (type
);
1424 sprintf (buff
, _("Operating System specific: %lx"), type
);
1427 sprintf (buff
, _("<unknown>: %lx"), type
);
1434 get_file_type (e_type
)
1437 static char buff
[32];
1441 case ET_NONE
: return _("NONE (None)");
1442 case ET_REL
: return _("REL (Relocatable file)");
1443 case ET_EXEC
: return _("EXEC (Executable file)");
1444 case ET_DYN
: return _("DYN (Shared object file)");
1445 case ET_CORE
: return _("CORE (Core file)");
1448 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1449 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1450 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1451 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1453 sprintf (buff
, _("<unknown>: %x"), e_type
);
1459 get_machine_name (e_machine
)
1462 static char buff
[64]; /* XXX */
1466 case EM_NONE
: return _("None");
1467 case EM_M32
: return "WE32100";
1468 case EM_SPARC
: return "Sparc";
1469 case EM_386
: return "Intel 80386";
1470 case EM_68K
: return "MC68000";
1471 case EM_88K
: return "MC88000";
1472 case EM_486
: return "Intel 80486";
1473 case EM_860
: return "Intel 80860";
1474 case EM_MIPS
: return "MIPS R3000";
1475 case EM_S370
: return "IBM System/370";
1476 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1477 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1478 case EM_PARISC
: return "HPPA";
1479 case EM_PPC_OLD
: return "Power PC (old)";
1480 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1481 case EM_960
: return "Intel 90860";
1482 case EM_PPC
: return "PowerPC";
1483 case EM_PPC64
: return "PowerPC64";
1484 case EM_V800
: return "NEC V800";
1485 case EM_FR20
: return "Fujitsu FR20";
1486 case EM_RH32
: return "TRW RH32";
1487 case EM_MCORE
: return "MCORE";
1488 case EM_ARM
: return "ARM";
1489 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1490 case EM_SH
: return "Hitachi SH";
1491 case EM_SPARCV9
: return "Sparc v9";
1492 case EM_TRICORE
: return "Siemens Tricore";
1493 case EM_ARC
: return "ARC";
1494 case EM_H8_300
: return "Hitachi H8/300";
1495 case EM_H8_300H
: return "Hitachi H8/300H";
1496 case EM_H8S
: return "Hitachi H8S";
1497 case EM_H8_500
: return "Hitachi H8/500";
1498 case EM_IA_64
: return "Intel IA-64";
1499 case EM_MIPS_X
: return "Stanford MIPS-X";
1500 case EM_COLDFIRE
: return "Motorola Coldfire";
1501 case EM_68HC12
: return "Motorola M68HC12";
1502 case EM_ALPHA
: return "Alpha";
1503 case EM_CYGNUS_D10V
:
1504 case EM_D10V
: return "d10v";
1505 case EM_CYGNUS_D30V
:
1506 case EM_D30V
: return "d30v";
1507 case EM_CYGNUS_M32R
:
1508 case EM_M32R
: return "Mitsubishi M32r";
1509 case EM_CYGNUS_V850
:
1510 case EM_V850
: return "NEC v850";
1511 case EM_CYGNUS_MN10300
:
1512 case EM_MN10300
: return "mn10300";
1513 case EM_CYGNUS_MN10200
:
1514 case EM_MN10200
: return "mn10200";
1515 case EM_CYGNUS_FR30
:
1516 case EM_FR30
: return "Fujitsu FR30";
1517 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1519 case EM_PJ
: return "picoJava";
1520 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1521 case EM_PCP
: return "Siemens PCP";
1522 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1523 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1524 case EM_STARCORE
: return "Motorola Star*Core processor";
1525 case EM_ME16
: return "Toyota ME16 processor";
1526 case EM_ST100
: return "STMicroelectronics ST100 processor";
1527 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1528 case EM_FX66
: return "Siemens FX66 microcontroller";
1529 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1530 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1531 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1532 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1533 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1534 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1535 case EM_SVX
: return "Silicon Graphics SVx";
1536 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1537 case EM_VAX
: return "Digital VAX";
1539 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1540 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1541 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1542 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1543 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1544 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1545 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1546 case EM_PRISM
: return "SiTera Prism";
1547 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1549 case EM_S390
: return "IBM S/390";
1550 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1552 case EM_OR32
: return "OpenRISC";
1553 case EM_DLX
: return "OpenDLX";
1555 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1561 decode_ARM_machine_flags (e_flags
, buf
)
1568 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1569 e_flags
&= ~ EF_ARM_EABIMASK
;
1571 /* Handle "generic" ARM flags. */
1572 if (e_flags
& EF_ARM_RELEXEC
)
1574 strcat (buf
, ", relocatable executable");
1575 e_flags
&= ~ EF_ARM_RELEXEC
;
1578 if (e_flags
& EF_ARM_HASENTRY
)
1580 strcat (buf
, ", has entry point");
1581 e_flags
&= ~ EF_ARM_HASENTRY
;
1584 /* Now handle EABI specific flags. */
1588 strcat (buf
, ", <unrecognized EABI>");
1593 case EF_ARM_EABI_VER1
:
1594 strcat (buf
, ", Version1 EABI");
1599 /* Process flags one bit at a time. */
1600 flag
= e_flags
& - e_flags
;
1605 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1606 strcat (buf
, ", sorted symbol tables");
1616 case EF_ARM_EABI_VER2
:
1617 strcat (buf
, ", Version2 EABI");
1622 /* Process flags one bit at a time. */
1623 flag
= e_flags
& - e_flags
;
1628 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1629 strcat (buf
, ", sorted symbol tables");
1632 case EF_ARM_DYNSYMSUSESEGIDX
:
1633 strcat (buf
, ", dynamic symbols use segment index");
1636 case EF_ARM_MAPSYMSFIRST
:
1637 strcat (buf
, ", mapping symbols precede others");
1647 case EF_ARM_EABI_UNKNOWN
:
1648 strcat (buf
, ", GNU EABI");
1653 /* Process flags one bit at a time. */
1654 flag
= e_flags
& - e_flags
;
1659 case EF_ARM_INTERWORK
:
1660 strcat (buf
, ", interworking enabled");
1663 case EF_ARM_APCS_26
:
1664 strcat (buf
, ", uses APCS/26");
1667 case EF_ARM_APCS_FLOAT
:
1668 strcat (buf
, ", uses APCS/float");
1672 strcat (buf
, ", position independent");
1676 strcat (buf
, ", 8 bit structure alignment");
1679 case EF_ARM_NEW_ABI
:
1680 strcat (buf
, ", uses new ABI");
1683 case EF_ARM_OLD_ABI
:
1684 strcat (buf
, ", uses old ABI");
1687 case EF_ARM_SOFT_FLOAT
:
1688 strcat (buf
, ", software FP");
1699 strcat (buf
,", <unknown>");
1703 get_machine_flags (e_flags
, e_machine
)
1707 static char buf
[1024];
1719 decode_ARM_machine_flags (e_flags
, buf
);
1723 if (e_flags
& EF_CPU32
)
1724 strcat (buf
, ", cpu32");
1725 if (e_flags
& EF_M68000
)
1726 strcat (buf
, ", m68000");
1730 if (e_flags
& EF_PPC_EMB
)
1731 strcat (buf
, ", emb");
1733 if (e_flags
& EF_PPC_RELOCATABLE
)
1734 strcat (buf
, ", relocatable");
1736 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1737 strcat (buf
, ", relocatable-lib");
1741 case EM_CYGNUS_V850
:
1742 switch (e_flags
& EF_V850_ARCH
)
1745 strcat (buf
, ", v850e");
1748 strcat (buf
, ", v850ea");
1751 strcat (buf
, ", v850");
1754 strcat (buf
, ", unknown v850 architecture variant");
1760 case EM_CYGNUS_M32R
:
1761 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1762 strcat (buf
, ", m32r");
1767 case EM_MIPS_RS3_LE
:
1768 if (e_flags
& EF_MIPS_NOREORDER
)
1769 strcat (buf
, ", noreorder");
1771 if (e_flags
& EF_MIPS_PIC
)
1772 strcat (buf
, ", pic");
1774 if (e_flags
& EF_MIPS_CPIC
)
1775 strcat (buf
, ", cpic");
1777 if (e_flags
& EF_MIPS_UCODE
)
1778 strcat (buf
, ", ugen_reserved");
1780 if (e_flags
& EF_MIPS_ABI2
)
1781 strcat (buf
, ", abi2");
1783 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1784 strcat (buf
, ", odk first");
1786 if (e_flags
& EF_MIPS_32BITMODE
)
1787 strcat (buf
, ", 32bitmode");
1789 switch ((e_flags
& EF_MIPS_MACH
))
1791 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1792 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1793 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1794 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1795 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1796 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1798 /* We simply ignore the field in this case to avoid confusion:
1799 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1802 default: strcat (buf
, ", unknown CPU"); break;
1805 switch ((e_flags
& EF_MIPS_ABI
))
1807 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1808 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1809 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1810 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1812 /* We simply ignore the field in this case to avoid confusion:
1813 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1814 This means it is likely to be an o32 file, but not for
1817 default: strcat (buf
, ", unknown ABI"); break;
1820 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1821 strcat (buf
, ", mdmx");
1823 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1824 strcat (buf
, ", mips16");
1826 switch ((e_flags
& EF_MIPS_ARCH
))
1828 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1829 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1830 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1831 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1832 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1833 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1834 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1835 default: strcat (buf
, ", unknown ISA"); break;
1841 if (e_flags
& EF_SPARC_32PLUS
)
1842 strcat (buf
, ", v8+");
1844 if (e_flags
& EF_SPARC_SUN_US1
)
1845 strcat (buf
, ", ultrasparcI");
1847 if (e_flags
& EF_SPARC_SUN_US3
)
1848 strcat (buf
, ", ultrasparcIII");
1850 if (e_flags
& EF_SPARC_HAL_R1
)
1851 strcat (buf
, ", halr1");
1853 if (e_flags
& EF_SPARC_LEDATA
)
1854 strcat (buf
, ", ledata");
1856 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1857 strcat (buf
, ", tso");
1859 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1860 strcat (buf
, ", pso");
1862 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1863 strcat (buf
, ", rmo");
1867 switch (e_flags
& EF_PARISC_ARCH
)
1869 case EFA_PARISC_1_0
:
1870 strcpy (buf
, ", PA-RISC 1.0");
1872 case EFA_PARISC_1_1
:
1873 strcpy (buf
, ", PA-RISC 1.1");
1875 case EFA_PARISC_2_0
:
1876 strcpy (buf
, ", PA-RISC 2.0");
1881 if (e_flags
& EF_PARISC_TRAPNIL
)
1882 strcat (buf
, ", trapnil");
1883 if (e_flags
& EF_PARISC_EXT
)
1884 strcat (buf
, ", ext");
1885 if (e_flags
& EF_PARISC_LSB
)
1886 strcat (buf
, ", lsb");
1887 if (e_flags
& EF_PARISC_WIDE
)
1888 strcat (buf
, ", wide");
1889 if (e_flags
& EF_PARISC_NO_KABP
)
1890 strcat (buf
, ", no kabp");
1891 if (e_flags
& EF_PARISC_LAZYSWAP
)
1892 strcat (buf
, ", lazyswap");
1897 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1898 strcat (buf
, ", new calling convention");
1900 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1901 strcat (buf
, ", gnu calling convention");
1905 if ((e_flags
& EF_IA_64_ABI64
))
1906 strcat (buf
, ", 64-bit");
1908 strcat (buf
, ", 32-bit");
1909 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1910 strcat (buf
, ", reduced fp model");
1911 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1912 strcat (buf
, ", no function descriptors, constant gp");
1913 else if ((e_flags
& EF_IA_64_CONS_GP
))
1914 strcat (buf
, ", constant gp");
1915 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1916 strcat (buf
, ", absolute");
1925 get_mips_segment_type (type
)
1930 case PT_MIPS_REGINFO
:
1932 case PT_MIPS_RTPROC
:
1934 case PT_MIPS_OPTIONS
:
1944 get_parisc_segment_type (type
)
1949 case PT_HP_TLS
: return "HP_TLS";
1950 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1951 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1952 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1953 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1954 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1955 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1956 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1957 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1958 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1959 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1960 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1961 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1962 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1971 get_ia64_segment_type (type
)
1976 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
1977 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
1978 case PT_HP_TLS
: return "HP_TLS";
1979 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
1980 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
1981 case PT_IA_64_HP_STACK
: return "HP_STACK";
1990 get_segment_type (p_type
)
1991 unsigned long p_type
;
1993 static char buff
[32];
1997 case PT_NULL
: return "NULL";
1998 case PT_LOAD
: return "LOAD";
1999 case PT_DYNAMIC
: return "DYNAMIC";
2000 case PT_INTERP
: return "INTERP";
2001 case PT_NOTE
: return "NOTE";
2002 case PT_SHLIB
: return "SHLIB";
2003 case PT_PHDR
: return "PHDR";
2004 case PT_TLS
: return "TLS";
2006 case PT_GNU_EH_FRAME
:
2007 return "GNU_EH_FRAME";
2010 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2012 const char * result
;
2014 switch (elf_header
.e_machine
)
2017 case EM_MIPS_RS3_LE
:
2018 result
= get_mips_segment_type (p_type
);
2021 result
= get_parisc_segment_type (p_type
);
2024 result
= get_ia64_segment_type (p_type
);
2034 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2036 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2038 const char * result
;
2040 switch (elf_header
.e_machine
)
2043 result
= get_parisc_segment_type (p_type
);
2046 result
= get_ia64_segment_type (p_type
);
2056 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2059 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2066 get_mips_section_type_name (sh_type
)
2067 unsigned int sh_type
;
2071 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2072 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2073 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2074 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2075 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2076 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2077 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2078 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2079 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2080 case SHT_MIPS_RELD
: return "MIPS_RELD";
2081 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2082 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2083 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2084 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2085 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2086 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2087 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2088 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2089 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2090 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2091 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2092 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2093 case SHT_MIPS_LINE
: return "MIPS_LINE";
2094 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2095 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2096 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2097 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2098 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2099 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2100 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2101 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2102 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2103 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2104 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2105 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2106 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2107 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2108 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2109 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2117 get_parisc_section_type_name (sh_type
)
2118 unsigned int sh_type
;
2122 case SHT_PARISC_EXT
: return "PARISC_EXT";
2123 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2124 case SHT_PARISC_DOC
: return "PARISC_DOC";
2132 get_ia64_section_type_name (sh_type
)
2133 unsigned int sh_type
;
2137 case SHT_IA_64_EXT
: return "IA_64_EXT";
2138 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2146 get_section_type_name (sh_type
)
2147 unsigned int sh_type
;
2149 static char buff
[32];
2153 case SHT_NULL
: return "NULL";
2154 case SHT_PROGBITS
: return "PROGBITS";
2155 case SHT_SYMTAB
: return "SYMTAB";
2156 case SHT_STRTAB
: return "STRTAB";
2157 case SHT_RELA
: return "RELA";
2158 case SHT_HASH
: return "HASH";
2159 case SHT_DYNAMIC
: return "DYNAMIC";
2160 case SHT_NOTE
: return "NOTE";
2161 case SHT_NOBITS
: return "NOBITS";
2162 case SHT_REL
: return "REL";
2163 case SHT_SHLIB
: return "SHLIB";
2164 case SHT_DYNSYM
: return "DYNSYM";
2165 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2166 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2167 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2168 case SHT_GROUP
: return "GROUP";
2169 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2170 case SHT_GNU_verdef
: return "VERDEF";
2171 case SHT_GNU_verneed
: return "VERNEED";
2172 case SHT_GNU_versym
: return "VERSYM";
2173 case 0x6ffffff0: return "VERSYM";
2174 case 0x6ffffffc: return "VERDEF";
2175 case 0x7ffffffd: return "AUXILIARY";
2176 case 0x7fffffff: return "FILTER";
2179 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2181 const char * result
;
2183 switch (elf_header
.e_machine
)
2186 case EM_MIPS_RS3_LE
:
2187 result
= get_mips_section_type_name (sh_type
);
2190 result
= get_parisc_section_type_name (sh_type
);
2193 result
= get_ia64_section_type_name (sh_type
);
2203 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2205 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2206 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2207 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2208 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2210 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2216 struct option options
[] =
2218 {"all", no_argument
, 0, 'a'},
2219 {"file-header", no_argument
, 0, 'h'},
2220 {"program-headers", no_argument
, 0, 'l'},
2221 {"headers", no_argument
, 0, 'e'},
2222 {"histogram", no_argument
, 0, 'I'},
2223 {"segments", no_argument
, 0, 'l'},
2224 {"sections", no_argument
, 0, 'S'},
2225 {"section-headers", no_argument
, 0, 'S'},
2226 {"symbols", no_argument
, 0, 's'},
2227 {"syms", no_argument
, 0, 's'},
2228 {"relocs", no_argument
, 0, 'r'},
2229 {"notes", no_argument
, 0, 'n'},
2230 {"dynamic", no_argument
, 0, 'd'},
2231 {"arch-specific", no_argument
, 0, 'A'},
2232 {"version-info", no_argument
, 0, 'V'},
2233 {"use-dynamic", no_argument
, 0, 'D'},
2234 {"hex-dump", required_argument
, 0, 'x'},
2235 {"debug-dump", optional_argument
, 0, 'w'},
2236 {"unwind", no_argument
, 0, 'u'},
2237 #ifdef SUPPORT_DISASSEMBLY
2238 {"instruction-dump", required_argument
, 0, 'i'},
2241 {"version", no_argument
, 0, 'v'},
2242 {"wide", no_argument
, 0, 'W'},
2243 {"help", no_argument
, 0, 'H'},
2244 {0, no_argument
, 0, 0}
2250 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2251 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2252 fprintf (stdout
, _(" Options are:\n\
2253 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2254 -h --file-header Display the ELF file header\n\
2255 -l --program-headers Display the program headers\n\
2256 --segments An alias for --program-headers\n\
2257 -S --section-headers Display the sections' header\n\
2258 --sections An alias for --section-headers\n\
2259 -e --headers Equivalent to: -h -l -S\n\
2260 -s --syms Display the symbol table\n\
2261 --symbols An alias for --syms\n\
2262 -n --notes Display the core notes (if present)\n\
2263 -r --relocs Display the relocations (if present)\n\
2264 -u --unwind Display the unwind info (if present)\n\
2265 -d --dynamic Display the dynamic segment (if present)\n\
2266 -V --version-info Display the version sections (if present)\n\
2267 -A --arch-specific Display architecture specific information (if any).\n\
2268 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2269 -x --hex-dump=<number> Dump the contents of section <number>\n\
2270 -w --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2271 Display the contents of DWARF2 debug sections\n"));
2272 #ifdef SUPPORT_DISASSEMBLY
2273 fprintf (stdout
, _("\
2274 -i --instruction-dump=<number>\n\
2275 Disassemble the contents of section <number>\n"));
2277 fprintf (stdout
, _("\
2278 -I --histogram Display histogram of bucket list lengths\n\
2279 -W --wide Allow output width to exceed 80 characters\n\
2280 -H --help Display this information\n\
2281 -v --version Display the version number of readelf\n"));
2282 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2288 request_dump (section
, type
)
2289 unsigned int section
;
2292 if (section
>= num_dump_sects
)
2294 char * new_dump_sects
;
2296 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2298 if (new_dump_sects
== NULL
)
2299 error (_("Out of memory allocating dump request table."));
2302 /* Copy current flag settings. */
2303 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2307 dump_sects
= new_dump_sects
;
2308 num_dump_sects
= section
+ 1;
2313 dump_sects
[section
] |= type
;
2319 parse_args (argc
, argv
)
2328 while ((c
= getopt_long
2329 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2365 do_using_dynamic
++;
2396 section
= strtoul (optarg
, & cp
, 0);
2397 if (! * cp
&& section
>= 0)
2399 request_dump (section
, HEX_DUMP
);
2409 unsigned int index
= 0;
2413 while (optarg
[index
])
2414 switch (optarg
[index
++])
2423 do_debug_abbrevs
= 1;
2433 do_debug_pubnames
= 1;
2438 do_debug_aranges
= 1;
2442 do_debug_frames_interp
= 1;
2444 do_debug_frames
= 1;
2449 do_debug_macinfo
= 1;
2463 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2468 #ifdef SUPPORT_DISASSEMBLY
2471 section
= strtoul (optarg
, & cp
, 0);
2472 if (! * cp
&& section
>= 0)
2474 request_dump (section
, DISASS_DUMP
);
2480 print_version (program_name
);
2490 /* xgettext:c-format */
2491 error (_("Invalid option '-%c'\n"), c
);
2498 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2499 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2500 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2504 warn (_("Nothing to do.\n"));
2510 get_elf_class (elf_class
)
2511 unsigned int elf_class
;
2513 static char buff
[32];
2517 case ELFCLASSNONE
: return _("none");
2518 case ELFCLASS32
: return "ELF32";
2519 case ELFCLASS64
: return "ELF64";
2521 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2527 get_data_encoding (encoding
)
2528 unsigned int encoding
;
2530 static char buff
[32];
2534 case ELFDATANONE
: return _("none");
2535 case ELFDATA2LSB
: return _("2's complement, little endian");
2536 case ELFDATA2MSB
: return _("2's complement, big endian");
2538 sprintf (buff
, _("<unknown: %x>"), encoding
);
2544 get_osabi_name (osabi
)
2547 static char buff
[32];
2551 case ELFOSABI_NONE
: return "UNIX - System V";
2552 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2553 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2554 case ELFOSABI_LINUX
: return "UNIX - Linux";
2555 case ELFOSABI_HURD
: return "GNU/Hurd";
2556 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2557 case ELFOSABI_AIX
: return "UNIX - AIX";
2558 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2559 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2560 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2561 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2562 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2563 case ELFOSABI_STANDALONE
: return _("Standalone App");
2564 case ELFOSABI_ARM
: return "ARM";
2566 sprintf (buff
, _("<unknown: %x>"), osabi
);
2571 /* Decode the data held in 'elf_header'. */
2573 process_file_header ()
2575 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2576 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2577 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2578 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2581 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2589 printf (_("ELF Header:\n"));
2590 printf (_(" Magic: "));
2591 for (i
= 0; i
< EI_NIDENT
; i
++)
2592 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2594 printf (_(" Class: %s\n"),
2595 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2596 printf (_(" Data: %s\n"),
2597 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2598 printf (_(" Version: %d %s\n"),
2599 elf_header
.e_ident
[EI_VERSION
],
2600 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2602 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2605 printf (_(" OS/ABI: %s\n"),
2606 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2607 printf (_(" ABI Version: %d\n"),
2608 elf_header
.e_ident
[EI_ABIVERSION
]);
2609 printf (_(" Type: %s\n"),
2610 get_file_type (elf_header
.e_type
));
2611 printf (_(" Machine: %s\n"),
2612 get_machine_name (elf_header
.e_machine
));
2613 printf (_(" Version: 0x%lx\n"),
2614 (unsigned long) elf_header
.e_version
);
2616 printf (_(" Entry point address: "));
2617 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2618 printf (_("\n Start of program headers: "));
2619 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2620 printf (_(" (bytes into file)\n Start of section headers: "));
2621 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2622 printf (_(" (bytes into file)\n"));
2624 printf (_(" Flags: 0x%lx%s\n"),
2625 (unsigned long) elf_header
.e_flags
,
2626 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2627 printf (_(" Size of this header: %ld (bytes)\n"),
2628 (long) elf_header
.e_ehsize
);
2629 printf (_(" Size of program headers: %ld (bytes)\n"),
2630 (long) elf_header
.e_phentsize
);
2631 printf (_(" Number of program headers: %ld\n"),
2632 (long) elf_header
.e_phnum
);
2633 printf (_(" Size of section headers: %ld (bytes)\n"),
2634 (long) elf_header
.e_shentsize
);
2635 printf (_(" Number of section headers: %ld"),
2636 (long) elf_header
.e_shnum
);
2637 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2638 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2639 putc ('\n', stdout
);
2640 printf (_(" Section header string table index: %ld"),
2641 (long) elf_header
.e_shstrndx
);
2642 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2643 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2644 putc ('\n', stdout
);
2647 if (section_headers
!= NULL
)
2649 if (elf_header
.e_shnum
== 0)
2650 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2651 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2652 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2653 free (section_headers
);
2654 section_headers
= NULL
;
2662 get_32bit_program_headers (file
, program_headers
)
2664 Elf_Internal_Phdr
* program_headers
;
2666 Elf32_External_Phdr
* phdrs
;
2667 Elf32_External_Phdr
* external
;
2668 Elf32_Internal_Phdr
* internal
;
2671 phdrs
= ((Elf32_External_Phdr
*)
2672 get_data (NULL
, file
, elf_header
.e_phoff
,
2673 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2674 _("program headers")));
2678 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2679 i
< elf_header
.e_phnum
;
2680 i
++, internal
++, external
++)
2682 internal
->p_type
= BYTE_GET (external
->p_type
);
2683 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2684 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2685 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2686 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2687 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2688 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2689 internal
->p_align
= BYTE_GET (external
->p_align
);
2698 get_64bit_program_headers (file
, program_headers
)
2700 Elf_Internal_Phdr
* program_headers
;
2702 Elf64_External_Phdr
* phdrs
;
2703 Elf64_External_Phdr
* external
;
2704 Elf64_Internal_Phdr
* internal
;
2707 phdrs
= ((Elf64_External_Phdr
*)
2708 get_data (NULL
, file
, elf_header
.e_phoff
,
2709 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2710 _("program headers")));
2714 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2715 i
< elf_header
.e_phnum
;
2716 i
++, internal
++, external
++)
2718 internal
->p_type
= BYTE_GET (external
->p_type
);
2719 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2720 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2721 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2722 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2723 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2724 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2725 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2734 process_program_headers (file
)
2737 Elf_Internal_Phdr
* program_headers
;
2738 Elf_Internal_Phdr
* segment
;
2741 if (elf_header
.e_phnum
== 0)
2744 printf (_("\nThere are no program headers in this file.\n"));
2748 if (do_segments
&& !do_header
)
2750 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2751 printf (_("Entry point "));
2752 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2753 printf (_("\nThere are %d program headers, starting at offset "),
2754 elf_header
.e_phnum
);
2755 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2759 program_headers
= (Elf_Internal_Phdr
*) malloc
2760 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2762 if (program_headers
== NULL
)
2764 error (_("Out of memory\n"));
2769 i
= get_32bit_program_headers (file
, program_headers
);
2771 i
= get_64bit_program_headers (file
, program_headers
);
2775 free (program_headers
);
2781 if (elf_header
.e_phnum
> 1)
2782 printf (_("\nProgram Headers:\n"));
2784 printf (_("\nProgram Headers:\n"));
2788 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2791 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2795 (_(" Type Offset VirtAddr PhysAddr\n"));
2797 (_(" FileSiz MemSiz Flags Align\n"));
2805 for (i
= 0, segment
= program_headers
;
2806 i
< elf_header
.e_phnum
;
2811 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2815 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2816 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2817 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2818 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2819 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2821 (segment
->p_flags
& PF_R
? 'R' : ' '),
2822 (segment
->p_flags
& PF_W
? 'W' : ' '),
2823 (segment
->p_flags
& PF_X
? 'E' : ' '));
2824 printf ("%#lx", (unsigned long) segment
->p_align
);
2828 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2829 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2832 print_vma (segment
->p_offset
, FULL_HEX
);
2836 print_vma (segment
->p_vaddr
, FULL_HEX
);
2838 print_vma (segment
->p_paddr
, FULL_HEX
);
2841 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
2842 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
2845 print_vma (segment
->p_filesz
, FULL_HEX
);
2849 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
2850 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
2853 print_vma (segment
->p_offset
, FULL_HEX
);
2857 (segment
->p_flags
& PF_R
? 'R' : ' '),
2858 (segment
->p_flags
& PF_W
? 'W' : ' '),
2859 (segment
->p_flags
& PF_X
? 'E' : ' '));
2861 if ((unsigned long) segment
->p_align
== segment
->p_align
)
2862 printf ("%#lx", (unsigned long) segment
->p_align
);
2865 print_vma (segment
->p_align
, PREFIX_HEX
);
2870 print_vma (segment
->p_offset
, FULL_HEX
);
2872 print_vma (segment
->p_vaddr
, FULL_HEX
);
2874 print_vma (segment
->p_paddr
, FULL_HEX
);
2876 print_vma (segment
->p_filesz
, FULL_HEX
);
2878 print_vma (segment
->p_memsz
, FULL_HEX
);
2880 (segment
->p_flags
& PF_R
? 'R' : ' '),
2881 (segment
->p_flags
& PF_W
? 'W' : ' '),
2882 (segment
->p_flags
& PF_X
? 'E' : ' '));
2883 print_vma (segment
->p_align
, HEX
);
2887 switch (segment
->p_type
)
2891 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2892 - (segment
->p_offset
& 0xfffff000);
2897 error (_("more than one dynamic segment\n"));
2899 dynamic_addr
= segment
->p_offset
;
2900 dynamic_size
= segment
->p_filesz
;
2904 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2905 error (_("Unable to find program interpreter name\n"));
2908 program_interpreter
[0] = 0;
2909 fscanf (file
, "%63s", program_interpreter
);
2912 printf (_("\n [Requesting program interpreter: %s]"),
2913 program_interpreter
);
2919 putc ('\n', stdout
);
2928 if (do_segments
&& section_headers
!= NULL
)
2930 printf (_("\n Section to Segment mapping:\n"));
2931 printf (_(" Segment Sections...\n"));
2933 assert (string_table
!= NULL
);
2935 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2938 Elf_Internal_Shdr
* section
;
2940 segment
= program_headers
+ i
;
2941 section
= section_headers
;
2943 printf (" %2.2d ", i
);
2945 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
2947 if (section
->sh_size
> 0
2948 /* Compare allocated sections by VMA, unallocated
2949 sections by file offset. */
2950 && (section
->sh_flags
& SHF_ALLOC
2951 ? (section
->sh_addr
>= segment
->p_vaddr
2952 && section
->sh_addr
+ section
->sh_size
2953 <= segment
->p_vaddr
+ segment
->p_memsz
)
2954 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2955 && (section
->sh_offset
+ section
->sh_size
2956 <= segment
->p_offset
+ segment
->p_filesz
))))
2957 printf ("%s ", SECTION_NAME (section
));
2964 free (program_headers
);
2971 get_32bit_section_headers (file
, num
)
2975 Elf32_External_Shdr
* shdrs
;
2976 Elf32_Internal_Shdr
* internal
;
2979 shdrs
= ((Elf32_External_Shdr
*)
2980 get_data (NULL
, file
, elf_header
.e_shoff
,
2981 elf_header
.e_shentsize
* num
,
2982 _("section headers")));
2986 section_headers
= ((Elf_Internal_Shdr
*)
2987 malloc (num
* sizeof (Elf_Internal_Shdr
)));
2989 if (section_headers
== NULL
)
2991 error (_("Out of memory\n"));
2995 for (i
= 0, internal
= section_headers
;
2999 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3000 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3001 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3002 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3003 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3004 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3005 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3006 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3007 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3008 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3017 get_64bit_section_headers (file
, num
)
3021 Elf64_External_Shdr
* shdrs
;
3022 Elf64_Internal_Shdr
* internal
;
3025 shdrs
= ((Elf64_External_Shdr
*)
3026 get_data (NULL
, file
, elf_header
.e_shoff
,
3027 elf_header
.e_shentsize
* num
,
3028 _("section headers")));
3032 section_headers
= ((Elf_Internal_Shdr
*)
3033 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3035 if (section_headers
== NULL
)
3037 error (_("Out of memory\n"));
3041 for (i
= 0, internal
= section_headers
;
3045 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3046 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3047 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3048 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3049 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3050 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3051 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3052 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3053 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3054 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3062 static Elf_Internal_Sym
*
3063 get_32bit_elf_symbols (file
, section
)
3065 Elf_Internal_Shdr
*section
;
3067 unsigned long number
;
3068 Elf32_External_Sym
* esyms
;
3069 Elf_External_Sym_Shndx
*shndx
;
3070 Elf_Internal_Sym
* isyms
;
3071 Elf_Internal_Sym
* psym
;
3074 esyms
= ((Elf32_External_Sym
*)
3075 get_data (NULL
, file
, section
->sh_offset
,
3076 section
->sh_size
, _("symbols")));
3081 if (symtab_shndx_hdr
!= NULL
3082 && (symtab_shndx_hdr
->sh_link
3083 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3085 shndx
= ((Elf_External_Sym_Shndx
*)
3086 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3087 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3095 number
= section
->sh_size
/ section
->sh_entsize
;
3096 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3100 error (_("Out of memory\n"));
3107 for (j
= 0, psym
= isyms
;
3111 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3112 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3113 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3114 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3115 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3117 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3118 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3119 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3129 static Elf_Internal_Sym
*
3130 get_64bit_elf_symbols (file
, section
)
3132 Elf_Internal_Shdr
*section
;
3134 unsigned long number
;
3135 Elf64_External_Sym
* esyms
;
3136 Elf_External_Sym_Shndx
*shndx
;
3137 Elf_Internal_Sym
* isyms
;
3138 Elf_Internal_Sym
* psym
;
3141 esyms
= ((Elf64_External_Sym
*)
3142 get_data (NULL
, file
, section
->sh_offset
,
3143 section
->sh_size
, _("symbols")));
3148 if (symtab_shndx_hdr
!= NULL
3149 && (symtab_shndx_hdr
->sh_link
3150 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3152 shndx
= ((Elf_External_Sym_Shndx
*)
3153 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3154 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3162 number
= section
->sh_size
/ section
->sh_entsize
;
3163 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3167 error (_("Out of memory\n"));
3174 for (j
= 0, psym
= isyms
;
3178 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3179 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3180 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3181 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3182 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3184 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3185 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3186 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3197 get_elf_section_flags (sh_flags
)
3200 static char buff
[32];
3208 flag
= sh_flags
& - sh_flags
;
3213 case SHF_WRITE
: strcat (buff
, "W"); break;
3214 case SHF_ALLOC
: strcat (buff
, "A"); break;
3215 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3216 case SHF_MERGE
: strcat (buff
, "M"); break;
3217 case SHF_STRINGS
: strcat (buff
, "S"); break;
3218 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3219 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3220 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3221 case SHF_GROUP
: strcat (buff
, "G"); break;
3222 case SHF_TLS
: strcat (buff
, "T"); break;
3225 if (flag
& SHF_MASKOS
)
3228 sh_flags
&= ~ SHF_MASKOS
;
3230 else if (flag
& SHF_MASKPROC
)
3233 sh_flags
&= ~ SHF_MASKPROC
;
3245 process_section_headers (file
)
3248 Elf_Internal_Shdr
* section
;
3251 section_headers
= NULL
;
3253 if (elf_header
.e_shnum
== 0)
3256 printf (_("\nThere are no sections in this file.\n"));
3261 if (do_sections
&& !do_header
)
3262 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3263 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3267 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3270 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3273 /* Read in the string table, so that we have names to display. */
3274 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3276 if (section
->sh_size
!= 0)
3278 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3279 section
->sh_size
, _("string table"));
3281 string_table_length
= section
->sh_size
;
3284 /* Scan the sections for the dynamic symbol table
3285 and dynamic string table and debug sections. */
3286 dynamic_symbols
= NULL
;
3287 dynamic_strings
= NULL
;
3288 dynamic_syminfo
= NULL
;
3290 for (i
= 0, section
= section_headers
;
3291 i
< elf_header
.e_shnum
;
3294 char * name
= SECTION_NAME (section
);
3296 if (section
->sh_type
== SHT_DYNSYM
)
3298 if (dynamic_symbols
!= NULL
)
3300 error (_("File contains multiple dynamic symbol tables\n"));
3304 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3305 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3307 else if (section
->sh_type
== SHT_STRTAB
3308 && strcmp (name
, ".dynstr") == 0)
3310 if (dynamic_strings
!= NULL
)
3312 error (_("File contains multiple dynamic string tables\n"));
3316 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3318 _("dynamic strings"));
3320 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3322 if (symtab_shndx_hdr
!= NULL
)
3324 error (_("File contains multiple symtab shndx tables\n"));
3327 symtab_shndx_hdr
= section
;
3329 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3330 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3331 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3333 && strncmp (name
, ".debug_", 7) == 0)
3338 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3339 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3340 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3341 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3342 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3343 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3344 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3345 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3346 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3348 request_dump (i
, DEBUG_DUMP
);
3350 /* linkonce section to be combined with .debug_info at link time. */
3351 else if ((do_debugging
|| do_debug_info
)
3352 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3353 request_dump (i
, DEBUG_DUMP
);
3354 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3355 request_dump (i
, DEBUG_DUMP
);
3361 if (elf_header
.e_shnum
> 1)
3362 printf (_("\nSection Headers:\n"));
3364 printf (_("\nSection Header:\n"));
3368 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3371 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3374 printf (_(" [Nr] Name Type Address Offset\n"));
3375 printf (_(" Size EntSize Flags Link Info Align\n"));
3378 for (i
= 0, section
= section_headers
;
3379 i
< elf_header
.e_shnum
;
3382 printf (" [%2u] %-17.17s %-15.15s ",
3383 SECTION_HEADER_NUM (i
),
3384 SECTION_NAME (section
),
3385 get_section_type_name (section
->sh_type
));
3389 print_vma (section
->sh_addr
, LONG_HEX
);
3391 printf ( " %6.6lx %6.6lx %2.2lx",
3392 (unsigned long) section
->sh_offset
,
3393 (unsigned long) section
->sh_size
,
3394 (unsigned long) section
->sh_entsize
);
3396 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3398 printf ("%2ld %3lx %2ld\n",
3399 (unsigned long) section
->sh_link
,
3400 (unsigned long) section
->sh_info
,
3401 (unsigned long) section
->sh_addralign
);
3405 print_vma (section
->sh_addr
, LONG_HEX
);
3407 if ((long) section
->sh_offset
== section
->sh_offset
)
3408 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3412 print_vma (section
->sh_offset
, LONG_HEX
);
3415 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3416 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3420 print_vma (section
->sh_size
, LONG_HEX
);
3423 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3424 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3428 print_vma (section
->sh_entsize
, LONG_HEX
);
3431 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3433 printf ("%2ld %3lx ",
3434 (unsigned long) section
->sh_link
,
3435 (unsigned long) section
->sh_info
);
3437 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3438 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3441 print_vma (section
->sh_addralign
, DEC
);
3448 print_vma (section
->sh_addr
, LONG_HEX
);
3449 if ((long) section
->sh_offset
== section
->sh_offset
)
3450 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3454 print_vma (section
->sh_offset
, LONG_HEX
);
3457 print_vma (section
->sh_size
, LONG_HEX
);
3459 print_vma (section
->sh_entsize
, LONG_HEX
);
3461 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3463 printf (" %2ld %3lx %ld\n",
3464 (unsigned long) section
->sh_link
,
3465 (unsigned long) section
->sh_info
,
3466 (unsigned long) section
->sh_addralign
);
3470 printf (_("Key to Flags:\n\
3471 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3472 I (info), L (link order), G (group), x (unknown)\n\
3473 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3478 /* Process the reloc section. */
3480 process_relocs (file
)
3483 unsigned long rel_size
;
3484 unsigned long rel_offset
;
3490 if (do_using_dynamic
)
3492 int is_rela
= FALSE
;
3497 if (dynamic_info
[DT_REL
])
3499 rel_offset
= dynamic_info
[DT_REL
];
3500 rel_size
= dynamic_info
[DT_RELSZ
];
3503 else if (dynamic_info
[DT_RELA
])
3505 rel_offset
= dynamic_info
[DT_RELA
];
3506 rel_size
= dynamic_info
[DT_RELASZ
];
3509 else if (dynamic_info
[DT_JMPREL
])
3511 rel_offset
= dynamic_info
[DT_JMPREL
];
3512 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3514 switch (dynamic_info
[DT_PLTREL
])
3531 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3532 rel_offset
, rel_size
);
3534 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3535 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3538 printf (_("\nThere are no dynamic relocations in this file.\n"));
3542 Elf32_Internal_Shdr
* section
;
3546 for (i
= 0, section
= section_headers
;
3547 i
< elf_header
.e_shnum
;
3550 if ( section
->sh_type
!= SHT_RELA
3551 && section
->sh_type
!= SHT_REL
)
3554 rel_offset
= section
->sh_offset
;
3555 rel_size
= section
->sh_size
;
3559 Elf32_Internal_Shdr
* strsec
;
3560 Elf_Internal_Sym
* symtab
;
3563 unsigned long nsyms
;
3565 printf (_("\nRelocation section "));
3567 if (string_table
== NULL
)
3568 printf ("%d", section
->sh_name
);
3570 printf (_("'%s'"), SECTION_NAME (section
));
3572 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3573 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3578 if (section
->sh_link
)
3580 Elf32_Internal_Shdr
* symsec
;
3582 symsec
= SECTION_HEADER (section
->sh_link
);
3583 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3584 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3589 strsec
= SECTION_HEADER (symsec
->sh_link
);
3591 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3595 is_rela
= section
->sh_type
== SHT_RELA
;
3597 dump_relocations (file
, rel_offset
, rel_size
,
3598 symtab
, nsyms
, strtab
, is_rela
);
3610 printf (_("\nThere are no relocations in this file.\n"));
3616 #include "unwind-ia64.h"
3618 /* An absolute address consists of a section and an offset. If the
3619 section is NULL, the offset itself is the address, otherwise, the
3620 address equals to LOAD_ADDRESS(section) + offset. */
3624 unsigned short section
;
3630 struct unw_table_entry
3632 struct absaddr start
;
3634 struct absaddr info
;
3636 *table
; /* Unwind table. */
3637 unsigned long table_len
; /* Length of unwind table. */
3638 unsigned char * info
; /* Unwind info. */
3639 unsigned long info_size
; /* Size of unwind info. */
3640 bfd_vma info_addr
; /* starting address of unwind info. */
3641 bfd_vma seg_base
; /* Starting address of segment. */
3642 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3643 unsigned long nsyms
; /* Number of symbols. */
3644 char * strtab
; /* The string table. */
3645 unsigned long strtab_size
; /* Size of string table. */
3648 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3649 struct absaddr
, const char **,
3651 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3652 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3653 Elf32_Internal_Shdr
*));
3656 find_symbol_for_address (aux
, addr
, symname
, offset
)
3657 struct unw_aux_info
*aux
;
3658 struct absaddr addr
;
3659 const char **symname
;
3662 bfd_vma dist
= (bfd_vma
) 0x100000;
3663 Elf_Internal_Sym
*sym
, *best
= NULL
;
3666 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3668 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3669 && sym
->st_name
!= 0
3670 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3671 && addr
.offset
>= sym
->st_value
3672 && addr
.offset
- sym
->st_value
< dist
)
3675 dist
= addr
.offset
- sym
->st_value
;
3682 *symname
= (best
->st_name
>= aux
->strtab_size
3683 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3688 *offset
= addr
.offset
;
3692 dump_ia64_unwind (aux
)
3693 struct unw_aux_info
*aux
;
3696 struct unw_table_entry
* tp
;
3699 addr_size
= is_32bit_elf
? 4 : 8;
3701 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3705 const unsigned char * dp
;
3706 const unsigned char * head
;
3707 const char * procname
;
3709 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3711 fputs ("\n<", stdout
);
3715 fputs (procname
, stdout
);
3718 printf ("+%lx", (unsigned long) offset
);
3721 fputs (">: [", stdout
);
3722 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3723 fputc ('-', stdout
);
3724 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3725 printf ("), info at +0x%lx\n",
3726 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3728 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3729 stamp
= BYTE_GET8 ((unsigned char *) head
);
3731 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3732 (unsigned) UNW_VER (stamp
),
3733 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3734 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3735 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3736 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3738 if (UNW_VER (stamp
) != 1)
3740 printf ("\tUnknown version.\n");
3745 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3746 dp
= unw_decode (dp
, in_body
, & in_body
);
3751 slurp_ia64_unwind_table (file
, aux
, sec
)
3753 struct unw_aux_info
*aux
;
3754 Elf32_Internal_Shdr
*sec
;
3756 unsigned long size
, addr_size
, nrelas
, i
;
3757 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3758 struct unw_table_entry
*tep
;
3759 Elf32_Internal_Shdr
*relsec
;
3760 Elf_Internal_Rela
*rela
, *rp
;
3761 unsigned char *table
, *tp
;
3762 Elf_Internal_Sym
*sym
;
3763 const char *relname
;
3766 addr_size
= is_32bit_elf
? 4 : 8;
3768 /* First, find the starting address of the segment that includes
3771 if (elf_header
.e_phnum
)
3773 prog_hdrs
= (Elf_Internal_Phdr
*)
3774 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3777 result
= get_32bit_program_headers (file
, prog_hdrs
);
3779 result
= get_64bit_program_headers (file
, prog_hdrs
);
3787 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3789 if (seg
->p_type
!= PT_LOAD
)
3792 if (sec
->sh_addr
>= seg
->p_vaddr
3793 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3795 aux
->seg_base
= seg
->p_vaddr
;
3803 /* Second, build the unwind table from the contents of the unwind section: */
3804 size
= sec
->sh_size
;
3805 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3806 size
, _("unwind table"));
3810 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3811 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3813 tep
->start
.section
= SHN_UNDEF
;
3814 tep
->end
.section
= SHN_UNDEF
;
3815 tep
->info
.section
= SHN_UNDEF
;
3818 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3819 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3820 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3824 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3825 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3826 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3828 tep
->start
.offset
+= aux
->seg_base
;
3829 tep
->end
.offset
+= aux
->seg_base
;
3830 tep
->info
.offset
+= aux
->seg_base
;
3834 /* Third, apply any relocations to the unwind table: */
3836 for (relsec
= section_headers
;
3837 relsec
< section_headers
+ elf_header
.e_shnum
;
3840 if (relsec
->sh_type
!= SHT_RELA
3841 || SECTION_HEADER (relsec
->sh_info
) != sec
)
3844 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3848 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3852 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3853 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3855 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3857 warn (_("Skipping unexpected symbol type %u\n"),
3858 ELF32_ST_TYPE (sym
->st_info
));
3864 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3865 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3867 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3869 warn (_("Skipping unexpected symbol type %u\n"),
3870 ELF64_ST_TYPE (sym
->st_info
));
3875 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
3877 warn (_("Skipping unexpected relocation type %s\n"), relname
);
3881 i
= rp
->r_offset
/ (3 * addr_size
);
3883 switch (rp
->r_offset
/addr_size
% 3)
3886 aux
->table
[i
].start
.section
= sym
->st_shndx
;
3887 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
3890 aux
->table
[i
].end
.section
= sym
->st_shndx
;
3891 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
3894 aux
->table
[i
].info
.section
= sym
->st_shndx
;
3895 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
3905 aux
->table_len
= size
/ (3 * addr_size
);
3910 process_unwind (file
)
3913 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
3914 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
3915 struct unw_aux_info aux
;
3920 if (elf_header
.e_machine
!= EM_IA_64
)
3922 printf (_("\nThere are no unwind sections in this file.\n"));
3926 memset (& aux
, 0, sizeof (aux
));
3928 addr_size
= is_32bit_elf
? 4 : 8;
3930 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
3932 if (sec
->sh_type
== SHT_SYMTAB
)
3934 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
3935 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
3937 strsec
= SECTION_HEADER (sec
->sh_link
);
3938 aux
.strtab_size
= strsec
->sh_size
;
3939 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3940 aux
.strtab_size
, _("string table"));
3942 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3947 printf (_("\nThere are no unwind sections in this file.\n"));
3949 while (unwcount
-- > 0)
3954 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
3955 i
< elf_header
.e_shnum
; ++i
, ++sec
)
3956 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3963 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
3965 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
3968 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3969 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
3970 suffix
= SECTION_NAME (unwsec
) + len
;
3971 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3973 if (strncmp (SECTION_NAME (sec
),
3974 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
3975 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3980 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3981 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3982 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
3983 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
3985 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
3987 suffix
= SECTION_NAME (unwsec
) + len
;
3988 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3990 if (strncmp (SECTION_NAME (sec
),
3991 ELF_STRING_ia64_unwind_info
, len2
) == 0
3992 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3996 if (i
== elf_header
.e_shnum
)
3998 printf (_("\nCould not find unwind info section for "));
4000 if (string_table
== NULL
)
4001 printf ("%d", unwsec
->sh_name
);
4003 printf (_("'%s'"), SECTION_NAME (unwsec
));
4007 aux
.info_size
= sec
->sh_size
;
4008 aux
.info_addr
= sec
->sh_addr
;
4009 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4010 aux
.info_size
, _("unwind info"));
4012 printf (_("\nUnwind section "));
4014 if (string_table
== NULL
)
4015 printf ("%d", unwsec
->sh_name
);
4017 printf (_("'%s'"), SECTION_NAME (unwsec
));
4019 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4020 (unsigned long) unwsec
->sh_offset
,
4021 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4023 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4025 if (aux
.table_len
> 0)
4026 dump_ia64_unwind (& aux
);
4029 free ((char *) aux
.table
);
4031 free ((char *) aux
.info
);
4040 free ((char *) aux
.strtab
);
4046 dynamic_segment_mips_val (entry
)
4047 Elf_Internal_Dyn
* entry
;
4049 switch (entry
->d_tag
)
4052 if (entry
->d_un
.d_val
== 0)
4056 static const char * opts
[] =
4058 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4059 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4060 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4061 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4066 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
4067 if (entry
->d_un
.d_val
& (1 << cnt
))
4069 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4076 case DT_MIPS_IVERSION
:
4077 if (dynamic_strings
!= NULL
)
4078 printf ("Interface Version: %s\n",
4079 dynamic_strings
+ entry
->d_un
.d_val
);
4081 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4084 case DT_MIPS_TIME_STAMP
:
4089 time_t time
= entry
->d_un
.d_val
;
4090 tmp
= gmtime (&time
);
4091 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4092 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4093 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4094 printf ("Time Stamp: %s\n", timebuf
);
4098 case DT_MIPS_RLD_VERSION
:
4099 case DT_MIPS_LOCAL_GOTNO
:
4100 case DT_MIPS_CONFLICTNO
:
4101 case DT_MIPS_LIBLISTNO
:
4102 case DT_MIPS_SYMTABNO
:
4103 case DT_MIPS_UNREFEXTNO
:
4104 case DT_MIPS_HIPAGENO
:
4105 case DT_MIPS_DELTA_CLASS_NO
:
4106 case DT_MIPS_DELTA_INSTANCE_NO
:
4107 case DT_MIPS_DELTA_RELOC_NO
:
4108 case DT_MIPS_DELTA_SYM_NO
:
4109 case DT_MIPS_DELTA_CLASSSYM_NO
:
4110 case DT_MIPS_COMPACT_SIZE
:
4111 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4115 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4121 dynamic_segment_parisc_val (entry
)
4122 Elf_Internal_Dyn
* entry
;
4124 switch (entry
->d_tag
)
4126 case DT_HP_DLD_FLAGS
:
4135 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4136 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4137 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4138 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4139 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4140 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4141 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4142 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4143 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4144 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4145 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4149 bfd_vma val
= entry
->d_un
.d_val
;
4151 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4152 if (val
& flags
[cnt
].bit
)
4156 fputs (flags
[cnt
].str
, stdout
);
4158 val
^= flags
[cnt
].bit
;
4161 if (val
!= 0 || first
)
4165 print_vma (val
, HEX
);
4171 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4177 get_32bit_dynamic_segment (file
)
4180 Elf32_External_Dyn
* edyn
;
4181 Elf_Internal_Dyn
* entry
;
4184 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4185 dynamic_size
, _("dynamic segment"));
4189 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4190 how large this .dynamic is now. We can do this even before the byte
4191 swapping since the DT_NULL tag is recognizable. */
4193 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4196 dynamic_segment
= (Elf_Internal_Dyn
*)
4197 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4199 if (dynamic_segment
== NULL
)
4201 error (_("Out of memory\n"));
4206 for (i
= 0, entry
= dynamic_segment
;
4210 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4211 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4220 get_64bit_dynamic_segment (file
)
4223 Elf64_External_Dyn
* edyn
;
4224 Elf_Internal_Dyn
* entry
;
4227 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4228 dynamic_size
, _("dynamic segment"));
4232 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4233 how large this .dynamic is now. We can do this even before the byte
4234 swapping since the DT_NULL tag is recognizable. */
4236 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4239 dynamic_segment
= (Elf_Internal_Dyn
*)
4240 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4242 if (dynamic_segment
== NULL
)
4244 error (_("Out of memory\n"));
4249 for (i
= 0, entry
= dynamic_segment
;
4253 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4254 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4263 get_dynamic_flags (flags
)
4266 static char buff
[128];
4274 flag
= flags
& - flags
;
4282 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4283 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4284 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4285 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4286 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4287 default: strcpy (p
, "unknown"); break;
4290 p
= strchr (p
, '\0');
4295 /* Parse and display the contents of the dynamic segment. */
4297 process_dynamic_segment (file
)
4300 Elf_Internal_Dyn
* entry
;
4303 if (dynamic_size
== 0)
4306 printf (_("\nThere is no dynamic segment in this file.\n"));
4313 if (! get_32bit_dynamic_segment (file
))
4316 else if (! get_64bit_dynamic_segment (file
))
4319 /* Find the appropriate symbol table. */
4320 if (dynamic_symbols
== NULL
)
4322 for (i
= 0, entry
= dynamic_segment
;
4326 Elf32_Internal_Shdr section
;
4328 if (entry
->d_tag
!= DT_SYMTAB
)
4331 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4333 /* Since we do not know how big the symbol table is,
4334 we default to reading in the entire file (!) and
4335 processing that. This is overkill, I know, but it
4337 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4339 if (fseek (file
, 0, SEEK_END
))
4340 error (_("Unable to seek to end of file!"));
4342 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4344 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4346 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4348 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4349 if (num_dynamic_syms
< 1)
4351 error (_("Unable to determine the number of symbols to load\n"));
4355 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4359 /* Similarly find a string table. */
4360 if (dynamic_strings
== NULL
)
4362 for (i
= 0, entry
= dynamic_segment
;
4366 unsigned long offset
;
4369 if (entry
->d_tag
!= DT_STRTAB
)
4372 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4374 /* Since we do not know how big the string table is,
4375 we default to reading in the entire file (!) and
4376 processing that. This is overkill, I know, but it
4379 offset
= entry
->d_un
.d_val
- loadaddr
;
4380 if (fseek (file
, 0, SEEK_END
))
4381 error (_("Unable to seek to end of file\n"));
4382 str_tab_len
= ftell (file
) - offset
;
4384 if (str_tab_len
< 1)
4387 (_("Unable to determine the length of the dynamic string table\n"));
4391 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4392 _("dynamic string table"));
4397 /* And find the syminfo section if available. */
4398 if (dynamic_syminfo
== NULL
)
4400 unsigned int syminsz
= 0;
4402 for (i
= 0, entry
= dynamic_segment
;
4406 if (entry
->d_tag
== DT_SYMINENT
)
4408 /* Note: these braces are necessary to avoid a syntax
4409 error from the SunOS4 C compiler. */
4410 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4412 else if (entry
->d_tag
== DT_SYMINSZ
)
4413 syminsz
= entry
->d_un
.d_val
;
4414 else if (entry
->d_tag
== DT_SYMINFO
)
4415 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4418 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4420 Elf_External_Syminfo
* extsyminfo
;
4421 Elf_Internal_Syminfo
* syminfo
;
4423 /* There is a syminfo section. Read the data. */
4424 extsyminfo
= ((Elf_External_Syminfo
*)
4425 get_data (NULL
, file
, dynamic_syminfo_offset
,
4426 syminsz
, _("symbol information")));
4430 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4431 if (dynamic_syminfo
== NULL
)
4433 error (_("Out of memory\n"));
4437 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4438 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4441 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4442 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4449 if (do_dynamic
&& dynamic_addr
)
4450 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4451 dynamic_addr
, (long) dynamic_size
);
4453 printf (_(" Tag Type Name/Value\n"));
4455 for (i
= 0, entry
= dynamic_segment
;
4464 print_vma (entry
->d_tag
, FULL_HEX
);
4465 dtype
= get_dynamic_type (entry
->d_tag
);
4466 printf (" (%s)%*s", dtype
,
4467 ((is_32bit_elf
? 27 : 19)
4468 - (int) strlen (dtype
)),
4472 switch (entry
->d_tag
)
4476 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4486 switch (entry
->d_tag
)
4489 printf (_("Auxiliary library"));
4493 printf (_("Filter library"));
4497 printf (_("Configuration file"));
4501 printf (_("Dependency audit library"));
4505 printf (_("Audit library"));
4509 if (dynamic_strings
)
4510 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4514 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4523 printf (_("Flags:"));
4524 if (entry
->d_un
.d_val
== 0)
4525 printf (_(" None\n"));
4528 unsigned long int val
= entry
->d_un
.d_val
;
4529 if (val
& DTF_1_PARINIT
)
4531 printf (" PARINIT");
4532 val
^= DTF_1_PARINIT
;
4534 if (val
& DTF_1_CONFEXP
)
4536 printf (" CONFEXP");
4537 val
^= DTF_1_CONFEXP
;
4540 printf (" %lx", val
);
4549 printf (_("Flags:"));
4550 if (entry
->d_un
.d_val
== 0)
4551 printf (_(" None\n"));
4554 unsigned long int val
= entry
->d_un
.d_val
;
4555 if (val
& DF_P1_LAZYLOAD
)
4557 printf (" LAZYLOAD");
4558 val
^= DF_P1_LAZYLOAD
;
4560 if (val
& DF_P1_GROUPPERM
)
4562 printf (" GROUPPERM");
4563 val
^= DF_P1_GROUPPERM
;
4566 printf (" %lx", val
);
4575 printf (_("Flags:"));
4576 if (entry
->d_un
.d_val
== 0)
4577 printf (_(" None\n"));
4580 unsigned long int val
= entry
->d_un
.d_val
;
4586 if (val
& DF_1_GLOBAL
)
4591 if (val
& DF_1_GROUP
)
4596 if (val
& DF_1_NODELETE
)
4598 printf (" NODELETE");
4599 val
^= DF_1_NODELETE
;
4601 if (val
& DF_1_LOADFLTR
)
4603 printf (" LOADFLTR");
4604 val
^= DF_1_LOADFLTR
;
4606 if (val
& DF_1_INITFIRST
)
4608 printf (" INITFIRST");
4609 val
^= DF_1_INITFIRST
;
4611 if (val
& DF_1_NOOPEN
)
4616 if (val
& DF_1_ORIGIN
)
4621 if (val
& DF_1_DIRECT
)
4626 if (val
& DF_1_TRANS
)
4631 if (val
& DF_1_INTERPOSE
)
4633 printf (" INTERPOSE");
4634 val
^= DF_1_INTERPOSE
;
4636 if (val
& DF_1_NODEFLIB
)
4638 printf (" NODEFLIB");
4639 val
^= DF_1_NODEFLIB
;
4641 if (val
& DF_1_NODUMP
)
4646 if (val
& DF_1_CONLFAT
)
4648 printf (" CONLFAT");
4649 val
^= DF_1_CONLFAT
;
4652 printf (" %lx", val
);
4660 puts (get_dynamic_type (entry
->d_un
.d_val
));
4680 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4686 if (dynamic_strings
== NULL
)
4689 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4693 switch (entry
->d_tag
)
4696 printf (_("Shared library: [%s]"), name
);
4698 if (strcmp (name
, program_interpreter
) == 0)
4699 printf (_(" program interpreter"));
4703 printf (_("Library soname: [%s]"), name
);
4707 printf (_("Library rpath: [%s]"), name
);
4711 printf (_("Library runpath: [%s]"), name
);
4715 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4720 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4736 case DT_INIT_ARRAYSZ
:
4737 case DT_FINI_ARRAYSZ
:
4740 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4741 printf (" (bytes)\n");
4751 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4764 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4768 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4772 printf (_("Not needed object: [%s]\n"), name
);
4777 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4783 /* The value of this entry is ignored. */
4787 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4788 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4793 switch (elf_header
.e_machine
)
4796 case EM_MIPS_RS3_LE
:
4797 dynamic_segment_mips_val (entry
);
4800 dynamic_segment_parisc_val (entry
);
4803 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4815 get_ver_flags (flags
)
4818 static char buff
[32];
4825 if (flags
& VER_FLG_BASE
)
4826 strcat (buff
, "BASE ");
4828 if (flags
& VER_FLG_WEAK
)
4830 if (flags
& VER_FLG_BASE
)
4831 strcat (buff
, "| ");
4833 strcat (buff
, "WEAK ");
4836 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4837 strcat (buff
, "| <unknown>");
4842 /* Display the contents of the version sections. */
4844 process_version_sections (file
)
4847 Elf32_Internal_Shdr
* section
;
4854 for (i
= 0, section
= section_headers
;
4855 i
< elf_header
.e_shnum
;
4858 switch (section
->sh_type
)
4860 case SHT_GNU_verdef
:
4862 Elf_External_Verdef
* edefs
;
4869 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4870 SECTION_NAME (section
), section
->sh_info
);
4872 printf (_(" Addr: 0x"));
4873 printf_vma (section
->sh_addr
);
4874 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4875 (unsigned long) section
->sh_offset
, section
->sh_link
,
4876 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
4878 edefs
= ((Elf_External_Verdef
*)
4879 get_data (NULL
, file
, section
->sh_offset
,
4881 _("version definition section")));
4885 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
4888 Elf_External_Verdef
* edef
;
4889 Elf_Internal_Verdef ent
;
4890 Elf_External_Verdaux
* eaux
;
4891 Elf_Internal_Verdaux aux
;
4895 vstart
= ((char *) edefs
) + idx
;
4897 edef
= (Elf_External_Verdef
*) vstart
;
4899 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
4900 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
4901 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
4902 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
4903 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
4904 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
4905 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
4907 printf (_(" %#06x: Rev: %d Flags: %s"),
4908 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
4910 printf (_(" Index: %d Cnt: %d "),
4911 ent
.vd_ndx
, ent
.vd_cnt
);
4913 vstart
+= ent
.vd_aux
;
4915 eaux
= (Elf_External_Verdaux
*) vstart
;
4917 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4918 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4920 if (dynamic_strings
)
4921 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
4923 printf (_("Name index: %ld\n"), aux
.vda_name
);
4925 isum
= idx
+ ent
.vd_aux
;
4927 for (j
= 1; j
< ent
.vd_cnt
; j
++)
4929 isum
+= aux
.vda_next
;
4930 vstart
+= aux
.vda_next
;
4932 eaux
= (Elf_External_Verdaux
*) vstart
;
4934 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4935 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4937 if (dynamic_strings
)
4938 printf (_(" %#06x: Parent %d: %s\n"),
4939 isum
, j
, dynamic_strings
+ aux
.vda_name
);
4941 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4942 isum
, j
, aux
.vda_name
);
4952 case SHT_GNU_verneed
:
4954 Elf_External_Verneed
* eneed
;
4960 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4961 SECTION_NAME (section
), section
->sh_info
);
4963 printf (_(" Addr: 0x"));
4964 printf_vma (section
->sh_addr
);
4965 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4966 (unsigned long) section
->sh_offset
, section
->sh_link
,
4967 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
4969 eneed
= ((Elf_External_Verneed
*)
4970 get_data (NULL
, file
, section
->sh_offset
,
4971 section
->sh_size
, _("version need section")));
4975 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
4977 Elf_External_Verneed
* entry
;
4978 Elf_Internal_Verneed ent
;
4983 vstart
= ((char *) eneed
) + idx
;
4985 entry
= (Elf_External_Verneed
*) vstart
;
4987 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
4988 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
4989 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
4990 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
4991 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
4993 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
4995 if (dynamic_strings
)
4996 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
4998 printf (_(" File: %lx"), ent
.vn_file
);
5000 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5002 vstart
+= ent
.vn_aux
;
5004 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5006 Elf_External_Vernaux
* eaux
;
5007 Elf_Internal_Vernaux aux
;
5009 eaux
= (Elf_External_Vernaux
*) vstart
;
5011 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5012 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5013 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5014 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5015 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5017 if (dynamic_strings
)
5018 printf (_(" %#06x: Name: %s"),
5019 isum
, dynamic_strings
+ aux
.vna_name
);
5021 printf (_(" %#06x: Name index: %lx"),
5022 isum
, aux
.vna_name
);
5024 printf (_(" Flags: %s Version: %d\n"),
5025 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5027 isum
+= aux
.vna_next
;
5028 vstart
+= aux
.vna_next
;
5038 case SHT_GNU_versym
:
5040 Elf32_Internal_Shdr
* link_section
;
5043 unsigned char * edata
;
5044 unsigned short * data
;
5046 Elf_Internal_Sym
* symbols
;
5047 Elf32_Internal_Shdr
* string_sec
;
5049 link_section
= SECTION_HEADER (section
->sh_link
);
5050 total
= section
->sh_size
/ section
->sh_entsize
;
5054 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5056 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5058 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5059 string_sec
->sh_size
,
5060 _("version string table"));
5064 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5065 SECTION_NAME (section
), total
);
5067 printf (_(" Addr: "));
5068 printf_vma (section
->sh_addr
);
5069 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5070 (unsigned long) section
->sh_offset
, section
->sh_link
,
5071 SECTION_NAME (link_section
));
5075 get_data (NULL
, file
,
5076 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5077 total
* sizeof (short), _("version symbol data")));
5084 data
= (unsigned short *) malloc (total
* sizeof (short));
5086 for (cnt
= total
; cnt
--;)
5087 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5092 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5095 int check_def
, check_need
;
5098 printf (" %03x:", cnt
);
5100 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5101 switch (data
[cnt
+ j
])
5104 fputs (_(" 0 (*local*) "), stdout
);
5108 fputs (_(" 1 (*global*) "), stdout
);
5112 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5113 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5117 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5120 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5127 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5129 Elf_Internal_Verneed ivn
;
5130 unsigned long offset
;
5132 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5137 Elf_Internal_Vernaux ivna
;
5138 Elf_External_Verneed evn
;
5139 Elf_External_Vernaux evna
;
5140 unsigned long a_off
;
5142 get_data (&evn
, file
, offset
, sizeof (evn
),
5145 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5146 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5148 a_off
= offset
+ ivn
.vn_aux
;
5152 get_data (&evna
, file
, a_off
, sizeof (evna
),
5153 _("version need aux (2)"));
5155 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5156 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5158 a_off
+= ivna
.vna_next
;
5160 while (ivna
.vna_other
!= data
[cnt
+ j
]
5161 && ivna
.vna_next
!= 0);
5163 if (ivna
.vna_other
== data
[cnt
+ j
])
5165 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5167 name
= strtab
+ ivna
.vna_name
;
5168 nn
+= printf ("(%s%-*s",
5170 12 - (int) strlen (name
),
5176 offset
+= ivn
.vn_next
;
5178 while (ivn
.vn_next
);
5181 if (check_def
&& data
[cnt
+ j
] != 0x8001
5182 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5184 Elf_Internal_Verdef ivd
;
5185 Elf_External_Verdef evd
;
5186 unsigned long offset
;
5188 offset
= version_info
5189 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
5193 get_data (&evd
, file
, offset
, sizeof (evd
),
5196 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5197 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5199 offset
+= ivd
.vd_next
;
5201 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5202 && ivd
.vd_next
!= 0);
5204 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5206 Elf_External_Verdaux evda
;
5207 Elf_Internal_Verdaux ivda
;
5209 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5211 get_data (&evda
, file
,
5212 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5213 sizeof (evda
), _("version def aux"));
5215 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5217 name
= strtab
+ ivda
.vda_name
;
5218 nn
+= printf ("(%s%-*s",
5220 12 - (int) strlen (name
),
5226 printf ("%*c", 18 - nn
, ' ');
5244 printf (_("\nNo version information found in this file.\n"));
5250 get_symbol_binding (binding
)
5251 unsigned int binding
;
5253 static char buff
[32];
5257 case STB_LOCAL
: return "LOCAL";
5258 case STB_GLOBAL
: return "GLOBAL";
5259 case STB_WEAK
: return "WEAK";
5261 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5262 sprintf (buff
, _("<processor specific>: %d"), binding
);
5263 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5264 sprintf (buff
, _("<OS specific>: %d"), binding
);
5266 sprintf (buff
, _("<unknown>: %d"), binding
);
5272 get_symbol_type (type
)
5275 static char buff
[32];
5279 case STT_NOTYPE
: return "NOTYPE";
5280 case STT_OBJECT
: return "OBJECT";
5281 case STT_FUNC
: return "FUNC";
5282 case STT_SECTION
: return "SECTION";
5283 case STT_FILE
: return "FILE";
5284 case STT_COMMON
: return "COMMON";
5285 case STT_TLS
: return "TLS";
5287 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5289 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5290 return "THUMB_FUNC";
5292 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5295 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5296 return "PARISC_MILLI";
5298 sprintf (buff
, _("<processor specific>: %d"), type
);
5300 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5302 if (elf_header
.e_machine
== EM_PARISC
)
5304 if (type
== STT_HP_OPAQUE
)
5306 if (type
== STT_HP_STUB
)
5310 sprintf (buff
, _("<OS specific>: %d"), type
);
5313 sprintf (buff
, _("<unknown>: %d"), type
);
5319 get_symbol_visibility (visibility
)
5320 unsigned int visibility
;
5324 case STV_DEFAULT
: return "DEFAULT";
5325 case STV_INTERNAL
: return "INTERNAL";
5326 case STV_HIDDEN
: return "HIDDEN";
5327 case STV_PROTECTED
: return "PROTECTED";
5333 get_symbol_index_type (type
)
5338 case SHN_UNDEF
: return "UND";
5339 case SHN_ABS
: return "ABS";
5340 case SHN_COMMON
: return "COM";
5342 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5344 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5346 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5350 static char buff
[32];
5352 sprintf (buff
, "%3d", type
);
5359 get_dynamic_data (file
, number
)
5361 unsigned int number
;
5363 unsigned char * e_data
;
5366 e_data
= (unsigned char *) malloc (number
* 4);
5370 error (_("Out of memory\n"));
5374 if (fread (e_data
, 4, number
, file
) != number
)
5376 error (_("Unable to read in dynamic data\n"));
5380 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5384 error (_("Out of memory\n"));
5390 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5397 /* Dump the symbol table. */
5399 process_symbol_table (file
)
5402 Elf32_Internal_Shdr
* section
;
5403 unsigned char nb
[4];
5404 unsigned char nc
[4];
5407 int * buckets
= NULL
;
5408 int * chains
= NULL
;
5410 if (! do_syms
&& !do_histogram
)
5413 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5416 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5418 error (_("Unable to seek to start of dynamic information"));
5422 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5424 error (_("Failed to read in number of buckets\n"));
5428 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5430 error (_("Failed to read in number of chains\n"));
5434 nbuckets
= byte_get (nb
, 4);
5435 nchains
= byte_get (nc
, 4);
5437 buckets
= get_dynamic_data (file
, nbuckets
);
5438 chains
= get_dynamic_data (file
, nchains
);
5440 if (buckets
== NULL
|| chains
== NULL
)
5445 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5450 printf (_("\nSymbol table for image:\n"));
5452 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5454 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5456 for (hn
= 0; hn
< nbuckets
; hn
++)
5461 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5463 Elf_Internal_Sym
* psym
;
5465 psym
= dynamic_symbols
+ si
;
5467 printf (" %3d %3d: ", si
, hn
);
5468 print_vma (psym
->st_value
, LONG_HEX
);
5470 print_vma (psym
->st_size
, DEC_5
);
5472 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5473 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5474 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5475 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5476 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5481 else if (do_syms
&& !do_using_dynamic
)
5485 for (i
= 0, section
= section_headers
;
5486 i
< elf_header
.e_shnum
;
5491 Elf_Internal_Sym
* symtab
;
5492 Elf_Internal_Sym
* psym
;
5495 if ( section
->sh_type
!= SHT_SYMTAB
5496 && section
->sh_type
!= SHT_DYNSYM
)
5499 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5500 SECTION_NAME (section
),
5501 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5503 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5505 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5507 symtab
= GET_ELF_SYMBOLS (file
, section
);
5511 if (section
->sh_link
== elf_header
.e_shstrndx
)
5512 strtab
= string_table
;
5515 Elf32_Internal_Shdr
* string_sec
;
5517 string_sec
= SECTION_HEADER (section
->sh_link
);
5519 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5520 string_sec
->sh_size
,
5524 for (si
= 0, psym
= symtab
;
5525 si
< section
->sh_size
/ section
->sh_entsize
;
5528 printf ("%6d: ", si
);
5529 print_vma (psym
->st_value
, LONG_HEX
);
5531 print_vma (psym
->st_size
, DEC_5
);
5532 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5533 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5534 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5535 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5536 print_symbol (25, strtab
+ psym
->st_name
);
5538 if (section
->sh_type
== SHT_DYNSYM
&&
5539 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5541 unsigned char data
[2];
5542 unsigned short vers_data
;
5543 unsigned long offset
;
5547 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5550 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5551 sizeof (data
), _("version data"));
5553 vers_data
= byte_get (data
, 2);
5555 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5558 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5560 if ((vers_data
& 0x8000) || vers_data
> 1)
5562 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5563 && (is_nobits
|| ! check_def
))
5565 Elf_External_Verneed evn
;
5566 Elf_Internal_Verneed ivn
;
5567 Elf_Internal_Vernaux ivna
;
5569 /* We must test both. */
5570 offset
= version_info
5571 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5575 unsigned long vna_off
;
5577 get_data (&evn
, file
, offset
, sizeof (evn
),
5580 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5581 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5583 vna_off
= offset
+ ivn
.vn_aux
;
5587 Elf_External_Vernaux evna
;
5589 get_data (&evna
, file
, vna_off
,
5591 _("version need aux (3)"));
5593 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5594 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5595 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5597 vna_off
+= ivna
.vna_next
;
5599 while (ivna
.vna_other
!= vers_data
5600 && ivna
.vna_next
!= 0);
5602 if (ivna
.vna_other
== vers_data
)
5605 offset
+= ivn
.vn_next
;
5607 while (ivn
.vn_next
!= 0);
5609 if (ivna
.vna_other
== vers_data
)
5612 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5615 else if (! is_nobits
)
5616 error (_("bad dynamic symbol"));
5623 if (vers_data
!= 0x8001
5624 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5626 Elf_Internal_Verdef ivd
;
5627 Elf_Internal_Verdaux ivda
;
5628 Elf_External_Verdaux evda
;
5629 unsigned long offset
;
5632 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5637 Elf_External_Verdef evd
;
5639 get_data (&evd
, file
, offset
, sizeof (evd
),
5642 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5643 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5644 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5646 offset
+= ivd
.vd_next
;
5648 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5649 && ivd
.vd_next
!= 0);
5651 offset
-= ivd
.vd_next
;
5652 offset
+= ivd
.vd_aux
;
5654 get_data (&evda
, file
, offset
, sizeof (evda
),
5655 _("version def aux"));
5657 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5659 if (psym
->st_name
!= ivda
.vda_name
)
5660 printf ((vers_data
& 0x8000)
5662 strtab
+ ivda
.vda_name
);
5672 if (strtab
!= string_table
)
5678 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5680 if (do_histogram
&& buckets
!= NULL
)
5687 int nzero_counts
= 0;
5690 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5692 printf (_(" Length Number %% of total Coverage\n"));
5694 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5695 if (lengths
== NULL
)
5697 error (_("Out of memory"));
5700 for (hn
= 0; hn
< nbuckets
; ++hn
)
5705 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5708 if (maxlength
< ++lengths
[hn
])
5713 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5716 error (_("Out of memory"));
5720 for (hn
= 0; hn
< nbuckets
; ++hn
)
5721 ++ counts
[lengths
[hn
]];
5725 printf (" 0 %-10d (%5.1f%%)\n",
5726 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5727 for (si
= 1; si
<= maxlength
; ++si
)
5729 nzero_counts
+= counts
[si
] * si
;
5730 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5731 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5732 (nzero_counts
* 100.0) / nsyms
);
5740 if (buckets
!= NULL
)
5750 process_syminfo (file
)
5751 FILE * file ATTRIBUTE_UNUSED
;
5755 if (dynamic_syminfo
== NULL
5757 /* No syminfo, this is ok. */
5760 /* There better should be a dynamic symbol section. */
5761 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5765 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5766 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5768 printf (_(" Num: Name BoundTo Flags\n"));
5769 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5771 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5773 printf ("%4d: ", i
);
5774 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5777 switch (dynamic_syminfo
[i
].si_boundto
)
5779 case SYMINFO_BT_SELF
:
5780 fputs ("SELF ", stdout
);
5782 case SYMINFO_BT_PARENT
:
5783 fputs ("PARENT ", stdout
);
5786 if (dynamic_syminfo
[i
].si_boundto
> 0
5787 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5789 print_symbol (10, dynamic_strings
5791 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5795 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5799 if (flags
& SYMINFO_FLG_DIRECT
)
5801 if (flags
& SYMINFO_FLG_PASSTHRU
)
5802 printf (" PASSTHRU");
5803 if (flags
& SYMINFO_FLG_COPY
)
5805 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5806 printf (" LAZYLOAD");
5814 #ifdef SUPPORT_DISASSEMBLY
5816 disassemble_section (section
, file
)
5817 Elf32_Internal_Shdr
* section
;
5820 printf (_("\nAssembly dump of section %s\n"),
5821 SECTION_NAME (section
));
5823 /* XXX -- to be done --- XXX */
5830 dump_section (section
, file
)
5831 Elf32_Internal_Shdr
* section
;
5834 bfd_size_type bytes
;
5836 unsigned char * data
;
5837 unsigned char * start
;
5839 bytes
= section
->sh_size
;
5843 printf (_("\nSection '%s' has no data to dump.\n"),
5844 SECTION_NAME (section
));
5848 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5850 addr
= section
->sh_addr
;
5852 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
5865 lbytes
= (bytes
> 16 ? 16 : bytes
);
5867 printf (" 0x%8.8lx ", (unsigned long) addr
);
5869 switch (elf_header
.e_ident
[EI_DATA
])
5873 for (j
= 15; j
>= 0; j
--)
5876 printf ("%2.2x", data
[j
]);
5886 for (j
= 0; j
< 16; j
++)
5889 printf ("%2.2x", data
[j
]);
5899 for (j
= 0; j
< lbytes
; j
++)
5902 if (k
>= ' ' && k
< 0x80)
5921 static unsigned long int
5922 read_leb128 (data
, length_return
, sign
)
5923 unsigned char * data
;
5924 int * length_return
;
5927 unsigned long int result
= 0;
5928 unsigned int num_read
= 0;
5937 result
|= (byte
& 0x7f) << shift
;
5942 while (byte
& 0x80);
5944 if (length_return
!= NULL
)
5945 * length_return
= num_read
;
5947 if (sign
&& (shift
< 32) && (byte
& 0x40))
5948 result
|= -1 << shift
;
5953 typedef struct State_Machine_Registers
5955 unsigned long address
;
5958 unsigned int column
;
5962 /* This variable hold the number of the last entry seen
5963 in the File Table. */
5964 unsigned int last_file_entry
;
5967 static SMR state_machine_regs
;
5970 reset_state_machine (is_stmt
)
5973 state_machine_regs
.address
= 0;
5974 state_machine_regs
.file
= 1;
5975 state_machine_regs
.line
= 1;
5976 state_machine_regs
.column
= 0;
5977 state_machine_regs
.is_stmt
= is_stmt
;
5978 state_machine_regs
.basic_block
= 0;
5979 state_machine_regs
.end_sequence
= 0;
5980 state_machine_regs
.last_file_entry
= 0;
5983 /* Handled an extend line op. Returns true if this is the end
5986 process_extended_line_op (data
, is_stmt
, pointer_size
)
5987 unsigned char * data
;
5991 unsigned char op_code
;
5994 unsigned char * name
;
5997 len
= read_leb128 (data
, & bytes_read
, 0);
6002 warn (_("badly formed extended line op encountered!\n"));
6007 op_code
= * data
++;
6009 printf (_(" Extended opcode %d: "), op_code
);
6013 case DW_LNE_end_sequence
:
6014 printf (_("End of Sequence\n\n"));
6015 reset_state_machine (is_stmt
);
6018 case DW_LNE_set_address
:
6019 adr
= byte_get (data
, pointer_size
);
6020 printf (_("set Address to 0x%lx\n"), adr
);
6021 state_machine_regs
.address
= adr
;
6024 case DW_LNE_define_file
:
6025 printf (_(" define new File Table entry\n"));
6026 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6028 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6030 data
+= strlen ((char *) data
) + 1;
6031 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6033 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6035 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6036 printf (_("%s\n\n"), name
);
6040 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6047 /* Size of pointers in the .debug_line section. This information is not
6048 really present in that section. It's obtained before dumping the debug
6049 sections by doing some pre-scan of the .debug_info section. */
6050 static int debug_line_pointer_size
= 4;
6053 display_debug_lines (section
, start
, file
)
6054 Elf32_Internal_Shdr
* section
;
6055 unsigned char * start
;
6056 FILE * file ATTRIBUTE_UNUSED
;
6058 DWARF2_External_LineInfo
* external
;
6059 DWARF2_Internal_LineInfo info
;
6060 unsigned char * standard_opcodes
;
6061 unsigned char * data
= start
;
6062 unsigned char * end
= start
+ section
->sh_size
;
6063 unsigned char * end_of_sequence
;
6066 printf (_("\nDump of debug contents of section %s:\n\n"),
6067 SECTION_NAME (section
));
6071 external
= (DWARF2_External_LineInfo
*) data
;
6073 /* Check the length of the block. */
6074 info
.li_length
= BYTE_GET (external
->li_length
);
6076 if (info
.li_length
== 0xffffffff)
6078 warn (_("64-bit DWARF line info is not supported yet.\n"));
6082 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6085 (_("The line info appears to be corrupt - the section is too small\n"));
6089 /* Check its version number. */
6090 info
.li_version
= BYTE_GET (external
->li_version
);
6091 if (info
.li_version
!= 2)
6093 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6097 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6098 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6099 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6100 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6101 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6102 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6104 /* Sign extend the line base field. */
6105 info
.li_line_base
<<= 24;
6106 info
.li_line_base
>>= 24;
6108 printf (_(" Length: %ld\n"), info
.li_length
);
6109 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6110 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6111 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6112 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6113 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6114 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6115 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6117 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6119 reset_state_machine (info
.li_default_is_stmt
);
6121 /* Display the contents of the Opcodes table. */
6122 standard_opcodes
= data
+ sizeof (* external
);
6124 printf (_("\n Opcodes:\n"));
6126 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6127 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6129 /* Display the contents of the Directory table. */
6130 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6133 printf (_("\n The Directory Table is empty.\n"));
6136 printf (_("\n The Directory Table:\n"));
6140 printf (_(" %s\n"), data
);
6142 data
+= strlen ((char *) data
) + 1;
6146 /* Skip the NUL at the end of the table. */
6149 /* Display the contents of the File Name table. */
6151 printf (_("\n The File Name Table is empty.\n"));
6154 printf (_("\n The File Name Table:\n"));
6155 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6159 unsigned char * name
;
6162 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6165 data
+= strlen ((char *) data
) + 1;
6167 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6169 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6171 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6173 printf (_("%s\n"), name
);
6177 /* Skip the NUL at the end of the table. */
6180 /* Now display the statements. */
6181 printf (_("\n Line Number Statements:\n"));
6184 while (data
< end_of_sequence
)
6186 unsigned char op_code
;
6190 op_code
= * data
++;
6192 if (op_code
>= info
.li_opcode_base
)
6194 op_code
-= info
.li_opcode_base
;
6195 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6196 state_machine_regs
.address
+= adv
;
6197 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6198 op_code
, adv
, state_machine_regs
.address
);
6199 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6200 state_machine_regs
.line
+= adv
;
6201 printf (_(" and Line by %d to %d\n"),
6202 adv
, state_machine_regs
.line
);
6204 else switch (op_code
)
6206 case DW_LNS_extended_op
:
6207 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6208 debug_line_pointer_size
);
6212 printf (_(" Copy\n"));
6215 case DW_LNS_advance_pc
:
6216 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6218 state_machine_regs
.address
+= adv
;
6219 printf (_(" Advance PC by %d to %lx\n"), adv
,
6220 state_machine_regs
.address
);
6223 case DW_LNS_advance_line
:
6224 adv
= read_leb128 (data
, & bytes_read
, 1);
6226 state_machine_regs
.line
+= adv
;
6227 printf (_(" Advance Line by %d to %d\n"), adv
,
6228 state_machine_regs
.line
);
6231 case DW_LNS_set_file
:
6232 adv
= read_leb128 (data
, & bytes_read
, 0);
6234 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6236 state_machine_regs
.file
= adv
;
6239 case DW_LNS_set_column
:
6240 adv
= read_leb128 (data
, & bytes_read
, 0);
6242 printf (_(" Set column to %d\n"), adv
);
6243 state_machine_regs
.column
= adv
;
6246 case DW_LNS_negate_stmt
:
6247 adv
= state_machine_regs
.is_stmt
;
6249 printf (_(" Set is_stmt to %d\n"), adv
);
6250 state_machine_regs
.is_stmt
= adv
;
6253 case DW_LNS_set_basic_block
:
6254 printf (_(" Set basic block\n"));
6255 state_machine_regs
.basic_block
= 1;
6258 case DW_LNS_const_add_pc
:
6259 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6260 * info
.li_min_insn_length
);
6261 state_machine_regs
.address
+= adv
;
6262 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6263 state_machine_regs
.address
);
6266 case DW_LNS_fixed_advance_pc
:
6267 adv
= byte_get (data
, 2);
6269 state_machine_regs
.address
+= adv
;
6270 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6271 adv
, state_machine_regs
.address
);
6274 case DW_LNS_set_prologue_end
:
6275 printf (_(" Set prologue_end to true\n"));
6278 case DW_LNS_set_epilogue_begin
:
6279 printf (_(" Set epilogue_begin to true\n"));
6282 case DW_LNS_set_isa
:
6283 adv
= read_leb128 (data
, & bytes_read
, 0);
6285 printf (_(" Set ISA to %d\n"), adv
);
6289 printf (_(" Unknown opcode %d with operands: "), op_code
);
6292 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6294 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6295 i
== 1 ? "" : ", ");
6310 display_debug_pubnames (section
, start
, file
)
6311 Elf32_Internal_Shdr
* section
;
6312 unsigned char * start
;
6313 FILE * file ATTRIBUTE_UNUSED
;
6315 DWARF2_External_PubNames
* external
;
6316 DWARF2_Internal_PubNames pubnames
;
6317 unsigned char * end
;
6319 end
= start
+ section
->sh_size
;
6321 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6325 unsigned char * data
;
6326 unsigned long offset
;
6328 external
= (DWARF2_External_PubNames
*) start
;
6330 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6331 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6332 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6333 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6335 data
= start
+ sizeof (* external
);
6336 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6338 if (pubnames
.pn_length
== 0xffffffff)
6340 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6344 if (pubnames
.pn_version
!= 2)
6346 static int warned
= 0;
6350 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6357 printf (_(" Length: %ld\n"),
6358 pubnames
.pn_length
);
6359 printf (_(" Version: %d\n"),
6360 pubnames
.pn_version
);
6361 printf (_(" Offset into .debug_info section: %ld\n"),
6362 pubnames
.pn_offset
);
6363 printf (_(" Size of area in .debug_info section: %ld\n"),
6366 printf (_("\n Offset\tName\n"));
6370 offset
= byte_get (data
, 4);
6375 printf (" %ld\t\t%s\n", offset
, data
);
6376 data
+= strlen ((char *) data
) + 1;
6379 while (offset
!= 0);
6392 case DW_TAG_padding
: return "DW_TAG_padding";
6393 case DW_TAG_array_type
: return "DW_TAG_array_type";
6394 case DW_TAG_class_type
: return "DW_TAG_class_type";
6395 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6396 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6397 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6398 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6399 case DW_TAG_label
: return "DW_TAG_label";
6400 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6401 case DW_TAG_member
: return "DW_TAG_member";
6402 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6403 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6404 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6405 case DW_TAG_string_type
: return "DW_TAG_string_type";
6406 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6407 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6408 case DW_TAG_typedef
: return "DW_TAG_typedef";
6409 case DW_TAG_union_type
: return "DW_TAG_union_type";
6410 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6411 case DW_TAG_variant
: return "DW_TAG_variant";
6412 case DW_TAG_common_block
: return "DW_TAG_common_block";
6413 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6414 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6415 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6416 case DW_TAG_module
: return "DW_TAG_module";
6417 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6418 case DW_TAG_set_type
: return "DW_TAG_set_type";
6419 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6420 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6421 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6422 case DW_TAG_base_type
: return "DW_TAG_base_type";
6423 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6424 case DW_TAG_const_type
: return "DW_TAG_const_type";
6425 case DW_TAG_constant
: return "DW_TAG_constant";
6426 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6427 case DW_TAG_file_type
: return "DW_TAG_file_type";
6428 case DW_TAG_friend
: return "DW_TAG_friend";
6429 case DW_TAG_namelist
: return "DW_TAG_namelist";
6430 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6431 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6432 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6433 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6434 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6435 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6436 case DW_TAG_try_block
: return "DW_TAG_try_block";
6437 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6438 case DW_TAG_variable
: return "DW_TAG_variable";
6439 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6440 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6441 case DW_TAG_format_label
: return "DW_TAG_format_label";
6442 case DW_TAG_function_template
: return "DW_TAG_function_template";
6443 case DW_TAG_class_template
: return "DW_TAG_class_template";
6444 /* DWARF 2.1 values. */
6445 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6446 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6447 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6448 case DW_TAG_namespace
: return "DW_TAG_namespace";
6449 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6450 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6451 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6452 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6455 static char buffer
[100];
6457 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6464 get_AT_name (attribute
)
6465 unsigned long attribute
;
6469 case DW_AT_sibling
: return "DW_AT_sibling";
6470 case DW_AT_location
: return "DW_AT_location";
6471 case DW_AT_name
: return "DW_AT_name";
6472 case DW_AT_ordering
: return "DW_AT_ordering";
6473 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6474 case DW_AT_byte_size
: return "DW_AT_byte_size";
6475 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6476 case DW_AT_bit_size
: return "DW_AT_bit_size";
6477 case DW_AT_element_list
: return "DW_AT_element_list";
6478 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6479 case DW_AT_low_pc
: return "DW_AT_low_pc";
6480 case DW_AT_high_pc
: return "DW_AT_high_pc";
6481 case DW_AT_language
: return "DW_AT_language";
6482 case DW_AT_member
: return "DW_AT_member";
6483 case DW_AT_discr
: return "DW_AT_discr";
6484 case DW_AT_discr_value
: return "DW_AT_discr_value";
6485 case DW_AT_visibility
: return "DW_AT_visibility";
6486 case DW_AT_import
: return "DW_AT_import";
6487 case DW_AT_string_length
: return "DW_AT_string_length";
6488 case DW_AT_common_reference
: return "DW_AT_common_reference";
6489 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6490 case DW_AT_const_value
: return "DW_AT_const_value";
6491 case DW_AT_containing_type
: return "DW_AT_containing_type";
6492 case DW_AT_default_value
: return "DW_AT_default_value";
6493 case DW_AT_inline
: return "DW_AT_inline";
6494 case DW_AT_is_optional
: return "DW_AT_is_optional";
6495 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6496 case DW_AT_producer
: return "DW_AT_producer";
6497 case DW_AT_prototyped
: return "DW_AT_prototyped";
6498 case DW_AT_return_addr
: return "DW_AT_return_addr";
6499 case DW_AT_start_scope
: return "DW_AT_start_scope";
6500 case DW_AT_stride_size
: return "DW_AT_stride_size";
6501 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6502 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6503 case DW_AT_accessibility
: return "DW_AT_accessibility";
6504 case DW_AT_address_class
: return "DW_AT_address_class";
6505 case DW_AT_artificial
: return "DW_AT_artificial";
6506 case DW_AT_base_types
: return "DW_AT_base_types";
6507 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6508 case DW_AT_count
: return "DW_AT_count";
6509 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6510 case DW_AT_decl_column
: return "DW_AT_decl_column";
6511 case DW_AT_decl_file
: return "DW_AT_decl_file";
6512 case DW_AT_decl_line
: return "DW_AT_decl_line";
6513 case DW_AT_declaration
: return "DW_AT_declaration";
6514 case DW_AT_discr_list
: return "DW_AT_discr_list";
6515 case DW_AT_encoding
: return "DW_AT_encoding";
6516 case DW_AT_external
: return "DW_AT_external";
6517 case DW_AT_frame_base
: return "DW_AT_frame_base";
6518 case DW_AT_friend
: return "DW_AT_friend";
6519 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6520 case DW_AT_macro_info
: return "DW_AT_macro_info";
6521 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6522 case DW_AT_priority
: return "DW_AT_priority";
6523 case DW_AT_segment
: return "DW_AT_segment";
6524 case DW_AT_specification
: return "DW_AT_specification";
6525 case DW_AT_static_link
: return "DW_AT_static_link";
6526 case DW_AT_type
: return "DW_AT_type";
6527 case DW_AT_use_location
: return "DW_AT_use_location";
6528 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6529 case DW_AT_virtuality
: return "DW_AT_virtuality";
6530 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6531 /* DWARF 2.1 values. */
6532 case DW_AT_allocated
: return "DW_AT_allocated";
6533 case DW_AT_associated
: return "DW_AT_associated";
6534 case DW_AT_data_location
: return "DW_AT_data_location";
6535 case DW_AT_stride
: return "DW_AT_stride";
6536 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6537 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6538 case DW_AT_extension
: return "DW_AT_extension";
6539 case DW_AT_ranges
: return "DW_AT_ranges";
6540 case DW_AT_trampoline
: return "DW_AT_trampoline";
6541 case DW_AT_call_column
: return "DW_AT_call_column";
6542 case DW_AT_call_file
: return "DW_AT_call_file";
6543 case DW_AT_call_line
: return "DW_AT_call_line";
6544 /* SGI/MIPS extensions. */
6545 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6546 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6547 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6548 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6549 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6550 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6551 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6552 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6553 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6554 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6555 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6556 /* GNU extensions. */
6557 case DW_AT_sf_names
: return "DW_AT_sf_names";
6558 case DW_AT_src_info
: return "DW_AT_src_info";
6559 case DW_AT_mac_info
: return "DW_AT_mac_info";
6560 case DW_AT_src_coords
: return "DW_AT_src_coords";
6561 case DW_AT_body_begin
: return "DW_AT_body_begin";
6562 case DW_AT_body_end
: return "DW_AT_body_end";
6563 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6566 static char buffer
[100];
6568 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6575 get_FORM_name (form
)
6580 case DW_FORM_addr
: return "DW_FORM_addr";
6581 case DW_FORM_block2
: return "DW_FORM_block2";
6582 case DW_FORM_block4
: return "DW_FORM_block4";
6583 case DW_FORM_data2
: return "DW_FORM_data2";
6584 case DW_FORM_data4
: return "DW_FORM_data4";
6585 case DW_FORM_data8
: return "DW_FORM_data8";
6586 case DW_FORM_string
: return "DW_FORM_string";
6587 case DW_FORM_block
: return "DW_FORM_block";
6588 case DW_FORM_block1
: return "DW_FORM_block1";
6589 case DW_FORM_data1
: return "DW_FORM_data1";
6590 case DW_FORM_flag
: return "DW_FORM_flag";
6591 case DW_FORM_sdata
: return "DW_FORM_sdata";
6592 case DW_FORM_strp
: return "DW_FORM_strp";
6593 case DW_FORM_udata
: return "DW_FORM_udata";
6594 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6595 case DW_FORM_ref1
: return "DW_FORM_ref1";
6596 case DW_FORM_ref2
: return "DW_FORM_ref2";
6597 case DW_FORM_ref4
: return "DW_FORM_ref4";
6598 case DW_FORM_ref8
: return "DW_FORM_ref8";
6599 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6600 case DW_FORM_indirect
: return "DW_FORM_indirect";
6603 static char buffer
[100];
6605 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6611 /* FIXME: There are better and more effiecint ways to handle
6612 these structures. For now though, I just want something that
6613 is simple to implement. */
6614 typedef struct abbrev_attr
6616 unsigned long attribute
;
6618 struct abbrev_attr
* next
;
6622 typedef struct abbrev_entry
6624 unsigned long entry
;
6627 struct abbrev_attr
* first_attr
;
6628 struct abbrev_attr
* last_attr
;
6629 struct abbrev_entry
* next
;
6633 static abbrev_entry
* first_abbrev
= NULL
;
6634 static abbrev_entry
* last_abbrev
= NULL
;
6637 free_abbrevs
PARAMS ((void))
6639 abbrev_entry
* abbrev
;
6641 for (abbrev
= first_abbrev
; abbrev
;)
6643 abbrev_entry
* next
= abbrev
->next
;
6646 for (attr
= abbrev
->first_attr
; attr
;)
6648 abbrev_attr
* next
= attr
->next
;
6658 last_abbrev
= first_abbrev
= NULL
;
6662 add_abbrev (number
, tag
, children
)
6663 unsigned long number
;
6667 abbrev_entry
* entry
;
6669 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6675 entry
->entry
= number
;
6677 entry
->children
= children
;
6678 entry
->first_attr
= NULL
;
6679 entry
->last_attr
= NULL
;
6682 if (first_abbrev
== NULL
)
6683 first_abbrev
= entry
;
6685 last_abbrev
->next
= entry
;
6687 last_abbrev
= entry
;
6691 add_abbrev_attr (attribute
, form
)
6692 unsigned long attribute
;
6697 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6703 attr
->attribute
= attribute
;
6707 if (last_abbrev
->first_attr
== NULL
)
6708 last_abbrev
->first_attr
= attr
;
6710 last_abbrev
->last_attr
->next
= attr
;
6712 last_abbrev
->last_attr
= attr
;
6715 /* Processes the (partial) contents of a .debug_abbrev section.
6716 Returns NULL if the end of the section was encountered.
6717 Returns the address after the last byte read if the end of
6718 an abbreviation set was found. */
6720 static unsigned char *
6721 process_abbrev_section (start
, end
)
6722 unsigned char * start
;
6723 unsigned char * end
;
6725 if (first_abbrev
!= NULL
)
6731 unsigned long entry
;
6733 unsigned long attribute
;
6736 entry
= read_leb128 (start
, & bytes_read
, 0);
6737 start
+= bytes_read
;
6739 /* A single zero is supposed to end the section according
6740 to the standard. If there's more, then signal that to
6743 return start
== end
? NULL
: start
;
6745 tag
= read_leb128 (start
, & bytes_read
, 0);
6746 start
+= bytes_read
;
6748 children
= * start
++;
6750 add_abbrev (entry
, tag
, children
);
6756 attribute
= read_leb128 (start
, & bytes_read
, 0);
6757 start
+= bytes_read
;
6759 form
= read_leb128 (start
, & bytes_read
, 0);
6760 start
+= bytes_read
;
6763 add_abbrev_attr (attribute
, form
);
6765 while (attribute
!= 0);
6773 display_debug_macinfo (section
, start
, file
)
6774 Elf32_Internal_Shdr
* section
;
6775 unsigned char * start
;
6776 FILE * file ATTRIBUTE_UNUSED
;
6778 unsigned char * end
= start
+ section
->sh_size
;
6779 unsigned char * curr
= start
;
6780 unsigned int bytes_read
;
6781 enum dwarf_macinfo_record_type op
;
6783 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6787 unsigned int lineno
;
6788 const char * string
;
6795 case DW_MACINFO_start_file
:
6797 unsigned int filenum
;
6799 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6801 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6804 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6808 case DW_MACINFO_end_file
:
6809 printf (_(" DW_MACINFO_end_file\n"));
6812 case DW_MACINFO_define
:
6813 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6816 curr
+= strlen (string
) + 1;
6817 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6820 case DW_MACINFO_undef
:
6821 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6824 curr
+= strlen (string
) + 1;
6825 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
6828 case DW_MACINFO_vendor_ext
:
6830 unsigned int constant
;
6832 constant
= read_leb128 (curr
, & bytes_read
, 0);
6835 curr
+= strlen (string
) + 1;
6836 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
6847 display_debug_abbrev (section
, start
, file
)
6848 Elf32_Internal_Shdr
* section
;
6849 unsigned char * start
;
6850 FILE * file ATTRIBUTE_UNUSED
;
6852 abbrev_entry
* entry
;
6853 unsigned char * end
= start
+ section
->sh_size
;
6855 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6859 start
= process_abbrev_section (start
, end
);
6861 if (first_abbrev
== NULL
)
6864 printf (_(" Number TAG\n"));
6866 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
6870 printf (_(" %ld %s [%s]\n"),
6872 get_TAG_name (entry
->tag
),
6873 entry
->children
? _("has children") : _("no children"));
6875 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6877 printf (_(" %-18s %s\n"),
6878 get_AT_name (attr
->attribute
),
6879 get_FORM_name (attr
->form
));
6893 static unsigned char *
6894 display_block (data
, length
)
6895 unsigned char * data
;
6896 unsigned long length
;
6898 printf (_(" %lu byte block: "), length
);
6901 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
6907 decode_location_expression (data
, pointer_size
, length
)
6908 unsigned char * data
;
6909 unsigned int pointer_size
;
6910 unsigned long length
;
6914 unsigned long uvalue
;
6915 unsigned char * end
= data
+ length
;
6924 printf ("DW_OP_addr: %lx",
6925 (unsigned long) byte_get (data
, pointer_size
));
6926 data
+= pointer_size
;
6929 printf ("DW_OP_deref");
6932 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
6935 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
6938 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
6942 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
6946 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
6950 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
6954 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
6955 (unsigned long) byte_get (data
+ 4, 4));
6959 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
6960 (long) byte_get (data
+ 4, 4));
6964 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
6968 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
6972 printf ("DW_OP_dup");
6975 printf ("DW_OP_drop");
6978 printf ("DW_OP_over");
6981 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
6984 printf ("DW_OP_swap");
6987 printf ("DW_OP_rot");
6990 printf ("DW_OP_xderef");
6993 printf ("DW_OP_abs");
6996 printf ("DW_OP_and");
6999 printf ("DW_OP_div");
7002 printf ("DW_OP_minus");
7005 printf ("DW_OP_mod");
7008 printf ("DW_OP_mul");
7011 printf ("DW_OP_neg");
7014 printf ("DW_OP_not");
7017 printf ("DW_OP_or");
7020 printf ("DW_OP_plus");
7022 case DW_OP_plus_uconst
:
7023 printf ("DW_OP_plus_uconst: %lu",
7024 read_leb128 (data
, &bytes_read
, 0));
7028 printf ("DW_OP_shl");
7031 printf ("DW_OP_shr");
7034 printf ("DW_OP_shra");
7037 printf ("DW_OP_xor");
7040 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7044 printf ("DW_OP_eq");
7047 printf ("DW_OP_ge");
7050 printf ("DW_OP_gt");
7053 printf ("DW_OP_le");
7056 printf ("DW_OP_lt");
7059 printf ("DW_OP_ne");
7062 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7098 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7133 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7168 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7169 read_leb128 (data
, &bytes_read
, 1));
7174 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7178 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7182 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7184 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7185 read_leb128 (data
, &bytes_read
, 1));
7189 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7192 case DW_OP_deref_size
:
7193 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7195 case DW_OP_xderef_size
:
7196 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7199 printf ("DW_OP_nop");
7202 /* DWARF 2.1 extensions. */
7203 case DW_OP_push_object_address
:
7204 printf ("DW_OP_push_object_address");
7207 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7211 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7215 printf ("DW_OP_calli");
7219 if (op
>= DW_OP_lo_user
7220 && op
<= DW_OP_hi_user
)
7221 printf (_("(User defined location op)"));
7223 printf (_("(Unknown location op)"));
7224 /* No way to tell where the next op is, so just bail. */
7228 /* Separate the ops. */
7233 static const char * debug_loc_contents
;
7234 static bfd_vma debug_loc_size
;
7237 load_debug_loc (file
)
7240 Elf32_Internal_Shdr
* sec
;
7243 /* If it is already loaded, do nothing. */
7244 if (debug_loc_contents
!= NULL
)
7247 /* Locate the .debug_loc section. */
7248 for (i
= 0, sec
= section_headers
;
7249 i
< elf_header
.e_shnum
;
7251 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7254 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7257 debug_loc_size
= sec
->sh_size
;
7259 debug_loc_contents
= ((char *)
7260 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7261 _("debug_loc section data")));
7267 if (debug_loc_contents
== NULL
)
7270 free ((char *) debug_loc_contents
);
7271 debug_loc_contents
= NULL
;
7277 display_debug_loc (section
, start
, file
)
7278 Elf32_Internal_Shdr
* section
;
7279 unsigned char * start
;
7280 FILE * file ATTRIBUTE_UNUSED
;
7282 unsigned char *section_end
;
7283 unsigned long bytes
;
7284 unsigned char *section_begin
= start
;
7287 addr
= section
->sh_addr
;
7288 bytes
= section
->sh_size
;
7289 section_end
= start
+ bytes
;
7292 printf (_("\nThe .debug_loc section is empty.\n"));
7295 printf (_("Contents of the .debug_loc section:\n\n"));
7296 printf (_("\n Offset Begin End Expression\n"));
7297 while (start
< section_end
)
7299 unsigned long begin
;
7301 unsigned short length
;
7302 unsigned long offset
;
7304 offset
= start
- section_begin
;
7308 /* Normally, the lists in the debug_loc section are related to a
7309 given compilation unit, and thus, we would use the
7310 pointer size of that compilation unit. However, since we are
7311 displaying it seperately here, we either have to store
7312 pointer sizes of all compilation units, or assume they don't
7313 change. We assume, like the debug_line display, that
7314 it doesn't change. */
7315 begin
= byte_get (start
, debug_line_pointer_size
);
7316 start
+= debug_line_pointer_size
;
7317 end
= byte_get (start
, debug_line_pointer_size
);
7318 start
+= debug_line_pointer_size
;
7320 if (begin
== 0 && end
== 0)
7326 length
= byte_get (start
, 2);
7329 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7330 decode_location_expression (start
, debug_line_pointer_size
, length
);
7340 static const char * debug_str_contents
;
7341 static bfd_vma debug_str_size
;
7344 load_debug_str (file
)
7347 Elf32_Internal_Shdr
* sec
;
7350 /* If it is already loaded, do nothing. */
7351 if (debug_str_contents
!= NULL
)
7354 /* Locate the .debug_str section. */
7355 for (i
= 0, sec
= section_headers
;
7356 i
< elf_header
.e_shnum
;
7358 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7361 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7364 debug_str_size
= sec
->sh_size
;
7366 debug_str_contents
= ((char *)
7367 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7368 _("debug_str section data")));
7374 if (debug_str_contents
== NULL
)
7377 free ((char *) debug_str_contents
);
7378 debug_str_contents
= NULL
;
7383 fetch_indirect_string (offset
)
7384 unsigned long offset
;
7386 if (debug_str_contents
== NULL
)
7387 return _("<no .debug_str section>");
7389 if (offset
> debug_str_size
)
7390 return _("<offset is too big>");
7392 return debug_str_contents
+ offset
;
7397 display_debug_str (section
, start
, file
)
7398 Elf32_Internal_Shdr
* section
;
7399 unsigned char * start
;
7400 FILE * file ATTRIBUTE_UNUSED
;
7402 unsigned long bytes
;
7405 addr
= section
->sh_addr
;
7406 bytes
= section
->sh_size
;
7410 printf (_("\nThe .debug_str section is empty.\n"));
7414 printf (_("Contents of the .debug_str section:\n\n"));
7422 lbytes
= (bytes
> 16 ? 16 : bytes
);
7424 printf (" 0x%8.8lx ", (unsigned long) addr
);
7426 for (j
= 0; j
< 16; j
++)
7429 printf ("%2.2x", start
[j
]);
7437 for (j
= 0; j
< lbytes
; j
++)
7440 if (k
>= ' ' && k
< 0x80)
7457 static unsigned char *
7458 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7459 unsigned long attribute
;
7461 unsigned char * data
;
7462 unsigned long cu_offset
;
7463 unsigned long pointer_size
;
7465 unsigned long uvalue
= 0;
7466 unsigned char * block_start
= NULL
;
7474 case DW_FORM_ref_addr
:
7476 uvalue
= byte_get (data
, pointer_size
);
7477 data
+= pointer_size
;
7481 uvalue
= byte_get (data
, /* offset_size */ 4);
7482 data
+= /* offset_size */ 4;
7488 uvalue
= byte_get (data
++, 1);
7493 uvalue
= byte_get (data
, 2);
7499 uvalue
= byte_get (data
, 4);
7504 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7508 case DW_FORM_ref_udata
:
7510 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7514 case DW_FORM_indirect
:
7515 form
= read_leb128 (data
, & bytes_read
, 0);
7517 printf (" %s", get_FORM_name (form
));
7518 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7524 case DW_FORM_ref_addr
:
7525 printf (" <#%lx>", uvalue
);
7531 case DW_FORM_ref_udata
:
7532 printf (" <%lx>", uvalue
+ cu_offset
);
7536 printf (" %#lx", uvalue
);
7544 printf (" %ld", uvalue
);
7549 uvalue
= byte_get (data
, 4);
7550 printf (" %lx", uvalue
);
7551 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7555 case DW_FORM_string
:
7556 printf (" %s", data
);
7557 data
+= strlen ((char *) data
) + 1;
7561 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7562 block_start
= data
+ bytes_read
;
7563 data
= display_block (block_start
, uvalue
);
7566 case DW_FORM_block1
:
7567 uvalue
= byte_get (data
, 1);
7568 block_start
= data
+ 1;
7569 data
= display_block (block_start
, uvalue
);
7572 case DW_FORM_block2
:
7573 uvalue
= byte_get (data
, 2);
7574 block_start
= data
+ 2;
7575 data
= display_block (block_start
, uvalue
);
7578 case DW_FORM_block4
:
7579 uvalue
= byte_get (data
, 4);
7580 block_start
= data
+ 4;
7581 data
= display_block (block_start
, uvalue
);
7585 printf (_(" (indirect string, offset: 0x%lx): "), uvalue
);
7586 printf (fetch_indirect_string (uvalue
));
7589 case DW_FORM_indirect
:
7590 /* Handled above. */
7594 warn (_("Unrecognized form: %d\n"), form
);
7598 /* For some attributes we can display futher information. */
7607 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7608 case DW_INL_inlined
: printf (_("(inlined)")); break;
7609 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7610 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7611 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7615 case DW_AT_language
:
7618 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7619 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7620 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7621 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7622 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7623 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7624 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7625 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7626 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7627 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7628 /* DWARF 2.1 values. */
7629 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7630 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7631 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7632 /* MIPS extension. */
7633 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7634 default: printf ("(Unknown: %lx)", uvalue
); break;
7638 case DW_AT_encoding
:
7641 case DW_ATE_void
: printf ("(void)"); break;
7642 case DW_ATE_address
: printf ("(machine address)"); break;
7643 case DW_ATE_boolean
: printf ("(boolean)"); break;
7644 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7645 case DW_ATE_float
: printf ("(float)"); break;
7646 case DW_ATE_signed
: printf ("(signed)"); break;
7647 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7648 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7649 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7650 /* DWARF 2.1 value. */
7651 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7653 if (uvalue
>= DW_ATE_lo_user
7654 && uvalue
<= DW_ATE_hi_user
)
7655 printf ("(user defined type)");
7657 printf ("(unknown type)");
7662 case DW_AT_accessibility
:
7665 case DW_ACCESS_public
: printf ("(public)"); break;
7666 case DW_ACCESS_protected
: printf ("(protected)"); break;
7667 case DW_ACCESS_private
: printf ("(private)"); break;
7668 default: printf ("(unknown accessibility)"); break;
7672 case DW_AT_visibility
:
7675 case DW_VIS_local
: printf ("(local)"); break;
7676 case DW_VIS_exported
: printf ("(exported)"); break;
7677 case DW_VIS_qualified
: printf ("(qualified)"); break;
7678 default: printf ("(unknown visibility)"); break;
7682 case DW_AT_virtuality
:
7685 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7686 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7687 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7688 default: printf ("(unknown virtuality)"); break;
7692 case DW_AT_identifier_case
:
7695 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7696 case DW_ID_up_case
: printf ("(up_case)"); break;
7697 case DW_ID_down_case
: printf ("(down_case)"); break;
7698 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7699 default: printf ("(unknown case)"); break;
7703 case DW_AT_calling_convention
:
7706 case DW_CC_normal
: printf ("(normal)"); break;
7707 case DW_CC_program
: printf ("(program)"); break;
7708 case DW_CC_nocall
: printf ("(nocall)"); break;
7710 if (uvalue
>= DW_CC_lo_user
7711 && uvalue
<= DW_CC_hi_user
)
7712 printf ("(user defined)");
7714 printf ("(unknown convention)");
7718 case DW_AT_ordering
:
7721 case -1: printf ("(undefined)"); break;
7722 case 0: printf ("(row major)"); break;
7723 case 1: printf ("(column major)"); break;
7727 case DW_AT_frame_base
:
7728 case DW_AT_location
:
7729 case DW_AT_data_member_location
:
7730 case DW_AT_vtable_elem_location
:
7731 case DW_AT_allocated
:
7732 case DW_AT_associated
:
7733 case DW_AT_data_location
:
7735 case DW_AT_upper_bound
:
7736 case DW_AT_lower_bound
:
7740 decode_location_expression (block_start
, pointer_size
, uvalue
);
7743 else if (form
== DW_FORM_data4
)
7746 printf ("location list");
7758 static unsigned char *
7759 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7760 unsigned long attribute
;
7762 unsigned char * data
;
7763 unsigned long cu_offset
;
7764 unsigned long pointer_size
;
7766 printf (" %-18s:", get_AT_name (attribute
));
7767 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7774 display_debug_info (section
, start
, file
)
7775 Elf32_Internal_Shdr
* section
;
7776 unsigned char * start
;
7779 unsigned char * end
= start
+ section
->sh_size
;
7780 unsigned char * section_begin
= start
;
7782 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7784 load_debug_str (file
);
7785 load_debug_loc (file
);
7789 DWARF2_External_CompUnit
* external
;
7790 DWARF2_Internal_CompUnit compunit
;
7791 Elf32_Internal_Shdr
* relsec
;
7792 unsigned char * tags
;
7795 unsigned long cu_offset
;
7797 external
= (DWARF2_External_CompUnit
*) start
;
7799 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7800 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7801 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7802 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7804 if (compunit
.cu_length
== 0xffffffff)
7806 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7810 /* Check for RELA relocations in the abbrev_offset address, and
7812 for (relsec
= section_headers
;
7813 relsec
< section_headers
+ elf_header
.e_shnum
;
7816 unsigned long nrelas
;
7817 Elf_Internal_Rela
*rela
, *rp
;
7818 Elf32_Internal_Shdr
*symsec
;
7819 Elf_Internal_Sym
*symtab
;
7820 Elf_Internal_Sym
*sym
;
7822 if (relsec
->sh_type
!= SHT_RELA
7823 || SECTION_HEADER (relsec
->sh_info
) != section
)
7826 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7830 symsec
= SECTION_HEADER (relsec
->sh_link
);
7831 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7833 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7836 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
7842 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7844 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7846 warn (_("Skipping unexpected symbol type %u\n"),
7847 ELF32_ST_TYPE (sym
->st_info
));
7853 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7855 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7857 warn (_("Skipping unexpected symbol type %u\n"),
7858 ELF64_ST_TYPE (sym
->st_info
));
7863 compunit
.cu_abbrev_offset
+= rp
->r_addend
;
7871 tags
= start
+ sizeof (* external
);
7872 cu_offset
= start
- section_begin
;
7873 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
7875 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
7876 printf (_(" Length: %ld\n"), compunit
.cu_length
);
7877 printf (_(" Version: %d\n"), compunit
.cu_version
);
7878 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
7879 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
7881 if (compunit
.cu_version
!= 2)
7883 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7889 /* Read in the abbrevs used by this compilation unit. */
7892 Elf32_Internal_Shdr
* sec
;
7893 unsigned char * begin
;
7895 /* Locate the .debug_abbrev section and process it. */
7896 for (i
= 0, sec
= section_headers
;
7897 i
< elf_header
.e_shnum
;
7899 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
7902 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7904 warn (_("Unable to locate .debug_abbrev section!\n"));
7908 begin
= ((unsigned char *)
7909 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7910 _("debug_abbrev section data")));
7914 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
7915 begin
+ sec
->sh_size
);
7921 while (tags
< start
)
7924 unsigned long abbrev_number
;
7925 abbrev_entry
* entry
;
7928 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
7931 /* A null DIE marks the end of a list of children. */
7932 if (abbrev_number
== 0)
7938 /* Scan through the abbreviation list until we reach the
7940 for (entry
= first_abbrev
;
7941 entry
&& entry
->entry
!= abbrev_number
;
7942 entry
= entry
->next
)
7947 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7952 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7954 (unsigned long) (tags
- section_begin
- bytes_read
),
7956 get_TAG_name (entry
->tag
));
7958 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7959 tags
= read_and_display_attr (attr
->attribute
,
7962 compunit
.cu_pointer_size
);
7964 if (entry
->children
)
7978 display_debug_aranges (section
, start
, file
)
7979 Elf32_Internal_Shdr
* section
;
7980 unsigned char * start
;
7981 FILE * file ATTRIBUTE_UNUSED
;
7983 unsigned char * end
= start
+ section
->sh_size
;
7985 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7989 DWARF2_External_ARange
* external
;
7990 DWARF2_Internal_ARange arange
;
7991 unsigned char * ranges
;
7992 unsigned long length
;
7993 unsigned long address
;
7996 external
= (DWARF2_External_ARange
*) start
;
7998 arange
.ar_length
= BYTE_GET (external
->ar_length
);
7999 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8000 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8001 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8002 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8004 if (arange
.ar_length
== 0xffffffff)
8006 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8010 if (arange
.ar_version
!= 2)
8012 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8016 printf (_(" Length: %ld\n"), arange
.ar_length
);
8017 printf (_(" Version: %d\n"), arange
.ar_version
);
8018 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8019 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8020 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8022 printf (_("\n Address Length\n"));
8024 ranges
= start
+ sizeof (* external
);
8026 /* Must pad to an alignment boundary that is twice the pointer size. */
8027 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
8029 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8033 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8035 ranges
+= arange
.ar_pointer_size
;
8037 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8039 ranges
+= arange
.ar_pointer_size
;
8041 /* A pair of zeros marks the end of the list. */
8042 if (address
== 0 && length
== 0)
8045 printf (" %8.8lx %lu\n", address
, length
);
8048 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8056 typedef struct Frame_Chunk
8058 struct Frame_Chunk
* next
;
8059 unsigned char * chunk_start
;
8061 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8062 short int * col_type
;
8064 char * augmentation
;
8065 unsigned int code_factor
;
8067 unsigned long pc_begin
;
8068 unsigned long pc_range
;
8072 unsigned char fde_encoding
;
8076 /* A marker for a col_type that means this column was never referenced
8077 in the frame info. */
8078 #define DW_CFA_unreferenced (-1)
8080 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8081 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8082 static int size_of_encoded_value
PARAMS ((int));
8085 frame_need_space (fc
, reg
)
8089 int prev
= fc
->ncols
;
8091 if (reg
< fc
->ncols
)
8094 fc
->ncols
= reg
+ 1;
8095 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8096 fc
->ncols
* sizeof (short int));
8097 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8098 fc
->ncols
* sizeof (int));
8100 while (prev
< fc
->ncols
)
8102 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8103 fc
->col_offset
[prev
] = 0;
8109 frame_display_row (fc
, need_col_headers
, max_regs
)
8111 int * need_col_headers
;
8117 if (* max_regs
< fc
->ncols
)
8118 * max_regs
= fc
->ncols
;
8120 if (* need_col_headers
)
8122 * need_col_headers
= 0;
8124 printf (" LOC CFA ");
8126 for (r
= 0; r
< * max_regs
; r
++)
8127 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8132 printf ("r%-4d", r
);
8138 printf ("%08lx ", fc
->pc_begin
);
8139 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8140 printf ("%-8s ", tmp
);
8142 for (r
= 0; r
< fc
->ncols
; r
++)
8144 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8146 switch (fc
->col_type
[r
])
8148 case DW_CFA_undefined
:
8151 case DW_CFA_same_value
:
8155 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8157 case DW_CFA_register
:
8158 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8161 strcpy (tmp
, "n/a");
8164 printf ("%-5s", tmp
);
8171 size_of_encoded_value (encoding
)
8174 switch (encoding
& 0x7)
8177 case 0: return is_32bit_elf
? 4 : 8;
8184 #define GET(N) byte_get (start, N); start += N
8185 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8186 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8189 display_debug_frames (section
, start
, file
)
8190 Elf32_Internal_Shdr
* section
;
8191 unsigned char * start
;
8192 FILE * file ATTRIBUTE_UNUSED
;
8194 unsigned char * end
= start
+ section
->sh_size
;
8195 unsigned char * section_start
= start
;
8196 Frame_Chunk
* chunks
= 0;
8197 Frame_Chunk
* remembered_state
= 0;
8199 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8202 int addr_size
= is_32bit_elf
? 4 : 8;
8204 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8208 unsigned char * saved_start
;
8209 unsigned char * block_end
;
8210 unsigned long length
;
8211 unsigned long cie_id
;
8214 int need_col_headers
= 1;
8215 unsigned char * augmentation_data
= NULL
;
8216 unsigned long augmentation_data_len
= 0;
8217 int encoded_ptr_size
= addr_size
;
8219 saved_start
= start
;
8220 length
= byte_get (start
, 4); start
+= 4;
8225 if (length
== 0xffffffff)
8227 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8231 block_end
= saved_start
+ length
+ 4;
8232 cie_id
= byte_get (start
, 4); start
+= 4;
8234 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8238 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8239 memset (fc
, 0, sizeof (Frame_Chunk
));
8243 fc
->chunk_start
= saved_start
;
8245 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8246 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8247 frame_need_space (fc
, max_regs
-1);
8251 fc
->augmentation
= start
;
8252 start
= strchr (start
, '\0') + 1;
8254 if (fc
->augmentation
[0] == 'z')
8256 fc
->code_factor
= LEB ();
8257 fc
->data_factor
= SLEB ();
8258 fc
->ra
= byte_get (start
, 1); start
+= 1;
8259 augmentation_data_len
= LEB ();
8260 augmentation_data
= start
;
8261 start
+= augmentation_data_len
;
8263 else if (strcmp (fc
->augmentation
, "eh") == 0)
8266 fc
->code_factor
= LEB ();
8267 fc
->data_factor
= SLEB ();
8268 fc
->ra
= byte_get (start
, 1); start
+= 1;
8272 fc
->code_factor
= LEB ();
8273 fc
->data_factor
= SLEB ();
8274 fc
->ra
= byte_get (start
, 1); start
+= 1;
8278 if (do_debug_frames_interp
)
8279 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8280 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8281 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8285 printf ("\n%08lx %08lx %08lx CIE\n",
8286 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8287 printf (" Version: %d\n", version
);
8288 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8289 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8290 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8291 printf (" Return address column: %d\n", fc
->ra
);
8293 if (augmentation_data_len
)
8296 printf (" Augmentation data: ");
8297 for (i
= 0; i
< augmentation_data_len
; ++i
)
8298 printf (" %02x", augmentation_data
[i
]);
8304 if (augmentation_data_len
)
8306 unsigned char *p
, *q
;
8307 p
= fc
->augmentation
+ 1;
8308 q
= augmentation_data
;
8315 q
+= 1 + size_of_encoded_value (*q
);
8317 fc
->fde_encoding
= *q
++;
8323 if (fc
->fde_encoding
)
8324 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8327 frame_need_space (fc
, fc
->ra
);
8331 unsigned char * look_for
;
8332 static Frame_Chunk fde_fc
;
8335 memset (fc
, 0, sizeof (Frame_Chunk
));
8337 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8339 for (cie
= chunks
; cie
; cie
= cie
->next
)
8340 if (cie
->chunk_start
== look_for
)
8345 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8346 cie_id
, saved_start
);
8349 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8350 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8351 frame_need_space (fc
, max_regs
- 1);
8353 fc
->augmentation
= "";
8354 fc
->fde_encoding
= 0;
8358 fc
->ncols
= cie
->ncols
;
8359 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8360 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8361 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8362 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8363 fc
->augmentation
= cie
->augmentation
;
8364 fc
->code_factor
= cie
->code_factor
;
8365 fc
->data_factor
= cie
->data_factor
;
8366 fc
->cfa_reg
= cie
->cfa_reg
;
8367 fc
->cfa_offset
= cie
->cfa_offset
;
8369 frame_need_space (fc
, max_regs
-1);
8370 fc
->fde_encoding
= cie
->fde_encoding
;
8373 if (fc
->fde_encoding
)
8374 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8376 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8377 start
+= encoded_ptr_size
;
8378 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8379 start
+= encoded_ptr_size
;
8381 if (cie
->augmentation
[0] == 'z')
8383 augmentation_data_len
= LEB ();
8384 augmentation_data
= start
;
8385 start
+= augmentation_data_len
;
8388 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8389 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8390 (unsigned long)(cie
->chunk_start
- section_start
),
8391 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8392 if (! do_debug_frames_interp
&& augmentation_data_len
)
8395 printf (" Augmentation data: ");
8396 for (i
= 0; i
< augmentation_data_len
; ++i
)
8397 printf (" %02x", augmentation_data
[i
]);
8403 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8404 about to interpret instructions for the chunk. */
8406 if (do_debug_frames_interp
)
8408 /* Start by making a pass over the chunk, allocating storage
8409 and taking note of what registers are used. */
8410 unsigned char * tmp
= start
;
8412 while (start
< block_end
)
8422 /* Warning: if you add any more cases to this switch, be
8423 sure to add them to the corresponding switch below. */
8426 case DW_CFA_advance_loc
:
8430 frame_need_space (fc
, opa
);
8431 fc
->col_type
[opa
] = DW_CFA_undefined
;
8433 case DW_CFA_restore
:
8434 frame_need_space (fc
, opa
);
8435 fc
->col_type
[opa
] = DW_CFA_undefined
;
8437 case DW_CFA_set_loc
:
8438 start
+= encoded_ptr_size
;
8440 case DW_CFA_advance_loc1
:
8443 case DW_CFA_advance_loc2
:
8446 case DW_CFA_advance_loc4
:
8449 case DW_CFA_offset_extended
:
8450 reg
= LEB (); LEB ();
8451 frame_need_space (fc
, reg
);
8452 fc
->col_type
[reg
] = DW_CFA_undefined
;
8454 case DW_CFA_restore_extended
:
8456 frame_need_space (fc
, reg
);
8457 fc
->col_type
[reg
] = DW_CFA_undefined
;
8459 case DW_CFA_undefined
:
8461 frame_need_space (fc
, reg
);
8462 fc
->col_type
[reg
] = DW_CFA_undefined
;
8464 case DW_CFA_same_value
:
8466 frame_need_space (fc
, reg
);
8467 fc
->col_type
[reg
] = DW_CFA_undefined
;
8469 case DW_CFA_register
:
8470 reg
= LEB (); LEB ();
8471 frame_need_space (fc
, reg
);
8472 fc
->col_type
[reg
] = DW_CFA_undefined
;
8474 case DW_CFA_def_cfa
:
8477 case DW_CFA_def_cfa_register
:
8480 case DW_CFA_def_cfa_offset
:
8483 case DW_CFA_offset_extended_sf
:
8484 reg
= LEB (); SLEB ();
8485 frame_need_space (fc
, reg
);
8486 fc
->col_type
[reg
] = DW_CFA_undefined
;
8488 case DW_CFA_def_cfa_sf
:
8491 case DW_CFA_def_cfa_offset_sf
:
8494 case DW_CFA_GNU_args_size
:
8497 case DW_CFA_GNU_negative_offset_extended
:
8498 reg
= LEB (); LEB ();
8499 frame_need_space (fc
, reg
);
8500 fc
->col_type
[reg
] = DW_CFA_undefined
;
8509 /* Now we know what registers are used, make a second pass over
8510 the chunk, this time actually printing out the info. */
8512 while (start
< block_end
)
8515 unsigned long ul
, reg
, roffs
;
8524 /* Warning: if you add any more cases to this switch, be
8525 sure to add them to the corresponding switch above. */
8528 case DW_CFA_advance_loc
:
8529 if (do_debug_frames_interp
)
8530 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8532 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8533 opa
* fc
->code_factor
,
8534 fc
->pc_begin
+ opa
* fc
->code_factor
);
8535 fc
->pc_begin
+= opa
* fc
->code_factor
;
8540 if (! do_debug_frames_interp
)
8541 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8542 opa
, roffs
* fc
->data_factor
);
8543 fc
->col_type
[opa
] = DW_CFA_offset
;
8544 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8547 case DW_CFA_restore
:
8548 if (! do_debug_frames_interp
)
8549 printf (" DW_CFA_restore: r%d\n", opa
);
8550 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8551 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8554 case DW_CFA_set_loc
:
8555 vma
= byte_get (start
, encoded_ptr_size
);
8556 start
+= encoded_ptr_size
;
8557 if (do_debug_frames_interp
)
8558 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8560 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8564 case DW_CFA_advance_loc1
:
8565 ofs
= byte_get (start
, 1); start
+= 1;
8566 if (do_debug_frames_interp
)
8567 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8569 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8570 ofs
* fc
->code_factor
,
8571 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8572 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8575 case DW_CFA_advance_loc2
:
8576 ofs
= byte_get (start
, 2); start
+= 2;
8577 if (do_debug_frames_interp
)
8578 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8580 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8581 ofs
* fc
->code_factor
,
8582 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8583 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8586 case DW_CFA_advance_loc4
:
8587 ofs
= byte_get (start
, 4); start
+= 4;
8588 if (do_debug_frames_interp
)
8589 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8591 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8592 ofs
* fc
->code_factor
,
8593 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8594 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8597 case DW_CFA_offset_extended
:
8600 if (! do_debug_frames_interp
)
8601 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8602 reg
, roffs
* fc
->data_factor
);
8603 fc
->col_type
[reg
] = DW_CFA_offset
;
8604 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8607 case DW_CFA_restore_extended
:
8609 if (! do_debug_frames_interp
)
8610 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8611 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8612 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8615 case DW_CFA_undefined
:
8617 if (! do_debug_frames_interp
)
8618 printf (" DW_CFA_undefined: r%ld\n", reg
);
8619 fc
->col_type
[reg
] = DW_CFA_undefined
;
8620 fc
->col_offset
[reg
] = 0;
8623 case DW_CFA_same_value
:
8625 if (! do_debug_frames_interp
)
8626 printf (" DW_CFA_same_value: r%ld\n", reg
);
8627 fc
->col_type
[reg
] = DW_CFA_same_value
;
8628 fc
->col_offset
[reg
] = 0;
8631 case DW_CFA_register
:
8634 if (! do_debug_frames_interp
)
8635 printf (" DW_CFA_register: r%ld\n", reg
);
8636 fc
->col_type
[reg
] = DW_CFA_register
;
8637 fc
->col_offset
[reg
] = roffs
;
8640 case DW_CFA_remember_state
:
8641 if (! do_debug_frames_interp
)
8642 printf (" DW_CFA_remember_state\n");
8643 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8644 rs
->ncols
= fc
->ncols
;
8645 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8646 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8647 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8648 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8649 rs
->next
= remembered_state
;
8650 remembered_state
= rs
;
8653 case DW_CFA_restore_state
:
8654 if (! do_debug_frames_interp
)
8655 printf (" DW_CFA_restore_state\n");
8656 rs
= remembered_state
;
8657 remembered_state
= rs
->next
;
8658 frame_need_space (fc
, rs
->ncols
-1);
8659 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8660 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8661 free (rs
->col_type
);
8662 free (rs
->col_offset
);
8666 case DW_CFA_def_cfa
:
8667 fc
->cfa_reg
= LEB ();
8668 fc
->cfa_offset
= LEB ();
8669 if (! do_debug_frames_interp
)
8670 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8671 fc
->cfa_reg
, fc
->cfa_offset
);
8674 case DW_CFA_def_cfa_register
:
8675 fc
->cfa_reg
= LEB ();
8676 if (! do_debug_frames_interp
)
8677 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8680 case DW_CFA_def_cfa_offset
:
8681 fc
->cfa_offset
= LEB ();
8682 if (! do_debug_frames_interp
)
8683 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8687 if (! do_debug_frames_interp
)
8688 printf (" DW_CFA_nop\n");
8691 case DW_CFA_offset_extended_sf
:
8694 frame_need_space (fc
, reg
);
8695 if (! do_debug_frames_interp
)
8696 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8697 reg
, l
* fc
->data_factor
);
8698 fc
->col_type
[reg
] = DW_CFA_offset
;
8699 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8702 case DW_CFA_def_cfa_sf
:
8703 fc
->cfa_reg
= LEB ();
8704 fc
->cfa_offset
= SLEB ();
8705 if (! do_debug_frames_interp
)
8706 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8707 fc
->cfa_reg
, fc
->cfa_offset
);
8710 case DW_CFA_def_cfa_offset_sf
:
8711 fc
->cfa_offset
= SLEB ();
8712 if (! do_debug_frames_interp
)
8713 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
8716 case DW_CFA_GNU_window_save
:
8717 if (! do_debug_frames_interp
)
8718 printf (" DW_CFA_GNU_window_save\n");
8721 case DW_CFA_GNU_args_size
:
8723 if (! do_debug_frames_interp
)
8724 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8727 case DW_CFA_GNU_negative_offset_extended
:
8730 frame_need_space (fc
, reg
);
8731 if (! do_debug_frames_interp
)
8732 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8733 reg
, l
* fc
->data_factor
);
8734 fc
->col_type
[reg
] = DW_CFA_offset
;
8735 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8738 /* FIXME: How do we handle these? */
8739 case DW_CFA_def_cfa_expression
:
8740 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
8744 case DW_CFA_expression
:
8745 fprintf (stderr
, "unsupported DW_CFA_expression\n");
8750 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8755 if (do_debug_frames_interp
)
8756 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8771 display_debug_not_supported (section
, start
, file
)
8772 Elf32_Internal_Shdr
* section
;
8773 unsigned char * start ATTRIBUTE_UNUSED
;
8774 FILE * file ATTRIBUTE_UNUSED
;
8776 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8777 SECTION_NAME (section
));
8782 /* Pre-scan the .debug_info section to record the size of address.
8783 When dumping the .debug_line, we use that size information, assuming
8784 that all compilation units have the same address size. */
8786 prescan_debug_info (section
, start
, file
)
8787 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8788 unsigned char * start
;
8789 FILE * file ATTRIBUTE_UNUSED
;
8791 DWARF2_External_CompUnit
* external
;
8793 external
= (DWARF2_External_CompUnit
*) start
;
8795 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8799 /* A structure containing the name of a debug section and a pointer
8800 to a function that can decode it. The third field is a prescan
8801 function to be run over the section before displaying any of the
8805 const char * const name
;
8806 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8807 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8811 { ".debug_abbrev", display_debug_abbrev
, NULL
},
8812 { ".debug_aranges", display_debug_aranges
, NULL
},
8813 { ".debug_frame", display_debug_frames
, NULL
},
8814 { ".debug_info", display_debug_info
, prescan_debug_info
},
8815 { ".debug_line", display_debug_lines
, NULL
},
8816 { ".debug_pubnames", display_debug_pubnames
, NULL
},
8817 { ".eh_frame", display_debug_frames
, NULL
},
8818 { ".debug_macinfo", display_debug_macinfo
, NULL
},
8819 { ".debug_str", display_debug_str
, NULL
},
8820 { ".debug_loc", display_debug_loc
, NULL
},
8821 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
8822 { ".debug_ranges", display_debug_not_supported
, NULL
},
8823 { ".debug_static_func", display_debug_not_supported
, NULL
},
8824 { ".debug_static_vars", display_debug_not_supported
, NULL
},
8825 { ".debug_types", display_debug_not_supported
, NULL
},
8826 { ".debug_weaknames", display_debug_not_supported
, NULL
}
8830 display_debug_section (section
, file
)
8831 Elf32_Internal_Shdr
* section
;
8834 char * name
= SECTION_NAME (section
);
8835 bfd_size_type length
;
8836 unsigned char * start
;
8839 length
= section
->sh_size
;
8842 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8846 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
8847 _("debug section data"));
8851 /* See if we know how to display the contents of this section. */
8852 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
8853 name
= ".debug_info";
8855 for (i
= NUM_ELEM (debug_displays
); i
--;)
8856 if (strcmp (debug_displays
[i
].name
, name
) == 0)
8858 debug_displays
[i
].display (section
, start
, file
);
8863 printf (_("Unrecognized debug section: %s\n"), name
);
8867 /* If we loaded in the abbrev section at some point,
8868 we must release it here. */
8875 process_section_contents (file
)
8878 Elf32_Internal_Shdr
* section
;
8884 /* Pre-scan the debug sections to find some debug information not
8885 present in some of them. For the .debug_line, we must find out the
8886 size of address (specified in .debug_info and .debug_aranges). */
8887 for (i
= 0, section
= section_headers
;
8888 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8891 char * name
= SECTION_NAME (section
);
8894 if (section
->sh_size
== 0)
8897 /* See if there is some pre-scan operation for this section. */
8898 for (j
= NUM_ELEM (debug_displays
); j
--;)
8899 if (strcmp (debug_displays
[j
].name
, name
) == 0)
8901 if (debug_displays
[j
].prescan
!= NULL
)
8903 bfd_size_type length
;
8904 unsigned char * start
;
8906 length
= section
->sh_size
;
8907 start
= ((unsigned char *)
8908 get_data (NULL
, file
, section
->sh_offset
, length
,
8909 _("debug section data")));
8913 debug_displays
[j
].prescan (section
, start
, file
);
8921 for (i
= 0, section
= section_headers
;
8922 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8925 #ifdef SUPPORT_DISASSEMBLY
8926 if (dump_sects
[i
] & DISASS_DUMP
)
8927 disassemble_section (section
, file
);
8929 if (dump_sects
[i
] & HEX_DUMP
)
8930 dump_section (section
, file
);
8932 if (dump_sects
[i
] & DEBUG_DUMP
)
8933 display_debug_section (section
, file
);
8936 if (i
< num_dump_sects
)
8937 warn (_("Some sections were not dumped because they do not exist!\n"));
8943 process_mips_fpe_exception (mask
)
8949 if (mask
& OEX_FPU_INEX
)
8950 fputs ("INEX", stdout
), first
= 0;
8951 if (mask
& OEX_FPU_UFLO
)
8952 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8953 if (mask
& OEX_FPU_OFLO
)
8954 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8955 if (mask
& OEX_FPU_DIV0
)
8956 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8957 if (mask
& OEX_FPU_INVAL
)
8958 printf ("%sINVAL", first
? "" : "|");
8961 fputs ("0", stdout
);
8965 process_mips_specific (file
)
8968 Elf_Internal_Dyn
* entry
;
8969 size_t liblist_offset
= 0;
8970 size_t liblistno
= 0;
8971 size_t conflictsno
= 0;
8972 size_t options_offset
= 0;
8973 size_t conflicts_offset
= 0;
8975 /* We have a lot of special sections. Thanks SGI! */
8976 if (dynamic_segment
== NULL
)
8977 /* No information available. */
8980 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
8981 switch (entry
->d_tag
)
8983 case DT_MIPS_LIBLIST
:
8984 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
8986 case DT_MIPS_LIBLISTNO
:
8987 liblistno
= entry
->d_un
.d_val
;
8989 case DT_MIPS_OPTIONS
:
8990 options_offset
= entry
->d_un
.d_val
- loadaddr
;
8992 case DT_MIPS_CONFLICT
:
8993 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
8995 case DT_MIPS_CONFLICTNO
:
8996 conflictsno
= entry
->d_un
.d_val
;
9002 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9004 Elf32_External_Lib
* elib
;
9007 elib
= ((Elf32_External_Lib
*)
9008 get_data (NULL
, file
, liblist_offset
,
9009 liblistno
* sizeof (Elf32_External_Lib
),
9013 printf ("\nSection '.liblist' contains %lu entries:\n",
9014 (unsigned long) liblistno
);
9015 fputs (" Library Time Stamp Checksum Version Flags\n",
9018 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9025 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9026 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9027 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9028 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9029 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9031 tmp
= gmtime (&time
);
9032 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9033 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9034 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9036 printf ("%3lu: ", (unsigned long) cnt
);
9037 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9038 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9041 if (liblist
.l_flags
== 0)
9052 { " EXACT_MATCH", LL_EXACT_MATCH
},
9053 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9054 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9055 { " EXPORTS", LL_EXPORTS
},
9056 { " DELAY_LOAD", LL_DELAY_LOAD
},
9057 { " DELTA", LL_DELTA
}
9059 int flags
= liblist
.l_flags
;
9063 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9065 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9067 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9068 flags
^= l_flags_vals
[fcnt
].bit
;
9071 printf (" %#x", (unsigned int) flags
);
9081 if (options_offset
!= 0)
9083 Elf_External_Options
* eopt
;
9084 Elf_Internal_Shdr
* sect
= section_headers
;
9085 Elf_Internal_Options
* iopt
;
9086 Elf_Internal_Options
* option
;
9090 /* Find the section header so that we get the size. */
9091 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9094 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9095 sect
->sh_size
, _("options"));
9098 iopt
= ((Elf_Internal_Options
*)
9099 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
9102 error (_("Out of memory"));
9109 while (offset
< sect
->sh_size
)
9111 Elf_External_Options
* eoption
;
9113 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9115 option
->kind
= BYTE_GET (eoption
->kind
);
9116 option
->size
= BYTE_GET (eoption
->size
);
9117 option
->section
= BYTE_GET (eoption
->section
);
9118 option
->info
= BYTE_GET (eoption
->info
);
9120 offset
+= option
->size
;
9126 printf (_("\nSection '%s' contains %d entries:\n"),
9127 SECTION_NAME (sect
), cnt
);
9135 switch (option
->kind
)
9138 /* This shouldn't happen. */
9139 printf (" NULL %d %lx", option
->section
, option
->info
);
9142 printf (" REGINFO ");
9143 if (elf_header
.e_machine
== EM_MIPS
)
9146 Elf32_External_RegInfo
* ereg
;
9147 Elf32_RegInfo reginfo
;
9149 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9150 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9151 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9152 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9153 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9154 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9155 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9157 printf ("GPR %08lx GP 0x%lx\n",
9159 (unsigned long) reginfo
.ri_gp_value
);
9160 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9161 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9162 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9167 Elf64_External_RegInfo
* ereg
;
9168 Elf64_Internal_RegInfo reginfo
;
9170 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9171 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9172 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9173 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9174 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9175 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9176 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9178 printf ("GPR %08lx GP 0x",
9179 reginfo
.ri_gprmask
);
9180 printf_vma (reginfo
.ri_gp_value
);
9183 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9184 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9185 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9189 case ODK_EXCEPTIONS
:
9190 fputs (" EXCEPTIONS fpe_min(", stdout
);
9191 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9192 fputs (") fpe_max(", stdout
);
9193 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9194 fputs (")", stdout
);
9196 if (option
->info
& OEX_PAGE0
)
9197 fputs (" PAGE0", stdout
);
9198 if (option
->info
& OEX_SMM
)
9199 fputs (" SMM", stdout
);
9200 if (option
->info
& OEX_FPDBUG
)
9201 fputs (" FPDBUG", stdout
);
9202 if (option
->info
& OEX_DISMISS
)
9203 fputs (" DISMISS", stdout
);
9206 fputs (" PAD ", stdout
);
9207 if (option
->info
& OPAD_PREFIX
)
9208 fputs (" PREFIX", stdout
);
9209 if (option
->info
& OPAD_POSTFIX
)
9210 fputs (" POSTFIX", stdout
);
9211 if (option
->info
& OPAD_SYMBOL
)
9212 fputs (" SYMBOL", stdout
);
9215 fputs (" HWPATCH ", stdout
);
9216 if (option
->info
& OHW_R4KEOP
)
9217 fputs (" R4KEOP", stdout
);
9218 if (option
->info
& OHW_R8KPFETCH
)
9219 fputs (" R8KPFETCH", stdout
);
9220 if (option
->info
& OHW_R5KEOP
)
9221 fputs (" R5KEOP", stdout
);
9222 if (option
->info
& OHW_R5KCVTL
)
9223 fputs (" R5KCVTL", stdout
);
9226 fputs (" FILL ", stdout
);
9227 /* XXX Print content of info word? */
9230 fputs (" TAGS ", stdout
);
9231 /* XXX Print content of info word? */
9234 fputs (" HWAND ", stdout
);
9235 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9236 fputs (" R4KEOP_CHECKED", stdout
);
9237 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9238 fputs (" R4KEOP_CLEAN", stdout
);
9241 fputs (" HWOR ", stdout
);
9242 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9243 fputs (" R4KEOP_CHECKED", stdout
);
9244 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9245 fputs (" R4KEOP_CLEAN", stdout
);
9248 printf (" GP_GROUP %#06lx self-contained %#06lx",
9249 option
->info
& OGP_GROUP
,
9250 (option
->info
& OGP_SELF
) >> 16);
9253 printf (" IDENT %#06lx self-contained %#06lx",
9254 option
->info
& OGP_GROUP
,
9255 (option
->info
& OGP_SELF
) >> 16);
9258 /* This shouldn't happen. */
9259 printf (" %3d ??? %d %lx",
9260 option
->kind
, option
->section
, option
->info
);
9264 len
= sizeof (* eopt
);
9265 while (len
< option
->size
)
9266 if (((char *) option
)[len
] >= ' '
9267 && ((char *) option
)[len
] < 0x7f)
9268 printf ("%c", ((char *) option
)[len
++]);
9270 printf ("\\%03o", ((char *) option
)[len
++]);
9272 fputs ("\n", stdout
);
9280 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9282 Elf32_Conflict
* iconf
;
9285 if (dynamic_symbols
== NULL
)
9287 error (_("conflict list found without a dynamic symbol table"));
9291 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
9294 error (_("Out of memory"));
9300 Elf32_External_Conflict
* econf32
;
9302 econf32
= ((Elf32_External_Conflict
*)
9303 get_data (NULL
, file
, conflicts_offset
,
9304 conflictsno
* sizeof (* econf32
),
9309 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9310 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9316 Elf64_External_Conflict
* econf64
;
9318 econf64
= ((Elf64_External_Conflict
*)
9319 get_data (NULL
, file
, conflicts_offset
,
9320 conflictsno
* sizeof (* econf64
),
9325 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9326 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9331 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9332 (long) conflictsno
);
9333 puts (_(" Num: Index Value Name"));
9335 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9337 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9339 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9340 print_vma (psym
->st_value
, FULL_HEX
);
9342 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9353 get_note_type (e_type
)
9356 static char buff
[64];
9360 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9361 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9362 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9363 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9364 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9365 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9366 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9367 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9368 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9369 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9370 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9372 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9378 get_netbsd_elfcore_note_type (e_type
)
9381 static char buff
[64];
9383 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9385 /* NetBSD core "procinfo" structure. */
9386 return _("NetBSD procinfo structure");
9389 /* As of Jan 2002 there are no other machine-independent notes
9390 defined for NetBSD core files. If the note type is less
9391 than the start of the machine-dependent note types, we don't
9394 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9396 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9400 switch (elf_header
.e_machine
)
9402 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9403 and PT_GETFPREGS == mach+2. */
9408 case EM_SPARC32PLUS
:
9412 case NT_NETBSDCORE_FIRSTMACH
+0:
9413 return _("PT_GETREGS (reg structure)");
9414 case NT_NETBSDCORE_FIRSTMACH
+2:
9415 return _("PT_GETFPREGS (fpreg structure)");
9421 /* On all other arch's, PT_GETREGS == mach+1 and
9422 PT_GETFPREGS == mach+3. */
9426 case NT_NETBSDCORE_FIRSTMACH
+1:
9427 return _("PT_GETREGS (reg structure)");
9428 case NT_NETBSDCORE_FIRSTMACH
+3:
9429 return _("PT_GETFPREGS (fpreg structure)");
9435 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9439 /* Note that by the ELF standard, the name field is already null byte
9440 terminated, and namesz includes the terminating null byte.
9441 I.E. the value of namesz for the name "FSF" is 4.
9443 If the value of namesz is zero, there is no name present. */
9445 process_note (pnote
)
9446 Elf32_Internal_Note
* pnote
;
9450 if (pnote
->namesz
== 0)
9452 /* If there is no note name, then use the default set of
9453 note type strings. */
9454 nt
= get_note_type (pnote
->type
);
9456 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9458 /* NetBSD-specific core file notes. */
9459 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9463 /* Don't recognize this note name; just use the default set of
9464 note type strings. */
9465 nt
= get_note_type (pnote
->type
);
9468 printf (" %s\t\t0x%08lx\t%s\n",
9469 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9476 process_corefile_note_segment (file
, offset
, length
)
9481 Elf_External_Note
* pnotes
;
9482 Elf_External_Note
* external
;
9488 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9495 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9496 (unsigned long) offset
, (unsigned long) length
);
9497 printf (_(" Owner\t\tData size\tDescription\n"));
9499 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9501 Elf_External_Note
* next
;
9502 Elf32_Internal_Note inote
;
9505 inote
.type
= BYTE_GET (external
->type
);
9506 inote
.namesz
= BYTE_GET (external
->namesz
);
9507 inote
.namedata
= external
->name
;
9508 inote
.descsz
= BYTE_GET (external
->descsz
);
9509 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9510 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9512 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9514 if (((char *) next
) > (((char *) pnotes
) + length
))
9516 warn (_("corrupt note found at offset %x into core notes\n"),
9517 ((char *) external
) - ((char *) pnotes
));
9518 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9519 inote
.type
, inote
.namesz
, inote
.descsz
);
9525 /* Verify that name is null terminated. It appears that at least
9526 one version of Linux (RedHat 6.0) generates corefiles that don't
9527 comply with the ELF spec by failing to include the null byte in
9529 if (inote
.namedata
[inote
.namesz
] != '\0')
9531 temp
= malloc (inote
.namesz
+ 1);
9535 error (_("Out of memory\n"));
9540 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9541 temp
[inote
.namesz
] = 0;
9543 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9544 inote
.namedata
= temp
;
9547 res
&= process_note (& inote
);
9562 process_corefile_note_segments (file
)
9565 Elf_Internal_Phdr
* program_headers
;
9566 Elf_Internal_Phdr
* segment
;
9570 program_headers
= (Elf_Internal_Phdr
*) malloc
9571 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9573 if (program_headers
== NULL
)
9575 error (_("Out of memory\n"));
9580 i
= get_32bit_program_headers (file
, program_headers
);
9582 i
= get_64bit_program_headers (file
, program_headers
);
9586 free (program_headers
);
9590 for (i
= 0, segment
= program_headers
;
9591 i
< elf_header
.e_phnum
;
9594 if (segment
->p_type
== PT_NOTE
)
9595 res
&= process_corefile_note_segment (file
,
9596 (bfd_vma
) segment
->p_offset
,
9597 (bfd_vma
) segment
->p_filesz
);
9600 free (program_headers
);
9606 process_corefile_contents (file
)
9609 /* If we have not been asked to display the notes then do nothing. */
9613 /* If file is not a core file then exit. */
9614 if (elf_header
.e_type
!= ET_CORE
)
9617 /* No program headers means no NOTE segment. */
9618 if (elf_header
.e_phnum
== 0)
9620 printf (_("No note segments present in the core file.\n"));
9624 return process_corefile_note_segments (file
);
9628 process_arch_specific (file
)
9634 switch (elf_header
.e_machine
)
9637 case EM_MIPS_RS3_LE
:
9638 return process_mips_specific (file
);
9647 get_file_header (file
)
9650 /* Read in the identity array. */
9651 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9654 /* Determine how to read the rest of the header. */
9655 switch (elf_header
.e_ident
[EI_DATA
])
9657 default: /* fall through */
9658 case ELFDATANONE
: /* fall through */
9659 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9660 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9663 /* For now we only support 32 bit and 64 bit ELF files. */
9664 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9666 /* Read in the rest of the header. */
9669 Elf32_External_Ehdr ehdr32
;
9671 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9674 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9675 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9676 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9677 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9678 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9679 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9680 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9681 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9682 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9683 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9684 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9685 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9686 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9690 Elf64_External_Ehdr ehdr64
;
9692 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9693 we will not be able to cope with the 64bit data found in
9694 64 ELF files. Detect this now and abort before we start
9695 overwritting things. */
9696 if (sizeof (bfd_vma
) < 8)
9698 error (_("This instance of readelf has been built without support for a\n\
9699 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9703 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9706 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9707 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9708 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9709 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9710 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9711 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9712 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9713 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9714 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9715 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9716 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9717 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9718 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9721 if (elf_header
.e_shoff
)
9723 /* There may be some extensions in the first section header. Don't
9724 bomb if we can't read it. */
9726 get_32bit_section_headers (file
, 1);
9728 get_64bit_section_headers (file
, 1);
9735 process_file (file_name
)
9739 struct stat statbuf
;
9742 if (stat (file_name
, & statbuf
) < 0)
9744 error (_("Cannot stat input file %s.\n"), file_name
);
9748 file
= fopen (file_name
, "rb");
9751 error (_("Input file %s not found.\n"), file_name
);
9755 if (! get_file_header (file
))
9757 error (_("%s: Failed to read file header\n"), file_name
);
9762 /* Initialise per file variables. */
9763 for (i
= NUM_ELEM (version_info
); i
--;)
9764 version_info
[i
] = 0;
9766 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9767 dynamic_info
[i
] = 0;
9769 /* Process the file. */
9771 printf (_("\nFile: %s\n"), file_name
);
9773 if (! process_file_header ())
9779 process_section_headers (file
);
9781 process_program_headers (file
);
9783 process_dynamic_segment (file
);
9785 process_relocs (file
);
9787 process_unwind (file
);
9789 process_symbol_table (file
);
9791 process_syminfo (file
);
9793 process_version_sections (file
);
9795 process_section_contents (file
);
9797 process_corefile_contents (file
);
9799 process_arch_specific (file
);
9803 if (section_headers
)
9805 free (section_headers
);
9806 section_headers
= NULL
;
9811 free (string_table
);
9812 string_table
= NULL
;
9813 string_table_length
= 0;
9816 if (dynamic_strings
)
9818 free (dynamic_strings
);
9819 dynamic_strings
= NULL
;
9822 if (dynamic_symbols
)
9824 free (dynamic_symbols
);
9825 dynamic_symbols
= NULL
;
9826 num_dynamic_syms
= 0;
9829 if (dynamic_syminfo
)
9831 free (dynamic_syminfo
);
9832 dynamic_syminfo
= NULL
;
9838 #ifdef SUPPORT_DISASSEMBLY
9839 /* Needed by the i386 disassembler. For extra credit, someone could
9840 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9844 print_address (unsigned int addr
, FILE * outfile
)
9846 fprintf (outfile
,"0x%8.8x", addr
);
9849 /* Needed by the i386 disassembler. */
9851 db_task_printsym (unsigned int addr
)
9853 print_address (addr
, stderr
);
9857 int main
PARAMS ((int, char **));
9866 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9867 setlocale (LC_MESSAGES
, "");
9869 #if defined (HAVE_SETLOCALE)
9870 setlocale (LC_CTYPE
, "");
9872 bindtextdomain (PACKAGE
, LOCALEDIR
);
9873 textdomain (PACKAGE
);
9875 parse_args (argc
, argv
);
9877 if (optind
< (argc
- 1))
9881 while (optind
< argc
)
9882 err
|= process_file (argv
[optind
++]);
9884 if (dump_sects
!= NULL
)