1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we 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"
83 #include "elf/sparc.h"
86 #include "elf/x86-64.h"
87 #include "elf/xstormy16.h"
92 char *program_name
= "readelf";
93 unsigned int dynamic_addr
;
94 bfd_size_type dynamic_size
;
95 unsigned int rela_addr
;
96 unsigned int rela_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 int dynamic_info
[DT_JMPREL
+ 1];
107 int 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
:
785 warn (_("Don't know about relocations on this machine architecture\n"));
791 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
793 unsigned long rel_offset
;
794 unsigned long rel_size
;
795 Elf_Internal_Rela
**relasp
;
796 unsigned long *nrelasp
;
798 Elf_Internal_Rela
*relas
;
799 unsigned long nrelas
;
804 Elf32_External_Rela
*erelas
;
806 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
807 rel_size
, _("relocs"));
811 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
813 relas
= (Elf_Internal_Rela
*)
814 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
818 error(_("out of memory parsing relocs"));
822 for (i
= 0; i
< nrelas
; i
++)
824 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
825 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
826 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
833 Elf64_External_Rela
*erelas
;
835 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
836 rel_size
, _("relocs"));
840 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
842 relas
= (Elf_Internal_Rela
*)
843 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
847 error(_("out of memory parsing relocs"));
851 for (i
= 0; i
< nrelas
; i
++)
853 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
854 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
855 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
866 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
868 unsigned long rel_offset
;
869 unsigned long rel_size
;
870 Elf_Internal_Rela
**relsp
;
871 unsigned long *nrelsp
;
873 Elf_Internal_Rela
*rels
;
879 Elf32_External_Rel
*erels
;
881 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
882 rel_size
, _("relocs"));
886 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
888 rels
= (Elf_Internal_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
892 error(_("out of memory parsing relocs"));
896 for (i
= 0; i
< nrels
; i
++)
898 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
899 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
900 rels
[i
].r_addend
= 0;
907 Elf64_External_Rel
*erels
;
909 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
910 rel_size
, _("relocs"));
914 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
916 rels
= (Elf_Internal_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
920 error(_("out of memory parsing relocs"));
924 for (i
= 0; i
< nrels
; i
++)
926 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
927 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
928 rels
[i
].r_addend
= 0;
938 /* Display the contents of the relocation data found at the specified offset. */
940 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
942 unsigned long rel_offset
;
943 unsigned long rel_size
;
944 Elf_Internal_Sym
*symtab
;
950 Elf_Internal_Rela
*rels
;
953 if (is_rela
== UNKNOWN
)
954 is_rela
= guess_is_rela (elf_header
.e_machine
);
958 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
963 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
972 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
974 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
979 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
981 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
989 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
991 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
996 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
998 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1002 for (i
= 0; i
< rel_size
; i
++)
1005 const char *rtype2
= NULL
;
1006 const char *rtype3
= NULL
;
1009 bfd_vma symtab_index
;
1011 bfd_vma type2
= (bfd_vma
) NULL
;
1012 bfd_vma type3
= (bfd_vma
) NULL
;
1014 offset
= rels
[i
].r_offset
;
1015 info
= rels
[i
].r_info
;
1019 type
= ELF32_R_TYPE (info
);
1020 symtab_index
= ELF32_R_SYM (info
);
1024 if (elf_header
.e_machine
== EM_MIPS
)
1026 type
= ELF64_MIPS_R_TYPE (info
);
1027 type2
= ELF64_MIPS_R_TYPE2 (info
);
1028 type3
= ELF64_MIPS_R_TYPE3 (info
);
1030 else if (elf_header
.e_machine
== EM_SPARCV9
)
1031 type
= ELF64_R_TYPE_ID (info
);
1033 type
= ELF64_R_TYPE (info
);
1034 /* The #ifdef BFD64 below is to prevent a compile time warning.
1035 We know that if we do not have a 64 bit data type that we
1036 will never execute this code anyway. */
1038 symtab_index
= ELF64_R_SYM (info
);
1044 #ifdef _bfd_int64_low
1045 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1047 printf ("%8.8lx %8.8lx ", offset
, info
);
1052 #ifdef _bfd_int64_low
1054 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1055 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1056 _bfd_int64_high (offset
),
1057 _bfd_int64_low (offset
),
1058 _bfd_int64_high (info
),
1059 _bfd_int64_low (info
));
1062 ? "%16.16lx %16.16lx "
1063 : "%12.12lx %12.12lx ",
1068 switch (elf_header
.e_machine
)
1075 case EM_CYGNUS_M32R
:
1076 rtype
= elf_m32r_reloc_type (type
);
1081 rtype
= elf_i386_reloc_type (type
);
1086 rtype
= elf_m68hc11_reloc_type (type
);
1090 rtype
= elf_m68k_reloc_type (type
);
1094 rtype
= elf_i960_reloc_type (type
);
1099 rtype
= elf_avr_reloc_type (type
);
1102 case EM_OLD_SPARCV9
:
1103 case EM_SPARC32PLUS
:
1106 rtype
= elf_sparc_reloc_type (type
);
1110 case EM_CYGNUS_V850
:
1111 rtype
= v850_reloc_type (type
);
1115 case EM_CYGNUS_D10V
:
1116 rtype
= elf_d10v_reloc_type (type
);
1120 case EM_CYGNUS_D30V
:
1121 rtype
= elf_d30v_reloc_type (type
);
1125 rtype
= elf_dlx_reloc_type (type
);
1129 rtype
= elf_sh_reloc_type (type
);
1133 case EM_CYGNUS_MN10300
:
1134 rtype
= elf_mn10300_reloc_type (type
);
1138 case EM_CYGNUS_MN10200
:
1139 rtype
= elf_mn10200_reloc_type (type
);
1143 case EM_CYGNUS_FR30
:
1144 rtype
= elf_fr30_reloc_type (type
);
1148 rtype
= elf_frv_reloc_type (type
);
1152 rtype
= elf_mcore_reloc_type (type
);
1156 rtype
= elf_mmix_reloc_type (type
);
1161 rtype
= elf_ppc_reloc_type (type
);
1165 case EM_MIPS_RS3_LE
:
1166 rtype
= elf_mips_reloc_type (type
);
1169 rtype2
= elf_mips_reloc_type (type2
);
1170 rtype3
= elf_mips_reloc_type (type3
);
1175 rtype
= elf_alpha_reloc_type (type
);
1179 rtype
= elf_arm_reloc_type (type
);
1183 rtype
= elf_arc_reloc_type (type
);
1187 rtype
= elf_hppa_reloc_type (type
);
1193 rtype
= elf_h8_reloc_type (type
);
1198 rtype
= elf_or32_reloc_type (type
);
1203 rtype
= elf_pj_reloc_type (type
);
1206 rtype
= elf_ia64_reloc_type (type
);
1210 rtype
= elf_cris_reloc_type (type
);
1214 rtype
= elf_i860_reloc_type (type
);
1218 rtype
= elf_x86_64_reloc_type (type
);
1222 rtype
= i370_reloc_type (type
);
1227 rtype
= elf_s390_reloc_type (type
);
1231 rtype
= elf_xstormy16_reloc_type (type
);
1235 rtype
= elf_vax_reloc_type (type
);
1240 rtype
= elf_ip2k_reloc_type (type
);
1245 #ifdef _bfd_int64_low
1246 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1248 printf (_("unrecognized: %-7lx"), type
);
1251 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1255 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1256 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1259 Elf_Internal_Sym
*psym
;
1261 psym
= symtab
+ symtab_index
;
1264 print_vma (psym
->st_value
, LONG_HEX
);
1265 printf (is_32bit_elf
? " " : " ");
1267 if (psym
->st_name
== 0)
1269 const char *sec_name
= "<null>";
1272 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1274 bfd_vma sec_index
= (bfd_vma
) -1;
1276 if (psym
->st_shndx
< SHN_LORESERVE
)
1277 sec_index
= psym
->st_shndx
;
1278 else if (psym
->st_shndx
> SHN_LORESERVE
)
1279 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1282 if (sec_index
!= (bfd_vma
) -1)
1283 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1284 else if (psym
->st_shndx
== SHN_ABS
)
1286 else if (psym
->st_shndx
== SHN_COMMON
)
1287 sec_name
= "COMMON";
1290 sprintf (name_buf
, "<section 0x%x>",
1291 (unsigned int) psym
->st_shndx
);
1292 sec_name
= name_buf
;
1295 print_symbol (22, sec_name
);
1297 else if (strtab
== NULL
)
1298 printf (_("<string table index %3ld>"), psym
->st_name
);
1300 print_symbol (22, strtab
+ psym
->st_name
);
1303 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1308 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1309 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1312 if (elf_header
.e_machine
== EM_SPARCV9
1313 && !strcmp (rtype
, "R_SPARC_OLO10"))
1314 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1318 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1320 printf (" Type2: ");
1323 #ifdef _bfd_int64_low
1324 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1326 printf (_("unrecognized: %-7lx"), type2
);
1329 printf ("%-17.17s", rtype2
);
1331 printf("\n Type3: ");
1334 #ifdef _bfd_int64_low
1335 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1337 printf (_("unrecognized: %-7lx"), type3
);
1340 printf ("%-17.17s", rtype3
);
1352 get_mips_dynamic_type (type
)
1357 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1358 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1359 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1360 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1361 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1362 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1363 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1364 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1365 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1366 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1367 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1368 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1369 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1370 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1371 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1372 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1373 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1374 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1375 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1376 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1377 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1378 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1379 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1380 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1381 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1382 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1383 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1384 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1385 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1386 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1387 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1388 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1389 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1390 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1391 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1392 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1393 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1394 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1395 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1396 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1397 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1398 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1399 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1406 get_sparc64_dynamic_type (type
)
1411 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1418 get_ppc64_dynamic_type (type
)
1423 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1424 case DT_PPC64_OPD
: return "PPC64_OPD";
1425 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1432 get_parisc_dynamic_type (type
)
1437 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1438 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1439 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1440 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1441 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1442 case DT_HP_PREINIT
: return "HP_PREINIT";
1443 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1444 case DT_HP_NEEDED
: return "HP_NEEDED";
1445 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1446 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1447 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1448 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1449 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1456 get_dynamic_type (type
)
1459 static char buff
[32];
1463 case DT_NULL
: return "NULL";
1464 case DT_NEEDED
: return "NEEDED";
1465 case DT_PLTRELSZ
: return "PLTRELSZ";
1466 case DT_PLTGOT
: return "PLTGOT";
1467 case DT_HASH
: return "HASH";
1468 case DT_STRTAB
: return "STRTAB";
1469 case DT_SYMTAB
: return "SYMTAB";
1470 case DT_RELA
: return "RELA";
1471 case DT_RELASZ
: return "RELASZ";
1472 case DT_RELAENT
: return "RELAENT";
1473 case DT_STRSZ
: return "STRSZ";
1474 case DT_SYMENT
: return "SYMENT";
1475 case DT_INIT
: return "INIT";
1476 case DT_FINI
: return "FINI";
1477 case DT_SONAME
: return "SONAME";
1478 case DT_RPATH
: return "RPATH";
1479 case DT_SYMBOLIC
: return "SYMBOLIC";
1480 case DT_REL
: return "REL";
1481 case DT_RELSZ
: return "RELSZ";
1482 case DT_RELENT
: return "RELENT";
1483 case DT_PLTREL
: return "PLTREL";
1484 case DT_DEBUG
: return "DEBUG";
1485 case DT_TEXTREL
: return "TEXTREL";
1486 case DT_JMPREL
: return "JMPREL";
1487 case DT_BIND_NOW
: return "BIND_NOW";
1488 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1489 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1490 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1491 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1492 case DT_RUNPATH
: return "RUNPATH";
1493 case DT_FLAGS
: return "FLAGS";
1495 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1496 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1498 case DT_CHECKSUM
: return "CHECKSUM";
1499 case DT_PLTPADSZ
: return "PLTPADSZ";
1500 case DT_MOVEENT
: return "MOVEENT";
1501 case DT_MOVESZ
: return "MOVESZ";
1502 case DT_FEATURE
: return "FEATURE";
1503 case DT_POSFLAG_1
: return "POSFLAG_1";
1504 case DT_SYMINSZ
: return "SYMINSZ";
1505 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1507 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1508 case DT_CONFIG
: return "CONFIG";
1509 case DT_DEPAUDIT
: return "DEPAUDIT";
1510 case DT_AUDIT
: return "AUDIT";
1511 case DT_PLTPAD
: return "PLTPAD";
1512 case DT_MOVETAB
: return "MOVETAB";
1513 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1515 case DT_VERSYM
: return "VERSYM";
1517 case DT_RELACOUNT
: return "RELACOUNT";
1518 case DT_RELCOUNT
: return "RELCOUNT";
1519 case DT_FLAGS_1
: return "FLAGS_1";
1520 case DT_VERDEF
: return "VERDEF";
1521 case DT_VERDEFNUM
: return "VERDEFNUM";
1522 case DT_VERNEED
: return "VERNEED";
1523 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1525 case DT_AUXILIARY
: return "AUXILIARY";
1526 case DT_USED
: return "USED";
1527 case DT_FILTER
: return "FILTER";
1529 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1530 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1531 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1532 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1533 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1536 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1540 switch (elf_header
.e_machine
)
1543 case EM_MIPS_RS3_LE
:
1544 result
= get_mips_dynamic_type (type
);
1547 result
= get_sparc64_dynamic_type (type
);
1550 result
= get_ppc64_dynamic_type (type
);
1560 sprintf (buff
, _("Processor Specific: %lx"), type
);
1562 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1566 switch (elf_header
.e_machine
)
1569 result
= get_parisc_dynamic_type (type
);
1579 sprintf (buff
, _("Operating System specific: %lx"), type
);
1582 sprintf (buff
, _("<unknown>: %lx"), type
);
1589 get_file_type (e_type
)
1592 static char buff
[32];
1596 case ET_NONE
: return _("NONE (None)");
1597 case ET_REL
: return _("REL (Relocatable file)");
1598 case ET_EXEC
: return _("EXEC (Executable file)");
1599 case ET_DYN
: return _("DYN (Shared object file)");
1600 case ET_CORE
: return _("CORE (Core file)");
1603 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1604 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1605 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1606 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1608 sprintf (buff
, _("<unknown>: %x"), e_type
);
1614 get_machine_name (e_machine
)
1617 static char buff
[64]; /* XXX */
1621 case EM_NONE
: return _("None");
1622 case EM_M32
: return "WE32100";
1623 case EM_SPARC
: return "Sparc";
1624 case EM_386
: return "Intel 80386";
1625 case EM_68K
: return "MC68000";
1626 case EM_88K
: return "MC88000";
1627 case EM_486
: return "Intel 80486";
1628 case EM_860
: return "Intel 80860";
1629 case EM_MIPS
: return "MIPS R3000";
1630 case EM_S370
: return "IBM System/370";
1631 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1632 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1633 case EM_PARISC
: return "HPPA";
1634 case EM_PPC_OLD
: return "Power PC (old)";
1635 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1636 case EM_960
: return "Intel 90860";
1637 case EM_PPC
: return "PowerPC";
1638 case EM_PPC64
: return "PowerPC64";
1639 case EM_V800
: return "NEC V800";
1640 case EM_FR20
: return "Fujitsu FR20";
1641 case EM_RH32
: return "TRW RH32";
1642 case EM_MCORE
: return "MCORE";
1643 case EM_ARM
: return "ARM";
1644 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1645 case EM_SH
: return "Hitachi SH";
1646 case EM_SPARCV9
: return "Sparc v9";
1647 case EM_TRICORE
: return "Siemens Tricore";
1648 case EM_ARC
: return "ARC";
1649 case EM_H8_300
: return "Hitachi H8/300";
1650 case EM_H8_300H
: return "Hitachi H8/300H";
1651 case EM_H8S
: return "Hitachi H8S";
1652 case EM_H8_500
: return "Hitachi H8/500";
1653 case EM_IA_64
: return "Intel IA-64";
1654 case EM_MIPS_X
: return "Stanford MIPS-X";
1655 case EM_COLDFIRE
: return "Motorola Coldfire";
1656 case EM_68HC12
: return "Motorola M68HC12";
1657 case EM_ALPHA
: return "Alpha";
1658 case EM_CYGNUS_D10V
:
1659 case EM_D10V
: return "d10v";
1660 case EM_CYGNUS_D30V
:
1661 case EM_D30V
: return "d30v";
1662 case EM_CYGNUS_M32R
:
1663 case EM_M32R
: return "Mitsubishi M32r";
1664 case EM_CYGNUS_V850
:
1665 case EM_V850
: return "NEC v850";
1666 case EM_CYGNUS_MN10300
:
1667 case EM_MN10300
: return "mn10300";
1668 case EM_CYGNUS_MN10200
:
1669 case EM_MN10200
: return "mn10200";
1670 case EM_CYGNUS_FR30
:
1671 case EM_FR30
: return "Fujitsu FR30";
1672 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1674 case EM_PJ
: return "picoJava";
1675 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1676 case EM_PCP
: return "Siemens PCP";
1677 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1678 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1679 case EM_STARCORE
: return "Motorola Star*Core processor";
1680 case EM_ME16
: return "Toyota ME16 processor";
1681 case EM_ST100
: return "STMicroelectronics ST100 processor";
1682 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1683 case EM_FX66
: return "Siemens FX66 microcontroller";
1684 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1685 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1686 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1687 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1688 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1689 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1690 case EM_SVX
: return "Silicon Graphics SVx";
1691 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1692 case EM_VAX
: return "Digital VAX";
1694 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1695 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1696 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1697 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1698 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1699 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1700 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1701 case EM_PRISM
: return "SiTera Prism";
1702 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1704 case EM_S390
: return "IBM S/390";
1705 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1707 case EM_OR32
: return "OpenRISC";
1708 case EM_DLX
: return "OpenDLX";
1710 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1712 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1718 decode_ARM_machine_flags (e_flags
, buf
)
1725 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1726 e_flags
&= ~ EF_ARM_EABIMASK
;
1728 /* Handle "generic" ARM flags. */
1729 if (e_flags
& EF_ARM_RELEXEC
)
1731 strcat (buf
, ", relocatable executable");
1732 e_flags
&= ~ EF_ARM_RELEXEC
;
1735 if (e_flags
& EF_ARM_HASENTRY
)
1737 strcat (buf
, ", has entry point");
1738 e_flags
&= ~ EF_ARM_HASENTRY
;
1741 /* Now handle EABI specific flags. */
1745 strcat (buf
, ", <unrecognized EABI>");
1750 case EF_ARM_EABI_VER1
:
1751 strcat (buf
, ", Version1 EABI");
1756 /* Process flags one bit at a time. */
1757 flag
= e_flags
& - e_flags
;
1762 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1763 strcat (buf
, ", sorted symbol tables");
1773 case EF_ARM_EABI_VER2
:
1774 strcat (buf
, ", Version2 EABI");
1779 /* Process flags one bit at a time. */
1780 flag
= e_flags
& - e_flags
;
1785 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1786 strcat (buf
, ", sorted symbol tables");
1789 case EF_ARM_DYNSYMSUSESEGIDX
:
1790 strcat (buf
, ", dynamic symbols use segment index");
1793 case EF_ARM_MAPSYMSFIRST
:
1794 strcat (buf
, ", mapping symbols precede others");
1804 case EF_ARM_EABI_UNKNOWN
:
1805 strcat (buf
, ", GNU EABI");
1810 /* Process flags one bit at a time. */
1811 flag
= e_flags
& - e_flags
;
1816 case EF_ARM_INTERWORK
:
1817 strcat (buf
, ", interworking enabled");
1820 case EF_ARM_APCS_26
:
1821 strcat (buf
, ", uses APCS/26");
1824 case EF_ARM_APCS_FLOAT
:
1825 strcat (buf
, ", uses APCS/float");
1829 strcat (buf
, ", position independent");
1833 strcat (buf
, ", 8 bit structure alignment");
1836 case EF_ARM_NEW_ABI
:
1837 strcat (buf
, ", uses new ABI");
1840 case EF_ARM_OLD_ABI
:
1841 strcat (buf
, ", uses old ABI");
1844 case EF_ARM_SOFT_FLOAT
:
1845 strcat (buf
, ", software FP");
1856 strcat (buf
,", <unknown>");
1860 get_machine_flags (e_flags
, e_machine
)
1864 static char buf
[1024];
1876 decode_ARM_machine_flags (e_flags
, buf
);
1880 if (e_flags
& EF_CPU32
)
1881 strcat (buf
, ", cpu32");
1882 if (e_flags
& EF_M68000
)
1883 strcat (buf
, ", m68000");
1887 if (e_flags
& EF_PPC_EMB
)
1888 strcat (buf
, ", emb");
1890 if (e_flags
& EF_PPC_RELOCATABLE
)
1891 strcat (buf
, ", relocatable");
1893 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1894 strcat (buf
, ", relocatable-lib");
1898 case EM_CYGNUS_V850
:
1899 switch (e_flags
& EF_V850_ARCH
)
1902 strcat (buf
, ", v850e");
1905 strcat (buf
, ", v850");
1908 strcat (buf
, ", unknown v850 architecture variant");
1914 case EM_CYGNUS_M32R
:
1915 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1916 strcat (buf
, ", m32r");
1921 case EM_MIPS_RS3_LE
:
1922 if (e_flags
& EF_MIPS_NOREORDER
)
1923 strcat (buf
, ", noreorder");
1925 if (e_flags
& EF_MIPS_PIC
)
1926 strcat (buf
, ", pic");
1928 if (e_flags
& EF_MIPS_CPIC
)
1929 strcat (buf
, ", cpic");
1931 if (e_flags
& EF_MIPS_UCODE
)
1932 strcat (buf
, ", ugen_reserved");
1934 if (e_flags
& EF_MIPS_ABI2
)
1935 strcat (buf
, ", abi2");
1937 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1938 strcat (buf
, ", odk first");
1940 if (e_flags
& EF_MIPS_32BITMODE
)
1941 strcat (buf
, ", 32bitmode");
1943 switch ((e_flags
& EF_MIPS_MACH
))
1945 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1946 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1947 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1948 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1949 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1950 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1951 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1952 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1953 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1955 /* We simply ignore the field in this case to avoid confusion:
1956 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1959 default: strcat (buf
, ", unknown CPU"); break;
1962 switch ((e_flags
& EF_MIPS_ABI
))
1964 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1965 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1966 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1967 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1969 /* We simply ignore the field in this case to avoid confusion:
1970 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1971 This means it is likely to be an o32 file, but not for
1974 default: strcat (buf
, ", unknown ABI"); break;
1977 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1978 strcat (buf
, ", mdmx");
1980 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1981 strcat (buf
, ", mips16");
1983 switch ((e_flags
& EF_MIPS_ARCH
))
1985 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1986 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1987 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1988 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1989 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1990 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1991 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1992 default: strcat (buf
, ", unknown ISA"); break;
1998 if (e_flags
& EF_SPARC_32PLUS
)
1999 strcat (buf
, ", v8+");
2001 if (e_flags
& EF_SPARC_SUN_US1
)
2002 strcat (buf
, ", ultrasparcI");
2004 if (e_flags
& EF_SPARC_SUN_US3
)
2005 strcat (buf
, ", ultrasparcIII");
2007 if (e_flags
& EF_SPARC_HAL_R1
)
2008 strcat (buf
, ", halr1");
2010 if (e_flags
& EF_SPARC_LEDATA
)
2011 strcat (buf
, ", ledata");
2013 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2014 strcat (buf
, ", tso");
2016 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2017 strcat (buf
, ", pso");
2019 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2020 strcat (buf
, ", rmo");
2024 switch (e_flags
& EF_PARISC_ARCH
)
2026 case EFA_PARISC_1_0
:
2027 strcpy (buf
, ", PA-RISC 1.0");
2029 case EFA_PARISC_1_1
:
2030 strcpy (buf
, ", PA-RISC 1.1");
2032 case EFA_PARISC_2_0
:
2033 strcpy (buf
, ", PA-RISC 2.0");
2038 if (e_flags
& EF_PARISC_TRAPNIL
)
2039 strcat (buf
, ", trapnil");
2040 if (e_flags
& EF_PARISC_EXT
)
2041 strcat (buf
, ", ext");
2042 if (e_flags
& EF_PARISC_LSB
)
2043 strcat (buf
, ", lsb");
2044 if (e_flags
& EF_PARISC_WIDE
)
2045 strcat (buf
, ", wide");
2046 if (e_flags
& EF_PARISC_NO_KABP
)
2047 strcat (buf
, ", no kabp");
2048 if (e_flags
& EF_PARISC_LAZYSWAP
)
2049 strcat (buf
, ", lazyswap");
2054 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2055 strcat (buf
, ", new calling convention");
2057 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2058 strcat (buf
, ", gnu calling convention");
2062 if ((e_flags
& EF_IA_64_ABI64
))
2063 strcat (buf
, ", 64-bit");
2065 strcat (buf
, ", 32-bit");
2066 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2067 strcat (buf
, ", reduced fp model");
2068 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2069 strcat (buf
, ", no function descriptors, constant gp");
2070 else if ((e_flags
& EF_IA_64_CONS_GP
))
2071 strcat (buf
, ", constant gp");
2072 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2073 strcat (buf
, ", absolute");
2077 if ((e_flags
& EF_VAX_NONPIC
))
2078 strcat (buf
, ", non-PIC");
2079 if ((e_flags
& EF_VAX_DFLOAT
))
2080 strcat (buf
, ", D-Float");
2081 if ((e_flags
& EF_VAX_GFLOAT
))
2082 strcat (buf
, ", G-Float");
2091 get_mips_segment_type (type
)
2096 case PT_MIPS_REGINFO
:
2098 case PT_MIPS_RTPROC
:
2100 case PT_MIPS_OPTIONS
:
2110 get_parisc_segment_type (type
)
2115 case PT_HP_TLS
: return "HP_TLS";
2116 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2117 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2118 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2119 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2120 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2121 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2122 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2123 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2124 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2125 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2126 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2127 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2128 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2137 get_ia64_segment_type (type
)
2142 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2143 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2144 case PT_HP_TLS
: return "HP_TLS";
2145 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2146 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2147 case PT_IA_64_HP_STACK
: return "HP_STACK";
2156 get_segment_type (p_type
)
2157 unsigned long p_type
;
2159 static char buff
[32];
2163 case PT_NULL
: return "NULL";
2164 case PT_LOAD
: return "LOAD";
2165 case PT_DYNAMIC
: return "DYNAMIC";
2166 case PT_INTERP
: return "INTERP";
2167 case PT_NOTE
: return "NOTE";
2168 case PT_SHLIB
: return "SHLIB";
2169 case PT_PHDR
: return "PHDR";
2170 case PT_TLS
: return "TLS";
2172 case PT_GNU_EH_FRAME
:
2173 return "GNU_EH_FRAME";
2176 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2180 switch (elf_header
.e_machine
)
2183 case EM_MIPS_RS3_LE
:
2184 result
= get_mips_segment_type (p_type
);
2187 result
= get_parisc_segment_type (p_type
);
2190 result
= get_ia64_segment_type (p_type
);
2200 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2202 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2206 switch (elf_header
.e_machine
)
2209 result
= get_parisc_segment_type (p_type
);
2212 result
= get_ia64_segment_type (p_type
);
2222 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2225 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2232 get_mips_section_type_name (sh_type
)
2233 unsigned int sh_type
;
2237 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2238 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2239 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2240 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2241 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2242 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2243 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2244 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2245 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2246 case SHT_MIPS_RELD
: return "MIPS_RELD";
2247 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2248 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2249 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2250 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2251 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2252 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2253 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2254 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2255 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2256 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2257 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2258 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2259 case SHT_MIPS_LINE
: return "MIPS_LINE";
2260 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2261 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2262 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2263 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2264 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2265 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2266 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2267 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2268 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2269 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2270 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2271 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2272 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2273 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2274 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2275 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2283 get_parisc_section_type_name (sh_type
)
2284 unsigned int sh_type
;
2288 case SHT_PARISC_EXT
: return "PARISC_EXT";
2289 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2290 case SHT_PARISC_DOC
: return "PARISC_DOC";
2298 get_ia64_section_type_name (sh_type
)
2299 unsigned int sh_type
;
2303 case SHT_IA_64_EXT
: return "IA_64_EXT";
2304 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2312 get_section_type_name (sh_type
)
2313 unsigned int sh_type
;
2315 static char buff
[32];
2319 case SHT_NULL
: return "NULL";
2320 case SHT_PROGBITS
: return "PROGBITS";
2321 case SHT_SYMTAB
: return "SYMTAB";
2322 case SHT_STRTAB
: return "STRTAB";
2323 case SHT_RELA
: return "RELA";
2324 case SHT_HASH
: return "HASH";
2325 case SHT_DYNAMIC
: return "DYNAMIC";
2326 case SHT_NOTE
: return "NOTE";
2327 case SHT_NOBITS
: return "NOBITS";
2328 case SHT_REL
: return "REL";
2329 case SHT_SHLIB
: return "SHLIB";
2330 case SHT_DYNSYM
: return "DYNSYM";
2331 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2332 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2333 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2334 case SHT_GROUP
: return "GROUP";
2335 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2336 case SHT_GNU_verdef
: return "VERDEF";
2337 case SHT_GNU_verneed
: return "VERNEED";
2338 case SHT_GNU_versym
: return "VERSYM";
2339 case 0x6ffffff0: return "VERSYM";
2340 case 0x6ffffffc: return "VERDEF";
2341 case 0x7ffffffd: return "AUXILIARY";
2342 case 0x7fffffff: return "FILTER";
2343 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2346 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2350 switch (elf_header
.e_machine
)
2353 case EM_MIPS_RS3_LE
:
2354 result
= get_mips_section_type_name (sh_type
);
2357 result
= get_parisc_section_type_name (sh_type
);
2360 result
= get_ia64_section_type_name (sh_type
);
2370 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2372 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2373 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2374 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2375 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2377 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2383 #define OPTION_DEBUG_DUMP 512
2385 struct option options
[] =
2387 {"all", no_argument
, 0, 'a'},
2388 {"file-header", no_argument
, 0, 'h'},
2389 {"program-headers", no_argument
, 0, 'l'},
2390 {"headers", no_argument
, 0, 'e'},
2391 {"histogram", no_argument
, 0, 'I'},
2392 {"segments", no_argument
, 0, 'l'},
2393 {"sections", no_argument
, 0, 'S'},
2394 {"section-headers", no_argument
, 0, 'S'},
2395 {"symbols", no_argument
, 0, 's'},
2396 {"syms", no_argument
, 0, 's'},
2397 {"relocs", no_argument
, 0, 'r'},
2398 {"notes", no_argument
, 0, 'n'},
2399 {"dynamic", no_argument
, 0, 'd'},
2400 {"arch-specific", no_argument
, 0, 'A'},
2401 {"version-info", no_argument
, 0, 'V'},
2402 {"use-dynamic", no_argument
, 0, 'D'},
2403 {"hex-dump", required_argument
, 0, 'x'},
2404 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2405 {"unwind", no_argument
, 0, 'u'},
2406 #ifdef SUPPORT_DISASSEMBLY
2407 {"instruction-dump", required_argument
, 0, 'i'},
2410 {"version", no_argument
, 0, 'v'},
2411 {"wide", no_argument
, 0, 'W'},
2412 {"help", no_argument
, 0, 'H'},
2413 {0, no_argument
, 0, 0}
2419 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2420 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2421 fprintf (stdout
, _(" Options are:\n\
2422 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2423 -h --file-header Display the ELF file header\n\
2424 -l --program-headers Display the program headers\n\
2425 --segments An alias for --program-headers\n\
2426 -S --section-headers Display the sections' header\n\
2427 --sections An alias for --section-headers\n\
2428 -e --headers Equivalent to: -h -l -S\n\
2429 -s --syms Display the symbol table\n\
2430 --symbols An alias for --syms\n\
2431 -n --notes Display the core notes (if present)\n\
2432 -r --relocs Display the relocations (if present)\n\
2433 -u --unwind Display the unwind info (if present)\n\
2434 -d --dynamic Display the dynamic segment (if present)\n\
2435 -V --version-info Display the version sections (if present)\n\
2436 -A --arch-specific Display architecture specific information (if any).\n\
2437 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2438 -x --hex-dump=<number> Dump the contents of section <number>\n\
2439 -w[liaprmfFso] or\n\
2440 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2441 Display the contents of DWARF2 debug sections\n"));
2442 #ifdef SUPPORT_DISASSEMBLY
2443 fprintf (stdout
, _("\
2444 -i --instruction-dump=<number>\n\
2445 Disassemble the contents of section <number>\n"));
2447 fprintf (stdout
, _("\
2448 -I --histogram Display histogram of bucket list lengths\n\
2449 -W --wide Allow output width to exceed 80 characters\n\
2450 -H --help Display this information\n\
2451 -v --version Display the version number of readelf\n"));
2452 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2458 request_dump (section
, type
)
2459 unsigned int section
;
2462 if (section
>= num_dump_sects
)
2464 char *new_dump_sects
;
2466 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2468 if (new_dump_sects
== NULL
)
2469 error (_("Out of memory allocating dump request table."));
2472 /* Copy current flag settings. */
2473 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2477 dump_sects
= new_dump_sects
;
2478 num_dump_sects
= section
+ 1;
2483 dump_sects
[section
] |= type
;
2489 parse_args (argc
, argv
)
2498 while ((c
= getopt_long
2499 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2566 section
= strtoul (optarg
, & cp
, 0);
2567 if (! *cp
&& section
>= 0)
2569 request_dump (section
, HEX_DUMP
);
2579 unsigned int index
= 0;
2583 while (optarg
[index
])
2584 switch (optarg
[index
++])
2593 do_debug_abbrevs
= 1;
2603 do_debug_pubnames
= 1;
2608 do_debug_aranges
= 1;
2612 do_debug_frames_interp
= 1;
2614 do_debug_frames
= 1;
2619 do_debug_macinfo
= 1;
2633 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2638 case OPTION_DEBUG_DUMP
:
2644 static const char *debug_dump_opt
[]
2645 = { "line", "info", "abbrev", "pubnames", "ranges",
2646 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2655 for (index
= 0; debug_dump_opt
[index
]; index
++)
2657 size_t len
= strlen (debug_dump_opt
[index
]);
2659 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2660 && (p
[len
] == ',' || p
[len
] == '\0'))
2669 do_debug_abbrevs
= 1;
2680 do_debug_pubnames
= 1;
2684 do_debug_aranges
= 1;
2689 do_debug_frames_interp
= 1;
2690 do_debug_frames
= 1;
2694 do_debug_macinfo
= 1;
2707 if (debug_dump_opt
[index
] == NULL
)
2709 warn (_("Unrecognized debug option '%s'\n"), p
);
2710 p
= strchr (p
, ',');
2720 #ifdef SUPPORT_DISASSEMBLY
2723 section
= strtoul (optarg
, & cp
, 0);
2724 if (! *cp
&& section
>= 0)
2726 request_dump (section
, DISASS_DUMP
);
2732 print_version (program_name
);
2742 /* xgettext:c-format */
2743 error (_("Invalid option '-%c'\n"), c
);
2750 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2751 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2752 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2756 warn (_("Nothing to do.\n"));
2762 get_elf_class (elf_class
)
2763 unsigned int elf_class
;
2765 static char buff
[32];
2769 case ELFCLASSNONE
: return _("none");
2770 case ELFCLASS32
: return "ELF32";
2771 case ELFCLASS64
: return "ELF64";
2773 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2779 get_data_encoding (encoding
)
2780 unsigned int encoding
;
2782 static char buff
[32];
2786 case ELFDATANONE
: return _("none");
2787 case ELFDATA2LSB
: return _("2's complement, little endian");
2788 case ELFDATA2MSB
: return _("2's complement, big endian");
2790 sprintf (buff
, _("<unknown: %x>"), encoding
);
2796 get_osabi_name (osabi
)
2799 static char buff
[32];
2803 case ELFOSABI_NONE
: return "UNIX - System V";
2804 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2805 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2806 case ELFOSABI_LINUX
: return "UNIX - Linux";
2807 case ELFOSABI_HURD
: return "GNU/Hurd";
2808 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2809 case ELFOSABI_AIX
: return "UNIX - AIX";
2810 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2811 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2812 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2813 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2814 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2815 case ELFOSABI_STANDALONE
: return _("Standalone App");
2816 case ELFOSABI_ARM
: return "ARM";
2818 sprintf (buff
, _("<unknown: %x>"), osabi
);
2823 /* Decode the data held in 'elf_header'. */
2825 process_file_header ()
2827 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2828 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2829 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2830 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2833 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2841 printf (_("ELF Header:\n"));
2842 printf (_(" Magic: "));
2843 for (i
= 0; i
< EI_NIDENT
; i
++)
2844 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2846 printf (_(" Class: %s\n"),
2847 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2848 printf (_(" Data: %s\n"),
2849 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2850 printf (_(" Version: %d %s\n"),
2851 elf_header
.e_ident
[EI_VERSION
],
2852 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2854 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2857 printf (_(" OS/ABI: %s\n"),
2858 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2859 printf (_(" ABI Version: %d\n"),
2860 elf_header
.e_ident
[EI_ABIVERSION
]);
2861 printf (_(" Type: %s\n"),
2862 get_file_type (elf_header
.e_type
));
2863 printf (_(" Machine: %s\n"),
2864 get_machine_name (elf_header
.e_machine
));
2865 printf (_(" Version: 0x%lx\n"),
2866 (unsigned long) elf_header
.e_version
);
2868 printf (_(" Entry point address: "));
2869 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2870 printf (_("\n Start of program headers: "));
2871 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2872 printf (_(" (bytes into file)\n Start of section headers: "));
2873 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2874 printf (_(" (bytes into file)\n"));
2876 printf (_(" Flags: 0x%lx%s\n"),
2877 (unsigned long) elf_header
.e_flags
,
2878 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2879 printf (_(" Size of this header: %ld (bytes)\n"),
2880 (long) elf_header
.e_ehsize
);
2881 printf (_(" Size of program headers: %ld (bytes)\n"),
2882 (long) elf_header
.e_phentsize
);
2883 printf (_(" Number of program headers: %ld\n"),
2884 (long) elf_header
.e_phnum
);
2885 printf (_(" Size of section headers: %ld (bytes)\n"),
2886 (long) elf_header
.e_shentsize
);
2887 printf (_(" Number of section headers: %ld"),
2888 (long) elf_header
.e_shnum
);
2889 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2890 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2891 putc ('\n', stdout
);
2892 printf (_(" Section header string table index: %ld"),
2893 (long) elf_header
.e_shstrndx
);
2894 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2895 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2896 putc ('\n', stdout
);
2899 if (section_headers
!= NULL
)
2901 if (elf_header
.e_shnum
== 0)
2902 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2903 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2904 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2905 free (section_headers
);
2906 section_headers
= NULL
;
2914 get_32bit_program_headers (file
, program_headers
)
2916 Elf_Internal_Phdr
*program_headers
;
2918 Elf32_External_Phdr
*phdrs
;
2919 Elf32_External_Phdr
*external
;
2920 Elf_Internal_Phdr
*internal
;
2923 phdrs
= ((Elf32_External_Phdr
*)
2924 get_data (NULL
, file
, elf_header
.e_phoff
,
2925 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2926 _("program headers")));
2930 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2931 i
< elf_header
.e_phnum
;
2932 i
++, internal
++, external
++)
2934 internal
->p_type
= BYTE_GET (external
->p_type
);
2935 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2936 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2937 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2938 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2939 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2940 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2941 internal
->p_align
= BYTE_GET (external
->p_align
);
2950 get_64bit_program_headers (file
, program_headers
)
2952 Elf_Internal_Phdr
*program_headers
;
2954 Elf64_External_Phdr
*phdrs
;
2955 Elf64_External_Phdr
*external
;
2956 Elf_Internal_Phdr
*internal
;
2959 phdrs
= ((Elf64_External_Phdr
*)
2960 get_data (NULL
, file
, elf_header
.e_phoff
,
2961 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2962 _("program headers")));
2966 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2967 i
< elf_header
.e_phnum
;
2968 i
++, internal
++, external
++)
2970 internal
->p_type
= BYTE_GET (external
->p_type
);
2971 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2972 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2973 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2974 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2975 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2976 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2977 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2985 /* Returns 1 if the program headers were loaded. */
2988 process_program_headers (file
)
2991 Elf_Internal_Phdr
*program_headers
;
2992 Elf_Internal_Phdr
*segment
;
2995 if (elf_header
.e_phnum
== 0)
2998 printf (_("\nThere are no program headers in this file.\n"));
3002 if (do_segments
&& !do_header
)
3004 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3005 printf (_("Entry point "));
3006 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3007 printf (_("\nThere are %d program headers, starting at offset "),
3008 elf_header
.e_phnum
);
3009 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3013 program_headers
= (Elf_Internal_Phdr
*) malloc
3014 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3016 if (program_headers
== NULL
)
3018 error (_("Out of memory\n"));
3023 i
= get_32bit_program_headers (file
, program_headers
);
3025 i
= get_64bit_program_headers (file
, program_headers
);
3029 free (program_headers
);
3035 if (elf_header
.e_phnum
> 1)
3036 printf (_("\nProgram Headers:\n"));
3038 printf (_("\nProgram Headers:\n"));
3042 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3045 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3049 (_(" Type Offset VirtAddr PhysAddr\n"));
3051 (_(" FileSiz MemSiz Flags Align\n"));
3059 for (i
= 0, segment
= program_headers
;
3060 i
< elf_header
.e_phnum
;
3065 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3069 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3070 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3071 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3072 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3073 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3075 (segment
->p_flags
& PF_R
? 'R' : ' '),
3076 (segment
->p_flags
& PF_W
? 'W' : ' '),
3077 (segment
->p_flags
& PF_X
? 'E' : ' '));
3078 printf ("%#lx", (unsigned long) segment
->p_align
);
3082 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3083 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3086 print_vma (segment
->p_offset
, FULL_HEX
);
3090 print_vma (segment
->p_vaddr
, FULL_HEX
);
3092 print_vma (segment
->p_paddr
, FULL_HEX
);
3095 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3096 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3099 print_vma (segment
->p_filesz
, FULL_HEX
);
3103 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3104 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3107 print_vma (segment
->p_offset
, FULL_HEX
);
3111 (segment
->p_flags
& PF_R
? 'R' : ' '),
3112 (segment
->p_flags
& PF_W
? 'W' : ' '),
3113 (segment
->p_flags
& PF_X
? 'E' : ' '));
3115 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3116 printf ("%#lx", (unsigned long) segment
->p_align
);
3119 print_vma (segment
->p_align
, PREFIX_HEX
);
3124 print_vma (segment
->p_offset
, FULL_HEX
);
3126 print_vma (segment
->p_vaddr
, FULL_HEX
);
3128 print_vma (segment
->p_paddr
, FULL_HEX
);
3130 print_vma (segment
->p_filesz
, FULL_HEX
);
3132 print_vma (segment
->p_memsz
, FULL_HEX
);
3134 (segment
->p_flags
& PF_R
? 'R' : ' '),
3135 (segment
->p_flags
& PF_W
? 'W' : ' '),
3136 (segment
->p_flags
& PF_X
? 'E' : ' '));
3137 print_vma (segment
->p_align
, HEX
);
3141 switch (segment
->p_type
)
3145 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
3146 - (segment
->p_offset
& 0xfffff000);
3151 error (_("more than one dynamic segment\n"));
3153 dynamic_addr
= segment
->p_offset
;
3154 dynamic_size
= segment
->p_filesz
;
3158 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
3159 error (_("Unable to find program interpreter name\n"));
3162 program_interpreter
[0] = 0;
3163 fscanf (file
, "%63s", program_interpreter
);
3166 printf (_("\n [Requesting program interpreter: %s]"),
3167 program_interpreter
);
3173 putc ('\n', stdout
);
3182 if (do_segments
&& section_headers
!= NULL
)
3184 printf (_("\n Section to Segment mapping:\n"));
3185 printf (_(" Segment Sections...\n"));
3187 assert (string_table
!= NULL
);
3189 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3192 Elf_Internal_Shdr
*section
;
3194 segment
= program_headers
+ i
;
3195 section
= section_headers
;
3197 printf (" %2.2d ", i
);
3199 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3201 if (section
->sh_size
> 0
3202 /* Compare allocated sections by VMA, unallocated
3203 sections by file offset. */
3204 && (section
->sh_flags
& SHF_ALLOC
3205 ? (section
->sh_addr
>= segment
->p_vaddr
3206 && section
->sh_addr
+ section
->sh_size
3207 <= segment
->p_vaddr
+ segment
->p_memsz
)
3208 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3209 && (section
->sh_offset
+ section
->sh_size
3210 <= segment
->p_offset
+ segment
->p_filesz
))))
3211 printf ("%s ", SECTION_NAME (section
));
3218 free (program_headers
);
3225 get_32bit_section_headers (file
, num
)
3229 Elf32_External_Shdr
*shdrs
;
3230 Elf_Internal_Shdr
*internal
;
3233 shdrs
= ((Elf32_External_Shdr
*)
3234 get_data (NULL
, file
, elf_header
.e_shoff
,
3235 elf_header
.e_shentsize
* num
,
3236 _("section headers")));
3240 section_headers
= ((Elf_Internal_Shdr
*)
3241 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3243 if (section_headers
== NULL
)
3245 error (_("Out of memory\n"));
3249 for (i
= 0, internal
= section_headers
;
3253 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3254 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3255 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3256 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3257 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3258 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3259 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3260 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3261 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3262 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3271 get_64bit_section_headers (file
, num
)
3275 Elf64_External_Shdr
*shdrs
;
3276 Elf_Internal_Shdr
*internal
;
3279 shdrs
= ((Elf64_External_Shdr
*)
3280 get_data (NULL
, file
, elf_header
.e_shoff
,
3281 elf_header
.e_shentsize
* num
,
3282 _("section headers")));
3286 section_headers
= ((Elf_Internal_Shdr
*)
3287 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3289 if (section_headers
== NULL
)
3291 error (_("Out of memory\n"));
3295 for (i
= 0, internal
= section_headers
;
3299 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3300 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3301 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3302 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3303 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3304 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3305 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3306 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3307 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3308 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3316 static Elf_Internal_Sym
*
3317 get_32bit_elf_symbols (file
, section
)
3319 Elf_Internal_Shdr
*section
;
3321 unsigned long number
;
3322 Elf32_External_Sym
*esyms
;
3323 Elf_External_Sym_Shndx
*shndx
;
3324 Elf_Internal_Sym
*isyms
;
3325 Elf_Internal_Sym
*psym
;
3328 esyms
= ((Elf32_External_Sym
*)
3329 get_data (NULL
, file
, section
->sh_offset
,
3330 section
->sh_size
, _("symbols")));
3335 if (symtab_shndx_hdr
!= NULL
3336 && (symtab_shndx_hdr
->sh_link
3337 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3339 shndx
= ((Elf_External_Sym_Shndx
*)
3340 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3341 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3349 number
= section
->sh_size
/ section
->sh_entsize
;
3350 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3354 error (_("Out of memory\n"));
3361 for (j
= 0, psym
= isyms
;
3365 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3366 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3367 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3368 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3369 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3371 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3372 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3373 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3383 static Elf_Internal_Sym
*
3384 get_64bit_elf_symbols (file
, section
)
3386 Elf_Internal_Shdr
*section
;
3388 unsigned long number
;
3389 Elf64_External_Sym
*esyms
;
3390 Elf_External_Sym_Shndx
*shndx
;
3391 Elf_Internal_Sym
*isyms
;
3392 Elf_Internal_Sym
*psym
;
3395 esyms
= ((Elf64_External_Sym
*)
3396 get_data (NULL
, file
, section
->sh_offset
,
3397 section
->sh_size
, _("symbols")));
3402 if (symtab_shndx_hdr
!= NULL
3403 && (symtab_shndx_hdr
->sh_link
3404 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3406 shndx
= ((Elf_External_Sym_Shndx
*)
3407 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3408 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3416 number
= section
->sh_size
/ section
->sh_entsize
;
3417 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3421 error (_("Out of memory\n"));
3428 for (j
= 0, psym
= isyms
;
3432 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3433 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3434 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3435 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3436 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3438 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3439 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3440 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3451 get_elf_section_flags (sh_flags
)
3454 static char buff
[32];
3462 flag
= sh_flags
& - sh_flags
;
3467 case SHF_WRITE
: strcat (buff
, "W"); break;
3468 case SHF_ALLOC
: strcat (buff
, "A"); break;
3469 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3470 case SHF_MERGE
: strcat (buff
, "M"); break;
3471 case SHF_STRINGS
: strcat (buff
, "S"); break;
3472 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3473 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3474 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3475 case SHF_GROUP
: strcat (buff
, "G"); break;
3476 case SHF_TLS
: strcat (buff
, "T"); break;
3479 if (flag
& SHF_MASKOS
)
3482 sh_flags
&= ~ SHF_MASKOS
;
3484 else if (flag
& SHF_MASKPROC
)
3487 sh_flags
&= ~ SHF_MASKPROC
;
3499 process_section_headers (file
)
3502 Elf_Internal_Shdr
*section
;
3505 section_headers
= NULL
;
3507 if (elf_header
.e_shnum
== 0)
3510 printf (_("\nThere are no sections in this file.\n"));
3515 if (do_sections
&& !do_header
)
3516 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3517 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3521 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3524 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3527 /* Read in the string table, so that we have names to display. */
3528 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3530 if (section
->sh_size
!= 0)
3532 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3533 section
->sh_size
, _("string table"));
3535 string_table_length
= section
->sh_size
;
3538 /* Scan the sections for the dynamic symbol table
3539 and dynamic string table and debug sections. */
3540 dynamic_symbols
= NULL
;
3541 dynamic_strings
= NULL
;
3542 dynamic_syminfo
= NULL
;
3543 symtab_shndx_hdr
= NULL
;
3545 for (i
= 0, section
= section_headers
;
3546 i
< elf_header
.e_shnum
;
3549 char *name
= SECTION_NAME (section
);
3551 if (section
->sh_type
== SHT_DYNSYM
)
3553 if (dynamic_symbols
!= NULL
)
3555 error (_("File contains multiple dynamic symbol tables\n"));
3559 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3560 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3562 else if (section
->sh_type
== SHT_STRTAB
3563 && strcmp (name
, ".dynstr") == 0)
3565 if (dynamic_strings
!= NULL
)
3567 error (_("File contains multiple dynamic string tables\n"));
3571 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3573 _("dynamic strings"));
3575 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3577 if (symtab_shndx_hdr
!= NULL
)
3579 error (_("File contains multiple symtab shndx tables\n"));
3582 symtab_shndx_hdr
= section
;
3584 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3585 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3586 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3588 && strncmp (name
, ".debug_", 7) == 0)
3593 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3594 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3595 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3596 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3597 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3598 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3599 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3600 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3601 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3603 request_dump (i
, DEBUG_DUMP
);
3605 /* linkonce section to be combined with .debug_info at link time. */
3606 else if ((do_debugging
|| do_debug_info
)
3607 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3608 request_dump (i
, DEBUG_DUMP
);
3609 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3610 request_dump (i
, DEBUG_DUMP
);
3616 if (elf_header
.e_shnum
> 1)
3617 printf (_("\nSection Headers:\n"));
3619 printf (_("\nSection Header:\n"));
3623 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3626 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3629 printf (_(" [Nr] Name Type Address Offset\n"));
3630 printf (_(" Size EntSize Flags Link Info Align\n"));
3633 for (i
= 0, section
= section_headers
;
3634 i
< elf_header
.e_shnum
;
3637 printf (" [%2u] %-17.17s %-15.15s ",
3638 SECTION_HEADER_NUM (i
),
3639 SECTION_NAME (section
),
3640 get_section_type_name (section
->sh_type
));
3644 print_vma (section
->sh_addr
, LONG_HEX
);
3646 printf ( " %6.6lx %6.6lx %2.2lx",
3647 (unsigned long) section
->sh_offset
,
3648 (unsigned long) section
->sh_size
,
3649 (unsigned long) section
->sh_entsize
);
3651 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3653 printf ("%2ld %3lx %2ld\n",
3654 (unsigned long) section
->sh_link
,
3655 (unsigned long) section
->sh_info
,
3656 (unsigned long) section
->sh_addralign
);
3660 print_vma (section
->sh_addr
, LONG_HEX
);
3662 if ((long) section
->sh_offset
== section
->sh_offset
)
3663 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3667 print_vma (section
->sh_offset
, LONG_HEX
);
3670 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3671 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3675 print_vma (section
->sh_size
, LONG_HEX
);
3678 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3679 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3683 print_vma (section
->sh_entsize
, LONG_HEX
);
3686 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3688 printf ("%2ld %3lx ",
3689 (unsigned long) section
->sh_link
,
3690 (unsigned long) section
->sh_info
);
3692 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3693 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3696 print_vma (section
->sh_addralign
, DEC
);
3703 print_vma (section
->sh_addr
, LONG_HEX
);
3704 if ((long) section
->sh_offset
== section
->sh_offset
)
3705 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3709 print_vma (section
->sh_offset
, LONG_HEX
);
3712 print_vma (section
->sh_size
, LONG_HEX
);
3714 print_vma (section
->sh_entsize
, LONG_HEX
);
3716 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3718 printf (" %2ld %3lx %ld\n",
3719 (unsigned long) section
->sh_link
,
3720 (unsigned long) section
->sh_info
,
3721 (unsigned long) section
->sh_addralign
);
3725 printf (_("Key to Flags:\n\
3726 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3727 I (info), L (link order), G (group), x (unknown)\n\
3728 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3733 /* Process the reloc section. */
3735 process_relocs (file
)
3738 unsigned long rel_size
;
3739 unsigned long rel_offset
;
3745 if (do_using_dynamic
)
3747 int is_rela
= FALSE
;
3752 if (dynamic_info
[DT_REL
])
3754 rel_offset
= dynamic_info
[DT_REL
];
3755 rel_size
= dynamic_info
[DT_RELSZ
];
3758 else if (dynamic_info
[DT_RELA
])
3760 rel_offset
= dynamic_info
[DT_RELA
];
3761 rel_size
= dynamic_info
[DT_RELASZ
];
3764 else if (dynamic_info
[DT_JMPREL
])
3766 rel_offset
= dynamic_info
[DT_JMPREL
];
3767 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3769 switch (dynamic_info
[DT_PLTREL
])
3786 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3787 rel_offset
, rel_size
);
3789 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3790 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3793 printf (_("\nThere are no dynamic relocations in this file.\n"));
3797 Elf_Internal_Shdr
*section
;
3801 for (i
= 0, section
= section_headers
;
3802 i
< elf_header
.e_shnum
;
3805 if ( section
->sh_type
!= SHT_RELA
3806 && section
->sh_type
!= SHT_REL
)
3809 rel_offset
= section
->sh_offset
;
3810 rel_size
= section
->sh_size
;
3814 Elf_Internal_Shdr
*strsec
;
3815 Elf_Internal_Sym
*symtab
;
3818 unsigned long nsyms
;
3820 printf (_("\nRelocation section "));
3822 if (string_table
== NULL
)
3823 printf ("%d", section
->sh_name
);
3825 printf (_("'%s'"), SECTION_NAME (section
));
3827 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3828 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3833 if (section
->sh_link
)
3835 Elf_Internal_Shdr
*symsec
;
3837 symsec
= SECTION_HEADER (section
->sh_link
);
3838 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3839 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3844 strsec
= SECTION_HEADER (symsec
->sh_link
);
3846 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3850 is_rela
= section
->sh_type
== SHT_RELA
;
3852 dump_relocations (file
, rel_offset
, rel_size
,
3853 symtab
, nsyms
, strtab
, is_rela
);
3865 printf (_("\nThere are no relocations in this file.\n"));
3871 #include "unwind-ia64.h"
3873 /* An absolute address consists of a section and an offset. If the
3874 section is NULL, the offset itself is the address, otherwise, the
3875 address equals to LOAD_ADDRESS(section) + offset. */
3879 unsigned short section
;
3885 struct unw_table_entry
3887 struct absaddr start
;
3889 struct absaddr info
;
3891 *table
; /* Unwind table. */
3892 unsigned long table_len
; /* Length of unwind table. */
3893 unsigned char *info
; /* Unwind info. */
3894 unsigned long info_size
; /* Size of unwind info. */
3895 bfd_vma info_addr
; /* starting address of unwind info. */
3896 bfd_vma seg_base
; /* Starting address of segment. */
3897 Elf_Internal_Sym
*symtab
; /* The symbol table. */
3898 unsigned long nsyms
; /* Number of symbols. */
3899 char *strtab
; /* The string table. */
3900 unsigned long strtab_size
; /* Size of string table. */
3903 static void find_symbol_for_address
3904 PARAMS ((struct unw_aux_info
*, struct absaddr
, const char **, bfd_vma
*));
3905 static void dump_ia64_unwind
3906 PARAMS ((struct unw_aux_info
*));
3907 static int slurp_ia64_unwind_table
3908 PARAMS ((FILE *, struct unw_aux_info
*, Elf_Internal_Shdr
*));
3911 find_symbol_for_address (aux
, addr
, symname
, offset
)
3912 struct unw_aux_info
*aux
;
3913 struct absaddr addr
;
3914 const char **symname
;
3917 bfd_vma dist
= (bfd_vma
) 0x100000;
3918 Elf_Internal_Sym
*sym
, *best
= NULL
;
3921 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3923 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3924 && sym
->st_name
!= 0
3925 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3926 && addr
.offset
>= sym
->st_value
3927 && addr
.offset
- sym
->st_value
< dist
)
3930 dist
= addr
.offset
- sym
->st_value
;
3937 *symname
= (best
->st_name
>= aux
->strtab_size
3938 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3943 *offset
= addr
.offset
;
3947 dump_ia64_unwind (aux
)
3948 struct unw_aux_info
*aux
;
3951 struct unw_table_entry
*tp
;
3954 addr_size
= is_32bit_elf
? 4 : 8;
3956 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3960 const unsigned char *dp
;
3961 const unsigned char *head
;
3962 const char *procname
;
3964 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3966 fputs ("\n<", stdout
);
3970 fputs (procname
, stdout
);
3973 printf ("+%lx", (unsigned long) offset
);
3976 fputs (">: [", stdout
);
3977 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3978 fputc ('-', stdout
);
3979 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3980 printf ("], info at +0x%lx\n",
3981 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3983 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3984 stamp
= BYTE_GET8 ((unsigned char *) head
);
3986 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
3987 (unsigned) UNW_VER (stamp
),
3988 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3989 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3990 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3991 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3993 if (UNW_VER (stamp
) != 1)
3995 printf ("\tUnknown version.\n");
4000 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4001 dp
= unw_decode (dp
, in_body
, & in_body
);
4006 slurp_ia64_unwind_table (file
, aux
, sec
)
4008 struct unw_aux_info
*aux
;
4009 Elf_Internal_Shdr
*sec
;
4011 unsigned long size
, addr_size
, nrelas
, i
;
4012 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
4013 struct unw_table_entry
*tep
;
4014 Elf_Internal_Shdr
*relsec
;
4015 Elf_Internal_Rela
*rela
, *rp
;
4016 unsigned char *table
, *tp
;
4017 Elf_Internal_Sym
*sym
;
4018 const char *relname
;
4021 addr_size
= is_32bit_elf
? 4 : 8;
4023 /* First, find the starting address of the segment that includes
4026 if (elf_header
.e_phnum
)
4028 prog_hdrs
= (Elf_Internal_Phdr
*)
4029 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
4032 result
= get_32bit_program_headers (file
, prog_hdrs
);
4034 result
= get_64bit_program_headers (file
, prog_hdrs
);
4042 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
4044 if (seg
->p_type
!= PT_LOAD
)
4047 if (sec
->sh_addr
>= seg
->p_vaddr
4048 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4050 aux
->seg_base
= seg
->p_vaddr
;
4058 /* Second, build the unwind table from the contents of the unwind section: */
4059 size
= sec
->sh_size
;
4060 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4061 size
, _("unwind table"));
4065 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4066 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4068 tep
->start
.section
= SHN_UNDEF
;
4069 tep
->end
.section
= SHN_UNDEF
;
4070 tep
->info
.section
= SHN_UNDEF
;
4073 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4074 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4075 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4079 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4080 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4081 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4083 tep
->start
.offset
+= aux
->seg_base
;
4084 tep
->end
.offset
+= aux
->seg_base
;
4085 tep
->info
.offset
+= aux
->seg_base
;
4089 /* Third, apply any relocations to the unwind table: */
4091 for (relsec
= section_headers
;
4092 relsec
< section_headers
+ elf_header
.e_shnum
;
4095 if (relsec
->sh_type
!= SHT_RELA
4096 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4099 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4103 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4107 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4108 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4110 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4112 warn (_("Skipping unexpected symbol type %u\n"),
4113 ELF32_ST_TYPE (sym
->st_info
));
4119 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4120 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4122 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4124 warn (_("Skipping unexpected symbol type %u\n"),
4125 ELF64_ST_TYPE (sym
->st_info
));
4130 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4132 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4136 i
= rp
->r_offset
/ (3 * addr_size
);
4138 switch (rp
->r_offset
/addr_size
% 3)
4141 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4142 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4145 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4146 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4149 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4150 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4160 aux
->table_len
= size
/ (3 * addr_size
);
4165 process_unwind (file
)
4168 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4169 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4170 struct unw_aux_info aux
;
4175 if (elf_header
.e_machine
!= EM_IA_64
)
4177 printf (_("\nThere are no unwind sections in this file.\n"));
4181 memset (& aux
, 0, sizeof (aux
));
4183 addr_size
= is_32bit_elf
? 4 : 8;
4185 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4187 if (sec
->sh_type
== SHT_SYMTAB
)
4189 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4190 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4192 strsec
= SECTION_HEADER (sec
->sh_link
);
4193 aux
.strtab_size
= strsec
->sh_size
;
4194 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4195 aux
.strtab_size
, _("string table"));
4197 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4202 printf (_("\nThere are no unwind sections in this file.\n"));
4204 while (unwcount
-- > 0)
4209 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4210 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4211 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4218 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4220 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
4223 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4224 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4225 suffix
= SECTION_NAME (unwsec
) + len
;
4226 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4228 if (strncmp (SECTION_NAME (sec
),
4229 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4230 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4235 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4236 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4237 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4238 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4240 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4242 suffix
= SECTION_NAME (unwsec
) + len
;
4243 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4245 if (strncmp (SECTION_NAME (sec
),
4246 ELF_STRING_ia64_unwind_info
, len2
) == 0
4247 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4251 if (i
== elf_header
.e_shnum
)
4253 printf (_("\nCould not find unwind info section for "));
4255 if (string_table
== NULL
)
4256 printf ("%d", unwsec
->sh_name
);
4258 printf (_("'%s'"), SECTION_NAME (unwsec
));
4262 aux
.info_size
= sec
->sh_size
;
4263 aux
.info_addr
= sec
->sh_addr
;
4264 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4265 aux
.info_size
, _("unwind info"));
4267 printf (_("\nUnwind section "));
4269 if (string_table
== NULL
)
4270 printf ("%d", unwsec
->sh_name
);
4272 printf (_("'%s'"), SECTION_NAME (unwsec
));
4274 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4275 (unsigned long) unwsec
->sh_offset
,
4276 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4278 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4280 if (aux
.table_len
> 0)
4281 dump_ia64_unwind (& aux
);
4284 free ((char *) aux
.table
);
4286 free ((char *) aux
.info
);
4295 free ((char *) aux
.strtab
);
4301 dynamic_segment_mips_val (entry
)
4302 Elf_Internal_Dyn
*entry
;
4304 switch (entry
->d_tag
)
4307 if (entry
->d_un
.d_val
== 0)
4311 static const char * opts
[] =
4313 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4314 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4315 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4316 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4321 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4322 if (entry
->d_un
.d_val
& (1 << cnt
))
4324 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4331 case DT_MIPS_IVERSION
:
4332 if (dynamic_strings
!= NULL
)
4333 printf ("Interface Version: %s\n",
4334 dynamic_strings
+ entry
->d_un
.d_val
);
4336 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4339 case DT_MIPS_TIME_STAMP
:
4344 time_t time
= entry
->d_un
.d_val
;
4345 tmp
= gmtime (&time
);
4346 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4347 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4348 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4349 printf ("Time Stamp: %s\n", timebuf
);
4353 case DT_MIPS_RLD_VERSION
:
4354 case DT_MIPS_LOCAL_GOTNO
:
4355 case DT_MIPS_CONFLICTNO
:
4356 case DT_MIPS_LIBLISTNO
:
4357 case DT_MIPS_SYMTABNO
:
4358 case DT_MIPS_UNREFEXTNO
:
4359 case DT_MIPS_HIPAGENO
:
4360 case DT_MIPS_DELTA_CLASS_NO
:
4361 case DT_MIPS_DELTA_INSTANCE_NO
:
4362 case DT_MIPS_DELTA_RELOC_NO
:
4363 case DT_MIPS_DELTA_SYM_NO
:
4364 case DT_MIPS_DELTA_CLASSSYM_NO
:
4365 case DT_MIPS_COMPACT_SIZE
:
4366 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4370 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4376 dynamic_segment_parisc_val (entry
)
4377 Elf_Internal_Dyn
*entry
;
4379 switch (entry
->d_tag
)
4381 case DT_HP_DLD_FLAGS
:
4390 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4391 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4392 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4393 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4394 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4395 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4396 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4397 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4398 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4399 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4400 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4404 bfd_vma val
= entry
->d_un
.d_val
;
4406 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4407 if (val
& flags
[cnt
].bit
)
4411 fputs (flags
[cnt
].str
, stdout
);
4413 val
^= flags
[cnt
].bit
;
4416 if (val
!= 0 || first
)
4420 print_vma (val
, HEX
);
4426 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4433 get_32bit_dynamic_segment (file
)
4436 Elf32_External_Dyn
*edyn
;
4437 Elf_Internal_Dyn
*entry
;
4440 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4441 dynamic_size
, _("dynamic segment"));
4445 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4446 how large this .dynamic is now. We can do this even before the byte
4447 swapping since the DT_NULL tag is recognizable. */
4449 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4452 dynamic_segment
= (Elf_Internal_Dyn
*)
4453 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4455 if (dynamic_segment
== NULL
)
4457 error (_("Out of memory\n"));
4462 for (i
= 0, entry
= dynamic_segment
;
4466 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4467 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4476 get_64bit_dynamic_segment (file
)
4479 Elf64_External_Dyn
*edyn
;
4480 Elf_Internal_Dyn
*entry
;
4483 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4484 dynamic_size
, _("dynamic segment"));
4488 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4489 how large this .dynamic is now. We can do this even before the byte
4490 swapping since the DT_NULL tag is recognizable. */
4492 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4495 dynamic_segment
= (Elf_Internal_Dyn
*)
4496 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4498 if (dynamic_segment
== NULL
)
4500 error (_("Out of memory\n"));
4505 for (i
= 0, entry
= dynamic_segment
;
4509 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4510 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4519 get_dynamic_flags (flags
)
4522 static char buff
[128];
4530 flag
= flags
& - flags
;
4538 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4539 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4540 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4541 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4542 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4543 default: strcpy (p
, "unknown"); break;
4546 p
= strchr (p
, '\0');
4551 /* Parse and display the contents of the dynamic segment. */
4553 process_dynamic_segment (file
)
4556 Elf_Internal_Dyn
*entry
;
4559 if (dynamic_size
== 0)
4562 printf (_("\nThere is no dynamic segment in this file.\n"));
4569 if (! get_32bit_dynamic_segment (file
))
4572 else if (! get_64bit_dynamic_segment (file
))
4575 /* Find the appropriate symbol table. */
4576 if (dynamic_symbols
== NULL
)
4578 for (i
= 0, entry
= dynamic_segment
;
4582 Elf_Internal_Shdr section
;
4584 if (entry
->d_tag
!= DT_SYMTAB
)
4587 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4589 /* Since we do not know how big the symbol table is,
4590 we default to reading in the entire file (!) and
4591 processing that. This is overkill, I know, but it
4593 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4595 if (fseek (file
, 0, SEEK_END
))
4596 error (_("Unable to seek to end of file!"));
4598 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4600 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4602 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4604 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4605 if (num_dynamic_syms
< 1)
4607 error (_("Unable to determine the number of symbols to load\n"));
4611 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4615 /* Similarly find a string table. */
4616 if (dynamic_strings
== NULL
)
4618 for (i
= 0, entry
= dynamic_segment
;
4622 unsigned long offset
;
4625 if (entry
->d_tag
!= DT_STRTAB
)
4628 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4630 /* Since we do not know how big the string table is,
4631 we default to reading in the entire file (!) and
4632 processing that. This is overkill, I know, but it
4635 offset
= entry
->d_un
.d_val
- loadaddr
;
4636 if (fseek (file
, 0, SEEK_END
))
4637 error (_("Unable to seek to end of file\n"));
4638 str_tab_len
= ftell (file
) - offset
;
4640 if (str_tab_len
< 1)
4643 (_("Unable to determine the length of the dynamic string table\n"));
4647 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4648 _("dynamic string table"));
4653 /* And find the syminfo section if available. */
4654 if (dynamic_syminfo
== NULL
)
4656 unsigned int syminsz
= 0;
4658 for (i
= 0, entry
= dynamic_segment
;
4662 if (entry
->d_tag
== DT_SYMINENT
)
4664 /* Note: these braces are necessary to avoid a syntax
4665 error from the SunOS4 C compiler. */
4666 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4668 else if (entry
->d_tag
== DT_SYMINSZ
)
4669 syminsz
= entry
->d_un
.d_val
;
4670 else if (entry
->d_tag
== DT_SYMINFO
)
4671 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4674 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4676 Elf_External_Syminfo
*extsyminfo
;
4677 Elf_Internal_Syminfo
*syminfo
;
4679 /* There is a syminfo section. Read the data. */
4680 extsyminfo
= ((Elf_External_Syminfo
*)
4681 get_data (NULL
, file
, dynamic_syminfo_offset
,
4682 syminsz
, _("symbol information")));
4686 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4687 if (dynamic_syminfo
== NULL
)
4689 error (_("Out of memory\n"));
4693 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4694 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4697 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4698 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4705 if (do_dynamic
&& dynamic_addr
)
4706 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4707 dynamic_addr
, (long) dynamic_size
);
4709 printf (_(" Tag Type Name/Value\n"));
4711 for (i
= 0, entry
= dynamic_segment
;
4720 print_vma (entry
->d_tag
, FULL_HEX
);
4721 dtype
= get_dynamic_type (entry
->d_tag
);
4722 printf (" (%s)%*s", dtype
,
4723 ((is_32bit_elf
? 27 : 19)
4724 - (int) strlen (dtype
)),
4728 switch (entry
->d_tag
)
4732 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4742 switch (entry
->d_tag
)
4745 printf (_("Auxiliary library"));
4749 printf (_("Filter library"));
4753 printf (_("Configuration file"));
4757 printf (_("Dependency audit library"));
4761 printf (_("Audit library"));
4765 if (dynamic_strings
)
4766 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4770 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4779 printf (_("Flags:"));
4781 if (entry
->d_un
.d_val
== 0)
4782 printf (_(" None\n"));
4785 unsigned long int val
= entry
->d_un
.d_val
;
4787 if (val
& DTF_1_PARINIT
)
4789 printf (" PARINIT");
4790 val
^= DTF_1_PARINIT
;
4792 if (val
& DTF_1_CONFEXP
)
4794 printf (" CONFEXP");
4795 val
^= DTF_1_CONFEXP
;
4798 printf (" %lx", val
);
4807 printf (_("Flags:"));
4809 if (entry
->d_un
.d_val
== 0)
4810 printf (_(" None\n"));
4813 unsigned long int val
= entry
->d_un
.d_val
;
4815 if (val
& DF_P1_LAZYLOAD
)
4817 printf (" LAZYLOAD");
4818 val
^= DF_P1_LAZYLOAD
;
4820 if (val
& DF_P1_GROUPPERM
)
4822 printf (" GROUPPERM");
4823 val
^= DF_P1_GROUPPERM
;
4826 printf (" %lx", val
);
4835 printf (_("Flags:"));
4836 if (entry
->d_un
.d_val
== 0)
4837 printf (_(" None\n"));
4840 unsigned long int val
= entry
->d_un
.d_val
;
4847 if (val
& DF_1_GLOBAL
)
4852 if (val
& DF_1_GROUP
)
4857 if (val
& DF_1_NODELETE
)
4859 printf (" NODELETE");
4860 val
^= DF_1_NODELETE
;
4862 if (val
& DF_1_LOADFLTR
)
4864 printf (" LOADFLTR");
4865 val
^= DF_1_LOADFLTR
;
4867 if (val
& DF_1_INITFIRST
)
4869 printf (" INITFIRST");
4870 val
^= DF_1_INITFIRST
;
4872 if (val
& DF_1_NOOPEN
)
4877 if (val
& DF_1_ORIGIN
)
4882 if (val
& DF_1_DIRECT
)
4887 if (val
& DF_1_TRANS
)
4892 if (val
& DF_1_INTERPOSE
)
4894 printf (" INTERPOSE");
4895 val
^= DF_1_INTERPOSE
;
4897 if (val
& DF_1_NODEFLIB
)
4899 printf (" NODEFLIB");
4900 val
^= DF_1_NODEFLIB
;
4902 if (val
& DF_1_NODUMP
)
4907 if (val
& DF_1_CONLFAT
)
4909 printf (" CONLFAT");
4910 val
^= DF_1_CONLFAT
;
4913 printf (" %lx", val
);
4921 puts (get_dynamic_type (entry
->d_un
.d_val
));
4941 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4947 if (dynamic_strings
== NULL
)
4950 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4954 switch (entry
->d_tag
)
4957 printf (_("Shared library: [%s]"), name
);
4959 if (strcmp (name
, program_interpreter
) == 0)
4960 printf (_(" program interpreter"));
4964 printf (_("Library soname: [%s]"), name
);
4968 printf (_("Library rpath: [%s]"), name
);
4972 printf (_("Library runpath: [%s]"), name
);
4976 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4981 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4997 case DT_INIT_ARRAYSZ
:
4998 case DT_FINI_ARRAYSZ
:
4999 case DT_GNU_CONFLICTSZ
:
5000 case DT_GNU_LIBLISTSZ
:
5003 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5004 printf (" (bytes)\n");
5014 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5027 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
5031 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5035 printf (_("Not needed object: [%s]\n"), name
);
5040 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5046 /* The value of this entry is ignored. */
5051 case DT_GNU_PRELINKED
:
5055 time_t time
= entry
->d_un
.d_val
;
5057 tmp
= gmtime (&time
);
5058 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5059 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5060 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5066 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5067 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5072 switch (elf_header
.e_machine
)
5075 case EM_MIPS_RS3_LE
:
5076 dynamic_segment_mips_val (entry
);
5079 dynamic_segment_parisc_val (entry
);
5082 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5094 get_ver_flags (flags
)
5097 static char buff
[32];
5104 if (flags
& VER_FLG_BASE
)
5105 strcat (buff
, "BASE ");
5107 if (flags
& VER_FLG_WEAK
)
5109 if (flags
& VER_FLG_BASE
)
5110 strcat (buff
, "| ");
5112 strcat (buff
, "WEAK ");
5115 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5116 strcat (buff
, "| <unknown>");
5121 /* Display the contents of the version sections. */
5123 process_version_sections (file
)
5126 Elf_Internal_Shdr
*section
;
5133 for (i
= 0, section
= section_headers
;
5134 i
< elf_header
.e_shnum
;
5137 switch (section
->sh_type
)
5139 case SHT_GNU_verdef
:
5141 Elf_External_Verdef
*edefs
;
5148 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5149 SECTION_NAME (section
), section
->sh_info
);
5151 printf (_(" Addr: 0x"));
5152 printf_vma (section
->sh_addr
);
5153 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5154 (unsigned long) section
->sh_offset
, section
->sh_link
,
5155 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5157 edefs
= ((Elf_External_Verdef
*)
5158 get_data (NULL
, file
, section
->sh_offset
,
5160 _("version definition section")));
5164 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5167 Elf_External_Verdef
*edef
;
5168 Elf_Internal_Verdef ent
;
5169 Elf_External_Verdaux
*eaux
;
5170 Elf_Internal_Verdaux aux
;
5174 vstart
= ((char *) edefs
) + idx
;
5176 edef
= (Elf_External_Verdef
*) vstart
;
5178 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5179 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5180 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5181 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5182 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5183 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5184 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5186 printf (_(" %#06x: Rev: %d Flags: %s"),
5187 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5189 printf (_(" Index: %d Cnt: %d "),
5190 ent
.vd_ndx
, ent
.vd_cnt
);
5192 vstart
+= ent
.vd_aux
;
5194 eaux
= (Elf_External_Verdaux
*) vstart
;
5196 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5197 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5199 if (dynamic_strings
)
5200 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5202 printf (_("Name index: %ld\n"), aux
.vda_name
);
5204 isum
= idx
+ ent
.vd_aux
;
5206 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5208 isum
+= aux
.vda_next
;
5209 vstart
+= aux
.vda_next
;
5211 eaux
= (Elf_External_Verdaux
*) vstart
;
5213 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5214 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5216 if (dynamic_strings
)
5217 printf (_(" %#06x: Parent %d: %s\n"),
5218 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5220 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5221 isum
, j
, aux
.vda_name
);
5231 case SHT_GNU_verneed
:
5233 Elf_External_Verneed
*eneed
;
5239 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5240 SECTION_NAME (section
), section
->sh_info
);
5242 printf (_(" Addr: 0x"));
5243 printf_vma (section
->sh_addr
);
5244 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5245 (unsigned long) section
->sh_offset
, section
->sh_link
,
5246 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5248 eneed
= ((Elf_External_Verneed
*)
5249 get_data (NULL
, file
, section
->sh_offset
,
5250 section
->sh_size
, _("version need section")));
5254 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5256 Elf_External_Verneed
*entry
;
5257 Elf_Internal_Verneed ent
;
5262 vstart
= ((char *) eneed
) + idx
;
5264 entry
= (Elf_External_Verneed
*) vstart
;
5266 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5267 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5268 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5269 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5270 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5272 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5274 if (dynamic_strings
)
5275 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5277 printf (_(" File: %lx"), ent
.vn_file
);
5279 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5281 vstart
+= ent
.vn_aux
;
5283 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5285 Elf_External_Vernaux
*eaux
;
5286 Elf_Internal_Vernaux aux
;
5288 eaux
= (Elf_External_Vernaux
*) vstart
;
5290 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5291 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5292 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5293 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5294 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5296 if (dynamic_strings
)
5297 printf (_(" %#06x: Name: %s"),
5298 isum
, dynamic_strings
+ aux
.vna_name
);
5300 printf (_(" %#06x: Name index: %lx"),
5301 isum
, aux
.vna_name
);
5303 printf (_(" Flags: %s Version: %d\n"),
5304 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5306 isum
+= aux
.vna_next
;
5307 vstart
+= aux
.vna_next
;
5317 case SHT_GNU_versym
:
5319 Elf_Internal_Shdr
*link_section
;
5322 unsigned char *edata
;
5323 unsigned short *data
;
5325 Elf_Internal_Sym
*symbols
;
5326 Elf_Internal_Shdr
*string_sec
;
5328 link_section
= SECTION_HEADER (section
->sh_link
);
5329 total
= section
->sh_size
/ section
->sh_entsize
;
5333 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5335 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5337 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5338 string_sec
->sh_size
,
5339 _("version string table"));
5343 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5344 SECTION_NAME (section
), total
);
5346 printf (_(" Addr: "));
5347 printf_vma (section
->sh_addr
);
5348 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5349 (unsigned long) section
->sh_offset
, section
->sh_link
,
5350 SECTION_NAME (link_section
));
5354 get_data (NULL
, file
,
5355 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5356 total
* sizeof (short), _("version symbol data")));
5363 data
= (unsigned short *) malloc (total
* sizeof (short));
5365 for (cnt
= total
; cnt
--;)
5366 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5371 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5374 int check_def
, check_need
;
5377 printf (" %03x:", cnt
);
5379 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5380 switch (data
[cnt
+ j
])
5383 fputs (_(" 0 (*local*) "), stdout
);
5387 fputs (_(" 1 (*global*) "), stdout
);
5391 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5392 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5396 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5399 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5406 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5408 Elf_Internal_Verneed ivn
;
5409 unsigned long offset
;
5411 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5416 Elf_Internal_Vernaux ivna
;
5417 Elf_External_Verneed evn
;
5418 Elf_External_Vernaux evna
;
5419 unsigned long a_off
;
5421 get_data (&evn
, file
, offset
, sizeof (evn
),
5424 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5425 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5427 a_off
= offset
+ ivn
.vn_aux
;
5431 get_data (&evna
, file
, a_off
, sizeof (evna
),
5432 _("version need aux (2)"));
5434 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5435 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5437 a_off
+= ivna
.vna_next
;
5439 while (ivna
.vna_other
!= data
[cnt
+ j
]
5440 && ivna
.vna_next
!= 0);
5442 if (ivna
.vna_other
== data
[cnt
+ j
])
5444 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5446 name
= strtab
+ ivna
.vna_name
;
5447 nn
+= printf ("(%s%-*s",
5449 12 - (int) strlen (name
),
5455 offset
+= ivn
.vn_next
;
5457 while (ivn
.vn_next
);
5460 if (check_def
&& data
[cnt
+ j
] != 0x8001
5461 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5463 Elf_Internal_Verdef ivd
;
5464 Elf_External_Verdef evd
;
5465 unsigned long offset
;
5467 offset
= (version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5472 get_data (&evd
, file
, offset
, sizeof (evd
),
5475 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5476 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5478 offset
+= ivd
.vd_next
;
5480 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5481 && ivd
.vd_next
!= 0);
5483 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5485 Elf_External_Verdaux evda
;
5486 Elf_Internal_Verdaux ivda
;
5488 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5490 get_data (&evda
, file
,
5491 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5492 sizeof (evda
), _("version def aux"));
5494 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5496 name
= strtab
+ ivda
.vda_name
;
5497 nn
+= printf ("(%s%-*s",
5499 12 - (int) strlen (name
),
5505 printf ("%*c", 18 - nn
, ' ');
5523 printf (_("\nNo version information found in this file.\n"));
5529 get_symbol_binding (binding
)
5530 unsigned int binding
;
5532 static char buff
[32];
5536 case STB_LOCAL
: return "LOCAL";
5537 case STB_GLOBAL
: return "GLOBAL";
5538 case STB_WEAK
: return "WEAK";
5540 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5541 sprintf (buff
, _("<processor specific>: %d"), binding
);
5542 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5543 sprintf (buff
, _("<OS specific>: %d"), binding
);
5545 sprintf (buff
, _("<unknown>: %d"), binding
);
5551 get_symbol_type (type
)
5554 static char buff
[32];
5558 case STT_NOTYPE
: return "NOTYPE";
5559 case STT_OBJECT
: return "OBJECT";
5560 case STT_FUNC
: return "FUNC";
5561 case STT_SECTION
: return "SECTION";
5562 case STT_FILE
: return "FILE";
5563 case STT_COMMON
: return "COMMON";
5564 case STT_TLS
: return "TLS";
5566 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5568 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5569 return "THUMB_FUNC";
5571 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5574 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5575 return "PARISC_MILLI";
5577 sprintf (buff
, _("<processor specific>: %d"), type
);
5579 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5581 if (elf_header
.e_machine
== EM_PARISC
)
5583 if (type
== STT_HP_OPAQUE
)
5585 if (type
== STT_HP_STUB
)
5589 sprintf (buff
, _("<OS specific>: %d"), type
);
5592 sprintf (buff
, _("<unknown>: %d"), type
);
5598 get_symbol_visibility (visibility
)
5599 unsigned int visibility
;
5603 case STV_DEFAULT
: return "DEFAULT";
5604 case STV_INTERNAL
: return "INTERNAL";
5605 case STV_HIDDEN
: return "HIDDEN";
5606 case STV_PROTECTED
: return "PROTECTED";
5612 get_symbol_index_type (type
)
5615 static char buff
[32];
5619 case SHN_UNDEF
: return "UND";
5620 case SHN_ABS
: return "ABS";
5621 case SHN_COMMON
: return "COM";
5623 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5624 sprintf (buff
, "PRC[0x%04x]", type
);
5625 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5626 sprintf (buff
, "OS [0x%04x]", type
);
5627 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5628 sprintf (buff
, "RSV[0x%04x]", type
);
5630 sprintf (buff
, "%3d", type
);
5638 get_dynamic_data (file
, number
)
5640 unsigned int number
;
5642 unsigned char *e_data
;
5645 e_data
= (unsigned char *) malloc (number
* 4);
5649 error (_("Out of memory\n"));
5653 if (fread (e_data
, 4, number
, file
) != number
)
5655 error (_("Unable to read in dynamic data\n"));
5659 i_data
= (int *) malloc (number
* sizeof (*i_data
));
5663 error (_("Out of memory\n"));
5669 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5676 /* Dump the symbol table. */
5678 process_symbol_table (file
)
5681 Elf_Internal_Shdr
*section
;
5682 unsigned char nb
[4];
5683 unsigned char nc
[4];
5686 int *buckets
= NULL
;
5689 if (! do_syms
&& !do_histogram
)
5692 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5695 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5697 error (_("Unable to seek to start of dynamic information"));
5701 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5703 error (_("Failed to read in number of buckets\n"));
5707 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5709 error (_("Failed to read in number of chains\n"));
5713 nbuckets
= byte_get (nb
, 4);
5714 nchains
= byte_get (nc
, 4);
5716 buckets
= get_dynamic_data (file
, nbuckets
);
5717 chains
= get_dynamic_data (file
, nchains
);
5719 if (buckets
== NULL
|| chains
== NULL
)
5724 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5729 printf (_("\nSymbol table for image:\n"));
5731 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5733 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5735 for (hn
= 0; hn
< nbuckets
; hn
++)
5740 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5742 Elf_Internal_Sym
*psym
;
5744 psym
= dynamic_symbols
+ si
;
5746 printf (" %3d %3d: ", si
, hn
);
5747 print_vma (psym
->st_value
, LONG_HEX
);
5749 print_vma (psym
->st_size
, DEC_5
);
5751 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5752 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5753 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5754 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5755 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5760 else if (do_syms
&& !do_using_dynamic
)
5764 for (i
= 0, section
= section_headers
;
5765 i
< elf_header
.e_shnum
;
5770 Elf_Internal_Sym
*symtab
;
5771 Elf_Internal_Sym
*psym
;
5774 if ( section
->sh_type
!= SHT_SYMTAB
5775 && section
->sh_type
!= SHT_DYNSYM
)
5778 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5779 SECTION_NAME (section
),
5780 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5782 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5784 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5786 symtab
= GET_ELF_SYMBOLS (file
, section
);
5790 if (section
->sh_link
== elf_header
.e_shstrndx
)
5791 strtab
= string_table
;
5794 Elf_Internal_Shdr
*string_sec
;
5796 string_sec
= SECTION_HEADER (section
->sh_link
);
5798 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5799 string_sec
->sh_size
,
5803 for (si
= 0, psym
= symtab
;
5804 si
< section
->sh_size
/ section
->sh_entsize
;
5807 printf ("%6d: ", si
);
5808 print_vma (psym
->st_value
, LONG_HEX
);
5810 print_vma (psym
->st_size
, DEC_5
);
5811 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5812 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5813 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5814 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5815 print_symbol (25, strtab
+ psym
->st_name
);
5817 if (section
->sh_type
== SHT_DYNSYM
&&
5818 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5820 unsigned char data
[2];
5821 unsigned short vers_data
;
5822 unsigned long offset
;
5826 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5829 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5830 sizeof (data
), _("version data"));
5832 vers_data
= byte_get (data
, 2);
5834 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5837 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5839 if ((vers_data
& 0x8000) || vers_data
> 1)
5841 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5842 && (is_nobits
|| ! check_def
))
5844 Elf_External_Verneed evn
;
5845 Elf_Internal_Verneed ivn
;
5846 Elf_Internal_Vernaux ivna
;
5848 /* We must test both. */
5849 offset
= (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5854 unsigned long vna_off
;
5856 get_data (&evn
, file
, offset
, sizeof (evn
),
5859 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5860 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5862 vna_off
= offset
+ ivn
.vn_aux
;
5866 Elf_External_Vernaux evna
;
5868 get_data (&evna
, file
, vna_off
,
5870 _("version need aux (3)"));
5872 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5873 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5874 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5876 vna_off
+= ivna
.vna_next
;
5878 while (ivna
.vna_other
!= vers_data
5879 && ivna
.vna_next
!= 0);
5881 if (ivna
.vna_other
== vers_data
)
5884 offset
+= ivn
.vn_next
;
5886 while (ivn
.vn_next
!= 0);
5888 if (ivna
.vna_other
== vers_data
)
5891 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5894 else if (! is_nobits
)
5895 error (_("bad dynamic symbol"));
5902 if (vers_data
!= 0x8001
5903 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5905 Elf_Internal_Verdef ivd
;
5906 Elf_Internal_Verdaux ivda
;
5907 Elf_External_Verdaux evda
;
5908 unsigned long offset
;
5911 = (version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5916 Elf_External_Verdef evd
;
5918 get_data (&evd
, file
, offset
, sizeof (evd
),
5921 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5922 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5923 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5925 offset
+= ivd
.vd_next
;
5927 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5928 && ivd
.vd_next
!= 0);
5930 offset
-= ivd
.vd_next
;
5931 offset
+= ivd
.vd_aux
;
5933 get_data (&evda
, file
, offset
, sizeof (evda
),
5934 _("version def aux"));
5936 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5938 if (psym
->st_name
!= ivda
.vda_name
)
5939 printf ((vers_data
& 0x8000)
5941 strtab
+ ivda
.vda_name
);
5951 if (strtab
!= string_table
)
5957 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5959 if (do_histogram
&& buckets
!= NULL
)
5966 int nzero_counts
= 0;
5969 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5971 printf (_(" Length Number %% of total Coverage\n"));
5973 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5974 if (lengths
== NULL
)
5976 error (_("Out of memory"));
5979 for (hn
= 0; hn
< nbuckets
; ++hn
)
5984 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5987 if (maxlength
< ++lengths
[hn
])
5992 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5995 error (_("Out of memory"));
5999 for (hn
= 0; hn
< nbuckets
; ++hn
)
6000 ++counts
[lengths
[hn
]];
6004 printf (" 0 %-10d (%5.1f%%)\n",
6005 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6006 for (si
= 1; si
<= maxlength
; ++si
)
6008 nzero_counts
+= counts
[si
] * si
;
6009 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6010 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6011 (nzero_counts
* 100.0) / nsyms
);
6019 if (buckets
!= NULL
)
6029 process_syminfo (file
)
6030 FILE *file ATTRIBUTE_UNUSED
;
6034 if (dynamic_syminfo
== NULL
6036 /* No syminfo, this is ok. */
6039 /* There better should be a dynamic symbol section. */
6040 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6044 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6045 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6047 printf (_(" Num: Name BoundTo Flags\n"));
6048 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6050 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6052 printf ("%4d: ", i
);
6053 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
6056 switch (dynamic_syminfo
[i
].si_boundto
)
6058 case SYMINFO_BT_SELF
:
6059 fputs ("SELF ", stdout
);
6061 case SYMINFO_BT_PARENT
:
6062 fputs ("PARENT ", stdout
);
6065 if (dynamic_syminfo
[i
].si_boundto
> 0
6066 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
6071 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6075 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6079 if (flags
& SYMINFO_FLG_DIRECT
)
6081 if (flags
& SYMINFO_FLG_PASSTHRU
)
6082 printf (" PASSTHRU");
6083 if (flags
& SYMINFO_FLG_COPY
)
6085 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6086 printf (" LAZYLOAD");
6094 #ifdef SUPPORT_DISASSEMBLY
6096 disassemble_section (section
, file
)
6097 Elf_Internal_Shdr
*section
;
6100 printf (_("\nAssembly dump of section %s\n"),
6101 SECTION_NAME (section
));
6103 /* XXX -- to be done --- XXX */
6110 dump_section (section
, file
)
6111 Elf_Internal_Shdr
*section
;
6114 bfd_size_type bytes
;
6116 unsigned char *data
;
6117 unsigned char *start
;
6119 bytes
= section
->sh_size
;
6123 printf (_("\nSection '%s' has no data to dump.\n"),
6124 SECTION_NAME (section
));
6128 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6130 addr
= section
->sh_addr
;
6132 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
6145 lbytes
= (bytes
> 16 ? 16 : bytes
);
6147 printf (" 0x%8.8lx ", (unsigned long) addr
);
6149 switch (elf_header
.e_ident
[EI_DATA
])
6153 for (j
= 15; j
>= 0; j
--)
6156 printf ("%2.2x", data
[j
]);
6166 for (j
= 0; j
< 16; j
++)
6169 printf ("%2.2x", data
[j
]);
6179 for (j
= 0; j
< lbytes
; j
++)
6182 if (k
>= ' ' && k
< 0x80)
6201 static unsigned long int
6202 read_leb128 (data
, length_return
, sign
)
6203 unsigned char *data
;
6207 unsigned long int result
= 0;
6208 unsigned int num_read
= 0;
6217 result
|= (byte
& 0x7f) << shift
;
6222 while (byte
& 0x80);
6224 if (length_return
!= NULL
)
6225 *length_return
= num_read
;
6227 if (sign
&& (shift
< 32) && (byte
& 0x40))
6228 result
|= -1 << shift
;
6233 typedef struct State_Machine_Registers
6235 unsigned long address
;
6238 unsigned int column
;
6242 /* This variable hold the number of the last entry seen
6243 in the File Table. */
6244 unsigned int last_file_entry
;
6247 static SMR state_machine_regs
;
6250 reset_state_machine (is_stmt
)
6253 state_machine_regs
.address
= 0;
6254 state_machine_regs
.file
= 1;
6255 state_machine_regs
.line
= 1;
6256 state_machine_regs
.column
= 0;
6257 state_machine_regs
.is_stmt
= is_stmt
;
6258 state_machine_regs
.basic_block
= 0;
6259 state_machine_regs
.end_sequence
= 0;
6260 state_machine_regs
.last_file_entry
= 0;
6263 /* Handled an extend line op. Returns true if this is the end
6266 process_extended_line_op (data
, is_stmt
, pointer_size
)
6267 unsigned char *data
;
6271 unsigned char op_code
;
6274 unsigned char *name
;
6277 len
= read_leb128 (data
, & bytes_read
, 0);
6282 warn (_("badly formed extended line op encountered!\n"));
6289 printf (_(" Extended opcode %d: "), op_code
);
6293 case DW_LNE_end_sequence
:
6294 printf (_("End of Sequence\n\n"));
6295 reset_state_machine (is_stmt
);
6298 case DW_LNE_set_address
:
6299 adr
= byte_get (data
, pointer_size
);
6300 printf (_("set Address to 0x%lx\n"), adr
);
6301 state_machine_regs
.address
= adr
;
6304 case DW_LNE_define_file
:
6305 printf (_(" define new File Table entry\n"));
6306 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6308 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6310 data
+= strlen ((char *) data
) + 1;
6311 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6313 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6315 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6316 printf (_("%s\n\n"), name
);
6320 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6327 /* Size of pointers in the .debug_line section. This information is not
6328 really present in that section. It's obtained before dumping the debug
6329 sections by doing some pre-scan of the .debug_info section. */
6330 static int debug_line_pointer_size
= 4;
6333 display_debug_lines (section
, start
, file
)
6334 Elf_Internal_Shdr
*section
;
6335 unsigned char * start
;
6336 FILE *file ATTRIBUTE_UNUSED
;
6338 DWARF2_External_LineInfo
*external
;
6339 DWARF2_Internal_LineInfo info
;
6340 unsigned char *standard_opcodes
;
6341 unsigned char *data
= start
;
6342 unsigned char *end
= start
+ section
->sh_size
;
6343 unsigned char *end_of_sequence
;
6346 printf (_("\nDump of debug contents of section %s:\n\n"),
6347 SECTION_NAME (section
));
6351 external
= (DWARF2_External_LineInfo
*) data
;
6353 /* Check the length of the block. */
6354 info
.li_length
= BYTE_GET (external
->li_length
);
6356 if (info
.li_length
== 0xffffffff)
6358 warn (_("64-bit DWARF line info is not supported yet.\n"));
6362 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6365 (_("The line info appears to be corrupt - the section is too small\n"));
6369 /* Check its version number. */
6370 info
.li_version
= BYTE_GET (external
->li_version
);
6371 if (info
.li_version
!= 2)
6373 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6377 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6378 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6379 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6380 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6381 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6382 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6384 /* Sign extend the line base field. */
6385 info
.li_line_base
<<= 24;
6386 info
.li_line_base
>>= 24;
6388 printf (_(" Length: %ld\n"), info
.li_length
);
6389 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6390 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6391 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6392 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6393 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6394 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6395 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6397 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6399 reset_state_machine (info
.li_default_is_stmt
);
6401 /* Display the contents of the Opcodes table. */
6402 standard_opcodes
= data
+ sizeof (*external
);
6404 printf (_("\n Opcodes:\n"));
6406 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6407 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6409 /* Display the contents of the Directory table. */
6410 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6413 printf (_("\n The Directory Table is empty.\n"));
6416 printf (_("\n The Directory Table:\n"));
6420 printf (_(" %s\n"), data
);
6422 data
+= strlen ((char *) data
) + 1;
6426 /* Skip the NUL at the end of the table. */
6429 /* Display the contents of the File Name table. */
6431 printf (_("\n The File Name Table is empty.\n"));
6434 printf (_("\n The File Name Table:\n"));
6435 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6439 unsigned char *name
;
6442 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6445 data
+= strlen ((char *) data
) + 1;
6447 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6449 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6451 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6453 printf (_("%s\n"), name
);
6457 /* Skip the NUL at the end of the table. */
6460 /* Now display the statements. */
6461 printf (_("\n Line Number Statements:\n"));
6464 while (data
< end_of_sequence
)
6466 unsigned char op_code
;
6472 if (op_code
>= info
.li_opcode_base
)
6474 op_code
-= info
.li_opcode_base
;
6475 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6476 state_machine_regs
.address
+= adv
;
6477 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6478 op_code
, adv
, state_machine_regs
.address
);
6479 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6480 state_machine_regs
.line
+= adv
;
6481 printf (_(" and Line by %d to %d\n"),
6482 adv
, state_machine_regs
.line
);
6484 else switch (op_code
)
6486 case DW_LNS_extended_op
:
6487 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6488 debug_line_pointer_size
);
6492 printf (_(" Copy\n"));
6495 case DW_LNS_advance_pc
:
6496 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6498 state_machine_regs
.address
+= adv
;
6499 printf (_(" Advance PC by %d to %lx\n"), adv
,
6500 state_machine_regs
.address
);
6503 case DW_LNS_advance_line
:
6504 adv
= read_leb128 (data
, & bytes_read
, 1);
6506 state_machine_regs
.line
+= adv
;
6507 printf (_(" Advance Line by %d to %d\n"), adv
,
6508 state_machine_regs
.line
);
6511 case DW_LNS_set_file
:
6512 adv
= read_leb128 (data
, & bytes_read
, 0);
6514 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6516 state_machine_regs
.file
= adv
;
6519 case DW_LNS_set_column
:
6520 adv
= read_leb128 (data
, & bytes_read
, 0);
6522 printf (_(" Set column to %d\n"), adv
);
6523 state_machine_regs
.column
= adv
;
6526 case DW_LNS_negate_stmt
:
6527 adv
= state_machine_regs
.is_stmt
;
6529 printf (_(" Set is_stmt to %d\n"), adv
);
6530 state_machine_regs
.is_stmt
= adv
;
6533 case DW_LNS_set_basic_block
:
6534 printf (_(" Set basic block\n"));
6535 state_machine_regs
.basic_block
= 1;
6538 case DW_LNS_const_add_pc
:
6539 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6540 * info
.li_min_insn_length
);
6541 state_machine_regs
.address
+= adv
;
6542 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6543 state_machine_regs
.address
);
6546 case DW_LNS_fixed_advance_pc
:
6547 adv
= byte_get (data
, 2);
6549 state_machine_regs
.address
+= adv
;
6550 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6551 adv
, state_machine_regs
.address
);
6554 case DW_LNS_set_prologue_end
:
6555 printf (_(" Set prologue_end to true\n"));
6558 case DW_LNS_set_epilogue_begin
:
6559 printf (_(" Set epilogue_begin to true\n"));
6562 case DW_LNS_set_isa
:
6563 adv
= read_leb128 (data
, & bytes_read
, 0);
6565 printf (_(" Set ISA to %d\n"), adv
);
6569 printf (_(" Unknown opcode %d with operands: "), op_code
);
6572 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6574 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6575 i
== 1 ? "" : ", ");
6590 display_debug_pubnames (section
, start
, file
)
6591 Elf_Internal_Shdr
*section
;
6592 unsigned char *start
;
6593 FILE *file ATTRIBUTE_UNUSED
;
6595 DWARF2_External_PubNames
*external
;
6596 DWARF2_Internal_PubNames pubnames
;
6599 end
= start
+ section
->sh_size
;
6601 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6605 unsigned char *data
;
6606 unsigned long offset
;
6608 external
= (DWARF2_External_PubNames
*) start
;
6610 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6611 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6612 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6613 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6615 data
= start
+ sizeof (*external
);
6616 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6618 if (pubnames
.pn_length
== 0xffffffff)
6620 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6624 if (pubnames
.pn_version
!= 2)
6626 static int warned
= 0;
6630 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6637 printf (_(" Length: %ld\n"),
6638 pubnames
.pn_length
);
6639 printf (_(" Version: %d\n"),
6640 pubnames
.pn_version
);
6641 printf (_(" Offset into .debug_info section: %ld\n"),
6642 pubnames
.pn_offset
);
6643 printf (_(" Size of area in .debug_info section: %ld\n"),
6646 printf (_("\n Offset\tName\n"));
6650 offset
= byte_get (data
, 4);
6655 printf (" %ld\t\t%s\n", offset
, data
);
6656 data
+= strlen ((char *) data
) + 1;
6659 while (offset
!= 0);
6672 case DW_TAG_padding
: return "DW_TAG_padding";
6673 case DW_TAG_array_type
: return "DW_TAG_array_type";
6674 case DW_TAG_class_type
: return "DW_TAG_class_type";
6675 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6676 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6677 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6678 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6679 case DW_TAG_label
: return "DW_TAG_label";
6680 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6681 case DW_TAG_member
: return "DW_TAG_member";
6682 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6683 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6684 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6685 case DW_TAG_string_type
: return "DW_TAG_string_type";
6686 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6687 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6688 case DW_TAG_typedef
: return "DW_TAG_typedef";
6689 case DW_TAG_union_type
: return "DW_TAG_union_type";
6690 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6691 case DW_TAG_variant
: return "DW_TAG_variant";
6692 case DW_TAG_common_block
: return "DW_TAG_common_block";
6693 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6694 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6695 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6696 case DW_TAG_module
: return "DW_TAG_module";
6697 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6698 case DW_TAG_set_type
: return "DW_TAG_set_type";
6699 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6700 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6701 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6702 case DW_TAG_base_type
: return "DW_TAG_base_type";
6703 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6704 case DW_TAG_const_type
: return "DW_TAG_const_type";
6705 case DW_TAG_constant
: return "DW_TAG_constant";
6706 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6707 case DW_TAG_file_type
: return "DW_TAG_file_type";
6708 case DW_TAG_friend
: return "DW_TAG_friend";
6709 case DW_TAG_namelist
: return "DW_TAG_namelist";
6710 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6711 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6712 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6713 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6714 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6715 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6716 case DW_TAG_try_block
: return "DW_TAG_try_block";
6717 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6718 case DW_TAG_variable
: return "DW_TAG_variable";
6719 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6720 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6721 case DW_TAG_format_label
: return "DW_TAG_format_label";
6722 case DW_TAG_function_template
: return "DW_TAG_function_template";
6723 case DW_TAG_class_template
: return "DW_TAG_class_template";
6724 /* DWARF 2.1 values. */
6725 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6726 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6727 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6728 case DW_TAG_namespace
: return "DW_TAG_namespace";
6729 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6730 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6731 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6732 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6735 static char buffer
[100];
6737 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6744 get_AT_name (attribute
)
6745 unsigned long attribute
;
6749 case DW_AT_sibling
: return "DW_AT_sibling";
6750 case DW_AT_location
: return "DW_AT_location";
6751 case DW_AT_name
: return "DW_AT_name";
6752 case DW_AT_ordering
: return "DW_AT_ordering";
6753 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6754 case DW_AT_byte_size
: return "DW_AT_byte_size";
6755 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6756 case DW_AT_bit_size
: return "DW_AT_bit_size";
6757 case DW_AT_element_list
: return "DW_AT_element_list";
6758 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6759 case DW_AT_low_pc
: return "DW_AT_low_pc";
6760 case DW_AT_high_pc
: return "DW_AT_high_pc";
6761 case DW_AT_language
: return "DW_AT_language";
6762 case DW_AT_member
: return "DW_AT_member";
6763 case DW_AT_discr
: return "DW_AT_discr";
6764 case DW_AT_discr_value
: return "DW_AT_discr_value";
6765 case DW_AT_visibility
: return "DW_AT_visibility";
6766 case DW_AT_import
: return "DW_AT_import";
6767 case DW_AT_string_length
: return "DW_AT_string_length";
6768 case DW_AT_common_reference
: return "DW_AT_common_reference";
6769 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6770 case DW_AT_const_value
: return "DW_AT_const_value";
6771 case DW_AT_containing_type
: return "DW_AT_containing_type";
6772 case DW_AT_default_value
: return "DW_AT_default_value";
6773 case DW_AT_inline
: return "DW_AT_inline";
6774 case DW_AT_is_optional
: return "DW_AT_is_optional";
6775 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6776 case DW_AT_producer
: return "DW_AT_producer";
6777 case DW_AT_prototyped
: return "DW_AT_prototyped";
6778 case DW_AT_return_addr
: return "DW_AT_return_addr";
6779 case DW_AT_start_scope
: return "DW_AT_start_scope";
6780 case DW_AT_stride_size
: return "DW_AT_stride_size";
6781 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6782 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6783 case DW_AT_accessibility
: return "DW_AT_accessibility";
6784 case DW_AT_address_class
: return "DW_AT_address_class";
6785 case DW_AT_artificial
: return "DW_AT_artificial";
6786 case DW_AT_base_types
: return "DW_AT_base_types";
6787 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6788 case DW_AT_count
: return "DW_AT_count";
6789 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6790 case DW_AT_decl_column
: return "DW_AT_decl_column";
6791 case DW_AT_decl_file
: return "DW_AT_decl_file";
6792 case DW_AT_decl_line
: return "DW_AT_decl_line";
6793 case DW_AT_declaration
: return "DW_AT_declaration";
6794 case DW_AT_discr_list
: return "DW_AT_discr_list";
6795 case DW_AT_encoding
: return "DW_AT_encoding";
6796 case DW_AT_external
: return "DW_AT_external";
6797 case DW_AT_frame_base
: return "DW_AT_frame_base";
6798 case DW_AT_friend
: return "DW_AT_friend";
6799 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6800 case DW_AT_macro_info
: return "DW_AT_macro_info";
6801 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6802 case DW_AT_priority
: return "DW_AT_priority";
6803 case DW_AT_segment
: return "DW_AT_segment";
6804 case DW_AT_specification
: return "DW_AT_specification";
6805 case DW_AT_static_link
: return "DW_AT_static_link";
6806 case DW_AT_type
: return "DW_AT_type";
6807 case DW_AT_use_location
: return "DW_AT_use_location";
6808 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6809 case DW_AT_virtuality
: return "DW_AT_virtuality";
6810 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6811 /* DWARF 2.1 values. */
6812 case DW_AT_allocated
: return "DW_AT_allocated";
6813 case DW_AT_associated
: return "DW_AT_associated";
6814 case DW_AT_data_location
: return "DW_AT_data_location";
6815 case DW_AT_stride
: return "DW_AT_stride";
6816 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6817 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6818 case DW_AT_extension
: return "DW_AT_extension";
6819 case DW_AT_ranges
: return "DW_AT_ranges";
6820 case DW_AT_trampoline
: return "DW_AT_trampoline";
6821 case DW_AT_call_column
: return "DW_AT_call_column";
6822 case DW_AT_call_file
: return "DW_AT_call_file";
6823 case DW_AT_call_line
: return "DW_AT_call_line";
6824 /* SGI/MIPS extensions. */
6825 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6826 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6827 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6828 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6829 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6830 case DW_AT_MIPS_software_pipeline_depth
:
6831 return "DW_AT_MIPS_software_pipeline_depth";
6832 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6833 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6834 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6835 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6836 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6837 /* GNU extensions. */
6838 case DW_AT_sf_names
: return "DW_AT_sf_names";
6839 case DW_AT_src_info
: return "DW_AT_src_info";
6840 case DW_AT_mac_info
: return "DW_AT_mac_info";
6841 case DW_AT_src_coords
: return "DW_AT_src_coords";
6842 case DW_AT_body_begin
: return "DW_AT_body_begin";
6843 case DW_AT_body_end
: return "DW_AT_body_end";
6844 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6847 static char buffer
[100];
6849 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6856 get_FORM_name (form
)
6861 case DW_FORM_addr
: return "DW_FORM_addr";
6862 case DW_FORM_block2
: return "DW_FORM_block2";
6863 case DW_FORM_block4
: return "DW_FORM_block4";
6864 case DW_FORM_data2
: return "DW_FORM_data2";
6865 case DW_FORM_data4
: return "DW_FORM_data4";
6866 case DW_FORM_data8
: return "DW_FORM_data8";
6867 case DW_FORM_string
: return "DW_FORM_string";
6868 case DW_FORM_block
: return "DW_FORM_block";
6869 case DW_FORM_block1
: return "DW_FORM_block1";
6870 case DW_FORM_data1
: return "DW_FORM_data1";
6871 case DW_FORM_flag
: return "DW_FORM_flag";
6872 case DW_FORM_sdata
: return "DW_FORM_sdata";
6873 case DW_FORM_strp
: return "DW_FORM_strp";
6874 case DW_FORM_udata
: return "DW_FORM_udata";
6875 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6876 case DW_FORM_ref1
: return "DW_FORM_ref1";
6877 case DW_FORM_ref2
: return "DW_FORM_ref2";
6878 case DW_FORM_ref4
: return "DW_FORM_ref4";
6879 case DW_FORM_ref8
: return "DW_FORM_ref8";
6880 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6881 case DW_FORM_indirect
: return "DW_FORM_indirect";
6884 static char buffer
[100];
6886 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6892 /* FIXME: There are better and more effiecint ways to handle
6893 these structures. For now though, I just want something that
6894 is simple to implement. */
6895 typedef struct abbrev_attr
6897 unsigned long attribute
;
6899 struct abbrev_attr
*next
;
6903 typedef struct abbrev_entry
6905 unsigned long entry
;
6908 struct abbrev_attr
*first_attr
;
6909 struct abbrev_attr
*last_attr
;
6910 struct abbrev_entry
*next
;
6914 static abbrev_entry
*first_abbrev
= NULL
;
6915 static abbrev_entry
*last_abbrev
= NULL
;
6920 abbrev_entry
*abbrev
;
6922 for (abbrev
= first_abbrev
; abbrev
;)
6924 abbrev_entry
*next
= abbrev
->next
;
6927 for (attr
= abbrev
->first_attr
; attr
;)
6929 abbrev_attr
*next
= attr
->next
;
6939 last_abbrev
= first_abbrev
= NULL
;
6943 add_abbrev (number
, tag
, children
)
6944 unsigned long number
;
6948 abbrev_entry
*entry
;
6950 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
6956 entry
->entry
= number
;
6958 entry
->children
= children
;
6959 entry
->first_attr
= NULL
;
6960 entry
->last_attr
= NULL
;
6963 if (first_abbrev
== NULL
)
6964 first_abbrev
= entry
;
6966 last_abbrev
->next
= entry
;
6968 last_abbrev
= entry
;
6972 add_abbrev_attr (attribute
, form
)
6973 unsigned long attribute
;
6978 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
6984 attr
->attribute
= attribute
;
6988 if (last_abbrev
->first_attr
== NULL
)
6989 last_abbrev
->first_attr
= attr
;
6991 last_abbrev
->last_attr
->next
= attr
;
6993 last_abbrev
->last_attr
= attr
;
6996 /* Processes the (partial) contents of a .debug_abbrev section.
6997 Returns NULL if the end of the section was encountered.
6998 Returns the address after the last byte read if the end of
6999 an abbreviation set was found. */
7001 static unsigned char *
7002 process_abbrev_section (start
, end
)
7003 unsigned char *start
;
7006 if (first_abbrev
!= NULL
)
7012 unsigned long entry
;
7014 unsigned long attribute
;
7017 entry
= read_leb128 (start
, & bytes_read
, 0);
7018 start
+= bytes_read
;
7020 /* A single zero is supposed to end the section according
7021 to the standard. If there's more, then signal that to
7024 return start
== end
? NULL
: start
;
7026 tag
= read_leb128 (start
, & bytes_read
, 0);
7027 start
+= bytes_read
;
7029 children
= *start
++;
7031 add_abbrev (entry
, tag
, children
);
7037 attribute
= read_leb128 (start
, & bytes_read
, 0);
7038 start
+= bytes_read
;
7040 form
= read_leb128 (start
, & bytes_read
, 0);
7041 start
+= bytes_read
;
7044 add_abbrev_attr (attribute
, form
);
7046 while (attribute
!= 0);
7054 display_debug_macinfo (section
, start
, file
)
7055 Elf_Internal_Shdr
*section
;
7056 unsigned char *start
;
7057 FILE *file ATTRIBUTE_UNUSED
;
7059 unsigned char *end
= start
+ section
->sh_size
;
7060 unsigned char *curr
= start
;
7061 unsigned int bytes_read
;
7062 enum dwarf_macinfo_record_type op
;
7064 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7068 unsigned int lineno
;
7076 case DW_MACINFO_start_file
:
7078 unsigned int filenum
;
7080 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7082 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7085 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7089 case DW_MACINFO_end_file
:
7090 printf (_(" DW_MACINFO_end_file\n"));
7093 case DW_MACINFO_define
:
7094 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7097 curr
+= strlen (string
) + 1;
7098 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7101 case DW_MACINFO_undef
:
7102 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7105 curr
+= strlen (string
) + 1;
7106 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7109 case DW_MACINFO_vendor_ext
:
7111 unsigned int constant
;
7113 constant
= read_leb128 (curr
, & bytes_read
, 0);
7116 curr
+= strlen (string
) + 1;
7117 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7128 display_debug_abbrev (section
, start
, file
)
7129 Elf_Internal_Shdr
*section
;
7130 unsigned char *start
;
7131 FILE *file ATTRIBUTE_UNUSED
;
7133 abbrev_entry
*entry
;
7134 unsigned char *end
= start
+ section
->sh_size
;
7136 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7140 start
= process_abbrev_section (start
, end
);
7142 if (first_abbrev
== NULL
)
7145 printf (_(" Number TAG\n"));
7147 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7151 printf (_(" %ld %s [%s]\n"),
7153 get_TAG_name (entry
->tag
),
7154 entry
->children
? _("has children") : _("no children"));
7156 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7158 printf (_(" %-18s %s\n"),
7159 get_AT_name (attr
->attribute
),
7160 get_FORM_name (attr
->form
));
7174 static unsigned char *
7175 display_block (data
, length
)
7176 unsigned char *data
;
7177 unsigned long length
;
7179 printf (_(" %lu byte block: "), length
);
7182 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7188 decode_location_expression (data
, pointer_size
, length
)
7189 unsigned char * data
;
7190 unsigned int pointer_size
;
7191 unsigned long length
;
7195 unsigned long uvalue
;
7196 unsigned char *end
= data
+ length
;
7205 printf ("DW_OP_addr: %lx",
7206 (unsigned long) byte_get (data
, pointer_size
));
7207 data
+= pointer_size
;
7210 printf ("DW_OP_deref");
7213 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7216 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7219 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7223 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7227 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7231 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7235 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7236 (unsigned long) byte_get (data
+ 4, 4));
7240 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7241 (long) byte_get (data
+ 4, 4));
7245 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7249 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7253 printf ("DW_OP_dup");
7256 printf ("DW_OP_drop");
7259 printf ("DW_OP_over");
7262 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7265 printf ("DW_OP_swap");
7268 printf ("DW_OP_rot");
7271 printf ("DW_OP_xderef");
7274 printf ("DW_OP_abs");
7277 printf ("DW_OP_and");
7280 printf ("DW_OP_div");
7283 printf ("DW_OP_minus");
7286 printf ("DW_OP_mod");
7289 printf ("DW_OP_mul");
7292 printf ("DW_OP_neg");
7295 printf ("DW_OP_not");
7298 printf ("DW_OP_or");
7301 printf ("DW_OP_plus");
7303 case DW_OP_plus_uconst
:
7304 printf ("DW_OP_plus_uconst: %lu",
7305 read_leb128 (data
, &bytes_read
, 0));
7309 printf ("DW_OP_shl");
7312 printf ("DW_OP_shr");
7315 printf ("DW_OP_shra");
7318 printf ("DW_OP_xor");
7321 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7325 printf ("DW_OP_eq");
7328 printf ("DW_OP_ge");
7331 printf ("DW_OP_gt");
7334 printf ("DW_OP_le");
7337 printf ("DW_OP_lt");
7340 printf ("DW_OP_ne");
7343 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7379 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7414 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7449 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7450 read_leb128 (data
, &bytes_read
, 1));
7455 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7459 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7463 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7465 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7466 read_leb128 (data
, &bytes_read
, 1));
7470 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7473 case DW_OP_deref_size
:
7474 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7476 case DW_OP_xderef_size
:
7477 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7480 printf ("DW_OP_nop");
7483 /* DWARF 3 extensions. */
7484 case DW_OP_push_object_address
:
7485 printf ("DW_OP_push_object_address");
7488 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7492 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7495 case DW_OP_call_ref
:
7496 printf ("DW_OP_call_ref");
7499 /* GNU extensions. */
7500 case DW_OP_GNU_push_tls_address
:
7501 printf ("DW_OP_GNU_push_tls_address");
7505 if (op
>= DW_OP_lo_user
7506 && op
<= DW_OP_hi_user
)
7507 printf (_("(User defined location op)"));
7509 printf (_("(Unknown location op)"));
7510 /* No way to tell where the next op is, so just bail. */
7514 /* Separate the ops. */
7519 static const char *debug_loc_contents
;
7520 static bfd_vma debug_loc_size
;
7523 load_debug_loc (file
)
7526 Elf_Internal_Shdr
*sec
;
7529 /* If it is already loaded, do nothing. */
7530 if (debug_loc_contents
!= NULL
)
7533 /* Locate the .debug_loc section. */
7534 for (i
= 0, sec
= section_headers
;
7535 i
< elf_header
.e_shnum
;
7537 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7540 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7543 debug_loc_size
= sec
->sh_size
;
7545 debug_loc_contents
= ((char *)
7546 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7547 _("debug_loc section data")));
7553 if (debug_loc_contents
== NULL
)
7556 free ((char *) debug_loc_contents
);
7557 debug_loc_contents
= NULL
;
7563 display_debug_loc (section
, start
, file
)
7564 Elf_Internal_Shdr
*section
;
7565 unsigned char *start
;
7566 FILE *file ATTRIBUTE_UNUSED
;
7568 unsigned char *section_end
;
7569 unsigned long bytes
;
7570 unsigned char *section_begin
= start
;
7573 addr
= section
->sh_addr
;
7574 bytes
= section
->sh_size
;
7575 section_end
= start
+ bytes
;
7579 printf (_("\nThe .debug_loc section is empty.\n"));
7583 printf (_("Contents of the .debug_loc section:\n\n"));
7584 printf (_("\n Offset Begin End Expression\n"));
7586 while (start
< section_end
)
7588 unsigned long begin
;
7590 unsigned short length
;
7591 unsigned long offset
;
7593 offset
= start
- section_begin
;
7597 /* Normally, the lists in the debug_loc section are related to a
7598 given compilation unit, and thus, we would use the
7599 pointer size of that compilation unit. However, since we are
7600 displaying it seperately here, we either have to store
7601 pointer sizes of all compilation units, or assume they don't
7602 change. We assume, like the debug_line display, that
7603 it doesn't change. */
7604 begin
= byte_get (start
, debug_line_pointer_size
);
7605 start
+= debug_line_pointer_size
;
7606 end
= byte_get (start
, debug_line_pointer_size
);
7607 start
+= debug_line_pointer_size
;
7609 if (begin
== 0 && end
== 0)
7615 length
= byte_get (start
, 2);
7618 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7619 decode_location_expression (start
, debug_line_pointer_size
, length
);
7629 static const char *debug_str_contents
;
7630 static bfd_vma debug_str_size
;
7633 load_debug_str (file
)
7636 Elf_Internal_Shdr
*sec
;
7639 /* If it is already loaded, do nothing. */
7640 if (debug_str_contents
!= NULL
)
7643 /* Locate the .debug_str section. */
7644 for (i
= 0, sec
= section_headers
;
7645 i
< elf_header
.e_shnum
;
7647 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7650 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7653 debug_str_size
= sec
->sh_size
;
7655 debug_str_contents
= ((char *)
7656 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7657 _("debug_str section data")));
7663 if (debug_str_contents
== NULL
)
7666 free ((char *) debug_str_contents
);
7667 debug_str_contents
= NULL
;
7672 fetch_indirect_string (offset
)
7673 unsigned long offset
;
7675 if (debug_str_contents
== NULL
)
7676 return _("<no .debug_str section>");
7678 if (offset
> debug_str_size
)
7679 return _("<offset is too big>");
7681 return debug_str_contents
+ offset
;
7685 display_debug_str (section
, start
, file
)
7686 Elf_Internal_Shdr
*section
;
7687 unsigned char *start
;
7688 FILE *file ATTRIBUTE_UNUSED
;
7690 unsigned long bytes
;
7693 addr
= section
->sh_addr
;
7694 bytes
= section
->sh_size
;
7698 printf (_("\nThe .debug_str section is empty.\n"));
7702 printf (_("Contents of the .debug_str section:\n\n"));
7710 lbytes
= (bytes
> 16 ? 16 : bytes
);
7712 printf (" 0x%8.8lx ", (unsigned long) addr
);
7714 for (j
= 0; j
< 16; j
++)
7717 printf ("%2.2x", start
[j
]);
7725 for (j
= 0; j
< lbytes
; j
++)
7728 if (k
>= ' ' && k
< 0x80)
7744 static unsigned char *
7745 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7746 unsigned long attribute
;
7748 unsigned char *data
;
7749 unsigned long cu_offset
;
7750 unsigned long pointer_size
;
7752 unsigned long uvalue
= 0;
7753 unsigned char *block_start
= NULL
;
7761 case DW_FORM_ref_addr
:
7763 uvalue
= byte_get (data
, pointer_size
);
7764 data
+= pointer_size
;
7768 uvalue
= byte_get (data
, /* offset_size */ 4);
7769 data
+= /* offset_size */ 4;
7775 uvalue
= byte_get (data
++, 1);
7780 uvalue
= byte_get (data
, 2);
7786 uvalue
= byte_get (data
, 4);
7791 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7795 case DW_FORM_ref_udata
:
7797 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7801 case DW_FORM_indirect
:
7802 form
= read_leb128 (data
, & bytes_read
, 0);
7804 printf (" %s", get_FORM_name (form
));
7805 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7811 case DW_FORM_ref_addr
:
7812 printf (" <#%lx>", uvalue
);
7818 case DW_FORM_ref_udata
:
7819 printf (" <%lx>", uvalue
+ cu_offset
);
7823 printf (" %#lx", uvalue
);
7831 printf (" %ld", uvalue
);
7836 uvalue
= byte_get (data
, 4);
7837 printf (" %lx", uvalue
);
7838 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7842 case DW_FORM_string
:
7843 printf (" %s", data
);
7844 data
+= strlen ((char *) data
) + 1;
7848 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7849 block_start
= data
+ bytes_read
;
7850 data
= display_block (block_start
, uvalue
);
7853 case DW_FORM_block1
:
7854 uvalue
= byte_get (data
, 1);
7855 block_start
= data
+ 1;
7856 data
= display_block (block_start
, uvalue
);
7859 case DW_FORM_block2
:
7860 uvalue
= byte_get (data
, 2);
7861 block_start
= data
+ 2;
7862 data
= display_block (block_start
, uvalue
);
7865 case DW_FORM_block4
:
7866 uvalue
= byte_get (data
, 4);
7867 block_start
= data
+ 4;
7868 data
= display_block (block_start
, uvalue
);
7872 printf (_(" (indirect string, offset: 0x%lx): %s"),
7873 uvalue
, fetch_indirect_string (uvalue
));
7876 case DW_FORM_indirect
:
7877 /* Handled above. */
7881 warn (_("Unrecognized form: %d\n"), form
);
7885 /* For some attributes we can display futher information. */
7894 case DW_INL_not_inlined
:
7895 printf (_("(not inlined)"));
7897 case DW_INL_inlined
:
7898 printf (_("(inlined)"));
7900 case DW_INL_declared_not_inlined
:
7901 printf (_("(declared as inline but ignored)"));
7903 case DW_INL_declared_inlined
:
7904 printf (_("(declared as inline and inlined)"));
7907 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
7912 case DW_AT_language
:
7915 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7916 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7917 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7918 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7919 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7920 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7921 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7922 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7923 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7924 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7925 /* DWARF 2.1 values. */
7926 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7927 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7928 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7929 /* MIPS extension. */
7930 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7932 printf ("(Unknown: %lx)", uvalue
);
7937 case DW_AT_encoding
:
7940 case DW_ATE_void
: printf ("(void)"); break;
7941 case DW_ATE_address
: printf ("(machine address)"); break;
7942 case DW_ATE_boolean
: printf ("(boolean)"); break;
7943 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7944 case DW_ATE_float
: printf ("(float)"); break;
7945 case DW_ATE_signed
: printf ("(signed)"); break;
7946 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7947 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7948 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7949 /* DWARF 2.1 value. */
7950 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7952 if (uvalue
>= DW_ATE_lo_user
7953 && uvalue
<= DW_ATE_hi_user
)
7954 printf ("(user defined type)");
7956 printf ("(unknown type)");
7961 case DW_AT_accessibility
:
7964 case DW_ACCESS_public
: printf ("(public)"); break;
7965 case DW_ACCESS_protected
: printf ("(protected)"); break;
7966 case DW_ACCESS_private
: printf ("(private)"); break;
7968 printf ("(unknown accessibility)");
7973 case DW_AT_visibility
:
7976 case DW_VIS_local
: printf ("(local)"); break;
7977 case DW_VIS_exported
: printf ("(exported)"); break;
7978 case DW_VIS_qualified
: printf ("(qualified)"); break;
7979 default: printf ("(unknown visibility)"); break;
7983 case DW_AT_virtuality
:
7986 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7987 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7988 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7989 default: printf ("(unknown virtuality)"); break;
7993 case DW_AT_identifier_case
:
7996 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7997 case DW_ID_up_case
: printf ("(up_case)"); break;
7998 case DW_ID_down_case
: printf ("(down_case)"); break;
7999 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8000 default: printf ("(unknown case)"); break;
8004 case DW_AT_calling_convention
:
8007 case DW_CC_normal
: printf ("(normal)"); break;
8008 case DW_CC_program
: printf ("(program)"); break;
8009 case DW_CC_nocall
: printf ("(nocall)"); break;
8011 if (uvalue
>= DW_CC_lo_user
8012 && uvalue
<= DW_CC_hi_user
)
8013 printf ("(user defined)");
8015 printf ("(unknown convention)");
8019 case DW_AT_ordering
:
8022 case -1: printf ("(undefined)"); break;
8023 case 0: printf ("(row major)"); break;
8024 case 1: printf ("(column major)"); break;
8028 case DW_AT_frame_base
:
8029 case DW_AT_location
:
8030 case DW_AT_data_member_location
:
8031 case DW_AT_vtable_elem_location
:
8032 case DW_AT_allocated
:
8033 case DW_AT_associated
:
8034 case DW_AT_data_location
:
8036 case DW_AT_upper_bound
:
8037 case DW_AT_lower_bound
:
8041 decode_location_expression (block_start
, pointer_size
, uvalue
);
8044 else if (form
== DW_FORM_data4
)
8047 printf ("location list");
8059 static unsigned char *
8060 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
8061 unsigned long attribute
;
8063 unsigned char *data
;
8064 unsigned long cu_offset
;
8065 unsigned long pointer_size
;
8067 printf (" %-18s:", get_AT_name (attribute
));
8068 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8075 display_debug_info (section
, start
, file
)
8076 Elf_Internal_Shdr
*section
;
8077 unsigned char *start
;
8080 unsigned char *end
= start
+ section
->sh_size
;
8081 unsigned char *section_begin
= start
;
8083 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8085 load_debug_str (file
);
8086 load_debug_loc (file
);
8090 DWARF2_External_CompUnit
*external
;
8091 DWARF2_Internal_CompUnit compunit
;
8092 Elf_Internal_Shdr
*relsec
;
8093 unsigned char *tags
;
8096 unsigned long cu_offset
;
8098 external
= (DWARF2_External_CompUnit
*) start
;
8100 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
8101 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
8102 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
8103 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8105 if (compunit
.cu_length
== 0xffffffff)
8107 warn (_("64-bit DWARF debug info is not supported yet.\n"));
8111 /* Check for RELA relocations in the
8112 abbrev_offset address, and apply them. */
8113 for (relsec
= section_headers
;
8114 relsec
< section_headers
+ elf_header
.e_shnum
;
8117 unsigned long nrelas
;
8118 Elf_Internal_Rela
*rela
, *rp
;
8119 Elf_Internal_Shdr
*symsec
;
8120 Elf_Internal_Sym
*symtab
;
8121 Elf_Internal_Sym
*sym
;
8123 if (relsec
->sh_type
!= SHT_RELA
8124 || SECTION_HEADER (relsec
->sh_info
) != section
8125 || relsec
->sh_size
== 0)
8128 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8132 symsec
= SECTION_HEADER (relsec
->sh_link
);
8133 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8135 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8138 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
8144 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8146 if (ELF32_R_SYM (rp
->r_info
) != 0
8147 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8149 warn (_("Skipping unexpected symbol type %u\n"),
8150 ELF32_ST_TYPE (sym
->st_info
));
8156 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8158 if (ELF64_R_SYM (rp
->r_info
) != 0
8159 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8161 warn (_("Skipping unexpected symbol type %u\n"),
8162 ELF64_ST_TYPE (sym
->st_info
));
8167 compunit
.cu_abbrev_offset
= rp
->r_addend
;
8175 tags
= start
+ sizeof (*external
);
8176 cu_offset
= start
- section_begin
;
8177 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
8179 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8180 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8181 printf (_(" Version: %d\n"), compunit
.cu_version
);
8182 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8183 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8185 if (compunit
.cu_version
!= 2)
8187 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8193 /* Read in the abbrevs used by this compilation unit. */
8195 Elf_Internal_Shdr
*sec
;
8196 unsigned char *begin
;
8198 /* Locate the .debug_abbrev section and process it. */
8199 for (i
= 0, sec
= section_headers
;
8200 i
< elf_header
.e_shnum
;
8202 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
8205 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
8207 warn (_("Unable to locate .debug_abbrev section!\n"));
8211 begin
= ((unsigned char *)
8212 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8213 _("debug_abbrev section data")));
8217 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8218 begin
+ sec
->sh_size
);
8224 while (tags
< start
)
8227 unsigned long abbrev_number
;
8228 abbrev_entry
*entry
;
8231 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8234 /* A null DIE marks the end of a list of children. */
8235 if (abbrev_number
== 0)
8241 /* Scan through the abbreviation list until we reach the
8243 for (entry
= first_abbrev
;
8244 entry
&& entry
->entry
!= abbrev_number
;
8245 entry
= entry
->next
)
8250 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8255 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8257 (unsigned long) (tags
- section_begin
- bytes_read
),
8259 get_TAG_name (entry
->tag
));
8261 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8262 tags
= read_and_display_attr (attr
->attribute
,
8265 compunit
.cu_pointer_size
);
8267 if (entry
->children
)
8281 display_debug_aranges (section
, start
, file
)
8282 Elf_Internal_Shdr
*section
;
8283 unsigned char *start
;
8284 FILE *file ATTRIBUTE_UNUSED
;
8286 unsigned char *end
= start
+ section
->sh_size
;
8288 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8292 DWARF2_External_ARange
*external
;
8293 DWARF2_Internal_ARange arange
;
8294 unsigned char *ranges
;
8295 unsigned long length
;
8296 unsigned long address
;
8299 external
= (DWARF2_External_ARange
*) start
;
8301 arange
.ar_length
= BYTE_GET (external
->ar_length
);
8302 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8303 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8304 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8305 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8307 if (arange
.ar_length
== 0xffffffff)
8309 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8313 if (arange
.ar_version
!= 2)
8315 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8319 printf (_(" Length: %ld\n"), arange
.ar_length
);
8320 printf (_(" Version: %d\n"), arange
.ar_version
);
8321 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8322 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8323 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8325 printf (_("\n Address Length\n"));
8327 ranges
= start
+ sizeof (*external
);
8329 /* Must pad to an alignment boundary that is twice the pointer size. */
8330 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
8332 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8336 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8338 ranges
+= arange
.ar_pointer_size
;
8340 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8342 ranges
+= arange
.ar_pointer_size
;
8344 /* A pair of zeros marks the end of the list. */
8345 if (address
== 0 && length
== 0)
8348 printf (" %8.8lx %lu\n", address
, length
);
8351 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8359 typedef struct Frame_Chunk
8361 struct Frame_Chunk
*next
;
8362 unsigned char *chunk_start
;
8364 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8365 short int *col_type
;
8368 unsigned int code_factor
;
8370 unsigned long pc_begin
;
8371 unsigned long pc_range
;
8375 unsigned char fde_encoding
;
8379 /* A marker for a col_type that means this column was never referenced
8380 in the frame info. */
8381 #define DW_CFA_unreferenced (-1)
8383 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8384 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8385 static int size_of_encoded_value
PARAMS ((int));
8388 frame_need_space (fc
, reg
)
8392 int prev
= fc
->ncols
;
8394 if (reg
< fc
->ncols
)
8397 fc
->ncols
= reg
+ 1;
8398 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8399 fc
->ncols
* sizeof (short int));
8400 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8401 fc
->ncols
* sizeof (int));
8403 while (prev
< fc
->ncols
)
8405 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8406 fc
->col_offset
[prev
] = 0;
8412 frame_display_row (fc
, need_col_headers
, max_regs
)
8414 int *need_col_headers
;
8420 if (*max_regs
< fc
->ncols
)
8421 *max_regs
= fc
->ncols
;
8423 if (*need_col_headers
)
8425 *need_col_headers
= 0;
8427 printf (" LOC CFA ");
8429 for (r
= 0; r
< *max_regs
; r
++)
8430 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8435 printf ("r%-4d", r
);
8441 printf ("%08lx ", fc
->pc_begin
);
8442 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8443 printf ("%-8s ", tmp
);
8445 for (r
= 0; r
< fc
->ncols
; r
++)
8447 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8449 switch (fc
->col_type
[r
])
8451 case DW_CFA_undefined
:
8454 case DW_CFA_same_value
:
8458 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8460 case DW_CFA_register
:
8461 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8464 strcpy (tmp
, "n/a");
8467 printf ("%-5s", tmp
);
8474 size_of_encoded_value (encoding
)
8477 switch (encoding
& 0x7)
8480 case 0: return is_32bit_elf
? 4 : 8;
8487 #define GET(N) byte_get (start, N); start += N
8488 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8489 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8492 display_debug_frames (section
, start
, file
)
8493 Elf_Internal_Shdr
*section
;
8494 unsigned char *start
;
8495 FILE *file ATTRIBUTE_UNUSED
;
8497 unsigned char *end
= start
+ section
->sh_size
;
8498 unsigned char *section_start
= start
;
8499 Frame_Chunk
*chunks
= 0;
8500 Frame_Chunk
*remembered_state
= 0;
8502 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8505 int addr_size
= is_32bit_elf
? 4 : 8;
8507 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8511 unsigned char *saved_start
;
8512 unsigned char *block_end
;
8513 unsigned long length
;
8514 unsigned long cie_id
;
8517 int need_col_headers
= 1;
8518 unsigned char *augmentation_data
= NULL
;
8519 unsigned long augmentation_data_len
= 0;
8520 int encoded_ptr_size
= addr_size
;
8522 saved_start
= start
;
8523 length
= byte_get (start
, 4); start
+= 4;
8527 printf ("\n%08lx ZERO terminator\n\n",
8528 (unsigned long)(saved_start
- section_start
));
8532 if (length
== 0xffffffff)
8534 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8538 block_end
= saved_start
+ length
+ 4;
8539 cie_id
= byte_get (start
, 4); start
+= 4;
8541 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8545 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8546 memset (fc
, 0, sizeof (Frame_Chunk
));
8550 fc
->chunk_start
= saved_start
;
8552 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8553 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8554 frame_need_space (fc
, max_regs
-1);
8558 fc
->augmentation
= start
;
8559 start
= strchr (start
, '\0') + 1;
8561 if (fc
->augmentation
[0] == 'z')
8563 fc
->code_factor
= LEB ();
8564 fc
->data_factor
= SLEB ();
8565 fc
->ra
= byte_get (start
, 1); start
+= 1;
8566 augmentation_data_len
= LEB ();
8567 augmentation_data
= start
;
8568 start
+= augmentation_data_len
;
8570 else if (strcmp (fc
->augmentation
, "eh") == 0)
8573 fc
->code_factor
= LEB ();
8574 fc
->data_factor
= SLEB ();
8575 fc
->ra
= byte_get (start
, 1); start
+= 1;
8579 fc
->code_factor
= LEB ();
8580 fc
->data_factor
= SLEB ();
8581 fc
->ra
= byte_get (start
, 1); start
+= 1;
8585 if (do_debug_frames_interp
)
8586 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8587 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8588 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8592 printf ("\n%08lx %08lx %08lx CIE\n",
8593 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8594 printf (" Version: %d\n", version
);
8595 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8596 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8597 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8598 printf (" Return address column: %d\n", fc
->ra
);
8600 if (augmentation_data_len
)
8603 printf (" Augmentation data: ");
8604 for (i
= 0; i
< augmentation_data_len
; ++i
)
8605 printf (" %02x", augmentation_data
[i
]);
8611 if (augmentation_data_len
)
8613 unsigned char *p
, *q
;
8614 p
= fc
->augmentation
+ 1;
8615 q
= augmentation_data
;
8622 q
+= 1 + size_of_encoded_value (*q
);
8624 fc
->fde_encoding
= *q
++;
8630 if (fc
->fde_encoding
)
8631 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8634 frame_need_space (fc
, fc
->ra
);
8638 unsigned char *look_for
;
8639 static Frame_Chunk fde_fc
;
8642 memset (fc
, 0, sizeof (Frame_Chunk
));
8644 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8646 for (cie
= chunks
; cie
; cie
= cie
->next
)
8647 if (cie
->chunk_start
== look_for
)
8652 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8653 cie_id
, saved_start
);
8656 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8657 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8658 frame_need_space (fc
, max_regs
- 1);
8660 fc
->augmentation
= "";
8661 fc
->fde_encoding
= 0;
8665 fc
->ncols
= cie
->ncols
;
8666 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8667 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8668 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8669 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8670 fc
->augmentation
= cie
->augmentation
;
8671 fc
->code_factor
= cie
->code_factor
;
8672 fc
->data_factor
= cie
->data_factor
;
8673 fc
->cfa_reg
= cie
->cfa_reg
;
8674 fc
->cfa_offset
= cie
->cfa_offset
;
8676 frame_need_space (fc
, max_regs
-1);
8677 fc
->fde_encoding
= cie
->fde_encoding
;
8680 if (fc
->fde_encoding
)
8681 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8683 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8684 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8685 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
8686 start
+= encoded_ptr_size
;
8687 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8688 start
+= encoded_ptr_size
;
8690 if (cie
->augmentation
[0] == 'z')
8692 augmentation_data_len
= LEB ();
8693 augmentation_data
= start
;
8694 start
+= augmentation_data_len
;
8697 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8698 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8699 (unsigned long)(cie
->chunk_start
- section_start
),
8700 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8701 if (! do_debug_frames_interp
&& augmentation_data_len
)
8704 printf (" Augmentation data: ");
8705 for (i
= 0; i
< augmentation_data_len
; ++i
)
8706 printf (" %02x", augmentation_data
[i
]);
8712 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8713 about to interpret instructions for the chunk. */
8715 if (do_debug_frames_interp
)
8717 /* Start by making a pass over the chunk, allocating storage
8718 and taking note of what registers are used. */
8719 unsigned char *tmp
= start
;
8721 while (start
< block_end
)
8731 /* Warning: if you add any more cases to this switch, be
8732 sure to add them to the corresponding switch below. */
8735 case DW_CFA_advance_loc
:
8739 frame_need_space (fc
, opa
);
8740 fc
->col_type
[opa
] = DW_CFA_undefined
;
8742 case DW_CFA_restore
:
8743 frame_need_space (fc
, opa
);
8744 fc
->col_type
[opa
] = DW_CFA_undefined
;
8746 case DW_CFA_set_loc
:
8747 start
+= encoded_ptr_size
;
8749 case DW_CFA_advance_loc1
:
8752 case DW_CFA_advance_loc2
:
8755 case DW_CFA_advance_loc4
:
8758 case DW_CFA_offset_extended
:
8759 reg
= LEB (); LEB ();
8760 frame_need_space (fc
, reg
);
8761 fc
->col_type
[reg
] = DW_CFA_undefined
;
8763 case DW_CFA_restore_extended
:
8765 frame_need_space (fc
, reg
);
8766 fc
->col_type
[reg
] = DW_CFA_undefined
;
8768 case DW_CFA_undefined
:
8770 frame_need_space (fc
, reg
);
8771 fc
->col_type
[reg
] = DW_CFA_undefined
;
8773 case DW_CFA_same_value
:
8775 frame_need_space (fc
, reg
);
8776 fc
->col_type
[reg
] = DW_CFA_undefined
;
8778 case DW_CFA_register
:
8779 reg
= LEB (); LEB ();
8780 frame_need_space (fc
, reg
);
8781 fc
->col_type
[reg
] = DW_CFA_undefined
;
8783 case DW_CFA_def_cfa
:
8786 case DW_CFA_def_cfa_register
:
8789 case DW_CFA_def_cfa_offset
:
8792 case DW_CFA_offset_extended_sf
:
8793 reg
= LEB (); SLEB ();
8794 frame_need_space (fc
, reg
);
8795 fc
->col_type
[reg
] = DW_CFA_undefined
;
8797 case DW_CFA_def_cfa_sf
:
8800 case DW_CFA_def_cfa_offset_sf
:
8803 case DW_CFA_GNU_args_size
:
8806 case DW_CFA_GNU_negative_offset_extended
:
8807 reg
= LEB (); LEB ();
8808 frame_need_space (fc
, reg
);
8809 fc
->col_type
[reg
] = DW_CFA_undefined
;
8818 /* Now we know what registers are used, make a second pass over
8819 the chunk, this time actually printing out the info. */
8821 while (start
< block_end
)
8824 unsigned long ul
, reg
, roffs
;
8833 /* Warning: if you add any more cases to this switch, be
8834 sure to add them to the corresponding switch above. */
8837 case DW_CFA_advance_loc
:
8838 if (do_debug_frames_interp
)
8839 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8841 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8842 opa
* fc
->code_factor
,
8843 fc
->pc_begin
+ opa
* fc
->code_factor
);
8844 fc
->pc_begin
+= opa
* fc
->code_factor
;
8849 if (! do_debug_frames_interp
)
8850 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8851 opa
, roffs
* fc
->data_factor
);
8852 fc
->col_type
[opa
] = DW_CFA_offset
;
8853 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8856 case DW_CFA_restore
:
8857 if (! do_debug_frames_interp
)
8858 printf (" DW_CFA_restore: r%d\n", opa
);
8859 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8860 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8863 case DW_CFA_set_loc
:
8864 vma
= byte_get (start
, encoded_ptr_size
);
8865 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8866 vma
+= section
->sh_addr
+ (start
- section_start
);
8867 start
+= encoded_ptr_size
;
8868 if (do_debug_frames_interp
)
8869 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8871 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8875 case DW_CFA_advance_loc1
:
8876 ofs
= byte_get (start
, 1); start
+= 1;
8877 if (do_debug_frames_interp
)
8878 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8880 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8881 ofs
* fc
->code_factor
,
8882 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8883 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8886 case DW_CFA_advance_loc2
:
8887 ofs
= byte_get (start
, 2); start
+= 2;
8888 if (do_debug_frames_interp
)
8889 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8891 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8892 ofs
* fc
->code_factor
,
8893 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8894 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8897 case DW_CFA_advance_loc4
:
8898 ofs
= byte_get (start
, 4); start
+= 4;
8899 if (do_debug_frames_interp
)
8900 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8902 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8903 ofs
* fc
->code_factor
,
8904 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8905 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8908 case DW_CFA_offset_extended
:
8911 if (! do_debug_frames_interp
)
8912 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8913 reg
, roffs
* fc
->data_factor
);
8914 fc
->col_type
[reg
] = DW_CFA_offset
;
8915 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8918 case DW_CFA_restore_extended
:
8920 if (! do_debug_frames_interp
)
8921 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8922 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8923 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8926 case DW_CFA_undefined
:
8928 if (! do_debug_frames_interp
)
8929 printf (" DW_CFA_undefined: r%ld\n", reg
);
8930 fc
->col_type
[reg
] = DW_CFA_undefined
;
8931 fc
->col_offset
[reg
] = 0;
8934 case DW_CFA_same_value
:
8936 if (! do_debug_frames_interp
)
8937 printf (" DW_CFA_same_value: r%ld\n", reg
);
8938 fc
->col_type
[reg
] = DW_CFA_same_value
;
8939 fc
->col_offset
[reg
] = 0;
8942 case DW_CFA_register
:
8945 if (! do_debug_frames_interp
)
8946 printf (" DW_CFA_register: r%ld\n", reg
);
8947 fc
->col_type
[reg
] = DW_CFA_register
;
8948 fc
->col_offset
[reg
] = roffs
;
8951 case DW_CFA_remember_state
:
8952 if (! do_debug_frames_interp
)
8953 printf (" DW_CFA_remember_state\n");
8954 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8955 rs
->ncols
= fc
->ncols
;
8956 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8957 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8958 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8959 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8960 rs
->next
= remembered_state
;
8961 remembered_state
= rs
;
8964 case DW_CFA_restore_state
:
8965 if (! do_debug_frames_interp
)
8966 printf (" DW_CFA_restore_state\n");
8967 rs
= remembered_state
;
8968 remembered_state
= rs
->next
;
8969 frame_need_space (fc
, rs
->ncols
-1);
8970 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8971 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8972 free (rs
->col_type
);
8973 free (rs
->col_offset
);
8977 case DW_CFA_def_cfa
:
8978 fc
->cfa_reg
= LEB ();
8979 fc
->cfa_offset
= LEB ();
8980 if (! do_debug_frames_interp
)
8981 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8982 fc
->cfa_reg
, fc
->cfa_offset
);
8985 case DW_CFA_def_cfa_register
:
8986 fc
->cfa_reg
= LEB ();
8987 if (! do_debug_frames_interp
)
8988 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8991 case DW_CFA_def_cfa_offset
:
8992 fc
->cfa_offset
= LEB ();
8993 if (! do_debug_frames_interp
)
8994 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8998 if (! do_debug_frames_interp
)
8999 printf (" DW_CFA_nop\n");
9002 case DW_CFA_offset_extended_sf
:
9005 frame_need_space (fc
, reg
);
9006 if (! do_debug_frames_interp
)
9007 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9008 reg
, l
* fc
->data_factor
);
9009 fc
->col_type
[reg
] = DW_CFA_offset
;
9010 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9013 case DW_CFA_def_cfa_sf
:
9014 fc
->cfa_reg
= LEB ();
9015 fc
->cfa_offset
= SLEB ();
9016 if (! do_debug_frames_interp
)
9017 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9018 fc
->cfa_reg
, fc
->cfa_offset
);
9021 case DW_CFA_def_cfa_offset_sf
:
9022 fc
->cfa_offset
= SLEB ();
9023 if (! do_debug_frames_interp
)
9024 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9027 case DW_CFA_GNU_window_save
:
9028 if (! do_debug_frames_interp
)
9029 printf (" DW_CFA_GNU_window_save\n");
9032 case DW_CFA_GNU_args_size
:
9034 if (! do_debug_frames_interp
)
9035 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9038 case DW_CFA_GNU_negative_offset_extended
:
9041 frame_need_space (fc
, reg
);
9042 if (! do_debug_frames_interp
)
9043 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9044 reg
, l
* fc
->data_factor
);
9045 fc
->col_type
[reg
] = DW_CFA_offset
;
9046 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9049 /* FIXME: How do we handle these? */
9050 case DW_CFA_def_cfa_expression
:
9051 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
9055 case DW_CFA_expression
:
9056 fprintf (stderr
, "unsupported DW_CFA_expression\n");
9061 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9066 if (do_debug_frames_interp
)
9067 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9082 display_debug_not_supported (section
, start
, file
)
9083 Elf_Internal_Shdr
*section
;
9084 unsigned char *start ATTRIBUTE_UNUSED
;
9085 FILE *file ATTRIBUTE_UNUSED
;
9087 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9088 SECTION_NAME (section
));
9093 /* Pre-scan the .debug_info section to record the size of address.
9094 When dumping the .debug_line, we use that size information, assuming
9095 that all compilation units have the same address size. */
9097 prescan_debug_info (section
, start
, file
)
9098 Elf_Internal_Shdr
*section ATTRIBUTE_UNUSED
;
9099 unsigned char *start
;
9100 FILE *file ATTRIBUTE_UNUSED
;
9102 DWARF2_External_CompUnit
*external
;
9104 external
= (DWARF2_External_CompUnit
*) start
;
9106 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
9110 /* A structure containing the name of a debug section and a pointer
9111 to a function that can decode it. The third field is a prescan
9112 function to be run over the section before displaying any of the
9116 const char *const name
;
9117 int (*display
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
9118 int (*prescan
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
9122 { ".debug_abbrev", display_debug_abbrev
, NULL
},
9123 { ".debug_aranges", display_debug_aranges
, NULL
},
9124 { ".debug_frame", display_debug_frames
, NULL
},
9125 { ".debug_info", display_debug_info
, prescan_debug_info
},
9126 { ".debug_line", display_debug_lines
, NULL
},
9127 { ".debug_pubnames", display_debug_pubnames
, NULL
},
9128 { ".eh_frame", display_debug_frames
, NULL
},
9129 { ".debug_macinfo", display_debug_macinfo
, NULL
},
9130 { ".debug_str", display_debug_str
, NULL
},
9131 { ".debug_loc", display_debug_loc
, NULL
},
9132 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
9133 { ".debug_ranges", display_debug_not_supported
, NULL
},
9134 { ".debug_static_func", display_debug_not_supported
, NULL
},
9135 { ".debug_static_vars", display_debug_not_supported
, NULL
},
9136 { ".debug_types", display_debug_not_supported
, NULL
},
9137 { ".debug_weaknames", display_debug_not_supported
, NULL
}
9141 display_debug_section (section
, file
)
9142 Elf_Internal_Shdr
*section
;
9145 char *name
= SECTION_NAME (section
);
9146 bfd_size_type length
;
9147 unsigned char *start
;
9150 length
= section
->sh_size
;
9153 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9157 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
9158 _("debug section data"));
9162 /* See if we know how to display the contents of this section. */
9163 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9164 name
= ".debug_info";
9166 for (i
= NUM_ELEM (debug_displays
); i
--;)
9167 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9169 debug_displays
[i
].display (section
, start
, file
);
9174 printf (_("Unrecognized debug section: %s\n"), name
);
9178 /* If we loaded in the abbrev section at some point,
9179 we must release it here. */
9186 process_section_contents (file
)
9189 Elf_Internal_Shdr
*section
;
9195 /* Pre-scan the debug sections to find some debug information not
9196 present in some of them. For the .debug_line, we must find out the
9197 size of address (specified in .debug_info and .debug_aranges). */
9198 for (i
= 0, section
= section_headers
;
9199 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9202 char *name
= SECTION_NAME (section
);
9205 if (section
->sh_size
== 0)
9208 /* See if there is some pre-scan operation for this section. */
9209 for (j
= NUM_ELEM (debug_displays
); j
--;)
9210 if (strcmp (debug_displays
[j
].name
, name
) == 0)
9212 if (debug_displays
[j
].prescan
!= NULL
)
9214 bfd_size_type length
;
9215 unsigned char *start
;
9217 length
= section
->sh_size
;
9218 start
= ((unsigned char *)
9219 get_data (NULL
, file
, section
->sh_offset
, length
,
9220 _("debug section data")));
9224 debug_displays
[j
].prescan (section
, start
, file
);
9232 for (i
= 0, section
= section_headers
;
9233 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9236 #ifdef SUPPORT_DISASSEMBLY
9237 if (dump_sects
[i
] & DISASS_DUMP
)
9238 disassemble_section (section
, file
);
9240 if (dump_sects
[i
] & HEX_DUMP
)
9241 dump_section (section
, file
);
9243 if (dump_sects
[i
] & DEBUG_DUMP
)
9244 display_debug_section (section
, file
);
9247 if (i
< num_dump_sects
)
9248 warn (_("Some sections were not dumped because they do not exist!\n"));
9254 process_mips_fpe_exception (mask
)
9260 if (mask
& OEX_FPU_INEX
)
9261 fputs ("INEX", stdout
), first
= 0;
9262 if (mask
& OEX_FPU_UFLO
)
9263 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9264 if (mask
& OEX_FPU_OFLO
)
9265 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9266 if (mask
& OEX_FPU_DIV0
)
9267 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9268 if (mask
& OEX_FPU_INVAL
)
9269 printf ("%sINVAL", first
? "" : "|");
9272 fputs ("0", stdout
);
9276 process_mips_specific (file
)
9279 Elf_Internal_Dyn
*entry
;
9280 size_t liblist_offset
= 0;
9281 size_t liblistno
= 0;
9282 size_t conflictsno
= 0;
9283 size_t options_offset
= 0;
9284 size_t conflicts_offset
= 0;
9286 /* We have a lot of special sections. Thanks SGI! */
9287 if (dynamic_segment
== NULL
)
9288 /* No information available. */
9291 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9292 switch (entry
->d_tag
)
9294 case DT_MIPS_LIBLIST
:
9295 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
9297 case DT_MIPS_LIBLISTNO
:
9298 liblistno
= entry
->d_un
.d_val
;
9300 case DT_MIPS_OPTIONS
:
9301 options_offset
= entry
->d_un
.d_val
- loadaddr
;
9303 case DT_MIPS_CONFLICT
:
9304 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
9306 case DT_MIPS_CONFLICTNO
:
9307 conflictsno
= entry
->d_un
.d_val
;
9313 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9315 Elf32_External_Lib
*elib
;
9318 elib
= ((Elf32_External_Lib
*)
9319 get_data (NULL
, file
, liblist_offset
,
9320 liblistno
* sizeof (Elf32_External_Lib
),
9324 printf ("\nSection '.liblist' contains %lu entries:\n",
9325 (unsigned long) liblistno
);
9326 fputs (" Library Time Stamp Checksum Version Flags\n",
9329 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9336 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9337 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9338 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9339 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9340 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9342 tmp
= gmtime (&time
);
9343 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9344 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9345 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9347 printf ("%3lu: ", (unsigned long) cnt
);
9348 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9349 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9352 if (liblist
.l_flags
== 0)
9363 { " EXACT_MATCH", LL_EXACT_MATCH
},
9364 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9365 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9366 { " EXPORTS", LL_EXPORTS
},
9367 { " DELAY_LOAD", LL_DELAY_LOAD
},
9368 { " DELTA", LL_DELTA
}
9370 int flags
= liblist
.l_flags
;
9374 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9376 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9378 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9379 flags
^= l_flags_vals
[fcnt
].bit
;
9382 printf (" %#x", (unsigned int) flags
);
9392 if (options_offset
!= 0)
9394 Elf_External_Options
*eopt
;
9395 Elf_Internal_Shdr
*sect
= section_headers
;
9396 Elf_Internal_Options
*iopt
;
9397 Elf_Internal_Options
*option
;
9401 /* Find the section header so that we get the size. */
9402 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9405 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9406 sect
->sh_size
, _("options"));
9409 iopt
= ((Elf_Internal_Options
*)
9410 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
)));
9413 error (_("Out of memory"));
9420 while (offset
< sect
->sh_size
)
9422 Elf_External_Options
*eoption
;
9424 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9426 option
->kind
= BYTE_GET (eoption
->kind
);
9427 option
->size
= BYTE_GET (eoption
->size
);
9428 option
->section
= BYTE_GET (eoption
->section
);
9429 option
->info
= BYTE_GET (eoption
->info
);
9431 offset
+= option
->size
;
9437 printf (_("\nSection '%s' contains %d entries:\n"),
9438 SECTION_NAME (sect
), cnt
);
9446 switch (option
->kind
)
9449 /* This shouldn't happen. */
9450 printf (" NULL %d %lx", option
->section
, option
->info
);
9453 printf (" REGINFO ");
9454 if (elf_header
.e_machine
== EM_MIPS
)
9457 Elf32_External_RegInfo
*ereg
;
9458 Elf32_RegInfo reginfo
;
9460 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9461 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9462 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9463 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9464 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9465 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9466 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9468 printf ("GPR %08lx GP 0x%lx\n",
9470 (unsigned long) reginfo
.ri_gp_value
);
9471 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9472 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9473 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9478 Elf64_External_RegInfo
*ereg
;
9479 Elf64_Internal_RegInfo reginfo
;
9481 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9482 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9483 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9484 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9485 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9486 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9487 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9489 printf ("GPR %08lx GP 0x",
9490 reginfo
.ri_gprmask
);
9491 printf_vma (reginfo
.ri_gp_value
);
9494 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9495 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9496 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9500 case ODK_EXCEPTIONS
:
9501 fputs (" EXCEPTIONS fpe_min(", stdout
);
9502 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9503 fputs (") fpe_max(", stdout
);
9504 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9505 fputs (")", stdout
);
9507 if (option
->info
& OEX_PAGE0
)
9508 fputs (" PAGE0", stdout
);
9509 if (option
->info
& OEX_SMM
)
9510 fputs (" SMM", stdout
);
9511 if (option
->info
& OEX_FPDBUG
)
9512 fputs (" FPDBUG", stdout
);
9513 if (option
->info
& OEX_DISMISS
)
9514 fputs (" DISMISS", stdout
);
9517 fputs (" PAD ", stdout
);
9518 if (option
->info
& OPAD_PREFIX
)
9519 fputs (" PREFIX", stdout
);
9520 if (option
->info
& OPAD_POSTFIX
)
9521 fputs (" POSTFIX", stdout
);
9522 if (option
->info
& OPAD_SYMBOL
)
9523 fputs (" SYMBOL", stdout
);
9526 fputs (" HWPATCH ", stdout
);
9527 if (option
->info
& OHW_R4KEOP
)
9528 fputs (" R4KEOP", stdout
);
9529 if (option
->info
& OHW_R8KPFETCH
)
9530 fputs (" R8KPFETCH", stdout
);
9531 if (option
->info
& OHW_R5KEOP
)
9532 fputs (" R5KEOP", stdout
);
9533 if (option
->info
& OHW_R5KCVTL
)
9534 fputs (" R5KCVTL", stdout
);
9537 fputs (" FILL ", stdout
);
9538 /* XXX Print content of info word? */
9541 fputs (" TAGS ", stdout
);
9542 /* XXX Print content of info word? */
9545 fputs (" HWAND ", stdout
);
9546 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9547 fputs (" R4KEOP_CHECKED", stdout
);
9548 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9549 fputs (" R4KEOP_CLEAN", stdout
);
9552 fputs (" HWOR ", stdout
);
9553 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9554 fputs (" R4KEOP_CHECKED", stdout
);
9555 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9556 fputs (" R4KEOP_CLEAN", stdout
);
9559 printf (" GP_GROUP %#06lx self-contained %#06lx",
9560 option
->info
& OGP_GROUP
,
9561 (option
->info
& OGP_SELF
) >> 16);
9564 printf (" IDENT %#06lx self-contained %#06lx",
9565 option
->info
& OGP_GROUP
,
9566 (option
->info
& OGP_SELF
) >> 16);
9569 /* This shouldn't happen. */
9570 printf (" %3d ??? %d %lx",
9571 option
->kind
, option
->section
, option
->info
);
9575 len
= sizeof (*eopt
);
9576 while (len
< option
->size
)
9577 if (((char *) option
)[len
] >= ' '
9578 && ((char *) option
)[len
] < 0x7f)
9579 printf ("%c", ((char *) option
)[len
++]);
9581 printf ("\\%03o", ((char *) option
)[len
++]);
9583 fputs ("\n", stdout
);
9591 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9593 Elf32_Conflict
*iconf
;
9596 if (dynamic_symbols
== NULL
)
9598 error (_("conflict list found without a dynamic symbol table"));
9602 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
9605 error (_("Out of memory"));
9611 Elf32_External_Conflict
*econf32
;
9613 econf32
= ((Elf32_External_Conflict
*)
9614 get_data (NULL
, file
, conflicts_offset
,
9615 conflictsno
* sizeof (*econf32
),
9620 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9621 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9627 Elf64_External_Conflict
*econf64
;
9629 econf64
= ((Elf64_External_Conflict
*)
9630 get_data (NULL
, file
, conflicts_offset
,
9631 conflictsno
* sizeof (*econf64
),
9636 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9637 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9642 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9643 (long) conflictsno
);
9644 puts (_(" Num: Index Value Name"));
9646 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9648 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9650 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9651 print_vma (psym
->st_value
, FULL_HEX
);
9653 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9664 process_gnu_liblist (file
)
9667 Elf_Internal_Shdr
*section
, *string_sec
;
9668 Elf32_External_Lib
*elib
;
9676 for (i
= 0, section
= section_headers
;
9677 i
< elf_header
.e_shnum
;
9680 switch (section
->sh_type
)
9682 case SHT_GNU_LIBLIST
:
9683 elib
= ((Elf32_External_Lib
*)
9684 get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9689 string_sec
= SECTION_HEADER (section
->sh_link
);
9691 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9692 string_sec
->sh_size
,
9693 _("liblist string table"));
9696 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9702 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9703 SECTION_NAME (section
),
9704 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9706 puts (" Library Time Stamp Checksum Version Flags");
9708 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9716 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9717 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9718 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9719 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9720 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9722 tmp
= gmtime (&time
);
9723 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9724 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9725 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9727 printf ("%3lu: ", (unsigned long) cnt
);
9729 printf ("%-20s", strtab
+ liblist
.l_name
);
9731 printf ("%-20.20s", strtab
+ liblist
.l_name
);
9732 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9733 liblist
.l_version
, liblist
.l_flags
);
9744 get_note_type (e_type
)
9747 static char buff
[64];
9751 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9752 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9753 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9754 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9755 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9756 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9757 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9758 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9759 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9760 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9761 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9763 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9769 get_netbsd_elfcore_note_type (e_type
)
9772 static char buff
[64];
9774 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9776 /* NetBSD core "procinfo" structure. */
9777 return _("NetBSD procinfo structure");
9780 /* As of Jan 2002 there are no other machine-independent notes
9781 defined for NetBSD core files. If the note type is less
9782 than the start of the machine-dependent note types, we don't
9785 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9787 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9791 switch (elf_header
.e_machine
)
9793 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9794 and PT_GETFPREGS == mach+2. */
9799 case EM_SPARC32PLUS
:
9803 case NT_NETBSDCORE_FIRSTMACH
+0:
9804 return _("PT_GETREGS (reg structure)");
9805 case NT_NETBSDCORE_FIRSTMACH
+2:
9806 return _("PT_GETFPREGS (fpreg structure)");
9812 /* On all other arch's, PT_GETREGS == mach+1 and
9813 PT_GETFPREGS == mach+3. */
9817 case NT_NETBSDCORE_FIRSTMACH
+1:
9818 return _("PT_GETREGS (reg structure)");
9819 case NT_NETBSDCORE_FIRSTMACH
+3:
9820 return _("PT_GETFPREGS (fpreg structure)");
9826 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9830 /* Note that by the ELF standard, the name field is already null byte
9831 terminated, and namesz includes the terminating null byte.
9832 I.E. the value of namesz for the name "FSF" is 4.
9834 If the value of namesz is zero, there is no name present. */
9836 process_note (pnote
)
9837 Elf_Internal_Note
*pnote
;
9841 if (pnote
->namesz
== 0)
9843 /* If there is no note name, then use the default set of
9844 note type strings. */
9845 nt
= get_note_type (pnote
->type
);
9847 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9849 /* NetBSD-specific core file notes. */
9850 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9854 /* Don't recognize this note name; just use the default set of
9855 note type strings. */
9856 nt
= get_note_type (pnote
->type
);
9859 printf (" %s\t\t0x%08lx\t%s\n",
9860 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9867 process_corefile_note_segment (file
, offset
, length
)
9872 Elf_External_Note
*pnotes
;
9873 Elf_External_Note
*external
;
9879 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9886 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9887 (unsigned long) offset
, (unsigned long) length
);
9888 printf (_(" Owner\t\tData size\tDescription\n"));
9890 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9892 Elf_External_Note
*next
;
9893 Elf_Internal_Note inote
;
9896 inote
.type
= BYTE_GET (external
->type
);
9897 inote
.namesz
= BYTE_GET (external
->namesz
);
9898 inote
.namedata
= external
->name
;
9899 inote
.descsz
= BYTE_GET (external
->descsz
);
9900 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9901 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9903 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9905 if (((char *) next
) > (((char *) pnotes
) + length
))
9907 warn (_("corrupt note found at offset %x into core notes\n"),
9908 ((char *) external
) - ((char *) pnotes
));
9909 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9910 inote
.type
, inote
.namesz
, inote
.descsz
);
9916 /* Verify that name is null terminated. It appears that at least
9917 one version of Linux (RedHat 6.0) generates corefiles that don't
9918 comply with the ELF spec by failing to include the null byte in
9920 if (inote
.namedata
[inote
.namesz
] != '\0')
9922 temp
= malloc (inote
.namesz
+ 1);
9926 error (_("Out of memory\n"));
9931 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9932 temp
[inote
.namesz
] = 0;
9934 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9935 inote
.namedata
= temp
;
9938 res
&= process_note (& inote
);
9953 process_corefile_note_segments (file
)
9956 Elf_Internal_Phdr
*program_headers
;
9957 Elf_Internal_Phdr
*segment
;
9961 program_headers
= (Elf_Internal_Phdr
*) malloc
9962 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9964 if (program_headers
== NULL
)
9966 error (_("Out of memory\n"));
9971 i
= get_32bit_program_headers (file
, program_headers
);
9973 i
= get_64bit_program_headers (file
, program_headers
);
9977 free (program_headers
);
9981 for (i
= 0, segment
= program_headers
;
9982 i
< elf_header
.e_phnum
;
9985 if (segment
->p_type
== PT_NOTE
)
9986 res
&= process_corefile_note_segment (file
,
9987 (bfd_vma
) segment
->p_offset
,
9988 (bfd_vma
) segment
->p_filesz
);
9991 free (program_headers
);
9997 process_corefile_contents (file
)
10000 /* If we have not been asked to display the notes then do nothing. */
10004 /* If file is not a core file then exit. */
10005 if (elf_header
.e_type
!= ET_CORE
)
10008 /* No program headers means no NOTE segment. */
10009 if (elf_header
.e_phnum
== 0)
10011 printf (_("No note segments present in the core file.\n"));
10015 return process_corefile_note_segments (file
);
10019 process_arch_specific (file
)
10025 switch (elf_header
.e_machine
)
10028 case EM_MIPS_RS3_LE
:
10029 return process_mips_specific (file
);
10038 get_file_header (file
)
10041 /* Read in the identity array. */
10042 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10045 /* Determine how to read the rest of the header. */
10046 switch (elf_header
.e_ident
[EI_DATA
])
10048 default: /* fall through */
10049 case ELFDATANONE
: /* fall through */
10050 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
10051 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
10054 /* For now we only support 32 bit and 64 bit ELF files. */
10055 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10057 /* Read in the rest of the header. */
10060 Elf32_External_Ehdr ehdr32
;
10062 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10065 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10066 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10067 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10068 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10069 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10070 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10071 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10072 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10073 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10074 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10075 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10076 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10077 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10081 Elf64_External_Ehdr ehdr64
;
10083 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10084 we will not be able to cope with the 64bit data found in
10085 64 ELF files. Detect this now and abort before we start
10086 overwritting things. */
10087 if (sizeof (bfd_vma
) < 8)
10089 error (_("This instance of readelf has been built without support for a\n\
10090 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10094 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10097 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10098 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10099 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10100 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10101 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10102 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10103 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10104 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10105 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10106 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10107 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10108 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10109 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10112 if (elf_header
.e_shoff
)
10114 /* There may be some extensions in the first section header. Don't
10115 bomb if we can't read it. */
10117 get_32bit_section_headers (file
, 1);
10119 get_64bit_section_headers (file
, 1);
10126 process_file (file_name
)
10130 struct stat statbuf
;
10133 if (stat (file_name
, & statbuf
) < 0)
10135 error (_("Cannot stat input file %s.\n"), file_name
);
10139 file
= fopen (file_name
, "rb");
10142 error (_("Input file %s not found.\n"), file_name
);
10146 if (! get_file_header (file
))
10148 error (_("%s: Failed to read file header\n"), file_name
);
10153 /* Initialise per file variables. */
10154 for (i
= NUM_ELEM (version_info
); i
--;)
10155 version_info
[i
] = 0;
10157 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10158 dynamic_info
[i
] = 0;
10160 /* Process the file. */
10162 printf (_("\nFile: %s\n"), file_name
);
10164 if (! process_file_header ())
10170 if (! process_section_headers (file
))
10172 /* Without loaded section headers we
10173 cannot process lots of things. */
10174 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10176 if (! do_using_dynamic
)
10177 do_syms
= do_reloc
= 0;
10180 if (process_program_headers (file
))
10181 process_dynamic_segment (file
);
10183 process_relocs (file
);
10185 process_unwind (file
);
10187 process_symbol_table (file
);
10189 process_syminfo (file
);
10191 process_version_sections (file
);
10193 process_section_contents (file
);
10195 process_corefile_contents (file
);
10197 process_gnu_liblist (file
);
10199 process_arch_specific (file
);
10203 if (section_headers
)
10205 free (section_headers
);
10206 section_headers
= NULL
;
10211 free (string_table
);
10212 string_table
= NULL
;
10213 string_table_length
= 0;
10216 if (dynamic_strings
)
10218 free (dynamic_strings
);
10219 dynamic_strings
= NULL
;
10222 if (dynamic_symbols
)
10224 free (dynamic_symbols
);
10225 dynamic_symbols
= NULL
;
10226 num_dynamic_syms
= 0;
10229 if (dynamic_syminfo
)
10231 free (dynamic_syminfo
);
10232 dynamic_syminfo
= NULL
;
10238 #ifdef SUPPORT_DISASSEMBLY
10239 /* Needed by the i386 disassembler. For extra credit, someone could
10240 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10244 print_address (unsigned int addr
, FILE *outfile
)
10246 fprintf (outfile
,"0x%8.8x", addr
);
10249 /* Needed by the i386 disassembler. */
10251 db_task_printsym (unsigned int addr
)
10253 print_address (addr
, stderr
);
10257 int main
PARAMS ((int, char **));
10266 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10267 setlocale (LC_MESSAGES
, "");
10269 #if defined (HAVE_SETLOCALE)
10270 setlocale (LC_CTYPE
, "");
10272 bindtextdomain (PACKAGE
, LOCALEDIR
);
10273 textdomain (PACKAGE
);
10275 parse_args (argc
, argv
);
10277 if (optind
< (argc
- 1))
10281 while (optind
< argc
)
10282 err
|= process_file (argv
[optind
++]);
10284 if (dump_sects
!= NULL
)