1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 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 believe that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
52 #include "elf/alpha.h"
72 #include "elf/m68hc11.h"
73 #include "elf/mcore.h"
76 #include "elf/mn10200.h"
77 #include "elf/mn10300.h"
78 #include "elf/msp430.h"
84 #include "elf/sparc.h"
87 #include "elf/x86-64.h"
88 #include "elf/xstormy16.h"
89 #include "elf/iq2000.h"
94 char *program_name
= "readelf";
95 unsigned long dynamic_addr
;
96 bfd_size_type dynamic_size
;
97 char *dynamic_strings
;
99 unsigned long string_table_length
;
100 unsigned long num_dynamic_syms
;
101 Elf_Internal_Sym
*dynamic_symbols
;
102 Elf_Internal_Syminfo
*dynamic_syminfo
;
103 unsigned long dynamic_syminfo_offset
;
104 unsigned int dynamic_syminfo_nent
;
105 char program_interpreter
[64];
106 long dynamic_info
[DT_JMPREL
+ 1];
107 long version_info
[16];
109 Elf_Internal_Ehdr elf_header
;
110 Elf_Internal_Shdr
*section_headers
;
111 Elf_Internal_Dyn
*dynamic_segment
;
112 Elf_Internal_Shdr
*symtab_shndx_hdr
;
120 int do_using_dynamic
;
128 int do_debug_abbrevs
;
130 int do_debug_pubnames
;
131 int do_debug_aranges
;
133 int do_debug_frames_interp
;
134 int do_debug_macinfo
;
141 /* A dynamic array of flags indicating which sections require dumping. */
142 char *dump_sects
= NULL
;
143 unsigned int num_dump_sects
= 0;
145 #define HEX_DUMP (1 << 0)
146 #define DISASS_DUMP (1 << 1)
147 #define DEBUG_DUMP (1 << 2)
149 /* How to rpint a vma value. */
150 typedef enum print_mode
162 /* Forward declarations for dumb compilers. */
163 static void print_vma
164 PARAMS ((bfd_vma
, print_mode
));
165 static void print_symbol
166 PARAMS ((int, const char *));
167 static bfd_vma (*byte_get
)
168 PARAMS ((unsigned char *, int));
169 static bfd_vma byte_get_little_endian
170 PARAMS ((unsigned char *, int));
171 static bfd_vma byte_get_big_endian
172 PARAMS ((unsigned char *, int));
173 static const char *get_mips_dynamic_type
174 PARAMS ((unsigned long));
175 static const char *get_sparc64_dynamic_type
176 PARAMS ((unsigned long));
177 static const char *get_ppc64_dynamic_type
178 PARAMS ((unsigned long));
179 static const char *get_parisc_dynamic_type
180 PARAMS ((unsigned long));
181 static const char *get_dynamic_type
182 PARAMS ((unsigned long));
183 static int slurp_rela_relocs
184 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**,
186 static int slurp_rel_relocs
187 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**,
189 static int dump_relocations
190 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*,
191 unsigned long, char *, int));
192 static char *get_file_type
194 static char *get_machine_name
196 static void decode_ARM_machine_flags
197 PARAMS ((unsigned, char[]));
198 static char *get_machine_flags
199 PARAMS ((unsigned, unsigned));
200 static const char *get_mips_segment_type
201 PARAMS ((unsigned long));
202 static const char *get_parisc_segment_type
203 PARAMS ((unsigned long));
204 static const char *get_ia64_segment_type
205 PARAMS ((unsigned long));
206 static const char *get_segment_type
207 PARAMS ((unsigned long));
208 static const char *get_mips_section_type_name
209 PARAMS ((unsigned int));
210 static const char *get_parisc_section_type_name
211 PARAMS ((unsigned int));
212 static const char *get_ia64_section_type_name
213 PARAMS ((unsigned int));
214 static const char *get_section_type_name
215 PARAMS ((unsigned int));
216 static const char *get_symbol_binding
217 PARAMS ((unsigned int));
218 static const char *get_symbol_type
219 PARAMS ((unsigned int));
220 static const char *get_symbol_visibility
221 PARAMS ((unsigned int));
222 static const char *get_symbol_index_type
223 PARAMS ((unsigned int));
224 static const char *get_dynamic_flags
228 static void parse_args
229 PARAMS ((int, char **));
230 static int process_file_header
232 static int process_program_headers
234 static int process_section_headers
236 static int process_unwind
238 static void dynamic_segment_mips_val
239 PARAMS ((Elf_Internal_Dyn
*));
240 static void dynamic_segment_parisc_val
241 PARAMS ((Elf_Internal_Dyn
*));
242 static int process_dynamic_segment
244 static int process_symbol_table
246 static int process_syminfo
248 static int process_section_contents
250 static void process_mips_fpe_exception
252 static int process_mips_specific
254 static int process_file
256 static int process_relocs
258 static int process_version_sections
260 static char *get_ver_flags
261 PARAMS ((unsigned int));
262 static int get_32bit_section_headers
263 PARAMS ((FILE *, unsigned int));
264 static int get_64bit_section_headers
265 PARAMS ((FILE *, unsigned int));
266 static int get_32bit_program_headers
267 PARAMS ((FILE *, Elf_Internal_Phdr
*));
268 static int get_64bit_program_headers
269 PARAMS ((FILE *, Elf_Internal_Phdr
*));
270 static int get_file_header
272 static Elf_Internal_Sym
*get_32bit_elf_symbols
273 PARAMS ((FILE *, Elf_Internal_Shdr
*));
274 static Elf_Internal_Sym
*get_64bit_elf_symbols
275 PARAMS ((FILE *, Elf_Internal_Shdr
*));
276 static const char *get_elf_section_flags
278 static int *get_dynamic_data
279 PARAMS ((FILE *, unsigned int));
280 static int get_32bit_dynamic_segment
282 static int get_64bit_dynamic_segment
284 #ifdef SUPPORT_DISASSEMBLY
285 static int disassemble_section
286 PARAMS ((Elf_Internal_Shdr
*, FILE *));
288 static int dump_section
289 PARAMS ((Elf_Internal_Shdr
*, FILE *));
290 static int display_debug_section
291 PARAMS ((Elf_Internal_Shdr
*, FILE *));
292 static int display_debug_info
293 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
294 static int display_debug_not_supported
295 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
296 static int prescan_debug_info
297 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
298 static int display_debug_lines
299 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
300 static int display_debug_pubnames
301 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
302 static int display_debug_abbrev
303 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
304 static int display_debug_aranges
305 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
306 static int display_debug_frames
307 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
308 static int display_debug_macinfo
309 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
310 static int display_debug_str
311 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
312 static int display_debug_loc
313 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
314 static unsigned char *process_abbrev_section
315 PARAMS ((unsigned char *, unsigned char *));
316 static void load_debug_str
318 static void free_debug_str
320 static const char *fetch_indirect_string
321 PARAMS ((unsigned long));
322 static void load_debug_loc
324 static void free_debug_loc
326 static unsigned long read_leb128
327 PARAMS ((unsigned char *, int *, int));
328 static int process_extended_line_op
329 PARAMS ((unsigned char *, int, int));
330 static void reset_state_machine
332 static char *get_TAG_name
333 PARAMS ((unsigned long));
334 static char *get_AT_name
335 PARAMS ((unsigned long));
336 static char *get_FORM_name
337 PARAMS ((unsigned long));
338 static void free_abbrevs
340 static void add_abbrev
341 PARAMS ((unsigned long, unsigned long, int));
342 static void add_abbrev_attr
343 PARAMS ((unsigned long, unsigned long));
344 static unsigned char *read_and_display_attr
345 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
347 static unsigned char *read_and_display_attr_value
348 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
350 static unsigned char *display_block
351 PARAMS ((unsigned char *, unsigned long));
352 static void decode_location_expression
353 PARAMS ((unsigned char *, unsigned int, unsigned long));
354 static void request_dump
355 PARAMS ((unsigned int, int));
356 static const char *get_elf_class
357 PARAMS ((unsigned int));
358 static const char *get_data_encoding
359 PARAMS ((unsigned int));
360 static const char *get_osabi_name
361 PARAMS ((unsigned int));
362 static int guess_is_rela
363 PARAMS ((unsigned long));
364 static const char *get_note_type
365 PARAMS ((unsigned int));
366 static const char *get_netbsd_elfcore_note_type
367 PARAMS ((unsigned int));
368 static int process_note
369 PARAMS ((Elf_Internal_Note
*));
370 static int process_corefile_note_segment
371 PARAMS ((FILE *, bfd_vma
, bfd_vma
));
372 static int process_corefile_note_segments
374 static int process_corefile_contents
376 static int process_arch_specific
378 static int process_gnu_liblist
381 typedef int Elf32_Word
;
385 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
386 ((X)->sh_name >= string_table_length \
387 ? "<corrupt>" : string_table + (X)->sh_name))
389 /* Given st_shndx I, map to section_headers index. */
390 #define SECTION_HEADER_INDEX(I) \
391 ((I) < SHN_LORESERVE \
393 : ((I) <= SHN_HIRESERVE \
395 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
397 /* Reverse of the above. */
398 #define SECTION_HEADER_NUM(N) \
399 ((N) < SHN_LORESERVE \
401 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
403 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
405 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
407 #define BYTE_GET(field) byte_get (field, sizeof (field))
409 /* If we can support a 64 bit data type then BFD64 should be defined
410 and sizeof (bfd_vma) == 8. In this case when translating from an
411 external 8 byte field to an internal field, we can assume that the
412 internal field is also 8 bytes wide and so we can extract all the data.
413 If, however, BFD64 is not defined, then we must assume that the
414 internal data structure only has 4 byte wide fields that are the
415 equivalent of the 8 byte wide external counterparts, and so we must
416 truncate the data. */
418 #define BYTE_GET8(field) byte_get (field, -8)
420 #define BYTE_GET8(field) byte_get (field, 8)
423 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
425 #define GET_ELF_SYMBOLS(file, section) \
426 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
427 : get_64bit_elf_symbols (file, section))
431 error
VPARAMS ((const char *message
, ...))
433 VA_OPEN (args
, message
);
434 VA_FIXEDARG (args
, const char *, message
);
436 fprintf (stderr
, _("%s: Error: "), program_name
);
437 vfprintf (stderr
, message
, args
);
442 warn
VPARAMS ((const char *message
, ...))
444 VA_OPEN (args
, message
);
445 VA_FIXEDARG (args
, const char *, message
);
447 fprintf (stderr
, _("%s: Warning: "), program_name
);
448 vfprintf (stderr
, message
, args
);
452 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
455 get_data (var
, file
, offset
, size
, reason
)
467 if (fseek (file
, offset
, SEEK_SET
))
469 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
476 mvar
= (PTR
) malloc (size
);
480 error (_("Out of memory allocating %d bytes for %s\n"),
486 if (fread (mvar
, size
, 1, file
) != 1)
488 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
498 byte_get_little_endian (field
, size
)
499 unsigned char *field
;
508 return ((unsigned int) (field
[0]))
509 | (((unsigned int) (field
[1])) << 8);
513 /* We want to extract data from an 8 byte wide field and
514 place it into a 4 byte wide field. Since this is a little
515 endian source we can just use the 4 byte extraction code. */
519 return ((unsigned long) (field
[0]))
520 | (((unsigned long) (field
[1])) << 8)
521 | (((unsigned long) (field
[2])) << 16)
522 | (((unsigned long) (field
[3])) << 24);
527 /* This is a special case, generated by the BYTE_GET8 macro.
528 It means that we are loading an 8 byte value from a field
529 in an external structure into an 8 byte value in a field
530 in an internal strcuture. */
531 return ((bfd_vma
) (field
[0]))
532 | (((bfd_vma
) (field
[1])) << 8)
533 | (((bfd_vma
) (field
[2])) << 16)
534 | (((bfd_vma
) (field
[3])) << 24)
535 | (((bfd_vma
) (field
[4])) << 32)
536 | (((bfd_vma
) (field
[5])) << 40)
537 | (((bfd_vma
) (field
[6])) << 48)
538 | (((bfd_vma
) (field
[7])) << 56);
541 error (_("Unhandled data length: %d\n"), size
);
546 /* Print a VMA value. */
548 print_vma (vma
, mode
)
558 case FULL_HEX
: printf ("0x"); /* drop through */
559 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
560 case PREFIX_HEX
: printf ("0x"); /* drop through */
561 case HEX
: printf ("%lx", (unsigned long) vma
); break;
562 case DEC
: printf ("%ld", (unsigned long) vma
); break;
563 case DEC_5
: printf ("%5ld", (long) vma
); break;
564 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
585 #if BFD_HOST_64BIT_LONG
588 if (_bfd_int64_high (vma
))
589 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
591 printf ("%lx", _bfd_int64_low (vma
));
596 #if BFD_HOST_64BIT_LONG
599 if (_bfd_int64_high (vma
))
601 printf ("++%ld", _bfd_int64_low (vma
));
603 printf ("%ld", _bfd_int64_low (vma
));
608 #if BFD_HOST_64BIT_LONG
609 printf ("%5ld", vma
);
611 if (_bfd_int64_high (vma
))
613 printf ("++%ld", _bfd_int64_low (vma
));
615 printf ("%5ld", _bfd_int64_low (vma
));
620 #if BFD_HOST_64BIT_LONG
623 if (_bfd_int64_high (vma
))
625 printf ("++%lu", _bfd_int64_low (vma
));
627 printf ("%lu", _bfd_int64_low (vma
));
635 /* Display a symbol on stdout. If do_wide is not true then
636 format the symbol to be at most WIDTH characters,
637 truncating as necessary. If WIDTH is negative then
638 format the string to be exactly - WIDTH characters,
639 truncating or padding as necessary. */
642 print_symbol (width
, symbol
)
647 printf ("%s", symbol
);
649 printf ("%-*.*s", width
, width
, symbol
);
651 printf ("%-.*s", width
, symbol
);
655 byte_get_big_endian (field
, size
)
656 unsigned char *field
;
665 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
668 return ((unsigned long) (field
[3]))
669 | (((unsigned long) (field
[2])) << 8)
670 | (((unsigned long) (field
[1])) << 16)
671 | (((unsigned long) (field
[0])) << 24);
675 /* Although we are extracing data from an 8 byte wide field, we
676 are returning only 4 bytes of data. */
677 return ((unsigned long) (field
[7]))
678 | (((unsigned long) (field
[6])) << 8)
679 | (((unsigned long) (field
[5])) << 16)
680 | (((unsigned long) (field
[4])) << 24);
684 /* This is a special case, generated by the BYTE_GET8 macro.
685 It means that we are loading an 8 byte value from a field
686 in an external structure into an 8 byte value in a field
687 in an internal strcuture. */
688 return ((bfd_vma
) (field
[7]))
689 | (((bfd_vma
) (field
[6])) << 8)
690 | (((bfd_vma
) (field
[5])) << 16)
691 | (((bfd_vma
) (field
[4])) << 24)
692 | (((bfd_vma
) (field
[3])) << 32)
693 | (((bfd_vma
) (field
[2])) << 40)
694 | (((bfd_vma
) (field
[1])) << 48)
695 | (((bfd_vma
) (field
[0])) << 56);
699 error (_("Unhandled data length: %d\n"), size
);
704 /* Guess the relocation size commonly used by the specific machines. */
707 guess_is_rela (e_machine
)
708 unsigned long e_machine
;
712 /* Targets that use REL relocations. */
728 /* Targets that use RELA relocations. */
743 case EM_CYGNUS_MN10200
:
745 case EM_CYGNUS_MN10300
:
788 warn (_("Don't know about relocations on this machine architecture\n"));
794 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
796 unsigned long rel_offset
;
797 unsigned long rel_size
;
798 Elf_Internal_Rela
**relasp
;
799 unsigned long *nrelasp
;
801 Elf_Internal_Rela
*relas
;
802 unsigned long nrelas
;
807 Elf32_External_Rela
*erelas
;
809 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
810 rel_size
, _("relocs"));
814 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
816 relas
= (Elf_Internal_Rela
*)
817 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
821 error(_("out of memory parsing relocs"));
825 for (i
= 0; i
< nrelas
; i
++)
827 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
828 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
829 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
836 Elf64_External_Rela
*erelas
;
838 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
839 rel_size
, _("relocs"));
843 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
845 relas
= (Elf_Internal_Rela
*)
846 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
850 error(_("out of memory parsing relocs"));
854 for (i
= 0; i
< nrelas
; i
++)
856 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
857 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
858 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
869 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
871 unsigned long rel_offset
;
872 unsigned long rel_size
;
873 Elf_Internal_Rela
**relsp
;
874 unsigned long *nrelsp
;
876 Elf_Internal_Rela
*rels
;
882 Elf32_External_Rel
*erels
;
884 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
885 rel_size
, _("relocs"));
889 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
891 rels
= (Elf_Internal_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
895 error(_("out of memory parsing relocs"));
899 for (i
= 0; i
< nrels
; i
++)
901 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
902 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
903 rels
[i
].r_addend
= 0;
910 Elf64_External_Rel
*erels
;
912 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
913 rel_size
, _("relocs"));
917 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
919 rels
= (Elf_Internal_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
923 error(_("out of memory parsing relocs"));
927 for (i
= 0; i
< nrels
; i
++)
929 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
930 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
931 rels
[i
].r_addend
= 0;
941 /* Display the contents of the relocation data found at the specified offset. */
943 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
945 unsigned long rel_offset
;
946 unsigned long rel_size
;
947 Elf_Internal_Sym
*symtab
;
953 Elf_Internal_Rela
*rels
;
956 if (is_rela
== UNKNOWN
)
957 is_rela
= guess_is_rela (elf_header
.e_machine
);
961 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
966 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
975 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
977 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
982 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
984 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
992 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
994 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
999 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1001 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1005 for (i
= 0; i
< rel_size
; i
++)
1008 const char *rtype2
= NULL
;
1009 const char *rtype3
= NULL
;
1012 bfd_vma symtab_index
;
1014 bfd_vma type2
= (bfd_vma
) NULL
;
1015 bfd_vma type3
= (bfd_vma
) NULL
;
1017 offset
= rels
[i
].r_offset
;
1018 info
= rels
[i
].r_info
;
1022 type
= ELF32_R_TYPE (info
);
1023 symtab_index
= ELF32_R_SYM (info
);
1027 if (elf_header
.e_machine
== EM_MIPS
)
1029 type
= ELF64_MIPS_R_TYPE (info
);
1030 type2
= ELF64_MIPS_R_TYPE2 (info
);
1031 type3
= ELF64_MIPS_R_TYPE3 (info
);
1033 else if (elf_header
.e_machine
== EM_SPARCV9
)
1034 type
= ELF64_R_TYPE_ID (info
);
1036 type
= ELF64_R_TYPE (info
);
1037 /* The #ifdef BFD64 below is to prevent a compile time warning.
1038 We know that if we do not have a 64 bit data type that we
1039 will never execute this code anyway. */
1041 symtab_index
= ELF64_R_SYM (info
);
1047 #ifdef _bfd_int64_low
1048 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1050 printf ("%8.8lx %8.8lx ", offset
, info
);
1055 #ifdef _bfd_int64_low
1057 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1058 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1059 _bfd_int64_high (offset
),
1060 _bfd_int64_low (offset
),
1061 _bfd_int64_high (info
),
1062 _bfd_int64_low (info
));
1065 ? "%16.16lx %16.16lx "
1066 : "%12.12lx %12.12lx ",
1071 switch (elf_header
.e_machine
)
1078 case EM_CYGNUS_M32R
:
1079 rtype
= elf_m32r_reloc_type (type
);
1084 rtype
= elf_i386_reloc_type (type
);
1089 rtype
= elf_m68hc11_reloc_type (type
);
1093 rtype
= elf_m68k_reloc_type (type
);
1097 rtype
= elf_i960_reloc_type (type
);
1102 rtype
= elf_avr_reloc_type (type
);
1105 case EM_OLD_SPARCV9
:
1106 case EM_SPARC32PLUS
:
1109 rtype
= elf_sparc_reloc_type (type
);
1113 case EM_CYGNUS_V850
:
1114 rtype
= v850_reloc_type (type
);
1118 case EM_CYGNUS_D10V
:
1119 rtype
= elf_d10v_reloc_type (type
);
1123 case EM_CYGNUS_D30V
:
1124 rtype
= elf_d30v_reloc_type (type
);
1128 rtype
= elf_dlx_reloc_type (type
);
1132 rtype
= elf_sh_reloc_type (type
);
1136 case EM_CYGNUS_MN10300
:
1137 rtype
= elf_mn10300_reloc_type (type
);
1141 case EM_CYGNUS_MN10200
:
1142 rtype
= elf_mn10200_reloc_type (type
);
1146 case EM_CYGNUS_FR30
:
1147 rtype
= elf_fr30_reloc_type (type
);
1151 rtype
= elf_frv_reloc_type (type
);
1155 rtype
= elf_mcore_reloc_type (type
);
1159 rtype
= elf_mmix_reloc_type (type
);
1164 rtype
= elf_msp430_reloc_type (type
);
1169 rtype
= elf_ppc_reloc_type (type
);
1173 case EM_MIPS_RS3_LE
:
1174 rtype
= elf_mips_reloc_type (type
);
1177 rtype2
= elf_mips_reloc_type (type2
);
1178 rtype3
= elf_mips_reloc_type (type3
);
1183 rtype
= elf_alpha_reloc_type (type
);
1187 rtype
= elf_arm_reloc_type (type
);
1191 rtype
= elf_arc_reloc_type (type
);
1195 rtype
= elf_hppa_reloc_type (type
);
1201 rtype
= elf_h8_reloc_type (type
);
1206 rtype
= elf_or32_reloc_type (type
);
1211 rtype
= elf_pj_reloc_type (type
);
1214 rtype
= elf_ia64_reloc_type (type
);
1218 rtype
= elf_cris_reloc_type (type
);
1222 rtype
= elf_i860_reloc_type (type
);
1226 rtype
= elf_x86_64_reloc_type (type
);
1230 rtype
= i370_reloc_type (type
);
1235 rtype
= elf_s390_reloc_type (type
);
1239 rtype
= elf_xstormy16_reloc_type (type
);
1243 rtype
= elf_vax_reloc_type (type
);
1248 rtype
= elf_ip2k_reloc_type (type
);
1252 rtype
= elf_iq2000_reloc_type (type
);
1257 #ifdef _bfd_int64_low
1258 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1260 printf (_("unrecognized: %-7lx"), type
);
1263 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1267 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1268 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1271 Elf_Internal_Sym
*psym
;
1273 psym
= symtab
+ symtab_index
;
1276 print_vma (psym
->st_value
, LONG_HEX
);
1277 printf (is_32bit_elf
? " " : " ");
1279 if (psym
->st_name
== 0)
1281 const char *sec_name
= "<null>";
1284 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1286 bfd_vma sec_index
= (bfd_vma
) -1;
1288 if (psym
->st_shndx
< SHN_LORESERVE
)
1289 sec_index
= psym
->st_shndx
;
1290 else if (psym
->st_shndx
> SHN_LORESERVE
)
1291 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1294 if (sec_index
!= (bfd_vma
) -1)
1295 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1296 else if (psym
->st_shndx
== SHN_ABS
)
1298 else if (psym
->st_shndx
== SHN_COMMON
)
1299 sec_name
= "COMMON";
1302 sprintf (name_buf
, "<section 0x%x>",
1303 (unsigned int) psym
->st_shndx
);
1304 sec_name
= name_buf
;
1307 print_symbol (22, sec_name
);
1309 else if (strtab
== NULL
)
1310 printf (_("<string table index %3ld>"), psym
->st_name
);
1312 print_symbol (22, strtab
+ psym
->st_name
);
1315 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1320 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1321 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1324 if (elf_header
.e_machine
== EM_SPARCV9
1325 && !strcmp (rtype
, "R_SPARC_OLO10"))
1326 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1330 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1332 printf (" Type2: ");
1335 #ifdef _bfd_int64_low
1336 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1338 printf (_("unrecognized: %-7lx"), type2
);
1341 printf ("%-17.17s", rtype2
);
1343 printf("\n Type3: ");
1346 #ifdef _bfd_int64_low
1347 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1349 printf (_("unrecognized: %-7lx"), type3
);
1352 printf ("%-17.17s", rtype3
);
1364 get_mips_dynamic_type (type
)
1369 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1370 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1371 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1372 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1373 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1374 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1375 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1376 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1377 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1378 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1379 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1380 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1381 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1382 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1383 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1384 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1385 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1386 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1387 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1388 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1389 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1390 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1391 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1392 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1393 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1394 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1395 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1396 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1397 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1398 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1399 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1400 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1401 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1402 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1403 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1404 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1405 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1406 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1407 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1408 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1409 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1410 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1411 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1418 get_sparc64_dynamic_type (type
)
1423 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1430 get_ppc64_dynamic_type (type
)
1435 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1436 case DT_PPC64_OPD
: return "PPC64_OPD";
1437 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1444 get_parisc_dynamic_type (type
)
1449 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1450 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1451 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1452 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1453 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1454 case DT_HP_PREINIT
: return "HP_PREINIT";
1455 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1456 case DT_HP_NEEDED
: return "HP_NEEDED";
1457 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1458 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1459 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1460 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1461 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1468 get_dynamic_type (type
)
1471 static char buff
[32];
1475 case DT_NULL
: return "NULL";
1476 case DT_NEEDED
: return "NEEDED";
1477 case DT_PLTRELSZ
: return "PLTRELSZ";
1478 case DT_PLTGOT
: return "PLTGOT";
1479 case DT_HASH
: return "HASH";
1480 case DT_STRTAB
: return "STRTAB";
1481 case DT_SYMTAB
: return "SYMTAB";
1482 case DT_RELA
: return "RELA";
1483 case DT_RELASZ
: return "RELASZ";
1484 case DT_RELAENT
: return "RELAENT";
1485 case DT_STRSZ
: return "STRSZ";
1486 case DT_SYMENT
: return "SYMENT";
1487 case DT_INIT
: return "INIT";
1488 case DT_FINI
: return "FINI";
1489 case DT_SONAME
: return "SONAME";
1490 case DT_RPATH
: return "RPATH";
1491 case DT_SYMBOLIC
: return "SYMBOLIC";
1492 case DT_REL
: return "REL";
1493 case DT_RELSZ
: return "RELSZ";
1494 case DT_RELENT
: return "RELENT";
1495 case DT_PLTREL
: return "PLTREL";
1496 case DT_DEBUG
: return "DEBUG";
1497 case DT_TEXTREL
: return "TEXTREL";
1498 case DT_JMPREL
: return "JMPREL";
1499 case DT_BIND_NOW
: return "BIND_NOW";
1500 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1501 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1502 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1503 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1504 case DT_RUNPATH
: return "RUNPATH";
1505 case DT_FLAGS
: return "FLAGS";
1507 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1508 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1510 case DT_CHECKSUM
: return "CHECKSUM";
1511 case DT_PLTPADSZ
: return "PLTPADSZ";
1512 case DT_MOVEENT
: return "MOVEENT";
1513 case DT_MOVESZ
: return "MOVESZ";
1514 case DT_FEATURE
: return "FEATURE";
1515 case DT_POSFLAG_1
: return "POSFLAG_1";
1516 case DT_SYMINSZ
: return "SYMINSZ";
1517 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1519 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1520 case DT_CONFIG
: return "CONFIG";
1521 case DT_DEPAUDIT
: return "DEPAUDIT";
1522 case DT_AUDIT
: return "AUDIT";
1523 case DT_PLTPAD
: return "PLTPAD";
1524 case DT_MOVETAB
: return "MOVETAB";
1525 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1527 case DT_VERSYM
: return "VERSYM";
1529 case DT_RELACOUNT
: return "RELACOUNT";
1530 case DT_RELCOUNT
: return "RELCOUNT";
1531 case DT_FLAGS_1
: return "FLAGS_1";
1532 case DT_VERDEF
: return "VERDEF";
1533 case DT_VERDEFNUM
: return "VERDEFNUM";
1534 case DT_VERNEED
: return "VERNEED";
1535 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1537 case DT_AUXILIARY
: return "AUXILIARY";
1538 case DT_USED
: return "USED";
1539 case DT_FILTER
: return "FILTER";
1541 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1542 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1543 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1544 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1545 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1548 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1552 switch (elf_header
.e_machine
)
1555 case EM_MIPS_RS3_LE
:
1556 result
= get_mips_dynamic_type (type
);
1559 result
= get_sparc64_dynamic_type (type
);
1562 result
= get_ppc64_dynamic_type (type
);
1572 sprintf (buff
, _("Processor Specific: %lx"), type
);
1574 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1578 switch (elf_header
.e_machine
)
1581 result
= get_parisc_dynamic_type (type
);
1591 sprintf (buff
, _("Operating System specific: %lx"), type
);
1594 sprintf (buff
, _("<unknown>: %lx"), type
);
1601 get_file_type (e_type
)
1604 static char buff
[32];
1608 case ET_NONE
: return _("NONE (None)");
1609 case ET_REL
: return _("REL (Relocatable file)");
1610 case ET_EXEC
: return _("EXEC (Executable file)");
1611 case ET_DYN
: return _("DYN (Shared object file)");
1612 case ET_CORE
: return _("CORE (Core file)");
1615 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1616 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1617 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1618 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1620 sprintf (buff
, _("<unknown>: %x"), e_type
);
1626 get_machine_name (e_machine
)
1629 static char buff
[64]; /* XXX */
1633 case EM_NONE
: return _("None");
1634 case EM_M32
: return "WE32100";
1635 case EM_SPARC
: return "Sparc";
1636 case EM_386
: return "Intel 80386";
1637 case EM_68K
: return "MC68000";
1638 case EM_88K
: return "MC88000";
1639 case EM_486
: return "Intel 80486";
1640 case EM_860
: return "Intel 80860";
1641 case EM_MIPS
: return "MIPS R3000";
1642 case EM_S370
: return "IBM System/370";
1643 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1644 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1645 case EM_PARISC
: return "HPPA";
1646 case EM_PPC_OLD
: return "Power PC (old)";
1647 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1648 case EM_960
: return "Intel 90860";
1649 case EM_PPC
: return "PowerPC";
1650 case EM_PPC64
: return "PowerPC64";
1651 case EM_V800
: return "NEC V800";
1652 case EM_FR20
: return "Fujitsu FR20";
1653 case EM_RH32
: return "TRW RH32";
1654 case EM_MCORE
: return "MCORE";
1655 case EM_ARM
: return "ARM";
1656 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1657 case EM_SH
: return "Hitachi SH";
1658 case EM_SPARCV9
: return "Sparc v9";
1659 case EM_TRICORE
: return "Siemens Tricore";
1660 case EM_ARC
: return "ARC";
1661 case EM_H8_300
: return "Hitachi H8/300";
1662 case EM_H8_300H
: return "Hitachi H8/300H";
1663 case EM_H8S
: return "Hitachi H8S";
1664 case EM_H8_500
: return "Hitachi H8/500";
1665 case EM_IA_64
: return "Intel IA-64";
1666 case EM_MIPS_X
: return "Stanford MIPS-X";
1667 case EM_COLDFIRE
: return "Motorola Coldfire";
1668 case EM_68HC12
: return "Motorola M68HC12";
1669 case EM_ALPHA
: return "Alpha";
1670 case EM_CYGNUS_D10V
:
1671 case EM_D10V
: return "d10v";
1672 case EM_CYGNUS_D30V
:
1673 case EM_D30V
: return "d30v";
1674 case EM_CYGNUS_M32R
:
1675 case EM_M32R
: return "Mitsubishi M32r";
1676 case EM_CYGNUS_V850
:
1677 case EM_V850
: return "NEC v850";
1678 case EM_CYGNUS_MN10300
:
1679 case EM_MN10300
: return "mn10300";
1680 case EM_CYGNUS_MN10200
:
1681 case EM_MN10200
: return "mn10200";
1682 case EM_CYGNUS_FR30
:
1683 case EM_FR30
: return "Fujitsu FR30";
1684 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1686 case EM_PJ
: return "picoJava";
1687 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1688 case EM_PCP
: return "Siemens PCP";
1689 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1690 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1691 case EM_STARCORE
: return "Motorola Star*Core processor";
1692 case EM_ME16
: return "Toyota ME16 processor";
1693 case EM_ST100
: return "STMicroelectronics ST100 processor";
1694 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1695 case EM_FX66
: return "Siemens FX66 microcontroller";
1696 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1697 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1698 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1699 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1700 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1701 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1702 case EM_SVX
: return "Silicon Graphics SVx";
1703 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1704 case EM_VAX
: return "Digital VAX";
1706 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1707 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1708 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1709 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1710 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1711 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1712 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1713 case EM_PRISM
: return "Vitesse Prism";
1714 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1716 case EM_S390
: return "IBM S/390";
1717 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1719 case EM_OR32
: return "OpenRISC";
1720 case EM_DLX
: return "OpenDLX";
1722 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1723 case EM_IQ2000
: return "Vitesse IQ2000";
1725 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1731 decode_ARM_machine_flags (e_flags
, buf
)
1738 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1739 e_flags
&= ~ EF_ARM_EABIMASK
;
1741 /* Handle "generic" ARM flags. */
1742 if (e_flags
& EF_ARM_RELEXEC
)
1744 strcat (buf
, ", relocatable executable");
1745 e_flags
&= ~ EF_ARM_RELEXEC
;
1748 if (e_flags
& EF_ARM_HASENTRY
)
1750 strcat (buf
, ", has entry point");
1751 e_flags
&= ~ EF_ARM_HASENTRY
;
1754 /* Now handle EABI specific flags. */
1758 strcat (buf
, ", <unrecognized EABI>");
1763 case EF_ARM_EABI_VER1
:
1764 strcat (buf
, ", Version1 EABI");
1769 /* Process flags one bit at a time. */
1770 flag
= e_flags
& - e_flags
;
1775 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1776 strcat (buf
, ", sorted symbol tables");
1786 case EF_ARM_EABI_VER2
:
1787 strcat (buf
, ", Version2 EABI");
1792 /* Process flags one bit at a time. */
1793 flag
= e_flags
& - e_flags
;
1798 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1799 strcat (buf
, ", sorted symbol tables");
1802 case EF_ARM_DYNSYMSUSESEGIDX
:
1803 strcat (buf
, ", dynamic symbols use segment index");
1806 case EF_ARM_MAPSYMSFIRST
:
1807 strcat (buf
, ", mapping symbols precede others");
1817 case EF_ARM_EABI_UNKNOWN
:
1818 strcat (buf
, ", GNU EABI");
1823 /* Process flags one bit at a time. */
1824 flag
= e_flags
& - e_flags
;
1829 case EF_ARM_INTERWORK
:
1830 strcat (buf
, ", interworking enabled");
1833 case EF_ARM_APCS_26
:
1834 strcat (buf
, ", uses APCS/26");
1837 case EF_ARM_APCS_FLOAT
:
1838 strcat (buf
, ", uses APCS/float");
1842 strcat (buf
, ", position independent");
1846 strcat (buf
, ", 8 bit structure alignment");
1849 case EF_ARM_NEW_ABI
:
1850 strcat (buf
, ", uses new ABI");
1853 case EF_ARM_OLD_ABI
:
1854 strcat (buf
, ", uses old ABI");
1857 case EF_ARM_SOFT_FLOAT
:
1858 strcat (buf
, ", software FP");
1869 strcat (buf
,", <unknown>");
1873 get_machine_flags (e_flags
, e_machine
)
1877 static char buf
[1024];
1889 decode_ARM_machine_flags (e_flags
, buf
);
1893 if (e_flags
& EF_CPU32
)
1894 strcat (buf
, ", cpu32");
1895 if (e_flags
& EF_M68000
)
1896 strcat (buf
, ", m68000");
1900 if (e_flags
& EF_PPC_EMB
)
1901 strcat (buf
, ", emb");
1903 if (e_flags
& EF_PPC_RELOCATABLE
)
1904 strcat (buf
, ", relocatable");
1906 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1907 strcat (buf
, ", relocatable-lib");
1911 case EM_CYGNUS_V850
:
1912 switch (e_flags
& EF_V850_ARCH
)
1915 strcat (buf
, ", v850e");
1918 strcat (buf
, ", v850");
1921 strcat (buf
, ", unknown v850 architecture variant");
1927 case EM_CYGNUS_M32R
:
1928 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1929 strcat (buf
, ", m32r");
1934 case EM_MIPS_RS3_LE
:
1935 if (e_flags
& EF_MIPS_NOREORDER
)
1936 strcat (buf
, ", noreorder");
1938 if (e_flags
& EF_MIPS_PIC
)
1939 strcat (buf
, ", pic");
1941 if (e_flags
& EF_MIPS_CPIC
)
1942 strcat (buf
, ", cpic");
1944 if (e_flags
& EF_MIPS_UCODE
)
1945 strcat (buf
, ", ugen_reserved");
1947 if (e_flags
& EF_MIPS_ABI2
)
1948 strcat (buf
, ", abi2");
1950 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1951 strcat (buf
, ", odk first");
1953 if (e_flags
& EF_MIPS_32BITMODE
)
1954 strcat (buf
, ", 32bitmode");
1956 switch ((e_flags
& EF_MIPS_MACH
))
1958 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1959 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1960 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1961 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1962 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1963 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1964 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1965 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1966 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1968 /* We simply ignore the field in this case to avoid confusion:
1969 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1972 default: strcat (buf
, ", unknown CPU"); break;
1975 switch ((e_flags
& EF_MIPS_ABI
))
1977 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1978 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1979 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1980 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1982 /* We simply ignore the field in this case to avoid confusion:
1983 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1984 This means it is likely to be an o32 file, but not for
1987 default: strcat (buf
, ", unknown ABI"); break;
1990 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1991 strcat (buf
, ", mdmx");
1993 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1994 strcat (buf
, ", mips16");
1996 switch ((e_flags
& EF_MIPS_ARCH
))
1998 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1999 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2000 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2001 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2002 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2003 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2004 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2005 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2006 default: strcat (buf
, ", unknown ISA"); break;
2012 if (e_flags
& EF_SPARC_32PLUS
)
2013 strcat (buf
, ", v8+");
2015 if (e_flags
& EF_SPARC_SUN_US1
)
2016 strcat (buf
, ", ultrasparcI");
2018 if (e_flags
& EF_SPARC_SUN_US3
)
2019 strcat (buf
, ", ultrasparcIII");
2021 if (e_flags
& EF_SPARC_HAL_R1
)
2022 strcat (buf
, ", halr1");
2024 if (e_flags
& EF_SPARC_LEDATA
)
2025 strcat (buf
, ", ledata");
2027 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2028 strcat (buf
, ", tso");
2030 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2031 strcat (buf
, ", pso");
2033 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2034 strcat (buf
, ", rmo");
2038 switch (e_flags
& EF_PARISC_ARCH
)
2040 case EFA_PARISC_1_0
:
2041 strcpy (buf
, ", PA-RISC 1.0");
2043 case EFA_PARISC_1_1
:
2044 strcpy (buf
, ", PA-RISC 1.1");
2046 case EFA_PARISC_2_0
:
2047 strcpy (buf
, ", PA-RISC 2.0");
2052 if (e_flags
& EF_PARISC_TRAPNIL
)
2053 strcat (buf
, ", trapnil");
2054 if (e_flags
& EF_PARISC_EXT
)
2055 strcat (buf
, ", ext");
2056 if (e_flags
& EF_PARISC_LSB
)
2057 strcat (buf
, ", lsb");
2058 if (e_flags
& EF_PARISC_WIDE
)
2059 strcat (buf
, ", wide");
2060 if (e_flags
& EF_PARISC_NO_KABP
)
2061 strcat (buf
, ", no kabp");
2062 if (e_flags
& EF_PARISC_LAZYSWAP
)
2063 strcat (buf
, ", lazyswap");
2068 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2069 strcat (buf
, ", new calling convention");
2071 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2072 strcat (buf
, ", gnu calling convention");
2076 if ((e_flags
& EF_IA_64_ABI64
))
2077 strcat (buf
, ", 64-bit");
2079 strcat (buf
, ", 32-bit");
2080 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2081 strcat (buf
, ", reduced fp model");
2082 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2083 strcat (buf
, ", no function descriptors, constant gp");
2084 else if ((e_flags
& EF_IA_64_CONS_GP
))
2085 strcat (buf
, ", constant gp");
2086 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2087 strcat (buf
, ", absolute");
2091 if ((e_flags
& EF_VAX_NONPIC
))
2092 strcat (buf
, ", non-PIC");
2093 if ((e_flags
& EF_VAX_DFLOAT
))
2094 strcat (buf
, ", D-Float");
2095 if ((e_flags
& EF_VAX_GFLOAT
))
2096 strcat (buf
, ", G-Float");
2105 get_mips_segment_type (type
)
2110 case PT_MIPS_REGINFO
:
2112 case PT_MIPS_RTPROC
:
2114 case PT_MIPS_OPTIONS
:
2124 get_parisc_segment_type (type
)
2129 case PT_HP_TLS
: return "HP_TLS";
2130 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2131 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2132 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2133 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2134 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2135 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2136 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2137 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2138 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2139 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2140 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2141 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2142 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2151 get_ia64_segment_type (type
)
2156 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2157 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2158 case PT_HP_TLS
: return "HP_TLS";
2159 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2160 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2161 case PT_IA_64_HP_STACK
: return "HP_STACK";
2170 get_segment_type (p_type
)
2171 unsigned long p_type
;
2173 static char buff
[32];
2177 case PT_NULL
: return "NULL";
2178 case PT_LOAD
: return "LOAD";
2179 case PT_DYNAMIC
: return "DYNAMIC";
2180 case PT_INTERP
: return "INTERP";
2181 case PT_NOTE
: return "NOTE";
2182 case PT_SHLIB
: return "SHLIB";
2183 case PT_PHDR
: return "PHDR";
2184 case PT_TLS
: return "TLS";
2186 case PT_GNU_EH_FRAME
:
2187 return "GNU_EH_FRAME";
2190 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2194 switch (elf_header
.e_machine
)
2197 case EM_MIPS_RS3_LE
:
2198 result
= get_mips_segment_type (p_type
);
2201 result
= get_parisc_segment_type (p_type
);
2204 result
= get_ia64_segment_type (p_type
);
2214 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2216 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2220 switch (elf_header
.e_machine
)
2223 result
= get_parisc_segment_type (p_type
);
2226 result
= get_ia64_segment_type (p_type
);
2236 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2239 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2246 get_mips_section_type_name (sh_type
)
2247 unsigned int sh_type
;
2251 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2252 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2253 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2254 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2255 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2256 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2257 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2258 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2259 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2260 case SHT_MIPS_RELD
: return "MIPS_RELD";
2261 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2262 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2263 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2264 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2265 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2266 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2267 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2268 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2269 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2270 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2271 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2272 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2273 case SHT_MIPS_LINE
: return "MIPS_LINE";
2274 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2275 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2276 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2277 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2278 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2279 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2280 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2281 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2282 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2283 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2284 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2285 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2286 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2287 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2288 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2289 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2297 get_parisc_section_type_name (sh_type
)
2298 unsigned int sh_type
;
2302 case SHT_PARISC_EXT
: return "PARISC_EXT";
2303 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2304 case SHT_PARISC_DOC
: return "PARISC_DOC";
2312 get_ia64_section_type_name (sh_type
)
2313 unsigned int sh_type
;
2317 case SHT_IA_64_EXT
: return "IA_64_EXT";
2318 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2326 get_section_type_name (sh_type
)
2327 unsigned int sh_type
;
2329 static char buff
[32];
2333 case SHT_NULL
: return "NULL";
2334 case SHT_PROGBITS
: return "PROGBITS";
2335 case SHT_SYMTAB
: return "SYMTAB";
2336 case SHT_STRTAB
: return "STRTAB";
2337 case SHT_RELA
: return "RELA";
2338 case SHT_HASH
: return "HASH";
2339 case SHT_DYNAMIC
: return "DYNAMIC";
2340 case SHT_NOTE
: return "NOTE";
2341 case SHT_NOBITS
: return "NOBITS";
2342 case SHT_REL
: return "REL";
2343 case SHT_SHLIB
: return "SHLIB";
2344 case SHT_DYNSYM
: return "DYNSYM";
2345 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2346 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2347 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2348 case SHT_GROUP
: return "GROUP";
2349 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2350 case SHT_GNU_verdef
: return "VERDEF";
2351 case SHT_GNU_verneed
: return "VERNEED";
2352 case SHT_GNU_versym
: return "VERSYM";
2353 case 0x6ffffff0: return "VERSYM";
2354 case 0x6ffffffc: return "VERDEF";
2355 case 0x7ffffffd: return "AUXILIARY";
2356 case 0x7fffffff: return "FILTER";
2357 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2360 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2364 switch (elf_header
.e_machine
)
2367 case EM_MIPS_RS3_LE
:
2368 result
= get_mips_section_type_name (sh_type
);
2371 result
= get_parisc_section_type_name (sh_type
);
2374 result
= get_ia64_section_type_name (sh_type
);
2384 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2386 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2387 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2388 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2389 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2391 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2397 #define OPTION_DEBUG_DUMP 512
2399 struct option options
[] =
2401 {"all", no_argument
, 0, 'a'},
2402 {"file-header", no_argument
, 0, 'h'},
2403 {"program-headers", no_argument
, 0, 'l'},
2404 {"headers", no_argument
, 0, 'e'},
2405 {"histogram", no_argument
, 0, 'I'},
2406 {"segments", no_argument
, 0, 'l'},
2407 {"sections", no_argument
, 0, 'S'},
2408 {"section-headers", no_argument
, 0, 'S'},
2409 {"symbols", no_argument
, 0, 's'},
2410 {"syms", no_argument
, 0, 's'},
2411 {"relocs", no_argument
, 0, 'r'},
2412 {"notes", no_argument
, 0, 'n'},
2413 {"dynamic", no_argument
, 0, 'd'},
2414 {"arch-specific", no_argument
, 0, 'A'},
2415 {"version-info", no_argument
, 0, 'V'},
2416 {"use-dynamic", no_argument
, 0, 'D'},
2417 {"hex-dump", required_argument
, 0, 'x'},
2418 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2419 {"unwind", no_argument
, 0, 'u'},
2420 #ifdef SUPPORT_DISASSEMBLY
2421 {"instruction-dump", required_argument
, 0, 'i'},
2424 {"version", no_argument
, 0, 'v'},
2425 {"wide", no_argument
, 0, 'W'},
2426 {"help", no_argument
, 0, 'H'},
2427 {0, no_argument
, 0, 0}
2433 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2434 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2435 fprintf (stdout
, _(" Options are:\n\
2436 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2437 -h --file-header Display the ELF file header\n\
2438 -l --program-headers Display the program headers\n\
2439 --segments An alias for --program-headers\n\
2440 -S --section-headers Display the sections' header\n\
2441 --sections An alias for --section-headers\n\
2442 -e --headers Equivalent to: -h -l -S\n\
2443 -s --syms Display the symbol table\n\
2444 --symbols An alias for --syms\n\
2445 -n --notes Display the core notes (if present)\n\
2446 -r --relocs Display the relocations (if present)\n\
2447 -u --unwind Display the unwind info (if present)\n\
2448 -d --dynamic Display the dynamic segment (if present)\n\
2449 -V --version-info Display the version sections (if present)\n\
2450 -A --arch-specific Display architecture specific information (if any).\n\
2451 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2452 -x --hex-dump=<number> Dump the contents of section <number>\n\
2453 -w[liaprmfFso] or\n\
2454 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2455 Display the contents of DWARF2 debug sections\n"));
2456 #ifdef SUPPORT_DISASSEMBLY
2457 fprintf (stdout
, _("\
2458 -i --instruction-dump=<number>\n\
2459 Disassemble the contents of section <number>\n"));
2461 fprintf (stdout
, _("\
2462 -I --histogram Display histogram of bucket list lengths\n\
2463 -W --wide Allow output width to exceed 80 characters\n\
2464 -H --help Display this information\n\
2465 -v --version Display the version number of readelf\n"));
2466 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2472 request_dump (section
, type
)
2473 unsigned int section
;
2476 if (section
>= num_dump_sects
)
2478 char *new_dump_sects
;
2480 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2482 if (new_dump_sects
== NULL
)
2483 error (_("Out of memory allocating dump request table."));
2486 /* Copy current flag settings. */
2487 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2491 dump_sects
= new_dump_sects
;
2492 num_dump_sects
= section
+ 1;
2497 dump_sects
[section
] |= type
;
2503 parse_args (argc
, argv
)
2512 while ((c
= getopt_long
2513 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2580 section
= strtoul (optarg
, & cp
, 0);
2581 if (! *cp
&& section
>= 0)
2583 request_dump (section
, HEX_DUMP
);
2593 unsigned int index
= 0;
2597 while (optarg
[index
])
2598 switch (optarg
[index
++])
2607 do_debug_abbrevs
= 1;
2617 do_debug_pubnames
= 1;
2622 do_debug_aranges
= 1;
2626 do_debug_frames_interp
= 1;
2628 do_debug_frames
= 1;
2633 do_debug_macinfo
= 1;
2647 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2652 case OPTION_DEBUG_DUMP
:
2658 static const char *debug_dump_opt
[]
2659 = { "line", "info", "abbrev", "pubnames", "ranges",
2660 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2669 for (index
= 0; debug_dump_opt
[index
]; index
++)
2671 size_t len
= strlen (debug_dump_opt
[index
]);
2673 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2674 && (p
[len
] == ',' || p
[len
] == '\0'))
2683 do_debug_abbrevs
= 1;
2694 do_debug_pubnames
= 1;
2698 do_debug_aranges
= 1;
2703 do_debug_frames_interp
= 1;
2704 do_debug_frames
= 1;
2708 do_debug_macinfo
= 1;
2721 if (debug_dump_opt
[index
] == NULL
)
2723 warn (_("Unrecognized debug option '%s'\n"), p
);
2724 p
= strchr (p
, ',');
2734 #ifdef SUPPORT_DISASSEMBLY
2737 section
= strtoul (optarg
, & cp
, 0);
2738 if (! *cp
&& section
>= 0)
2740 request_dump (section
, DISASS_DUMP
);
2746 print_version (program_name
);
2756 /* xgettext:c-format */
2757 error (_("Invalid option '-%c'\n"), c
);
2764 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2765 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2766 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2770 warn (_("Nothing to do.\n"));
2776 get_elf_class (elf_class
)
2777 unsigned int elf_class
;
2779 static char buff
[32];
2783 case ELFCLASSNONE
: return _("none");
2784 case ELFCLASS32
: return "ELF32";
2785 case ELFCLASS64
: return "ELF64";
2787 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2793 get_data_encoding (encoding
)
2794 unsigned int encoding
;
2796 static char buff
[32];
2800 case ELFDATANONE
: return _("none");
2801 case ELFDATA2LSB
: return _("2's complement, little endian");
2802 case ELFDATA2MSB
: return _("2's complement, big endian");
2804 sprintf (buff
, _("<unknown: %x>"), encoding
);
2810 get_osabi_name (osabi
)
2813 static char buff
[32];
2817 case ELFOSABI_NONE
: return "UNIX - System V";
2818 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2819 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2820 case ELFOSABI_LINUX
: return "UNIX - Linux";
2821 case ELFOSABI_HURD
: return "GNU/Hurd";
2822 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2823 case ELFOSABI_AIX
: return "UNIX - AIX";
2824 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2825 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2826 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2827 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2828 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2829 case ELFOSABI_STANDALONE
: return _("Standalone App");
2830 case ELFOSABI_ARM
: return "ARM";
2832 sprintf (buff
, _("<unknown: %x>"), osabi
);
2837 /* Decode the data held in 'elf_header'. */
2839 process_file_header ()
2841 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2842 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2843 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2844 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2847 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2855 printf (_("ELF Header:\n"));
2856 printf (_(" Magic: "));
2857 for (i
= 0; i
< EI_NIDENT
; i
++)
2858 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2860 printf (_(" Class: %s\n"),
2861 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2862 printf (_(" Data: %s\n"),
2863 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2864 printf (_(" Version: %d %s\n"),
2865 elf_header
.e_ident
[EI_VERSION
],
2866 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2868 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2871 printf (_(" OS/ABI: %s\n"),
2872 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2873 printf (_(" ABI Version: %d\n"),
2874 elf_header
.e_ident
[EI_ABIVERSION
]);
2875 printf (_(" Type: %s\n"),
2876 get_file_type (elf_header
.e_type
));
2877 printf (_(" Machine: %s\n"),
2878 get_machine_name (elf_header
.e_machine
));
2879 printf (_(" Version: 0x%lx\n"),
2880 (unsigned long) elf_header
.e_version
);
2882 printf (_(" Entry point address: "));
2883 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2884 printf (_("\n Start of program headers: "));
2885 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2886 printf (_(" (bytes into file)\n Start of section headers: "));
2887 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2888 printf (_(" (bytes into file)\n"));
2890 printf (_(" Flags: 0x%lx%s\n"),
2891 (unsigned long) elf_header
.e_flags
,
2892 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2893 printf (_(" Size of this header: %ld (bytes)\n"),
2894 (long) elf_header
.e_ehsize
);
2895 printf (_(" Size of program headers: %ld (bytes)\n"),
2896 (long) elf_header
.e_phentsize
);
2897 printf (_(" Number of program headers: %ld\n"),
2898 (long) elf_header
.e_phnum
);
2899 printf (_(" Size of section headers: %ld (bytes)\n"),
2900 (long) elf_header
.e_shentsize
);
2901 printf (_(" Number of section headers: %ld"),
2902 (long) elf_header
.e_shnum
);
2903 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2904 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2905 putc ('\n', stdout
);
2906 printf (_(" Section header string table index: %ld"),
2907 (long) elf_header
.e_shstrndx
);
2908 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2909 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2910 putc ('\n', stdout
);
2913 if (section_headers
!= NULL
)
2915 if (elf_header
.e_shnum
== 0)
2916 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2917 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2918 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2919 free (section_headers
);
2920 section_headers
= NULL
;
2928 get_32bit_program_headers (file
, program_headers
)
2930 Elf_Internal_Phdr
*program_headers
;
2932 Elf32_External_Phdr
*phdrs
;
2933 Elf32_External_Phdr
*external
;
2934 Elf_Internal_Phdr
*internal
;
2937 phdrs
= ((Elf32_External_Phdr
*)
2938 get_data (NULL
, file
, elf_header
.e_phoff
,
2939 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2940 _("program headers")));
2944 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2945 i
< elf_header
.e_phnum
;
2946 i
++, internal
++, external
++)
2948 internal
->p_type
= BYTE_GET (external
->p_type
);
2949 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2950 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2951 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2952 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2953 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2954 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2955 internal
->p_align
= BYTE_GET (external
->p_align
);
2964 get_64bit_program_headers (file
, program_headers
)
2966 Elf_Internal_Phdr
*program_headers
;
2968 Elf64_External_Phdr
*phdrs
;
2969 Elf64_External_Phdr
*external
;
2970 Elf_Internal_Phdr
*internal
;
2973 phdrs
= ((Elf64_External_Phdr
*)
2974 get_data (NULL
, file
, elf_header
.e_phoff
,
2975 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2976 _("program headers")));
2980 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2981 i
< elf_header
.e_phnum
;
2982 i
++, internal
++, external
++)
2984 internal
->p_type
= BYTE_GET (external
->p_type
);
2985 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2986 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2987 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2988 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2989 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2990 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2991 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2999 /* Returns 1 if the program headers were loaded. */
3002 process_program_headers (file
)
3005 Elf_Internal_Phdr
*program_headers
;
3006 Elf_Internal_Phdr
*segment
;
3009 if (elf_header
.e_phnum
== 0)
3012 printf (_("\nThere are no program headers in this file.\n"));
3016 if (do_segments
&& !do_header
)
3018 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3019 printf (_("Entry point "));
3020 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3021 printf (_("\nThere are %d program headers, starting at offset "),
3022 elf_header
.e_phnum
);
3023 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3027 program_headers
= (Elf_Internal_Phdr
*) malloc
3028 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3030 if (program_headers
== NULL
)
3032 error (_("Out of memory\n"));
3037 i
= get_32bit_program_headers (file
, program_headers
);
3039 i
= get_64bit_program_headers (file
, program_headers
);
3043 free (program_headers
);
3049 if (elf_header
.e_phnum
> 1)
3050 printf (_("\nProgram Headers:\n"));
3052 printf (_("\nProgram Headers:\n"));
3056 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3059 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3063 (_(" Type Offset VirtAddr PhysAddr\n"));
3065 (_(" FileSiz MemSiz Flags Align\n"));
3073 for (i
= 0, segment
= program_headers
;
3074 i
< elf_header
.e_phnum
;
3079 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3083 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3084 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3085 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3086 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3087 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3089 (segment
->p_flags
& PF_R
? 'R' : ' '),
3090 (segment
->p_flags
& PF_W
? 'W' : ' '),
3091 (segment
->p_flags
& PF_X
? 'E' : ' '));
3092 printf ("%#lx", (unsigned long) segment
->p_align
);
3096 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3097 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3100 print_vma (segment
->p_offset
, FULL_HEX
);
3104 print_vma (segment
->p_vaddr
, FULL_HEX
);
3106 print_vma (segment
->p_paddr
, FULL_HEX
);
3109 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3110 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3113 print_vma (segment
->p_filesz
, FULL_HEX
);
3117 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3118 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3121 print_vma (segment
->p_offset
, FULL_HEX
);
3125 (segment
->p_flags
& PF_R
? 'R' : ' '),
3126 (segment
->p_flags
& PF_W
? 'W' : ' '),
3127 (segment
->p_flags
& PF_X
? 'E' : ' '));
3129 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3130 printf ("%#lx", (unsigned long) segment
->p_align
);
3133 print_vma (segment
->p_align
, PREFIX_HEX
);
3138 print_vma (segment
->p_offset
, FULL_HEX
);
3140 print_vma (segment
->p_vaddr
, FULL_HEX
);
3142 print_vma (segment
->p_paddr
, FULL_HEX
);
3144 print_vma (segment
->p_filesz
, FULL_HEX
);
3146 print_vma (segment
->p_memsz
, FULL_HEX
);
3148 (segment
->p_flags
& PF_R
? 'R' : ' '),
3149 (segment
->p_flags
& PF_W
? 'W' : ' '),
3150 (segment
->p_flags
& PF_X
? 'E' : ' '));
3151 print_vma (segment
->p_align
, HEX
);
3155 switch (segment
->p_type
)
3160 unsigned long align_mask
= -segment
->p_align
;
3162 if (align_mask
== 0)
3164 loadaddr
= ((segment
->p_vaddr
& align_mask
)
3165 - (segment
->p_offset
& align_mask
));
3171 error (_("more than one dynamic segment\n"));
3173 dynamic_addr
= segment
->p_offset
;
3174 dynamic_size
= segment
->p_filesz
;
3178 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
3179 error (_("Unable to find program interpreter name\n"));
3182 program_interpreter
[0] = 0;
3183 fscanf (file
, "%63s", program_interpreter
);
3186 printf (_("\n [Requesting program interpreter: %s]"),
3187 program_interpreter
);
3193 putc ('\n', stdout
);
3202 if (do_segments
&& section_headers
!= NULL
)
3204 printf (_("\n Section to Segment mapping:\n"));
3205 printf (_(" Segment Sections...\n"));
3207 assert (string_table
!= NULL
);
3209 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3212 Elf_Internal_Shdr
*section
;
3214 segment
= program_headers
+ i
;
3215 section
= section_headers
;
3217 printf (" %2.2d ", i
);
3219 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3221 if (section
->sh_size
> 0
3222 /* Compare allocated sections by VMA, unallocated
3223 sections by file offset. */
3224 && (section
->sh_flags
& SHF_ALLOC
3225 ? (section
->sh_addr
>= segment
->p_vaddr
3226 && section
->sh_addr
+ section
->sh_size
3227 <= segment
->p_vaddr
+ segment
->p_memsz
)
3228 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3229 && (section
->sh_offset
+ section
->sh_size
3230 <= segment
->p_offset
+ segment
->p_filesz
))))
3231 printf ("%s ", SECTION_NAME (section
));
3238 free (program_headers
);
3245 get_32bit_section_headers (file
, num
)
3249 Elf32_External_Shdr
*shdrs
;
3250 Elf_Internal_Shdr
*internal
;
3253 shdrs
= ((Elf32_External_Shdr
*)
3254 get_data (NULL
, file
, elf_header
.e_shoff
,
3255 elf_header
.e_shentsize
* num
,
3256 _("section headers")));
3260 section_headers
= ((Elf_Internal_Shdr
*)
3261 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3263 if (section_headers
== NULL
)
3265 error (_("Out of memory\n"));
3269 for (i
= 0, internal
= section_headers
;
3273 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3274 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3275 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3276 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3277 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3278 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3279 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3280 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3281 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3282 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3291 get_64bit_section_headers (file
, num
)
3295 Elf64_External_Shdr
*shdrs
;
3296 Elf_Internal_Shdr
*internal
;
3299 shdrs
= ((Elf64_External_Shdr
*)
3300 get_data (NULL
, file
, elf_header
.e_shoff
,
3301 elf_header
.e_shentsize
* num
,
3302 _("section headers")));
3306 section_headers
= ((Elf_Internal_Shdr
*)
3307 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3309 if (section_headers
== NULL
)
3311 error (_("Out of memory\n"));
3315 for (i
= 0, internal
= section_headers
;
3319 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3320 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3321 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3322 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3323 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3324 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3325 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3326 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3327 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3328 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3336 static Elf_Internal_Sym
*
3337 get_32bit_elf_symbols (file
, section
)
3339 Elf_Internal_Shdr
*section
;
3341 unsigned long number
;
3342 Elf32_External_Sym
*esyms
;
3343 Elf_External_Sym_Shndx
*shndx
;
3344 Elf_Internal_Sym
*isyms
;
3345 Elf_Internal_Sym
*psym
;
3348 esyms
= ((Elf32_External_Sym
*)
3349 get_data (NULL
, file
, section
->sh_offset
,
3350 section
->sh_size
, _("symbols")));
3355 if (symtab_shndx_hdr
!= NULL
3356 && (symtab_shndx_hdr
->sh_link
3357 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3359 shndx
= ((Elf_External_Sym_Shndx
*)
3360 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3361 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3369 number
= section
->sh_size
/ section
->sh_entsize
;
3370 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3374 error (_("Out of memory\n"));
3381 for (j
= 0, psym
= isyms
;
3385 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3386 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3387 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3388 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3389 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3391 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3392 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3393 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3403 static Elf_Internal_Sym
*
3404 get_64bit_elf_symbols (file
, section
)
3406 Elf_Internal_Shdr
*section
;
3408 unsigned long number
;
3409 Elf64_External_Sym
*esyms
;
3410 Elf_External_Sym_Shndx
*shndx
;
3411 Elf_Internal_Sym
*isyms
;
3412 Elf_Internal_Sym
*psym
;
3415 esyms
= ((Elf64_External_Sym
*)
3416 get_data (NULL
, file
, section
->sh_offset
,
3417 section
->sh_size
, _("symbols")));
3422 if (symtab_shndx_hdr
!= NULL
3423 && (symtab_shndx_hdr
->sh_link
3424 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3426 shndx
= ((Elf_External_Sym_Shndx
*)
3427 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3428 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3436 number
= section
->sh_size
/ section
->sh_entsize
;
3437 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3441 error (_("Out of memory\n"));
3448 for (j
= 0, psym
= isyms
;
3452 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3453 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3454 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3455 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3456 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3458 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3459 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3460 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3471 get_elf_section_flags (sh_flags
)
3474 static char buff
[32];
3482 flag
= sh_flags
& - sh_flags
;
3487 case SHF_WRITE
: strcat (buff
, "W"); break;
3488 case SHF_ALLOC
: strcat (buff
, "A"); break;
3489 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3490 case SHF_MERGE
: strcat (buff
, "M"); break;
3491 case SHF_STRINGS
: strcat (buff
, "S"); break;
3492 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3493 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3494 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3495 case SHF_GROUP
: strcat (buff
, "G"); break;
3496 case SHF_TLS
: strcat (buff
, "T"); break;
3499 if (flag
& SHF_MASKOS
)
3502 sh_flags
&= ~ SHF_MASKOS
;
3504 else if (flag
& SHF_MASKPROC
)
3507 sh_flags
&= ~ SHF_MASKPROC
;
3519 process_section_headers (file
)
3522 Elf_Internal_Shdr
*section
;
3525 section_headers
= NULL
;
3527 if (elf_header
.e_shnum
== 0)
3530 printf (_("\nThere are no sections in this file.\n"));
3535 if (do_sections
&& !do_header
)
3536 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3537 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3541 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3544 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3547 /* Read in the string table, so that we have names to display. */
3548 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3550 if (section
->sh_size
!= 0)
3552 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3553 section
->sh_size
, _("string table"));
3555 string_table_length
= section
->sh_size
;
3558 /* Scan the sections for the dynamic symbol table
3559 and dynamic string table and debug sections. */
3560 dynamic_symbols
= NULL
;
3561 dynamic_strings
= NULL
;
3562 dynamic_syminfo
= NULL
;
3563 symtab_shndx_hdr
= NULL
;
3565 for (i
= 0, section
= section_headers
;
3566 i
< elf_header
.e_shnum
;
3569 char *name
= SECTION_NAME (section
);
3571 if (section
->sh_type
== SHT_DYNSYM
)
3573 if (dynamic_symbols
!= NULL
)
3575 error (_("File contains multiple dynamic symbol tables\n"));
3579 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3580 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3582 else if (section
->sh_type
== SHT_STRTAB
3583 && strcmp (name
, ".dynstr") == 0)
3585 if (dynamic_strings
!= NULL
)
3587 error (_("File contains multiple dynamic string tables\n"));
3591 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3593 _("dynamic strings"));
3595 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3597 if (symtab_shndx_hdr
!= NULL
)
3599 error (_("File contains multiple symtab shndx tables\n"));
3602 symtab_shndx_hdr
= section
;
3604 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3605 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3606 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3608 && strncmp (name
, ".debug_", 7) == 0)
3613 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3614 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3615 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3616 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3617 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3618 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3619 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3620 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3621 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3623 request_dump (i
, DEBUG_DUMP
);
3625 /* linkonce section to be combined with .debug_info at link time. */
3626 else if ((do_debugging
|| do_debug_info
)
3627 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3628 request_dump (i
, DEBUG_DUMP
);
3629 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3630 request_dump (i
, DEBUG_DUMP
);
3636 if (elf_header
.e_shnum
> 1)
3637 printf (_("\nSection Headers:\n"));
3639 printf (_("\nSection Header:\n"));
3643 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3646 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3649 printf (_(" [Nr] Name Type Address Offset\n"));
3650 printf (_(" Size EntSize Flags Link Info Align\n"));
3653 for (i
= 0, section
= section_headers
;
3654 i
< elf_header
.e_shnum
;
3657 printf (" [%2u] %-17.17s %-15.15s ",
3658 SECTION_HEADER_NUM (i
),
3659 SECTION_NAME (section
),
3660 get_section_type_name (section
->sh_type
));
3664 print_vma (section
->sh_addr
, LONG_HEX
);
3666 printf ( " %6.6lx %6.6lx %2.2lx",
3667 (unsigned long) section
->sh_offset
,
3668 (unsigned long) section
->sh_size
,
3669 (unsigned long) section
->sh_entsize
);
3671 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3673 printf ("%2ld %3lx %2ld\n",
3674 (unsigned long) section
->sh_link
,
3675 (unsigned long) section
->sh_info
,
3676 (unsigned long) section
->sh_addralign
);
3680 print_vma (section
->sh_addr
, LONG_HEX
);
3682 if ((long) section
->sh_offset
== section
->sh_offset
)
3683 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3687 print_vma (section
->sh_offset
, LONG_HEX
);
3690 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3691 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3695 print_vma (section
->sh_size
, LONG_HEX
);
3698 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3699 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3703 print_vma (section
->sh_entsize
, LONG_HEX
);
3706 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3708 printf ("%2ld %3lx ",
3709 (unsigned long) section
->sh_link
,
3710 (unsigned long) section
->sh_info
);
3712 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3713 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3716 print_vma (section
->sh_addralign
, DEC
);
3723 print_vma (section
->sh_addr
, LONG_HEX
);
3724 if ((long) section
->sh_offset
== section
->sh_offset
)
3725 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3729 print_vma (section
->sh_offset
, LONG_HEX
);
3732 print_vma (section
->sh_size
, LONG_HEX
);
3734 print_vma (section
->sh_entsize
, LONG_HEX
);
3736 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3738 printf (" %2ld %3lx %ld\n",
3739 (unsigned long) section
->sh_link
,
3740 (unsigned long) section
->sh_info
,
3741 (unsigned long) section
->sh_addralign
);
3745 printf (_("Key to Flags:\n\
3746 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3747 I (info), L (link order), G (group), x (unknown)\n\
3748 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3753 /* Process the reloc section. */
3755 process_relocs (file
)
3758 unsigned long rel_size
;
3759 unsigned long rel_offset
;
3765 if (do_using_dynamic
)
3767 int is_rela
= FALSE
;
3772 if (dynamic_info
[DT_REL
])
3774 rel_offset
= dynamic_info
[DT_REL
];
3775 rel_size
= dynamic_info
[DT_RELSZ
];
3778 else if (dynamic_info
[DT_RELA
])
3780 rel_offset
= dynamic_info
[DT_RELA
];
3781 rel_size
= dynamic_info
[DT_RELASZ
];
3784 else if (dynamic_info
[DT_JMPREL
])
3786 rel_offset
= dynamic_info
[DT_JMPREL
];
3787 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3789 switch (dynamic_info
[DT_PLTREL
])
3806 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3807 rel_offset
, rel_size
);
3809 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3810 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
,
3814 printf (_("\nThere are no dynamic relocations in this file.\n"));
3818 Elf_Internal_Shdr
*section
;
3822 for (i
= 0, section
= section_headers
;
3823 i
< elf_header
.e_shnum
;
3826 if ( section
->sh_type
!= SHT_RELA
3827 && section
->sh_type
!= SHT_REL
)
3830 rel_offset
= section
->sh_offset
;
3831 rel_size
= section
->sh_size
;
3835 Elf_Internal_Shdr
*strsec
;
3836 Elf_Internal_Sym
*symtab
;
3839 unsigned long nsyms
;
3841 printf (_("\nRelocation section "));
3843 if (string_table
== NULL
)
3844 printf ("%d", section
->sh_name
);
3846 printf (_("'%s'"), SECTION_NAME (section
));
3848 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3849 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3854 if (section
->sh_link
)
3856 Elf_Internal_Shdr
*symsec
;
3858 symsec
= SECTION_HEADER (section
->sh_link
);
3859 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3860 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3865 strsec
= SECTION_HEADER (symsec
->sh_link
);
3867 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3871 is_rela
= section
->sh_type
== SHT_RELA
;
3873 dump_relocations (file
, rel_offset
, rel_size
,
3874 symtab
, nsyms
, strtab
, is_rela
);
3886 printf (_("\nThere are no relocations in this file.\n"));
3892 #include "unwind-ia64.h"
3894 /* An absolute address consists of a section and an offset. If the
3895 section is NULL, the offset itself is the address, otherwise, the
3896 address equals to LOAD_ADDRESS(section) + offset. */
3900 unsigned short section
;
3906 struct unw_table_entry
3908 struct absaddr start
;
3910 struct absaddr info
;
3912 *table
; /* Unwind table. */
3913 unsigned long table_len
; /* Length of unwind table. */
3914 unsigned char *info
; /* Unwind info. */
3915 unsigned long info_size
; /* Size of unwind info. */
3916 bfd_vma info_addr
; /* starting address of unwind info. */
3917 bfd_vma seg_base
; /* Starting address of segment. */
3918 Elf_Internal_Sym
*symtab
; /* The symbol table. */
3919 unsigned long nsyms
; /* Number of symbols. */
3920 char *strtab
; /* The string table. */
3921 unsigned long strtab_size
; /* Size of string table. */
3924 static void find_symbol_for_address
3925 PARAMS ((struct unw_aux_info
*, struct absaddr
, const char **, bfd_vma
*));
3926 static void dump_ia64_unwind
3927 PARAMS ((struct unw_aux_info
*));
3928 static int slurp_ia64_unwind_table
3929 PARAMS ((FILE *, struct unw_aux_info
*, Elf_Internal_Shdr
*));
3932 find_symbol_for_address (aux
, addr
, symname
, offset
)
3933 struct unw_aux_info
*aux
;
3934 struct absaddr addr
;
3935 const char **symname
;
3938 bfd_vma dist
= (bfd_vma
) 0x100000;
3939 Elf_Internal_Sym
*sym
, *best
= NULL
;
3942 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3944 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3945 && sym
->st_name
!= 0
3946 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3947 && addr
.offset
>= sym
->st_value
3948 && addr
.offset
- sym
->st_value
< dist
)
3951 dist
= addr
.offset
- sym
->st_value
;
3958 *symname
= (best
->st_name
>= aux
->strtab_size
3959 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3964 *offset
= addr
.offset
;
3968 dump_ia64_unwind (aux
)
3969 struct unw_aux_info
*aux
;
3972 struct unw_table_entry
*tp
;
3975 addr_size
= is_32bit_elf
? 4 : 8;
3977 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3981 const unsigned char *dp
;
3982 const unsigned char *head
;
3983 const char *procname
;
3985 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3987 fputs ("\n<", stdout
);
3991 fputs (procname
, stdout
);
3994 printf ("+%lx", (unsigned long) offset
);
3997 fputs (">: [", stdout
);
3998 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3999 fputc ('-', stdout
);
4000 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4001 printf ("], info at +0x%lx\n",
4002 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4004 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4005 stamp
= BYTE_GET8 ((unsigned char *) head
);
4007 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4008 (unsigned) UNW_VER (stamp
),
4009 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4010 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4011 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4012 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4014 if (UNW_VER (stamp
) != 1)
4016 printf ("\tUnknown version.\n");
4021 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4022 dp
= unw_decode (dp
, in_body
, & in_body
);
4027 slurp_ia64_unwind_table (file
, aux
, sec
)
4029 struct unw_aux_info
*aux
;
4030 Elf_Internal_Shdr
*sec
;
4032 unsigned long size
, addr_size
, nrelas
, i
;
4033 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
4034 struct unw_table_entry
*tep
;
4035 Elf_Internal_Shdr
*relsec
;
4036 Elf_Internal_Rela
*rela
, *rp
;
4037 unsigned char *table
, *tp
;
4038 Elf_Internal_Sym
*sym
;
4039 const char *relname
;
4042 addr_size
= is_32bit_elf
? 4 : 8;
4044 /* First, find the starting address of the segment that includes
4047 if (elf_header
.e_phnum
)
4049 prog_hdrs
= (Elf_Internal_Phdr
*)
4050 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
4053 result
= get_32bit_program_headers (file
, prog_hdrs
);
4055 result
= get_64bit_program_headers (file
, prog_hdrs
);
4063 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
4065 if (seg
->p_type
!= PT_LOAD
)
4068 if (sec
->sh_addr
>= seg
->p_vaddr
4069 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4071 aux
->seg_base
= seg
->p_vaddr
;
4079 /* Second, build the unwind table from the contents of the unwind section: */
4080 size
= sec
->sh_size
;
4081 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4082 size
, _("unwind table"));
4086 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4087 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4089 tep
->start
.section
= SHN_UNDEF
;
4090 tep
->end
.section
= SHN_UNDEF
;
4091 tep
->info
.section
= SHN_UNDEF
;
4094 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4095 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4096 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4100 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4101 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4102 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4104 tep
->start
.offset
+= aux
->seg_base
;
4105 tep
->end
.offset
+= aux
->seg_base
;
4106 tep
->info
.offset
+= aux
->seg_base
;
4110 /* Third, apply any relocations to the unwind table: */
4112 for (relsec
= section_headers
;
4113 relsec
< section_headers
+ elf_header
.e_shnum
;
4116 if (relsec
->sh_type
!= SHT_RELA
4117 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4120 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4124 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4128 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4129 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4131 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4133 warn (_("Skipping unexpected symbol type %u\n"),
4134 ELF32_ST_TYPE (sym
->st_info
));
4140 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4141 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4143 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4145 warn (_("Skipping unexpected symbol type %u\n"),
4146 ELF64_ST_TYPE (sym
->st_info
));
4151 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4153 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4157 i
= rp
->r_offset
/ (3 * addr_size
);
4159 switch (rp
->r_offset
/addr_size
% 3)
4162 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4163 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4166 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4167 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4170 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4171 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4181 aux
->table_len
= size
/ (3 * addr_size
);
4186 process_unwind (file
)
4189 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4190 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4191 struct unw_aux_info aux
;
4196 if (elf_header
.e_machine
!= EM_IA_64
)
4198 printf (_("\nThere are no unwind sections in this file.\n"));
4202 memset (& aux
, 0, sizeof (aux
));
4204 addr_size
= is_32bit_elf
? 4 : 8;
4206 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4208 if (sec
->sh_type
== SHT_SYMTAB
)
4210 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4211 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4213 strsec
= SECTION_HEADER (sec
->sh_link
);
4214 aux
.strtab_size
= strsec
->sh_size
;
4215 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4216 aux
.strtab_size
, _("string table"));
4218 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4223 printf (_("\nThere are no unwind sections in this file.\n"));
4225 while (unwcount
-- > 0)
4230 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4231 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4232 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4239 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4241 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
4244 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4245 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4246 suffix
= SECTION_NAME (unwsec
) + len
;
4247 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4249 if (strncmp (SECTION_NAME (sec
),
4250 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4251 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4256 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4257 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4258 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4259 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4261 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4263 suffix
= SECTION_NAME (unwsec
) + len
;
4264 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4266 if (strncmp (SECTION_NAME (sec
),
4267 ELF_STRING_ia64_unwind_info
, len2
) == 0
4268 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4272 if (i
== elf_header
.e_shnum
)
4274 printf (_("\nCould not find unwind info section for "));
4276 if (string_table
== NULL
)
4277 printf ("%d", unwsec
->sh_name
);
4279 printf (_("'%s'"), SECTION_NAME (unwsec
));
4283 aux
.info_size
= sec
->sh_size
;
4284 aux
.info_addr
= sec
->sh_addr
;
4285 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4286 aux
.info_size
, _("unwind info"));
4288 printf (_("\nUnwind section "));
4290 if (string_table
== NULL
)
4291 printf ("%d", unwsec
->sh_name
);
4293 printf (_("'%s'"), SECTION_NAME (unwsec
));
4295 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4296 (unsigned long) unwsec
->sh_offset
,
4297 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4299 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4301 if (aux
.table_len
> 0)
4302 dump_ia64_unwind (& aux
);
4305 free ((char *) aux
.table
);
4307 free ((char *) aux
.info
);
4316 free ((char *) aux
.strtab
);
4322 dynamic_segment_mips_val (entry
)
4323 Elf_Internal_Dyn
*entry
;
4325 switch (entry
->d_tag
)
4328 if (entry
->d_un
.d_val
== 0)
4332 static const char * opts
[] =
4334 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4335 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4336 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4337 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4342 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4343 if (entry
->d_un
.d_val
& (1 << cnt
))
4345 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4352 case DT_MIPS_IVERSION
:
4353 if (dynamic_strings
!= NULL
)
4354 printf ("Interface Version: %s\n",
4355 dynamic_strings
+ entry
->d_un
.d_val
);
4357 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4360 case DT_MIPS_TIME_STAMP
:
4365 time_t time
= entry
->d_un
.d_val
;
4366 tmp
= gmtime (&time
);
4367 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4368 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4369 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4370 printf ("Time Stamp: %s\n", timebuf
);
4374 case DT_MIPS_RLD_VERSION
:
4375 case DT_MIPS_LOCAL_GOTNO
:
4376 case DT_MIPS_CONFLICTNO
:
4377 case DT_MIPS_LIBLISTNO
:
4378 case DT_MIPS_SYMTABNO
:
4379 case DT_MIPS_UNREFEXTNO
:
4380 case DT_MIPS_HIPAGENO
:
4381 case DT_MIPS_DELTA_CLASS_NO
:
4382 case DT_MIPS_DELTA_INSTANCE_NO
:
4383 case DT_MIPS_DELTA_RELOC_NO
:
4384 case DT_MIPS_DELTA_SYM_NO
:
4385 case DT_MIPS_DELTA_CLASSSYM_NO
:
4386 case DT_MIPS_COMPACT_SIZE
:
4387 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4391 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4397 dynamic_segment_parisc_val (entry
)
4398 Elf_Internal_Dyn
*entry
;
4400 switch (entry
->d_tag
)
4402 case DT_HP_DLD_FLAGS
:
4411 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4412 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4413 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4414 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4415 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4416 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4417 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4418 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4419 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4420 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4421 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4425 bfd_vma val
= entry
->d_un
.d_val
;
4427 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4428 if (val
& flags
[cnt
].bit
)
4432 fputs (flags
[cnt
].str
, stdout
);
4434 val
^= flags
[cnt
].bit
;
4437 if (val
!= 0 || first
)
4441 print_vma (val
, HEX
);
4447 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4454 get_32bit_dynamic_segment (file
)
4457 Elf32_External_Dyn
*edyn
;
4458 Elf_Internal_Dyn
*entry
;
4461 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4462 dynamic_size
, _("dynamic segment"));
4466 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4467 how large this .dynamic is now. We can do this even before the byte
4468 swapping since the DT_NULL tag is recognizable. */
4470 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4473 dynamic_segment
= (Elf_Internal_Dyn
*)
4474 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4476 if (dynamic_segment
== NULL
)
4478 error (_("Out of memory\n"));
4483 for (i
= 0, entry
= dynamic_segment
;
4487 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4488 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4497 get_64bit_dynamic_segment (file
)
4500 Elf64_External_Dyn
*edyn
;
4501 Elf_Internal_Dyn
*entry
;
4504 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4505 dynamic_size
, _("dynamic segment"));
4509 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4510 how large this .dynamic is now. We can do this even before the byte
4511 swapping since the DT_NULL tag is recognizable. */
4513 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4516 dynamic_segment
= (Elf_Internal_Dyn
*)
4517 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4519 if (dynamic_segment
== NULL
)
4521 error (_("Out of memory\n"));
4526 for (i
= 0, entry
= dynamic_segment
;
4530 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4531 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4540 get_dynamic_flags (flags
)
4543 static char buff
[128];
4551 flag
= flags
& - flags
;
4559 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4560 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4561 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4562 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4563 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4564 default: strcpy (p
, "unknown"); break;
4567 p
= strchr (p
, '\0');
4572 /* Parse and display the contents of the dynamic segment. */
4574 process_dynamic_segment (file
)
4577 Elf_Internal_Dyn
*entry
;
4580 if (dynamic_size
== 0)
4583 printf (_("\nThere is no dynamic segment in this file.\n"));
4590 if (! get_32bit_dynamic_segment (file
))
4593 else if (! get_64bit_dynamic_segment (file
))
4596 /* Find the appropriate symbol table. */
4597 if (dynamic_symbols
== NULL
)
4599 for (i
= 0, entry
= dynamic_segment
;
4603 Elf_Internal_Shdr section
;
4605 if (entry
->d_tag
!= DT_SYMTAB
)
4608 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4610 /* Since we do not know how big the symbol table is,
4611 we default to reading in the entire file (!) and
4612 processing that. This is overkill, I know, but it
4614 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4616 if (fseek (file
, 0, SEEK_END
))
4617 error (_("Unable to seek to end of file!"));
4619 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4621 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4623 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4625 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4626 if (num_dynamic_syms
< 1)
4628 error (_("Unable to determine the number of symbols to load\n"));
4632 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4636 /* Similarly find a string table. */
4637 if (dynamic_strings
== NULL
)
4639 for (i
= 0, entry
= dynamic_segment
;
4643 unsigned long offset
;
4646 if (entry
->d_tag
!= DT_STRTAB
)
4649 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4651 /* Since we do not know how big the string table is,
4652 we default to reading in the entire file (!) and
4653 processing that. This is overkill, I know, but it
4656 offset
= entry
->d_un
.d_val
- loadaddr
;
4657 if (fseek (file
, 0, SEEK_END
))
4658 error (_("Unable to seek to end of file\n"));
4659 str_tab_len
= ftell (file
) - offset
;
4661 if (str_tab_len
< 1)
4664 (_("Unable to determine the length of the dynamic string table\n"));
4668 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4669 _("dynamic string table"));
4674 /* And find the syminfo section if available. */
4675 if (dynamic_syminfo
== NULL
)
4677 unsigned long syminsz
= 0;
4679 for (i
= 0, entry
= dynamic_segment
;
4683 if (entry
->d_tag
== DT_SYMINENT
)
4685 /* Note: these braces are necessary to avoid a syntax
4686 error from the SunOS4 C compiler. */
4687 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4689 else if (entry
->d_tag
== DT_SYMINSZ
)
4690 syminsz
= entry
->d_un
.d_val
;
4691 else if (entry
->d_tag
== DT_SYMINFO
)
4692 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4695 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4697 Elf_External_Syminfo
*extsyminfo
;
4698 Elf_Internal_Syminfo
*syminfo
;
4700 /* There is a syminfo section. Read the data. */
4701 extsyminfo
= ((Elf_External_Syminfo
*)
4702 get_data (NULL
, file
, dynamic_syminfo_offset
,
4703 syminsz
, _("symbol information")));
4707 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4708 if (dynamic_syminfo
== NULL
)
4710 error (_("Out of memory\n"));
4714 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4715 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4718 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4719 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4726 if (do_dynamic
&& dynamic_addr
)
4727 printf (_("\nDynamic segment at offset 0x%lx contains %ld entries:\n"),
4728 dynamic_addr
, (long) dynamic_size
);
4730 printf (_(" Tag Type Name/Value\n"));
4732 for (i
= 0, entry
= dynamic_segment
;
4741 print_vma (entry
->d_tag
, FULL_HEX
);
4742 dtype
= get_dynamic_type (entry
->d_tag
);
4743 printf (" (%s)%*s", dtype
,
4744 ((is_32bit_elf
? 27 : 19)
4745 - (int) strlen (dtype
)),
4749 switch (entry
->d_tag
)
4753 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4763 switch (entry
->d_tag
)
4766 printf (_("Auxiliary library"));
4770 printf (_("Filter library"));
4774 printf (_("Configuration file"));
4778 printf (_("Dependency audit library"));
4782 printf (_("Audit library"));
4786 if (dynamic_strings
)
4787 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4791 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4800 printf (_("Flags:"));
4802 if (entry
->d_un
.d_val
== 0)
4803 printf (_(" None\n"));
4806 unsigned long int val
= entry
->d_un
.d_val
;
4808 if (val
& DTF_1_PARINIT
)
4810 printf (" PARINIT");
4811 val
^= DTF_1_PARINIT
;
4813 if (val
& DTF_1_CONFEXP
)
4815 printf (" CONFEXP");
4816 val
^= DTF_1_CONFEXP
;
4819 printf (" %lx", val
);
4828 printf (_("Flags:"));
4830 if (entry
->d_un
.d_val
== 0)
4831 printf (_(" None\n"));
4834 unsigned long int val
= entry
->d_un
.d_val
;
4836 if (val
& DF_P1_LAZYLOAD
)
4838 printf (" LAZYLOAD");
4839 val
^= DF_P1_LAZYLOAD
;
4841 if (val
& DF_P1_GROUPPERM
)
4843 printf (" GROUPPERM");
4844 val
^= DF_P1_GROUPPERM
;
4847 printf (" %lx", val
);
4856 printf (_("Flags:"));
4857 if (entry
->d_un
.d_val
== 0)
4858 printf (_(" None\n"));
4861 unsigned long int val
= entry
->d_un
.d_val
;
4868 if (val
& DF_1_GLOBAL
)
4873 if (val
& DF_1_GROUP
)
4878 if (val
& DF_1_NODELETE
)
4880 printf (" NODELETE");
4881 val
^= DF_1_NODELETE
;
4883 if (val
& DF_1_LOADFLTR
)
4885 printf (" LOADFLTR");
4886 val
^= DF_1_LOADFLTR
;
4888 if (val
& DF_1_INITFIRST
)
4890 printf (" INITFIRST");
4891 val
^= DF_1_INITFIRST
;
4893 if (val
& DF_1_NOOPEN
)
4898 if (val
& DF_1_ORIGIN
)
4903 if (val
& DF_1_DIRECT
)
4908 if (val
& DF_1_TRANS
)
4913 if (val
& DF_1_INTERPOSE
)
4915 printf (" INTERPOSE");
4916 val
^= DF_1_INTERPOSE
;
4918 if (val
& DF_1_NODEFLIB
)
4920 printf (" NODEFLIB");
4921 val
^= DF_1_NODEFLIB
;
4923 if (val
& DF_1_NODUMP
)
4928 if (val
& DF_1_CONLFAT
)
4930 printf (" CONLFAT");
4931 val
^= DF_1_CONLFAT
;
4934 printf (" %lx", val
);
4942 puts (get_dynamic_type (entry
->d_un
.d_val
));
4962 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4968 if (dynamic_strings
== NULL
)
4971 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4975 switch (entry
->d_tag
)
4978 printf (_("Shared library: [%s]"), name
);
4980 if (strcmp (name
, program_interpreter
) == 0)
4981 printf (_(" program interpreter"));
4985 printf (_("Library soname: [%s]"), name
);
4989 printf (_("Library rpath: [%s]"), name
);
4993 printf (_("Library runpath: [%s]"), name
);
4997 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5002 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5018 case DT_INIT_ARRAYSZ
:
5019 case DT_FINI_ARRAYSZ
:
5020 case DT_GNU_CONFLICTSZ
:
5021 case DT_GNU_LIBLISTSZ
:
5024 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5025 printf (" (bytes)\n");
5035 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5048 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
5052 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5056 printf (_("Not needed object: [%s]\n"), name
);
5061 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5067 /* The value of this entry is ignored. */
5072 case DT_GNU_PRELINKED
:
5076 time_t time
= entry
->d_un
.d_val
;
5078 tmp
= gmtime (&time
);
5079 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5080 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5081 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5087 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5088 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5093 switch (elf_header
.e_machine
)
5096 case EM_MIPS_RS3_LE
:
5097 dynamic_segment_mips_val (entry
);
5100 dynamic_segment_parisc_val (entry
);
5103 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5115 get_ver_flags (flags
)
5118 static char buff
[32];
5125 if (flags
& VER_FLG_BASE
)
5126 strcat (buff
, "BASE ");
5128 if (flags
& VER_FLG_WEAK
)
5130 if (flags
& VER_FLG_BASE
)
5131 strcat (buff
, "| ");
5133 strcat (buff
, "WEAK ");
5136 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5137 strcat (buff
, "| <unknown>");
5142 /* Display the contents of the version sections. */
5144 process_version_sections (file
)
5147 Elf_Internal_Shdr
*section
;
5154 for (i
= 0, section
= section_headers
;
5155 i
< elf_header
.e_shnum
;
5158 switch (section
->sh_type
)
5160 case SHT_GNU_verdef
:
5162 Elf_External_Verdef
*edefs
;
5169 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5170 SECTION_NAME (section
), section
->sh_info
);
5172 printf (_(" Addr: 0x"));
5173 printf_vma (section
->sh_addr
);
5174 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5175 (unsigned long) section
->sh_offset
, section
->sh_link
,
5176 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5178 edefs
= ((Elf_External_Verdef
*)
5179 get_data (NULL
, file
, section
->sh_offset
,
5181 _("version definition section")));
5185 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5188 Elf_External_Verdef
*edef
;
5189 Elf_Internal_Verdef ent
;
5190 Elf_External_Verdaux
*eaux
;
5191 Elf_Internal_Verdaux aux
;
5195 vstart
= ((char *) edefs
) + idx
;
5197 edef
= (Elf_External_Verdef
*) vstart
;
5199 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5200 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5201 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5202 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5203 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5204 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5205 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5207 printf (_(" %#06x: Rev: %d Flags: %s"),
5208 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5210 printf (_(" Index: %d Cnt: %d "),
5211 ent
.vd_ndx
, ent
.vd_cnt
);
5213 vstart
+= ent
.vd_aux
;
5215 eaux
= (Elf_External_Verdaux
*) vstart
;
5217 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5218 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5220 if (dynamic_strings
)
5221 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5223 printf (_("Name index: %ld\n"), aux
.vda_name
);
5225 isum
= idx
+ ent
.vd_aux
;
5227 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5229 isum
+= aux
.vda_next
;
5230 vstart
+= aux
.vda_next
;
5232 eaux
= (Elf_External_Verdaux
*) vstart
;
5234 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5235 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5237 if (dynamic_strings
)
5238 printf (_(" %#06x: Parent %d: %s\n"),
5239 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5241 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5242 isum
, j
, aux
.vda_name
);
5252 case SHT_GNU_verneed
:
5254 Elf_External_Verneed
*eneed
;
5260 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5261 SECTION_NAME (section
), section
->sh_info
);
5263 printf (_(" Addr: 0x"));
5264 printf_vma (section
->sh_addr
);
5265 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5266 (unsigned long) section
->sh_offset
, section
->sh_link
,
5267 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5269 eneed
= ((Elf_External_Verneed
*)
5270 get_data (NULL
, file
, section
->sh_offset
,
5271 section
->sh_size
, _("version need section")));
5275 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5277 Elf_External_Verneed
*entry
;
5278 Elf_Internal_Verneed ent
;
5283 vstart
= ((char *) eneed
) + idx
;
5285 entry
= (Elf_External_Verneed
*) vstart
;
5287 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5288 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5289 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5290 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5291 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5293 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5295 if (dynamic_strings
)
5296 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5298 printf (_(" File: %lx"), ent
.vn_file
);
5300 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5302 vstart
+= ent
.vn_aux
;
5304 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5306 Elf_External_Vernaux
*eaux
;
5307 Elf_Internal_Vernaux aux
;
5309 eaux
= (Elf_External_Vernaux
*) vstart
;
5311 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5312 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5313 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5314 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5315 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5317 if (dynamic_strings
)
5318 printf (_(" %#06x: Name: %s"),
5319 isum
, dynamic_strings
+ aux
.vna_name
);
5321 printf (_(" %#06x: Name index: %lx"),
5322 isum
, aux
.vna_name
);
5324 printf (_(" Flags: %s Version: %d\n"),
5325 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5327 isum
+= aux
.vna_next
;
5328 vstart
+= aux
.vna_next
;
5338 case SHT_GNU_versym
:
5340 Elf_Internal_Shdr
*link_section
;
5343 unsigned char *edata
;
5344 unsigned short *data
;
5346 Elf_Internal_Sym
*symbols
;
5347 Elf_Internal_Shdr
*string_sec
;
5349 link_section
= SECTION_HEADER (section
->sh_link
);
5350 total
= section
->sh_size
/ section
->sh_entsize
;
5354 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5356 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5358 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5359 string_sec
->sh_size
,
5360 _("version string table"));
5364 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5365 SECTION_NAME (section
), total
);
5367 printf (_(" Addr: "));
5368 printf_vma (section
->sh_addr
);
5369 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5370 (unsigned long) section
->sh_offset
, section
->sh_link
,
5371 SECTION_NAME (link_section
));
5375 get_data (NULL
, file
,
5376 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5377 total
* sizeof (short), _("version symbol data")));
5384 data
= (unsigned short *) malloc (total
* sizeof (short));
5386 for (cnt
= total
; cnt
--;)
5387 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5392 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5395 int check_def
, check_need
;
5398 printf (" %03x:", cnt
);
5400 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5401 switch (data
[cnt
+ j
])
5404 fputs (_(" 0 (*local*) "), stdout
);
5408 fputs (_(" 1 (*global*) "), stdout
);
5412 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5413 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5417 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5420 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5427 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5429 Elf_Internal_Verneed ivn
;
5430 unsigned long offset
;
5432 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5437 Elf_Internal_Vernaux ivna
;
5438 Elf_External_Verneed evn
;
5439 Elf_External_Vernaux evna
;
5440 unsigned long a_off
;
5442 get_data (&evn
, file
, offset
, sizeof (evn
),
5445 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5446 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5448 a_off
= offset
+ ivn
.vn_aux
;
5452 get_data (&evna
, file
, a_off
, sizeof (evna
),
5453 _("version need aux (2)"));
5455 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5456 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5458 a_off
+= ivna
.vna_next
;
5460 while (ivna
.vna_other
!= data
[cnt
+ j
]
5461 && ivna
.vna_next
!= 0);
5463 if (ivna
.vna_other
== data
[cnt
+ j
])
5465 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5467 name
= strtab
+ ivna
.vna_name
;
5468 nn
+= printf ("(%s%-*s",
5470 12 - (int) strlen (name
),
5476 offset
+= ivn
.vn_next
;
5478 while (ivn
.vn_next
);
5481 if (check_def
&& data
[cnt
+ j
] != 0x8001
5482 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5484 Elf_Internal_Verdef ivd
;
5485 Elf_External_Verdef evd
;
5486 unsigned long offset
;
5488 offset
= (version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5493 get_data (&evd
, file
, offset
, sizeof (evd
),
5496 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5497 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5499 offset
+= ivd
.vd_next
;
5501 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5502 && ivd
.vd_next
!= 0);
5504 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5506 Elf_External_Verdaux evda
;
5507 Elf_Internal_Verdaux ivda
;
5509 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5511 get_data (&evda
, file
,
5512 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5513 sizeof (evda
), _("version def aux"));
5515 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5517 name
= strtab
+ ivda
.vda_name
;
5518 nn
+= printf ("(%s%-*s",
5520 12 - (int) strlen (name
),
5526 printf ("%*c", 18 - nn
, ' ');
5544 printf (_("\nNo version information found in this file.\n"));
5550 get_symbol_binding (binding
)
5551 unsigned int binding
;
5553 static char buff
[32];
5557 case STB_LOCAL
: return "LOCAL";
5558 case STB_GLOBAL
: return "GLOBAL";
5559 case STB_WEAK
: return "WEAK";
5561 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5562 sprintf (buff
, _("<processor specific>: %d"), binding
);
5563 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5564 sprintf (buff
, _("<OS specific>: %d"), binding
);
5566 sprintf (buff
, _("<unknown>: %d"), binding
);
5572 get_symbol_type (type
)
5575 static char buff
[32];
5579 case STT_NOTYPE
: return "NOTYPE";
5580 case STT_OBJECT
: return "OBJECT";
5581 case STT_FUNC
: return "FUNC";
5582 case STT_SECTION
: return "SECTION";
5583 case STT_FILE
: return "FILE";
5584 case STT_COMMON
: return "COMMON";
5585 case STT_TLS
: return "TLS";
5587 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5589 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5590 return "THUMB_FUNC";
5592 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5595 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5596 return "PARISC_MILLI";
5598 sprintf (buff
, _("<processor specific>: %d"), type
);
5600 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5602 if (elf_header
.e_machine
== EM_PARISC
)
5604 if (type
== STT_HP_OPAQUE
)
5606 if (type
== STT_HP_STUB
)
5610 sprintf (buff
, _("<OS specific>: %d"), type
);
5613 sprintf (buff
, _("<unknown>: %d"), type
);
5619 get_symbol_visibility (visibility
)
5620 unsigned int visibility
;
5624 case STV_DEFAULT
: return "DEFAULT";
5625 case STV_INTERNAL
: return "INTERNAL";
5626 case STV_HIDDEN
: return "HIDDEN";
5627 case STV_PROTECTED
: return "PROTECTED";
5633 get_symbol_index_type (type
)
5636 static char buff
[32];
5640 case SHN_UNDEF
: return "UND";
5641 case SHN_ABS
: return "ABS";
5642 case SHN_COMMON
: return "COM";
5644 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5645 sprintf (buff
, "PRC[0x%04x]", type
);
5646 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5647 sprintf (buff
, "OS [0x%04x]", type
);
5648 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5649 sprintf (buff
, "RSV[0x%04x]", type
);
5651 sprintf (buff
, "%3d", type
);
5659 get_dynamic_data (file
, number
)
5661 unsigned int number
;
5663 unsigned char *e_data
;
5666 e_data
= (unsigned char *) malloc (number
* 4);
5670 error (_("Out of memory\n"));
5674 if (fread (e_data
, 4, number
, file
) != number
)
5676 error (_("Unable to read in dynamic data\n"));
5680 i_data
= (int *) malloc (number
* sizeof (*i_data
));
5684 error (_("Out of memory\n"));
5690 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5697 /* Dump the symbol table. */
5699 process_symbol_table (file
)
5702 Elf_Internal_Shdr
*section
;
5703 unsigned char nb
[4];
5704 unsigned char nc
[4];
5707 int *buckets
= NULL
;
5710 if (! do_syms
&& !do_histogram
)
5713 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5716 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5718 error (_("Unable to seek to start of dynamic information"));
5722 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5724 error (_("Failed to read in number of buckets\n"));
5728 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5730 error (_("Failed to read in number of chains\n"));
5734 nbuckets
= byte_get (nb
, 4);
5735 nchains
= byte_get (nc
, 4);
5737 buckets
= get_dynamic_data (file
, nbuckets
);
5738 chains
= get_dynamic_data (file
, nchains
);
5740 if (buckets
== NULL
|| chains
== NULL
)
5745 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5750 printf (_("\nSymbol table for image:\n"));
5752 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5754 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5756 for (hn
= 0; hn
< nbuckets
; hn
++)
5761 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5763 Elf_Internal_Sym
*psym
;
5765 psym
= dynamic_symbols
+ si
;
5767 printf (" %3d %3d: ", si
, hn
);
5768 print_vma (psym
->st_value
, LONG_HEX
);
5770 print_vma (psym
->st_size
, DEC_5
);
5772 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5773 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5774 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5775 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5776 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5781 else if (do_syms
&& !do_using_dynamic
)
5785 for (i
= 0, section
= section_headers
;
5786 i
< elf_header
.e_shnum
;
5791 Elf_Internal_Sym
*symtab
;
5792 Elf_Internal_Sym
*psym
;
5795 if ( section
->sh_type
!= SHT_SYMTAB
5796 && section
->sh_type
!= SHT_DYNSYM
)
5799 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5800 SECTION_NAME (section
),
5801 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5803 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5805 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5807 symtab
= GET_ELF_SYMBOLS (file
, section
);
5811 if (section
->sh_link
== elf_header
.e_shstrndx
)
5812 strtab
= string_table
;
5815 Elf_Internal_Shdr
*string_sec
;
5817 string_sec
= SECTION_HEADER (section
->sh_link
);
5819 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5820 string_sec
->sh_size
,
5824 for (si
= 0, psym
= symtab
;
5825 si
< section
->sh_size
/ section
->sh_entsize
;
5828 printf ("%6d: ", si
);
5829 print_vma (psym
->st_value
, LONG_HEX
);
5831 print_vma (psym
->st_size
, DEC_5
);
5832 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5833 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5834 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5835 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5836 print_symbol (25, strtab
+ psym
->st_name
);
5838 if (section
->sh_type
== SHT_DYNSYM
&&
5839 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5841 unsigned char data
[2];
5842 unsigned short vers_data
;
5843 unsigned long offset
;
5847 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5850 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5851 sizeof (data
), _("version data"));
5853 vers_data
= byte_get (data
, 2);
5855 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5858 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5860 if ((vers_data
& 0x8000) || vers_data
> 1)
5862 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5863 && (is_nobits
|| ! check_def
))
5865 Elf_External_Verneed evn
;
5866 Elf_Internal_Verneed ivn
;
5867 Elf_Internal_Vernaux ivna
;
5869 /* We must test both. */
5870 offset
= (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5875 unsigned long vna_off
;
5877 get_data (&evn
, file
, offset
, sizeof (evn
),
5880 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5881 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5883 vna_off
= offset
+ ivn
.vn_aux
;
5887 Elf_External_Vernaux evna
;
5889 get_data (&evna
, file
, vna_off
,
5891 _("version need aux (3)"));
5893 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5894 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5895 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5897 vna_off
+= ivna
.vna_next
;
5899 while (ivna
.vna_other
!= vers_data
5900 && ivna
.vna_next
!= 0);
5902 if (ivna
.vna_other
== vers_data
)
5905 offset
+= ivn
.vn_next
;
5907 while (ivn
.vn_next
!= 0);
5909 if (ivna
.vna_other
== vers_data
)
5912 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5915 else if (! is_nobits
)
5916 error (_("bad dynamic symbol"));
5923 if (vers_data
!= 0x8001
5924 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5926 Elf_Internal_Verdef ivd
;
5927 Elf_Internal_Verdaux ivda
;
5928 Elf_External_Verdaux evda
;
5929 unsigned long offset
;
5932 = (version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5937 Elf_External_Verdef evd
;
5939 get_data (&evd
, file
, offset
, sizeof (evd
),
5942 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5943 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5944 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5946 offset
+= ivd
.vd_next
;
5948 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5949 && ivd
.vd_next
!= 0);
5951 offset
-= ivd
.vd_next
;
5952 offset
+= ivd
.vd_aux
;
5954 get_data (&evda
, file
, offset
, sizeof (evda
),
5955 _("version def aux"));
5957 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5959 if (psym
->st_name
!= ivda
.vda_name
)
5960 printf ((vers_data
& 0x8000)
5962 strtab
+ ivda
.vda_name
);
5972 if (strtab
!= string_table
)
5978 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5980 if (do_histogram
&& buckets
!= NULL
)
5987 int nzero_counts
= 0;
5990 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5992 printf (_(" Length Number %% of total Coverage\n"));
5994 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5995 if (lengths
== NULL
)
5997 error (_("Out of memory"));
6000 for (hn
= 0; hn
< nbuckets
; ++hn
)
6005 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6008 if (maxlength
< ++lengths
[hn
])
6013 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
6016 error (_("Out of memory"));
6020 for (hn
= 0; hn
< nbuckets
; ++hn
)
6021 ++counts
[lengths
[hn
]];
6025 printf (" 0 %-10d (%5.1f%%)\n",
6026 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6027 for (si
= 1; si
<= maxlength
; ++si
)
6029 nzero_counts
+= counts
[si
] * si
;
6030 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6031 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6032 (nzero_counts
* 100.0) / nsyms
);
6040 if (buckets
!= NULL
)
6050 process_syminfo (file
)
6051 FILE *file ATTRIBUTE_UNUSED
;
6055 if (dynamic_syminfo
== NULL
6057 /* No syminfo, this is ok. */
6060 /* There better should be a dynamic symbol section. */
6061 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6065 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6066 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6068 printf (_(" Num: Name BoundTo Flags\n"));
6069 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6071 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6073 printf ("%4d: ", i
);
6074 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
6077 switch (dynamic_syminfo
[i
].si_boundto
)
6079 case SYMINFO_BT_SELF
:
6080 fputs ("SELF ", stdout
);
6082 case SYMINFO_BT_PARENT
:
6083 fputs ("PARENT ", stdout
);
6086 if (dynamic_syminfo
[i
].si_boundto
> 0
6087 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
6092 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6096 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6100 if (flags
& SYMINFO_FLG_DIRECT
)
6102 if (flags
& SYMINFO_FLG_PASSTHRU
)
6103 printf (" PASSTHRU");
6104 if (flags
& SYMINFO_FLG_COPY
)
6106 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6107 printf (" LAZYLOAD");
6115 #ifdef SUPPORT_DISASSEMBLY
6117 disassemble_section (section
, file
)
6118 Elf_Internal_Shdr
*section
;
6121 printf (_("\nAssembly dump of section %s\n"),
6122 SECTION_NAME (section
));
6124 /* XXX -- to be done --- XXX */
6131 dump_section (section
, file
)
6132 Elf_Internal_Shdr
*section
;
6135 bfd_size_type bytes
;
6137 unsigned char *data
;
6138 unsigned char *start
;
6140 bytes
= section
->sh_size
;
6144 printf (_("\nSection '%s' has no data to dump.\n"),
6145 SECTION_NAME (section
));
6149 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6151 addr
= section
->sh_addr
;
6153 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
6166 lbytes
= (bytes
> 16 ? 16 : bytes
);
6168 printf (" 0x%8.8lx ", (unsigned long) addr
);
6170 switch (elf_header
.e_ident
[EI_DATA
])
6174 for (j
= 15; j
>= 0; j
--)
6177 printf ("%2.2x", data
[j
]);
6187 for (j
= 0; j
< 16; j
++)
6190 printf ("%2.2x", data
[j
]);
6200 for (j
= 0; j
< lbytes
; j
++)
6203 if (k
>= ' ' && k
< 0x80)
6222 static unsigned long int
6223 read_leb128 (data
, length_return
, sign
)
6224 unsigned char *data
;
6228 unsigned long int result
= 0;
6229 unsigned int num_read
= 0;
6238 result
|= (byte
& 0x7f) << shift
;
6243 while (byte
& 0x80);
6245 if (length_return
!= NULL
)
6246 *length_return
= num_read
;
6248 if (sign
&& (shift
< 32) && (byte
& 0x40))
6249 result
|= -1 << shift
;
6254 typedef struct State_Machine_Registers
6256 unsigned long address
;
6259 unsigned int column
;
6263 /* This variable hold the number of the last entry seen
6264 in the File Table. */
6265 unsigned int last_file_entry
;
6268 static SMR state_machine_regs
;
6271 reset_state_machine (is_stmt
)
6274 state_machine_regs
.address
= 0;
6275 state_machine_regs
.file
= 1;
6276 state_machine_regs
.line
= 1;
6277 state_machine_regs
.column
= 0;
6278 state_machine_regs
.is_stmt
= is_stmt
;
6279 state_machine_regs
.basic_block
= 0;
6280 state_machine_regs
.end_sequence
= 0;
6281 state_machine_regs
.last_file_entry
= 0;
6284 /* Handled an extend line op. Returns true if this is the end
6287 process_extended_line_op (data
, is_stmt
, pointer_size
)
6288 unsigned char *data
;
6292 unsigned char op_code
;
6295 unsigned char *name
;
6298 len
= read_leb128 (data
, & bytes_read
, 0);
6303 warn (_("badly formed extended line op encountered!\n"));
6310 printf (_(" Extended opcode %d: "), op_code
);
6314 case DW_LNE_end_sequence
:
6315 printf (_("End of Sequence\n\n"));
6316 reset_state_machine (is_stmt
);
6319 case DW_LNE_set_address
:
6320 adr
= byte_get (data
, pointer_size
);
6321 printf (_("set Address to 0x%lx\n"), adr
);
6322 state_machine_regs
.address
= adr
;
6325 case DW_LNE_define_file
:
6326 printf (_(" define new File Table entry\n"));
6327 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6329 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6331 data
+= strlen ((char *) data
) + 1;
6332 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6334 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6336 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6337 printf (_("%s\n\n"), name
);
6341 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6348 /* Size of pointers in the .debug_line section. This information is not
6349 really present in that section. It's obtained before dumping the debug
6350 sections by doing some pre-scan of the .debug_info section. */
6351 static int debug_line_pointer_size
= 4;
6354 display_debug_lines (section
, start
, file
)
6355 Elf_Internal_Shdr
*section
;
6356 unsigned char * start
;
6357 FILE *file ATTRIBUTE_UNUSED
;
6359 DWARF2_External_LineInfo
*external
;
6360 DWARF2_Internal_LineInfo info
;
6361 unsigned char *standard_opcodes
;
6362 unsigned char *data
= start
;
6363 unsigned char *end
= start
+ section
->sh_size
;
6364 unsigned char *end_of_sequence
;
6367 printf (_("\nDump of debug contents of section %s:\n\n"),
6368 SECTION_NAME (section
));
6372 external
= (DWARF2_External_LineInfo
*) data
;
6374 /* Check the length of the block. */
6375 info
.li_length
= BYTE_GET (external
->li_length
);
6377 if (info
.li_length
== 0xffffffff)
6379 warn (_("64-bit DWARF line info is not supported yet.\n"));
6383 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6386 (_("The line info appears to be corrupt - the section is too small\n"));
6390 /* Check its version number. */
6391 info
.li_version
= BYTE_GET (external
->li_version
);
6392 if (info
.li_version
!= 2)
6394 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6398 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6399 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6400 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6401 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6402 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6403 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6405 /* Sign extend the line base field. */
6406 info
.li_line_base
<<= 24;
6407 info
.li_line_base
>>= 24;
6409 printf (_(" Length: %ld\n"), info
.li_length
);
6410 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6411 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6412 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6413 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6414 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6415 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6416 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6418 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6420 reset_state_machine (info
.li_default_is_stmt
);
6422 /* Display the contents of the Opcodes table. */
6423 standard_opcodes
= data
+ sizeof (*external
);
6425 printf (_("\n Opcodes:\n"));
6427 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6428 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6430 /* Display the contents of the Directory table. */
6431 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6434 printf (_("\n The Directory Table is empty.\n"));
6437 printf (_("\n The Directory Table:\n"));
6441 printf (_(" %s\n"), data
);
6443 data
+= strlen ((char *) data
) + 1;
6447 /* Skip the NUL at the end of the table. */
6450 /* Display the contents of the File Name table. */
6452 printf (_("\n The File Name Table is empty.\n"));
6455 printf (_("\n The File Name Table:\n"));
6456 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6460 unsigned char *name
;
6463 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6466 data
+= strlen ((char *) data
) + 1;
6468 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6470 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6472 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6474 printf (_("%s\n"), name
);
6478 /* Skip the NUL at the end of the table. */
6481 /* Now display the statements. */
6482 printf (_("\n Line Number Statements:\n"));
6485 while (data
< end_of_sequence
)
6487 unsigned char op_code
;
6493 if (op_code
>= info
.li_opcode_base
)
6495 op_code
-= info
.li_opcode_base
;
6496 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6497 state_machine_regs
.address
+= adv
;
6498 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6499 op_code
, adv
, state_machine_regs
.address
);
6500 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6501 state_machine_regs
.line
+= adv
;
6502 printf (_(" and Line by %d to %d\n"),
6503 adv
, state_machine_regs
.line
);
6505 else switch (op_code
)
6507 case DW_LNS_extended_op
:
6508 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6509 debug_line_pointer_size
);
6513 printf (_(" Copy\n"));
6516 case DW_LNS_advance_pc
:
6517 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6519 state_machine_regs
.address
+= adv
;
6520 printf (_(" Advance PC by %d to %lx\n"), adv
,
6521 state_machine_regs
.address
);
6524 case DW_LNS_advance_line
:
6525 adv
= read_leb128 (data
, & bytes_read
, 1);
6527 state_machine_regs
.line
+= adv
;
6528 printf (_(" Advance Line by %d to %d\n"), adv
,
6529 state_machine_regs
.line
);
6532 case DW_LNS_set_file
:
6533 adv
= read_leb128 (data
, & bytes_read
, 0);
6535 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6537 state_machine_regs
.file
= adv
;
6540 case DW_LNS_set_column
:
6541 adv
= read_leb128 (data
, & bytes_read
, 0);
6543 printf (_(" Set column to %d\n"), adv
);
6544 state_machine_regs
.column
= adv
;
6547 case DW_LNS_negate_stmt
:
6548 adv
= state_machine_regs
.is_stmt
;
6550 printf (_(" Set is_stmt to %d\n"), adv
);
6551 state_machine_regs
.is_stmt
= adv
;
6554 case DW_LNS_set_basic_block
:
6555 printf (_(" Set basic block\n"));
6556 state_machine_regs
.basic_block
= 1;
6559 case DW_LNS_const_add_pc
:
6560 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6561 * info
.li_min_insn_length
);
6562 state_machine_regs
.address
+= adv
;
6563 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6564 state_machine_regs
.address
);
6567 case DW_LNS_fixed_advance_pc
:
6568 adv
= byte_get (data
, 2);
6570 state_machine_regs
.address
+= adv
;
6571 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6572 adv
, state_machine_regs
.address
);
6575 case DW_LNS_set_prologue_end
:
6576 printf (_(" Set prologue_end to true\n"));
6579 case DW_LNS_set_epilogue_begin
:
6580 printf (_(" Set epilogue_begin to true\n"));
6583 case DW_LNS_set_isa
:
6584 adv
= read_leb128 (data
, & bytes_read
, 0);
6586 printf (_(" Set ISA to %d\n"), adv
);
6590 printf (_(" Unknown opcode %d with operands: "), op_code
);
6593 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6595 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6596 i
== 1 ? "" : ", ");
6611 display_debug_pubnames (section
, start
, file
)
6612 Elf_Internal_Shdr
*section
;
6613 unsigned char *start
;
6614 FILE *file ATTRIBUTE_UNUSED
;
6616 DWARF2_External_PubNames
*external
;
6617 DWARF2_Internal_PubNames pubnames
;
6620 end
= start
+ section
->sh_size
;
6622 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6626 unsigned char *data
;
6627 unsigned long offset
;
6629 external
= (DWARF2_External_PubNames
*) start
;
6631 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6632 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6633 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6634 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6636 data
= start
+ sizeof (*external
);
6637 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6639 if (pubnames
.pn_length
== 0xffffffff)
6641 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6645 if (pubnames
.pn_version
!= 2)
6647 static int warned
= 0;
6651 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6658 printf (_(" Length: %ld\n"),
6659 pubnames
.pn_length
);
6660 printf (_(" Version: %d\n"),
6661 pubnames
.pn_version
);
6662 printf (_(" Offset into .debug_info section: %ld\n"),
6663 pubnames
.pn_offset
);
6664 printf (_(" Size of area in .debug_info section: %ld\n"),
6667 printf (_("\n Offset\tName\n"));
6671 offset
= byte_get (data
, 4);
6676 printf (" %ld\t\t%s\n", offset
, data
);
6677 data
+= strlen ((char *) data
) + 1;
6680 while (offset
!= 0);
6693 case DW_TAG_padding
: return "DW_TAG_padding";
6694 case DW_TAG_array_type
: return "DW_TAG_array_type";
6695 case DW_TAG_class_type
: return "DW_TAG_class_type";
6696 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6697 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6698 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6699 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6700 case DW_TAG_label
: return "DW_TAG_label";
6701 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6702 case DW_TAG_member
: return "DW_TAG_member";
6703 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6704 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6705 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6706 case DW_TAG_string_type
: return "DW_TAG_string_type";
6707 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6708 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6709 case DW_TAG_typedef
: return "DW_TAG_typedef";
6710 case DW_TAG_union_type
: return "DW_TAG_union_type";
6711 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6712 case DW_TAG_variant
: return "DW_TAG_variant";
6713 case DW_TAG_common_block
: return "DW_TAG_common_block";
6714 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6715 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6716 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6717 case DW_TAG_module
: return "DW_TAG_module";
6718 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6719 case DW_TAG_set_type
: return "DW_TAG_set_type";
6720 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6721 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6722 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6723 case DW_TAG_base_type
: return "DW_TAG_base_type";
6724 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6725 case DW_TAG_const_type
: return "DW_TAG_const_type";
6726 case DW_TAG_constant
: return "DW_TAG_constant";
6727 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6728 case DW_TAG_file_type
: return "DW_TAG_file_type";
6729 case DW_TAG_friend
: return "DW_TAG_friend";
6730 case DW_TAG_namelist
: return "DW_TAG_namelist";
6731 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6732 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6733 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6734 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6735 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6736 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6737 case DW_TAG_try_block
: return "DW_TAG_try_block";
6738 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6739 case DW_TAG_variable
: return "DW_TAG_variable";
6740 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6741 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6742 case DW_TAG_format_label
: return "DW_TAG_format_label";
6743 case DW_TAG_function_template
: return "DW_TAG_function_template";
6744 case DW_TAG_class_template
: return "DW_TAG_class_template";
6745 /* DWARF 2.1 values. */
6746 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6747 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6748 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6749 case DW_TAG_namespace
: return "DW_TAG_namespace";
6750 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6751 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6752 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6753 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6755 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
6756 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
6757 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
6760 static char buffer
[100];
6762 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6769 get_AT_name (attribute
)
6770 unsigned long attribute
;
6774 case DW_AT_sibling
: return "DW_AT_sibling";
6775 case DW_AT_location
: return "DW_AT_location";
6776 case DW_AT_name
: return "DW_AT_name";
6777 case DW_AT_ordering
: return "DW_AT_ordering";
6778 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6779 case DW_AT_byte_size
: return "DW_AT_byte_size";
6780 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6781 case DW_AT_bit_size
: return "DW_AT_bit_size";
6782 case DW_AT_element_list
: return "DW_AT_element_list";
6783 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6784 case DW_AT_low_pc
: return "DW_AT_low_pc";
6785 case DW_AT_high_pc
: return "DW_AT_high_pc";
6786 case DW_AT_language
: return "DW_AT_language";
6787 case DW_AT_member
: return "DW_AT_member";
6788 case DW_AT_discr
: return "DW_AT_discr";
6789 case DW_AT_discr_value
: return "DW_AT_discr_value";
6790 case DW_AT_visibility
: return "DW_AT_visibility";
6791 case DW_AT_import
: return "DW_AT_import";
6792 case DW_AT_string_length
: return "DW_AT_string_length";
6793 case DW_AT_common_reference
: return "DW_AT_common_reference";
6794 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6795 case DW_AT_const_value
: return "DW_AT_const_value";
6796 case DW_AT_containing_type
: return "DW_AT_containing_type";
6797 case DW_AT_default_value
: return "DW_AT_default_value";
6798 case DW_AT_inline
: return "DW_AT_inline";
6799 case DW_AT_is_optional
: return "DW_AT_is_optional";
6800 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6801 case DW_AT_producer
: return "DW_AT_producer";
6802 case DW_AT_prototyped
: return "DW_AT_prototyped";
6803 case DW_AT_return_addr
: return "DW_AT_return_addr";
6804 case DW_AT_start_scope
: return "DW_AT_start_scope";
6805 case DW_AT_stride_size
: return "DW_AT_stride_size";
6806 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6807 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6808 case DW_AT_accessibility
: return "DW_AT_accessibility";
6809 case DW_AT_address_class
: return "DW_AT_address_class";
6810 case DW_AT_artificial
: return "DW_AT_artificial";
6811 case DW_AT_base_types
: return "DW_AT_base_types";
6812 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6813 case DW_AT_count
: return "DW_AT_count";
6814 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6815 case DW_AT_decl_column
: return "DW_AT_decl_column";
6816 case DW_AT_decl_file
: return "DW_AT_decl_file";
6817 case DW_AT_decl_line
: return "DW_AT_decl_line";
6818 case DW_AT_declaration
: return "DW_AT_declaration";
6819 case DW_AT_discr_list
: return "DW_AT_discr_list";
6820 case DW_AT_encoding
: return "DW_AT_encoding";
6821 case DW_AT_external
: return "DW_AT_external";
6822 case DW_AT_frame_base
: return "DW_AT_frame_base";
6823 case DW_AT_friend
: return "DW_AT_friend";
6824 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6825 case DW_AT_macro_info
: return "DW_AT_macro_info";
6826 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6827 case DW_AT_priority
: return "DW_AT_priority";
6828 case DW_AT_segment
: return "DW_AT_segment";
6829 case DW_AT_specification
: return "DW_AT_specification";
6830 case DW_AT_static_link
: return "DW_AT_static_link";
6831 case DW_AT_type
: return "DW_AT_type";
6832 case DW_AT_use_location
: return "DW_AT_use_location";
6833 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6834 case DW_AT_virtuality
: return "DW_AT_virtuality";
6835 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6836 /* DWARF 2.1 values. */
6837 case DW_AT_allocated
: return "DW_AT_allocated";
6838 case DW_AT_associated
: return "DW_AT_associated";
6839 case DW_AT_data_location
: return "DW_AT_data_location";
6840 case DW_AT_stride
: return "DW_AT_stride";
6841 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6842 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6843 case DW_AT_extension
: return "DW_AT_extension";
6844 case DW_AT_ranges
: return "DW_AT_ranges";
6845 case DW_AT_trampoline
: return "DW_AT_trampoline";
6846 case DW_AT_call_column
: return "DW_AT_call_column";
6847 case DW_AT_call_file
: return "DW_AT_call_file";
6848 case DW_AT_call_line
: return "DW_AT_call_line";
6849 /* SGI/MIPS extensions. */
6850 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6851 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6852 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6853 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6854 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6855 case DW_AT_MIPS_software_pipeline_depth
:
6856 return "DW_AT_MIPS_software_pipeline_depth";
6857 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6858 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6859 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6860 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6861 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6862 /* GNU extensions. */
6863 case DW_AT_sf_names
: return "DW_AT_sf_names";
6864 case DW_AT_src_info
: return "DW_AT_src_info";
6865 case DW_AT_mac_info
: return "DW_AT_mac_info";
6866 case DW_AT_src_coords
: return "DW_AT_src_coords";
6867 case DW_AT_body_begin
: return "DW_AT_body_begin";
6868 case DW_AT_body_end
: return "DW_AT_body_end";
6869 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6870 /* UPC extension. */
6871 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
6874 static char buffer
[100];
6876 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6883 get_FORM_name (form
)
6888 case DW_FORM_addr
: return "DW_FORM_addr";
6889 case DW_FORM_block2
: return "DW_FORM_block2";
6890 case DW_FORM_block4
: return "DW_FORM_block4";
6891 case DW_FORM_data2
: return "DW_FORM_data2";
6892 case DW_FORM_data4
: return "DW_FORM_data4";
6893 case DW_FORM_data8
: return "DW_FORM_data8";
6894 case DW_FORM_string
: return "DW_FORM_string";
6895 case DW_FORM_block
: return "DW_FORM_block";
6896 case DW_FORM_block1
: return "DW_FORM_block1";
6897 case DW_FORM_data1
: return "DW_FORM_data1";
6898 case DW_FORM_flag
: return "DW_FORM_flag";
6899 case DW_FORM_sdata
: return "DW_FORM_sdata";
6900 case DW_FORM_strp
: return "DW_FORM_strp";
6901 case DW_FORM_udata
: return "DW_FORM_udata";
6902 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6903 case DW_FORM_ref1
: return "DW_FORM_ref1";
6904 case DW_FORM_ref2
: return "DW_FORM_ref2";
6905 case DW_FORM_ref4
: return "DW_FORM_ref4";
6906 case DW_FORM_ref8
: return "DW_FORM_ref8";
6907 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6908 case DW_FORM_indirect
: return "DW_FORM_indirect";
6911 static char buffer
[100];
6913 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6919 /* FIXME: There are better and more effiecint ways to handle
6920 these structures. For now though, I just want something that
6921 is simple to implement. */
6922 typedef struct abbrev_attr
6924 unsigned long attribute
;
6926 struct abbrev_attr
*next
;
6930 typedef struct abbrev_entry
6932 unsigned long entry
;
6935 struct abbrev_attr
*first_attr
;
6936 struct abbrev_attr
*last_attr
;
6937 struct abbrev_entry
*next
;
6941 static abbrev_entry
*first_abbrev
= NULL
;
6942 static abbrev_entry
*last_abbrev
= NULL
;
6947 abbrev_entry
*abbrev
;
6949 for (abbrev
= first_abbrev
; abbrev
;)
6951 abbrev_entry
*next
= abbrev
->next
;
6954 for (attr
= abbrev
->first_attr
; attr
;)
6956 abbrev_attr
*next
= attr
->next
;
6966 last_abbrev
= first_abbrev
= NULL
;
6970 add_abbrev (number
, tag
, children
)
6971 unsigned long number
;
6975 abbrev_entry
*entry
;
6977 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
6983 entry
->entry
= number
;
6985 entry
->children
= children
;
6986 entry
->first_attr
= NULL
;
6987 entry
->last_attr
= NULL
;
6990 if (first_abbrev
== NULL
)
6991 first_abbrev
= entry
;
6993 last_abbrev
->next
= entry
;
6995 last_abbrev
= entry
;
6999 add_abbrev_attr (attribute
, form
)
7000 unsigned long attribute
;
7005 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
7011 attr
->attribute
= attribute
;
7015 if (last_abbrev
->first_attr
== NULL
)
7016 last_abbrev
->first_attr
= attr
;
7018 last_abbrev
->last_attr
->next
= attr
;
7020 last_abbrev
->last_attr
= attr
;
7023 /* Processes the (partial) contents of a .debug_abbrev section.
7024 Returns NULL if the end of the section was encountered.
7025 Returns the address after the last byte read if the end of
7026 an abbreviation set was found. */
7028 static unsigned char *
7029 process_abbrev_section (start
, end
)
7030 unsigned char *start
;
7033 if (first_abbrev
!= NULL
)
7039 unsigned long entry
;
7041 unsigned long attribute
;
7044 entry
= read_leb128 (start
, & bytes_read
, 0);
7045 start
+= bytes_read
;
7047 /* A single zero is supposed to end the section according
7048 to the standard. If there's more, then signal that to
7051 return start
== end
? NULL
: start
;
7053 tag
= read_leb128 (start
, & bytes_read
, 0);
7054 start
+= bytes_read
;
7056 children
= *start
++;
7058 add_abbrev (entry
, tag
, children
);
7064 attribute
= read_leb128 (start
, & bytes_read
, 0);
7065 start
+= bytes_read
;
7067 form
= read_leb128 (start
, & bytes_read
, 0);
7068 start
+= bytes_read
;
7071 add_abbrev_attr (attribute
, form
);
7073 while (attribute
!= 0);
7081 display_debug_macinfo (section
, start
, file
)
7082 Elf_Internal_Shdr
*section
;
7083 unsigned char *start
;
7084 FILE *file ATTRIBUTE_UNUSED
;
7086 unsigned char *end
= start
+ section
->sh_size
;
7087 unsigned char *curr
= start
;
7088 unsigned int bytes_read
;
7089 enum dwarf_macinfo_record_type op
;
7091 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7095 unsigned int lineno
;
7103 case DW_MACINFO_start_file
:
7105 unsigned int filenum
;
7107 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7109 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7112 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7116 case DW_MACINFO_end_file
:
7117 printf (_(" DW_MACINFO_end_file\n"));
7120 case DW_MACINFO_define
:
7121 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7124 curr
+= strlen (string
) + 1;
7125 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7128 case DW_MACINFO_undef
:
7129 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7132 curr
+= strlen (string
) + 1;
7133 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7136 case DW_MACINFO_vendor_ext
:
7138 unsigned int constant
;
7140 constant
= read_leb128 (curr
, & bytes_read
, 0);
7143 curr
+= strlen (string
) + 1;
7144 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7155 display_debug_abbrev (section
, start
, file
)
7156 Elf_Internal_Shdr
*section
;
7157 unsigned char *start
;
7158 FILE *file ATTRIBUTE_UNUSED
;
7160 abbrev_entry
*entry
;
7161 unsigned char *end
= start
+ section
->sh_size
;
7163 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7167 start
= process_abbrev_section (start
, end
);
7169 if (first_abbrev
== NULL
)
7172 printf (_(" Number TAG\n"));
7174 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7178 printf (_(" %ld %s [%s]\n"),
7180 get_TAG_name (entry
->tag
),
7181 entry
->children
? _("has children") : _("no children"));
7183 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7185 printf (_(" %-18s %s\n"),
7186 get_AT_name (attr
->attribute
),
7187 get_FORM_name (attr
->form
));
7201 static unsigned char *
7202 display_block (data
, length
)
7203 unsigned char *data
;
7204 unsigned long length
;
7206 printf (_(" %lu byte block: "), length
);
7209 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7215 decode_location_expression (data
, pointer_size
, length
)
7216 unsigned char * data
;
7217 unsigned int pointer_size
;
7218 unsigned long length
;
7222 unsigned long uvalue
;
7223 unsigned char *end
= data
+ length
;
7232 printf ("DW_OP_addr: %lx",
7233 (unsigned long) byte_get (data
, pointer_size
));
7234 data
+= pointer_size
;
7237 printf ("DW_OP_deref");
7240 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7243 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7246 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7250 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7254 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7258 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7262 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7263 (unsigned long) byte_get (data
+ 4, 4));
7267 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7268 (long) byte_get (data
+ 4, 4));
7272 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7276 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7280 printf ("DW_OP_dup");
7283 printf ("DW_OP_drop");
7286 printf ("DW_OP_over");
7289 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7292 printf ("DW_OP_swap");
7295 printf ("DW_OP_rot");
7298 printf ("DW_OP_xderef");
7301 printf ("DW_OP_abs");
7304 printf ("DW_OP_and");
7307 printf ("DW_OP_div");
7310 printf ("DW_OP_minus");
7313 printf ("DW_OP_mod");
7316 printf ("DW_OP_mul");
7319 printf ("DW_OP_neg");
7322 printf ("DW_OP_not");
7325 printf ("DW_OP_or");
7328 printf ("DW_OP_plus");
7330 case DW_OP_plus_uconst
:
7331 printf ("DW_OP_plus_uconst: %lu",
7332 read_leb128 (data
, &bytes_read
, 0));
7336 printf ("DW_OP_shl");
7339 printf ("DW_OP_shr");
7342 printf ("DW_OP_shra");
7345 printf ("DW_OP_xor");
7348 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7352 printf ("DW_OP_eq");
7355 printf ("DW_OP_ge");
7358 printf ("DW_OP_gt");
7361 printf ("DW_OP_le");
7364 printf ("DW_OP_lt");
7367 printf ("DW_OP_ne");
7370 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7406 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7441 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7476 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7477 read_leb128 (data
, &bytes_read
, 1));
7482 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7486 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7490 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7492 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7493 read_leb128 (data
, &bytes_read
, 1));
7497 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7500 case DW_OP_deref_size
:
7501 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7503 case DW_OP_xderef_size
:
7504 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7507 printf ("DW_OP_nop");
7510 /* DWARF 3 extensions. */
7511 case DW_OP_push_object_address
:
7512 printf ("DW_OP_push_object_address");
7515 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7519 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7522 case DW_OP_call_ref
:
7523 printf ("DW_OP_call_ref");
7526 /* GNU extensions. */
7527 case DW_OP_GNU_push_tls_address
:
7528 printf ("DW_OP_GNU_push_tls_address");
7532 if (op
>= DW_OP_lo_user
7533 && op
<= DW_OP_hi_user
)
7534 printf (_("(User defined location op)"));
7536 printf (_("(Unknown location op)"));
7537 /* No way to tell where the next op is, so just bail. */
7541 /* Separate the ops. */
7546 static const char *debug_loc_contents
;
7547 static bfd_vma debug_loc_size
;
7550 load_debug_loc (file
)
7553 Elf_Internal_Shdr
*sec
;
7556 /* If it is already loaded, do nothing. */
7557 if (debug_loc_contents
!= NULL
)
7560 /* Locate the .debug_loc section. */
7561 for (i
= 0, sec
= section_headers
;
7562 i
< elf_header
.e_shnum
;
7564 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7567 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7570 debug_loc_size
= sec
->sh_size
;
7572 debug_loc_contents
= ((char *)
7573 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7574 _("debug_loc section data")));
7580 if (debug_loc_contents
== NULL
)
7583 free ((char *) debug_loc_contents
);
7584 debug_loc_contents
= NULL
;
7590 display_debug_loc (section
, start
, file
)
7591 Elf_Internal_Shdr
*section
;
7592 unsigned char *start
;
7593 FILE *file ATTRIBUTE_UNUSED
;
7595 unsigned char *section_end
;
7596 unsigned long bytes
;
7597 unsigned char *section_begin
= start
;
7600 addr
= section
->sh_addr
;
7601 bytes
= section
->sh_size
;
7602 section_end
= start
+ bytes
;
7606 printf (_("\nThe .debug_loc section is empty.\n"));
7610 printf (_("Contents of the .debug_loc section:\n\n"));
7611 printf (_("\n Offset Begin End Expression\n"));
7613 while (start
< section_end
)
7615 unsigned long begin
;
7617 unsigned short length
;
7618 unsigned long offset
;
7620 offset
= start
- section_begin
;
7624 /* Normally, the lists in the debug_loc section are related to a
7625 given compilation unit, and thus, we would use the
7626 pointer size of that compilation unit. However, since we are
7627 displaying it seperately here, we either have to store
7628 pointer sizes of all compilation units, or assume they don't
7629 change. We assume, like the debug_line display, that
7630 it doesn't change. */
7631 begin
= byte_get (start
, debug_line_pointer_size
);
7632 start
+= debug_line_pointer_size
;
7633 end
= byte_get (start
, debug_line_pointer_size
);
7634 start
+= debug_line_pointer_size
;
7636 if (begin
== 0 && end
== 0)
7642 length
= byte_get (start
, 2);
7645 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7646 decode_location_expression (start
, debug_line_pointer_size
, length
);
7656 static const char *debug_str_contents
;
7657 static bfd_vma debug_str_size
;
7660 load_debug_str (file
)
7663 Elf_Internal_Shdr
*sec
;
7666 /* If it is already loaded, do nothing. */
7667 if (debug_str_contents
!= NULL
)
7670 /* Locate the .debug_str section. */
7671 for (i
= 0, sec
= section_headers
;
7672 i
< elf_header
.e_shnum
;
7674 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7677 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7680 debug_str_size
= sec
->sh_size
;
7682 debug_str_contents
= ((char *)
7683 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7684 _("debug_str section data")));
7690 if (debug_str_contents
== NULL
)
7693 free ((char *) debug_str_contents
);
7694 debug_str_contents
= NULL
;
7699 fetch_indirect_string (offset
)
7700 unsigned long offset
;
7702 if (debug_str_contents
== NULL
)
7703 return _("<no .debug_str section>");
7705 if (offset
> debug_str_size
)
7706 return _("<offset is too big>");
7708 return debug_str_contents
+ offset
;
7712 display_debug_str (section
, start
, file
)
7713 Elf_Internal_Shdr
*section
;
7714 unsigned char *start
;
7715 FILE *file ATTRIBUTE_UNUSED
;
7717 unsigned long bytes
;
7720 addr
= section
->sh_addr
;
7721 bytes
= section
->sh_size
;
7725 printf (_("\nThe .debug_str section is empty.\n"));
7729 printf (_("Contents of the .debug_str section:\n\n"));
7737 lbytes
= (bytes
> 16 ? 16 : bytes
);
7739 printf (" 0x%8.8lx ", (unsigned long) addr
);
7741 for (j
= 0; j
< 16; j
++)
7744 printf ("%2.2x", start
[j
]);
7752 for (j
= 0; j
< lbytes
; j
++)
7755 if (k
>= ' ' && k
< 0x80)
7771 static unsigned char *
7772 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7773 unsigned long attribute
;
7775 unsigned char *data
;
7776 unsigned long cu_offset
;
7777 unsigned long pointer_size
;
7779 unsigned long uvalue
= 0;
7780 unsigned char *block_start
= NULL
;
7788 case DW_FORM_ref_addr
:
7790 uvalue
= byte_get (data
, pointer_size
);
7791 data
+= pointer_size
;
7795 uvalue
= byte_get (data
, /* offset_size */ 4);
7796 data
+= /* offset_size */ 4;
7802 uvalue
= byte_get (data
++, 1);
7807 uvalue
= byte_get (data
, 2);
7813 uvalue
= byte_get (data
, 4);
7818 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7822 case DW_FORM_ref_udata
:
7824 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7828 case DW_FORM_indirect
:
7829 form
= read_leb128 (data
, & bytes_read
, 0);
7831 printf (" %s", get_FORM_name (form
));
7832 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7838 case DW_FORM_ref_addr
:
7839 printf (" <#%lx>", uvalue
);
7845 case DW_FORM_ref_udata
:
7846 printf (" <%lx>", uvalue
+ cu_offset
);
7850 printf (" %#lx", uvalue
);
7858 printf (" %ld", uvalue
);
7863 uvalue
= byte_get (data
, 4);
7864 printf (" %lx", uvalue
);
7865 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7869 case DW_FORM_string
:
7870 printf (" %s", data
);
7871 data
+= strlen ((char *) data
) + 1;
7875 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7876 block_start
= data
+ bytes_read
;
7877 data
= display_block (block_start
, uvalue
);
7880 case DW_FORM_block1
:
7881 uvalue
= byte_get (data
, 1);
7882 block_start
= data
+ 1;
7883 data
= display_block (block_start
, uvalue
);
7886 case DW_FORM_block2
:
7887 uvalue
= byte_get (data
, 2);
7888 block_start
= data
+ 2;
7889 data
= display_block (block_start
, uvalue
);
7892 case DW_FORM_block4
:
7893 uvalue
= byte_get (data
, 4);
7894 block_start
= data
+ 4;
7895 data
= display_block (block_start
, uvalue
);
7899 printf (_(" (indirect string, offset: 0x%lx): %s"),
7900 uvalue
, fetch_indirect_string (uvalue
));
7903 case DW_FORM_indirect
:
7904 /* Handled above. */
7908 warn (_("Unrecognized form: %d\n"), form
);
7912 /* For some attributes we can display futher information. */
7921 case DW_INL_not_inlined
:
7922 printf (_("(not inlined)"));
7924 case DW_INL_inlined
:
7925 printf (_("(inlined)"));
7927 case DW_INL_declared_not_inlined
:
7928 printf (_("(declared as inline but ignored)"));
7930 case DW_INL_declared_inlined
:
7931 printf (_("(declared as inline and inlined)"));
7934 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
7939 case DW_AT_language
:
7942 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7943 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7944 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7945 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7946 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7947 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7948 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7949 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7950 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7951 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7952 /* DWARF 2.1 values. */
7953 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7954 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7955 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7956 /* MIPS extension. */
7957 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7958 /* UPC extension. */
7959 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
7961 printf ("(Unknown: %lx)", uvalue
);
7966 case DW_AT_encoding
:
7969 case DW_ATE_void
: printf ("(void)"); break;
7970 case DW_ATE_address
: printf ("(machine address)"); break;
7971 case DW_ATE_boolean
: printf ("(boolean)"); break;
7972 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7973 case DW_ATE_float
: printf ("(float)"); break;
7974 case DW_ATE_signed
: printf ("(signed)"); break;
7975 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7976 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7977 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7978 /* DWARF 2.1 value. */
7979 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7981 if (uvalue
>= DW_ATE_lo_user
7982 && uvalue
<= DW_ATE_hi_user
)
7983 printf ("(user defined type)");
7985 printf ("(unknown type)");
7990 case DW_AT_accessibility
:
7993 case DW_ACCESS_public
: printf ("(public)"); break;
7994 case DW_ACCESS_protected
: printf ("(protected)"); break;
7995 case DW_ACCESS_private
: printf ("(private)"); break;
7997 printf ("(unknown accessibility)");
8002 case DW_AT_visibility
:
8005 case DW_VIS_local
: printf ("(local)"); break;
8006 case DW_VIS_exported
: printf ("(exported)"); break;
8007 case DW_VIS_qualified
: printf ("(qualified)"); break;
8008 default: printf ("(unknown visibility)"); break;
8012 case DW_AT_virtuality
:
8015 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8016 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8017 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8018 default: printf ("(unknown virtuality)"); break;
8022 case DW_AT_identifier_case
:
8025 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8026 case DW_ID_up_case
: printf ("(up_case)"); break;
8027 case DW_ID_down_case
: printf ("(down_case)"); break;
8028 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8029 default: printf ("(unknown case)"); break;
8033 case DW_AT_calling_convention
:
8036 case DW_CC_normal
: printf ("(normal)"); break;
8037 case DW_CC_program
: printf ("(program)"); break;
8038 case DW_CC_nocall
: printf ("(nocall)"); break;
8040 if (uvalue
>= DW_CC_lo_user
8041 && uvalue
<= DW_CC_hi_user
)
8042 printf ("(user defined)");
8044 printf ("(unknown convention)");
8048 case DW_AT_ordering
:
8051 case -1: printf ("(undefined)"); break;
8052 case 0: printf ("(row major)"); break;
8053 case 1: printf ("(column major)"); break;
8057 case DW_AT_frame_base
:
8058 case DW_AT_location
:
8059 case DW_AT_data_member_location
:
8060 case DW_AT_vtable_elem_location
:
8061 case DW_AT_allocated
:
8062 case DW_AT_associated
:
8063 case DW_AT_data_location
:
8065 case DW_AT_upper_bound
:
8066 case DW_AT_lower_bound
:
8070 decode_location_expression (block_start
, pointer_size
, uvalue
);
8073 else if (form
== DW_FORM_data4
)
8076 printf ("location list");
8088 static unsigned char *
8089 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
8090 unsigned long attribute
;
8092 unsigned char *data
;
8093 unsigned long cu_offset
;
8094 unsigned long pointer_size
;
8096 printf (" %-18s:", get_AT_name (attribute
));
8097 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8104 display_debug_info (section
, start
, file
)
8105 Elf_Internal_Shdr
*section
;
8106 unsigned char *start
;
8109 unsigned char *end
= start
+ section
->sh_size
;
8110 unsigned char *section_begin
= start
;
8112 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8114 load_debug_str (file
);
8115 load_debug_loc (file
);
8119 DWARF2_External_CompUnit
*external
;
8120 DWARF2_Internal_CompUnit compunit
;
8121 Elf_Internal_Shdr
*relsec
;
8122 unsigned char *tags
;
8125 unsigned long cu_offset
;
8127 external
= (DWARF2_External_CompUnit
*) start
;
8129 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
8130 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
8131 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
8132 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8134 if (compunit
.cu_length
== 0xffffffff)
8136 warn (_("64-bit DWARF debug info is not supported yet.\n"));
8140 /* Check for RELA relocations in the
8141 abbrev_offset address, and apply them. */
8142 for (relsec
= section_headers
;
8143 relsec
< section_headers
+ elf_header
.e_shnum
;
8146 unsigned long nrelas
;
8147 Elf_Internal_Rela
*rela
, *rp
;
8148 Elf_Internal_Shdr
*symsec
;
8149 Elf_Internal_Sym
*symtab
;
8150 Elf_Internal_Sym
*sym
;
8152 if (relsec
->sh_type
!= SHT_RELA
8153 || SECTION_HEADER (relsec
->sh_info
) != section
8154 || relsec
->sh_size
== 0)
8157 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8161 symsec
= SECTION_HEADER (relsec
->sh_link
);
8162 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8164 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8167 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
8173 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8175 if (ELF32_R_SYM (rp
->r_info
) != 0
8176 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8178 warn (_("Skipping unexpected symbol type %u\n"),
8179 ELF32_ST_TYPE (sym
->st_info
));
8185 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8187 if (ELF64_R_SYM (rp
->r_info
) != 0
8188 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8190 warn (_("Skipping unexpected symbol type %u\n"),
8191 ELF64_ST_TYPE (sym
->st_info
));
8196 compunit
.cu_abbrev_offset
= rp
->r_addend
;
8204 tags
= start
+ sizeof (*external
);
8205 cu_offset
= start
- section_begin
;
8206 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
8208 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8209 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8210 printf (_(" Version: %d\n"), compunit
.cu_version
);
8211 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8212 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8214 if (compunit
.cu_version
!= 2)
8216 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8222 /* Read in the abbrevs used by this compilation unit. */
8224 Elf_Internal_Shdr
*sec
;
8225 unsigned char *begin
;
8227 /* Locate the .debug_abbrev section and process it. */
8228 for (i
= 0, sec
= section_headers
;
8229 i
< elf_header
.e_shnum
;
8231 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
8234 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
8236 warn (_("Unable to locate .debug_abbrev section!\n"));
8240 begin
= ((unsigned char *)
8241 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8242 _("debug_abbrev section data")));
8246 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8247 begin
+ sec
->sh_size
);
8253 while (tags
< start
)
8256 unsigned long abbrev_number
;
8257 abbrev_entry
*entry
;
8260 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8263 /* A null DIE marks the end of a list of children. */
8264 if (abbrev_number
== 0)
8270 /* Scan through the abbreviation list until we reach the
8272 for (entry
= first_abbrev
;
8273 entry
&& entry
->entry
!= abbrev_number
;
8274 entry
= entry
->next
)
8279 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8284 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8286 (unsigned long) (tags
- section_begin
- bytes_read
),
8288 get_TAG_name (entry
->tag
));
8290 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8291 tags
= read_and_display_attr (attr
->attribute
,
8294 compunit
.cu_pointer_size
);
8296 if (entry
->children
)
8310 display_debug_aranges (section
, start
, file
)
8311 Elf_Internal_Shdr
*section
;
8312 unsigned char *start
;
8313 FILE *file ATTRIBUTE_UNUSED
;
8315 unsigned char *end
= start
+ section
->sh_size
;
8317 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8321 DWARF2_External_ARange
*external
;
8322 DWARF2_Internal_ARange arange
;
8323 unsigned char *ranges
;
8324 unsigned long length
;
8325 unsigned long address
;
8328 external
= (DWARF2_External_ARange
*) start
;
8330 arange
.ar_length
= BYTE_GET (external
->ar_length
);
8331 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8332 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8333 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8334 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8336 if (arange
.ar_length
== 0xffffffff)
8338 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8342 if (arange
.ar_version
!= 2)
8344 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8348 printf (_(" Length: %ld\n"), arange
.ar_length
);
8349 printf (_(" Version: %d\n"), arange
.ar_version
);
8350 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8351 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8352 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8354 printf (_("\n Address Length\n"));
8356 ranges
= start
+ sizeof (*external
);
8358 /* Must pad to an alignment boundary that is twice the pointer size. */
8359 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
8361 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8365 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8367 ranges
+= arange
.ar_pointer_size
;
8369 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8371 ranges
+= arange
.ar_pointer_size
;
8373 /* A pair of zeros marks the end of the list. */
8374 if (address
== 0 && length
== 0)
8377 printf (" %8.8lx %lu\n", address
, length
);
8380 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8388 typedef struct Frame_Chunk
8390 struct Frame_Chunk
*next
;
8391 unsigned char *chunk_start
;
8393 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8394 short int *col_type
;
8397 unsigned int code_factor
;
8399 unsigned long pc_begin
;
8400 unsigned long pc_range
;
8404 unsigned char fde_encoding
;
8408 /* A marker for a col_type that means this column was never referenced
8409 in the frame info. */
8410 #define DW_CFA_unreferenced (-1)
8412 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8413 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8414 static int size_of_encoded_value
PARAMS ((int));
8417 frame_need_space (fc
, reg
)
8421 int prev
= fc
->ncols
;
8423 if (reg
< fc
->ncols
)
8426 fc
->ncols
= reg
+ 1;
8427 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8428 fc
->ncols
* sizeof (short int));
8429 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8430 fc
->ncols
* sizeof (int));
8432 while (prev
< fc
->ncols
)
8434 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8435 fc
->col_offset
[prev
] = 0;
8441 frame_display_row (fc
, need_col_headers
, max_regs
)
8443 int *need_col_headers
;
8449 if (*max_regs
< fc
->ncols
)
8450 *max_regs
= fc
->ncols
;
8452 if (*need_col_headers
)
8454 *need_col_headers
= 0;
8456 printf (" LOC CFA ");
8458 for (r
= 0; r
< *max_regs
; r
++)
8459 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8464 printf ("r%-4d", r
);
8470 printf ("%08lx ", fc
->pc_begin
);
8471 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8472 printf ("%-8s ", tmp
);
8474 for (r
= 0; r
< fc
->ncols
; r
++)
8476 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8478 switch (fc
->col_type
[r
])
8480 case DW_CFA_undefined
:
8483 case DW_CFA_same_value
:
8487 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8489 case DW_CFA_register
:
8490 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8493 strcpy (tmp
, "n/a");
8496 printf ("%-5s", tmp
);
8503 size_of_encoded_value (encoding
)
8506 switch (encoding
& 0x7)
8509 case 0: return is_32bit_elf
? 4 : 8;
8516 #define GET(N) byte_get (start, N); start += N
8517 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8518 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8521 display_debug_frames (section
, start
, file
)
8522 Elf_Internal_Shdr
*section
;
8523 unsigned char *start
;
8524 FILE *file ATTRIBUTE_UNUSED
;
8526 unsigned char *end
= start
+ section
->sh_size
;
8527 unsigned char *section_start
= start
;
8528 Frame_Chunk
*chunks
= 0;
8529 Frame_Chunk
*remembered_state
= 0;
8531 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8534 int addr_size
= is_32bit_elf
? 4 : 8;
8536 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8540 unsigned char *saved_start
;
8541 unsigned char *block_end
;
8542 unsigned long length
;
8543 unsigned long cie_id
;
8546 int need_col_headers
= 1;
8547 unsigned char *augmentation_data
= NULL
;
8548 unsigned long augmentation_data_len
= 0;
8549 int encoded_ptr_size
= addr_size
;
8551 saved_start
= start
;
8552 length
= byte_get (start
, 4); start
+= 4;
8556 printf ("\n%08lx ZERO terminator\n\n",
8557 (unsigned long)(saved_start
- section_start
));
8561 if (length
== 0xffffffff)
8563 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8567 block_end
= saved_start
+ length
+ 4;
8568 cie_id
= byte_get (start
, 4); start
+= 4;
8570 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8574 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8575 memset (fc
, 0, sizeof (Frame_Chunk
));
8579 fc
->chunk_start
= saved_start
;
8581 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8582 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8583 frame_need_space (fc
, max_regs
-1);
8587 fc
->augmentation
= start
;
8588 start
= strchr (start
, '\0') + 1;
8590 if (fc
->augmentation
[0] == 'z')
8592 fc
->code_factor
= LEB ();
8593 fc
->data_factor
= SLEB ();
8594 fc
->ra
= byte_get (start
, 1); start
+= 1;
8595 augmentation_data_len
= LEB ();
8596 augmentation_data
= start
;
8597 start
+= augmentation_data_len
;
8599 else if (strcmp (fc
->augmentation
, "eh") == 0)
8602 fc
->code_factor
= LEB ();
8603 fc
->data_factor
= SLEB ();
8604 fc
->ra
= byte_get (start
, 1); start
+= 1;
8608 fc
->code_factor
= LEB ();
8609 fc
->data_factor
= SLEB ();
8610 fc
->ra
= byte_get (start
, 1); start
+= 1;
8614 if (do_debug_frames_interp
)
8615 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8616 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8617 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8621 printf ("\n%08lx %08lx %08lx CIE\n",
8622 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8623 printf (" Version: %d\n", version
);
8624 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8625 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8626 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8627 printf (" Return address column: %d\n", fc
->ra
);
8629 if (augmentation_data_len
)
8632 printf (" Augmentation data: ");
8633 for (i
= 0; i
< augmentation_data_len
; ++i
)
8634 printf (" %02x", augmentation_data
[i
]);
8640 if (augmentation_data_len
)
8642 unsigned char *p
, *q
;
8643 p
= fc
->augmentation
+ 1;
8644 q
= augmentation_data
;
8651 q
+= 1 + size_of_encoded_value (*q
);
8653 fc
->fde_encoding
= *q
++;
8659 if (fc
->fde_encoding
)
8660 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8663 frame_need_space (fc
, fc
->ra
);
8667 unsigned char *look_for
;
8668 static Frame_Chunk fde_fc
;
8671 memset (fc
, 0, sizeof (Frame_Chunk
));
8673 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8675 for (cie
= chunks
; cie
; cie
= cie
->next
)
8676 if (cie
->chunk_start
== look_for
)
8681 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8682 cie_id
, saved_start
);
8685 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8686 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8687 frame_need_space (fc
, max_regs
- 1);
8689 fc
->augmentation
= "";
8690 fc
->fde_encoding
= 0;
8694 fc
->ncols
= cie
->ncols
;
8695 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8696 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8697 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8698 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8699 fc
->augmentation
= cie
->augmentation
;
8700 fc
->code_factor
= cie
->code_factor
;
8701 fc
->data_factor
= cie
->data_factor
;
8702 fc
->cfa_reg
= cie
->cfa_reg
;
8703 fc
->cfa_offset
= cie
->cfa_offset
;
8705 frame_need_space (fc
, max_regs
-1);
8706 fc
->fde_encoding
= cie
->fde_encoding
;
8709 if (fc
->fde_encoding
)
8710 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8712 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8713 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8714 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
8715 start
+= encoded_ptr_size
;
8716 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8717 start
+= encoded_ptr_size
;
8719 if (cie
->augmentation
[0] == 'z')
8721 augmentation_data_len
= LEB ();
8722 augmentation_data
= start
;
8723 start
+= augmentation_data_len
;
8726 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8727 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8728 (unsigned long)(cie
->chunk_start
- section_start
),
8729 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8730 if (! do_debug_frames_interp
&& augmentation_data_len
)
8733 printf (" Augmentation data: ");
8734 for (i
= 0; i
< augmentation_data_len
; ++i
)
8735 printf (" %02x", augmentation_data
[i
]);
8741 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8742 about to interpret instructions for the chunk. */
8744 if (do_debug_frames_interp
)
8746 /* Start by making a pass over the chunk, allocating storage
8747 and taking note of what registers are used. */
8748 unsigned char *tmp
= start
;
8750 while (start
< block_end
)
8760 /* Warning: if you add any more cases to this switch, be
8761 sure to add them to the corresponding switch below. */
8764 case DW_CFA_advance_loc
:
8768 frame_need_space (fc
, opa
);
8769 fc
->col_type
[opa
] = DW_CFA_undefined
;
8771 case DW_CFA_restore
:
8772 frame_need_space (fc
, opa
);
8773 fc
->col_type
[opa
] = DW_CFA_undefined
;
8775 case DW_CFA_set_loc
:
8776 start
+= encoded_ptr_size
;
8778 case DW_CFA_advance_loc1
:
8781 case DW_CFA_advance_loc2
:
8784 case DW_CFA_advance_loc4
:
8787 case DW_CFA_offset_extended
:
8788 reg
= LEB (); LEB ();
8789 frame_need_space (fc
, reg
);
8790 fc
->col_type
[reg
] = DW_CFA_undefined
;
8792 case DW_CFA_restore_extended
:
8794 frame_need_space (fc
, reg
);
8795 fc
->col_type
[reg
] = DW_CFA_undefined
;
8797 case DW_CFA_undefined
:
8799 frame_need_space (fc
, reg
);
8800 fc
->col_type
[reg
] = DW_CFA_undefined
;
8802 case DW_CFA_same_value
:
8804 frame_need_space (fc
, reg
);
8805 fc
->col_type
[reg
] = DW_CFA_undefined
;
8807 case DW_CFA_register
:
8808 reg
= LEB (); LEB ();
8809 frame_need_space (fc
, reg
);
8810 fc
->col_type
[reg
] = DW_CFA_undefined
;
8812 case DW_CFA_def_cfa
:
8815 case DW_CFA_def_cfa_register
:
8818 case DW_CFA_def_cfa_offset
:
8821 case DW_CFA_offset_extended_sf
:
8822 reg
= LEB (); SLEB ();
8823 frame_need_space (fc
, reg
);
8824 fc
->col_type
[reg
] = DW_CFA_undefined
;
8826 case DW_CFA_def_cfa_sf
:
8829 case DW_CFA_def_cfa_offset_sf
:
8832 case DW_CFA_GNU_args_size
:
8835 case DW_CFA_GNU_negative_offset_extended
:
8836 reg
= LEB (); LEB ();
8837 frame_need_space (fc
, reg
);
8838 fc
->col_type
[reg
] = DW_CFA_undefined
;
8847 /* Now we know what registers are used, make a second pass over
8848 the chunk, this time actually printing out the info. */
8850 while (start
< block_end
)
8853 unsigned long ul
, reg
, roffs
;
8862 /* Warning: if you add any more cases to this switch, be
8863 sure to add them to the corresponding switch above. */
8866 case DW_CFA_advance_loc
:
8867 if (do_debug_frames_interp
)
8868 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8870 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8871 opa
* fc
->code_factor
,
8872 fc
->pc_begin
+ opa
* fc
->code_factor
);
8873 fc
->pc_begin
+= opa
* fc
->code_factor
;
8878 if (! do_debug_frames_interp
)
8879 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8880 opa
, roffs
* fc
->data_factor
);
8881 fc
->col_type
[opa
] = DW_CFA_offset
;
8882 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8885 case DW_CFA_restore
:
8886 if (! do_debug_frames_interp
)
8887 printf (" DW_CFA_restore: r%d\n", opa
);
8888 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8889 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8892 case DW_CFA_set_loc
:
8893 vma
= byte_get (start
, encoded_ptr_size
);
8894 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8895 vma
+= section
->sh_addr
+ (start
- section_start
);
8896 start
+= encoded_ptr_size
;
8897 if (do_debug_frames_interp
)
8898 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8900 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8904 case DW_CFA_advance_loc1
:
8905 ofs
= byte_get (start
, 1); start
+= 1;
8906 if (do_debug_frames_interp
)
8907 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8909 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8910 ofs
* fc
->code_factor
,
8911 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8912 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8915 case DW_CFA_advance_loc2
:
8916 ofs
= byte_get (start
, 2); start
+= 2;
8917 if (do_debug_frames_interp
)
8918 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8920 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8921 ofs
* fc
->code_factor
,
8922 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8923 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8926 case DW_CFA_advance_loc4
:
8927 ofs
= byte_get (start
, 4); start
+= 4;
8928 if (do_debug_frames_interp
)
8929 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8931 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8932 ofs
* fc
->code_factor
,
8933 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8934 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8937 case DW_CFA_offset_extended
:
8940 if (! do_debug_frames_interp
)
8941 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8942 reg
, roffs
* fc
->data_factor
);
8943 fc
->col_type
[reg
] = DW_CFA_offset
;
8944 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8947 case DW_CFA_restore_extended
:
8949 if (! do_debug_frames_interp
)
8950 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8951 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8952 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8955 case DW_CFA_undefined
:
8957 if (! do_debug_frames_interp
)
8958 printf (" DW_CFA_undefined: r%ld\n", reg
);
8959 fc
->col_type
[reg
] = DW_CFA_undefined
;
8960 fc
->col_offset
[reg
] = 0;
8963 case DW_CFA_same_value
:
8965 if (! do_debug_frames_interp
)
8966 printf (" DW_CFA_same_value: r%ld\n", reg
);
8967 fc
->col_type
[reg
] = DW_CFA_same_value
;
8968 fc
->col_offset
[reg
] = 0;
8971 case DW_CFA_register
:
8974 if (! do_debug_frames_interp
)
8975 printf (" DW_CFA_register: r%ld\n", reg
);
8976 fc
->col_type
[reg
] = DW_CFA_register
;
8977 fc
->col_offset
[reg
] = roffs
;
8980 case DW_CFA_remember_state
:
8981 if (! do_debug_frames_interp
)
8982 printf (" DW_CFA_remember_state\n");
8983 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8984 rs
->ncols
= fc
->ncols
;
8985 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8986 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8987 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8988 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8989 rs
->next
= remembered_state
;
8990 remembered_state
= rs
;
8993 case DW_CFA_restore_state
:
8994 if (! do_debug_frames_interp
)
8995 printf (" DW_CFA_restore_state\n");
8996 rs
= remembered_state
;
8997 remembered_state
= rs
->next
;
8998 frame_need_space (fc
, rs
->ncols
-1);
8999 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
9000 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
9001 free (rs
->col_type
);
9002 free (rs
->col_offset
);
9006 case DW_CFA_def_cfa
:
9007 fc
->cfa_reg
= LEB ();
9008 fc
->cfa_offset
= LEB ();
9009 if (! do_debug_frames_interp
)
9010 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9011 fc
->cfa_reg
, fc
->cfa_offset
);
9014 case DW_CFA_def_cfa_register
:
9015 fc
->cfa_reg
= LEB ();
9016 if (! do_debug_frames_interp
)
9017 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9020 case DW_CFA_def_cfa_offset
:
9021 fc
->cfa_offset
= LEB ();
9022 if (! do_debug_frames_interp
)
9023 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9027 if (! do_debug_frames_interp
)
9028 printf (" DW_CFA_nop\n");
9031 case DW_CFA_offset_extended_sf
:
9034 frame_need_space (fc
, reg
);
9035 if (! do_debug_frames_interp
)
9036 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9037 reg
, l
* fc
->data_factor
);
9038 fc
->col_type
[reg
] = DW_CFA_offset
;
9039 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9042 case DW_CFA_def_cfa_sf
:
9043 fc
->cfa_reg
= LEB ();
9044 fc
->cfa_offset
= SLEB ();
9045 if (! do_debug_frames_interp
)
9046 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9047 fc
->cfa_reg
, fc
->cfa_offset
);
9050 case DW_CFA_def_cfa_offset_sf
:
9051 fc
->cfa_offset
= SLEB ();
9052 if (! do_debug_frames_interp
)
9053 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9056 case DW_CFA_GNU_window_save
:
9057 if (! do_debug_frames_interp
)
9058 printf (" DW_CFA_GNU_window_save\n");
9061 case DW_CFA_GNU_args_size
:
9063 if (! do_debug_frames_interp
)
9064 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9067 case DW_CFA_GNU_negative_offset_extended
:
9070 frame_need_space (fc
, reg
);
9071 if (! do_debug_frames_interp
)
9072 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9073 reg
, l
* fc
->data_factor
);
9074 fc
->col_type
[reg
] = DW_CFA_offset
;
9075 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9078 /* FIXME: How do we handle these? */
9079 case DW_CFA_def_cfa_expression
:
9080 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
9084 case DW_CFA_expression
:
9085 fprintf (stderr
, "unsupported DW_CFA_expression\n");
9090 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9095 if (do_debug_frames_interp
)
9096 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9111 display_debug_not_supported (section
, start
, file
)
9112 Elf_Internal_Shdr
*section
;
9113 unsigned char *start ATTRIBUTE_UNUSED
;
9114 FILE *file ATTRIBUTE_UNUSED
;
9116 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9117 SECTION_NAME (section
));
9122 /* Pre-scan the .debug_info section to record the size of address.
9123 When dumping the .debug_line, we use that size information, assuming
9124 that all compilation units have the same address size. */
9126 prescan_debug_info (section
, start
, file
)
9127 Elf_Internal_Shdr
*section ATTRIBUTE_UNUSED
;
9128 unsigned char *start
;
9129 FILE *file ATTRIBUTE_UNUSED
;
9131 DWARF2_External_CompUnit
*external
;
9133 external
= (DWARF2_External_CompUnit
*) start
;
9135 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
9139 /* A structure containing the name of a debug section and a pointer
9140 to a function that can decode it. The third field is a prescan
9141 function to be run over the section before displaying any of the
9145 const char *const name
;
9146 int (*display
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
9147 int (*prescan
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
9151 { ".debug_abbrev", display_debug_abbrev
, NULL
},
9152 { ".debug_aranges", display_debug_aranges
, NULL
},
9153 { ".debug_frame", display_debug_frames
, NULL
},
9154 { ".debug_info", display_debug_info
, prescan_debug_info
},
9155 { ".debug_line", display_debug_lines
, NULL
},
9156 { ".debug_pubnames", display_debug_pubnames
, NULL
},
9157 { ".eh_frame", display_debug_frames
, NULL
},
9158 { ".debug_macinfo", display_debug_macinfo
, NULL
},
9159 { ".debug_str", display_debug_str
, NULL
},
9160 { ".debug_loc", display_debug_loc
, NULL
},
9161 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
9162 { ".debug_ranges", display_debug_not_supported
, NULL
},
9163 { ".debug_static_func", display_debug_not_supported
, NULL
},
9164 { ".debug_static_vars", display_debug_not_supported
, NULL
},
9165 { ".debug_types", display_debug_not_supported
, NULL
},
9166 { ".debug_weaknames", display_debug_not_supported
, NULL
}
9170 display_debug_section (section
, file
)
9171 Elf_Internal_Shdr
*section
;
9174 char *name
= SECTION_NAME (section
);
9175 bfd_size_type length
;
9176 unsigned char *start
;
9179 length
= section
->sh_size
;
9182 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9186 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
9187 _("debug section data"));
9191 /* See if we know how to display the contents of this section. */
9192 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9193 name
= ".debug_info";
9195 for (i
= NUM_ELEM (debug_displays
); i
--;)
9196 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9198 debug_displays
[i
].display (section
, start
, file
);
9203 printf (_("Unrecognized debug section: %s\n"), name
);
9207 /* If we loaded in the abbrev section at some point,
9208 we must release it here. */
9215 process_section_contents (file
)
9218 Elf_Internal_Shdr
*section
;
9224 /* Pre-scan the debug sections to find some debug information not
9225 present in some of them. For the .debug_line, we must find out the
9226 size of address (specified in .debug_info and .debug_aranges). */
9227 for (i
= 0, section
= section_headers
;
9228 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9231 char *name
= SECTION_NAME (section
);
9234 if (section
->sh_size
== 0)
9237 /* See if there is some pre-scan operation for this section. */
9238 for (j
= NUM_ELEM (debug_displays
); j
--;)
9239 if (strcmp (debug_displays
[j
].name
, name
) == 0)
9241 if (debug_displays
[j
].prescan
!= NULL
)
9243 bfd_size_type length
;
9244 unsigned char *start
;
9246 length
= section
->sh_size
;
9247 start
= ((unsigned char *)
9248 get_data (NULL
, file
, section
->sh_offset
, length
,
9249 _("debug section data")));
9253 debug_displays
[j
].prescan (section
, start
, file
);
9261 for (i
= 0, section
= section_headers
;
9262 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9265 #ifdef SUPPORT_DISASSEMBLY
9266 if (dump_sects
[i
] & DISASS_DUMP
)
9267 disassemble_section (section
, file
);
9269 if (dump_sects
[i
] & HEX_DUMP
)
9270 dump_section (section
, file
);
9272 if (dump_sects
[i
] & DEBUG_DUMP
)
9273 display_debug_section (section
, file
);
9276 if (i
< num_dump_sects
)
9277 warn (_("Some sections were not dumped because they do not exist!\n"));
9283 process_mips_fpe_exception (mask
)
9289 if (mask
& OEX_FPU_INEX
)
9290 fputs ("INEX", stdout
), first
= 0;
9291 if (mask
& OEX_FPU_UFLO
)
9292 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9293 if (mask
& OEX_FPU_OFLO
)
9294 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9295 if (mask
& OEX_FPU_DIV0
)
9296 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9297 if (mask
& OEX_FPU_INVAL
)
9298 printf ("%sINVAL", first
? "" : "|");
9301 fputs ("0", stdout
);
9305 process_mips_specific (file
)
9308 Elf_Internal_Dyn
*entry
;
9309 size_t liblist_offset
= 0;
9310 size_t liblistno
= 0;
9311 size_t conflictsno
= 0;
9312 size_t options_offset
= 0;
9313 size_t conflicts_offset
= 0;
9315 /* We have a lot of special sections. Thanks SGI! */
9316 if (dynamic_segment
== NULL
)
9317 /* No information available. */
9320 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9321 switch (entry
->d_tag
)
9323 case DT_MIPS_LIBLIST
:
9324 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
9326 case DT_MIPS_LIBLISTNO
:
9327 liblistno
= entry
->d_un
.d_val
;
9329 case DT_MIPS_OPTIONS
:
9330 options_offset
= entry
->d_un
.d_val
- loadaddr
;
9332 case DT_MIPS_CONFLICT
:
9333 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
9335 case DT_MIPS_CONFLICTNO
:
9336 conflictsno
= entry
->d_un
.d_val
;
9342 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9344 Elf32_External_Lib
*elib
;
9347 elib
= ((Elf32_External_Lib
*)
9348 get_data (NULL
, file
, liblist_offset
,
9349 liblistno
* sizeof (Elf32_External_Lib
),
9353 printf ("\nSection '.liblist' contains %lu entries:\n",
9354 (unsigned long) liblistno
);
9355 fputs (" Library Time Stamp Checksum Version Flags\n",
9358 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9365 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9366 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9367 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9368 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9369 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9371 tmp
= gmtime (&time
);
9372 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9373 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9374 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9376 printf ("%3lu: ", (unsigned long) cnt
);
9377 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9378 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9381 if (liblist
.l_flags
== 0)
9392 { " EXACT_MATCH", LL_EXACT_MATCH
},
9393 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9394 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9395 { " EXPORTS", LL_EXPORTS
},
9396 { " DELAY_LOAD", LL_DELAY_LOAD
},
9397 { " DELTA", LL_DELTA
}
9399 int flags
= liblist
.l_flags
;
9403 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9405 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9407 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9408 flags
^= l_flags_vals
[fcnt
].bit
;
9411 printf (" %#x", (unsigned int) flags
);
9421 if (options_offset
!= 0)
9423 Elf_External_Options
*eopt
;
9424 Elf_Internal_Shdr
*sect
= section_headers
;
9425 Elf_Internal_Options
*iopt
;
9426 Elf_Internal_Options
*option
;
9430 /* Find the section header so that we get the size. */
9431 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9434 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9435 sect
->sh_size
, _("options"));
9438 iopt
= ((Elf_Internal_Options
*)
9439 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
)));
9442 error (_("Out of memory"));
9449 while (offset
< sect
->sh_size
)
9451 Elf_External_Options
*eoption
;
9453 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9455 option
->kind
= BYTE_GET (eoption
->kind
);
9456 option
->size
= BYTE_GET (eoption
->size
);
9457 option
->section
= BYTE_GET (eoption
->section
);
9458 option
->info
= BYTE_GET (eoption
->info
);
9460 offset
+= option
->size
;
9466 printf (_("\nSection '%s' contains %d entries:\n"),
9467 SECTION_NAME (sect
), cnt
);
9475 switch (option
->kind
)
9478 /* This shouldn't happen. */
9479 printf (" NULL %d %lx", option
->section
, option
->info
);
9482 printf (" REGINFO ");
9483 if (elf_header
.e_machine
== EM_MIPS
)
9486 Elf32_External_RegInfo
*ereg
;
9487 Elf32_RegInfo reginfo
;
9489 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9490 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9491 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9492 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9493 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9494 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9495 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9497 printf ("GPR %08lx GP 0x%lx\n",
9499 (unsigned long) reginfo
.ri_gp_value
);
9500 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9501 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9502 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9507 Elf64_External_RegInfo
*ereg
;
9508 Elf64_Internal_RegInfo reginfo
;
9510 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9511 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9512 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9513 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9514 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9515 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9516 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9518 printf ("GPR %08lx GP 0x",
9519 reginfo
.ri_gprmask
);
9520 printf_vma (reginfo
.ri_gp_value
);
9523 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9524 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9525 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9529 case ODK_EXCEPTIONS
:
9530 fputs (" EXCEPTIONS fpe_min(", stdout
);
9531 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9532 fputs (") fpe_max(", stdout
);
9533 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9534 fputs (")", stdout
);
9536 if (option
->info
& OEX_PAGE0
)
9537 fputs (" PAGE0", stdout
);
9538 if (option
->info
& OEX_SMM
)
9539 fputs (" SMM", stdout
);
9540 if (option
->info
& OEX_FPDBUG
)
9541 fputs (" FPDBUG", stdout
);
9542 if (option
->info
& OEX_DISMISS
)
9543 fputs (" DISMISS", stdout
);
9546 fputs (" PAD ", stdout
);
9547 if (option
->info
& OPAD_PREFIX
)
9548 fputs (" PREFIX", stdout
);
9549 if (option
->info
& OPAD_POSTFIX
)
9550 fputs (" POSTFIX", stdout
);
9551 if (option
->info
& OPAD_SYMBOL
)
9552 fputs (" SYMBOL", stdout
);
9555 fputs (" HWPATCH ", stdout
);
9556 if (option
->info
& OHW_R4KEOP
)
9557 fputs (" R4KEOP", stdout
);
9558 if (option
->info
& OHW_R8KPFETCH
)
9559 fputs (" R8KPFETCH", stdout
);
9560 if (option
->info
& OHW_R5KEOP
)
9561 fputs (" R5KEOP", stdout
);
9562 if (option
->info
& OHW_R5KCVTL
)
9563 fputs (" R5KCVTL", stdout
);
9566 fputs (" FILL ", stdout
);
9567 /* XXX Print content of info word? */
9570 fputs (" TAGS ", stdout
);
9571 /* XXX Print content of info word? */
9574 fputs (" HWAND ", stdout
);
9575 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9576 fputs (" R4KEOP_CHECKED", stdout
);
9577 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9578 fputs (" R4KEOP_CLEAN", stdout
);
9581 fputs (" HWOR ", stdout
);
9582 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9583 fputs (" R4KEOP_CHECKED", stdout
);
9584 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9585 fputs (" R4KEOP_CLEAN", stdout
);
9588 printf (" GP_GROUP %#06lx self-contained %#06lx",
9589 option
->info
& OGP_GROUP
,
9590 (option
->info
& OGP_SELF
) >> 16);
9593 printf (" IDENT %#06lx self-contained %#06lx",
9594 option
->info
& OGP_GROUP
,
9595 (option
->info
& OGP_SELF
) >> 16);
9598 /* This shouldn't happen. */
9599 printf (" %3d ??? %d %lx",
9600 option
->kind
, option
->section
, option
->info
);
9604 len
= sizeof (*eopt
);
9605 while (len
< option
->size
)
9606 if (((char *) option
)[len
] >= ' '
9607 && ((char *) option
)[len
] < 0x7f)
9608 printf ("%c", ((char *) option
)[len
++]);
9610 printf ("\\%03o", ((char *) option
)[len
++]);
9612 fputs ("\n", stdout
);
9620 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9622 Elf32_Conflict
*iconf
;
9625 if (dynamic_symbols
== NULL
)
9627 error (_("conflict list found without a dynamic symbol table"));
9631 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
9634 error (_("Out of memory"));
9640 Elf32_External_Conflict
*econf32
;
9642 econf32
= ((Elf32_External_Conflict
*)
9643 get_data (NULL
, file
, conflicts_offset
,
9644 conflictsno
* sizeof (*econf32
),
9649 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9650 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9656 Elf64_External_Conflict
*econf64
;
9658 econf64
= ((Elf64_External_Conflict
*)
9659 get_data (NULL
, file
, conflicts_offset
,
9660 conflictsno
* sizeof (*econf64
),
9665 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9666 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9671 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9672 (long) conflictsno
);
9673 puts (_(" Num: Index Value Name"));
9675 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9677 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9679 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9680 print_vma (psym
->st_value
, FULL_HEX
);
9682 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9693 process_gnu_liblist (file
)
9696 Elf_Internal_Shdr
*section
, *string_sec
;
9697 Elf32_External_Lib
*elib
;
9705 for (i
= 0, section
= section_headers
;
9706 i
< elf_header
.e_shnum
;
9709 switch (section
->sh_type
)
9711 case SHT_GNU_LIBLIST
:
9712 elib
= ((Elf32_External_Lib
*)
9713 get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9718 string_sec
= SECTION_HEADER (section
->sh_link
);
9720 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9721 string_sec
->sh_size
,
9722 _("liblist string table"));
9725 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9731 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9732 SECTION_NAME (section
),
9733 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9735 puts (" Library Time Stamp Checksum Version Flags");
9737 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9745 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9746 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9747 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9748 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9749 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9751 tmp
= gmtime (&time
);
9752 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9753 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9754 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9756 printf ("%3lu: ", (unsigned long) cnt
);
9758 printf ("%-20s", strtab
+ liblist
.l_name
);
9760 printf ("%-20.20s", strtab
+ liblist
.l_name
);
9761 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9762 liblist
.l_version
, liblist
.l_flags
);
9773 get_note_type (e_type
)
9776 static char buff
[64];
9780 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9781 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9782 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9783 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9784 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9785 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9786 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9787 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9788 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9789 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9790 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9792 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9798 get_netbsd_elfcore_note_type (e_type
)
9801 static char buff
[64];
9803 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9805 /* NetBSD core "procinfo" structure. */
9806 return _("NetBSD procinfo structure");
9809 /* As of Jan 2002 there are no other machine-independent notes
9810 defined for NetBSD core files. If the note type is less
9811 than the start of the machine-dependent note types, we don't
9814 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9816 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9820 switch (elf_header
.e_machine
)
9822 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9823 and PT_GETFPREGS == mach+2. */
9828 case EM_SPARC32PLUS
:
9832 case NT_NETBSDCORE_FIRSTMACH
+0:
9833 return _("PT_GETREGS (reg structure)");
9834 case NT_NETBSDCORE_FIRSTMACH
+2:
9835 return _("PT_GETFPREGS (fpreg structure)");
9841 /* On all other arch's, PT_GETREGS == mach+1 and
9842 PT_GETFPREGS == mach+3. */
9846 case NT_NETBSDCORE_FIRSTMACH
+1:
9847 return _("PT_GETREGS (reg structure)");
9848 case NT_NETBSDCORE_FIRSTMACH
+3:
9849 return _("PT_GETFPREGS (fpreg structure)");
9855 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9859 /* Note that by the ELF standard, the name field is already null byte
9860 terminated, and namesz includes the terminating null byte.
9861 I.E. the value of namesz for the name "FSF" is 4.
9863 If the value of namesz is zero, there is no name present. */
9865 process_note (pnote
)
9866 Elf_Internal_Note
*pnote
;
9870 if (pnote
->namesz
== 0)
9872 /* If there is no note name, then use the default set of
9873 note type strings. */
9874 nt
= get_note_type (pnote
->type
);
9876 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9878 /* NetBSD-specific core file notes. */
9879 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9883 /* Don't recognize this note name; just use the default set of
9884 note type strings. */
9885 nt
= get_note_type (pnote
->type
);
9888 printf (" %s\t\t0x%08lx\t%s\n",
9889 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9896 process_corefile_note_segment (file
, offset
, length
)
9901 Elf_External_Note
*pnotes
;
9902 Elf_External_Note
*external
;
9908 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9915 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9916 (unsigned long) offset
, (unsigned long) length
);
9917 printf (_(" Owner\t\tData size\tDescription\n"));
9919 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9921 Elf_External_Note
*next
;
9922 Elf_Internal_Note inote
;
9925 inote
.type
= BYTE_GET (external
->type
);
9926 inote
.namesz
= BYTE_GET (external
->namesz
);
9927 inote
.namedata
= external
->name
;
9928 inote
.descsz
= BYTE_GET (external
->descsz
);
9929 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9930 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9932 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9934 if (((char *) next
) > (((char *) pnotes
) + length
))
9936 warn (_("corrupt note found at offset %x into core notes\n"),
9937 ((char *) external
) - ((char *) pnotes
));
9938 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9939 inote
.type
, inote
.namesz
, inote
.descsz
);
9945 /* Verify that name is null terminated. It appears that at least
9946 one version of Linux (RedHat 6.0) generates corefiles that don't
9947 comply with the ELF spec by failing to include the null byte in
9949 if (inote
.namedata
[inote
.namesz
] != '\0')
9951 temp
= malloc (inote
.namesz
+ 1);
9955 error (_("Out of memory\n"));
9960 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9961 temp
[inote
.namesz
] = 0;
9963 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9964 inote
.namedata
= temp
;
9967 res
&= process_note (& inote
);
9982 process_corefile_note_segments (file
)
9985 Elf_Internal_Phdr
*program_headers
;
9986 Elf_Internal_Phdr
*segment
;
9990 program_headers
= (Elf_Internal_Phdr
*) malloc
9991 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9993 if (program_headers
== NULL
)
9995 error (_("Out of memory\n"));
10000 i
= get_32bit_program_headers (file
, program_headers
);
10002 i
= get_64bit_program_headers (file
, program_headers
);
10006 free (program_headers
);
10010 for (i
= 0, segment
= program_headers
;
10011 i
< elf_header
.e_phnum
;
10014 if (segment
->p_type
== PT_NOTE
)
10015 res
&= process_corefile_note_segment (file
,
10016 (bfd_vma
) segment
->p_offset
,
10017 (bfd_vma
) segment
->p_filesz
);
10020 free (program_headers
);
10026 process_corefile_contents (file
)
10029 /* If we have not been asked to display the notes then do nothing. */
10033 /* If file is not a core file then exit. */
10034 if (elf_header
.e_type
!= ET_CORE
)
10037 /* No program headers means no NOTE segment. */
10038 if (elf_header
.e_phnum
== 0)
10040 printf (_("No note segments present in the core file.\n"));
10044 return process_corefile_note_segments (file
);
10048 process_arch_specific (file
)
10054 switch (elf_header
.e_machine
)
10057 case EM_MIPS_RS3_LE
:
10058 return process_mips_specific (file
);
10067 get_file_header (file
)
10070 /* Read in the identity array. */
10071 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10074 /* Determine how to read the rest of the header. */
10075 switch (elf_header
.e_ident
[EI_DATA
])
10077 default: /* fall through */
10078 case ELFDATANONE
: /* fall through */
10079 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
10080 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
10083 /* For now we only support 32 bit and 64 bit ELF files. */
10084 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10086 /* Read in the rest of the header. */
10089 Elf32_External_Ehdr ehdr32
;
10091 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10094 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10095 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10096 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10097 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10098 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10099 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10100 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10101 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10102 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10103 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10104 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10105 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10106 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10110 Elf64_External_Ehdr ehdr64
;
10112 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10113 we will not be able to cope with the 64bit data found in
10114 64 ELF files. Detect this now and abort before we start
10115 overwritting things. */
10116 if (sizeof (bfd_vma
) < 8)
10118 error (_("This instance of readelf has been built without support for a\n\
10119 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10123 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10126 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10127 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10128 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10129 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10130 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10131 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10132 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10133 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10134 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10135 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10136 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10137 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10138 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10141 if (elf_header
.e_shoff
)
10143 /* There may be some extensions in the first section header. Don't
10144 bomb if we can't read it. */
10146 get_32bit_section_headers (file
, 1);
10148 get_64bit_section_headers (file
, 1);
10155 process_file (file_name
)
10159 struct stat statbuf
;
10162 if (stat (file_name
, & statbuf
) < 0)
10164 error (_("Cannot stat input file %s.\n"), file_name
);
10168 file
= fopen (file_name
, "rb");
10171 error (_("Input file %s not found.\n"), file_name
);
10175 if (! get_file_header (file
))
10177 error (_("%s: Failed to read file header\n"), file_name
);
10182 /* Initialise per file variables. */
10183 for (i
= NUM_ELEM (version_info
); i
--;)
10184 version_info
[i
] = 0;
10186 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10187 dynamic_info
[i
] = 0;
10189 /* Process the file. */
10191 printf (_("\nFile: %s\n"), file_name
);
10193 if (! process_file_header ())
10199 if (! process_section_headers (file
))
10201 /* Without loaded section headers we
10202 cannot process lots of things. */
10203 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10205 if (! do_using_dynamic
)
10206 do_syms
= do_reloc
= 0;
10209 if (process_program_headers (file
))
10210 process_dynamic_segment (file
);
10212 process_relocs (file
);
10214 process_unwind (file
);
10216 process_symbol_table (file
);
10218 process_syminfo (file
);
10220 process_version_sections (file
);
10222 process_section_contents (file
);
10224 process_corefile_contents (file
);
10226 process_gnu_liblist (file
);
10228 process_arch_specific (file
);
10232 if (section_headers
)
10234 free (section_headers
);
10235 section_headers
= NULL
;
10240 free (string_table
);
10241 string_table
= NULL
;
10242 string_table_length
= 0;
10245 if (dynamic_strings
)
10247 free (dynamic_strings
);
10248 dynamic_strings
= NULL
;
10251 if (dynamic_symbols
)
10253 free (dynamic_symbols
);
10254 dynamic_symbols
= NULL
;
10255 num_dynamic_syms
= 0;
10258 if (dynamic_syminfo
)
10260 free (dynamic_syminfo
);
10261 dynamic_syminfo
= NULL
;
10267 #ifdef SUPPORT_DISASSEMBLY
10268 /* Needed by the i386 disassembler. For extra credit, someone could
10269 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10273 print_address (unsigned int addr
, FILE *outfile
)
10275 fprintf (outfile
,"0x%8.8x", addr
);
10278 /* Needed by the i386 disassembler. */
10280 db_task_printsym (unsigned int addr
)
10282 print_address (addr
, stderr
);
10286 int main
PARAMS ((int, char **));
10294 char *cmdline_dump_sects
= NULL
;
10295 unsigned num_cmdline_dump_sects
= 0;
10297 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10298 setlocale (LC_MESSAGES
, "");
10300 #if defined (HAVE_SETLOCALE)
10301 setlocale (LC_CTYPE
, "");
10303 bindtextdomain (PACKAGE
, LOCALEDIR
);
10304 textdomain (PACKAGE
);
10306 parse_args (argc
, argv
);
10308 if (optind
< (argc
- 1))
10311 /* When processing more than one file remember the dump requests
10312 issued on command line to reset them after each file. */
10313 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
10315 cmdline_dump_sects
= malloc (num_dump_sects
);
10316 if (cmdline_dump_sects
== NULL
)
10317 error (_("Out of memory allocating dump request table."));
10320 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
10321 num_cmdline_dump_sects
= num_dump_sects
;
10326 while (optind
< argc
)
10328 err
|= process_file (argv
[optind
++]);
10330 /* Reset dump requests. */
10331 if (optind
< argc
&& dump_sects
!= NULL
)
10333 num_dump_sects
= num_cmdline_dump_sects
;
10334 if (num_cmdline_dump_sects
> 0)
10335 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
10339 if (dump_sects
!= NULL
)
10341 if (cmdline_dump_sects
!= NULL
)
10342 free (cmdline_dump_sects
);