1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we belive that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
52 #include "elf/alpha.h"
70 #include "elf/m68hc11.h"
71 #include "elf/mcore.h"
74 #include "elf/mn10200.h"
75 #include "elf/mn10300.h"
81 #include "elf/sparc.h"
84 #include "elf/x86-64.h"
85 #include "elf/xstormy16.h"
90 char * program_name
= "readelf";
91 unsigned int dynamic_addr
;
92 bfd_size_type dynamic_size
;
93 unsigned int rela_addr
;
94 unsigned int rela_size
;
95 char * dynamic_strings
;
97 unsigned long string_table_length
;
98 unsigned long num_dynamic_syms
;
99 Elf_Internal_Sym
* dynamic_symbols
;
100 Elf_Internal_Syminfo
* dynamic_syminfo
;
101 unsigned long dynamic_syminfo_offset
;
102 unsigned int dynamic_syminfo_nent
;
103 char program_interpreter
[64];
104 int dynamic_info
[DT_JMPREL
+ 1];
105 int version_info
[16];
107 Elf_Internal_Ehdr elf_header
;
108 Elf_Internal_Shdr
* section_headers
;
109 Elf_Internal_Dyn
* dynamic_segment
;
110 Elf_Internal_Shdr
* symtab_shndx_hdr
;
118 int do_using_dynamic
;
126 int do_debug_abbrevs
;
128 int do_debug_pubnames
;
129 int do_debug_aranges
;
131 int do_debug_frames_interp
;
132 int do_debug_macinfo
;
139 /* A dynamic array of flags indicating which sections require dumping. */
140 char * dump_sects
= NULL
;
141 unsigned int num_dump_sects
= 0;
143 #define HEX_DUMP (1 << 0)
144 #define DISASS_DUMP (1 << 1)
145 #define DEBUG_DUMP (1 << 2)
147 /* How to rpint a vma value. */
148 typedef enum print_mode
160 /* Forward declarations for dumb compilers. */
161 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
162 static void print_symbol
PARAMS ((int, char *));
163 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
164 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
165 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
166 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
167 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
168 static const char * get_ppc64_dynamic_type
PARAMS ((unsigned long));
169 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
170 static const char * get_dynamic_type
PARAMS ((unsigned long));
171 static int slurp_rela_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**, unsigned long *));
172 static int slurp_rel_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel
**, unsigned long *));
173 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
174 static char * get_file_type
PARAMS ((unsigned));
175 static char * get_machine_name
PARAMS ((unsigned));
176 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
177 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
178 static const char * get_mips_segment_type
PARAMS ((unsigned long));
179 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
180 static const char * get_ia64_segment_type
PARAMS ((unsigned long));
181 static const char * get_segment_type
PARAMS ((unsigned long));
182 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
183 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
184 static const char * get_ia64_section_type_name
PARAMS ((unsigned int));
185 static const char * get_section_type_name
PARAMS ((unsigned int));
186 static const char * get_symbol_binding
PARAMS ((unsigned int));
187 static const char * get_symbol_type
PARAMS ((unsigned int));
188 static const char * get_symbol_visibility
PARAMS ((unsigned int));
189 static const char * get_symbol_index_type
PARAMS ((unsigned int));
190 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
191 static void usage
PARAMS ((void));
192 static void parse_args
PARAMS ((int, char **));
193 static int process_file_header
PARAMS ((void));
194 static int process_program_headers
PARAMS ((FILE *));
195 static int process_section_headers
PARAMS ((FILE *));
196 static int process_unwind
PARAMS ((FILE *));
197 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
198 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
199 static int process_dynamic_segment
PARAMS ((FILE *));
200 static int process_symbol_table
PARAMS ((FILE *));
201 static int process_syminfo
PARAMS ((FILE *));
202 static int process_section_contents
PARAMS ((FILE *));
203 static void process_mips_fpe_exception
PARAMS ((int));
204 static int process_mips_specific
PARAMS ((FILE *));
205 static int process_file
PARAMS ((char *));
206 static int process_relocs
PARAMS ((FILE *));
207 static int process_version_sections
PARAMS ((FILE *));
208 static char * get_ver_flags
PARAMS ((unsigned int));
209 static int get_32bit_section_headers
PARAMS ((FILE *, unsigned int));
210 static int get_64bit_section_headers
PARAMS ((FILE *, unsigned int));
211 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
212 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
213 static int get_file_header
PARAMS ((FILE *));
214 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
215 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, Elf_Internal_Shdr
*));
216 static const char * get_elf_section_flags
PARAMS ((bfd_vma
));
217 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
218 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
219 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
220 #ifdef SUPPORT_DISASSEMBLY
221 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
223 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
224 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
225 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
226 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
227 static int prescan_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
228 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
229 static int display_debug_pubnames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
230 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
231 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
232 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
233 static int display_debug_macinfo
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
234 static int display_debug_str
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
235 static int display_debug_loc
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
236 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
237 static void load_debug_str
PARAMS ((FILE *));
238 static void free_debug_str
PARAMS ((void));
239 static const char * fetch_indirect_string
PARAMS ((unsigned long));
240 static void load_debug_loc
PARAMS ((FILE *));
241 static void free_debug_loc
PARAMS ((void));
242 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
243 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
244 static void reset_state_machine
PARAMS ((int));
245 static char * get_TAG_name
PARAMS ((unsigned long));
246 static char * get_AT_name
PARAMS ((unsigned long));
247 static char * get_FORM_name
PARAMS ((unsigned long));
248 static void free_abbrevs
PARAMS ((void));
249 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
250 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
251 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
252 static unsigned char * read_and_display_attr_value
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
253 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
254 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
255 static void request_dump
PARAMS ((unsigned int, int));
256 static const char * get_elf_class
PARAMS ((unsigned int));
257 static const char * get_data_encoding
PARAMS ((unsigned int));
258 static const char * get_osabi_name
PARAMS ((unsigned int));
259 static int guess_is_rela
PARAMS ((unsigned long));
260 static const char * get_note_type
PARAMS ((unsigned int));
261 static const char * get_netbsd_elfcore_note_type
PARAMS ((unsigned int));
262 static int process_note
PARAMS ((Elf32_Internal_Note
*));
263 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
264 static int process_corefile_note_segments
PARAMS ((FILE *));
265 static int process_corefile_contents
PARAMS ((FILE *));
266 static int process_arch_specific
PARAMS ((FILE *));
267 static int process_gnu_liblist
PARAMS ((FILE *));
269 typedef int Elf32_Word
;
277 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
278 ((X)->sh_name >= string_table_length \
279 ? "<corrupt>" : string_table + (X)->sh_name))
281 /* Given st_shndx I, map to section_headers index. */
282 #define SECTION_HEADER_INDEX(I) \
283 ((I) < SHN_LORESERVE \
285 : ((I) <= SHN_HIRESERVE \
287 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
289 /* Reverse of the above. */
290 #define SECTION_HEADER_NUM(N) \
291 ((N) < SHN_LORESERVE \
293 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
295 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
297 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
299 #define BYTE_GET(field) byte_get (field, sizeof (field))
301 /* If we can support a 64 bit data type then BFD64 should be defined
302 and sizeof (bfd_vma) == 8. In this case when translating from an
303 external 8 byte field to an internal field, we can assume that the
304 internal field is also 8 bytes wide and so we can extract all the data.
305 If, however, BFD64 is not defined, then we must assume that the
306 internal data structure only has 4 byte wide fields that are the
307 equivalent of the 8 byte wide external counterparts, and so we must
308 truncate the data. */
310 #define BYTE_GET8(field) byte_get (field, -8)
312 #define BYTE_GET8(field) byte_get (field, 8)
315 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
317 #define GET_ELF_SYMBOLS(file, section) \
318 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
319 : get_64bit_elf_symbols (file, section))
323 error
VPARAMS ((const char *message
, ...))
325 VA_OPEN (args
, message
);
326 VA_FIXEDARG (args
, const char *, message
);
328 fprintf (stderr
, _("%s: Error: "), program_name
);
329 vfprintf (stderr
, message
, args
);
334 warn
VPARAMS ((const char *message
, ...))
336 VA_OPEN (args
, message
);
337 VA_FIXEDARG (args
, const char *, message
);
339 fprintf (stderr
, _("%s: Warning: "), program_name
);
340 vfprintf (stderr
, message
, args
);
344 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
347 get_data (var
, file
, offset
, size
, reason
)
359 if (fseek (file
, offset
, SEEK_SET
))
361 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
368 mvar
= (PTR
) malloc (size
);
372 error (_("Out of memory allocating %d bytes for %s\n"),
378 if (fread (mvar
, size
, 1, file
) != 1)
380 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
390 byte_get_little_endian (field
, size
)
391 unsigned char * field
;
400 return ((unsigned int) (field
[0]))
401 | (((unsigned int) (field
[1])) << 8);
405 /* We want to extract data from an 8 byte wide field and
406 place it into a 4 byte wide field. Since this is a little
407 endian source we can juts use the 4 byte extraction code. */
411 return ((unsigned long) (field
[0]))
412 | (((unsigned long) (field
[1])) << 8)
413 | (((unsigned long) (field
[2])) << 16)
414 | (((unsigned long) (field
[3])) << 24);
419 /* This is a special case, generated by the BYTE_GET8 macro.
420 It means that we are loading an 8 byte value from a field
421 in an external structure into an 8 byte value in a field
422 in an internal strcuture. */
423 return ((bfd_vma
) (field
[0]))
424 | (((bfd_vma
) (field
[1])) << 8)
425 | (((bfd_vma
) (field
[2])) << 16)
426 | (((bfd_vma
) (field
[3])) << 24)
427 | (((bfd_vma
) (field
[4])) << 32)
428 | (((bfd_vma
) (field
[5])) << 40)
429 | (((bfd_vma
) (field
[6])) << 48)
430 | (((bfd_vma
) (field
[7])) << 56);
433 error (_("Unhandled data length: %d\n"), size
);
438 /* Print a VMA value. */
440 print_vma (vma
, mode
)
450 case FULL_HEX
: printf ("0x"); /* drop through */
451 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
452 case PREFIX_HEX
: printf ("0x"); /* drop through */
453 case HEX
: printf ("%lx", (unsigned long) vma
); break;
454 case DEC
: printf ("%ld", (unsigned long) vma
); break;
455 case DEC_5
: printf ("%5ld", (long) vma
); break;
456 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
477 #if BFD_HOST_64BIT_LONG
480 if (_bfd_int64_high (vma
))
481 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
483 printf ("%lx", _bfd_int64_low (vma
));
488 #if BFD_HOST_64BIT_LONG
491 if (_bfd_int64_high (vma
))
493 printf ("++%ld", _bfd_int64_low (vma
));
495 printf ("%ld", _bfd_int64_low (vma
));
500 #if BFD_HOST_64BIT_LONG
501 printf ("%5ld", vma
);
503 if (_bfd_int64_high (vma
))
505 printf ("++%ld", _bfd_int64_low (vma
));
507 printf ("%5ld", _bfd_int64_low (vma
));
512 #if BFD_HOST_64BIT_LONG
515 if (_bfd_int64_high (vma
))
517 printf ("++%lu", _bfd_int64_low (vma
));
519 printf ("%lu", _bfd_int64_low (vma
));
527 /* Display a symbol on stdout. If do_wide is not true then
528 format the symbol to be at most WIDTH characters,
529 truncating as necessary. If WIDTH is negative then
530 format the string to be exactly - WIDTH characters,
531 truncating or padding as necessary. */
534 print_symbol (width
, symbol
)
541 printf ("%-*.*s", width
, width
, symbol
);
543 printf ("%-.*s", width
, symbol
);
547 byte_get_big_endian (field
, size
)
548 unsigned char * field
;
557 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
560 return ((unsigned long) (field
[3]))
561 | (((unsigned long) (field
[2])) << 8)
562 | (((unsigned long) (field
[1])) << 16)
563 | (((unsigned long) (field
[0])) << 24);
567 /* Although we are extracing data from an 8 byte wide field, we
568 are returning only 4 bytes of data. */
569 return ((unsigned long) (field
[7]))
570 | (((unsigned long) (field
[6])) << 8)
571 | (((unsigned long) (field
[5])) << 16)
572 | (((unsigned long) (field
[4])) << 24);
576 /* This is a special case, generated by the BYTE_GET8 macro.
577 It means that we are loading an 8 byte value from a field
578 in an external structure into an 8 byte value in a field
579 in an internal strcuture. */
580 return ((bfd_vma
) (field
[7]))
581 | (((bfd_vma
) (field
[6])) << 8)
582 | (((bfd_vma
) (field
[5])) << 16)
583 | (((bfd_vma
) (field
[4])) << 24)
584 | (((bfd_vma
) (field
[3])) << 32)
585 | (((bfd_vma
) (field
[2])) << 40)
586 | (((bfd_vma
) (field
[1])) << 48)
587 | (((bfd_vma
) (field
[0])) << 56);
591 error (_("Unhandled data length: %d\n"), size
);
596 /* Guess the relocation size commonly used by the specific machines. */
599 guess_is_rela (e_machine
)
600 unsigned long e_machine
;
604 /* Targets that use REL relocations. */
620 /* Targets that use RELA relocations. */
635 case EM_CYGNUS_MN10200
:
637 case EM_CYGNUS_MN10300
:
675 warn (_("Don't know about relocations on this machine architecture\n"));
681 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
683 unsigned long rel_offset
;
684 unsigned long rel_size
;
685 Elf_Internal_Rela
**relasp
;
686 unsigned long *nrelasp
;
688 Elf_Internal_Rela
*relas
;
689 unsigned long nrelas
;
694 Elf32_External_Rela
* erelas
;
696 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
697 rel_size
, _("relocs"));
701 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
703 relas
= (Elf_Internal_Rela
*)
704 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
708 error(_("out of memory parsing relocs"));
712 for (i
= 0; i
< nrelas
; i
++)
714 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
715 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
716 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
723 Elf64_External_Rela
* erelas
;
725 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
726 rel_size
, _("relocs"));
730 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
732 relas
= (Elf_Internal_Rela
*)
733 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
737 error(_("out of memory parsing relocs"));
741 for (i
= 0; i
< nrelas
; i
++)
743 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
744 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
745 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
756 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
758 unsigned long rel_offset
;
759 unsigned long rel_size
;
760 Elf_Internal_Rel
**relsp
;
761 unsigned long *nrelsp
;
763 Elf_Internal_Rel
*rels
;
769 Elf32_External_Rel
* erels
;
771 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
772 rel_size
, _("relocs"));
776 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
778 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
782 error(_("out of memory parsing relocs"));
786 for (i
= 0; i
< nrels
; i
++)
788 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
789 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
796 Elf64_External_Rel
* erels
;
798 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
799 rel_size
, _("relocs"));
803 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
805 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
809 error(_("out of memory parsing relocs"));
813 for (i
= 0; i
< nrels
; i
++)
815 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
816 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
826 /* Display the contents of the relocation data found at the specified offset. */
828 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
830 unsigned long rel_offset
;
831 unsigned long rel_size
;
832 Elf_Internal_Sym
* symtab
;
838 Elf_Internal_Rel
* rels
;
839 Elf_Internal_Rela
* relas
;
842 if (is_rela
== UNKNOWN
)
843 is_rela
= guess_is_rela (elf_header
.e_machine
);
847 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &relas
, &rel_size
))
852 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
861 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
863 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
868 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
870 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
878 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
880 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
885 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
887 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
891 for (i
= 0; i
< rel_size
; i
++)
894 const char * rtype2
= NULL
;
895 const char * rtype3
= NULL
;
898 bfd_vma symtab_index
;
900 bfd_vma type2
= (bfd_vma
) NULL
;
901 bfd_vma type3
= (bfd_vma
) NULL
;
905 offset
= relas
[i
].r_offset
;
906 info
= relas
[i
].r_info
;
910 offset
= rels
[i
].r_offset
;
911 info
= rels
[i
].r_info
;
916 type
= ELF32_R_TYPE (info
);
917 symtab_index
= ELF32_R_SYM (info
);
921 if (elf_header
.e_machine
== EM_MIPS
)
923 type
= ELF64_MIPS_R_TYPE (info
);
924 type2
= ELF64_MIPS_R_TYPE2 (info
);
925 type3
= ELF64_MIPS_R_TYPE3 (info
);
927 else if (elf_header
.e_machine
== EM_SPARCV9
)
928 type
= ELF64_R_TYPE_ID (info
);
930 type
= ELF64_R_TYPE (info
);
931 /* The #ifdef BFD64 below is to prevent a compile time warning.
932 We know that if we do not have a 64 bit data type that we
933 will never execute this code anyway. */
935 symtab_index
= ELF64_R_SYM (info
);
941 #ifdef _bfd_int64_low
942 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
944 printf ("%8.8lx %8.8lx ", offset
, info
);
949 #ifdef _bfd_int64_low
951 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
952 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
953 _bfd_int64_high (offset
),
954 _bfd_int64_low (offset
),
955 _bfd_int64_high (info
),
956 _bfd_int64_low (info
));
959 ? "%16.16lx %16.16lx "
960 : "%12.12lx %12.12lx ",
965 switch (elf_header
.e_machine
)
973 rtype
= elf_m32r_reloc_type (type
);
978 rtype
= elf_i386_reloc_type (type
);
983 rtype
= elf_m68hc11_reloc_type (type
);
987 rtype
= elf_m68k_reloc_type (type
);
991 rtype
= elf_i960_reloc_type (type
);
996 rtype
= elf_avr_reloc_type (type
);
1000 case EM_SPARC32PLUS
:
1003 rtype
= elf_sparc_reloc_type (type
);
1007 case EM_CYGNUS_V850
:
1008 rtype
= v850_reloc_type (type
);
1012 case EM_CYGNUS_D10V
:
1013 rtype
= elf_d10v_reloc_type (type
);
1017 case EM_CYGNUS_D30V
:
1018 rtype
= elf_d30v_reloc_type (type
);
1022 rtype
= elf_dlx_reloc_type (type
);
1026 rtype
= elf_sh_reloc_type (type
);
1030 case EM_CYGNUS_MN10300
:
1031 rtype
= elf_mn10300_reloc_type (type
);
1035 case EM_CYGNUS_MN10200
:
1036 rtype
= elf_mn10200_reloc_type (type
);
1040 case EM_CYGNUS_FR30
:
1041 rtype
= elf_fr30_reloc_type (type
);
1045 rtype
= elf_frv_reloc_type (type
);
1049 rtype
= elf_mcore_reloc_type (type
);
1053 rtype
= elf_mmix_reloc_type (type
);
1058 rtype
= elf_ppc_reloc_type (type
);
1062 case EM_MIPS_RS3_LE
:
1063 rtype
= elf_mips_reloc_type (type
);
1066 rtype2
= elf_mips_reloc_type (type2
);
1067 rtype3
= elf_mips_reloc_type (type3
);
1072 rtype
= elf_alpha_reloc_type (type
);
1076 rtype
= elf_arm_reloc_type (type
);
1080 rtype
= elf_arc_reloc_type (type
);
1084 rtype
= elf_hppa_reloc_type (type
);
1090 rtype
= elf_h8_reloc_type (type
);
1095 rtype
= elf_or32_reloc_type (type
);
1100 rtype
= elf_pj_reloc_type (type
);
1103 rtype
= elf_ia64_reloc_type (type
);
1107 rtype
= elf_cris_reloc_type (type
);
1111 rtype
= elf_i860_reloc_type (type
);
1115 rtype
= elf_x86_64_reloc_type (type
);
1120 rtype
= elf_s390_reloc_type (type
);
1124 rtype
= elf_xstormy16_reloc_type (type
);
1128 rtype
= elf_vax_reloc_type (type
);
1133 #ifdef _bfd_int64_low
1134 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1136 printf (_("unrecognized: %-7lx"), type
);
1139 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1143 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1144 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1147 Elf_Internal_Sym
* psym
;
1149 psym
= symtab
+ symtab_index
;
1152 print_vma (psym
->st_value
, LONG_HEX
);
1153 printf (is_32bit_elf
? " " : " ");
1155 if (psym
->st_name
== 0)
1156 print_symbol (22, SECTION_NAME (section_headers
+ psym
->st_shndx
));
1157 else if (strtab
== NULL
)
1158 printf (_("<string table index %3ld>"), psym
->st_name
);
1160 print_symbol (22, strtab
+ psym
->st_name
);
1163 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
1168 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1169 print_vma (relas
[i
].r_addend
, LONG_HEX
);
1172 if (elf_header
.e_machine
== EM_SPARCV9
1173 && !strcmp (rtype
, "R_SPARC_OLO10"))
1174 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1178 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1180 printf (" Type2: ");
1183 #ifdef _bfd_int64_low
1184 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1186 printf (_("unrecognized: %-7lx"), type2
);
1189 printf ("%-17.17s", rtype2
);
1191 printf("\n Type3: ");
1194 #ifdef _bfd_int64_low
1195 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1197 printf (_("unrecognized: %-7lx"), type3
);
1200 printf ("%-17.17s", rtype3
);
1215 get_mips_dynamic_type (type
)
1220 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1221 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1222 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1223 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1224 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1225 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1226 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1227 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1228 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1229 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1230 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1231 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1232 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1233 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1234 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1235 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1236 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1237 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1238 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1239 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1240 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1241 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1242 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1243 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1244 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1245 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1246 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1247 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1248 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1249 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1250 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1251 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1252 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1253 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1254 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1255 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1256 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1257 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1258 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1259 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1260 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1261 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1262 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1269 get_sparc64_dynamic_type (type
)
1274 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1281 get_ppc64_dynamic_type (type
)
1286 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1287 case DT_PPC64_OPD
: return "PPC64_OPD";
1288 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1295 get_parisc_dynamic_type (type
)
1300 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1301 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1302 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1303 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1304 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1305 case DT_HP_PREINIT
: return "HP_PREINIT";
1306 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1307 case DT_HP_NEEDED
: return "HP_NEEDED";
1308 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1309 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1310 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1311 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1312 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1319 get_dynamic_type (type
)
1322 static char buff
[32];
1326 case DT_NULL
: return "NULL";
1327 case DT_NEEDED
: return "NEEDED";
1328 case DT_PLTRELSZ
: return "PLTRELSZ";
1329 case DT_PLTGOT
: return "PLTGOT";
1330 case DT_HASH
: return "HASH";
1331 case DT_STRTAB
: return "STRTAB";
1332 case DT_SYMTAB
: return "SYMTAB";
1333 case DT_RELA
: return "RELA";
1334 case DT_RELASZ
: return "RELASZ";
1335 case DT_RELAENT
: return "RELAENT";
1336 case DT_STRSZ
: return "STRSZ";
1337 case DT_SYMENT
: return "SYMENT";
1338 case DT_INIT
: return "INIT";
1339 case DT_FINI
: return "FINI";
1340 case DT_SONAME
: return "SONAME";
1341 case DT_RPATH
: return "RPATH";
1342 case DT_SYMBOLIC
: return "SYMBOLIC";
1343 case DT_REL
: return "REL";
1344 case DT_RELSZ
: return "RELSZ";
1345 case DT_RELENT
: return "RELENT";
1346 case DT_PLTREL
: return "PLTREL";
1347 case DT_DEBUG
: return "DEBUG";
1348 case DT_TEXTREL
: return "TEXTREL";
1349 case DT_JMPREL
: return "JMPREL";
1350 case DT_BIND_NOW
: return "BIND_NOW";
1351 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1352 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1353 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1354 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1355 case DT_RUNPATH
: return "RUNPATH";
1356 case DT_FLAGS
: return "FLAGS";
1358 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1359 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1361 case DT_CHECKSUM
: return "CHECKSUM";
1362 case DT_PLTPADSZ
: return "PLTPADSZ";
1363 case DT_MOVEENT
: return "MOVEENT";
1364 case DT_MOVESZ
: return "MOVESZ";
1365 case DT_FEATURE
: return "FEATURE";
1366 case DT_POSFLAG_1
: return "POSFLAG_1";
1367 case DT_SYMINSZ
: return "SYMINSZ";
1368 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1370 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1371 case DT_CONFIG
: return "CONFIG";
1372 case DT_DEPAUDIT
: return "DEPAUDIT";
1373 case DT_AUDIT
: return "AUDIT";
1374 case DT_PLTPAD
: return "PLTPAD";
1375 case DT_MOVETAB
: return "MOVETAB";
1376 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1378 case DT_VERSYM
: return "VERSYM";
1380 case DT_RELACOUNT
: return "RELACOUNT";
1381 case DT_RELCOUNT
: return "RELCOUNT";
1382 case DT_FLAGS_1
: return "FLAGS_1";
1383 case DT_VERDEF
: return "VERDEF";
1384 case DT_VERDEFNUM
: return "VERDEFNUM";
1385 case DT_VERNEED
: return "VERNEED";
1386 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1388 case DT_AUXILIARY
: return "AUXILIARY";
1389 case DT_USED
: return "USED";
1390 case DT_FILTER
: return "FILTER";
1392 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1393 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1394 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1395 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1396 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1399 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1401 const char * result
;
1403 switch (elf_header
.e_machine
)
1406 case EM_MIPS_RS3_LE
:
1407 result
= get_mips_dynamic_type (type
);
1410 result
= get_sparc64_dynamic_type (type
);
1413 result
= get_ppc64_dynamic_type (type
);
1423 sprintf (buff
, _("Processor Specific: %lx"), type
);
1425 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1427 const char * result
;
1429 switch (elf_header
.e_machine
)
1432 result
= get_parisc_dynamic_type (type
);
1442 sprintf (buff
, _("Operating System specific: %lx"), type
);
1445 sprintf (buff
, _("<unknown>: %lx"), type
);
1452 get_file_type (e_type
)
1455 static char buff
[32];
1459 case ET_NONE
: return _("NONE (None)");
1460 case ET_REL
: return _("REL (Relocatable file)");
1461 case ET_EXEC
: return _("EXEC (Executable file)");
1462 case ET_DYN
: return _("DYN (Shared object file)");
1463 case ET_CORE
: return _("CORE (Core file)");
1466 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1467 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1468 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1469 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1471 sprintf (buff
, _("<unknown>: %x"), e_type
);
1477 get_machine_name (e_machine
)
1480 static char buff
[64]; /* XXX */
1484 case EM_NONE
: return _("None");
1485 case EM_M32
: return "WE32100";
1486 case EM_SPARC
: return "Sparc";
1487 case EM_386
: return "Intel 80386";
1488 case EM_68K
: return "MC68000";
1489 case EM_88K
: return "MC88000";
1490 case EM_486
: return "Intel 80486";
1491 case EM_860
: return "Intel 80860";
1492 case EM_MIPS
: return "MIPS R3000";
1493 case EM_S370
: return "IBM System/370";
1494 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1495 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1496 case EM_PARISC
: return "HPPA";
1497 case EM_PPC_OLD
: return "Power PC (old)";
1498 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1499 case EM_960
: return "Intel 90860";
1500 case EM_PPC
: return "PowerPC";
1501 case EM_PPC64
: return "PowerPC64";
1502 case EM_V800
: return "NEC V800";
1503 case EM_FR20
: return "Fujitsu FR20";
1504 case EM_RH32
: return "TRW RH32";
1505 case EM_MCORE
: return "MCORE";
1506 case EM_ARM
: return "ARM";
1507 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1508 case EM_SH
: return "Hitachi SH";
1509 case EM_SPARCV9
: return "Sparc v9";
1510 case EM_TRICORE
: return "Siemens Tricore";
1511 case EM_ARC
: return "ARC";
1512 case EM_H8_300
: return "Hitachi H8/300";
1513 case EM_H8_300H
: return "Hitachi H8/300H";
1514 case EM_H8S
: return "Hitachi H8S";
1515 case EM_H8_500
: return "Hitachi H8/500";
1516 case EM_IA_64
: return "Intel IA-64";
1517 case EM_MIPS_X
: return "Stanford MIPS-X";
1518 case EM_COLDFIRE
: return "Motorola Coldfire";
1519 case EM_68HC12
: return "Motorola M68HC12";
1520 case EM_ALPHA
: return "Alpha";
1521 case EM_CYGNUS_D10V
:
1522 case EM_D10V
: return "d10v";
1523 case EM_CYGNUS_D30V
:
1524 case EM_D30V
: return "d30v";
1525 case EM_CYGNUS_M32R
:
1526 case EM_M32R
: return "Mitsubishi M32r";
1527 case EM_CYGNUS_V850
:
1528 case EM_V850
: return "NEC v850";
1529 case EM_CYGNUS_MN10300
:
1530 case EM_MN10300
: return "mn10300";
1531 case EM_CYGNUS_MN10200
:
1532 case EM_MN10200
: return "mn10200";
1533 case EM_CYGNUS_FR30
:
1534 case EM_FR30
: return "Fujitsu FR30";
1535 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1537 case EM_PJ
: return "picoJava";
1538 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1539 case EM_PCP
: return "Siemens PCP";
1540 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1541 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1542 case EM_STARCORE
: return "Motorola Star*Core processor";
1543 case EM_ME16
: return "Toyota ME16 processor";
1544 case EM_ST100
: return "STMicroelectronics ST100 processor";
1545 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1546 case EM_FX66
: return "Siemens FX66 microcontroller";
1547 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1548 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1549 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1550 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1551 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1552 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1553 case EM_SVX
: return "Silicon Graphics SVx";
1554 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1555 case EM_VAX
: return "Digital VAX";
1557 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1558 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1559 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1560 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1561 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1562 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1563 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1564 case EM_PRISM
: return "SiTera Prism";
1565 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1567 case EM_S390
: return "IBM S/390";
1568 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1570 case EM_OR32
: return "OpenRISC";
1571 case EM_DLX
: return "OpenDLX";
1573 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1579 decode_ARM_machine_flags (e_flags
, buf
)
1586 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1587 e_flags
&= ~ EF_ARM_EABIMASK
;
1589 /* Handle "generic" ARM flags. */
1590 if (e_flags
& EF_ARM_RELEXEC
)
1592 strcat (buf
, ", relocatable executable");
1593 e_flags
&= ~ EF_ARM_RELEXEC
;
1596 if (e_flags
& EF_ARM_HASENTRY
)
1598 strcat (buf
, ", has entry point");
1599 e_flags
&= ~ EF_ARM_HASENTRY
;
1602 /* Now handle EABI specific flags. */
1606 strcat (buf
, ", <unrecognized EABI>");
1611 case EF_ARM_EABI_VER1
:
1612 strcat (buf
, ", Version1 EABI");
1617 /* Process flags one bit at a time. */
1618 flag
= e_flags
& - e_flags
;
1623 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1624 strcat (buf
, ", sorted symbol tables");
1634 case EF_ARM_EABI_VER2
:
1635 strcat (buf
, ", Version2 EABI");
1640 /* Process flags one bit at a time. */
1641 flag
= e_flags
& - e_flags
;
1646 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1647 strcat (buf
, ", sorted symbol tables");
1650 case EF_ARM_DYNSYMSUSESEGIDX
:
1651 strcat (buf
, ", dynamic symbols use segment index");
1654 case EF_ARM_MAPSYMSFIRST
:
1655 strcat (buf
, ", mapping symbols precede others");
1665 case EF_ARM_EABI_UNKNOWN
:
1666 strcat (buf
, ", GNU EABI");
1671 /* Process flags one bit at a time. */
1672 flag
= e_flags
& - e_flags
;
1677 case EF_ARM_INTERWORK
:
1678 strcat (buf
, ", interworking enabled");
1681 case EF_ARM_APCS_26
:
1682 strcat (buf
, ", uses APCS/26");
1685 case EF_ARM_APCS_FLOAT
:
1686 strcat (buf
, ", uses APCS/float");
1690 strcat (buf
, ", position independent");
1694 strcat (buf
, ", 8 bit structure alignment");
1697 case EF_ARM_NEW_ABI
:
1698 strcat (buf
, ", uses new ABI");
1701 case EF_ARM_OLD_ABI
:
1702 strcat (buf
, ", uses old ABI");
1705 case EF_ARM_SOFT_FLOAT
:
1706 strcat (buf
, ", software FP");
1717 strcat (buf
,", <unknown>");
1721 get_machine_flags (e_flags
, e_machine
)
1725 static char buf
[1024];
1737 decode_ARM_machine_flags (e_flags
, buf
);
1741 if (e_flags
& EF_CPU32
)
1742 strcat (buf
, ", cpu32");
1743 if (e_flags
& EF_M68000
)
1744 strcat (buf
, ", m68000");
1748 if (e_flags
& EF_PPC_EMB
)
1749 strcat (buf
, ", emb");
1751 if (e_flags
& EF_PPC_RELOCATABLE
)
1752 strcat (buf
, ", relocatable");
1754 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1755 strcat (buf
, ", relocatable-lib");
1759 case EM_CYGNUS_V850
:
1760 switch (e_flags
& EF_V850_ARCH
)
1763 strcat (buf
, ", v850e");
1766 strcat (buf
, ", v850ea");
1769 strcat (buf
, ", v850");
1772 strcat (buf
, ", unknown v850 architecture variant");
1778 case EM_CYGNUS_M32R
:
1779 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1780 strcat (buf
, ", m32r");
1785 case EM_MIPS_RS3_LE
:
1786 if (e_flags
& EF_MIPS_NOREORDER
)
1787 strcat (buf
, ", noreorder");
1789 if (e_flags
& EF_MIPS_PIC
)
1790 strcat (buf
, ", pic");
1792 if (e_flags
& EF_MIPS_CPIC
)
1793 strcat (buf
, ", cpic");
1795 if (e_flags
& EF_MIPS_UCODE
)
1796 strcat (buf
, ", ugen_reserved");
1798 if (e_flags
& EF_MIPS_ABI2
)
1799 strcat (buf
, ", abi2");
1801 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1802 strcat (buf
, ", odk first");
1804 if (e_flags
& EF_MIPS_32BITMODE
)
1805 strcat (buf
, ", 32bitmode");
1807 switch ((e_flags
& EF_MIPS_MACH
))
1809 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1810 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1811 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1812 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1813 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1814 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1816 /* We simply ignore the field in this case to avoid confusion:
1817 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1820 default: strcat (buf
, ", unknown CPU"); break;
1823 switch ((e_flags
& EF_MIPS_ABI
))
1825 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1826 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1827 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1828 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1830 /* We simply ignore the field in this case to avoid confusion:
1831 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1832 This means it is likely to be an o32 file, but not for
1835 default: strcat (buf
, ", unknown ABI"); break;
1838 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1839 strcat (buf
, ", mdmx");
1841 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1842 strcat (buf
, ", mips16");
1844 switch ((e_flags
& EF_MIPS_ARCH
))
1846 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1847 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1848 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1849 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1850 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1851 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1852 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1853 default: strcat (buf
, ", unknown ISA"); break;
1859 if (e_flags
& EF_SPARC_32PLUS
)
1860 strcat (buf
, ", v8+");
1862 if (e_flags
& EF_SPARC_SUN_US1
)
1863 strcat (buf
, ", ultrasparcI");
1865 if (e_flags
& EF_SPARC_SUN_US3
)
1866 strcat (buf
, ", ultrasparcIII");
1868 if (e_flags
& EF_SPARC_HAL_R1
)
1869 strcat (buf
, ", halr1");
1871 if (e_flags
& EF_SPARC_LEDATA
)
1872 strcat (buf
, ", ledata");
1874 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1875 strcat (buf
, ", tso");
1877 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1878 strcat (buf
, ", pso");
1880 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1881 strcat (buf
, ", rmo");
1885 switch (e_flags
& EF_PARISC_ARCH
)
1887 case EFA_PARISC_1_0
:
1888 strcpy (buf
, ", PA-RISC 1.0");
1890 case EFA_PARISC_1_1
:
1891 strcpy (buf
, ", PA-RISC 1.1");
1893 case EFA_PARISC_2_0
:
1894 strcpy (buf
, ", PA-RISC 2.0");
1899 if (e_flags
& EF_PARISC_TRAPNIL
)
1900 strcat (buf
, ", trapnil");
1901 if (e_flags
& EF_PARISC_EXT
)
1902 strcat (buf
, ", ext");
1903 if (e_flags
& EF_PARISC_LSB
)
1904 strcat (buf
, ", lsb");
1905 if (e_flags
& EF_PARISC_WIDE
)
1906 strcat (buf
, ", wide");
1907 if (e_flags
& EF_PARISC_NO_KABP
)
1908 strcat (buf
, ", no kabp");
1909 if (e_flags
& EF_PARISC_LAZYSWAP
)
1910 strcat (buf
, ", lazyswap");
1915 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1916 strcat (buf
, ", new calling convention");
1918 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1919 strcat (buf
, ", gnu calling convention");
1923 if ((e_flags
& EF_IA_64_ABI64
))
1924 strcat (buf
, ", 64-bit");
1926 strcat (buf
, ", 32-bit");
1927 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1928 strcat (buf
, ", reduced fp model");
1929 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1930 strcat (buf
, ", no function descriptors, constant gp");
1931 else if ((e_flags
& EF_IA_64_CONS_GP
))
1932 strcat (buf
, ", constant gp");
1933 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1934 strcat (buf
, ", absolute");
1938 if ((e_flags
& EF_VAX_NONPIC
))
1939 strcat (buf
, ", non-PIC");
1940 if ((e_flags
& EF_VAX_DFLOAT
))
1941 strcat (buf
, ", D-Float");
1942 if ((e_flags
& EF_VAX_GFLOAT
))
1943 strcat (buf
, ", G-Float");
1952 get_mips_segment_type (type
)
1957 case PT_MIPS_REGINFO
:
1959 case PT_MIPS_RTPROC
:
1961 case PT_MIPS_OPTIONS
:
1971 get_parisc_segment_type (type
)
1976 case PT_HP_TLS
: return "HP_TLS";
1977 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1978 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1979 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1980 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1981 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1982 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1983 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1984 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1985 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1986 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1987 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1988 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1989 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1998 get_ia64_segment_type (type
)
2003 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2004 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2005 case PT_HP_TLS
: return "HP_TLS";
2006 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2007 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2008 case PT_IA_64_HP_STACK
: return "HP_STACK";
2017 get_segment_type (p_type
)
2018 unsigned long p_type
;
2020 static char buff
[32];
2024 case PT_NULL
: return "NULL";
2025 case PT_LOAD
: return "LOAD";
2026 case PT_DYNAMIC
: return "DYNAMIC";
2027 case PT_INTERP
: return "INTERP";
2028 case PT_NOTE
: return "NOTE";
2029 case PT_SHLIB
: return "SHLIB";
2030 case PT_PHDR
: return "PHDR";
2031 case PT_TLS
: return "TLS";
2033 case PT_GNU_EH_FRAME
:
2034 return "GNU_EH_FRAME";
2037 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2039 const char * result
;
2041 switch (elf_header
.e_machine
)
2044 case EM_MIPS_RS3_LE
:
2045 result
= get_mips_segment_type (p_type
);
2048 result
= get_parisc_segment_type (p_type
);
2051 result
= get_ia64_segment_type (p_type
);
2061 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2063 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2065 const char * result
;
2067 switch (elf_header
.e_machine
)
2070 result
= get_parisc_segment_type (p_type
);
2073 result
= get_ia64_segment_type (p_type
);
2083 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2086 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2093 get_mips_section_type_name (sh_type
)
2094 unsigned int sh_type
;
2098 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2099 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2100 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2101 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2102 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2103 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2104 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2105 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2106 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2107 case SHT_MIPS_RELD
: return "MIPS_RELD";
2108 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2109 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2110 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2111 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2112 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2113 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2114 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2115 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2116 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2117 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2118 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2119 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2120 case SHT_MIPS_LINE
: return "MIPS_LINE";
2121 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2122 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2123 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2124 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2125 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2126 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2127 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2128 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2129 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2130 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2131 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2132 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2133 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2134 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2135 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2136 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2144 get_parisc_section_type_name (sh_type
)
2145 unsigned int sh_type
;
2149 case SHT_PARISC_EXT
: return "PARISC_EXT";
2150 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2151 case SHT_PARISC_DOC
: return "PARISC_DOC";
2159 get_ia64_section_type_name (sh_type
)
2160 unsigned int sh_type
;
2164 case SHT_IA_64_EXT
: return "IA_64_EXT";
2165 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2173 get_section_type_name (sh_type
)
2174 unsigned int sh_type
;
2176 static char buff
[32];
2180 case SHT_NULL
: return "NULL";
2181 case SHT_PROGBITS
: return "PROGBITS";
2182 case SHT_SYMTAB
: return "SYMTAB";
2183 case SHT_STRTAB
: return "STRTAB";
2184 case SHT_RELA
: return "RELA";
2185 case SHT_HASH
: return "HASH";
2186 case SHT_DYNAMIC
: return "DYNAMIC";
2187 case SHT_NOTE
: return "NOTE";
2188 case SHT_NOBITS
: return "NOBITS";
2189 case SHT_REL
: return "REL";
2190 case SHT_SHLIB
: return "SHLIB";
2191 case SHT_DYNSYM
: return "DYNSYM";
2192 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2193 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2194 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2195 case SHT_GROUP
: return "GROUP";
2196 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2197 case SHT_GNU_verdef
: return "VERDEF";
2198 case SHT_GNU_verneed
: return "VERNEED";
2199 case SHT_GNU_versym
: return "VERSYM";
2200 case 0x6ffffff0: return "VERSYM";
2201 case 0x6ffffffc: return "VERDEF";
2202 case 0x7ffffffd: return "AUXILIARY";
2203 case 0x7fffffff: return "FILTER";
2204 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2207 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2209 const char * result
;
2211 switch (elf_header
.e_machine
)
2214 case EM_MIPS_RS3_LE
:
2215 result
= get_mips_section_type_name (sh_type
);
2218 result
= get_parisc_section_type_name (sh_type
);
2221 result
= get_ia64_section_type_name (sh_type
);
2231 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2233 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2234 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2235 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2236 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2238 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2244 struct option options
[] =
2246 {"all", no_argument
, 0, 'a'},
2247 {"file-header", no_argument
, 0, 'h'},
2248 {"program-headers", no_argument
, 0, 'l'},
2249 {"headers", no_argument
, 0, 'e'},
2250 {"histogram", no_argument
, 0, 'I'},
2251 {"segments", no_argument
, 0, 'l'},
2252 {"sections", no_argument
, 0, 'S'},
2253 {"section-headers", no_argument
, 0, 'S'},
2254 {"symbols", no_argument
, 0, 's'},
2255 {"syms", no_argument
, 0, 's'},
2256 {"relocs", no_argument
, 0, 'r'},
2257 {"notes", no_argument
, 0, 'n'},
2258 {"dynamic", no_argument
, 0, 'd'},
2259 {"arch-specific", no_argument
, 0, 'A'},
2260 {"version-info", no_argument
, 0, 'V'},
2261 {"use-dynamic", no_argument
, 0, 'D'},
2262 {"hex-dump", required_argument
, 0, 'x'},
2263 {"debug-dump", optional_argument
, 0, 'w'},
2264 {"unwind", no_argument
, 0, 'u'},
2265 #ifdef SUPPORT_DISASSEMBLY
2266 {"instruction-dump", required_argument
, 0, 'i'},
2269 {"version", no_argument
, 0, 'v'},
2270 {"wide", no_argument
, 0, 'W'},
2271 {"help", no_argument
, 0, 'H'},
2272 {0, no_argument
, 0, 0}
2278 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2279 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2280 fprintf (stdout
, _(" Options are:\n\
2281 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2282 -h --file-header Display the ELF file header\n\
2283 -l --program-headers Display the program headers\n\
2284 --segments An alias for --program-headers\n\
2285 -S --section-headers Display the sections' header\n\
2286 --sections An alias for --section-headers\n\
2287 -e --headers Equivalent to: -h -l -S\n\
2288 -s --syms Display the symbol table\n\
2289 --symbols An alias for --syms\n\
2290 -n --notes Display the core notes (if present)\n\
2291 -r --relocs Display the relocations (if present)\n\
2292 -u --unwind Display the unwind info (if present)\n\
2293 -d --dynamic Display the dynamic segment (if present)\n\
2294 -V --version-info Display the version sections (if present)\n\
2295 -A --arch-specific Display architecture specific information (if any).\n\
2296 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2297 -x --hex-dump=<number> Dump the contents of section <number>\n\
2298 -w --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2299 Display the contents of DWARF2 debug sections\n"));
2300 #ifdef SUPPORT_DISASSEMBLY
2301 fprintf (stdout
, _("\
2302 -i --instruction-dump=<number>\n\
2303 Disassemble the contents of section <number>\n"));
2305 fprintf (stdout
, _("\
2306 -I --histogram Display histogram of bucket list lengths\n\
2307 -W --wide Allow output width to exceed 80 characters\n\
2308 -H --help Display this information\n\
2309 -v --version Display the version number of readelf\n"));
2310 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2316 request_dump (section
, type
)
2317 unsigned int section
;
2320 if (section
>= num_dump_sects
)
2322 char * new_dump_sects
;
2324 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2326 if (new_dump_sects
== NULL
)
2327 error (_("Out of memory allocating dump request table."));
2330 /* Copy current flag settings. */
2331 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2335 dump_sects
= new_dump_sects
;
2336 num_dump_sects
= section
+ 1;
2341 dump_sects
[section
] |= type
;
2347 parse_args (argc
, argv
)
2356 while ((c
= getopt_long
2357 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2393 do_using_dynamic
++;
2424 section
= strtoul (optarg
, & cp
, 0);
2425 if (! * cp
&& section
>= 0)
2427 request_dump (section
, HEX_DUMP
);
2437 unsigned int index
= 0;
2441 while (optarg
[index
])
2442 switch (optarg
[index
++])
2451 do_debug_abbrevs
= 1;
2461 do_debug_pubnames
= 1;
2466 do_debug_aranges
= 1;
2470 do_debug_frames_interp
= 1;
2472 do_debug_frames
= 1;
2477 do_debug_macinfo
= 1;
2491 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2496 #ifdef SUPPORT_DISASSEMBLY
2499 section
= strtoul (optarg
, & cp
, 0);
2500 if (! * cp
&& section
>= 0)
2502 request_dump (section
, DISASS_DUMP
);
2508 print_version (program_name
);
2518 /* xgettext:c-format */
2519 error (_("Invalid option '-%c'\n"), c
);
2526 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2527 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2528 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2532 warn (_("Nothing to do.\n"));
2538 get_elf_class (elf_class
)
2539 unsigned int elf_class
;
2541 static char buff
[32];
2545 case ELFCLASSNONE
: return _("none");
2546 case ELFCLASS32
: return "ELF32";
2547 case ELFCLASS64
: return "ELF64";
2549 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2555 get_data_encoding (encoding
)
2556 unsigned int encoding
;
2558 static char buff
[32];
2562 case ELFDATANONE
: return _("none");
2563 case ELFDATA2LSB
: return _("2's complement, little endian");
2564 case ELFDATA2MSB
: return _("2's complement, big endian");
2566 sprintf (buff
, _("<unknown: %x>"), encoding
);
2572 get_osabi_name (osabi
)
2575 static char buff
[32];
2579 case ELFOSABI_NONE
: return "UNIX - System V";
2580 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2581 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2582 case ELFOSABI_LINUX
: return "UNIX - Linux";
2583 case ELFOSABI_HURD
: return "GNU/Hurd";
2584 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2585 case ELFOSABI_AIX
: return "UNIX - AIX";
2586 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2587 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2588 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2589 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2590 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2591 case ELFOSABI_STANDALONE
: return _("Standalone App");
2592 case ELFOSABI_ARM
: return "ARM";
2594 sprintf (buff
, _("<unknown: %x>"), osabi
);
2599 /* Decode the data held in 'elf_header'. */
2601 process_file_header ()
2603 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2604 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2605 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2606 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2609 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2617 printf (_("ELF Header:\n"));
2618 printf (_(" Magic: "));
2619 for (i
= 0; i
< EI_NIDENT
; i
++)
2620 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2622 printf (_(" Class: %s\n"),
2623 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2624 printf (_(" Data: %s\n"),
2625 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2626 printf (_(" Version: %d %s\n"),
2627 elf_header
.e_ident
[EI_VERSION
],
2628 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2630 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2633 printf (_(" OS/ABI: %s\n"),
2634 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2635 printf (_(" ABI Version: %d\n"),
2636 elf_header
.e_ident
[EI_ABIVERSION
]);
2637 printf (_(" Type: %s\n"),
2638 get_file_type (elf_header
.e_type
));
2639 printf (_(" Machine: %s\n"),
2640 get_machine_name (elf_header
.e_machine
));
2641 printf (_(" Version: 0x%lx\n"),
2642 (unsigned long) elf_header
.e_version
);
2644 printf (_(" Entry point address: "));
2645 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2646 printf (_("\n Start of program headers: "));
2647 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2648 printf (_(" (bytes into file)\n Start of section headers: "));
2649 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2650 printf (_(" (bytes into file)\n"));
2652 printf (_(" Flags: 0x%lx%s\n"),
2653 (unsigned long) elf_header
.e_flags
,
2654 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2655 printf (_(" Size of this header: %ld (bytes)\n"),
2656 (long) elf_header
.e_ehsize
);
2657 printf (_(" Size of program headers: %ld (bytes)\n"),
2658 (long) elf_header
.e_phentsize
);
2659 printf (_(" Number of program headers: %ld\n"),
2660 (long) elf_header
.e_phnum
);
2661 printf (_(" Size of section headers: %ld (bytes)\n"),
2662 (long) elf_header
.e_shentsize
);
2663 printf (_(" Number of section headers: %ld"),
2664 (long) elf_header
.e_shnum
);
2665 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2666 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2667 putc ('\n', stdout
);
2668 printf (_(" Section header string table index: %ld"),
2669 (long) elf_header
.e_shstrndx
);
2670 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2671 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2672 putc ('\n', stdout
);
2675 if (section_headers
!= NULL
)
2677 if (elf_header
.e_shnum
== 0)
2678 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2679 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2680 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2681 free (section_headers
);
2682 section_headers
= NULL
;
2690 get_32bit_program_headers (file
, program_headers
)
2692 Elf_Internal_Phdr
* program_headers
;
2694 Elf32_External_Phdr
* phdrs
;
2695 Elf32_External_Phdr
* external
;
2696 Elf32_Internal_Phdr
* internal
;
2699 phdrs
= ((Elf32_External_Phdr
*)
2700 get_data (NULL
, file
, elf_header
.e_phoff
,
2701 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2702 _("program headers")));
2706 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2707 i
< elf_header
.e_phnum
;
2708 i
++, internal
++, external
++)
2710 internal
->p_type
= BYTE_GET (external
->p_type
);
2711 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2712 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2713 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2714 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2715 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2716 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2717 internal
->p_align
= BYTE_GET (external
->p_align
);
2726 get_64bit_program_headers (file
, program_headers
)
2728 Elf_Internal_Phdr
* program_headers
;
2730 Elf64_External_Phdr
* phdrs
;
2731 Elf64_External_Phdr
* external
;
2732 Elf64_Internal_Phdr
* internal
;
2735 phdrs
= ((Elf64_External_Phdr
*)
2736 get_data (NULL
, file
, elf_header
.e_phoff
,
2737 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2738 _("program headers")));
2742 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2743 i
< elf_header
.e_phnum
;
2744 i
++, internal
++, external
++)
2746 internal
->p_type
= BYTE_GET (external
->p_type
);
2747 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2748 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2749 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2750 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2751 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2752 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2753 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2762 process_program_headers (file
)
2765 Elf_Internal_Phdr
* program_headers
;
2766 Elf_Internal_Phdr
* segment
;
2769 if (elf_header
.e_phnum
== 0)
2772 printf (_("\nThere are no program headers in this file.\n"));
2776 if (do_segments
&& !do_header
)
2778 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2779 printf (_("Entry point "));
2780 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2781 printf (_("\nThere are %d program headers, starting at offset "),
2782 elf_header
.e_phnum
);
2783 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2787 program_headers
= (Elf_Internal_Phdr
*) malloc
2788 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2790 if (program_headers
== NULL
)
2792 error (_("Out of memory\n"));
2797 i
= get_32bit_program_headers (file
, program_headers
);
2799 i
= get_64bit_program_headers (file
, program_headers
);
2803 free (program_headers
);
2809 if (elf_header
.e_phnum
> 1)
2810 printf (_("\nProgram Headers:\n"));
2812 printf (_("\nProgram Headers:\n"));
2816 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2819 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2823 (_(" Type Offset VirtAddr PhysAddr\n"));
2825 (_(" FileSiz MemSiz Flags Align\n"));
2833 for (i
= 0, segment
= program_headers
;
2834 i
< elf_header
.e_phnum
;
2839 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2843 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2844 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2845 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2846 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2847 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2849 (segment
->p_flags
& PF_R
? 'R' : ' '),
2850 (segment
->p_flags
& PF_W
? 'W' : ' '),
2851 (segment
->p_flags
& PF_X
? 'E' : ' '));
2852 printf ("%#lx", (unsigned long) segment
->p_align
);
2856 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2857 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2860 print_vma (segment
->p_offset
, FULL_HEX
);
2864 print_vma (segment
->p_vaddr
, FULL_HEX
);
2866 print_vma (segment
->p_paddr
, FULL_HEX
);
2869 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
2870 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
2873 print_vma (segment
->p_filesz
, FULL_HEX
);
2877 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
2878 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
2881 print_vma (segment
->p_offset
, FULL_HEX
);
2885 (segment
->p_flags
& PF_R
? 'R' : ' '),
2886 (segment
->p_flags
& PF_W
? 'W' : ' '),
2887 (segment
->p_flags
& PF_X
? 'E' : ' '));
2889 if ((unsigned long) segment
->p_align
== segment
->p_align
)
2890 printf ("%#lx", (unsigned long) segment
->p_align
);
2893 print_vma (segment
->p_align
, PREFIX_HEX
);
2898 print_vma (segment
->p_offset
, FULL_HEX
);
2900 print_vma (segment
->p_vaddr
, FULL_HEX
);
2902 print_vma (segment
->p_paddr
, FULL_HEX
);
2904 print_vma (segment
->p_filesz
, FULL_HEX
);
2906 print_vma (segment
->p_memsz
, FULL_HEX
);
2908 (segment
->p_flags
& PF_R
? 'R' : ' '),
2909 (segment
->p_flags
& PF_W
? 'W' : ' '),
2910 (segment
->p_flags
& PF_X
? 'E' : ' '));
2911 print_vma (segment
->p_align
, HEX
);
2915 switch (segment
->p_type
)
2919 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2920 - (segment
->p_offset
& 0xfffff000);
2925 error (_("more than one dynamic segment\n"));
2927 dynamic_addr
= segment
->p_offset
;
2928 dynamic_size
= segment
->p_filesz
;
2932 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2933 error (_("Unable to find program interpreter name\n"));
2936 program_interpreter
[0] = 0;
2937 fscanf (file
, "%63s", program_interpreter
);
2940 printf (_("\n [Requesting program interpreter: %s]"),
2941 program_interpreter
);
2947 putc ('\n', stdout
);
2956 if (do_segments
&& section_headers
!= NULL
)
2958 printf (_("\n Section to Segment mapping:\n"));
2959 printf (_(" Segment Sections...\n"));
2961 assert (string_table
!= NULL
);
2963 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2966 Elf_Internal_Shdr
* section
;
2968 segment
= program_headers
+ i
;
2969 section
= section_headers
;
2971 printf (" %2.2d ", i
);
2973 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
2975 if (section
->sh_size
> 0
2976 /* Compare allocated sections by VMA, unallocated
2977 sections by file offset. */
2978 && (section
->sh_flags
& SHF_ALLOC
2979 ? (section
->sh_addr
>= segment
->p_vaddr
2980 && section
->sh_addr
+ section
->sh_size
2981 <= segment
->p_vaddr
+ segment
->p_memsz
)
2982 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2983 && (section
->sh_offset
+ section
->sh_size
2984 <= segment
->p_offset
+ segment
->p_filesz
))))
2985 printf ("%s ", SECTION_NAME (section
));
2992 free (program_headers
);
2999 get_32bit_section_headers (file
, num
)
3003 Elf32_External_Shdr
* shdrs
;
3004 Elf32_Internal_Shdr
* internal
;
3007 shdrs
= ((Elf32_External_Shdr
*)
3008 get_data (NULL
, file
, elf_header
.e_shoff
,
3009 elf_header
.e_shentsize
* num
,
3010 _("section headers")));
3014 section_headers
= ((Elf_Internal_Shdr
*)
3015 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3017 if (section_headers
== NULL
)
3019 error (_("Out of memory\n"));
3023 for (i
= 0, internal
= section_headers
;
3027 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3028 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3029 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3030 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3031 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3032 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3033 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3034 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3035 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3036 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3045 get_64bit_section_headers (file
, num
)
3049 Elf64_External_Shdr
* shdrs
;
3050 Elf64_Internal_Shdr
* internal
;
3053 shdrs
= ((Elf64_External_Shdr
*)
3054 get_data (NULL
, file
, elf_header
.e_shoff
,
3055 elf_header
.e_shentsize
* num
,
3056 _("section headers")));
3060 section_headers
= ((Elf_Internal_Shdr
*)
3061 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3063 if (section_headers
== NULL
)
3065 error (_("Out of memory\n"));
3069 for (i
= 0, internal
= section_headers
;
3073 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3074 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3075 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3076 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3077 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3078 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3079 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3080 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3081 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3082 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3090 static Elf_Internal_Sym
*
3091 get_32bit_elf_symbols (file
, section
)
3093 Elf_Internal_Shdr
*section
;
3095 unsigned long number
;
3096 Elf32_External_Sym
* esyms
;
3097 Elf_External_Sym_Shndx
*shndx
;
3098 Elf_Internal_Sym
* isyms
;
3099 Elf_Internal_Sym
* psym
;
3102 esyms
= ((Elf32_External_Sym
*)
3103 get_data (NULL
, file
, section
->sh_offset
,
3104 section
->sh_size
, _("symbols")));
3109 if (symtab_shndx_hdr
!= NULL
3110 && (symtab_shndx_hdr
->sh_link
3111 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3113 shndx
= ((Elf_External_Sym_Shndx
*)
3114 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3115 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3123 number
= section
->sh_size
/ section
->sh_entsize
;
3124 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3128 error (_("Out of memory\n"));
3135 for (j
= 0, psym
= isyms
;
3139 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3140 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3141 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3142 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3143 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3145 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3146 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3147 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3157 static Elf_Internal_Sym
*
3158 get_64bit_elf_symbols (file
, section
)
3160 Elf_Internal_Shdr
*section
;
3162 unsigned long number
;
3163 Elf64_External_Sym
* esyms
;
3164 Elf_External_Sym_Shndx
*shndx
;
3165 Elf_Internal_Sym
* isyms
;
3166 Elf_Internal_Sym
* psym
;
3169 esyms
= ((Elf64_External_Sym
*)
3170 get_data (NULL
, file
, section
->sh_offset
,
3171 section
->sh_size
, _("symbols")));
3176 if (symtab_shndx_hdr
!= NULL
3177 && (symtab_shndx_hdr
->sh_link
3178 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3180 shndx
= ((Elf_External_Sym_Shndx
*)
3181 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3182 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3190 number
= section
->sh_size
/ section
->sh_entsize
;
3191 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3195 error (_("Out of memory\n"));
3202 for (j
= 0, psym
= isyms
;
3206 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3207 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3208 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3209 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3210 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3212 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3213 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3214 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3225 get_elf_section_flags (sh_flags
)
3228 static char buff
[32];
3236 flag
= sh_flags
& - sh_flags
;
3241 case SHF_WRITE
: strcat (buff
, "W"); break;
3242 case SHF_ALLOC
: strcat (buff
, "A"); break;
3243 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3244 case SHF_MERGE
: strcat (buff
, "M"); break;
3245 case SHF_STRINGS
: strcat (buff
, "S"); break;
3246 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3247 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3248 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3249 case SHF_GROUP
: strcat (buff
, "G"); break;
3250 case SHF_TLS
: strcat (buff
, "T"); break;
3253 if (flag
& SHF_MASKOS
)
3256 sh_flags
&= ~ SHF_MASKOS
;
3258 else if (flag
& SHF_MASKPROC
)
3261 sh_flags
&= ~ SHF_MASKPROC
;
3273 process_section_headers (file
)
3276 Elf_Internal_Shdr
* section
;
3279 section_headers
= NULL
;
3281 if (elf_header
.e_shnum
== 0)
3284 printf (_("\nThere are no sections in this file.\n"));
3289 if (do_sections
&& !do_header
)
3290 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3291 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3295 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3298 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3301 /* Read in the string table, so that we have names to display. */
3302 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3304 if (section
->sh_size
!= 0)
3306 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3307 section
->sh_size
, _("string table"));
3309 string_table_length
= section
->sh_size
;
3312 /* Scan the sections for the dynamic symbol table
3313 and dynamic string table and debug sections. */
3314 dynamic_symbols
= NULL
;
3315 dynamic_strings
= NULL
;
3316 dynamic_syminfo
= NULL
;
3318 for (i
= 0, section
= section_headers
;
3319 i
< elf_header
.e_shnum
;
3322 char * name
= SECTION_NAME (section
);
3324 if (section
->sh_type
== SHT_DYNSYM
)
3326 if (dynamic_symbols
!= NULL
)
3328 error (_("File contains multiple dynamic symbol tables\n"));
3332 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3333 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3335 else if (section
->sh_type
== SHT_STRTAB
3336 && strcmp (name
, ".dynstr") == 0)
3338 if (dynamic_strings
!= NULL
)
3340 error (_("File contains multiple dynamic string tables\n"));
3344 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3346 _("dynamic strings"));
3348 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3350 if (symtab_shndx_hdr
!= NULL
)
3352 error (_("File contains multiple symtab shndx tables\n"));
3355 symtab_shndx_hdr
= section
;
3357 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3358 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3359 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3361 && strncmp (name
, ".debug_", 7) == 0)
3366 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3367 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3368 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3369 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3370 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3371 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3372 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3373 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3374 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3376 request_dump (i
, DEBUG_DUMP
);
3378 /* linkonce section to be combined with .debug_info at link time. */
3379 else if ((do_debugging
|| do_debug_info
)
3380 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3381 request_dump (i
, DEBUG_DUMP
);
3382 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3383 request_dump (i
, DEBUG_DUMP
);
3389 if (elf_header
.e_shnum
> 1)
3390 printf (_("\nSection Headers:\n"));
3392 printf (_("\nSection Header:\n"));
3396 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3399 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3402 printf (_(" [Nr] Name Type Address Offset\n"));
3403 printf (_(" Size EntSize Flags Link Info Align\n"));
3406 for (i
= 0, section
= section_headers
;
3407 i
< elf_header
.e_shnum
;
3410 printf (" [%2u] %-17.17s %-15.15s ",
3411 SECTION_HEADER_NUM (i
),
3412 SECTION_NAME (section
),
3413 get_section_type_name (section
->sh_type
));
3417 print_vma (section
->sh_addr
, LONG_HEX
);
3419 printf ( " %6.6lx %6.6lx %2.2lx",
3420 (unsigned long) section
->sh_offset
,
3421 (unsigned long) section
->sh_size
,
3422 (unsigned long) section
->sh_entsize
);
3424 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3426 printf ("%2ld %3lx %2ld\n",
3427 (unsigned long) section
->sh_link
,
3428 (unsigned long) section
->sh_info
,
3429 (unsigned long) section
->sh_addralign
);
3433 print_vma (section
->sh_addr
, LONG_HEX
);
3435 if ((long) section
->sh_offset
== section
->sh_offset
)
3436 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3440 print_vma (section
->sh_offset
, LONG_HEX
);
3443 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3444 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3448 print_vma (section
->sh_size
, LONG_HEX
);
3451 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3452 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3456 print_vma (section
->sh_entsize
, LONG_HEX
);
3459 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3461 printf ("%2ld %3lx ",
3462 (unsigned long) section
->sh_link
,
3463 (unsigned long) section
->sh_info
);
3465 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3466 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3469 print_vma (section
->sh_addralign
, DEC
);
3476 print_vma (section
->sh_addr
, LONG_HEX
);
3477 if ((long) section
->sh_offset
== section
->sh_offset
)
3478 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3482 print_vma (section
->sh_offset
, LONG_HEX
);
3485 print_vma (section
->sh_size
, LONG_HEX
);
3487 print_vma (section
->sh_entsize
, LONG_HEX
);
3489 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3491 printf (" %2ld %3lx %ld\n",
3492 (unsigned long) section
->sh_link
,
3493 (unsigned long) section
->sh_info
,
3494 (unsigned long) section
->sh_addralign
);
3498 printf (_("Key to Flags:\n\
3499 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3500 I (info), L (link order), G (group), x (unknown)\n\
3501 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3506 /* Process the reloc section. */
3508 process_relocs (file
)
3511 unsigned long rel_size
;
3512 unsigned long rel_offset
;
3518 if (do_using_dynamic
)
3520 int is_rela
= FALSE
;
3525 if (dynamic_info
[DT_REL
])
3527 rel_offset
= dynamic_info
[DT_REL
];
3528 rel_size
= dynamic_info
[DT_RELSZ
];
3531 else if (dynamic_info
[DT_RELA
])
3533 rel_offset
= dynamic_info
[DT_RELA
];
3534 rel_size
= dynamic_info
[DT_RELASZ
];
3537 else if (dynamic_info
[DT_JMPREL
])
3539 rel_offset
= dynamic_info
[DT_JMPREL
];
3540 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3542 switch (dynamic_info
[DT_PLTREL
])
3559 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3560 rel_offset
, rel_size
);
3562 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3563 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3566 printf (_("\nThere are no dynamic relocations in this file.\n"));
3570 Elf32_Internal_Shdr
* section
;
3574 for (i
= 0, section
= section_headers
;
3575 i
< elf_header
.e_shnum
;
3578 if ( section
->sh_type
!= SHT_RELA
3579 && section
->sh_type
!= SHT_REL
)
3582 rel_offset
= section
->sh_offset
;
3583 rel_size
= section
->sh_size
;
3587 Elf32_Internal_Shdr
* strsec
;
3588 Elf_Internal_Sym
* symtab
;
3591 unsigned long nsyms
;
3593 printf (_("\nRelocation section "));
3595 if (string_table
== NULL
)
3596 printf ("%d", section
->sh_name
);
3598 printf (_("'%s'"), SECTION_NAME (section
));
3600 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3601 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3606 if (section
->sh_link
)
3608 Elf32_Internal_Shdr
* symsec
;
3610 symsec
= SECTION_HEADER (section
->sh_link
);
3611 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3612 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3617 strsec
= SECTION_HEADER (symsec
->sh_link
);
3619 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3623 is_rela
= section
->sh_type
== SHT_RELA
;
3625 dump_relocations (file
, rel_offset
, rel_size
,
3626 symtab
, nsyms
, strtab
, is_rela
);
3638 printf (_("\nThere are no relocations in this file.\n"));
3644 #include "unwind-ia64.h"
3646 /* An absolute address consists of a section and an offset. If the
3647 section is NULL, the offset itself is the address, otherwise, the
3648 address equals to LOAD_ADDRESS(section) + offset. */
3652 unsigned short section
;
3658 struct unw_table_entry
3660 struct absaddr start
;
3662 struct absaddr info
;
3664 *table
; /* Unwind table. */
3665 unsigned long table_len
; /* Length of unwind table. */
3666 unsigned char * info
; /* Unwind info. */
3667 unsigned long info_size
; /* Size of unwind info. */
3668 bfd_vma info_addr
; /* starting address of unwind info. */
3669 bfd_vma seg_base
; /* Starting address of segment. */
3670 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3671 unsigned long nsyms
; /* Number of symbols. */
3672 char * strtab
; /* The string table. */
3673 unsigned long strtab_size
; /* Size of string table. */
3676 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3677 struct absaddr
, const char **,
3679 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3680 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3681 Elf32_Internal_Shdr
*));
3684 find_symbol_for_address (aux
, addr
, symname
, offset
)
3685 struct unw_aux_info
*aux
;
3686 struct absaddr addr
;
3687 const char **symname
;
3690 bfd_vma dist
= (bfd_vma
) 0x100000;
3691 Elf_Internal_Sym
*sym
, *best
= NULL
;
3694 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3696 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3697 && sym
->st_name
!= 0
3698 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3699 && addr
.offset
>= sym
->st_value
3700 && addr
.offset
- sym
->st_value
< dist
)
3703 dist
= addr
.offset
- sym
->st_value
;
3710 *symname
= (best
->st_name
>= aux
->strtab_size
3711 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3716 *offset
= addr
.offset
;
3720 dump_ia64_unwind (aux
)
3721 struct unw_aux_info
*aux
;
3724 struct unw_table_entry
* tp
;
3727 addr_size
= is_32bit_elf
? 4 : 8;
3729 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3733 const unsigned char * dp
;
3734 const unsigned char * head
;
3735 const char * procname
;
3737 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3739 fputs ("\n<", stdout
);
3743 fputs (procname
, stdout
);
3746 printf ("+%lx", (unsigned long) offset
);
3749 fputs (">: [", stdout
);
3750 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3751 fputc ('-', stdout
);
3752 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3753 printf ("), info at +0x%lx\n",
3754 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3756 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3757 stamp
= BYTE_GET8 ((unsigned char *) head
);
3759 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3760 (unsigned) UNW_VER (stamp
),
3761 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3762 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3763 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3764 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3766 if (UNW_VER (stamp
) != 1)
3768 printf ("\tUnknown version.\n");
3773 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3774 dp
= unw_decode (dp
, in_body
, & in_body
);
3779 slurp_ia64_unwind_table (file
, aux
, sec
)
3781 struct unw_aux_info
*aux
;
3782 Elf32_Internal_Shdr
*sec
;
3784 unsigned long size
, addr_size
, nrelas
, i
;
3785 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3786 struct unw_table_entry
*tep
;
3787 Elf32_Internal_Shdr
*relsec
;
3788 Elf_Internal_Rela
*rela
, *rp
;
3789 unsigned char *table
, *tp
;
3790 Elf_Internal_Sym
*sym
;
3791 const char *relname
;
3794 addr_size
= is_32bit_elf
? 4 : 8;
3796 /* First, find the starting address of the segment that includes
3799 if (elf_header
.e_phnum
)
3801 prog_hdrs
= (Elf_Internal_Phdr
*)
3802 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3805 result
= get_32bit_program_headers (file
, prog_hdrs
);
3807 result
= get_64bit_program_headers (file
, prog_hdrs
);
3815 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3817 if (seg
->p_type
!= PT_LOAD
)
3820 if (sec
->sh_addr
>= seg
->p_vaddr
3821 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3823 aux
->seg_base
= seg
->p_vaddr
;
3831 /* Second, build the unwind table from the contents of the unwind section: */
3832 size
= sec
->sh_size
;
3833 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3834 size
, _("unwind table"));
3838 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3839 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3841 tep
->start
.section
= SHN_UNDEF
;
3842 tep
->end
.section
= SHN_UNDEF
;
3843 tep
->info
.section
= SHN_UNDEF
;
3846 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3847 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3848 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3852 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3853 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3854 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3856 tep
->start
.offset
+= aux
->seg_base
;
3857 tep
->end
.offset
+= aux
->seg_base
;
3858 tep
->info
.offset
+= aux
->seg_base
;
3862 /* Third, apply any relocations to the unwind table: */
3864 for (relsec
= section_headers
;
3865 relsec
< section_headers
+ elf_header
.e_shnum
;
3868 if (relsec
->sh_type
!= SHT_RELA
3869 || SECTION_HEADER (relsec
->sh_info
) != sec
)
3872 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3876 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3880 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3881 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3883 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3885 warn (_("Skipping unexpected symbol type %u\n"),
3886 ELF32_ST_TYPE (sym
->st_info
));
3892 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3893 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3895 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3897 warn (_("Skipping unexpected symbol type %u\n"),
3898 ELF64_ST_TYPE (sym
->st_info
));
3903 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
3905 warn (_("Skipping unexpected relocation type %s\n"), relname
);
3909 i
= rp
->r_offset
/ (3 * addr_size
);
3911 switch (rp
->r_offset
/addr_size
% 3)
3914 aux
->table
[i
].start
.section
= sym
->st_shndx
;
3915 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
3918 aux
->table
[i
].end
.section
= sym
->st_shndx
;
3919 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
3922 aux
->table
[i
].info
.section
= sym
->st_shndx
;
3923 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
3933 aux
->table_len
= size
/ (3 * addr_size
);
3938 process_unwind (file
)
3941 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
3942 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
3943 struct unw_aux_info aux
;
3948 if (elf_header
.e_machine
!= EM_IA_64
)
3950 printf (_("\nThere are no unwind sections in this file.\n"));
3954 memset (& aux
, 0, sizeof (aux
));
3956 addr_size
= is_32bit_elf
? 4 : 8;
3958 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
3960 if (sec
->sh_type
== SHT_SYMTAB
)
3962 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
3963 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
3965 strsec
= SECTION_HEADER (sec
->sh_link
);
3966 aux
.strtab_size
= strsec
->sh_size
;
3967 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3968 aux
.strtab_size
, _("string table"));
3970 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3975 printf (_("\nThere are no unwind sections in this file.\n"));
3977 while (unwcount
-- > 0)
3982 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
3983 i
< elf_header
.e_shnum
; ++i
, ++sec
)
3984 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3991 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
3993 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
3996 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3997 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
3998 suffix
= SECTION_NAME (unwsec
) + len
;
3999 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4001 if (strncmp (SECTION_NAME (sec
),
4002 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4003 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4008 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4009 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4010 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4011 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4013 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4015 suffix
= SECTION_NAME (unwsec
) + len
;
4016 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4018 if (strncmp (SECTION_NAME (sec
),
4019 ELF_STRING_ia64_unwind_info
, len2
) == 0
4020 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4024 if (i
== elf_header
.e_shnum
)
4026 printf (_("\nCould not find unwind info section for "));
4028 if (string_table
== NULL
)
4029 printf ("%d", unwsec
->sh_name
);
4031 printf (_("'%s'"), SECTION_NAME (unwsec
));
4035 aux
.info_size
= sec
->sh_size
;
4036 aux
.info_addr
= sec
->sh_addr
;
4037 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4038 aux
.info_size
, _("unwind info"));
4040 printf (_("\nUnwind section "));
4042 if (string_table
== NULL
)
4043 printf ("%d", unwsec
->sh_name
);
4045 printf (_("'%s'"), SECTION_NAME (unwsec
));
4047 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4048 (unsigned long) unwsec
->sh_offset
,
4049 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4051 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4053 if (aux
.table_len
> 0)
4054 dump_ia64_unwind (& aux
);
4057 free ((char *) aux
.table
);
4059 free ((char *) aux
.info
);
4068 free ((char *) aux
.strtab
);
4074 dynamic_segment_mips_val (entry
)
4075 Elf_Internal_Dyn
* entry
;
4077 switch (entry
->d_tag
)
4080 if (entry
->d_un
.d_val
== 0)
4084 static const char * opts
[] =
4086 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4087 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4088 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4089 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4094 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
4095 if (entry
->d_un
.d_val
& (1 << cnt
))
4097 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4104 case DT_MIPS_IVERSION
:
4105 if (dynamic_strings
!= NULL
)
4106 printf ("Interface Version: %s\n",
4107 dynamic_strings
+ entry
->d_un
.d_val
);
4109 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4112 case DT_MIPS_TIME_STAMP
:
4117 time_t time
= entry
->d_un
.d_val
;
4118 tmp
= gmtime (&time
);
4119 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4120 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4121 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4122 printf ("Time Stamp: %s\n", timebuf
);
4126 case DT_MIPS_RLD_VERSION
:
4127 case DT_MIPS_LOCAL_GOTNO
:
4128 case DT_MIPS_CONFLICTNO
:
4129 case DT_MIPS_LIBLISTNO
:
4130 case DT_MIPS_SYMTABNO
:
4131 case DT_MIPS_UNREFEXTNO
:
4132 case DT_MIPS_HIPAGENO
:
4133 case DT_MIPS_DELTA_CLASS_NO
:
4134 case DT_MIPS_DELTA_INSTANCE_NO
:
4135 case DT_MIPS_DELTA_RELOC_NO
:
4136 case DT_MIPS_DELTA_SYM_NO
:
4137 case DT_MIPS_DELTA_CLASSSYM_NO
:
4138 case DT_MIPS_COMPACT_SIZE
:
4139 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4143 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4149 dynamic_segment_parisc_val (entry
)
4150 Elf_Internal_Dyn
* entry
;
4152 switch (entry
->d_tag
)
4154 case DT_HP_DLD_FLAGS
:
4163 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4164 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4165 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4166 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4167 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4168 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4169 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4170 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4171 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4172 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4173 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4177 bfd_vma val
= entry
->d_un
.d_val
;
4179 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4180 if (val
& flags
[cnt
].bit
)
4184 fputs (flags
[cnt
].str
, stdout
);
4186 val
^= flags
[cnt
].bit
;
4189 if (val
!= 0 || first
)
4193 print_vma (val
, HEX
);
4199 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4205 get_32bit_dynamic_segment (file
)
4208 Elf32_External_Dyn
* edyn
;
4209 Elf_Internal_Dyn
* entry
;
4212 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4213 dynamic_size
, _("dynamic segment"));
4217 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4218 how large this .dynamic is now. We can do this even before the byte
4219 swapping since the DT_NULL tag is recognizable. */
4221 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4224 dynamic_segment
= (Elf_Internal_Dyn
*)
4225 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4227 if (dynamic_segment
== NULL
)
4229 error (_("Out of memory\n"));
4234 for (i
= 0, entry
= dynamic_segment
;
4238 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4239 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4248 get_64bit_dynamic_segment (file
)
4251 Elf64_External_Dyn
* edyn
;
4252 Elf_Internal_Dyn
* entry
;
4255 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4256 dynamic_size
, _("dynamic segment"));
4260 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4261 how large this .dynamic is now. We can do this even before the byte
4262 swapping since the DT_NULL tag is recognizable. */
4264 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4267 dynamic_segment
= (Elf_Internal_Dyn
*)
4268 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4270 if (dynamic_segment
== NULL
)
4272 error (_("Out of memory\n"));
4277 for (i
= 0, entry
= dynamic_segment
;
4281 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4282 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4291 get_dynamic_flags (flags
)
4294 static char buff
[128];
4302 flag
= flags
& - flags
;
4310 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4311 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4312 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4313 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4314 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4315 default: strcpy (p
, "unknown"); break;
4318 p
= strchr (p
, '\0');
4323 /* Parse and display the contents of the dynamic segment. */
4325 process_dynamic_segment (file
)
4328 Elf_Internal_Dyn
* entry
;
4331 if (dynamic_size
== 0)
4334 printf (_("\nThere is no dynamic segment in this file.\n"));
4341 if (! get_32bit_dynamic_segment (file
))
4344 else if (! get_64bit_dynamic_segment (file
))
4347 /* Find the appropriate symbol table. */
4348 if (dynamic_symbols
== NULL
)
4350 for (i
= 0, entry
= dynamic_segment
;
4354 Elf32_Internal_Shdr section
;
4356 if (entry
->d_tag
!= DT_SYMTAB
)
4359 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4361 /* Since we do not know how big the symbol table is,
4362 we default to reading in the entire file (!) and
4363 processing that. This is overkill, I know, but it
4365 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4367 if (fseek (file
, 0, SEEK_END
))
4368 error (_("Unable to seek to end of file!"));
4370 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4372 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4374 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4376 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4377 if (num_dynamic_syms
< 1)
4379 error (_("Unable to determine the number of symbols to load\n"));
4383 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4387 /* Similarly find a string table. */
4388 if (dynamic_strings
== NULL
)
4390 for (i
= 0, entry
= dynamic_segment
;
4394 unsigned long offset
;
4397 if (entry
->d_tag
!= DT_STRTAB
)
4400 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4402 /* Since we do not know how big the string table is,
4403 we default to reading in the entire file (!) and
4404 processing that. This is overkill, I know, but it
4407 offset
= entry
->d_un
.d_val
- loadaddr
;
4408 if (fseek (file
, 0, SEEK_END
))
4409 error (_("Unable to seek to end of file\n"));
4410 str_tab_len
= ftell (file
) - offset
;
4412 if (str_tab_len
< 1)
4415 (_("Unable to determine the length of the dynamic string table\n"));
4419 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4420 _("dynamic string table"));
4425 /* And find the syminfo section if available. */
4426 if (dynamic_syminfo
== NULL
)
4428 unsigned int syminsz
= 0;
4430 for (i
= 0, entry
= dynamic_segment
;
4434 if (entry
->d_tag
== DT_SYMINENT
)
4436 /* Note: these braces are necessary to avoid a syntax
4437 error from the SunOS4 C compiler. */
4438 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4440 else if (entry
->d_tag
== DT_SYMINSZ
)
4441 syminsz
= entry
->d_un
.d_val
;
4442 else if (entry
->d_tag
== DT_SYMINFO
)
4443 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4446 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4448 Elf_External_Syminfo
* extsyminfo
;
4449 Elf_Internal_Syminfo
* syminfo
;
4451 /* There is a syminfo section. Read the data. */
4452 extsyminfo
= ((Elf_External_Syminfo
*)
4453 get_data (NULL
, file
, dynamic_syminfo_offset
,
4454 syminsz
, _("symbol information")));
4458 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4459 if (dynamic_syminfo
== NULL
)
4461 error (_("Out of memory\n"));
4465 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4466 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4469 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4470 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4477 if (do_dynamic
&& dynamic_addr
)
4478 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4479 dynamic_addr
, (long) dynamic_size
);
4481 printf (_(" Tag Type Name/Value\n"));
4483 for (i
= 0, entry
= dynamic_segment
;
4492 print_vma (entry
->d_tag
, FULL_HEX
);
4493 dtype
= get_dynamic_type (entry
->d_tag
);
4494 printf (" (%s)%*s", dtype
,
4495 ((is_32bit_elf
? 27 : 19)
4496 - (int) strlen (dtype
)),
4500 switch (entry
->d_tag
)
4504 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4514 switch (entry
->d_tag
)
4517 printf (_("Auxiliary library"));
4521 printf (_("Filter library"));
4525 printf (_("Configuration file"));
4529 printf (_("Dependency audit library"));
4533 printf (_("Audit library"));
4537 if (dynamic_strings
)
4538 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4542 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4551 printf (_("Flags:"));
4552 if (entry
->d_un
.d_val
== 0)
4553 printf (_(" None\n"));
4556 unsigned long int val
= entry
->d_un
.d_val
;
4557 if (val
& DTF_1_PARINIT
)
4559 printf (" PARINIT");
4560 val
^= DTF_1_PARINIT
;
4562 if (val
& DTF_1_CONFEXP
)
4564 printf (" CONFEXP");
4565 val
^= DTF_1_CONFEXP
;
4568 printf (" %lx", val
);
4577 printf (_("Flags:"));
4578 if (entry
->d_un
.d_val
== 0)
4579 printf (_(" None\n"));
4582 unsigned long int val
= entry
->d_un
.d_val
;
4583 if (val
& DF_P1_LAZYLOAD
)
4585 printf (" LAZYLOAD");
4586 val
^= DF_P1_LAZYLOAD
;
4588 if (val
& DF_P1_GROUPPERM
)
4590 printf (" GROUPPERM");
4591 val
^= DF_P1_GROUPPERM
;
4594 printf (" %lx", val
);
4603 printf (_("Flags:"));
4604 if (entry
->d_un
.d_val
== 0)
4605 printf (_(" None\n"));
4608 unsigned long int val
= entry
->d_un
.d_val
;
4614 if (val
& DF_1_GLOBAL
)
4619 if (val
& DF_1_GROUP
)
4624 if (val
& DF_1_NODELETE
)
4626 printf (" NODELETE");
4627 val
^= DF_1_NODELETE
;
4629 if (val
& DF_1_LOADFLTR
)
4631 printf (" LOADFLTR");
4632 val
^= DF_1_LOADFLTR
;
4634 if (val
& DF_1_INITFIRST
)
4636 printf (" INITFIRST");
4637 val
^= DF_1_INITFIRST
;
4639 if (val
& DF_1_NOOPEN
)
4644 if (val
& DF_1_ORIGIN
)
4649 if (val
& DF_1_DIRECT
)
4654 if (val
& DF_1_TRANS
)
4659 if (val
& DF_1_INTERPOSE
)
4661 printf (" INTERPOSE");
4662 val
^= DF_1_INTERPOSE
;
4664 if (val
& DF_1_NODEFLIB
)
4666 printf (" NODEFLIB");
4667 val
^= DF_1_NODEFLIB
;
4669 if (val
& DF_1_NODUMP
)
4674 if (val
& DF_1_CONLFAT
)
4676 printf (" CONLFAT");
4677 val
^= DF_1_CONLFAT
;
4680 printf (" %lx", val
);
4688 puts (get_dynamic_type (entry
->d_un
.d_val
));
4708 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4714 if (dynamic_strings
== NULL
)
4717 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4721 switch (entry
->d_tag
)
4724 printf (_("Shared library: [%s]"), name
);
4726 if (strcmp (name
, program_interpreter
) == 0)
4727 printf (_(" program interpreter"));
4731 printf (_("Library soname: [%s]"), name
);
4735 printf (_("Library rpath: [%s]"), name
);
4739 printf (_("Library runpath: [%s]"), name
);
4743 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4748 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4764 case DT_INIT_ARRAYSZ
:
4765 case DT_FINI_ARRAYSZ
:
4766 case DT_GNU_CONFLICTSZ
:
4767 case DT_GNU_LIBLISTSZ
:
4770 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4771 printf (" (bytes)\n");
4781 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4794 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4798 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4802 printf (_("Not needed object: [%s]\n"), name
);
4807 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4813 /* The value of this entry is ignored. */
4816 case DT_GNU_PRELINKED
:
4820 time_t time
= entry
->d_un
.d_val
;
4822 tmp
= gmtime (&time
);
4823 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
4824 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4825 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4831 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4832 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4837 switch (elf_header
.e_machine
)
4840 case EM_MIPS_RS3_LE
:
4841 dynamic_segment_mips_val (entry
);
4844 dynamic_segment_parisc_val (entry
);
4847 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4859 get_ver_flags (flags
)
4862 static char buff
[32];
4869 if (flags
& VER_FLG_BASE
)
4870 strcat (buff
, "BASE ");
4872 if (flags
& VER_FLG_WEAK
)
4874 if (flags
& VER_FLG_BASE
)
4875 strcat (buff
, "| ");
4877 strcat (buff
, "WEAK ");
4880 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4881 strcat (buff
, "| <unknown>");
4886 /* Display the contents of the version sections. */
4888 process_version_sections (file
)
4891 Elf32_Internal_Shdr
* section
;
4898 for (i
= 0, section
= section_headers
;
4899 i
< elf_header
.e_shnum
;
4902 switch (section
->sh_type
)
4904 case SHT_GNU_verdef
:
4906 Elf_External_Verdef
* edefs
;
4913 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4914 SECTION_NAME (section
), section
->sh_info
);
4916 printf (_(" Addr: 0x"));
4917 printf_vma (section
->sh_addr
);
4918 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4919 (unsigned long) section
->sh_offset
, section
->sh_link
,
4920 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
4922 edefs
= ((Elf_External_Verdef
*)
4923 get_data (NULL
, file
, section
->sh_offset
,
4925 _("version definition section")));
4929 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
4932 Elf_External_Verdef
* edef
;
4933 Elf_Internal_Verdef ent
;
4934 Elf_External_Verdaux
* eaux
;
4935 Elf_Internal_Verdaux aux
;
4939 vstart
= ((char *) edefs
) + idx
;
4941 edef
= (Elf_External_Verdef
*) vstart
;
4943 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
4944 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
4945 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
4946 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
4947 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
4948 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
4949 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
4951 printf (_(" %#06x: Rev: %d Flags: %s"),
4952 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
4954 printf (_(" Index: %d Cnt: %d "),
4955 ent
.vd_ndx
, ent
.vd_cnt
);
4957 vstart
+= ent
.vd_aux
;
4959 eaux
= (Elf_External_Verdaux
*) vstart
;
4961 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4962 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4964 if (dynamic_strings
)
4965 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
4967 printf (_("Name index: %ld\n"), aux
.vda_name
);
4969 isum
= idx
+ ent
.vd_aux
;
4971 for (j
= 1; j
< ent
.vd_cnt
; j
++)
4973 isum
+= aux
.vda_next
;
4974 vstart
+= aux
.vda_next
;
4976 eaux
= (Elf_External_Verdaux
*) vstart
;
4978 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4979 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4981 if (dynamic_strings
)
4982 printf (_(" %#06x: Parent %d: %s\n"),
4983 isum
, j
, dynamic_strings
+ aux
.vda_name
);
4985 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4986 isum
, j
, aux
.vda_name
);
4996 case SHT_GNU_verneed
:
4998 Elf_External_Verneed
* eneed
;
5004 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5005 SECTION_NAME (section
), section
->sh_info
);
5007 printf (_(" Addr: 0x"));
5008 printf_vma (section
->sh_addr
);
5009 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5010 (unsigned long) section
->sh_offset
, section
->sh_link
,
5011 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5013 eneed
= ((Elf_External_Verneed
*)
5014 get_data (NULL
, file
, section
->sh_offset
,
5015 section
->sh_size
, _("version need section")));
5019 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5021 Elf_External_Verneed
* entry
;
5022 Elf_Internal_Verneed ent
;
5027 vstart
= ((char *) eneed
) + idx
;
5029 entry
= (Elf_External_Verneed
*) vstart
;
5031 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5032 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5033 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5034 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5035 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5037 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5039 if (dynamic_strings
)
5040 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5042 printf (_(" File: %lx"), ent
.vn_file
);
5044 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5046 vstart
+= ent
.vn_aux
;
5048 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5050 Elf_External_Vernaux
* eaux
;
5051 Elf_Internal_Vernaux aux
;
5053 eaux
= (Elf_External_Vernaux
*) vstart
;
5055 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5056 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5057 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5058 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5059 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5061 if (dynamic_strings
)
5062 printf (_(" %#06x: Name: %s"),
5063 isum
, dynamic_strings
+ aux
.vna_name
);
5065 printf (_(" %#06x: Name index: %lx"),
5066 isum
, aux
.vna_name
);
5068 printf (_(" Flags: %s Version: %d\n"),
5069 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5071 isum
+= aux
.vna_next
;
5072 vstart
+= aux
.vna_next
;
5082 case SHT_GNU_versym
:
5084 Elf32_Internal_Shdr
* link_section
;
5087 unsigned char * edata
;
5088 unsigned short * data
;
5090 Elf_Internal_Sym
* symbols
;
5091 Elf32_Internal_Shdr
* string_sec
;
5093 link_section
= SECTION_HEADER (section
->sh_link
);
5094 total
= section
->sh_size
/ section
->sh_entsize
;
5098 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5100 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5102 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5103 string_sec
->sh_size
,
5104 _("version string table"));
5108 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5109 SECTION_NAME (section
), total
);
5111 printf (_(" Addr: "));
5112 printf_vma (section
->sh_addr
);
5113 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5114 (unsigned long) section
->sh_offset
, section
->sh_link
,
5115 SECTION_NAME (link_section
));
5119 get_data (NULL
, file
,
5120 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5121 total
* sizeof (short), _("version symbol data")));
5128 data
= (unsigned short *) malloc (total
* sizeof (short));
5130 for (cnt
= total
; cnt
--;)
5131 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5136 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5139 int check_def
, check_need
;
5142 printf (" %03x:", cnt
);
5144 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5145 switch (data
[cnt
+ j
])
5148 fputs (_(" 0 (*local*) "), stdout
);
5152 fputs (_(" 1 (*global*) "), stdout
);
5156 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5157 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5161 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5164 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5171 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5173 Elf_Internal_Verneed ivn
;
5174 unsigned long offset
;
5176 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5181 Elf_Internal_Vernaux ivna
;
5182 Elf_External_Verneed evn
;
5183 Elf_External_Vernaux evna
;
5184 unsigned long a_off
;
5186 get_data (&evn
, file
, offset
, sizeof (evn
),
5189 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5190 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5192 a_off
= offset
+ ivn
.vn_aux
;
5196 get_data (&evna
, file
, a_off
, sizeof (evna
),
5197 _("version need aux (2)"));
5199 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5200 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5202 a_off
+= ivna
.vna_next
;
5204 while (ivna
.vna_other
!= data
[cnt
+ j
]
5205 && ivna
.vna_next
!= 0);
5207 if (ivna
.vna_other
== data
[cnt
+ j
])
5209 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5211 name
= strtab
+ ivna
.vna_name
;
5212 nn
+= printf ("(%s%-*s",
5214 12 - (int) strlen (name
),
5220 offset
+= ivn
.vn_next
;
5222 while (ivn
.vn_next
);
5225 if (check_def
&& data
[cnt
+ j
] != 0x8001
5226 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5228 Elf_Internal_Verdef ivd
;
5229 Elf_External_Verdef evd
;
5230 unsigned long offset
;
5232 offset
= version_info
5233 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
5237 get_data (&evd
, file
, offset
, sizeof (evd
),
5240 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5241 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5243 offset
+= ivd
.vd_next
;
5245 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5246 && ivd
.vd_next
!= 0);
5248 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5250 Elf_External_Verdaux evda
;
5251 Elf_Internal_Verdaux ivda
;
5253 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5255 get_data (&evda
, file
,
5256 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5257 sizeof (evda
), _("version def aux"));
5259 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5261 name
= strtab
+ ivda
.vda_name
;
5262 nn
+= printf ("(%s%-*s",
5264 12 - (int) strlen (name
),
5270 printf ("%*c", 18 - nn
, ' ');
5288 printf (_("\nNo version information found in this file.\n"));
5294 get_symbol_binding (binding
)
5295 unsigned int binding
;
5297 static char buff
[32];
5301 case STB_LOCAL
: return "LOCAL";
5302 case STB_GLOBAL
: return "GLOBAL";
5303 case STB_WEAK
: return "WEAK";
5305 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5306 sprintf (buff
, _("<processor specific>: %d"), binding
);
5307 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5308 sprintf (buff
, _("<OS specific>: %d"), binding
);
5310 sprintf (buff
, _("<unknown>: %d"), binding
);
5316 get_symbol_type (type
)
5319 static char buff
[32];
5323 case STT_NOTYPE
: return "NOTYPE";
5324 case STT_OBJECT
: return "OBJECT";
5325 case STT_FUNC
: return "FUNC";
5326 case STT_SECTION
: return "SECTION";
5327 case STT_FILE
: return "FILE";
5328 case STT_COMMON
: return "COMMON";
5329 case STT_TLS
: return "TLS";
5331 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5333 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5334 return "THUMB_FUNC";
5336 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5339 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5340 return "PARISC_MILLI";
5342 sprintf (buff
, _("<processor specific>: %d"), type
);
5344 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5346 if (elf_header
.e_machine
== EM_PARISC
)
5348 if (type
== STT_HP_OPAQUE
)
5350 if (type
== STT_HP_STUB
)
5354 sprintf (buff
, _("<OS specific>: %d"), type
);
5357 sprintf (buff
, _("<unknown>: %d"), type
);
5363 get_symbol_visibility (visibility
)
5364 unsigned int visibility
;
5368 case STV_DEFAULT
: return "DEFAULT";
5369 case STV_INTERNAL
: return "INTERNAL";
5370 case STV_HIDDEN
: return "HIDDEN";
5371 case STV_PROTECTED
: return "PROTECTED";
5377 get_symbol_index_type (type
)
5382 case SHN_UNDEF
: return "UND";
5383 case SHN_ABS
: return "ABS";
5384 case SHN_COMMON
: return "COM";
5386 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5388 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5390 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5394 static char buff
[32];
5396 sprintf (buff
, "%3d", type
);
5403 get_dynamic_data (file
, number
)
5405 unsigned int number
;
5407 unsigned char * e_data
;
5410 e_data
= (unsigned char *) malloc (number
* 4);
5414 error (_("Out of memory\n"));
5418 if (fread (e_data
, 4, number
, file
) != number
)
5420 error (_("Unable to read in dynamic data\n"));
5424 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5428 error (_("Out of memory\n"));
5434 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5441 /* Dump the symbol table. */
5443 process_symbol_table (file
)
5446 Elf32_Internal_Shdr
* section
;
5447 unsigned char nb
[4];
5448 unsigned char nc
[4];
5451 int * buckets
= NULL
;
5452 int * chains
= NULL
;
5454 if (! do_syms
&& !do_histogram
)
5457 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5460 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5462 error (_("Unable to seek to start of dynamic information"));
5466 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5468 error (_("Failed to read in number of buckets\n"));
5472 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5474 error (_("Failed to read in number of chains\n"));
5478 nbuckets
= byte_get (nb
, 4);
5479 nchains
= byte_get (nc
, 4);
5481 buckets
= get_dynamic_data (file
, nbuckets
);
5482 chains
= get_dynamic_data (file
, nchains
);
5484 if (buckets
== NULL
|| chains
== NULL
)
5489 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5494 printf (_("\nSymbol table for image:\n"));
5496 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5498 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5500 for (hn
= 0; hn
< nbuckets
; hn
++)
5505 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5507 Elf_Internal_Sym
* psym
;
5509 psym
= dynamic_symbols
+ si
;
5511 printf (" %3d %3d: ", si
, hn
);
5512 print_vma (psym
->st_value
, LONG_HEX
);
5514 print_vma (psym
->st_size
, DEC_5
);
5516 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5517 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5518 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5519 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5520 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5525 else if (do_syms
&& !do_using_dynamic
)
5529 for (i
= 0, section
= section_headers
;
5530 i
< elf_header
.e_shnum
;
5535 Elf_Internal_Sym
* symtab
;
5536 Elf_Internal_Sym
* psym
;
5539 if ( section
->sh_type
!= SHT_SYMTAB
5540 && section
->sh_type
!= SHT_DYNSYM
)
5543 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5544 SECTION_NAME (section
),
5545 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5547 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5549 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5551 symtab
= GET_ELF_SYMBOLS (file
, section
);
5555 if (section
->sh_link
== elf_header
.e_shstrndx
)
5556 strtab
= string_table
;
5559 Elf32_Internal_Shdr
* string_sec
;
5561 string_sec
= SECTION_HEADER (section
->sh_link
);
5563 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5564 string_sec
->sh_size
,
5568 for (si
= 0, psym
= symtab
;
5569 si
< section
->sh_size
/ section
->sh_entsize
;
5572 printf ("%6d: ", si
);
5573 print_vma (psym
->st_value
, LONG_HEX
);
5575 print_vma (psym
->st_size
, DEC_5
);
5576 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5577 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5578 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5579 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5580 print_symbol (25, strtab
+ psym
->st_name
);
5582 if (section
->sh_type
== SHT_DYNSYM
&&
5583 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5585 unsigned char data
[2];
5586 unsigned short vers_data
;
5587 unsigned long offset
;
5591 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5594 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5595 sizeof (data
), _("version data"));
5597 vers_data
= byte_get (data
, 2);
5599 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5602 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5604 if ((vers_data
& 0x8000) || vers_data
> 1)
5606 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5607 && (is_nobits
|| ! check_def
))
5609 Elf_External_Verneed evn
;
5610 Elf_Internal_Verneed ivn
;
5611 Elf_Internal_Vernaux ivna
;
5613 /* We must test both. */
5614 offset
= version_info
5615 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5619 unsigned long vna_off
;
5621 get_data (&evn
, file
, offset
, sizeof (evn
),
5624 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5625 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5627 vna_off
= offset
+ ivn
.vn_aux
;
5631 Elf_External_Vernaux evna
;
5633 get_data (&evna
, file
, vna_off
,
5635 _("version need aux (3)"));
5637 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5638 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5639 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5641 vna_off
+= ivna
.vna_next
;
5643 while (ivna
.vna_other
!= vers_data
5644 && ivna
.vna_next
!= 0);
5646 if (ivna
.vna_other
== vers_data
)
5649 offset
+= ivn
.vn_next
;
5651 while (ivn
.vn_next
!= 0);
5653 if (ivna
.vna_other
== vers_data
)
5656 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5659 else if (! is_nobits
)
5660 error (_("bad dynamic symbol"));
5667 if (vers_data
!= 0x8001
5668 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5670 Elf_Internal_Verdef ivd
;
5671 Elf_Internal_Verdaux ivda
;
5672 Elf_External_Verdaux evda
;
5673 unsigned long offset
;
5676 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5681 Elf_External_Verdef evd
;
5683 get_data (&evd
, file
, offset
, sizeof (evd
),
5686 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5687 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5688 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5690 offset
+= ivd
.vd_next
;
5692 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5693 && ivd
.vd_next
!= 0);
5695 offset
-= ivd
.vd_next
;
5696 offset
+= ivd
.vd_aux
;
5698 get_data (&evda
, file
, offset
, sizeof (evda
),
5699 _("version def aux"));
5701 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5703 if (psym
->st_name
!= ivda
.vda_name
)
5704 printf ((vers_data
& 0x8000)
5706 strtab
+ ivda
.vda_name
);
5716 if (strtab
!= string_table
)
5722 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5724 if (do_histogram
&& buckets
!= NULL
)
5731 int nzero_counts
= 0;
5734 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5736 printf (_(" Length Number %% of total Coverage\n"));
5738 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5739 if (lengths
== NULL
)
5741 error (_("Out of memory"));
5744 for (hn
= 0; hn
< nbuckets
; ++hn
)
5749 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5752 if (maxlength
< ++lengths
[hn
])
5757 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5760 error (_("Out of memory"));
5764 for (hn
= 0; hn
< nbuckets
; ++hn
)
5765 ++ counts
[lengths
[hn
]];
5769 printf (" 0 %-10d (%5.1f%%)\n",
5770 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5771 for (si
= 1; si
<= maxlength
; ++si
)
5773 nzero_counts
+= counts
[si
] * si
;
5774 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5775 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5776 (nzero_counts
* 100.0) / nsyms
);
5784 if (buckets
!= NULL
)
5794 process_syminfo (file
)
5795 FILE * file ATTRIBUTE_UNUSED
;
5799 if (dynamic_syminfo
== NULL
5801 /* No syminfo, this is ok. */
5804 /* There better should be a dynamic symbol section. */
5805 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5809 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5810 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5812 printf (_(" Num: Name BoundTo Flags\n"));
5813 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5815 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5817 printf ("%4d: ", i
);
5818 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5821 switch (dynamic_syminfo
[i
].si_boundto
)
5823 case SYMINFO_BT_SELF
:
5824 fputs ("SELF ", stdout
);
5826 case SYMINFO_BT_PARENT
:
5827 fputs ("PARENT ", stdout
);
5830 if (dynamic_syminfo
[i
].si_boundto
> 0
5831 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5833 print_symbol (10, dynamic_strings
5835 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5839 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5843 if (flags
& SYMINFO_FLG_DIRECT
)
5845 if (flags
& SYMINFO_FLG_PASSTHRU
)
5846 printf (" PASSTHRU");
5847 if (flags
& SYMINFO_FLG_COPY
)
5849 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5850 printf (" LAZYLOAD");
5858 #ifdef SUPPORT_DISASSEMBLY
5860 disassemble_section (section
, file
)
5861 Elf32_Internal_Shdr
* section
;
5864 printf (_("\nAssembly dump of section %s\n"),
5865 SECTION_NAME (section
));
5867 /* XXX -- to be done --- XXX */
5874 dump_section (section
, file
)
5875 Elf32_Internal_Shdr
* section
;
5878 bfd_size_type bytes
;
5880 unsigned char * data
;
5881 unsigned char * start
;
5883 bytes
= section
->sh_size
;
5887 printf (_("\nSection '%s' has no data to dump.\n"),
5888 SECTION_NAME (section
));
5892 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5894 addr
= section
->sh_addr
;
5896 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
5909 lbytes
= (bytes
> 16 ? 16 : bytes
);
5911 printf (" 0x%8.8lx ", (unsigned long) addr
);
5913 switch (elf_header
.e_ident
[EI_DATA
])
5917 for (j
= 15; j
>= 0; j
--)
5920 printf ("%2.2x", data
[j
]);
5930 for (j
= 0; j
< 16; j
++)
5933 printf ("%2.2x", data
[j
]);
5943 for (j
= 0; j
< lbytes
; j
++)
5946 if (k
>= ' ' && k
< 0x80)
5965 static unsigned long int
5966 read_leb128 (data
, length_return
, sign
)
5967 unsigned char * data
;
5968 int * length_return
;
5971 unsigned long int result
= 0;
5972 unsigned int num_read
= 0;
5981 result
|= (byte
& 0x7f) << shift
;
5986 while (byte
& 0x80);
5988 if (length_return
!= NULL
)
5989 * length_return
= num_read
;
5991 if (sign
&& (shift
< 32) && (byte
& 0x40))
5992 result
|= -1 << shift
;
5997 typedef struct State_Machine_Registers
5999 unsigned long address
;
6002 unsigned int column
;
6006 /* This variable hold the number of the last entry seen
6007 in the File Table. */
6008 unsigned int last_file_entry
;
6011 static SMR state_machine_regs
;
6014 reset_state_machine (is_stmt
)
6017 state_machine_regs
.address
= 0;
6018 state_machine_regs
.file
= 1;
6019 state_machine_regs
.line
= 1;
6020 state_machine_regs
.column
= 0;
6021 state_machine_regs
.is_stmt
= is_stmt
;
6022 state_machine_regs
.basic_block
= 0;
6023 state_machine_regs
.end_sequence
= 0;
6024 state_machine_regs
.last_file_entry
= 0;
6027 /* Handled an extend line op. Returns true if this is the end
6030 process_extended_line_op (data
, is_stmt
, pointer_size
)
6031 unsigned char * data
;
6035 unsigned char op_code
;
6038 unsigned char * name
;
6041 len
= read_leb128 (data
, & bytes_read
, 0);
6046 warn (_("badly formed extended line op encountered!\n"));
6051 op_code
= * data
++;
6053 printf (_(" Extended opcode %d: "), op_code
);
6057 case DW_LNE_end_sequence
:
6058 printf (_("End of Sequence\n\n"));
6059 reset_state_machine (is_stmt
);
6062 case DW_LNE_set_address
:
6063 adr
= byte_get (data
, pointer_size
);
6064 printf (_("set Address to 0x%lx\n"), adr
);
6065 state_machine_regs
.address
= adr
;
6068 case DW_LNE_define_file
:
6069 printf (_(" define new File Table entry\n"));
6070 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6072 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6074 data
+= strlen ((char *) data
) + 1;
6075 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6077 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6079 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6080 printf (_("%s\n\n"), name
);
6084 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6091 /* Size of pointers in the .debug_line section. This information is not
6092 really present in that section. It's obtained before dumping the debug
6093 sections by doing some pre-scan of the .debug_info section. */
6094 static int debug_line_pointer_size
= 4;
6097 display_debug_lines (section
, start
, file
)
6098 Elf32_Internal_Shdr
* section
;
6099 unsigned char * start
;
6100 FILE * file ATTRIBUTE_UNUSED
;
6102 DWARF2_External_LineInfo
* external
;
6103 DWARF2_Internal_LineInfo info
;
6104 unsigned char * standard_opcodes
;
6105 unsigned char * data
= start
;
6106 unsigned char * end
= start
+ section
->sh_size
;
6107 unsigned char * end_of_sequence
;
6110 printf (_("\nDump of debug contents of section %s:\n\n"),
6111 SECTION_NAME (section
));
6115 external
= (DWARF2_External_LineInfo
*) data
;
6117 /* Check the length of the block. */
6118 info
.li_length
= BYTE_GET (external
->li_length
);
6120 if (info
.li_length
== 0xffffffff)
6122 warn (_("64-bit DWARF line info is not supported yet.\n"));
6126 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6129 (_("The line info appears to be corrupt - the section is too small\n"));
6133 /* Check its version number. */
6134 info
.li_version
= BYTE_GET (external
->li_version
);
6135 if (info
.li_version
!= 2)
6137 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6141 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6142 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6143 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6144 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6145 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6146 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6148 /* Sign extend the line base field. */
6149 info
.li_line_base
<<= 24;
6150 info
.li_line_base
>>= 24;
6152 printf (_(" Length: %ld\n"), info
.li_length
);
6153 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6154 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6155 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6156 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6157 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6158 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6159 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6161 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6163 reset_state_machine (info
.li_default_is_stmt
);
6165 /* Display the contents of the Opcodes table. */
6166 standard_opcodes
= data
+ sizeof (* external
);
6168 printf (_("\n Opcodes:\n"));
6170 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6171 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6173 /* Display the contents of the Directory table. */
6174 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6177 printf (_("\n The Directory Table is empty.\n"));
6180 printf (_("\n The Directory Table:\n"));
6184 printf (_(" %s\n"), data
);
6186 data
+= strlen ((char *) data
) + 1;
6190 /* Skip the NUL at the end of the table. */
6193 /* Display the contents of the File Name table. */
6195 printf (_("\n The File Name Table is empty.\n"));
6198 printf (_("\n The File Name Table:\n"));
6199 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6203 unsigned char * name
;
6206 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
6209 data
+= strlen ((char *) data
) + 1;
6211 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6213 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6215 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6217 printf (_("%s\n"), name
);
6221 /* Skip the NUL at the end of the table. */
6224 /* Now display the statements. */
6225 printf (_("\n Line Number Statements:\n"));
6228 while (data
< end_of_sequence
)
6230 unsigned char op_code
;
6234 op_code
= * data
++;
6236 if (op_code
>= info
.li_opcode_base
)
6238 op_code
-= info
.li_opcode_base
;
6239 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6240 state_machine_regs
.address
+= adv
;
6241 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6242 op_code
, adv
, state_machine_regs
.address
);
6243 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6244 state_machine_regs
.line
+= adv
;
6245 printf (_(" and Line by %d to %d\n"),
6246 adv
, state_machine_regs
.line
);
6248 else switch (op_code
)
6250 case DW_LNS_extended_op
:
6251 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6252 debug_line_pointer_size
);
6256 printf (_(" Copy\n"));
6259 case DW_LNS_advance_pc
:
6260 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6262 state_machine_regs
.address
+= adv
;
6263 printf (_(" Advance PC by %d to %lx\n"), adv
,
6264 state_machine_regs
.address
);
6267 case DW_LNS_advance_line
:
6268 adv
= read_leb128 (data
, & bytes_read
, 1);
6270 state_machine_regs
.line
+= adv
;
6271 printf (_(" Advance Line by %d to %d\n"), adv
,
6272 state_machine_regs
.line
);
6275 case DW_LNS_set_file
:
6276 adv
= read_leb128 (data
, & bytes_read
, 0);
6278 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6280 state_machine_regs
.file
= adv
;
6283 case DW_LNS_set_column
:
6284 adv
= read_leb128 (data
, & bytes_read
, 0);
6286 printf (_(" Set column to %d\n"), adv
);
6287 state_machine_regs
.column
= adv
;
6290 case DW_LNS_negate_stmt
:
6291 adv
= state_machine_regs
.is_stmt
;
6293 printf (_(" Set is_stmt to %d\n"), adv
);
6294 state_machine_regs
.is_stmt
= adv
;
6297 case DW_LNS_set_basic_block
:
6298 printf (_(" Set basic block\n"));
6299 state_machine_regs
.basic_block
= 1;
6302 case DW_LNS_const_add_pc
:
6303 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6304 * info
.li_min_insn_length
);
6305 state_machine_regs
.address
+= adv
;
6306 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6307 state_machine_regs
.address
);
6310 case DW_LNS_fixed_advance_pc
:
6311 adv
= byte_get (data
, 2);
6313 state_machine_regs
.address
+= adv
;
6314 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6315 adv
, state_machine_regs
.address
);
6318 case DW_LNS_set_prologue_end
:
6319 printf (_(" Set prologue_end to true\n"));
6322 case DW_LNS_set_epilogue_begin
:
6323 printf (_(" Set epilogue_begin to true\n"));
6326 case DW_LNS_set_isa
:
6327 adv
= read_leb128 (data
, & bytes_read
, 0);
6329 printf (_(" Set ISA to %d\n"), adv
);
6333 printf (_(" Unknown opcode %d with operands: "), op_code
);
6336 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6338 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6339 i
== 1 ? "" : ", ");
6354 display_debug_pubnames (section
, start
, file
)
6355 Elf32_Internal_Shdr
* section
;
6356 unsigned char * start
;
6357 FILE * file ATTRIBUTE_UNUSED
;
6359 DWARF2_External_PubNames
* external
;
6360 DWARF2_Internal_PubNames pubnames
;
6361 unsigned char * end
;
6363 end
= start
+ section
->sh_size
;
6365 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6369 unsigned char * data
;
6370 unsigned long offset
;
6372 external
= (DWARF2_External_PubNames
*) start
;
6374 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6375 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6376 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6377 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6379 data
= start
+ sizeof (* external
);
6380 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6382 if (pubnames
.pn_length
== 0xffffffff)
6384 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6388 if (pubnames
.pn_version
!= 2)
6390 static int warned
= 0;
6394 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6401 printf (_(" Length: %ld\n"),
6402 pubnames
.pn_length
);
6403 printf (_(" Version: %d\n"),
6404 pubnames
.pn_version
);
6405 printf (_(" Offset into .debug_info section: %ld\n"),
6406 pubnames
.pn_offset
);
6407 printf (_(" Size of area in .debug_info section: %ld\n"),
6410 printf (_("\n Offset\tName\n"));
6414 offset
= byte_get (data
, 4);
6419 printf (" %ld\t\t%s\n", offset
, data
);
6420 data
+= strlen ((char *) data
) + 1;
6423 while (offset
!= 0);
6436 case DW_TAG_padding
: return "DW_TAG_padding";
6437 case DW_TAG_array_type
: return "DW_TAG_array_type";
6438 case DW_TAG_class_type
: return "DW_TAG_class_type";
6439 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6440 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6441 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6442 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6443 case DW_TAG_label
: return "DW_TAG_label";
6444 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6445 case DW_TAG_member
: return "DW_TAG_member";
6446 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6447 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6448 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6449 case DW_TAG_string_type
: return "DW_TAG_string_type";
6450 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6451 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6452 case DW_TAG_typedef
: return "DW_TAG_typedef";
6453 case DW_TAG_union_type
: return "DW_TAG_union_type";
6454 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6455 case DW_TAG_variant
: return "DW_TAG_variant";
6456 case DW_TAG_common_block
: return "DW_TAG_common_block";
6457 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6458 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6459 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6460 case DW_TAG_module
: return "DW_TAG_module";
6461 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6462 case DW_TAG_set_type
: return "DW_TAG_set_type";
6463 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6464 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6465 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6466 case DW_TAG_base_type
: return "DW_TAG_base_type";
6467 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6468 case DW_TAG_const_type
: return "DW_TAG_const_type";
6469 case DW_TAG_constant
: return "DW_TAG_constant";
6470 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6471 case DW_TAG_file_type
: return "DW_TAG_file_type";
6472 case DW_TAG_friend
: return "DW_TAG_friend";
6473 case DW_TAG_namelist
: return "DW_TAG_namelist";
6474 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6475 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6476 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6477 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6478 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6479 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6480 case DW_TAG_try_block
: return "DW_TAG_try_block";
6481 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6482 case DW_TAG_variable
: return "DW_TAG_variable";
6483 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6484 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6485 case DW_TAG_format_label
: return "DW_TAG_format_label";
6486 case DW_TAG_function_template
: return "DW_TAG_function_template";
6487 case DW_TAG_class_template
: return "DW_TAG_class_template";
6488 /* DWARF 2.1 values. */
6489 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6490 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6491 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6492 case DW_TAG_namespace
: return "DW_TAG_namespace";
6493 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6494 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6495 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6496 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6499 static char buffer
[100];
6501 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6508 get_AT_name (attribute
)
6509 unsigned long attribute
;
6513 case DW_AT_sibling
: return "DW_AT_sibling";
6514 case DW_AT_location
: return "DW_AT_location";
6515 case DW_AT_name
: return "DW_AT_name";
6516 case DW_AT_ordering
: return "DW_AT_ordering";
6517 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6518 case DW_AT_byte_size
: return "DW_AT_byte_size";
6519 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6520 case DW_AT_bit_size
: return "DW_AT_bit_size";
6521 case DW_AT_element_list
: return "DW_AT_element_list";
6522 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6523 case DW_AT_low_pc
: return "DW_AT_low_pc";
6524 case DW_AT_high_pc
: return "DW_AT_high_pc";
6525 case DW_AT_language
: return "DW_AT_language";
6526 case DW_AT_member
: return "DW_AT_member";
6527 case DW_AT_discr
: return "DW_AT_discr";
6528 case DW_AT_discr_value
: return "DW_AT_discr_value";
6529 case DW_AT_visibility
: return "DW_AT_visibility";
6530 case DW_AT_import
: return "DW_AT_import";
6531 case DW_AT_string_length
: return "DW_AT_string_length";
6532 case DW_AT_common_reference
: return "DW_AT_common_reference";
6533 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6534 case DW_AT_const_value
: return "DW_AT_const_value";
6535 case DW_AT_containing_type
: return "DW_AT_containing_type";
6536 case DW_AT_default_value
: return "DW_AT_default_value";
6537 case DW_AT_inline
: return "DW_AT_inline";
6538 case DW_AT_is_optional
: return "DW_AT_is_optional";
6539 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6540 case DW_AT_producer
: return "DW_AT_producer";
6541 case DW_AT_prototyped
: return "DW_AT_prototyped";
6542 case DW_AT_return_addr
: return "DW_AT_return_addr";
6543 case DW_AT_start_scope
: return "DW_AT_start_scope";
6544 case DW_AT_stride_size
: return "DW_AT_stride_size";
6545 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6546 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6547 case DW_AT_accessibility
: return "DW_AT_accessibility";
6548 case DW_AT_address_class
: return "DW_AT_address_class";
6549 case DW_AT_artificial
: return "DW_AT_artificial";
6550 case DW_AT_base_types
: return "DW_AT_base_types";
6551 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6552 case DW_AT_count
: return "DW_AT_count";
6553 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6554 case DW_AT_decl_column
: return "DW_AT_decl_column";
6555 case DW_AT_decl_file
: return "DW_AT_decl_file";
6556 case DW_AT_decl_line
: return "DW_AT_decl_line";
6557 case DW_AT_declaration
: return "DW_AT_declaration";
6558 case DW_AT_discr_list
: return "DW_AT_discr_list";
6559 case DW_AT_encoding
: return "DW_AT_encoding";
6560 case DW_AT_external
: return "DW_AT_external";
6561 case DW_AT_frame_base
: return "DW_AT_frame_base";
6562 case DW_AT_friend
: return "DW_AT_friend";
6563 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6564 case DW_AT_macro_info
: return "DW_AT_macro_info";
6565 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6566 case DW_AT_priority
: return "DW_AT_priority";
6567 case DW_AT_segment
: return "DW_AT_segment";
6568 case DW_AT_specification
: return "DW_AT_specification";
6569 case DW_AT_static_link
: return "DW_AT_static_link";
6570 case DW_AT_type
: return "DW_AT_type";
6571 case DW_AT_use_location
: return "DW_AT_use_location";
6572 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6573 case DW_AT_virtuality
: return "DW_AT_virtuality";
6574 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6575 /* DWARF 2.1 values. */
6576 case DW_AT_allocated
: return "DW_AT_allocated";
6577 case DW_AT_associated
: return "DW_AT_associated";
6578 case DW_AT_data_location
: return "DW_AT_data_location";
6579 case DW_AT_stride
: return "DW_AT_stride";
6580 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6581 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6582 case DW_AT_extension
: return "DW_AT_extension";
6583 case DW_AT_ranges
: return "DW_AT_ranges";
6584 case DW_AT_trampoline
: return "DW_AT_trampoline";
6585 case DW_AT_call_column
: return "DW_AT_call_column";
6586 case DW_AT_call_file
: return "DW_AT_call_file";
6587 case DW_AT_call_line
: return "DW_AT_call_line";
6588 /* SGI/MIPS extensions. */
6589 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6590 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6591 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6592 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6593 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6594 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6595 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6596 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6597 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6598 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6599 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6600 /* GNU extensions. */
6601 case DW_AT_sf_names
: return "DW_AT_sf_names";
6602 case DW_AT_src_info
: return "DW_AT_src_info";
6603 case DW_AT_mac_info
: return "DW_AT_mac_info";
6604 case DW_AT_src_coords
: return "DW_AT_src_coords";
6605 case DW_AT_body_begin
: return "DW_AT_body_begin";
6606 case DW_AT_body_end
: return "DW_AT_body_end";
6607 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6610 static char buffer
[100];
6612 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6619 get_FORM_name (form
)
6624 case DW_FORM_addr
: return "DW_FORM_addr";
6625 case DW_FORM_block2
: return "DW_FORM_block2";
6626 case DW_FORM_block4
: return "DW_FORM_block4";
6627 case DW_FORM_data2
: return "DW_FORM_data2";
6628 case DW_FORM_data4
: return "DW_FORM_data4";
6629 case DW_FORM_data8
: return "DW_FORM_data8";
6630 case DW_FORM_string
: return "DW_FORM_string";
6631 case DW_FORM_block
: return "DW_FORM_block";
6632 case DW_FORM_block1
: return "DW_FORM_block1";
6633 case DW_FORM_data1
: return "DW_FORM_data1";
6634 case DW_FORM_flag
: return "DW_FORM_flag";
6635 case DW_FORM_sdata
: return "DW_FORM_sdata";
6636 case DW_FORM_strp
: return "DW_FORM_strp";
6637 case DW_FORM_udata
: return "DW_FORM_udata";
6638 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6639 case DW_FORM_ref1
: return "DW_FORM_ref1";
6640 case DW_FORM_ref2
: return "DW_FORM_ref2";
6641 case DW_FORM_ref4
: return "DW_FORM_ref4";
6642 case DW_FORM_ref8
: return "DW_FORM_ref8";
6643 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6644 case DW_FORM_indirect
: return "DW_FORM_indirect";
6647 static char buffer
[100];
6649 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6655 /* FIXME: There are better and more effiecint ways to handle
6656 these structures. For now though, I just want something that
6657 is simple to implement. */
6658 typedef struct abbrev_attr
6660 unsigned long attribute
;
6662 struct abbrev_attr
* next
;
6666 typedef struct abbrev_entry
6668 unsigned long entry
;
6671 struct abbrev_attr
* first_attr
;
6672 struct abbrev_attr
* last_attr
;
6673 struct abbrev_entry
* next
;
6677 static abbrev_entry
* first_abbrev
= NULL
;
6678 static abbrev_entry
* last_abbrev
= NULL
;
6681 free_abbrevs
PARAMS ((void))
6683 abbrev_entry
* abbrev
;
6685 for (abbrev
= first_abbrev
; abbrev
;)
6687 abbrev_entry
* next
= abbrev
->next
;
6690 for (attr
= abbrev
->first_attr
; attr
;)
6692 abbrev_attr
* next
= attr
->next
;
6702 last_abbrev
= first_abbrev
= NULL
;
6706 add_abbrev (number
, tag
, children
)
6707 unsigned long number
;
6711 abbrev_entry
* entry
;
6713 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6719 entry
->entry
= number
;
6721 entry
->children
= children
;
6722 entry
->first_attr
= NULL
;
6723 entry
->last_attr
= NULL
;
6726 if (first_abbrev
== NULL
)
6727 first_abbrev
= entry
;
6729 last_abbrev
->next
= entry
;
6731 last_abbrev
= entry
;
6735 add_abbrev_attr (attribute
, form
)
6736 unsigned long attribute
;
6741 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6747 attr
->attribute
= attribute
;
6751 if (last_abbrev
->first_attr
== NULL
)
6752 last_abbrev
->first_attr
= attr
;
6754 last_abbrev
->last_attr
->next
= attr
;
6756 last_abbrev
->last_attr
= attr
;
6759 /* Processes the (partial) contents of a .debug_abbrev section.
6760 Returns NULL if the end of the section was encountered.
6761 Returns the address after the last byte read if the end of
6762 an abbreviation set was found. */
6764 static unsigned char *
6765 process_abbrev_section (start
, end
)
6766 unsigned char * start
;
6767 unsigned char * end
;
6769 if (first_abbrev
!= NULL
)
6775 unsigned long entry
;
6777 unsigned long attribute
;
6780 entry
= read_leb128 (start
, & bytes_read
, 0);
6781 start
+= bytes_read
;
6783 /* A single zero is supposed to end the section according
6784 to the standard. If there's more, then signal that to
6787 return start
== end
? NULL
: start
;
6789 tag
= read_leb128 (start
, & bytes_read
, 0);
6790 start
+= bytes_read
;
6792 children
= * start
++;
6794 add_abbrev (entry
, tag
, children
);
6800 attribute
= read_leb128 (start
, & bytes_read
, 0);
6801 start
+= bytes_read
;
6803 form
= read_leb128 (start
, & bytes_read
, 0);
6804 start
+= bytes_read
;
6807 add_abbrev_attr (attribute
, form
);
6809 while (attribute
!= 0);
6817 display_debug_macinfo (section
, start
, file
)
6818 Elf32_Internal_Shdr
* section
;
6819 unsigned char * start
;
6820 FILE * file ATTRIBUTE_UNUSED
;
6822 unsigned char * end
= start
+ section
->sh_size
;
6823 unsigned char * curr
= start
;
6824 unsigned int bytes_read
;
6825 enum dwarf_macinfo_record_type op
;
6827 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6831 unsigned int lineno
;
6832 const char * string
;
6839 case DW_MACINFO_start_file
:
6841 unsigned int filenum
;
6843 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6845 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6848 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6852 case DW_MACINFO_end_file
:
6853 printf (_(" DW_MACINFO_end_file\n"));
6856 case DW_MACINFO_define
:
6857 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6860 curr
+= strlen (string
) + 1;
6861 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6864 case DW_MACINFO_undef
:
6865 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6868 curr
+= strlen (string
) + 1;
6869 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
6872 case DW_MACINFO_vendor_ext
:
6874 unsigned int constant
;
6876 constant
= read_leb128 (curr
, & bytes_read
, 0);
6879 curr
+= strlen (string
) + 1;
6880 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
6891 display_debug_abbrev (section
, start
, file
)
6892 Elf32_Internal_Shdr
* section
;
6893 unsigned char * start
;
6894 FILE * file ATTRIBUTE_UNUSED
;
6896 abbrev_entry
* entry
;
6897 unsigned char * end
= start
+ section
->sh_size
;
6899 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6903 start
= process_abbrev_section (start
, end
);
6905 if (first_abbrev
== NULL
)
6908 printf (_(" Number TAG\n"));
6910 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
6914 printf (_(" %ld %s [%s]\n"),
6916 get_TAG_name (entry
->tag
),
6917 entry
->children
? _("has children") : _("no children"));
6919 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6921 printf (_(" %-18s %s\n"),
6922 get_AT_name (attr
->attribute
),
6923 get_FORM_name (attr
->form
));
6937 static unsigned char *
6938 display_block (data
, length
)
6939 unsigned char * data
;
6940 unsigned long length
;
6942 printf (_(" %lu byte block: "), length
);
6945 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
6951 decode_location_expression (data
, pointer_size
, length
)
6952 unsigned char * data
;
6953 unsigned int pointer_size
;
6954 unsigned long length
;
6958 unsigned long uvalue
;
6959 unsigned char * end
= data
+ length
;
6968 printf ("DW_OP_addr: %lx",
6969 (unsigned long) byte_get (data
, pointer_size
));
6970 data
+= pointer_size
;
6973 printf ("DW_OP_deref");
6976 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
6979 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
6982 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
6986 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
6990 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
6994 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
6998 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
6999 (unsigned long) byte_get (data
+ 4, 4));
7003 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7004 (long) byte_get (data
+ 4, 4));
7008 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7012 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7016 printf ("DW_OP_dup");
7019 printf ("DW_OP_drop");
7022 printf ("DW_OP_over");
7025 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7028 printf ("DW_OP_swap");
7031 printf ("DW_OP_rot");
7034 printf ("DW_OP_xderef");
7037 printf ("DW_OP_abs");
7040 printf ("DW_OP_and");
7043 printf ("DW_OP_div");
7046 printf ("DW_OP_minus");
7049 printf ("DW_OP_mod");
7052 printf ("DW_OP_mul");
7055 printf ("DW_OP_neg");
7058 printf ("DW_OP_not");
7061 printf ("DW_OP_or");
7064 printf ("DW_OP_plus");
7066 case DW_OP_plus_uconst
:
7067 printf ("DW_OP_plus_uconst: %lu",
7068 read_leb128 (data
, &bytes_read
, 0));
7072 printf ("DW_OP_shl");
7075 printf ("DW_OP_shr");
7078 printf ("DW_OP_shra");
7081 printf ("DW_OP_xor");
7084 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7088 printf ("DW_OP_eq");
7091 printf ("DW_OP_ge");
7094 printf ("DW_OP_gt");
7097 printf ("DW_OP_le");
7100 printf ("DW_OP_lt");
7103 printf ("DW_OP_ne");
7106 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7142 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7177 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7212 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7213 read_leb128 (data
, &bytes_read
, 1));
7218 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7222 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7226 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7228 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7229 read_leb128 (data
, &bytes_read
, 1));
7233 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7236 case DW_OP_deref_size
:
7237 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7239 case DW_OP_xderef_size
:
7240 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7243 printf ("DW_OP_nop");
7246 /* DWARF 2.1 extensions. */
7247 case DW_OP_push_object_address
:
7248 printf ("DW_OP_push_object_address");
7251 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7255 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7259 printf ("DW_OP_calli");
7263 if (op
>= DW_OP_lo_user
7264 && op
<= DW_OP_hi_user
)
7265 printf (_("(User defined location op)"));
7267 printf (_("(Unknown location op)"));
7268 /* No way to tell where the next op is, so just bail. */
7272 /* Separate the ops. */
7277 static const char * debug_loc_contents
;
7278 static bfd_vma debug_loc_size
;
7281 load_debug_loc (file
)
7284 Elf32_Internal_Shdr
* sec
;
7287 /* If it is already loaded, do nothing. */
7288 if (debug_loc_contents
!= NULL
)
7291 /* Locate the .debug_loc section. */
7292 for (i
= 0, sec
= section_headers
;
7293 i
< elf_header
.e_shnum
;
7295 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7298 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7301 debug_loc_size
= sec
->sh_size
;
7303 debug_loc_contents
= ((char *)
7304 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7305 _("debug_loc section data")));
7311 if (debug_loc_contents
== NULL
)
7314 free ((char *) debug_loc_contents
);
7315 debug_loc_contents
= NULL
;
7321 display_debug_loc (section
, start
, file
)
7322 Elf32_Internal_Shdr
* section
;
7323 unsigned char * start
;
7324 FILE * file ATTRIBUTE_UNUSED
;
7326 unsigned char *section_end
;
7327 unsigned long bytes
;
7328 unsigned char *section_begin
= start
;
7331 addr
= section
->sh_addr
;
7332 bytes
= section
->sh_size
;
7333 section_end
= start
+ bytes
;
7336 printf (_("\nThe .debug_loc section is empty.\n"));
7339 printf (_("Contents of the .debug_loc section:\n\n"));
7340 printf (_("\n Offset Begin End Expression\n"));
7341 while (start
< section_end
)
7343 unsigned long begin
;
7345 unsigned short length
;
7346 unsigned long offset
;
7348 offset
= start
- section_begin
;
7352 /* Normally, the lists in the debug_loc section are related to a
7353 given compilation unit, and thus, we would use the
7354 pointer size of that compilation unit. However, since we are
7355 displaying it seperately here, we either have to store
7356 pointer sizes of all compilation units, or assume they don't
7357 change. We assume, like the debug_line display, that
7358 it doesn't change. */
7359 begin
= byte_get (start
, debug_line_pointer_size
);
7360 start
+= debug_line_pointer_size
;
7361 end
= byte_get (start
, debug_line_pointer_size
);
7362 start
+= debug_line_pointer_size
;
7364 if (begin
== 0 && end
== 0)
7370 length
= byte_get (start
, 2);
7373 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7374 decode_location_expression (start
, debug_line_pointer_size
, length
);
7384 static const char * debug_str_contents
;
7385 static bfd_vma debug_str_size
;
7388 load_debug_str (file
)
7391 Elf32_Internal_Shdr
* sec
;
7394 /* If it is already loaded, do nothing. */
7395 if (debug_str_contents
!= NULL
)
7398 /* Locate the .debug_str section. */
7399 for (i
= 0, sec
= section_headers
;
7400 i
< elf_header
.e_shnum
;
7402 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7405 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7408 debug_str_size
= sec
->sh_size
;
7410 debug_str_contents
= ((char *)
7411 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7412 _("debug_str section data")));
7418 if (debug_str_contents
== NULL
)
7421 free ((char *) debug_str_contents
);
7422 debug_str_contents
= NULL
;
7427 fetch_indirect_string (offset
)
7428 unsigned long offset
;
7430 if (debug_str_contents
== NULL
)
7431 return _("<no .debug_str section>");
7433 if (offset
> debug_str_size
)
7434 return _("<offset is too big>");
7436 return debug_str_contents
+ offset
;
7441 display_debug_str (section
, start
, file
)
7442 Elf32_Internal_Shdr
* section
;
7443 unsigned char * start
;
7444 FILE * file ATTRIBUTE_UNUSED
;
7446 unsigned long bytes
;
7449 addr
= section
->sh_addr
;
7450 bytes
= section
->sh_size
;
7454 printf (_("\nThe .debug_str section is empty.\n"));
7458 printf (_("Contents of the .debug_str section:\n\n"));
7466 lbytes
= (bytes
> 16 ? 16 : bytes
);
7468 printf (" 0x%8.8lx ", (unsigned long) addr
);
7470 for (j
= 0; j
< 16; j
++)
7473 printf ("%2.2x", start
[j
]);
7481 for (j
= 0; j
< lbytes
; j
++)
7484 if (k
>= ' ' && k
< 0x80)
7501 static unsigned char *
7502 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7503 unsigned long attribute
;
7505 unsigned char * data
;
7506 unsigned long cu_offset
;
7507 unsigned long pointer_size
;
7509 unsigned long uvalue
= 0;
7510 unsigned char * block_start
= NULL
;
7518 case DW_FORM_ref_addr
:
7520 uvalue
= byte_get (data
, pointer_size
);
7521 data
+= pointer_size
;
7525 uvalue
= byte_get (data
, /* offset_size */ 4);
7526 data
+= /* offset_size */ 4;
7532 uvalue
= byte_get (data
++, 1);
7537 uvalue
= byte_get (data
, 2);
7543 uvalue
= byte_get (data
, 4);
7548 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7552 case DW_FORM_ref_udata
:
7554 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7558 case DW_FORM_indirect
:
7559 form
= read_leb128 (data
, & bytes_read
, 0);
7561 printf (" %s", get_FORM_name (form
));
7562 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7568 case DW_FORM_ref_addr
:
7569 printf (" <#%lx>", uvalue
);
7575 case DW_FORM_ref_udata
:
7576 printf (" <%lx>", uvalue
+ cu_offset
);
7580 printf (" %#lx", uvalue
);
7588 printf (" %ld", uvalue
);
7593 uvalue
= byte_get (data
, 4);
7594 printf (" %lx", uvalue
);
7595 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7599 case DW_FORM_string
:
7600 printf (" %s", data
);
7601 data
+= strlen ((char *) data
) + 1;
7605 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7606 block_start
= data
+ bytes_read
;
7607 data
= display_block (block_start
, uvalue
);
7610 case DW_FORM_block1
:
7611 uvalue
= byte_get (data
, 1);
7612 block_start
= data
+ 1;
7613 data
= display_block (block_start
, uvalue
);
7616 case DW_FORM_block2
:
7617 uvalue
= byte_get (data
, 2);
7618 block_start
= data
+ 2;
7619 data
= display_block (block_start
, uvalue
);
7622 case DW_FORM_block4
:
7623 uvalue
= byte_get (data
, 4);
7624 block_start
= data
+ 4;
7625 data
= display_block (block_start
, uvalue
);
7629 printf (_(" (indirect string, offset: 0x%lx): "), uvalue
);
7630 printf (fetch_indirect_string (uvalue
));
7633 case DW_FORM_indirect
:
7634 /* Handled above. */
7638 warn (_("Unrecognized form: %d\n"), form
);
7642 /* For some attributes we can display futher information. */
7651 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7652 case DW_INL_inlined
: printf (_("(inlined)")); break;
7653 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7654 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7655 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7659 case DW_AT_language
:
7662 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7663 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7664 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7665 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7666 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7667 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7668 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7669 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7670 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7671 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7672 /* DWARF 2.1 values. */
7673 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7674 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7675 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7676 /* MIPS extension. */
7677 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7678 default: printf ("(Unknown: %lx)", uvalue
); break;
7682 case DW_AT_encoding
:
7685 case DW_ATE_void
: printf ("(void)"); break;
7686 case DW_ATE_address
: printf ("(machine address)"); break;
7687 case DW_ATE_boolean
: printf ("(boolean)"); break;
7688 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7689 case DW_ATE_float
: printf ("(float)"); break;
7690 case DW_ATE_signed
: printf ("(signed)"); break;
7691 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7692 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7693 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7694 /* DWARF 2.1 value. */
7695 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7697 if (uvalue
>= DW_ATE_lo_user
7698 && uvalue
<= DW_ATE_hi_user
)
7699 printf ("(user defined type)");
7701 printf ("(unknown type)");
7706 case DW_AT_accessibility
:
7709 case DW_ACCESS_public
: printf ("(public)"); break;
7710 case DW_ACCESS_protected
: printf ("(protected)"); break;
7711 case DW_ACCESS_private
: printf ("(private)"); break;
7712 default: printf ("(unknown accessibility)"); break;
7716 case DW_AT_visibility
:
7719 case DW_VIS_local
: printf ("(local)"); break;
7720 case DW_VIS_exported
: printf ("(exported)"); break;
7721 case DW_VIS_qualified
: printf ("(qualified)"); break;
7722 default: printf ("(unknown visibility)"); break;
7726 case DW_AT_virtuality
:
7729 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7730 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7731 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7732 default: printf ("(unknown virtuality)"); break;
7736 case DW_AT_identifier_case
:
7739 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7740 case DW_ID_up_case
: printf ("(up_case)"); break;
7741 case DW_ID_down_case
: printf ("(down_case)"); break;
7742 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7743 default: printf ("(unknown case)"); break;
7747 case DW_AT_calling_convention
:
7750 case DW_CC_normal
: printf ("(normal)"); break;
7751 case DW_CC_program
: printf ("(program)"); break;
7752 case DW_CC_nocall
: printf ("(nocall)"); break;
7754 if (uvalue
>= DW_CC_lo_user
7755 && uvalue
<= DW_CC_hi_user
)
7756 printf ("(user defined)");
7758 printf ("(unknown convention)");
7762 case DW_AT_ordering
:
7765 case -1: printf ("(undefined)"); break;
7766 case 0: printf ("(row major)"); break;
7767 case 1: printf ("(column major)"); break;
7771 case DW_AT_frame_base
:
7772 case DW_AT_location
:
7773 case DW_AT_data_member_location
:
7774 case DW_AT_vtable_elem_location
:
7775 case DW_AT_allocated
:
7776 case DW_AT_associated
:
7777 case DW_AT_data_location
:
7779 case DW_AT_upper_bound
:
7780 case DW_AT_lower_bound
:
7784 decode_location_expression (block_start
, pointer_size
, uvalue
);
7787 else if (form
== DW_FORM_data4
)
7790 printf ("location list");
7802 static unsigned char *
7803 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7804 unsigned long attribute
;
7806 unsigned char * data
;
7807 unsigned long cu_offset
;
7808 unsigned long pointer_size
;
7810 printf (" %-18s:", get_AT_name (attribute
));
7811 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7818 display_debug_info (section
, start
, file
)
7819 Elf32_Internal_Shdr
* section
;
7820 unsigned char * start
;
7823 unsigned char * end
= start
+ section
->sh_size
;
7824 unsigned char * section_begin
= start
;
7826 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7828 load_debug_str (file
);
7829 load_debug_loc (file
);
7833 DWARF2_External_CompUnit
* external
;
7834 DWARF2_Internal_CompUnit compunit
;
7835 Elf32_Internal_Shdr
* relsec
;
7836 unsigned char * tags
;
7839 unsigned long cu_offset
;
7841 external
= (DWARF2_External_CompUnit
*) start
;
7843 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7844 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7845 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7846 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7848 if (compunit
.cu_length
== 0xffffffff)
7850 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7854 /* Check for RELA relocations in the abbrev_offset address, and
7856 for (relsec
= section_headers
;
7857 relsec
< section_headers
+ elf_header
.e_shnum
;
7860 unsigned long nrelas
;
7861 Elf_Internal_Rela
*rela
, *rp
;
7862 Elf32_Internal_Shdr
*symsec
;
7863 Elf_Internal_Sym
*symtab
;
7864 Elf_Internal_Sym
*sym
;
7866 if (relsec
->sh_type
!= SHT_RELA
7867 || SECTION_HEADER (relsec
->sh_info
) != section
)
7870 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7874 symsec
= SECTION_HEADER (relsec
->sh_link
);
7875 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7877 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7880 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
7886 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7888 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7890 warn (_("Skipping unexpected symbol type %u\n"),
7891 ELF32_ST_TYPE (sym
->st_info
));
7897 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7899 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7901 warn (_("Skipping unexpected symbol type %u\n"),
7902 ELF64_ST_TYPE (sym
->st_info
));
7907 compunit
.cu_abbrev_offset
+= rp
->r_addend
;
7915 tags
= start
+ sizeof (* external
);
7916 cu_offset
= start
- section_begin
;
7917 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
7919 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
7920 printf (_(" Length: %ld\n"), compunit
.cu_length
);
7921 printf (_(" Version: %d\n"), compunit
.cu_version
);
7922 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
7923 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
7925 if (compunit
.cu_version
!= 2)
7927 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7933 /* Read in the abbrevs used by this compilation unit. */
7936 Elf32_Internal_Shdr
* sec
;
7937 unsigned char * begin
;
7939 /* Locate the .debug_abbrev section and process it. */
7940 for (i
= 0, sec
= section_headers
;
7941 i
< elf_header
.e_shnum
;
7943 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
7946 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7948 warn (_("Unable to locate .debug_abbrev section!\n"));
7952 begin
= ((unsigned char *)
7953 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7954 _("debug_abbrev section data")));
7958 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
7959 begin
+ sec
->sh_size
);
7965 while (tags
< start
)
7968 unsigned long abbrev_number
;
7969 abbrev_entry
* entry
;
7972 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
7975 /* A null DIE marks the end of a list of children. */
7976 if (abbrev_number
== 0)
7982 /* Scan through the abbreviation list until we reach the
7984 for (entry
= first_abbrev
;
7985 entry
&& entry
->entry
!= abbrev_number
;
7986 entry
= entry
->next
)
7991 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7996 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7998 (unsigned long) (tags
- section_begin
- bytes_read
),
8000 get_TAG_name (entry
->tag
));
8002 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8003 tags
= read_and_display_attr (attr
->attribute
,
8006 compunit
.cu_pointer_size
);
8008 if (entry
->children
)
8022 display_debug_aranges (section
, start
, file
)
8023 Elf32_Internal_Shdr
* section
;
8024 unsigned char * start
;
8025 FILE * file ATTRIBUTE_UNUSED
;
8027 unsigned char * end
= start
+ section
->sh_size
;
8029 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8033 DWARF2_External_ARange
* external
;
8034 DWARF2_Internal_ARange arange
;
8035 unsigned char * ranges
;
8036 unsigned long length
;
8037 unsigned long address
;
8040 external
= (DWARF2_External_ARange
*) start
;
8042 arange
.ar_length
= BYTE_GET (external
->ar_length
);
8043 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8044 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8045 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8046 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8048 if (arange
.ar_length
== 0xffffffff)
8050 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8054 if (arange
.ar_version
!= 2)
8056 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8060 printf (_(" Length: %ld\n"), arange
.ar_length
);
8061 printf (_(" Version: %d\n"), arange
.ar_version
);
8062 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8063 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8064 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8066 printf (_("\n Address Length\n"));
8068 ranges
= start
+ sizeof (* external
);
8070 /* Must pad to an alignment boundary that is twice the pointer size. */
8071 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
8073 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8077 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8079 ranges
+= arange
.ar_pointer_size
;
8081 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8083 ranges
+= arange
.ar_pointer_size
;
8085 /* A pair of zeros marks the end of the list. */
8086 if (address
== 0 && length
== 0)
8089 printf (" %8.8lx %lu\n", address
, length
);
8092 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8100 typedef struct Frame_Chunk
8102 struct Frame_Chunk
* next
;
8103 unsigned char * chunk_start
;
8105 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8106 short int * col_type
;
8108 char * augmentation
;
8109 unsigned int code_factor
;
8111 unsigned long pc_begin
;
8112 unsigned long pc_range
;
8116 unsigned char fde_encoding
;
8120 /* A marker for a col_type that means this column was never referenced
8121 in the frame info. */
8122 #define DW_CFA_unreferenced (-1)
8124 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8125 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8126 static int size_of_encoded_value
PARAMS ((int));
8129 frame_need_space (fc
, reg
)
8133 int prev
= fc
->ncols
;
8135 if (reg
< fc
->ncols
)
8138 fc
->ncols
= reg
+ 1;
8139 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8140 fc
->ncols
* sizeof (short int));
8141 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8142 fc
->ncols
* sizeof (int));
8144 while (prev
< fc
->ncols
)
8146 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8147 fc
->col_offset
[prev
] = 0;
8153 frame_display_row (fc
, need_col_headers
, max_regs
)
8155 int * need_col_headers
;
8161 if (* max_regs
< fc
->ncols
)
8162 * max_regs
= fc
->ncols
;
8164 if (* need_col_headers
)
8166 * need_col_headers
= 0;
8168 printf (" LOC CFA ");
8170 for (r
= 0; r
< * max_regs
; r
++)
8171 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8176 printf ("r%-4d", r
);
8182 printf ("%08lx ", fc
->pc_begin
);
8183 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8184 printf ("%-8s ", tmp
);
8186 for (r
= 0; r
< fc
->ncols
; r
++)
8188 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8190 switch (fc
->col_type
[r
])
8192 case DW_CFA_undefined
:
8195 case DW_CFA_same_value
:
8199 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8201 case DW_CFA_register
:
8202 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8205 strcpy (tmp
, "n/a");
8208 printf ("%-5s", tmp
);
8215 size_of_encoded_value (encoding
)
8218 switch (encoding
& 0x7)
8221 case 0: return is_32bit_elf
? 4 : 8;
8228 #define GET(N) byte_get (start, N); start += N
8229 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8230 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8233 display_debug_frames (section
, start
, file
)
8234 Elf32_Internal_Shdr
* section
;
8235 unsigned char * start
;
8236 FILE * file ATTRIBUTE_UNUSED
;
8238 unsigned char * end
= start
+ section
->sh_size
;
8239 unsigned char * section_start
= start
;
8240 Frame_Chunk
* chunks
= 0;
8241 Frame_Chunk
* remembered_state
= 0;
8243 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8246 int addr_size
= is_32bit_elf
? 4 : 8;
8248 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8252 unsigned char * saved_start
;
8253 unsigned char * block_end
;
8254 unsigned long length
;
8255 unsigned long cie_id
;
8258 int need_col_headers
= 1;
8259 unsigned char * augmentation_data
= NULL
;
8260 unsigned long augmentation_data_len
= 0;
8261 int encoded_ptr_size
= addr_size
;
8263 saved_start
= start
;
8264 length
= byte_get (start
, 4); start
+= 4;
8269 if (length
== 0xffffffff)
8271 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8275 block_end
= saved_start
+ length
+ 4;
8276 cie_id
= byte_get (start
, 4); start
+= 4;
8278 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8282 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8283 memset (fc
, 0, sizeof (Frame_Chunk
));
8287 fc
->chunk_start
= saved_start
;
8289 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8290 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8291 frame_need_space (fc
, max_regs
-1);
8295 fc
->augmentation
= start
;
8296 start
= strchr (start
, '\0') + 1;
8298 if (fc
->augmentation
[0] == 'z')
8300 fc
->code_factor
= LEB ();
8301 fc
->data_factor
= SLEB ();
8302 fc
->ra
= byte_get (start
, 1); start
+= 1;
8303 augmentation_data_len
= LEB ();
8304 augmentation_data
= start
;
8305 start
+= augmentation_data_len
;
8307 else if (strcmp (fc
->augmentation
, "eh") == 0)
8310 fc
->code_factor
= LEB ();
8311 fc
->data_factor
= SLEB ();
8312 fc
->ra
= byte_get (start
, 1); start
+= 1;
8316 fc
->code_factor
= LEB ();
8317 fc
->data_factor
= SLEB ();
8318 fc
->ra
= byte_get (start
, 1); start
+= 1;
8322 if (do_debug_frames_interp
)
8323 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8324 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8325 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8329 printf ("\n%08lx %08lx %08lx CIE\n",
8330 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8331 printf (" Version: %d\n", version
);
8332 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8333 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8334 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8335 printf (" Return address column: %d\n", fc
->ra
);
8337 if (augmentation_data_len
)
8340 printf (" Augmentation data: ");
8341 for (i
= 0; i
< augmentation_data_len
; ++i
)
8342 printf (" %02x", augmentation_data
[i
]);
8348 if (augmentation_data_len
)
8350 unsigned char *p
, *q
;
8351 p
= fc
->augmentation
+ 1;
8352 q
= augmentation_data
;
8359 q
+= 1 + size_of_encoded_value (*q
);
8361 fc
->fde_encoding
= *q
++;
8367 if (fc
->fde_encoding
)
8368 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8371 frame_need_space (fc
, fc
->ra
);
8375 unsigned char * look_for
;
8376 static Frame_Chunk fde_fc
;
8379 memset (fc
, 0, sizeof (Frame_Chunk
));
8381 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8383 for (cie
= chunks
; cie
; cie
= cie
->next
)
8384 if (cie
->chunk_start
== look_for
)
8389 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8390 cie_id
, saved_start
);
8393 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8394 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8395 frame_need_space (fc
, max_regs
- 1);
8397 fc
->augmentation
= "";
8398 fc
->fde_encoding
= 0;
8402 fc
->ncols
= cie
->ncols
;
8403 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8404 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8405 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8406 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8407 fc
->augmentation
= cie
->augmentation
;
8408 fc
->code_factor
= cie
->code_factor
;
8409 fc
->data_factor
= cie
->data_factor
;
8410 fc
->cfa_reg
= cie
->cfa_reg
;
8411 fc
->cfa_offset
= cie
->cfa_offset
;
8413 frame_need_space (fc
, max_regs
-1);
8414 fc
->fde_encoding
= cie
->fde_encoding
;
8417 if (fc
->fde_encoding
)
8418 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8420 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8421 start
+= encoded_ptr_size
;
8422 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8423 start
+= encoded_ptr_size
;
8425 if (cie
->augmentation
[0] == 'z')
8427 augmentation_data_len
= LEB ();
8428 augmentation_data
= start
;
8429 start
+= augmentation_data_len
;
8432 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8433 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8434 (unsigned long)(cie
->chunk_start
- section_start
),
8435 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8436 if (! do_debug_frames_interp
&& augmentation_data_len
)
8439 printf (" Augmentation data: ");
8440 for (i
= 0; i
< augmentation_data_len
; ++i
)
8441 printf (" %02x", augmentation_data
[i
]);
8447 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8448 about to interpret instructions for the chunk. */
8450 if (do_debug_frames_interp
)
8452 /* Start by making a pass over the chunk, allocating storage
8453 and taking note of what registers are used. */
8454 unsigned char * tmp
= start
;
8456 while (start
< block_end
)
8466 /* Warning: if you add any more cases to this switch, be
8467 sure to add them to the corresponding switch below. */
8470 case DW_CFA_advance_loc
:
8474 frame_need_space (fc
, opa
);
8475 fc
->col_type
[opa
] = DW_CFA_undefined
;
8477 case DW_CFA_restore
:
8478 frame_need_space (fc
, opa
);
8479 fc
->col_type
[opa
] = DW_CFA_undefined
;
8481 case DW_CFA_set_loc
:
8482 start
+= encoded_ptr_size
;
8484 case DW_CFA_advance_loc1
:
8487 case DW_CFA_advance_loc2
:
8490 case DW_CFA_advance_loc4
:
8493 case DW_CFA_offset_extended
:
8494 reg
= LEB (); LEB ();
8495 frame_need_space (fc
, reg
);
8496 fc
->col_type
[reg
] = DW_CFA_undefined
;
8498 case DW_CFA_restore_extended
:
8500 frame_need_space (fc
, reg
);
8501 fc
->col_type
[reg
] = DW_CFA_undefined
;
8503 case DW_CFA_undefined
:
8505 frame_need_space (fc
, reg
);
8506 fc
->col_type
[reg
] = DW_CFA_undefined
;
8508 case DW_CFA_same_value
:
8510 frame_need_space (fc
, reg
);
8511 fc
->col_type
[reg
] = DW_CFA_undefined
;
8513 case DW_CFA_register
:
8514 reg
= LEB (); LEB ();
8515 frame_need_space (fc
, reg
);
8516 fc
->col_type
[reg
] = DW_CFA_undefined
;
8518 case DW_CFA_def_cfa
:
8521 case DW_CFA_def_cfa_register
:
8524 case DW_CFA_def_cfa_offset
:
8527 case DW_CFA_offset_extended_sf
:
8528 reg
= LEB (); SLEB ();
8529 frame_need_space (fc
, reg
);
8530 fc
->col_type
[reg
] = DW_CFA_undefined
;
8532 case DW_CFA_def_cfa_sf
:
8535 case DW_CFA_def_cfa_offset_sf
:
8538 case DW_CFA_GNU_args_size
:
8541 case DW_CFA_GNU_negative_offset_extended
:
8542 reg
= LEB (); LEB ();
8543 frame_need_space (fc
, reg
);
8544 fc
->col_type
[reg
] = DW_CFA_undefined
;
8553 /* Now we know what registers are used, make a second pass over
8554 the chunk, this time actually printing out the info. */
8556 while (start
< block_end
)
8559 unsigned long ul
, reg
, roffs
;
8568 /* Warning: if you add any more cases to this switch, be
8569 sure to add them to the corresponding switch above. */
8572 case DW_CFA_advance_loc
:
8573 if (do_debug_frames_interp
)
8574 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8576 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8577 opa
* fc
->code_factor
,
8578 fc
->pc_begin
+ opa
* fc
->code_factor
);
8579 fc
->pc_begin
+= opa
* fc
->code_factor
;
8584 if (! do_debug_frames_interp
)
8585 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8586 opa
, roffs
* fc
->data_factor
);
8587 fc
->col_type
[opa
] = DW_CFA_offset
;
8588 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8591 case DW_CFA_restore
:
8592 if (! do_debug_frames_interp
)
8593 printf (" DW_CFA_restore: r%d\n", opa
);
8594 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8595 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8598 case DW_CFA_set_loc
:
8599 vma
= byte_get (start
, encoded_ptr_size
);
8600 start
+= encoded_ptr_size
;
8601 if (do_debug_frames_interp
)
8602 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8604 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8608 case DW_CFA_advance_loc1
:
8609 ofs
= byte_get (start
, 1); start
+= 1;
8610 if (do_debug_frames_interp
)
8611 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8613 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8614 ofs
* fc
->code_factor
,
8615 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8616 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8619 case DW_CFA_advance_loc2
:
8620 ofs
= byte_get (start
, 2); start
+= 2;
8621 if (do_debug_frames_interp
)
8622 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8624 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8625 ofs
* fc
->code_factor
,
8626 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8627 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8630 case DW_CFA_advance_loc4
:
8631 ofs
= byte_get (start
, 4); start
+= 4;
8632 if (do_debug_frames_interp
)
8633 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8635 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8636 ofs
* fc
->code_factor
,
8637 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8638 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8641 case DW_CFA_offset_extended
:
8644 if (! do_debug_frames_interp
)
8645 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8646 reg
, roffs
* fc
->data_factor
);
8647 fc
->col_type
[reg
] = DW_CFA_offset
;
8648 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8651 case DW_CFA_restore_extended
:
8653 if (! do_debug_frames_interp
)
8654 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8655 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8656 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8659 case DW_CFA_undefined
:
8661 if (! do_debug_frames_interp
)
8662 printf (" DW_CFA_undefined: r%ld\n", reg
);
8663 fc
->col_type
[reg
] = DW_CFA_undefined
;
8664 fc
->col_offset
[reg
] = 0;
8667 case DW_CFA_same_value
:
8669 if (! do_debug_frames_interp
)
8670 printf (" DW_CFA_same_value: r%ld\n", reg
);
8671 fc
->col_type
[reg
] = DW_CFA_same_value
;
8672 fc
->col_offset
[reg
] = 0;
8675 case DW_CFA_register
:
8678 if (! do_debug_frames_interp
)
8679 printf (" DW_CFA_register: r%ld\n", reg
);
8680 fc
->col_type
[reg
] = DW_CFA_register
;
8681 fc
->col_offset
[reg
] = roffs
;
8684 case DW_CFA_remember_state
:
8685 if (! do_debug_frames_interp
)
8686 printf (" DW_CFA_remember_state\n");
8687 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8688 rs
->ncols
= fc
->ncols
;
8689 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8690 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8691 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8692 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8693 rs
->next
= remembered_state
;
8694 remembered_state
= rs
;
8697 case DW_CFA_restore_state
:
8698 if (! do_debug_frames_interp
)
8699 printf (" DW_CFA_restore_state\n");
8700 rs
= remembered_state
;
8701 remembered_state
= rs
->next
;
8702 frame_need_space (fc
, rs
->ncols
-1);
8703 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8704 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8705 free (rs
->col_type
);
8706 free (rs
->col_offset
);
8710 case DW_CFA_def_cfa
:
8711 fc
->cfa_reg
= LEB ();
8712 fc
->cfa_offset
= LEB ();
8713 if (! do_debug_frames_interp
)
8714 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8715 fc
->cfa_reg
, fc
->cfa_offset
);
8718 case DW_CFA_def_cfa_register
:
8719 fc
->cfa_reg
= LEB ();
8720 if (! do_debug_frames_interp
)
8721 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8724 case DW_CFA_def_cfa_offset
:
8725 fc
->cfa_offset
= LEB ();
8726 if (! do_debug_frames_interp
)
8727 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8731 if (! do_debug_frames_interp
)
8732 printf (" DW_CFA_nop\n");
8735 case DW_CFA_offset_extended_sf
:
8738 frame_need_space (fc
, reg
);
8739 if (! do_debug_frames_interp
)
8740 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8741 reg
, l
* fc
->data_factor
);
8742 fc
->col_type
[reg
] = DW_CFA_offset
;
8743 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8746 case DW_CFA_def_cfa_sf
:
8747 fc
->cfa_reg
= LEB ();
8748 fc
->cfa_offset
= SLEB ();
8749 if (! do_debug_frames_interp
)
8750 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8751 fc
->cfa_reg
, fc
->cfa_offset
);
8754 case DW_CFA_def_cfa_offset_sf
:
8755 fc
->cfa_offset
= SLEB ();
8756 if (! do_debug_frames_interp
)
8757 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
8760 case DW_CFA_GNU_window_save
:
8761 if (! do_debug_frames_interp
)
8762 printf (" DW_CFA_GNU_window_save\n");
8765 case DW_CFA_GNU_args_size
:
8767 if (! do_debug_frames_interp
)
8768 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8771 case DW_CFA_GNU_negative_offset_extended
:
8774 frame_need_space (fc
, reg
);
8775 if (! do_debug_frames_interp
)
8776 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8777 reg
, l
* fc
->data_factor
);
8778 fc
->col_type
[reg
] = DW_CFA_offset
;
8779 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8782 /* FIXME: How do we handle these? */
8783 case DW_CFA_def_cfa_expression
:
8784 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
8788 case DW_CFA_expression
:
8789 fprintf (stderr
, "unsupported DW_CFA_expression\n");
8794 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8799 if (do_debug_frames_interp
)
8800 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8815 display_debug_not_supported (section
, start
, file
)
8816 Elf32_Internal_Shdr
* section
;
8817 unsigned char * start ATTRIBUTE_UNUSED
;
8818 FILE * file ATTRIBUTE_UNUSED
;
8820 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8821 SECTION_NAME (section
));
8826 /* Pre-scan the .debug_info section to record the size of address.
8827 When dumping the .debug_line, we use that size information, assuming
8828 that all compilation units have the same address size. */
8830 prescan_debug_info (section
, start
, file
)
8831 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8832 unsigned char * start
;
8833 FILE * file ATTRIBUTE_UNUSED
;
8835 DWARF2_External_CompUnit
* external
;
8837 external
= (DWARF2_External_CompUnit
*) start
;
8839 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8843 /* A structure containing the name of a debug section and a pointer
8844 to a function that can decode it. The third field is a prescan
8845 function to be run over the section before displaying any of the
8849 const char * const name
;
8850 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8851 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8855 { ".debug_abbrev", display_debug_abbrev
, NULL
},
8856 { ".debug_aranges", display_debug_aranges
, NULL
},
8857 { ".debug_frame", display_debug_frames
, NULL
},
8858 { ".debug_info", display_debug_info
, prescan_debug_info
},
8859 { ".debug_line", display_debug_lines
, NULL
},
8860 { ".debug_pubnames", display_debug_pubnames
, NULL
},
8861 { ".eh_frame", display_debug_frames
, NULL
},
8862 { ".debug_macinfo", display_debug_macinfo
, NULL
},
8863 { ".debug_str", display_debug_str
, NULL
},
8864 { ".debug_loc", display_debug_loc
, NULL
},
8865 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
8866 { ".debug_ranges", display_debug_not_supported
, NULL
},
8867 { ".debug_static_func", display_debug_not_supported
, NULL
},
8868 { ".debug_static_vars", display_debug_not_supported
, NULL
},
8869 { ".debug_types", display_debug_not_supported
, NULL
},
8870 { ".debug_weaknames", display_debug_not_supported
, NULL
}
8874 display_debug_section (section
, file
)
8875 Elf32_Internal_Shdr
* section
;
8878 char * name
= SECTION_NAME (section
);
8879 bfd_size_type length
;
8880 unsigned char * start
;
8883 length
= section
->sh_size
;
8886 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8890 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
8891 _("debug section data"));
8895 /* See if we know how to display the contents of this section. */
8896 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
8897 name
= ".debug_info";
8899 for (i
= NUM_ELEM (debug_displays
); i
--;)
8900 if (strcmp (debug_displays
[i
].name
, name
) == 0)
8902 debug_displays
[i
].display (section
, start
, file
);
8907 printf (_("Unrecognized debug section: %s\n"), name
);
8911 /* If we loaded in the abbrev section at some point,
8912 we must release it here. */
8919 process_section_contents (file
)
8922 Elf32_Internal_Shdr
* section
;
8928 /* Pre-scan the debug sections to find some debug information not
8929 present in some of them. For the .debug_line, we must find out the
8930 size of address (specified in .debug_info and .debug_aranges). */
8931 for (i
= 0, section
= section_headers
;
8932 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8935 char * name
= SECTION_NAME (section
);
8938 if (section
->sh_size
== 0)
8941 /* See if there is some pre-scan operation for this section. */
8942 for (j
= NUM_ELEM (debug_displays
); j
--;)
8943 if (strcmp (debug_displays
[j
].name
, name
) == 0)
8945 if (debug_displays
[j
].prescan
!= NULL
)
8947 bfd_size_type length
;
8948 unsigned char * start
;
8950 length
= section
->sh_size
;
8951 start
= ((unsigned char *)
8952 get_data (NULL
, file
, section
->sh_offset
, length
,
8953 _("debug section data")));
8957 debug_displays
[j
].prescan (section
, start
, file
);
8965 for (i
= 0, section
= section_headers
;
8966 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8969 #ifdef SUPPORT_DISASSEMBLY
8970 if (dump_sects
[i
] & DISASS_DUMP
)
8971 disassemble_section (section
, file
);
8973 if (dump_sects
[i
] & HEX_DUMP
)
8974 dump_section (section
, file
);
8976 if (dump_sects
[i
] & DEBUG_DUMP
)
8977 display_debug_section (section
, file
);
8980 if (i
< num_dump_sects
)
8981 warn (_("Some sections were not dumped because they do not exist!\n"));
8987 process_mips_fpe_exception (mask
)
8993 if (mask
& OEX_FPU_INEX
)
8994 fputs ("INEX", stdout
), first
= 0;
8995 if (mask
& OEX_FPU_UFLO
)
8996 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8997 if (mask
& OEX_FPU_OFLO
)
8998 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8999 if (mask
& OEX_FPU_DIV0
)
9000 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9001 if (mask
& OEX_FPU_INVAL
)
9002 printf ("%sINVAL", first
? "" : "|");
9005 fputs ("0", stdout
);
9009 process_mips_specific (file
)
9012 Elf_Internal_Dyn
* entry
;
9013 size_t liblist_offset
= 0;
9014 size_t liblistno
= 0;
9015 size_t conflictsno
= 0;
9016 size_t options_offset
= 0;
9017 size_t conflicts_offset
= 0;
9019 /* We have a lot of special sections. Thanks SGI! */
9020 if (dynamic_segment
== NULL
)
9021 /* No information available. */
9024 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9025 switch (entry
->d_tag
)
9027 case DT_MIPS_LIBLIST
:
9028 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
9030 case DT_MIPS_LIBLISTNO
:
9031 liblistno
= entry
->d_un
.d_val
;
9033 case DT_MIPS_OPTIONS
:
9034 options_offset
= entry
->d_un
.d_val
- loadaddr
;
9036 case DT_MIPS_CONFLICT
:
9037 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
9039 case DT_MIPS_CONFLICTNO
:
9040 conflictsno
= entry
->d_un
.d_val
;
9046 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9048 Elf32_External_Lib
* elib
;
9051 elib
= ((Elf32_External_Lib
*)
9052 get_data (NULL
, file
, liblist_offset
,
9053 liblistno
* sizeof (Elf32_External_Lib
),
9057 printf ("\nSection '.liblist' contains %lu entries:\n",
9058 (unsigned long) liblistno
);
9059 fputs (" Library Time Stamp Checksum Version Flags\n",
9062 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9069 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9070 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9071 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9072 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9073 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9075 tmp
= gmtime (&time
);
9076 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9077 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9078 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9080 printf ("%3lu: ", (unsigned long) cnt
);
9081 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9082 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9085 if (liblist
.l_flags
== 0)
9096 { " EXACT_MATCH", LL_EXACT_MATCH
},
9097 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9098 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9099 { " EXPORTS", LL_EXPORTS
},
9100 { " DELAY_LOAD", LL_DELAY_LOAD
},
9101 { " DELTA", LL_DELTA
}
9103 int flags
= liblist
.l_flags
;
9107 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9109 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9111 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9112 flags
^= l_flags_vals
[fcnt
].bit
;
9115 printf (" %#x", (unsigned int) flags
);
9125 if (options_offset
!= 0)
9127 Elf_External_Options
* eopt
;
9128 Elf_Internal_Shdr
* sect
= section_headers
;
9129 Elf_Internal_Options
* iopt
;
9130 Elf_Internal_Options
* option
;
9134 /* Find the section header so that we get the size. */
9135 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9138 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9139 sect
->sh_size
, _("options"));
9142 iopt
= ((Elf_Internal_Options
*)
9143 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
9146 error (_("Out of memory"));
9153 while (offset
< sect
->sh_size
)
9155 Elf_External_Options
* eoption
;
9157 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9159 option
->kind
= BYTE_GET (eoption
->kind
);
9160 option
->size
= BYTE_GET (eoption
->size
);
9161 option
->section
= BYTE_GET (eoption
->section
);
9162 option
->info
= BYTE_GET (eoption
->info
);
9164 offset
+= option
->size
;
9170 printf (_("\nSection '%s' contains %d entries:\n"),
9171 SECTION_NAME (sect
), cnt
);
9179 switch (option
->kind
)
9182 /* This shouldn't happen. */
9183 printf (" NULL %d %lx", option
->section
, option
->info
);
9186 printf (" REGINFO ");
9187 if (elf_header
.e_machine
== EM_MIPS
)
9190 Elf32_External_RegInfo
* ereg
;
9191 Elf32_RegInfo reginfo
;
9193 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9194 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9195 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9196 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9197 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9198 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9199 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9201 printf ("GPR %08lx GP 0x%lx\n",
9203 (unsigned long) reginfo
.ri_gp_value
);
9204 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9205 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9206 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9211 Elf64_External_RegInfo
* ereg
;
9212 Elf64_Internal_RegInfo reginfo
;
9214 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9215 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9216 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9217 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9218 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9219 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9220 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9222 printf ("GPR %08lx GP 0x",
9223 reginfo
.ri_gprmask
);
9224 printf_vma (reginfo
.ri_gp_value
);
9227 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9228 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9229 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9233 case ODK_EXCEPTIONS
:
9234 fputs (" EXCEPTIONS fpe_min(", stdout
);
9235 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9236 fputs (") fpe_max(", stdout
);
9237 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9238 fputs (")", stdout
);
9240 if (option
->info
& OEX_PAGE0
)
9241 fputs (" PAGE0", stdout
);
9242 if (option
->info
& OEX_SMM
)
9243 fputs (" SMM", stdout
);
9244 if (option
->info
& OEX_FPDBUG
)
9245 fputs (" FPDBUG", stdout
);
9246 if (option
->info
& OEX_DISMISS
)
9247 fputs (" DISMISS", stdout
);
9250 fputs (" PAD ", stdout
);
9251 if (option
->info
& OPAD_PREFIX
)
9252 fputs (" PREFIX", stdout
);
9253 if (option
->info
& OPAD_POSTFIX
)
9254 fputs (" POSTFIX", stdout
);
9255 if (option
->info
& OPAD_SYMBOL
)
9256 fputs (" SYMBOL", stdout
);
9259 fputs (" HWPATCH ", stdout
);
9260 if (option
->info
& OHW_R4KEOP
)
9261 fputs (" R4KEOP", stdout
);
9262 if (option
->info
& OHW_R8KPFETCH
)
9263 fputs (" R8KPFETCH", stdout
);
9264 if (option
->info
& OHW_R5KEOP
)
9265 fputs (" R5KEOP", stdout
);
9266 if (option
->info
& OHW_R5KCVTL
)
9267 fputs (" R5KCVTL", stdout
);
9270 fputs (" FILL ", stdout
);
9271 /* XXX Print content of info word? */
9274 fputs (" TAGS ", stdout
);
9275 /* XXX Print content of info word? */
9278 fputs (" HWAND ", stdout
);
9279 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9280 fputs (" R4KEOP_CHECKED", stdout
);
9281 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9282 fputs (" R4KEOP_CLEAN", stdout
);
9285 fputs (" HWOR ", stdout
);
9286 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9287 fputs (" R4KEOP_CHECKED", stdout
);
9288 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9289 fputs (" R4KEOP_CLEAN", stdout
);
9292 printf (" GP_GROUP %#06lx self-contained %#06lx",
9293 option
->info
& OGP_GROUP
,
9294 (option
->info
& OGP_SELF
) >> 16);
9297 printf (" IDENT %#06lx self-contained %#06lx",
9298 option
->info
& OGP_GROUP
,
9299 (option
->info
& OGP_SELF
) >> 16);
9302 /* This shouldn't happen. */
9303 printf (" %3d ??? %d %lx",
9304 option
->kind
, option
->section
, option
->info
);
9308 len
= sizeof (* eopt
);
9309 while (len
< option
->size
)
9310 if (((char *) option
)[len
] >= ' '
9311 && ((char *) option
)[len
] < 0x7f)
9312 printf ("%c", ((char *) option
)[len
++]);
9314 printf ("\\%03o", ((char *) option
)[len
++]);
9316 fputs ("\n", stdout
);
9324 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9326 Elf32_Conflict
* iconf
;
9329 if (dynamic_symbols
== NULL
)
9331 error (_("conflict list found without a dynamic symbol table"));
9335 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
9338 error (_("Out of memory"));
9344 Elf32_External_Conflict
* econf32
;
9346 econf32
= ((Elf32_External_Conflict
*)
9347 get_data (NULL
, file
, conflicts_offset
,
9348 conflictsno
* sizeof (* econf32
),
9353 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9354 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9360 Elf64_External_Conflict
* econf64
;
9362 econf64
= ((Elf64_External_Conflict
*)
9363 get_data (NULL
, file
, conflicts_offset
,
9364 conflictsno
* sizeof (* econf64
),
9369 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9370 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9375 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9376 (long) conflictsno
);
9377 puts (_(" Num: Index Value Name"));
9379 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9381 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
9383 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9384 print_vma (psym
->st_value
, FULL_HEX
);
9386 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9397 process_gnu_liblist (file
)
9400 Elf_Internal_Shdr
* section
, * string_sec
;
9401 Elf32_External_Lib
* elib
;
9409 for (i
= 0, section
= section_headers
;
9410 i
< elf_header
.e_shnum
;
9413 switch (section
->sh_type
)
9415 case SHT_GNU_LIBLIST
:
9416 elib
= ((Elf32_External_Lib
*)
9417 get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9422 string_sec
= SECTION_HEADER (section
->sh_link
);
9424 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9425 string_sec
->sh_size
,
9426 _("liblist string table"));
9429 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9435 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9436 SECTION_NAME (section
),
9437 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9439 puts (" Library Time Stamp Checksum Version Flags");
9441 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9449 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9450 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9451 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9452 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9453 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9455 tmp
= gmtime (&time
);
9456 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9457 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9458 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9460 printf ("%3lu: ", (unsigned long) cnt
);
9462 printf ("%-20s", strtab
+ liblist
.l_name
);
9464 printf ("%-20.20s", strtab
+ liblist
.l_name
);
9465 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9466 liblist
.l_version
, liblist
.l_flags
);
9477 get_note_type (e_type
)
9480 static char buff
[64];
9484 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9485 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9486 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9487 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9488 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9489 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9490 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9491 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9492 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9493 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9494 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9496 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9502 get_netbsd_elfcore_note_type (e_type
)
9505 static char buff
[64];
9507 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9509 /* NetBSD core "procinfo" structure. */
9510 return _("NetBSD procinfo structure");
9513 /* As of Jan 2002 there are no other machine-independent notes
9514 defined for NetBSD core files. If the note type is less
9515 than the start of the machine-dependent note types, we don't
9518 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9520 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9524 switch (elf_header
.e_machine
)
9526 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9527 and PT_GETFPREGS == mach+2. */
9532 case EM_SPARC32PLUS
:
9536 case NT_NETBSDCORE_FIRSTMACH
+0:
9537 return _("PT_GETREGS (reg structure)");
9538 case NT_NETBSDCORE_FIRSTMACH
+2:
9539 return _("PT_GETFPREGS (fpreg structure)");
9545 /* On all other arch's, PT_GETREGS == mach+1 and
9546 PT_GETFPREGS == mach+3. */
9550 case NT_NETBSDCORE_FIRSTMACH
+1:
9551 return _("PT_GETREGS (reg structure)");
9552 case NT_NETBSDCORE_FIRSTMACH
+3:
9553 return _("PT_GETFPREGS (fpreg structure)");
9559 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9563 /* Note that by the ELF standard, the name field is already null byte
9564 terminated, and namesz includes the terminating null byte.
9565 I.E. the value of namesz for the name "FSF" is 4.
9567 If the value of namesz is zero, there is no name present. */
9569 process_note (pnote
)
9570 Elf32_Internal_Note
* pnote
;
9574 if (pnote
->namesz
== 0)
9576 /* If there is no note name, then use the default set of
9577 note type strings. */
9578 nt
= get_note_type (pnote
->type
);
9580 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9582 /* NetBSD-specific core file notes. */
9583 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9587 /* Don't recognize this note name; just use the default set of
9588 note type strings. */
9589 nt
= get_note_type (pnote
->type
);
9592 printf (" %s\t\t0x%08lx\t%s\n",
9593 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9600 process_corefile_note_segment (file
, offset
, length
)
9605 Elf_External_Note
* pnotes
;
9606 Elf_External_Note
* external
;
9612 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9619 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9620 (unsigned long) offset
, (unsigned long) length
);
9621 printf (_(" Owner\t\tData size\tDescription\n"));
9623 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9625 Elf_External_Note
* next
;
9626 Elf32_Internal_Note inote
;
9629 inote
.type
= BYTE_GET (external
->type
);
9630 inote
.namesz
= BYTE_GET (external
->namesz
);
9631 inote
.namedata
= external
->name
;
9632 inote
.descsz
= BYTE_GET (external
->descsz
);
9633 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9634 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9636 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9638 if (((char *) next
) > (((char *) pnotes
) + length
))
9640 warn (_("corrupt note found at offset %x into core notes\n"),
9641 ((char *) external
) - ((char *) pnotes
));
9642 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9643 inote
.type
, inote
.namesz
, inote
.descsz
);
9649 /* Verify that name is null terminated. It appears that at least
9650 one version of Linux (RedHat 6.0) generates corefiles that don't
9651 comply with the ELF spec by failing to include the null byte in
9653 if (inote
.namedata
[inote
.namesz
] != '\0')
9655 temp
= malloc (inote
.namesz
+ 1);
9659 error (_("Out of memory\n"));
9664 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9665 temp
[inote
.namesz
] = 0;
9667 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9668 inote
.namedata
= temp
;
9671 res
&= process_note (& inote
);
9686 process_corefile_note_segments (file
)
9689 Elf_Internal_Phdr
* program_headers
;
9690 Elf_Internal_Phdr
* segment
;
9694 program_headers
= (Elf_Internal_Phdr
*) malloc
9695 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9697 if (program_headers
== NULL
)
9699 error (_("Out of memory\n"));
9704 i
= get_32bit_program_headers (file
, program_headers
);
9706 i
= get_64bit_program_headers (file
, program_headers
);
9710 free (program_headers
);
9714 for (i
= 0, segment
= program_headers
;
9715 i
< elf_header
.e_phnum
;
9718 if (segment
->p_type
== PT_NOTE
)
9719 res
&= process_corefile_note_segment (file
,
9720 (bfd_vma
) segment
->p_offset
,
9721 (bfd_vma
) segment
->p_filesz
);
9724 free (program_headers
);
9730 process_corefile_contents (file
)
9733 /* If we have not been asked to display the notes then do nothing. */
9737 /* If file is not a core file then exit. */
9738 if (elf_header
.e_type
!= ET_CORE
)
9741 /* No program headers means no NOTE segment. */
9742 if (elf_header
.e_phnum
== 0)
9744 printf (_("No note segments present in the core file.\n"));
9748 return process_corefile_note_segments (file
);
9752 process_arch_specific (file
)
9758 switch (elf_header
.e_machine
)
9761 case EM_MIPS_RS3_LE
:
9762 return process_mips_specific (file
);
9771 get_file_header (file
)
9774 /* Read in the identity array. */
9775 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9778 /* Determine how to read the rest of the header. */
9779 switch (elf_header
.e_ident
[EI_DATA
])
9781 default: /* fall through */
9782 case ELFDATANONE
: /* fall through */
9783 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9784 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9787 /* For now we only support 32 bit and 64 bit ELF files. */
9788 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9790 /* Read in the rest of the header. */
9793 Elf32_External_Ehdr ehdr32
;
9795 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9798 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9799 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9800 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9801 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9802 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9803 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9804 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9805 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9806 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9807 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9808 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9809 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9810 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9814 Elf64_External_Ehdr ehdr64
;
9816 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9817 we will not be able to cope with the 64bit data found in
9818 64 ELF files. Detect this now and abort before we start
9819 overwritting things. */
9820 if (sizeof (bfd_vma
) < 8)
9822 error (_("This instance of readelf has been built without support for a\n\
9823 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9827 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9830 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9831 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9832 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9833 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9834 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9835 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9836 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9837 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9838 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9839 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9840 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9841 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9842 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9845 if (elf_header
.e_shoff
)
9847 /* There may be some extensions in the first section header. Don't
9848 bomb if we can't read it. */
9850 get_32bit_section_headers (file
, 1);
9852 get_64bit_section_headers (file
, 1);
9859 process_file (file_name
)
9863 struct stat statbuf
;
9866 if (stat (file_name
, & statbuf
) < 0)
9868 error (_("Cannot stat input file %s.\n"), file_name
);
9872 file
= fopen (file_name
, "rb");
9875 error (_("Input file %s not found.\n"), file_name
);
9879 if (! get_file_header (file
))
9881 error (_("%s: Failed to read file header\n"), file_name
);
9886 /* Initialise per file variables. */
9887 for (i
= NUM_ELEM (version_info
); i
--;)
9888 version_info
[i
] = 0;
9890 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9891 dynamic_info
[i
] = 0;
9893 /* Process the file. */
9895 printf (_("\nFile: %s\n"), file_name
);
9897 if (! process_file_header ())
9903 process_section_headers (file
);
9905 process_program_headers (file
);
9907 process_dynamic_segment (file
);
9909 process_relocs (file
);
9911 process_unwind (file
);
9913 process_symbol_table (file
);
9915 process_syminfo (file
);
9917 process_version_sections (file
);
9919 process_section_contents (file
);
9921 process_corefile_contents (file
);
9923 process_gnu_liblist (file
);
9925 process_arch_specific (file
);
9929 if (section_headers
)
9931 free (section_headers
);
9932 section_headers
= NULL
;
9937 free (string_table
);
9938 string_table
= NULL
;
9939 string_table_length
= 0;
9942 if (dynamic_strings
)
9944 free (dynamic_strings
);
9945 dynamic_strings
= NULL
;
9948 if (dynamic_symbols
)
9950 free (dynamic_symbols
);
9951 dynamic_symbols
= NULL
;
9952 num_dynamic_syms
= 0;
9955 if (dynamic_syminfo
)
9957 free (dynamic_syminfo
);
9958 dynamic_syminfo
= NULL
;
9964 #ifdef SUPPORT_DISASSEMBLY
9965 /* Needed by the i386 disassembler. For extra credit, someone could
9966 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9970 print_address (unsigned int addr
, FILE * outfile
)
9972 fprintf (outfile
,"0x%8.8x", addr
);
9975 /* Needed by the i386 disassembler. */
9977 db_task_printsym (unsigned int addr
)
9979 print_address (addr
, stderr
);
9983 int main
PARAMS ((int, char **));
9992 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9993 setlocale (LC_MESSAGES
, "");
9995 #if defined (HAVE_SETLOCALE)
9996 setlocale (LC_CTYPE
, "");
9998 bindtextdomain (PACKAGE
, LOCALEDIR
);
9999 textdomain (PACKAGE
);
10001 parse_args (argc
, argv
);
10003 if (optind
< (argc
- 1))
10007 while (optind
< argc
)
10008 err
|= process_file (argv
[optind
++]);
10010 if (dump_sects
!= NULL
)