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 long dynamic_addr
;
94 bfd_size_type dynamic_size
;
95 char *dynamic_strings
;
97 unsigned long string_table_length
;
98 unsigned long num_dynamic_syms
;
99 Elf_Internal_Sym
*dynamic_symbols
;
100 Elf_Internal_Syminfo
*dynamic_syminfo
;
101 unsigned long dynamic_syminfo_offset
;
102 unsigned int dynamic_syminfo_nent
;
103 char program_interpreter
[64];
104 long dynamic_info
[DT_JMPREL
+ 1];
105 long version_info
[16];
107 Elf_Internal_Ehdr elf_header
;
108 Elf_Internal_Shdr
*section_headers
;
109 Elf_Internal_Dyn
*dynamic_segment
;
110 Elf_Internal_Shdr
*symtab_shndx_hdr
;
118 int do_using_dynamic
;
126 int do_debug_abbrevs
;
128 int do_debug_pubnames
;
129 int do_debug_aranges
;
131 int do_debug_frames_interp
;
132 int do_debug_macinfo
;
139 /* A dynamic array of flags indicating which sections require dumping. */
140 char *dump_sects
= NULL
;
141 unsigned int num_dump_sects
= 0;
143 #define HEX_DUMP (1 << 0)
144 #define DISASS_DUMP (1 << 1)
145 #define DEBUG_DUMP (1 << 2)
147 /* How to rpint a vma value. */
148 typedef enum print_mode
160 /* Forward declarations for dumb compilers. */
161 static void print_vma
162 PARAMS ((bfd_vma
, print_mode
));
163 static void print_symbol
164 PARAMS ((int, const char *));
165 static bfd_vma (*byte_get
)
166 PARAMS ((unsigned char *, int));
167 static bfd_vma byte_get_little_endian
168 PARAMS ((unsigned char *, int));
169 static bfd_vma byte_get_big_endian
170 PARAMS ((unsigned char *, int));
171 static const char *get_mips_dynamic_type
172 PARAMS ((unsigned long));
173 static const char *get_sparc64_dynamic_type
174 PARAMS ((unsigned long));
175 static const char *get_ppc64_dynamic_type
176 PARAMS ((unsigned long));
177 static const char *get_parisc_dynamic_type
178 PARAMS ((unsigned long));
179 static const char *get_dynamic_type
180 PARAMS ((unsigned long));
181 static int slurp_rela_relocs
182 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**,
184 static int slurp_rel_relocs
185 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**,
187 static int dump_relocations
188 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*,
189 unsigned long, char *, int));
190 static char *get_file_type
192 static char *get_machine_name
194 static void decode_ARM_machine_flags
195 PARAMS ((unsigned, char[]));
196 static char *get_machine_flags
197 PARAMS ((unsigned, unsigned));
198 static const char *get_mips_segment_type
199 PARAMS ((unsigned long));
200 static const char *get_parisc_segment_type
201 PARAMS ((unsigned long));
202 static const char *get_ia64_segment_type
203 PARAMS ((unsigned long));
204 static const char *get_segment_type
205 PARAMS ((unsigned long));
206 static const char *get_mips_section_type_name
207 PARAMS ((unsigned int));
208 static const char *get_parisc_section_type_name
209 PARAMS ((unsigned int));
210 static const char *get_ia64_section_type_name
211 PARAMS ((unsigned int));
212 static const char *get_section_type_name
213 PARAMS ((unsigned int));
214 static const char *get_symbol_binding
215 PARAMS ((unsigned int));
216 static const char *get_symbol_type
217 PARAMS ((unsigned int));
218 static const char *get_symbol_visibility
219 PARAMS ((unsigned int));
220 static const char *get_symbol_index_type
221 PARAMS ((unsigned int));
222 static const char *get_dynamic_flags
226 static void parse_args
227 PARAMS ((int, char **));
228 static int process_file_header
230 static int process_program_headers
232 static int process_section_headers
234 static int process_unwind
236 static void dynamic_segment_mips_val
237 PARAMS ((Elf_Internal_Dyn
*));
238 static void dynamic_segment_parisc_val
239 PARAMS ((Elf_Internal_Dyn
*));
240 static int process_dynamic_segment
242 static int process_symbol_table
244 static int process_syminfo
246 static int process_section_contents
248 static void process_mips_fpe_exception
250 static int process_mips_specific
252 static int process_file
254 static int process_relocs
256 static int process_version_sections
258 static char *get_ver_flags
259 PARAMS ((unsigned int));
260 static int get_32bit_section_headers
261 PARAMS ((FILE *, unsigned int));
262 static int get_64bit_section_headers
263 PARAMS ((FILE *, unsigned int));
264 static int get_32bit_program_headers
265 PARAMS ((FILE *, Elf_Internal_Phdr
*));
266 static int get_64bit_program_headers
267 PARAMS ((FILE *, Elf_Internal_Phdr
*));
268 static int get_file_header
270 static Elf_Internal_Sym
*get_32bit_elf_symbols
271 PARAMS ((FILE *, Elf_Internal_Shdr
*));
272 static Elf_Internal_Sym
*get_64bit_elf_symbols
273 PARAMS ((FILE *, Elf_Internal_Shdr
*));
274 static const char *get_elf_section_flags
276 static int *get_dynamic_data
277 PARAMS ((FILE *, unsigned int));
278 static int get_32bit_dynamic_segment
280 static int get_64bit_dynamic_segment
282 #ifdef SUPPORT_DISASSEMBLY
283 static int disassemble_section
284 PARAMS ((Elf_Internal_Shdr
*, FILE *));
286 static int dump_section
287 PARAMS ((Elf_Internal_Shdr
*, FILE *));
288 static int display_debug_section
289 PARAMS ((Elf_Internal_Shdr
*, FILE *));
290 static int display_debug_info
291 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
292 static int display_debug_not_supported
293 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
294 static int prescan_debug_info
295 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
296 static int display_debug_lines
297 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
298 static int display_debug_pubnames
299 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
300 static int display_debug_abbrev
301 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
302 static int display_debug_aranges
303 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
304 static int display_debug_frames
305 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
306 static int display_debug_macinfo
307 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
308 static int display_debug_str
309 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
310 static int display_debug_loc
311 PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
312 static unsigned char *process_abbrev_section
313 PARAMS ((unsigned char *, unsigned char *));
314 static void load_debug_str
316 static void free_debug_str
318 static const char *fetch_indirect_string
319 PARAMS ((unsigned long));
320 static void load_debug_loc
322 static void free_debug_loc
324 static unsigned long read_leb128
325 PARAMS ((unsigned char *, int *, int));
326 static int process_extended_line_op
327 PARAMS ((unsigned char *, int, int));
328 static void reset_state_machine
330 static char *get_TAG_name
331 PARAMS ((unsigned long));
332 static char *get_AT_name
333 PARAMS ((unsigned long));
334 static char *get_FORM_name
335 PARAMS ((unsigned long));
336 static void free_abbrevs
338 static void add_abbrev
339 PARAMS ((unsigned long, unsigned long, int));
340 static void add_abbrev_attr
341 PARAMS ((unsigned long, unsigned long));
342 static unsigned char *read_and_display_attr
343 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
345 static unsigned char *read_and_display_attr_value
346 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
348 static unsigned char *display_block
349 PARAMS ((unsigned char *, unsigned long));
350 static void decode_location_expression
351 PARAMS ((unsigned char *, unsigned int, unsigned long));
352 static void request_dump
353 PARAMS ((unsigned int, int));
354 static const char *get_elf_class
355 PARAMS ((unsigned int));
356 static const char *get_data_encoding
357 PARAMS ((unsigned int));
358 static const char *get_osabi_name
359 PARAMS ((unsigned int));
360 static int guess_is_rela
361 PARAMS ((unsigned long));
362 static const char *get_note_type
363 PARAMS ((unsigned int));
364 static const char *get_netbsd_elfcore_note_type
365 PARAMS ((unsigned int));
366 static int process_note
367 PARAMS ((Elf_Internal_Note
*));
368 static int process_corefile_note_segment
369 PARAMS ((FILE *, bfd_vma
, bfd_vma
));
370 static int process_corefile_note_segments
372 static int process_corefile_contents
374 static int process_arch_specific
376 static int process_gnu_liblist
379 typedef int Elf32_Word
;
383 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
384 ((X)->sh_name >= string_table_length \
385 ? "<corrupt>" : string_table + (X)->sh_name))
387 /* Given st_shndx I, map to section_headers index. */
388 #define SECTION_HEADER_INDEX(I) \
389 ((I) < SHN_LORESERVE \
391 : ((I) <= SHN_HIRESERVE \
393 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
395 /* Reverse of the above. */
396 #define SECTION_HEADER_NUM(N) \
397 ((N) < SHN_LORESERVE \
399 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
401 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
403 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
405 #define BYTE_GET(field) byte_get (field, sizeof (field))
407 /* If we can support a 64 bit data type then BFD64 should be defined
408 and sizeof (bfd_vma) == 8. In this case when translating from an
409 external 8 byte field to an internal field, we can assume that the
410 internal field is also 8 bytes wide and so we can extract all the data.
411 If, however, BFD64 is not defined, then we must assume that the
412 internal data structure only has 4 byte wide fields that are the
413 equivalent of the 8 byte wide external counterparts, and so we must
414 truncate the data. */
416 #define BYTE_GET8(field) byte_get (field, -8)
418 #define BYTE_GET8(field) byte_get (field, 8)
421 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
423 #define GET_ELF_SYMBOLS(file, section) \
424 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
425 : get_64bit_elf_symbols (file, section))
429 error
VPARAMS ((const char *message
, ...))
431 VA_OPEN (args
, message
);
432 VA_FIXEDARG (args
, const char *, message
);
434 fprintf (stderr
, _("%s: Error: "), program_name
);
435 vfprintf (stderr
, message
, args
);
440 warn
VPARAMS ((const char *message
, ...))
442 VA_OPEN (args
, message
);
443 VA_FIXEDARG (args
, const char *, message
);
445 fprintf (stderr
, _("%s: Warning: "), program_name
);
446 vfprintf (stderr
, message
, args
);
450 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
453 get_data (var
, file
, offset
, size
, reason
)
465 if (fseek (file
, offset
, SEEK_SET
))
467 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
474 mvar
= (PTR
) malloc (size
);
478 error (_("Out of memory allocating %d bytes for %s\n"),
484 if (fread (mvar
, size
, 1, file
) != 1)
486 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
496 byte_get_little_endian (field
, size
)
497 unsigned char *field
;
506 return ((unsigned int) (field
[0]))
507 | (((unsigned int) (field
[1])) << 8);
511 /* We want to extract data from an 8 byte wide field and
512 place it into a 4 byte wide field. Since this is a little
513 endian source we can just use the 4 byte extraction code. */
517 return ((unsigned long) (field
[0]))
518 | (((unsigned long) (field
[1])) << 8)
519 | (((unsigned long) (field
[2])) << 16)
520 | (((unsigned long) (field
[3])) << 24);
525 /* This is a special case, generated by the BYTE_GET8 macro.
526 It means that we are loading an 8 byte value from a field
527 in an external structure into an 8 byte value in a field
528 in an internal strcuture. */
529 return ((bfd_vma
) (field
[0]))
530 | (((bfd_vma
) (field
[1])) << 8)
531 | (((bfd_vma
) (field
[2])) << 16)
532 | (((bfd_vma
) (field
[3])) << 24)
533 | (((bfd_vma
) (field
[4])) << 32)
534 | (((bfd_vma
) (field
[5])) << 40)
535 | (((bfd_vma
) (field
[6])) << 48)
536 | (((bfd_vma
) (field
[7])) << 56);
539 error (_("Unhandled data length: %d\n"), size
);
544 /* Print a VMA value. */
546 print_vma (vma
, mode
)
556 case FULL_HEX
: printf ("0x"); /* drop through */
557 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
558 case PREFIX_HEX
: printf ("0x"); /* drop through */
559 case HEX
: printf ("%lx", (unsigned long) vma
); break;
560 case DEC
: printf ("%ld", (unsigned long) vma
); break;
561 case DEC_5
: printf ("%5ld", (long) vma
); break;
562 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
583 #if BFD_HOST_64BIT_LONG
586 if (_bfd_int64_high (vma
))
587 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
589 printf ("%lx", _bfd_int64_low (vma
));
594 #if BFD_HOST_64BIT_LONG
597 if (_bfd_int64_high (vma
))
599 printf ("++%ld", _bfd_int64_low (vma
));
601 printf ("%ld", _bfd_int64_low (vma
));
606 #if BFD_HOST_64BIT_LONG
607 printf ("%5ld", vma
);
609 if (_bfd_int64_high (vma
))
611 printf ("++%ld", _bfd_int64_low (vma
));
613 printf ("%5ld", _bfd_int64_low (vma
));
618 #if BFD_HOST_64BIT_LONG
621 if (_bfd_int64_high (vma
))
623 printf ("++%lu", _bfd_int64_low (vma
));
625 printf ("%lu", _bfd_int64_low (vma
));
633 /* Display a symbol on stdout. If do_wide is not true then
634 format the symbol to be at most WIDTH characters,
635 truncating as necessary. If WIDTH is negative then
636 format the string to be exactly - WIDTH characters,
637 truncating or padding as necessary. */
640 print_symbol (width
, symbol
)
645 printf ("%s", symbol
);
647 printf ("%-*.*s", width
, width
, symbol
);
649 printf ("%-.*s", width
, symbol
);
653 byte_get_big_endian (field
, size
)
654 unsigned char *field
;
663 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
666 return ((unsigned long) (field
[3]))
667 | (((unsigned long) (field
[2])) << 8)
668 | (((unsigned long) (field
[1])) << 16)
669 | (((unsigned long) (field
[0])) << 24);
673 /* Although we are extracing data from an 8 byte wide field, we
674 are returning only 4 bytes of data. */
675 return ((unsigned long) (field
[7]))
676 | (((unsigned long) (field
[6])) << 8)
677 | (((unsigned long) (field
[5])) << 16)
678 | (((unsigned long) (field
[4])) << 24);
682 /* This is a special case, generated by the BYTE_GET8 macro.
683 It means that we are loading an 8 byte value from a field
684 in an external structure into an 8 byte value in a field
685 in an internal strcuture. */
686 return ((bfd_vma
) (field
[7]))
687 | (((bfd_vma
) (field
[6])) << 8)
688 | (((bfd_vma
) (field
[5])) << 16)
689 | (((bfd_vma
) (field
[4])) << 24)
690 | (((bfd_vma
) (field
[3])) << 32)
691 | (((bfd_vma
) (field
[2])) << 40)
692 | (((bfd_vma
) (field
[1])) << 48)
693 | (((bfd_vma
) (field
[0])) << 56);
697 error (_("Unhandled data length: %d\n"), size
);
702 /* Guess the relocation size commonly used by the specific machines. */
705 guess_is_rela (e_machine
)
706 unsigned long e_machine
;
710 /* Targets that use REL relocations. */
726 /* Targets that use RELA relocations. */
741 case EM_CYGNUS_MN10200
:
743 case EM_CYGNUS_MN10300
:
783 warn (_("Don't know about relocations on this machine architecture\n"));
789 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
791 unsigned long rel_offset
;
792 unsigned long rel_size
;
793 Elf_Internal_Rela
**relasp
;
794 unsigned long *nrelasp
;
796 Elf_Internal_Rela
*relas
;
797 unsigned long nrelas
;
802 Elf32_External_Rela
*erelas
;
804 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
805 rel_size
, _("relocs"));
809 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
811 relas
= (Elf_Internal_Rela
*)
812 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
816 error(_("out of memory parsing relocs"));
820 for (i
= 0; i
< nrelas
; i
++)
822 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
823 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
824 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
831 Elf64_External_Rela
*erelas
;
833 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
834 rel_size
, _("relocs"));
838 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
840 relas
= (Elf_Internal_Rela
*)
841 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
845 error(_("out of memory parsing relocs"));
849 for (i
= 0; i
< nrelas
; i
++)
851 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
852 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
853 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
864 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
866 unsigned long rel_offset
;
867 unsigned long rel_size
;
868 Elf_Internal_Rela
**relsp
;
869 unsigned long *nrelsp
;
871 Elf_Internal_Rela
*rels
;
877 Elf32_External_Rel
*erels
;
879 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
880 rel_size
, _("relocs"));
884 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
886 rels
= (Elf_Internal_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
890 error(_("out of memory parsing relocs"));
894 for (i
= 0; i
< nrels
; i
++)
896 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
897 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
898 rels
[i
].r_addend
= 0;
905 Elf64_External_Rel
*erels
;
907 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
908 rel_size
, _("relocs"));
912 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
914 rels
= (Elf_Internal_Rela
*) malloc (nrels
* sizeof (Elf_Internal_Rela
));
918 error(_("out of memory parsing relocs"));
922 for (i
= 0; i
< nrels
; i
++)
924 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
925 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
926 rels
[i
].r_addend
= 0;
936 /* Display the contents of the relocation data found at the specified offset. */
938 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
940 unsigned long rel_offset
;
941 unsigned long rel_size
;
942 Elf_Internal_Sym
*symtab
;
948 Elf_Internal_Rela
*rels
;
951 if (is_rela
== UNKNOWN
)
952 is_rela
= guess_is_rela (elf_header
.e_machine
);
956 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
961 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
970 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
972 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
977 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
979 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
987 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
989 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
994 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
996 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1000 for (i
= 0; i
< rel_size
; i
++)
1003 const char *rtype2
= NULL
;
1004 const char *rtype3
= NULL
;
1007 bfd_vma symtab_index
;
1009 bfd_vma type2
= (bfd_vma
) NULL
;
1010 bfd_vma type3
= (bfd_vma
) NULL
;
1012 offset
= rels
[i
].r_offset
;
1013 info
= rels
[i
].r_info
;
1017 type
= ELF32_R_TYPE (info
);
1018 symtab_index
= ELF32_R_SYM (info
);
1022 if (elf_header
.e_machine
== EM_MIPS
)
1024 type
= ELF64_MIPS_R_TYPE (info
);
1025 type2
= ELF64_MIPS_R_TYPE2 (info
);
1026 type3
= ELF64_MIPS_R_TYPE3 (info
);
1028 else if (elf_header
.e_machine
== EM_SPARCV9
)
1029 type
= ELF64_R_TYPE_ID (info
);
1031 type
= ELF64_R_TYPE (info
);
1032 /* The #ifdef BFD64 below is to prevent a compile time warning.
1033 We know that if we do not have a 64 bit data type that we
1034 will never execute this code anyway. */
1036 symtab_index
= ELF64_R_SYM (info
);
1042 #ifdef _bfd_int64_low
1043 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1045 printf ("%8.8lx %8.8lx ", offset
, info
);
1050 #ifdef _bfd_int64_low
1052 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1053 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1054 _bfd_int64_high (offset
),
1055 _bfd_int64_low (offset
),
1056 _bfd_int64_high (info
),
1057 _bfd_int64_low (info
));
1060 ? "%16.16lx %16.16lx "
1061 : "%12.12lx %12.12lx ",
1066 switch (elf_header
.e_machine
)
1073 case EM_CYGNUS_M32R
:
1074 rtype
= elf_m32r_reloc_type (type
);
1079 rtype
= elf_i386_reloc_type (type
);
1084 rtype
= elf_m68hc11_reloc_type (type
);
1088 rtype
= elf_m68k_reloc_type (type
);
1092 rtype
= elf_i960_reloc_type (type
);
1097 rtype
= elf_avr_reloc_type (type
);
1100 case EM_OLD_SPARCV9
:
1101 case EM_SPARC32PLUS
:
1104 rtype
= elf_sparc_reloc_type (type
);
1108 case EM_CYGNUS_V850
:
1109 rtype
= v850_reloc_type (type
);
1113 case EM_CYGNUS_D10V
:
1114 rtype
= elf_d10v_reloc_type (type
);
1118 case EM_CYGNUS_D30V
:
1119 rtype
= elf_d30v_reloc_type (type
);
1123 rtype
= elf_dlx_reloc_type (type
);
1127 rtype
= elf_sh_reloc_type (type
);
1131 case EM_CYGNUS_MN10300
:
1132 rtype
= elf_mn10300_reloc_type (type
);
1136 case EM_CYGNUS_MN10200
:
1137 rtype
= elf_mn10200_reloc_type (type
);
1141 case EM_CYGNUS_FR30
:
1142 rtype
= elf_fr30_reloc_type (type
);
1146 rtype
= elf_frv_reloc_type (type
);
1150 rtype
= elf_mcore_reloc_type (type
);
1154 rtype
= elf_mmix_reloc_type (type
);
1159 rtype
= elf_ppc_reloc_type (type
);
1163 case EM_MIPS_RS3_LE
:
1164 rtype
= elf_mips_reloc_type (type
);
1167 rtype2
= elf_mips_reloc_type (type2
);
1168 rtype3
= elf_mips_reloc_type (type3
);
1173 rtype
= elf_alpha_reloc_type (type
);
1177 rtype
= elf_arm_reloc_type (type
);
1181 rtype
= elf_arc_reloc_type (type
);
1185 rtype
= elf_hppa_reloc_type (type
);
1191 rtype
= elf_h8_reloc_type (type
);
1196 rtype
= elf_or32_reloc_type (type
);
1201 rtype
= elf_pj_reloc_type (type
);
1204 rtype
= elf_ia64_reloc_type (type
);
1208 rtype
= elf_cris_reloc_type (type
);
1212 rtype
= elf_i860_reloc_type (type
);
1216 rtype
= elf_x86_64_reloc_type (type
);
1220 rtype
= i370_reloc_type (type
);
1225 rtype
= elf_s390_reloc_type (type
);
1229 rtype
= elf_xstormy16_reloc_type (type
);
1233 rtype
= elf_vax_reloc_type (type
);
1238 rtype
= elf_ip2k_reloc_type (type
);
1243 #ifdef _bfd_int64_low
1244 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1246 printf (_("unrecognized: %-7lx"), type
);
1249 printf (do_wide
? "%-21.21s" : "%-17.17s", rtype
);
1253 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1254 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1257 Elf_Internal_Sym
*psym
;
1259 psym
= symtab
+ symtab_index
;
1262 print_vma (psym
->st_value
, LONG_HEX
);
1263 printf (is_32bit_elf
? " " : " ");
1265 if (psym
->st_name
== 0)
1267 const char *sec_name
= "<null>";
1270 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1272 bfd_vma sec_index
= (bfd_vma
) -1;
1274 if (psym
->st_shndx
< SHN_LORESERVE
)
1275 sec_index
= psym
->st_shndx
;
1276 else if (psym
->st_shndx
> SHN_LORESERVE
)
1277 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1280 if (sec_index
!= (bfd_vma
) -1)
1281 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1282 else if (psym
->st_shndx
== SHN_ABS
)
1284 else if (psym
->st_shndx
== SHN_COMMON
)
1285 sec_name
= "COMMON";
1288 sprintf (name_buf
, "<section 0x%x>",
1289 (unsigned int) psym
->st_shndx
);
1290 sec_name
= name_buf
;
1293 print_symbol (22, sec_name
);
1295 else if (strtab
== NULL
)
1296 printf (_("<string table index %3ld>"), psym
->st_name
);
1298 print_symbol (22, strtab
+ psym
->st_name
);
1301 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1306 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1307 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1310 if (elf_header
.e_machine
== EM_SPARCV9
1311 && !strcmp (rtype
, "R_SPARC_OLO10"))
1312 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1316 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1318 printf (" Type2: ");
1321 #ifdef _bfd_int64_low
1322 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1324 printf (_("unrecognized: %-7lx"), type2
);
1327 printf ("%-17.17s", rtype2
);
1329 printf("\n Type3: ");
1332 #ifdef _bfd_int64_low
1333 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1335 printf (_("unrecognized: %-7lx"), type3
);
1338 printf ("%-17.17s", rtype3
);
1350 get_mips_dynamic_type (type
)
1355 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1356 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1357 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1358 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1359 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1360 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1361 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1362 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1363 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1364 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1365 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1366 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1367 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1368 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1369 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1370 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1371 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1372 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1373 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1374 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1375 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1376 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1377 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1378 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1379 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1380 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1381 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1382 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1383 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1384 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1385 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1386 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1387 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1388 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1389 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1390 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1391 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1392 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1393 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1394 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1395 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1396 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1397 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1404 get_sparc64_dynamic_type (type
)
1409 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1416 get_ppc64_dynamic_type (type
)
1421 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1422 case DT_PPC64_OPD
: return "PPC64_OPD";
1423 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1430 get_parisc_dynamic_type (type
)
1435 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1436 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1437 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1438 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1439 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1440 case DT_HP_PREINIT
: return "HP_PREINIT";
1441 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1442 case DT_HP_NEEDED
: return "HP_NEEDED";
1443 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1444 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1445 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1446 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1447 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1454 get_dynamic_type (type
)
1457 static char buff
[32];
1461 case DT_NULL
: return "NULL";
1462 case DT_NEEDED
: return "NEEDED";
1463 case DT_PLTRELSZ
: return "PLTRELSZ";
1464 case DT_PLTGOT
: return "PLTGOT";
1465 case DT_HASH
: return "HASH";
1466 case DT_STRTAB
: return "STRTAB";
1467 case DT_SYMTAB
: return "SYMTAB";
1468 case DT_RELA
: return "RELA";
1469 case DT_RELASZ
: return "RELASZ";
1470 case DT_RELAENT
: return "RELAENT";
1471 case DT_STRSZ
: return "STRSZ";
1472 case DT_SYMENT
: return "SYMENT";
1473 case DT_INIT
: return "INIT";
1474 case DT_FINI
: return "FINI";
1475 case DT_SONAME
: return "SONAME";
1476 case DT_RPATH
: return "RPATH";
1477 case DT_SYMBOLIC
: return "SYMBOLIC";
1478 case DT_REL
: return "REL";
1479 case DT_RELSZ
: return "RELSZ";
1480 case DT_RELENT
: return "RELENT";
1481 case DT_PLTREL
: return "PLTREL";
1482 case DT_DEBUG
: return "DEBUG";
1483 case DT_TEXTREL
: return "TEXTREL";
1484 case DT_JMPREL
: return "JMPREL";
1485 case DT_BIND_NOW
: return "BIND_NOW";
1486 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1487 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1488 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1489 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1490 case DT_RUNPATH
: return "RUNPATH";
1491 case DT_FLAGS
: return "FLAGS";
1493 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1494 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1496 case DT_CHECKSUM
: return "CHECKSUM";
1497 case DT_PLTPADSZ
: return "PLTPADSZ";
1498 case DT_MOVEENT
: return "MOVEENT";
1499 case DT_MOVESZ
: return "MOVESZ";
1500 case DT_FEATURE
: return "FEATURE";
1501 case DT_POSFLAG_1
: return "POSFLAG_1";
1502 case DT_SYMINSZ
: return "SYMINSZ";
1503 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1505 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1506 case DT_CONFIG
: return "CONFIG";
1507 case DT_DEPAUDIT
: return "DEPAUDIT";
1508 case DT_AUDIT
: return "AUDIT";
1509 case DT_PLTPAD
: return "PLTPAD";
1510 case DT_MOVETAB
: return "MOVETAB";
1511 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1513 case DT_VERSYM
: return "VERSYM";
1515 case DT_RELACOUNT
: return "RELACOUNT";
1516 case DT_RELCOUNT
: return "RELCOUNT";
1517 case DT_FLAGS_1
: return "FLAGS_1";
1518 case DT_VERDEF
: return "VERDEF";
1519 case DT_VERDEFNUM
: return "VERDEFNUM";
1520 case DT_VERNEED
: return "VERNEED";
1521 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1523 case DT_AUXILIARY
: return "AUXILIARY";
1524 case DT_USED
: return "USED";
1525 case DT_FILTER
: return "FILTER";
1527 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1528 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1529 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1530 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1531 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1534 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1538 switch (elf_header
.e_machine
)
1541 case EM_MIPS_RS3_LE
:
1542 result
= get_mips_dynamic_type (type
);
1545 result
= get_sparc64_dynamic_type (type
);
1548 result
= get_ppc64_dynamic_type (type
);
1558 sprintf (buff
, _("Processor Specific: %lx"), type
);
1560 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1564 switch (elf_header
.e_machine
)
1567 result
= get_parisc_dynamic_type (type
);
1577 sprintf (buff
, _("Operating System specific: %lx"), type
);
1580 sprintf (buff
, _("<unknown>: %lx"), type
);
1587 get_file_type (e_type
)
1590 static char buff
[32];
1594 case ET_NONE
: return _("NONE (None)");
1595 case ET_REL
: return _("REL (Relocatable file)");
1596 case ET_EXEC
: return _("EXEC (Executable file)");
1597 case ET_DYN
: return _("DYN (Shared object file)");
1598 case ET_CORE
: return _("CORE (Core file)");
1601 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1602 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1603 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1604 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1606 sprintf (buff
, _("<unknown>: %x"), e_type
);
1612 get_machine_name (e_machine
)
1615 static char buff
[64]; /* XXX */
1619 case EM_NONE
: return _("None");
1620 case EM_M32
: return "WE32100";
1621 case EM_SPARC
: return "Sparc";
1622 case EM_386
: return "Intel 80386";
1623 case EM_68K
: return "MC68000";
1624 case EM_88K
: return "MC88000";
1625 case EM_486
: return "Intel 80486";
1626 case EM_860
: return "Intel 80860";
1627 case EM_MIPS
: return "MIPS R3000";
1628 case EM_S370
: return "IBM System/370";
1629 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1630 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1631 case EM_PARISC
: return "HPPA";
1632 case EM_PPC_OLD
: return "Power PC (old)";
1633 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1634 case EM_960
: return "Intel 90860";
1635 case EM_PPC
: return "PowerPC";
1636 case EM_PPC64
: return "PowerPC64";
1637 case EM_V800
: return "NEC V800";
1638 case EM_FR20
: return "Fujitsu FR20";
1639 case EM_RH32
: return "TRW RH32";
1640 case EM_MCORE
: return "MCORE";
1641 case EM_ARM
: return "ARM";
1642 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1643 case EM_SH
: return "Hitachi SH";
1644 case EM_SPARCV9
: return "Sparc v9";
1645 case EM_TRICORE
: return "Siemens Tricore";
1646 case EM_ARC
: return "ARC";
1647 case EM_H8_300
: return "Hitachi H8/300";
1648 case EM_H8_300H
: return "Hitachi H8/300H";
1649 case EM_H8S
: return "Hitachi H8S";
1650 case EM_H8_500
: return "Hitachi H8/500";
1651 case EM_IA_64
: return "Intel IA-64";
1652 case EM_MIPS_X
: return "Stanford MIPS-X";
1653 case EM_COLDFIRE
: return "Motorola Coldfire";
1654 case EM_68HC12
: return "Motorola M68HC12";
1655 case EM_ALPHA
: return "Alpha";
1656 case EM_CYGNUS_D10V
:
1657 case EM_D10V
: return "d10v";
1658 case EM_CYGNUS_D30V
:
1659 case EM_D30V
: return "d30v";
1660 case EM_CYGNUS_M32R
:
1661 case EM_M32R
: return "Mitsubishi M32r";
1662 case EM_CYGNUS_V850
:
1663 case EM_V850
: return "NEC v850";
1664 case EM_CYGNUS_MN10300
:
1665 case EM_MN10300
: return "mn10300";
1666 case EM_CYGNUS_MN10200
:
1667 case EM_MN10200
: return "mn10200";
1668 case EM_CYGNUS_FR30
:
1669 case EM_FR30
: return "Fujitsu FR30";
1670 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1672 case EM_PJ
: return "picoJava";
1673 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1674 case EM_PCP
: return "Siemens PCP";
1675 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1676 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1677 case EM_STARCORE
: return "Motorola Star*Core processor";
1678 case EM_ME16
: return "Toyota ME16 processor";
1679 case EM_ST100
: return "STMicroelectronics ST100 processor";
1680 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1681 case EM_FX66
: return "Siemens FX66 microcontroller";
1682 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1683 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1684 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1685 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1686 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1687 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1688 case EM_SVX
: return "Silicon Graphics SVx";
1689 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1690 case EM_VAX
: return "Digital VAX";
1692 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1693 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1694 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1695 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1696 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1697 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1698 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1699 case EM_PRISM
: return "SiTera Prism";
1700 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1702 case EM_S390
: return "IBM S/390";
1703 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1705 case EM_OR32
: return "OpenRISC";
1706 case EM_DLX
: return "OpenDLX";
1708 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1710 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1716 decode_ARM_machine_flags (e_flags
, buf
)
1723 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1724 e_flags
&= ~ EF_ARM_EABIMASK
;
1726 /* Handle "generic" ARM flags. */
1727 if (e_flags
& EF_ARM_RELEXEC
)
1729 strcat (buf
, ", relocatable executable");
1730 e_flags
&= ~ EF_ARM_RELEXEC
;
1733 if (e_flags
& EF_ARM_HASENTRY
)
1735 strcat (buf
, ", has entry point");
1736 e_flags
&= ~ EF_ARM_HASENTRY
;
1739 /* Now handle EABI specific flags. */
1743 strcat (buf
, ", <unrecognized EABI>");
1748 case EF_ARM_EABI_VER1
:
1749 strcat (buf
, ", Version1 EABI");
1754 /* Process flags one bit at a time. */
1755 flag
= e_flags
& - e_flags
;
1760 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1761 strcat (buf
, ", sorted symbol tables");
1771 case EF_ARM_EABI_VER2
:
1772 strcat (buf
, ", Version2 EABI");
1777 /* Process flags one bit at a time. */
1778 flag
= e_flags
& - e_flags
;
1783 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1784 strcat (buf
, ", sorted symbol tables");
1787 case EF_ARM_DYNSYMSUSESEGIDX
:
1788 strcat (buf
, ", dynamic symbols use segment index");
1791 case EF_ARM_MAPSYMSFIRST
:
1792 strcat (buf
, ", mapping symbols precede others");
1802 case EF_ARM_EABI_UNKNOWN
:
1803 strcat (buf
, ", GNU EABI");
1808 /* Process flags one bit at a time. */
1809 flag
= e_flags
& - e_flags
;
1814 case EF_ARM_INTERWORK
:
1815 strcat (buf
, ", interworking enabled");
1818 case EF_ARM_APCS_26
:
1819 strcat (buf
, ", uses APCS/26");
1822 case EF_ARM_APCS_FLOAT
:
1823 strcat (buf
, ", uses APCS/float");
1827 strcat (buf
, ", position independent");
1831 strcat (buf
, ", 8 bit structure alignment");
1834 case EF_ARM_NEW_ABI
:
1835 strcat (buf
, ", uses new ABI");
1838 case EF_ARM_OLD_ABI
:
1839 strcat (buf
, ", uses old ABI");
1842 case EF_ARM_SOFT_FLOAT
:
1843 strcat (buf
, ", software FP");
1854 strcat (buf
,", <unknown>");
1858 get_machine_flags (e_flags
, e_machine
)
1862 static char buf
[1024];
1874 decode_ARM_machine_flags (e_flags
, buf
);
1878 if (e_flags
& EF_CPU32
)
1879 strcat (buf
, ", cpu32");
1880 if (e_flags
& EF_M68000
)
1881 strcat (buf
, ", m68000");
1885 if (e_flags
& EF_PPC_EMB
)
1886 strcat (buf
, ", emb");
1888 if (e_flags
& EF_PPC_RELOCATABLE
)
1889 strcat (buf
, ", relocatable");
1891 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1892 strcat (buf
, ", relocatable-lib");
1896 case EM_CYGNUS_V850
:
1897 switch (e_flags
& EF_V850_ARCH
)
1900 strcat (buf
, ", v850e");
1903 strcat (buf
, ", v850");
1906 strcat (buf
, ", unknown v850 architecture variant");
1912 case EM_CYGNUS_M32R
:
1913 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1914 strcat (buf
, ", m32r");
1919 case EM_MIPS_RS3_LE
:
1920 if (e_flags
& EF_MIPS_NOREORDER
)
1921 strcat (buf
, ", noreorder");
1923 if (e_flags
& EF_MIPS_PIC
)
1924 strcat (buf
, ", pic");
1926 if (e_flags
& EF_MIPS_CPIC
)
1927 strcat (buf
, ", cpic");
1929 if (e_flags
& EF_MIPS_UCODE
)
1930 strcat (buf
, ", ugen_reserved");
1932 if (e_flags
& EF_MIPS_ABI2
)
1933 strcat (buf
, ", abi2");
1935 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1936 strcat (buf
, ", odk first");
1938 if (e_flags
& EF_MIPS_32BITMODE
)
1939 strcat (buf
, ", 32bitmode");
1941 switch ((e_flags
& EF_MIPS_MACH
))
1943 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1944 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1945 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1946 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1947 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1948 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1949 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1950 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1951 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1953 /* We simply ignore the field in this case to avoid confusion:
1954 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1957 default: strcat (buf
, ", unknown CPU"); break;
1960 switch ((e_flags
& EF_MIPS_ABI
))
1962 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1963 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1964 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1965 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1967 /* We simply ignore the field in this case to avoid confusion:
1968 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1969 This means it is likely to be an o32 file, but not for
1972 default: strcat (buf
, ", unknown ABI"); break;
1975 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1976 strcat (buf
, ", mdmx");
1978 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1979 strcat (buf
, ", mips16");
1981 switch ((e_flags
& EF_MIPS_ARCH
))
1983 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1984 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1985 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1986 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1987 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1988 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1989 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1990 default: strcat (buf
, ", unknown ISA"); break;
1996 if (e_flags
& EF_SPARC_32PLUS
)
1997 strcat (buf
, ", v8+");
1999 if (e_flags
& EF_SPARC_SUN_US1
)
2000 strcat (buf
, ", ultrasparcI");
2002 if (e_flags
& EF_SPARC_SUN_US3
)
2003 strcat (buf
, ", ultrasparcIII");
2005 if (e_flags
& EF_SPARC_HAL_R1
)
2006 strcat (buf
, ", halr1");
2008 if (e_flags
& EF_SPARC_LEDATA
)
2009 strcat (buf
, ", ledata");
2011 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2012 strcat (buf
, ", tso");
2014 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2015 strcat (buf
, ", pso");
2017 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2018 strcat (buf
, ", rmo");
2022 switch (e_flags
& EF_PARISC_ARCH
)
2024 case EFA_PARISC_1_0
:
2025 strcpy (buf
, ", PA-RISC 1.0");
2027 case EFA_PARISC_1_1
:
2028 strcpy (buf
, ", PA-RISC 1.1");
2030 case EFA_PARISC_2_0
:
2031 strcpy (buf
, ", PA-RISC 2.0");
2036 if (e_flags
& EF_PARISC_TRAPNIL
)
2037 strcat (buf
, ", trapnil");
2038 if (e_flags
& EF_PARISC_EXT
)
2039 strcat (buf
, ", ext");
2040 if (e_flags
& EF_PARISC_LSB
)
2041 strcat (buf
, ", lsb");
2042 if (e_flags
& EF_PARISC_WIDE
)
2043 strcat (buf
, ", wide");
2044 if (e_flags
& EF_PARISC_NO_KABP
)
2045 strcat (buf
, ", no kabp");
2046 if (e_flags
& EF_PARISC_LAZYSWAP
)
2047 strcat (buf
, ", lazyswap");
2052 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2053 strcat (buf
, ", new calling convention");
2055 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2056 strcat (buf
, ", gnu calling convention");
2060 if ((e_flags
& EF_IA_64_ABI64
))
2061 strcat (buf
, ", 64-bit");
2063 strcat (buf
, ", 32-bit");
2064 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2065 strcat (buf
, ", reduced fp model");
2066 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2067 strcat (buf
, ", no function descriptors, constant gp");
2068 else if ((e_flags
& EF_IA_64_CONS_GP
))
2069 strcat (buf
, ", constant gp");
2070 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2071 strcat (buf
, ", absolute");
2075 if ((e_flags
& EF_VAX_NONPIC
))
2076 strcat (buf
, ", non-PIC");
2077 if ((e_flags
& EF_VAX_DFLOAT
))
2078 strcat (buf
, ", D-Float");
2079 if ((e_flags
& EF_VAX_GFLOAT
))
2080 strcat (buf
, ", G-Float");
2089 get_mips_segment_type (type
)
2094 case PT_MIPS_REGINFO
:
2096 case PT_MIPS_RTPROC
:
2098 case PT_MIPS_OPTIONS
:
2108 get_parisc_segment_type (type
)
2113 case PT_HP_TLS
: return "HP_TLS";
2114 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2115 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2116 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2117 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2118 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2119 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2120 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2121 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2122 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2123 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2124 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2125 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2126 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2135 get_ia64_segment_type (type
)
2140 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2141 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2142 case PT_HP_TLS
: return "HP_TLS";
2143 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2144 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2145 case PT_IA_64_HP_STACK
: return "HP_STACK";
2154 get_segment_type (p_type
)
2155 unsigned long p_type
;
2157 static char buff
[32];
2161 case PT_NULL
: return "NULL";
2162 case PT_LOAD
: return "LOAD";
2163 case PT_DYNAMIC
: return "DYNAMIC";
2164 case PT_INTERP
: return "INTERP";
2165 case PT_NOTE
: return "NOTE";
2166 case PT_SHLIB
: return "SHLIB";
2167 case PT_PHDR
: return "PHDR";
2168 case PT_TLS
: return "TLS";
2170 case PT_GNU_EH_FRAME
:
2171 return "GNU_EH_FRAME";
2174 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2178 switch (elf_header
.e_machine
)
2181 case EM_MIPS_RS3_LE
:
2182 result
= get_mips_segment_type (p_type
);
2185 result
= get_parisc_segment_type (p_type
);
2188 result
= get_ia64_segment_type (p_type
);
2198 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2200 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2204 switch (elf_header
.e_machine
)
2207 result
= get_parisc_segment_type (p_type
);
2210 result
= get_ia64_segment_type (p_type
);
2220 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2223 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2230 get_mips_section_type_name (sh_type
)
2231 unsigned int sh_type
;
2235 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2236 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2237 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2238 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2239 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2240 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2241 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2242 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2243 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2244 case SHT_MIPS_RELD
: return "MIPS_RELD";
2245 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2246 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2247 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2248 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2249 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2250 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2251 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2252 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2253 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2254 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2255 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2256 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2257 case SHT_MIPS_LINE
: return "MIPS_LINE";
2258 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2259 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2260 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2261 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2262 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2263 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2264 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2265 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2266 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2267 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2268 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2269 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2270 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2271 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2272 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2273 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2281 get_parisc_section_type_name (sh_type
)
2282 unsigned int sh_type
;
2286 case SHT_PARISC_EXT
: return "PARISC_EXT";
2287 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2288 case SHT_PARISC_DOC
: return "PARISC_DOC";
2296 get_ia64_section_type_name (sh_type
)
2297 unsigned int sh_type
;
2301 case SHT_IA_64_EXT
: return "IA_64_EXT";
2302 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2310 get_section_type_name (sh_type
)
2311 unsigned int sh_type
;
2313 static char buff
[32];
2317 case SHT_NULL
: return "NULL";
2318 case SHT_PROGBITS
: return "PROGBITS";
2319 case SHT_SYMTAB
: return "SYMTAB";
2320 case SHT_STRTAB
: return "STRTAB";
2321 case SHT_RELA
: return "RELA";
2322 case SHT_HASH
: return "HASH";
2323 case SHT_DYNAMIC
: return "DYNAMIC";
2324 case SHT_NOTE
: return "NOTE";
2325 case SHT_NOBITS
: return "NOBITS";
2326 case SHT_REL
: return "REL";
2327 case SHT_SHLIB
: return "SHLIB";
2328 case SHT_DYNSYM
: return "DYNSYM";
2329 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2330 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2331 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2332 case SHT_GROUP
: return "GROUP";
2333 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2334 case SHT_GNU_verdef
: return "VERDEF";
2335 case SHT_GNU_verneed
: return "VERNEED";
2336 case SHT_GNU_versym
: return "VERSYM";
2337 case 0x6ffffff0: return "VERSYM";
2338 case 0x6ffffffc: return "VERDEF";
2339 case 0x7ffffffd: return "AUXILIARY";
2340 case 0x7fffffff: return "FILTER";
2341 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2344 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2348 switch (elf_header
.e_machine
)
2351 case EM_MIPS_RS3_LE
:
2352 result
= get_mips_section_type_name (sh_type
);
2355 result
= get_parisc_section_type_name (sh_type
);
2358 result
= get_ia64_section_type_name (sh_type
);
2368 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2370 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2371 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2372 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2373 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2375 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2381 #define OPTION_DEBUG_DUMP 512
2383 struct option options
[] =
2385 {"all", no_argument
, 0, 'a'},
2386 {"file-header", no_argument
, 0, 'h'},
2387 {"program-headers", no_argument
, 0, 'l'},
2388 {"headers", no_argument
, 0, 'e'},
2389 {"histogram", no_argument
, 0, 'I'},
2390 {"segments", no_argument
, 0, 'l'},
2391 {"sections", no_argument
, 0, 'S'},
2392 {"section-headers", no_argument
, 0, 'S'},
2393 {"symbols", no_argument
, 0, 's'},
2394 {"syms", no_argument
, 0, 's'},
2395 {"relocs", no_argument
, 0, 'r'},
2396 {"notes", no_argument
, 0, 'n'},
2397 {"dynamic", no_argument
, 0, 'd'},
2398 {"arch-specific", no_argument
, 0, 'A'},
2399 {"version-info", no_argument
, 0, 'V'},
2400 {"use-dynamic", no_argument
, 0, 'D'},
2401 {"hex-dump", required_argument
, 0, 'x'},
2402 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2403 {"unwind", no_argument
, 0, 'u'},
2404 #ifdef SUPPORT_DISASSEMBLY
2405 {"instruction-dump", required_argument
, 0, 'i'},
2408 {"version", no_argument
, 0, 'v'},
2409 {"wide", no_argument
, 0, 'W'},
2410 {"help", no_argument
, 0, 'H'},
2411 {0, no_argument
, 0, 0}
2417 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2418 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2419 fprintf (stdout
, _(" Options are:\n\
2420 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2421 -h --file-header Display the ELF file header\n\
2422 -l --program-headers Display the program headers\n\
2423 --segments An alias for --program-headers\n\
2424 -S --section-headers Display the sections' header\n\
2425 --sections An alias for --section-headers\n\
2426 -e --headers Equivalent to: -h -l -S\n\
2427 -s --syms Display the symbol table\n\
2428 --symbols An alias for --syms\n\
2429 -n --notes Display the core notes (if present)\n\
2430 -r --relocs Display the relocations (if present)\n\
2431 -u --unwind Display the unwind info (if present)\n\
2432 -d --dynamic Display the dynamic segment (if present)\n\
2433 -V --version-info Display the version sections (if present)\n\
2434 -A --arch-specific Display architecture specific information (if any).\n\
2435 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2436 -x --hex-dump=<number> Dump the contents of section <number>\n\
2437 -w[liaprmfFso] or\n\
2438 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2439 Display the contents of DWARF2 debug sections\n"));
2440 #ifdef SUPPORT_DISASSEMBLY
2441 fprintf (stdout
, _("\
2442 -i --instruction-dump=<number>\n\
2443 Disassemble the contents of section <number>\n"));
2445 fprintf (stdout
, _("\
2446 -I --histogram Display histogram of bucket list lengths\n\
2447 -W --wide Allow output width to exceed 80 characters\n\
2448 -H --help Display this information\n\
2449 -v --version Display the version number of readelf\n"));
2450 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2456 request_dump (section
, type
)
2457 unsigned int section
;
2460 if (section
>= num_dump_sects
)
2462 char *new_dump_sects
;
2464 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2466 if (new_dump_sects
== NULL
)
2467 error (_("Out of memory allocating dump request table."));
2470 /* Copy current flag settings. */
2471 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2475 dump_sects
= new_dump_sects
;
2476 num_dump_sects
= section
+ 1;
2481 dump_sects
[section
] |= type
;
2487 parse_args (argc
, argv
)
2496 while ((c
= getopt_long
2497 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2564 section
= strtoul (optarg
, & cp
, 0);
2565 if (! *cp
&& section
>= 0)
2567 request_dump (section
, HEX_DUMP
);
2577 unsigned int index
= 0;
2581 while (optarg
[index
])
2582 switch (optarg
[index
++])
2591 do_debug_abbrevs
= 1;
2601 do_debug_pubnames
= 1;
2606 do_debug_aranges
= 1;
2610 do_debug_frames_interp
= 1;
2612 do_debug_frames
= 1;
2617 do_debug_macinfo
= 1;
2631 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2636 case OPTION_DEBUG_DUMP
:
2642 static const char *debug_dump_opt
[]
2643 = { "line", "info", "abbrev", "pubnames", "ranges",
2644 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2653 for (index
= 0; debug_dump_opt
[index
]; index
++)
2655 size_t len
= strlen (debug_dump_opt
[index
]);
2657 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2658 && (p
[len
] == ',' || p
[len
] == '\0'))
2667 do_debug_abbrevs
= 1;
2678 do_debug_pubnames
= 1;
2682 do_debug_aranges
= 1;
2687 do_debug_frames_interp
= 1;
2688 do_debug_frames
= 1;
2692 do_debug_macinfo
= 1;
2705 if (debug_dump_opt
[index
] == NULL
)
2707 warn (_("Unrecognized debug option '%s'\n"), p
);
2708 p
= strchr (p
, ',');
2718 #ifdef SUPPORT_DISASSEMBLY
2721 section
= strtoul (optarg
, & cp
, 0);
2722 if (! *cp
&& section
>= 0)
2724 request_dump (section
, DISASS_DUMP
);
2730 print_version (program_name
);
2740 /* xgettext:c-format */
2741 error (_("Invalid option '-%c'\n"), c
);
2748 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2749 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2750 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2754 warn (_("Nothing to do.\n"));
2760 get_elf_class (elf_class
)
2761 unsigned int elf_class
;
2763 static char buff
[32];
2767 case ELFCLASSNONE
: return _("none");
2768 case ELFCLASS32
: return "ELF32";
2769 case ELFCLASS64
: return "ELF64";
2771 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2777 get_data_encoding (encoding
)
2778 unsigned int encoding
;
2780 static char buff
[32];
2784 case ELFDATANONE
: return _("none");
2785 case ELFDATA2LSB
: return _("2's complement, little endian");
2786 case ELFDATA2MSB
: return _("2's complement, big endian");
2788 sprintf (buff
, _("<unknown: %x>"), encoding
);
2794 get_osabi_name (osabi
)
2797 static char buff
[32];
2801 case ELFOSABI_NONE
: return "UNIX - System V";
2802 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2803 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2804 case ELFOSABI_LINUX
: return "UNIX - Linux";
2805 case ELFOSABI_HURD
: return "GNU/Hurd";
2806 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2807 case ELFOSABI_AIX
: return "UNIX - AIX";
2808 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2809 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2810 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2811 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2812 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2813 case ELFOSABI_STANDALONE
: return _("Standalone App");
2814 case ELFOSABI_ARM
: return "ARM";
2816 sprintf (buff
, _("<unknown: %x>"), osabi
);
2821 /* Decode the data held in 'elf_header'. */
2823 process_file_header ()
2825 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2826 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2827 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2828 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2831 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2839 printf (_("ELF Header:\n"));
2840 printf (_(" Magic: "));
2841 for (i
= 0; i
< EI_NIDENT
; i
++)
2842 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2844 printf (_(" Class: %s\n"),
2845 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2846 printf (_(" Data: %s\n"),
2847 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2848 printf (_(" Version: %d %s\n"),
2849 elf_header
.e_ident
[EI_VERSION
],
2850 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2852 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2855 printf (_(" OS/ABI: %s\n"),
2856 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2857 printf (_(" ABI Version: %d\n"),
2858 elf_header
.e_ident
[EI_ABIVERSION
]);
2859 printf (_(" Type: %s\n"),
2860 get_file_type (elf_header
.e_type
));
2861 printf (_(" Machine: %s\n"),
2862 get_machine_name (elf_header
.e_machine
));
2863 printf (_(" Version: 0x%lx\n"),
2864 (unsigned long) elf_header
.e_version
);
2866 printf (_(" Entry point address: "));
2867 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2868 printf (_("\n Start of program headers: "));
2869 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2870 printf (_(" (bytes into file)\n Start of section headers: "));
2871 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2872 printf (_(" (bytes into file)\n"));
2874 printf (_(" Flags: 0x%lx%s\n"),
2875 (unsigned long) elf_header
.e_flags
,
2876 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2877 printf (_(" Size of this header: %ld (bytes)\n"),
2878 (long) elf_header
.e_ehsize
);
2879 printf (_(" Size of program headers: %ld (bytes)\n"),
2880 (long) elf_header
.e_phentsize
);
2881 printf (_(" Number of program headers: %ld\n"),
2882 (long) elf_header
.e_phnum
);
2883 printf (_(" Size of section headers: %ld (bytes)\n"),
2884 (long) elf_header
.e_shentsize
);
2885 printf (_(" Number of section headers: %ld"),
2886 (long) elf_header
.e_shnum
);
2887 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2888 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2889 putc ('\n', stdout
);
2890 printf (_(" Section header string table index: %ld"),
2891 (long) elf_header
.e_shstrndx
);
2892 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2893 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2894 putc ('\n', stdout
);
2897 if (section_headers
!= NULL
)
2899 if (elf_header
.e_shnum
== 0)
2900 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2901 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2902 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2903 free (section_headers
);
2904 section_headers
= NULL
;
2912 get_32bit_program_headers (file
, program_headers
)
2914 Elf_Internal_Phdr
*program_headers
;
2916 Elf32_External_Phdr
*phdrs
;
2917 Elf32_External_Phdr
*external
;
2918 Elf_Internal_Phdr
*internal
;
2921 phdrs
= ((Elf32_External_Phdr
*)
2922 get_data (NULL
, file
, elf_header
.e_phoff
,
2923 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2924 _("program headers")));
2928 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2929 i
< elf_header
.e_phnum
;
2930 i
++, internal
++, external
++)
2932 internal
->p_type
= BYTE_GET (external
->p_type
);
2933 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2934 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2935 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2936 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2937 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2938 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2939 internal
->p_align
= BYTE_GET (external
->p_align
);
2948 get_64bit_program_headers (file
, program_headers
)
2950 Elf_Internal_Phdr
*program_headers
;
2952 Elf64_External_Phdr
*phdrs
;
2953 Elf64_External_Phdr
*external
;
2954 Elf_Internal_Phdr
*internal
;
2957 phdrs
= ((Elf64_External_Phdr
*)
2958 get_data (NULL
, file
, elf_header
.e_phoff
,
2959 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2960 _("program headers")));
2964 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2965 i
< elf_header
.e_phnum
;
2966 i
++, internal
++, external
++)
2968 internal
->p_type
= BYTE_GET (external
->p_type
);
2969 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2970 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2971 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2972 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2973 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2974 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2975 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2983 /* Returns 1 if the program headers were loaded. */
2986 process_program_headers (file
)
2989 Elf_Internal_Phdr
*program_headers
;
2990 Elf_Internal_Phdr
*segment
;
2993 if (elf_header
.e_phnum
== 0)
2996 printf (_("\nThere are no program headers in this file.\n"));
3000 if (do_segments
&& !do_header
)
3002 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3003 printf (_("Entry point "));
3004 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3005 printf (_("\nThere are %d program headers, starting at offset "),
3006 elf_header
.e_phnum
);
3007 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3011 program_headers
= (Elf_Internal_Phdr
*) malloc
3012 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3014 if (program_headers
== NULL
)
3016 error (_("Out of memory\n"));
3021 i
= get_32bit_program_headers (file
, program_headers
);
3023 i
= get_64bit_program_headers (file
, program_headers
);
3027 free (program_headers
);
3033 if (elf_header
.e_phnum
> 1)
3034 printf (_("\nProgram Headers:\n"));
3036 printf (_("\nProgram Headers:\n"));
3040 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3043 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3047 (_(" Type Offset VirtAddr PhysAddr\n"));
3049 (_(" FileSiz MemSiz Flags Align\n"));
3057 for (i
= 0, segment
= program_headers
;
3058 i
< elf_header
.e_phnum
;
3063 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3067 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3068 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3069 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3070 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3071 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3073 (segment
->p_flags
& PF_R
? 'R' : ' '),
3074 (segment
->p_flags
& PF_W
? 'W' : ' '),
3075 (segment
->p_flags
& PF_X
? 'E' : ' '));
3076 printf ("%#lx", (unsigned long) segment
->p_align
);
3080 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3081 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3084 print_vma (segment
->p_offset
, FULL_HEX
);
3088 print_vma (segment
->p_vaddr
, FULL_HEX
);
3090 print_vma (segment
->p_paddr
, FULL_HEX
);
3093 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3094 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3097 print_vma (segment
->p_filesz
, FULL_HEX
);
3101 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3102 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3105 print_vma (segment
->p_offset
, FULL_HEX
);
3109 (segment
->p_flags
& PF_R
? 'R' : ' '),
3110 (segment
->p_flags
& PF_W
? 'W' : ' '),
3111 (segment
->p_flags
& PF_X
? 'E' : ' '));
3113 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3114 printf ("%#lx", (unsigned long) segment
->p_align
);
3117 print_vma (segment
->p_align
, PREFIX_HEX
);
3122 print_vma (segment
->p_offset
, FULL_HEX
);
3124 print_vma (segment
->p_vaddr
, FULL_HEX
);
3126 print_vma (segment
->p_paddr
, FULL_HEX
);
3128 print_vma (segment
->p_filesz
, FULL_HEX
);
3130 print_vma (segment
->p_memsz
, FULL_HEX
);
3132 (segment
->p_flags
& PF_R
? 'R' : ' '),
3133 (segment
->p_flags
& PF_W
? 'W' : ' '),
3134 (segment
->p_flags
& PF_X
? 'E' : ' '));
3135 print_vma (segment
->p_align
, HEX
);
3139 switch (segment
->p_type
)
3144 unsigned long align_mask
= -segment
->p_align
;
3146 if (align_mask
== 0)
3148 loadaddr
= ((segment
->p_vaddr
& align_mask
)
3149 - (segment
->p_offset
& align_mask
));
3155 error (_("more than one dynamic segment\n"));
3157 dynamic_addr
= segment
->p_offset
;
3158 dynamic_size
= segment
->p_filesz
;
3162 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
3163 error (_("Unable to find program interpreter name\n"));
3166 program_interpreter
[0] = 0;
3167 fscanf (file
, "%63s", program_interpreter
);
3170 printf (_("\n [Requesting program interpreter: %s]"),
3171 program_interpreter
);
3177 putc ('\n', stdout
);
3186 if (do_segments
&& section_headers
!= NULL
)
3188 printf (_("\n Section to Segment mapping:\n"));
3189 printf (_(" Segment Sections...\n"));
3191 assert (string_table
!= NULL
);
3193 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3196 Elf_Internal_Shdr
*section
;
3198 segment
= program_headers
+ i
;
3199 section
= section_headers
;
3201 printf (" %2.2d ", i
);
3203 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3205 if (section
->sh_size
> 0
3206 /* Compare allocated sections by VMA, unallocated
3207 sections by file offset. */
3208 && (section
->sh_flags
& SHF_ALLOC
3209 ? (section
->sh_addr
>= segment
->p_vaddr
3210 && section
->sh_addr
+ section
->sh_size
3211 <= segment
->p_vaddr
+ segment
->p_memsz
)
3212 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3213 && (section
->sh_offset
+ section
->sh_size
3214 <= segment
->p_offset
+ segment
->p_filesz
))))
3215 printf ("%s ", SECTION_NAME (section
));
3222 free (program_headers
);
3229 get_32bit_section_headers (file
, num
)
3233 Elf32_External_Shdr
*shdrs
;
3234 Elf_Internal_Shdr
*internal
;
3237 shdrs
= ((Elf32_External_Shdr
*)
3238 get_data (NULL
, file
, elf_header
.e_shoff
,
3239 elf_header
.e_shentsize
* num
,
3240 _("section headers")));
3244 section_headers
= ((Elf_Internal_Shdr
*)
3245 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3247 if (section_headers
== NULL
)
3249 error (_("Out of memory\n"));
3253 for (i
= 0, internal
= section_headers
;
3257 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3258 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3259 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3260 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3261 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3262 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3263 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3264 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3265 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3266 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3275 get_64bit_section_headers (file
, num
)
3279 Elf64_External_Shdr
*shdrs
;
3280 Elf_Internal_Shdr
*internal
;
3283 shdrs
= ((Elf64_External_Shdr
*)
3284 get_data (NULL
, file
, elf_header
.e_shoff
,
3285 elf_header
.e_shentsize
* num
,
3286 _("section headers")));
3290 section_headers
= ((Elf_Internal_Shdr
*)
3291 malloc (num
* sizeof (Elf_Internal_Shdr
)));
3293 if (section_headers
== NULL
)
3295 error (_("Out of memory\n"));
3299 for (i
= 0, internal
= section_headers
;
3303 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3304 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3305 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3306 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3307 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3308 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3309 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3310 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3311 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3312 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3320 static Elf_Internal_Sym
*
3321 get_32bit_elf_symbols (file
, section
)
3323 Elf_Internal_Shdr
*section
;
3325 unsigned long number
;
3326 Elf32_External_Sym
*esyms
;
3327 Elf_External_Sym_Shndx
*shndx
;
3328 Elf_Internal_Sym
*isyms
;
3329 Elf_Internal_Sym
*psym
;
3332 esyms
= ((Elf32_External_Sym
*)
3333 get_data (NULL
, file
, section
->sh_offset
,
3334 section
->sh_size
, _("symbols")));
3339 if (symtab_shndx_hdr
!= NULL
3340 && (symtab_shndx_hdr
->sh_link
3341 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3343 shndx
= ((Elf_External_Sym_Shndx
*)
3344 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3345 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3353 number
= section
->sh_size
/ section
->sh_entsize
;
3354 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3358 error (_("Out of memory\n"));
3365 for (j
= 0, psym
= isyms
;
3369 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3370 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3371 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3372 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3373 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3375 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3376 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3377 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3387 static Elf_Internal_Sym
*
3388 get_64bit_elf_symbols (file
, section
)
3390 Elf_Internal_Shdr
*section
;
3392 unsigned long number
;
3393 Elf64_External_Sym
*esyms
;
3394 Elf_External_Sym_Shndx
*shndx
;
3395 Elf_Internal_Sym
*isyms
;
3396 Elf_Internal_Sym
*psym
;
3399 esyms
= ((Elf64_External_Sym
*)
3400 get_data (NULL
, file
, section
->sh_offset
,
3401 section
->sh_size
, _("symbols")));
3406 if (symtab_shndx_hdr
!= NULL
3407 && (symtab_shndx_hdr
->sh_link
3408 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3410 shndx
= ((Elf_External_Sym_Shndx
*)
3411 get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3412 symtab_shndx_hdr
->sh_size
, _("symtab shndx")));
3420 number
= section
->sh_size
/ section
->sh_entsize
;
3421 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
3425 error (_("Out of memory\n"));
3432 for (j
= 0, psym
= isyms
;
3436 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3437 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3438 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3439 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3440 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3442 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3443 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3444 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3455 get_elf_section_flags (sh_flags
)
3458 static char buff
[32];
3466 flag
= sh_flags
& - sh_flags
;
3471 case SHF_WRITE
: strcat (buff
, "W"); break;
3472 case SHF_ALLOC
: strcat (buff
, "A"); break;
3473 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3474 case SHF_MERGE
: strcat (buff
, "M"); break;
3475 case SHF_STRINGS
: strcat (buff
, "S"); break;
3476 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3477 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3478 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3479 case SHF_GROUP
: strcat (buff
, "G"); break;
3480 case SHF_TLS
: strcat (buff
, "T"); break;
3483 if (flag
& SHF_MASKOS
)
3486 sh_flags
&= ~ SHF_MASKOS
;
3488 else if (flag
& SHF_MASKPROC
)
3491 sh_flags
&= ~ SHF_MASKPROC
;
3503 process_section_headers (file
)
3506 Elf_Internal_Shdr
*section
;
3509 section_headers
= NULL
;
3511 if (elf_header
.e_shnum
== 0)
3514 printf (_("\nThere are no sections in this file.\n"));
3519 if (do_sections
&& !do_header
)
3520 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3521 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3525 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3528 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3531 /* Read in the string table, so that we have names to display. */
3532 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3534 if (section
->sh_size
!= 0)
3536 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3537 section
->sh_size
, _("string table"));
3539 string_table_length
= section
->sh_size
;
3542 /* Scan the sections for the dynamic symbol table
3543 and dynamic string table and debug sections. */
3544 dynamic_symbols
= NULL
;
3545 dynamic_strings
= NULL
;
3546 dynamic_syminfo
= NULL
;
3547 symtab_shndx_hdr
= NULL
;
3549 for (i
= 0, section
= section_headers
;
3550 i
< elf_header
.e_shnum
;
3553 char *name
= SECTION_NAME (section
);
3555 if (section
->sh_type
== SHT_DYNSYM
)
3557 if (dynamic_symbols
!= NULL
)
3559 error (_("File contains multiple dynamic symbol tables\n"));
3563 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3564 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3566 else if (section
->sh_type
== SHT_STRTAB
3567 && strcmp (name
, ".dynstr") == 0)
3569 if (dynamic_strings
!= NULL
)
3571 error (_("File contains multiple dynamic string tables\n"));
3575 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3577 _("dynamic strings"));
3579 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3581 if (symtab_shndx_hdr
!= NULL
)
3583 error (_("File contains multiple symtab shndx tables\n"));
3586 symtab_shndx_hdr
= section
;
3588 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3589 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3590 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3592 && strncmp (name
, ".debug_", 7) == 0)
3597 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3598 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3599 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3600 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3601 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3602 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3603 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3604 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3605 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3607 request_dump (i
, DEBUG_DUMP
);
3609 /* linkonce section to be combined with .debug_info at link time. */
3610 else if ((do_debugging
|| do_debug_info
)
3611 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3612 request_dump (i
, DEBUG_DUMP
);
3613 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3614 request_dump (i
, DEBUG_DUMP
);
3620 if (elf_header
.e_shnum
> 1)
3621 printf (_("\nSection Headers:\n"));
3623 printf (_("\nSection Header:\n"));
3627 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3630 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3633 printf (_(" [Nr] Name Type Address Offset\n"));
3634 printf (_(" Size EntSize Flags Link Info Align\n"));
3637 for (i
= 0, section
= section_headers
;
3638 i
< elf_header
.e_shnum
;
3641 printf (" [%2u] %-17.17s %-15.15s ",
3642 SECTION_HEADER_NUM (i
),
3643 SECTION_NAME (section
),
3644 get_section_type_name (section
->sh_type
));
3648 print_vma (section
->sh_addr
, LONG_HEX
);
3650 printf ( " %6.6lx %6.6lx %2.2lx",
3651 (unsigned long) section
->sh_offset
,
3652 (unsigned long) section
->sh_size
,
3653 (unsigned long) section
->sh_entsize
);
3655 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3657 printf ("%2ld %3lx %2ld\n",
3658 (unsigned long) section
->sh_link
,
3659 (unsigned long) section
->sh_info
,
3660 (unsigned long) section
->sh_addralign
);
3664 print_vma (section
->sh_addr
, LONG_HEX
);
3666 if ((long) section
->sh_offset
== section
->sh_offset
)
3667 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3671 print_vma (section
->sh_offset
, LONG_HEX
);
3674 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3675 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3679 print_vma (section
->sh_size
, LONG_HEX
);
3682 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3683 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3687 print_vma (section
->sh_entsize
, LONG_HEX
);
3690 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3692 printf ("%2ld %3lx ",
3693 (unsigned long) section
->sh_link
,
3694 (unsigned long) section
->sh_info
);
3696 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3697 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3700 print_vma (section
->sh_addralign
, DEC
);
3707 print_vma (section
->sh_addr
, LONG_HEX
);
3708 if ((long) section
->sh_offset
== section
->sh_offset
)
3709 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3713 print_vma (section
->sh_offset
, LONG_HEX
);
3716 print_vma (section
->sh_size
, LONG_HEX
);
3718 print_vma (section
->sh_entsize
, LONG_HEX
);
3720 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3722 printf (" %2ld %3lx %ld\n",
3723 (unsigned long) section
->sh_link
,
3724 (unsigned long) section
->sh_info
,
3725 (unsigned long) section
->sh_addralign
);
3729 printf (_("Key to Flags:\n\
3730 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3731 I (info), L (link order), G (group), x (unknown)\n\
3732 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3737 /* Process the reloc section. */
3739 process_relocs (file
)
3742 unsigned long rel_size
;
3743 unsigned long rel_offset
;
3749 if (do_using_dynamic
)
3751 int is_rela
= FALSE
;
3756 if (dynamic_info
[DT_REL
])
3758 rel_offset
= dynamic_info
[DT_REL
];
3759 rel_size
= dynamic_info
[DT_RELSZ
];
3762 else if (dynamic_info
[DT_RELA
])
3764 rel_offset
= dynamic_info
[DT_RELA
];
3765 rel_size
= dynamic_info
[DT_RELASZ
];
3768 else if (dynamic_info
[DT_JMPREL
])
3770 rel_offset
= dynamic_info
[DT_JMPREL
];
3771 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3773 switch (dynamic_info
[DT_PLTREL
])
3790 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3791 rel_offset
, rel_size
);
3793 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3794 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
,
3798 printf (_("\nThere are no dynamic relocations in this file.\n"));
3802 Elf_Internal_Shdr
*section
;
3806 for (i
= 0, section
= section_headers
;
3807 i
< elf_header
.e_shnum
;
3810 if ( section
->sh_type
!= SHT_RELA
3811 && section
->sh_type
!= SHT_REL
)
3814 rel_offset
= section
->sh_offset
;
3815 rel_size
= section
->sh_size
;
3819 Elf_Internal_Shdr
*strsec
;
3820 Elf_Internal_Sym
*symtab
;
3823 unsigned long nsyms
;
3825 printf (_("\nRelocation section "));
3827 if (string_table
== NULL
)
3828 printf ("%d", section
->sh_name
);
3830 printf (_("'%s'"), SECTION_NAME (section
));
3832 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3833 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3838 if (section
->sh_link
)
3840 Elf_Internal_Shdr
*symsec
;
3842 symsec
= SECTION_HEADER (section
->sh_link
);
3843 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3844 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3849 strsec
= SECTION_HEADER (symsec
->sh_link
);
3851 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3855 is_rela
= section
->sh_type
== SHT_RELA
;
3857 dump_relocations (file
, rel_offset
, rel_size
,
3858 symtab
, nsyms
, strtab
, is_rela
);
3870 printf (_("\nThere are no relocations in this file.\n"));
3876 #include "unwind-ia64.h"
3878 /* An absolute address consists of a section and an offset. If the
3879 section is NULL, the offset itself is the address, otherwise, the
3880 address equals to LOAD_ADDRESS(section) + offset. */
3884 unsigned short section
;
3890 struct unw_table_entry
3892 struct absaddr start
;
3894 struct absaddr info
;
3896 *table
; /* Unwind table. */
3897 unsigned long table_len
; /* Length of unwind table. */
3898 unsigned char *info
; /* Unwind info. */
3899 unsigned long info_size
; /* Size of unwind info. */
3900 bfd_vma info_addr
; /* starting address of unwind info. */
3901 bfd_vma seg_base
; /* Starting address of segment. */
3902 Elf_Internal_Sym
*symtab
; /* The symbol table. */
3903 unsigned long nsyms
; /* Number of symbols. */
3904 char *strtab
; /* The string table. */
3905 unsigned long strtab_size
; /* Size of string table. */
3908 static void find_symbol_for_address
3909 PARAMS ((struct unw_aux_info
*, struct absaddr
, const char **, bfd_vma
*));
3910 static void dump_ia64_unwind
3911 PARAMS ((struct unw_aux_info
*));
3912 static int slurp_ia64_unwind_table
3913 PARAMS ((FILE *, struct unw_aux_info
*, Elf_Internal_Shdr
*));
3916 find_symbol_for_address (aux
, addr
, symname
, offset
)
3917 struct unw_aux_info
*aux
;
3918 struct absaddr addr
;
3919 const char **symname
;
3922 bfd_vma dist
= (bfd_vma
) 0x100000;
3923 Elf_Internal_Sym
*sym
, *best
= NULL
;
3926 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3928 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3929 && sym
->st_name
!= 0
3930 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3931 && addr
.offset
>= sym
->st_value
3932 && addr
.offset
- sym
->st_value
< dist
)
3935 dist
= addr
.offset
- sym
->st_value
;
3942 *symname
= (best
->st_name
>= aux
->strtab_size
3943 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3948 *offset
= addr
.offset
;
3952 dump_ia64_unwind (aux
)
3953 struct unw_aux_info
*aux
;
3956 struct unw_table_entry
*tp
;
3959 addr_size
= is_32bit_elf
? 4 : 8;
3961 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3965 const unsigned char *dp
;
3966 const unsigned char *head
;
3967 const char *procname
;
3969 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3971 fputs ("\n<", stdout
);
3975 fputs (procname
, stdout
);
3978 printf ("+%lx", (unsigned long) offset
);
3981 fputs (">: [", stdout
);
3982 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3983 fputc ('-', stdout
);
3984 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3985 printf ("], info at +0x%lx\n",
3986 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3988 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3989 stamp
= BYTE_GET8 ((unsigned char *) head
);
3991 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
3992 (unsigned) UNW_VER (stamp
),
3993 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3994 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3995 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3996 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3998 if (UNW_VER (stamp
) != 1)
4000 printf ("\tUnknown version.\n");
4005 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4006 dp
= unw_decode (dp
, in_body
, & in_body
);
4011 slurp_ia64_unwind_table (file
, aux
, sec
)
4013 struct unw_aux_info
*aux
;
4014 Elf_Internal_Shdr
*sec
;
4016 unsigned long size
, addr_size
, nrelas
, i
;
4017 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
4018 struct unw_table_entry
*tep
;
4019 Elf_Internal_Shdr
*relsec
;
4020 Elf_Internal_Rela
*rela
, *rp
;
4021 unsigned char *table
, *tp
;
4022 Elf_Internal_Sym
*sym
;
4023 const char *relname
;
4026 addr_size
= is_32bit_elf
? 4 : 8;
4028 /* First, find the starting address of the segment that includes
4031 if (elf_header
.e_phnum
)
4033 prog_hdrs
= (Elf_Internal_Phdr
*)
4034 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
4037 result
= get_32bit_program_headers (file
, prog_hdrs
);
4039 result
= get_64bit_program_headers (file
, prog_hdrs
);
4047 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
4049 if (seg
->p_type
!= PT_LOAD
)
4052 if (sec
->sh_addr
>= seg
->p_vaddr
4053 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4055 aux
->seg_base
= seg
->p_vaddr
;
4063 /* Second, build the unwind table from the contents of the unwind section: */
4064 size
= sec
->sh_size
;
4065 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4066 size
, _("unwind table"));
4070 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4071 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4073 tep
->start
.section
= SHN_UNDEF
;
4074 tep
->end
.section
= SHN_UNDEF
;
4075 tep
->info
.section
= SHN_UNDEF
;
4078 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4079 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4080 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4084 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4085 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4086 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4088 tep
->start
.offset
+= aux
->seg_base
;
4089 tep
->end
.offset
+= aux
->seg_base
;
4090 tep
->info
.offset
+= aux
->seg_base
;
4094 /* Third, apply any relocations to the unwind table: */
4096 for (relsec
= section_headers
;
4097 relsec
< section_headers
+ elf_header
.e_shnum
;
4100 if (relsec
->sh_type
!= SHT_RELA
4101 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4104 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4108 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4112 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4113 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4115 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4117 warn (_("Skipping unexpected symbol type %u\n"),
4118 ELF32_ST_TYPE (sym
->st_info
));
4124 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4125 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4127 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4129 warn (_("Skipping unexpected symbol type %u\n"),
4130 ELF64_ST_TYPE (sym
->st_info
));
4135 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4137 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4141 i
= rp
->r_offset
/ (3 * addr_size
);
4143 switch (rp
->r_offset
/addr_size
% 3)
4146 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4147 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4150 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4151 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4154 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4155 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4165 aux
->table_len
= size
/ (3 * addr_size
);
4170 process_unwind (file
)
4173 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4174 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4175 struct unw_aux_info aux
;
4180 if (elf_header
.e_machine
!= EM_IA_64
)
4182 printf (_("\nThere are no unwind sections in this file.\n"));
4186 memset (& aux
, 0, sizeof (aux
));
4188 addr_size
= is_32bit_elf
? 4 : 8;
4190 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4192 if (sec
->sh_type
== SHT_SYMTAB
)
4194 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4195 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4197 strsec
= SECTION_HEADER (sec
->sh_link
);
4198 aux
.strtab_size
= strsec
->sh_size
;
4199 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
4200 aux
.strtab_size
, _("string table"));
4202 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4207 printf (_("\nThere are no unwind sections in this file.\n"));
4209 while (unwcount
-- > 0)
4214 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4215 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4216 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4223 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4225 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
4228 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4229 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4230 suffix
= SECTION_NAME (unwsec
) + len
;
4231 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4233 if (strncmp (SECTION_NAME (sec
),
4234 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4235 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4240 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4241 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4242 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4243 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4245 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4247 suffix
= SECTION_NAME (unwsec
) + len
;
4248 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4250 if (strncmp (SECTION_NAME (sec
),
4251 ELF_STRING_ia64_unwind_info
, len2
) == 0
4252 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4256 if (i
== elf_header
.e_shnum
)
4258 printf (_("\nCould not find unwind info section for "));
4260 if (string_table
== NULL
)
4261 printf ("%d", unwsec
->sh_name
);
4263 printf (_("'%s'"), SECTION_NAME (unwsec
));
4267 aux
.info_size
= sec
->sh_size
;
4268 aux
.info_addr
= sec
->sh_addr
;
4269 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
4270 aux
.info_size
, _("unwind info"));
4272 printf (_("\nUnwind section "));
4274 if (string_table
== NULL
)
4275 printf ("%d", unwsec
->sh_name
);
4277 printf (_("'%s'"), SECTION_NAME (unwsec
));
4279 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4280 (unsigned long) unwsec
->sh_offset
,
4281 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4283 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4285 if (aux
.table_len
> 0)
4286 dump_ia64_unwind (& aux
);
4289 free ((char *) aux
.table
);
4291 free ((char *) aux
.info
);
4300 free ((char *) aux
.strtab
);
4306 dynamic_segment_mips_val (entry
)
4307 Elf_Internal_Dyn
*entry
;
4309 switch (entry
->d_tag
)
4312 if (entry
->d_un
.d_val
== 0)
4316 static const char * opts
[] =
4318 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4319 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4320 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4321 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4326 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4327 if (entry
->d_un
.d_val
& (1 << cnt
))
4329 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4336 case DT_MIPS_IVERSION
:
4337 if (dynamic_strings
!= NULL
)
4338 printf ("Interface Version: %s\n",
4339 dynamic_strings
+ entry
->d_un
.d_val
);
4341 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4344 case DT_MIPS_TIME_STAMP
:
4349 time_t time
= entry
->d_un
.d_val
;
4350 tmp
= gmtime (&time
);
4351 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4352 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4353 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4354 printf ("Time Stamp: %s\n", timebuf
);
4358 case DT_MIPS_RLD_VERSION
:
4359 case DT_MIPS_LOCAL_GOTNO
:
4360 case DT_MIPS_CONFLICTNO
:
4361 case DT_MIPS_LIBLISTNO
:
4362 case DT_MIPS_SYMTABNO
:
4363 case DT_MIPS_UNREFEXTNO
:
4364 case DT_MIPS_HIPAGENO
:
4365 case DT_MIPS_DELTA_CLASS_NO
:
4366 case DT_MIPS_DELTA_INSTANCE_NO
:
4367 case DT_MIPS_DELTA_RELOC_NO
:
4368 case DT_MIPS_DELTA_SYM_NO
:
4369 case DT_MIPS_DELTA_CLASSSYM_NO
:
4370 case DT_MIPS_COMPACT_SIZE
:
4371 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4375 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4381 dynamic_segment_parisc_val (entry
)
4382 Elf_Internal_Dyn
*entry
;
4384 switch (entry
->d_tag
)
4386 case DT_HP_DLD_FLAGS
:
4395 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4396 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4397 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4398 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4399 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4400 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4401 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4402 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4403 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4404 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4405 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4409 bfd_vma val
= entry
->d_un
.d_val
;
4411 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4412 if (val
& flags
[cnt
].bit
)
4416 fputs (flags
[cnt
].str
, stdout
);
4418 val
^= flags
[cnt
].bit
;
4421 if (val
!= 0 || first
)
4425 print_vma (val
, HEX
);
4431 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4438 get_32bit_dynamic_segment (file
)
4441 Elf32_External_Dyn
*edyn
;
4442 Elf_Internal_Dyn
*entry
;
4445 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4446 dynamic_size
, _("dynamic segment"));
4450 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4451 how large this .dynamic is now. We can do this even before the byte
4452 swapping since the DT_NULL tag is recognizable. */
4454 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4457 dynamic_segment
= (Elf_Internal_Dyn
*)
4458 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4460 if (dynamic_segment
== NULL
)
4462 error (_("Out of memory\n"));
4467 for (i
= 0, entry
= dynamic_segment
;
4471 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4472 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4481 get_64bit_dynamic_segment (file
)
4484 Elf64_External_Dyn
*edyn
;
4485 Elf_Internal_Dyn
*entry
;
4488 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
4489 dynamic_size
, _("dynamic segment"));
4493 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4494 how large this .dynamic is now. We can do this even before the byte
4495 swapping since the DT_NULL tag is recognizable. */
4497 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4500 dynamic_segment
= (Elf_Internal_Dyn
*)
4501 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4503 if (dynamic_segment
== NULL
)
4505 error (_("Out of memory\n"));
4510 for (i
= 0, entry
= dynamic_segment
;
4514 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4515 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4524 get_dynamic_flags (flags
)
4527 static char buff
[128];
4535 flag
= flags
& - flags
;
4543 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4544 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4545 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4546 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4547 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4548 default: strcpy (p
, "unknown"); break;
4551 p
= strchr (p
, '\0');
4556 /* Parse and display the contents of the dynamic segment. */
4558 process_dynamic_segment (file
)
4561 Elf_Internal_Dyn
*entry
;
4564 if (dynamic_size
== 0)
4567 printf (_("\nThere is no dynamic segment in this file.\n"));
4574 if (! get_32bit_dynamic_segment (file
))
4577 else if (! get_64bit_dynamic_segment (file
))
4580 /* Find the appropriate symbol table. */
4581 if (dynamic_symbols
== NULL
)
4583 for (i
= 0, entry
= dynamic_segment
;
4587 Elf_Internal_Shdr section
;
4589 if (entry
->d_tag
!= DT_SYMTAB
)
4592 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4594 /* Since we do not know how big the symbol table is,
4595 we default to reading in the entire file (!) and
4596 processing that. This is overkill, I know, but it
4598 section
.sh_offset
= entry
->d_un
.d_val
- loadaddr
;
4600 if (fseek (file
, 0, SEEK_END
))
4601 error (_("Unable to seek to end of file!"));
4603 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4605 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4607 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4609 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4610 if (num_dynamic_syms
< 1)
4612 error (_("Unable to determine the number of symbols to load\n"));
4616 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4620 /* Similarly find a string table. */
4621 if (dynamic_strings
== NULL
)
4623 for (i
= 0, entry
= dynamic_segment
;
4627 unsigned long offset
;
4630 if (entry
->d_tag
!= DT_STRTAB
)
4633 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4635 /* Since we do not know how big the string table is,
4636 we default to reading in the entire file (!) and
4637 processing that. This is overkill, I know, but it
4640 offset
= entry
->d_un
.d_val
- loadaddr
;
4641 if (fseek (file
, 0, SEEK_END
))
4642 error (_("Unable to seek to end of file\n"));
4643 str_tab_len
= ftell (file
) - offset
;
4645 if (str_tab_len
< 1)
4648 (_("Unable to determine the length of the dynamic string table\n"));
4652 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4653 _("dynamic string table"));
4658 /* And find the syminfo section if available. */
4659 if (dynamic_syminfo
== NULL
)
4661 unsigned long syminsz
= 0;
4663 for (i
= 0, entry
= dynamic_segment
;
4667 if (entry
->d_tag
== DT_SYMINENT
)
4669 /* Note: these braces are necessary to avoid a syntax
4670 error from the SunOS4 C compiler. */
4671 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4673 else if (entry
->d_tag
== DT_SYMINSZ
)
4674 syminsz
= entry
->d_un
.d_val
;
4675 else if (entry
->d_tag
== DT_SYMINFO
)
4676 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4679 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4681 Elf_External_Syminfo
*extsyminfo
;
4682 Elf_Internal_Syminfo
*syminfo
;
4684 /* There is a syminfo section. Read the data. */
4685 extsyminfo
= ((Elf_External_Syminfo
*)
4686 get_data (NULL
, file
, dynamic_syminfo_offset
,
4687 syminsz
, _("symbol information")));
4691 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4692 if (dynamic_syminfo
== NULL
)
4694 error (_("Out of memory\n"));
4698 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4699 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4702 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4703 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4710 if (do_dynamic
&& dynamic_addr
)
4711 printf (_("\nDynamic segment at offset 0x%lx contains %ld entries:\n"),
4712 dynamic_addr
, (long) dynamic_size
);
4714 printf (_(" Tag Type Name/Value\n"));
4716 for (i
= 0, entry
= dynamic_segment
;
4725 print_vma (entry
->d_tag
, FULL_HEX
);
4726 dtype
= get_dynamic_type (entry
->d_tag
);
4727 printf (" (%s)%*s", dtype
,
4728 ((is_32bit_elf
? 27 : 19)
4729 - (int) strlen (dtype
)),
4733 switch (entry
->d_tag
)
4737 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4747 switch (entry
->d_tag
)
4750 printf (_("Auxiliary library"));
4754 printf (_("Filter library"));
4758 printf (_("Configuration file"));
4762 printf (_("Dependency audit library"));
4766 printf (_("Audit library"));
4770 if (dynamic_strings
)
4771 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4775 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4784 printf (_("Flags:"));
4786 if (entry
->d_un
.d_val
== 0)
4787 printf (_(" None\n"));
4790 unsigned long int val
= entry
->d_un
.d_val
;
4792 if (val
& DTF_1_PARINIT
)
4794 printf (" PARINIT");
4795 val
^= DTF_1_PARINIT
;
4797 if (val
& DTF_1_CONFEXP
)
4799 printf (" CONFEXP");
4800 val
^= DTF_1_CONFEXP
;
4803 printf (" %lx", val
);
4812 printf (_("Flags:"));
4814 if (entry
->d_un
.d_val
== 0)
4815 printf (_(" None\n"));
4818 unsigned long int val
= entry
->d_un
.d_val
;
4820 if (val
& DF_P1_LAZYLOAD
)
4822 printf (" LAZYLOAD");
4823 val
^= DF_P1_LAZYLOAD
;
4825 if (val
& DF_P1_GROUPPERM
)
4827 printf (" GROUPPERM");
4828 val
^= DF_P1_GROUPPERM
;
4831 printf (" %lx", val
);
4840 printf (_("Flags:"));
4841 if (entry
->d_un
.d_val
== 0)
4842 printf (_(" None\n"));
4845 unsigned long int val
= entry
->d_un
.d_val
;
4852 if (val
& DF_1_GLOBAL
)
4857 if (val
& DF_1_GROUP
)
4862 if (val
& DF_1_NODELETE
)
4864 printf (" NODELETE");
4865 val
^= DF_1_NODELETE
;
4867 if (val
& DF_1_LOADFLTR
)
4869 printf (" LOADFLTR");
4870 val
^= DF_1_LOADFLTR
;
4872 if (val
& DF_1_INITFIRST
)
4874 printf (" INITFIRST");
4875 val
^= DF_1_INITFIRST
;
4877 if (val
& DF_1_NOOPEN
)
4882 if (val
& DF_1_ORIGIN
)
4887 if (val
& DF_1_DIRECT
)
4892 if (val
& DF_1_TRANS
)
4897 if (val
& DF_1_INTERPOSE
)
4899 printf (" INTERPOSE");
4900 val
^= DF_1_INTERPOSE
;
4902 if (val
& DF_1_NODEFLIB
)
4904 printf (" NODEFLIB");
4905 val
^= DF_1_NODEFLIB
;
4907 if (val
& DF_1_NODUMP
)
4912 if (val
& DF_1_CONLFAT
)
4914 printf (" CONLFAT");
4915 val
^= DF_1_CONLFAT
;
4918 printf (" %lx", val
);
4926 puts (get_dynamic_type (entry
->d_un
.d_val
));
4946 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4952 if (dynamic_strings
== NULL
)
4955 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4959 switch (entry
->d_tag
)
4962 printf (_("Shared library: [%s]"), name
);
4964 if (strcmp (name
, program_interpreter
) == 0)
4965 printf (_(" program interpreter"));
4969 printf (_("Library soname: [%s]"), name
);
4973 printf (_("Library rpath: [%s]"), name
);
4977 printf (_("Library runpath: [%s]"), name
);
4981 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4986 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5002 case DT_INIT_ARRAYSZ
:
5003 case DT_FINI_ARRAYSZ
:
5004 case DT_GNU_CONFLICTSZ
:
5005 case DT_GNU_LIBLISTSZ
:
5008 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5009 printf (" (bytes)\n");
5019 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5032 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
5036 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5040 printf (_("Not needed object: [%s]\n"), name
);
5045 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5051 /* The value of this entry is ignored. */
5056 case DT_GNU_PRELINKED
:
5060 time_t time
= entry
->d_un
.d_val
;
5062 tmp
= gmtime (&time
);
5063 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5064 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5065 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5071 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5072 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5077 switch (elf_header
.e_machine
)
5080 case EM_MIPS_RS3_LE
:
5081 dynamic_segment_mips_val (entry
);
5084 dynamic_segment_parisc_val (entry
);
5087 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5099 get_ver_flags (flags
)
5102 static char buff
[32];
5109 if (flags
& VER_FLG_BASE
)
5110 strcat (buff
, "BASE ");
5112 if (flags
& VER_FLG_WEAK
)
5114 if (flags
& VER_FLG_BASE
)
5115 strcat (buff
, "| ");
5117 strcat (buff
, "WEAK ");
5120 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5121 strcat (buff
, "| <unknown>");
5126 /* Display the contents of the version sections. */
5128 process_version_sections (file
)
5131 Elf_Internal_Shdr
*section
;
5138 for (i
= 0, section
= section_headers
;
5139 i
< elf_header
.e_shnum
;
5142 switch (section
->sh_type
)
5144 case SHT_GNU_verdef
:
5146 Elf_External_Verdef
*edefs
;
5153 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5154 SECTION_NAME (section
), section
->sh_info
);
5156 printf (_(" Addr: 0x"));
5157 printf_vma (section
->sh_addr
);
5158 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5159 (unsigned long) section
->sh_offset
, section
->sh_link
,
5160 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5162 edefs
= ((Elf_External_Verdef
*)
5163 get_data (NULL
, file
, section
->sh_offset
,
5165 _("version definition section")));
5169 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5172 Elf_External_Verdef
*edef
;
5173 Elf_Internal_Verdef ent
;
5174 Elf_External_Verdaux
*eaux
;
5175 Elf_Internal_Verdaux aux
;
5179 vstart
= ((char *) edefs
) + idx
;
5181 edef
= (Elf_External_Verdef
*) vstart
;
5183 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5184 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5185 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5186 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5187 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5188 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5189 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5191 printf (_(" %#06x: Rev: %d Flags: %s"),
5192 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5194 printf (_(" Index: %d Cnt: %d "),
5195 ent
.vd_ndx
, ent
.vd_cnt
);
5197 vstart
+= ent
.vd_aux
;
5199 eaux
= (Elf_External_Verdaux
*) vstart
;
5201 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5202 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5204 if (dynamic_strings
)
5205 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5207 printf (_("Name index: %ld\n"), aux
.vda_name
);
5209 isum
= idx
+ ent
.vd_aux
;
5211 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5213 isum
+= aux
.vda_next
;
5214 vstart
+= aux
.vda_next
;
5216 eaux
= (Elf_External_Verdaux
*) vstart
;
5218 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5219 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5221 if (dynamic_strings
)
5222 printf (_(" %#06x: Parent %d: %s\n"),
5223 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5225 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5226 isum
, j
, aux
.vda_name
);
5236 case SHT_GNU_verneed
:
5238 Elf_External_Verneed
*eneed
;
5244 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5245 SECTION_NAME (section
), section
->sh_info
);
5247 printf (_(" Addr: 0x"));
5248 printf_vma (section
->sh_addr
);
5249 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5250 (unsigned long) section
->sh_offset
, section
->sh_link
,
5251 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5253 eneed
= ((Elf_External_Verneed
*)
5254 get_data (NULL
, file
, section
->sh_offset
,
5255 section
->sh_size
, _("version need section")));
5259 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5261 Elf_External_Verneed
*entry
;
5262 Elf_Internal_Verneed ent
;
5267 vstart
= ((char *) eneed
) + idx
;
5269 entry
= (Elf_External_Verneed
*) vstart
;
5271 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5272 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5273 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5274 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5275 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5277 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5279 if (dynamic_strings
)
5280 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5282 printf (_(" File: %lx"), ent
.vn_file
);
5284 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5286 vstart
+= ent
.vn_aux
;
5288 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5290 Elf_External_Vernaux
*eaux
;
5291 Elf_Internal_Vernaux aux
;
5293 eaux
= (Elf_External_Vernaux
*) vstart
;
5295 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5296 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5297 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5298 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5299 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5301 if (dynamic_strings
)
5302 printf (_(" %#06x: Name: %s"),
5303 isum
, dynamic_strings
+ aux
.vna_name
);
5305 printf (_(" %#06x: Name index: %lx"),
5306 isum
, aux
.vna_name
);
5308 printf (_(" Flags: %s Version: %d\n"),
5309 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5311 isum
+= aux
.vna_next
;
5312 vstart
+= aux
.vna_next
;
5322 case SHT_GNU_versym
:
5324 Elf_Internal_Shdr
*link_section
;
5327 unsigned char *edata
;
5328 unsigned short *data
;
5330 Elf_Internal_Sym
*symbols
;
5331 Elf_Internal_Shdr
*string_sec
;
5333 link_section
= SECTION_HEADER (section
->sh_link
);
5334 total
= section
->sh_size
/ section
->sh_entsize
;
5338 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5340 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5342 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5343 string_sec
->sh_size
,
5344 _("version string table"));
5348 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5349 SECTION_NAME (section
), total
);
5351 printf (_(" Addr: "));
5352 printf_vma (section
->sh_addr
);
5353 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5354 (unsigned long) section
->sh_offset
, section
->sh_link
,
5355 SECTION_NAME (link_section
));
5359 get_data (NULL
, file
,
5360 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
5361 total
* sizeof (short), _("version symbol data")));
5368 data
= (unsigned short *) malloc (total
* sizeof (short));
5370 for (cnt
= total
; cnt
--;)
5371 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5376 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5379 int check_def
, check_need
;
5382 printf (" %03x:", cnt
);
5384 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5385 switch (data
[cnt
+ j
])
5388 fputs (_(" 0 (*local*) "), stdout
);
5392 fputs (_(" 1 (*global*) "), stdout
);
5396 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5397 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5401 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5404 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5411 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5413 Elf_Internal_Verneed ivn
;
5414 unsigned long offset
;
5416 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5421 Elf_Internal_Vernaux ivna
;
5422 Elf_External_Verneed evn
;
5423 Elf_External_Vernaux evna
;
5424 unsigned long a_off
;
5426 get_data (&evn
, file
, offset
, sizeof (evn
),
5429 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5430 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5432 a_off
= offset
+ ivn
.vn_aux
;
5436 get_data (&evna
, file
, a_off
, sizeof (evna
),
5437 _("version need aux (2)"));
5439 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5440 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5442 a_off
+= ivna
.vna_next
;
5444 while (ivna
.vna_other
!= data
[cnt
+ j
]
5445 && ivna
.vna_next
!= 0);
5447 if (ivna
.vna_other
== data
[cnt
+ j
])
5449 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5451 name
= strtab
+ ivna
.vna_name
;
5452 nn
+= printf ("(%s%-*s",
5454 12 - (int) strlen (name
),
5460 offset
+= ivn
.vn_next
;
5462 while (ivn
.vn_next
);
5465 if (check_def
&& data
[cnt
+ j
] != 0x8001
5466 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5468 Elf_Internal_Verdef ivd
;
5469 Elf_External_Verdef evd
;
5470 unsigned long offset
;
5472 offset
= (version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5477 get_data (&evd
, file
, offset
, sizeof (evd
),
5480 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5481 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5483 offset
+= ivd
.vd_next
;
5485 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5486 && ivd
.vd_next
!= 0);
5488 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5490 Elf_External_Verdaux evda
;
5491 Elf_Internal_Verdaux ivda
;
5493 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5495 get_data (&evda
, file
,
5496 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5497 sizeof (evda
), _("version def aux"));
5499 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5501 name
= strtab
+ ivda
.vda_name
;
5502 nn
+= printf ("(%s%-*s",
5504 12 - (int) strlen (name
),
5510 printf ("%*c", 18 - nn
, ' ');
5528 printf (_("\nNo version information found in this file.\n"));
5534 get_symbol_binding (binding
)
5535 unsigned int binding
;
5537 static char buff
[32];
5541 case STB_LOCAL
: return "LOCAL";
5542 case STB_GLOBAL
: return "GLOBAL";
5543 case STB_WEAK
: return "WEAK";
5545 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5546 sprintf (buff
, _("<processor specific>: %d"), binding
);
5547 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5548 sprintf (buff
, _("<OS specific>: %d"), binding
);
5550 sprintf (buff
, _("<unknown>: %d"), binding
);
5556 get_symbol_type (type
)
5559 static char buff
[32];
5563 case STT_NOTYPE
: return "NOTYPE";
5564 case STT_OBJECT
: return "OBJECT";
5565 case STT_FUNC
: return "FUNC";
5566 case STT_SECTION
: return "SECTION";
5567 case STT_FILE
: return "FILE";
5568 case STT_COMMON
: return "COMMON";
5569 case STT_TLS
: return "TLS";
5571 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5573 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5574 return "THUMB_FUNC";
5576 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5579 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5580 return "PARISC_MILLI";
5582 sprintf (buff
, _("<processor specific>: %d"), type
);
5584 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5586 if (elf_header
.e_machine
== EM_PARISC
)
5588 if (type
== STT_HP_OPAQUE
)
5590 if (type
== STT_HP_STUB
)
5594 sprintf (buff
, _("<OS specific>: %d"), type
);
5597 sprintf (buff
, _("<unknown>: %d"), type
);
5603 get_symbol_visibility (visibility
)
5604 unsigned int visibility
;
5608 case STV_DEFAULT
: return "DEFAULT";
5609 case STV_INTERNAL
: return "INTERNAL";
5610 case STV_HIDDEN
: return "HIDDEN";
5611 case STV_PROTECTED
: return "PROTECTED";
5617 get_symbol_index_type (type
)
5620 static char buff
[32];
5624 case SHN_UNDEF
: return "UND";
5625 case SHN_ABS
: return "ABS";
5626 case SHN_COMMON
: return "COM";
5628 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5629 sprintf (buff
, "PRC[0x%04x]", type
);
5630 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5631 sprintf (buff
, "OS [0x%04x]", type
);
5632 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5633 sprintf (buff
, "RSV[0x%04x]", type
);
5635 sprintf (buff
, "%3d", type
);
5643 get_dynamic_data (file
, number
)
5645 unsigned int number
;
5647 unsigned char *e_data
;
5650 e_data
= (unsigned char *) malloc (number
* 4);
5654 error (_("Out of memory\n"));
5658 if (fread (e_data
, 4, number
, file
) != number
)
5660 error (_("Unable to read in dynamic data\n"));
5664 i_data
= (int *) malloc (number
* sizeof (*i_data
));
5668 error (_("Out of memory\n"));
5674 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5681 /* Dump the symbol table. */
5683 process_symbol_table (file
)
5686 Elf_Internal_Shdr
*section
;
5687 unsigned char nb
[4];
5688 unsigned char nc
[4];
5691 int *buckets
= NULL
;
5694 if (! do_syms
&& !do_histogram
)
5697 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5700 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5702 error (_("Unable to seek to start of dynamic information"));
5706 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5708 error (_("Failed to read in number of buckets\n"));
5712 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5714 error (_("Failed to read in number of chains\n"));
5718 nbuckets
= byte_get (nb
, 4);
5719 nchains
= byte_get (nc
, 4);
5721 buckets
= get_dynamic_data (file
, nbuckets
);
5722 chains
= get_dynamic_data (file
, nchains
);
5724 if (buckets
== NULL
|| chains
== NULL
)
5729 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5734 printf (_("\nSymbol table for image:\n"));
5736 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5738 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5740 for (hn
= 0; hn
< nbuckets
; hn
++)
5745 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5747 Elf_Internal_Sym
*psym
;
5749 psym
= dynamic_symbols
+ si
;
5751 printf (" %3d %3d: ", si
, hn
);
5752 print_vma (psym
->st_value
, LONG_HEX
);
5754 print_vma (psym
->st_size
, DEC_5
);
5756 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5757 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5758 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5759 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5760 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5765 else if (do_syms
&& !do_using_dynamic
)
5769 for (i
= 0, section
= section_headers
;
5770 i
< elf_header
.e_shnum
;
5775 Elf_Internal_Sym
*symtab
;
5776 Elf_Internal_Sym
*psym
;
5779 if ( section
->sh_type
!= SHT_SYMTAB
5780 && section
->sh_type
!= SHT_DYNSYM
)
5783 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5784 SECTION_NAME (section
),
5785 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5787 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5789 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5791 symtab
= GET_ELF_SYMBOLS (file
, section
);
5795 if (section
->sh_link
== elf_header
.e_shstrndx
)
5796 strtab
= string_table
;
5799 Elf_Internal_Shdr
*string_sec
;
5801 string_sec
= SECTION_HEADER (section
->sh_link
);
5803 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5804 string_sec
->sh_size
,
5808 for (si
= 0, psym
= symtab
;
5809 si
< section
->sh_size
/ section
->sh_entsize
;
5812 printf ("%6d: ", si
);
5813 print_vma (psym
->st_value
, LONG_HEX
);
5815 print_vma (psym
->st_size
, DEC_5
);
5816 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5817 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5818 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5819 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5820 print_symbol (25, strtab
+ psym
->st_name
);
5822 if (section
->sh_type
== SHT_DYNSYM
&&
5823 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5825 unsigned char data
[2];
5826 unsigned short vers_data
;
5827 unsigned long offset
;
5831 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5834 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5835 sizeof (data
), _("version data"));
5837 vers_data
= byte_get (data
, 2);
5839 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5842 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5844 if ((vers_data
& 0x8000) || vers_data
> 1)
5846 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5847 && (is_nobits
|| ! check_def
))
5849 Elf_External_Verneed evn
;
5850 Elf_Internal_Verneed ivn
;
5851 Elf_Internal_Vernaux ivna
;
5853 /* We must test both. */
5854 offset
= (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5859 unsigned long vna_off
;
5861 get_data (&evn
, file
, offset
, sizeof (evn
),
5864 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5865 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5867 vna_off
= offset
+ ivn
.vn_aux
;
5871 Elf_External_Vernaux evna
;
5873 get_data (&evna
, file
, vna_off
,
5875 _("version need aux (3)"));
5877 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5878 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5879 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5881 vna_off
+= ivna
.vna_next
;
5883 while (ivna
.vna_other
!= vers_data
5884 && ivna
.vna_next
!= 0);
5886 if (ivna
.vna_other
== vers_data
)
5889 offset
+= ivn
.vn_next
;
5891 while (ivn
.vn_next
!= 0);
5893 if (ivna
.vna_other
== vers_data
)
5896 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5899 else if (! is_nobits
)
5900 error (_("bad dynamic symbol"));
5907 if (vers_data
!= 0x8001
5908 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5910 Elf_Internal_Verdef ivd
;
5911 Elf_Internal_Verdaux ivda
;
5912 Elf_External_Verdaux evda
;
5913 unsigned long offset
;
5916 = (version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5921 Elf_External_Verdef evd
;
5923 get_data (&evd
, file
, offset
, sizeof (evd
),
5926 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5927 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5928 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5930 offset
+= ivd
.vd_next
;
5932 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5933 && ivd
.vd_next
!= 0);
5935 offset
-= ivd
.vd_next
;
5936 offset
+= ivd
.vd_aux
;
5938 get_data (&evda
, file
, offset
, sizeof (evda
),
5939 _("version def aux"));
5941 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5943 if (psym
->st_name
!= ivda
.vda_name
)
5944 printf ((vers_data
& 0x8000)
5946 strtab
+ ivda
.vda_name
);
5956 if (strtab
!= string_table
)
5962 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5964 if (do_histogram
&& buckets
!= NULL
)
5971 int nzero_counts
= 0;
5974 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5976 printf (_(" Length Number %% of total Coverage\n"));
5978 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5979 if (lengths
== NULL
)
5981 error (_("Out of memory"));
5984 for (hn
= 0; hn
< nbuckets
; ++hn
)
5989 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5992 if (maxlength
< ++lengths
[hn
])
5997 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
6000 error (_("Out of memory"));
6004 for (hn
= 0; hn
< nbuckets
; ++hn
)
6005 ++counts
[lengths
[hn
]];
6009 printf (" 0 %-10d (%5.1f%%)\n",
6010 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6011 for (si
= 1; si
<= maxlength
; ++si
)
6013 nzero_counts
+= counts
[si
] * si
;
6014 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6015 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6016 (nzero_counts
* 100.0) / nsyms
);
6024 if (buckets
!= NULL
)
6034 process_syminfo (file
)
6035 FILE *file ATTRIBUTE_UNUSED
;
6039 if (dynamic_syminfo
== NULL
6041 /* No syminfo, this is ok. */
6044 /* There better should be a dynamic symbol section. */
6045 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6049 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6050 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6052 printf (_(" Num: Name BoundTo Flags\n"));
6053 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6055 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6057 printf ("%4d: ", i
);
6058 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
6061 switch (dynamic_syminfo
[i
].si_boundto
)
6063 case SYMINFO_BT_SELF
:
6064 fputs ("SELF ", stdout
);
6066 case SYMINFO_BT_PARENT
:
6067 fputs ("PARENT ", stdout
);
6070 if (dynamic_syminfo
[i
].si_boundto
> 0
6071 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
6076 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6080 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6084 if (flags
& SYMINFO_FLG_DIRECT
)
6086 if (flags
& SYMINFO_FLG_PASSTHRU
)
6087 printf (" PASSTHRU");
6088 if (flags
& SYMINFO_FLG_COPY
)
6090 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6091 printf (" LAZYLOAD");
6099 #ifdef SUPPORT_DISASSEMBLY
6101 disassemble_section (section
, file
)
6102 Elf_Internal_Shdr
*section
;
6105 printf (_("\nAssembly dump of section %s\n"),
6106 SECTION_NAME (section
));
6108 /* XXX -- to be done --- XXX */
6115 dump_section (section
, file
)
6116 Elf_Internal_Shdr
*section
;
6119 bfd_size_type bytes
;
6121 unsigned char *data
;
6122 unsigned char *start
;
6124 bytes
= section
->sh_size
;
6128 printf (_("\nSection '%s' has no data to dump.\n"),
6129 SECTION_NAME (section
));
6133 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6135 addr
= section
->sh_addr
;
6137 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
6150 lbytes
= (bytes
> 16 ? 16 : bytes
);
6152 printf (" 0x%8.8lx ", (unsigned long) addr
);
6154 switch (elf_header
.e_ident
[EI_DATA
])
6158 for (j
= 15; j
>= 0; j
--)
6161 printf ("%2.2x", data
[j
]);
6171 for (j
= 0; j
< 16; j
++)
6174 printf ("%2.2x", data
[j
]);
6184 for (j
= 0; j
< lbytes
; j
++)
6187 if (k
>= ' ' && k
< 0x80)
6206 static unsigned long int
6207 read_leb128 (data
, length_return
, sign
)
6208 unsigned char *data
;
6212 unsigned long int result
= 0;
6213 unsigned int num_read
= 0;
6222 result
|= (byte
& 0x7f) << shift
;
6227 while (byte
& 0x80);
6229 if (length_return
!= NULL
)
6230 *length_return
= num_read
;
6232 if (sign
&& (shift
< 32) && (byte
& 0x40))
6233 result
|= -1 << shift
;
6238 typedef struct State_Machine_Registers
6240 unsigned long address
;
6243 unsigned int column
;
6247 /* This variable hold the number of the last entry seen
6248 in the File Table. */
6249 unsigned int last_file_entry
;
6252 static SMR state_machine_regs
;
6255 reset_state_machine (is_stmt
)
6258 state_machine_regs
.address
= 0;
6259 state_machine_regs
.file
= 1;
6260 state_machine_regs
.line
= 1;
6261 state_machine_regs
.column
= 0;
6262 state_machine_regs
.is_stmt
= is_stmt
;
6263 state_machine_regs
.basic_block
= 0;
6264 state_machine_regs
.end_sequence
= 0;
6265 state_machine_regs
.last_file_entry
= 0;
6268 /* Handled an extend line op. Returns true if this is the end
6271 process_extended_line_op (data
, is_stmt
, pointer_size
)
6272 unsigned char *data
;
6276 unsigned char op_code
;
6279 unsigned char *name
;
6282 len
= read_leb128 (data
, & bytes_read
, 0);
6287 warn (_("badly formed extended line op encountered!\n"));
6294 printf (_(" Extended opcode %d: "), op_code
);
6298 case DW_LNE_end_sequence
:
6299 printf (_("End of Sequence\n\n"));
6300 reset_state_machine (is_stmt
);
6303 case DW_LNE_set_address
:
6304 adr
= byte_get (data
, pointer_size
);
6305 printf (_("set Address to 0x%lx\n"), adr
);
6306 state_machine_regs
.address
= adr
;
6309 case DW_LNE_define_file
:
6310 printf (_(" define new File Table entry\n"));
6311 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6313 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6315 data
+= strlen ((char *) data
) + 1;
6316 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6318 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6320 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6321 printf (_("%s\n\n"), name
);
6325 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6332 /* Size of pointers in the .debug_line section. This information is not
6333 really present in that section. It's obtained before dumping the debug
6334 sections by doing some pre-scan of the .debug_info section. */
6335 static int debug_line_pointer_size
= 4;
6338 display_debug_lines (section
, start
, file
)
6339 Elf_Internal_Shdr
*section
;
6340 unsigned char * start
;
6341 FILE *file ATTRIBUTE_UNUSED
;
6343 DWARF2_External_LineInfo
*external
;
6344 DWARF2_Internal_LineInfo info
;
6345 unsigned char *standard_opcodes
;
6346 unsigned char *data
= start
;
6347 unsigned char *end
= start
+ section
->sh_size
;
6348 unsigned char *end_of_sequence
;
6351 printf (_("\nDump of debug contents of section %s:\n\n"),
6352 SECTION_NAME (section
));
6356 external
= (DWARF2_External_LineInfo
*) data
;
6358 /* Check the length of the block. */
6359 info
.li_length
= BYTE_GET (external
->li_length
);
6361 if (info
.li_length
== 0xffffffff)
6363 warn (_("64-bit DWARF line info is not supported yet.\n"));
6367 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
6370 (_("The line info appears to be corrupt - the section is too small\n"));
6374 /* Check its version number. */
6375 info
.li_version
= BYTE_GET (external
->li_version
);
6376 if (info
.li_version
!= 2)
6378 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6382 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
6383 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
6384 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
6385 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
6386 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
6387 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
6389 /* Sign extend the line base field. */
6390 info
.li_line_base
<<= 24;
6391 info
.li_line_base
>>= 24;
6393 printf (_(" Length: %ld\n"), info
.li_length
);
6394 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6395 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6396 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6397 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6398 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6399 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6400 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6402 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
6404 reset_state_machine (info
.li_default_is_stmt
);
6406 /* Display the contents of the Opcodes table. */
6407 standard_opcodes
= data
+ sizeof (*external
);
6409 printf (_("\n Opcodes:\n"));
6411 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6412 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6414 /* Display the contents of the Directory table. */
6415 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6418 printf (_("\n The Directory Table is empty.\n"));
6421 printf (_("\n The Directory Table:\n"));
6425 printf (_(" %s\n"), data
);
6427 data
+= strlen ((char *) data
) + 1;
6431 /* Skip the NUL at the end of the table. */
6434 /* Display the contents of the File Name table. */
6436 printf (_("\n The File Name Table is empty.\n"));
6439 printf (_("\n The File Name Table:\n"));
6440 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6444 unsigned char *name
;
6447 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6450 data
+= strlen ((char *) data
) + 1;
6452 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6454 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6456 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6458 printf (_("%s\n"), name
);
6462 /* Skip the NUL at the end of the table. */
6465 /* Now display the statements. */
6466 printf (_("\n Line Number Statements:\n"));
6469 while (data
< end_of_sequence
)
6471 unsigned char op_code
;
6477 if (op_code
>= info
.li_opcode_base
)
6479 op_code
-= info
.li_opcode_base
;
6480 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6481 state_machine_regs
.address
+= adv
;
6482 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6483 op_code
, adv
, state_machine_regs
.address
);
6484 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6485 state_machine_regs
.line
+= adv
;
6486 printf (_(" and Line by %d to %d\n"),
6487 adv
, state_machine_regs
.line
);
6489 else switch (op_code
)
6491 case DW_LNS_extended_op
:
6492 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6493 debug_line_pointer_size
);
6497 printf (_(" Copy\n"));
6500 case DW_LNS_advance_pc
:
6501 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6503 state_machine_regs
.address
+= adv
;
6504 printf (_(" Advance PC by %d to %lx\n"), adv
,
6505 state_machine_regs
.address
);
6508 case DW_LNS_advance_line
:
6509 adv
= read_leb128 (data
, & bytes_read
, 1);
6511 state_machine_regs
.line
+= adv
;
6512 printf (_(" Advance Line by %d to %d\n"), adv
,
6513 state_machine_regs
.line
);
6516 case DW_LNS_set_file
:
6517 adv
= read_leb128 (data
, & bytes_read
, 0);
6519 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6521 state_machine_regs
.file
= adv
;
6524 case DW_LNS_set_column
:
6525 adv
= read_leb128 (data
, & bytes_read
, 0);
6527 printf (_(" Set column to %d\n"), adv
);
6528 state_machine_regs
.column
= adv
;
6531 case DW_LNS_negate_stmt
:
6532 adv
= state_machine_regs
.is_stmt
;
6534 printf (_(" Set is_stmt to %d\n"), adv
);
6535 state_machine_regs
.is_stmt
= adv
;
6538 case DW_LNS_set_basic_block
:
6539 printf (_(" Set basic block\n"));
6540 state_machine_regs
.basic_block
= 1;
6543 case DW_LNS_const_add_pc
:
6544 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6545 * info
.li_min_insn_length
);
6546 state_machine_regs
.address
+= adv
;
6547 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6548 state_machine_regs
.address
);
6551 case DW_LNS_fixed_advance_pc
:
6552 adv
= byte_get (data
, 2);
6554 state_machine_regs
.address
+= adv
;
6555 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6556 adv
, state_machine_regs
.address
);
6559 case DW_LNS_set_prologue_end
:
6560 printf (_(" Set prologue_end to true\n"));
6563 case DW_LNS_set_epilogue_begin
:
6564 printf (_(" Set epilogue_begin to true\n"));
6567 case DW_LNS_set_isa
:
6568 adv
= read_leb128 (data
, & bytes_read
, 0);
6570 printf (_(" Set ISA to %d\n"), adv
);
6574 printf (_(" Unknown opcode %d with operands: "), op_code
);
6577 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6579 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6580 i
== 1 ? "" : ", ");
6595 display_debug_pubnames (section
, start
, file
)
6596 Elf_Internal_Shdr
*section
;
6597 unsigned char *start
;
6598 FILE *file ATTRIBUTE_UNUSED
;
6600 DWARF2_External_PubNames
*external
;
6601 DWARF2_Internal_PubNames pubnames
;
6604 end
= start
+ section
->sh_size
;
6606 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6610 unsigned char *data
;
6611 unsigned long offset
;
6613 external
= (DWARF2_External_PubNames
*) start
;
6615 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6616 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6617 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6618 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6620 data
= start
+ sizeof (*external
);
6621 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6623 if (pubnames
.pn_length
== 0xffffffff)
6625 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6629 if (pubnames
.pn_version
!= 2)
6631 static int warned
= 0;
6635 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6642 printf (_(" Length: %ld\n"),
6643 pubnames
.pn_length
);
6644 printf (_(" Version: %d\n"),
6645 pubnames
.pn_version
);
6646 printf (_(" Offset into .debug_info section: %ld\n"),
6647 pubnames
.pn_offset
);
6648 printf (_(" Size of area in .debug_info section: %ld\n"),
6651 printf (_("\n Offset\tName\n"));
6655 offset
= byte_get (data
, 4);
6660 printf (" %ld\t\t%s\n", offset
, data
);
6661 data
+= strlen ((char *) data
) + 1;
6664 while (offset
!= 0);
6677 case DW_TAG_padding
: return "DW_TAG_padding";
6678 case DW_TAG_array_type
: return "DW_TAG_array_type";
6679 case DW_TAG_class_type
: return "DW_TAG_class_type";
6680 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6681 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6682 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6683 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6684 case DW_TAG_label
: return "DW_TAG_label";
6685 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6686 case DW_TAG_member
: return "DW_TAG_member";
6687 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6688 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6689 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6690 case DW_TAG_string_type
: return "DW_TAG_string_type";
6691 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6692 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6693 case DW_TAG_typedef
: return "DW_TAG_typedef";
6694 case DW_TAG_union_type
: return "DW_TAG_union_type";
6695 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6696 case DW_TAG_variant
: return "DW_TAG_variant";
6697 case DW_TAG_common_block
: return "DW_TAG_common_block";
6698 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6699 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6700 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6701 case DW_TAG_module
: return "DW_TAG_module";
6702 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6703 case DW_TAG_set_type
: return "DW_TAG_set_type";
6704 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6705 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6706 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6707 case DW_TAG_base_type
: return "DW_TAG_base_type";
6708 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6709 case DW_TAG_const_type
: return "DW_TAG_const_type";
6710 case DW_TAG_constant
: return "DW_TAG_constant";
6711 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6712 case DW_TAG_file_type
: return "DW_TAG_file_type";
6713 case DW_TAG_friend
: return "DW_TAG_friend";
6714 case DW_TAG_namelist
: return "DW_TAG_namelist";
6715 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6716 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6717 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6718 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6719 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6720 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6721 case DW_TAG_try_block
: return "DW_TAG_try_block";
6722 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6723 case DW_TAG_variable
: return "DW_TAG_variable";
6724 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6725 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6726 case DW_TAG_format_label
: return "DW_TAG_format_label";
6727 case DW_TAG_function_template
: return "DW_TAG_function_template";
6728 case DW_TAG_class_template
: return "DW_TAG_class_template";
6729 /* DWARF 2.1 values. */
6730 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6731 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6732 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6733 case DW_TAG_namespace
: return "DW_TAG_namespace";
6734 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6735 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6736 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6737 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6739 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
6740 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
6741 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
6744 static char buffer
[100];
6746 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6753 get_AT_name (attribute
)
6754 unsigned long attribute
;
6758 case DW_AT_sibling
: return "DW_AT_sibling";
6759 case DW_AT_location
: return "DW_AT_location";
6760 case DW_AT_name
: return "DW_AT_name";
6761 case DW_AT_ordering
: return "DW_AT_ordering";
6762 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6763 case DW_AT_byte_size
: return "DW_AT_byte_size";
6764 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6765 case DW_AT_bit_size
: return "DW_AT_bit_size";
6766 case DW_AT_element_list
: return "DW_AT_element_list";
6767 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6768 case DW_AT_low_pc
: return "DW_AT_low_pc";
6769 case DW_AT_high_pc
: return "DW_AT_high_pc";
6770 case DW_AT_language
: return "DW_AT_language";
6771 case DW_AT_member
: return "DW_AT_member";
6772 case DW_AT_discr
: return "DW_AT_discr";
6773 case DW_AT_discr_value
: return "DW_AT_discr_value";
6774 case DW_AT_visibility
: return "DW_AT_visibility";
6775 case DW_AT_import
: return "DW_AT_import";
6776 case DW_AT_string_length
: return "DW_AT_string_length";
6777 case DW_AT_common_reference
: return "DW_AT_common_reference";
6778 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6779 case DW_AT_const_value
: return "DW_AT_const_value";
6780 case DW_AT_containing_type
: return "DW_AT_containing_type";
6781 case DW_AT_default_value
: return "DW_AT_default_value";
6782 case DW_AT_inline
: return "DW_AT_inline";
6783 case DW_AT_is_optional
: return "DW_AT_is_optional";
6784 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6785 case DW_AT_producer
: return "DW_AT_producer";
6786 case DW_AT_prototyped
: return "DW_AT_prototyped";
6787 case DW_AT_return_addr
: return "DW_AT_return_addr";
6788 case DW_AT_start_scope
: return "DW_AT_start_scope";
6789 case DW_AT_stride_size
: return "DW_AT_stride_size";
6790 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6791 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6792 case DW_AT_accessibility
: return "DW_AT_accessibility";
6793 case DW_AT_address_class
: return "DW_AT_address_class";
6794 case DW_AT_artificial
: return "DW_AT_artificial";
6795 case DW_AT_base_types
: return "DW_AT_base_types";
6796 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6797 case DW_AT_count
: return "DW_AT_count";
6798 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6799 case DW_AT_decl_column
: return "DW_AT_decl_column";
6800 case DW_AT_decl_file
: return "DW_AT_decl_file";
6801 case DW_AT_decl_line
: return "DW_AT_decl_line";
6802 case DW_AT_declaration
: return "DW_AT_declaration";
6803 case DW_AT_discr_list
: return "DW_AT_discr_list";
6804 case DW_AT_encoding
: return "DW_AT_encoding";
6805 case DW_AT_external
: return "DW_AT_external";
6806 case DW_AT_frame_base
: return "DW_AT_frame_base";
6807 case DW_AT_friend
: return "DW_AT_friend";
6808 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6809 case DW_AT_macro_info
: return "DW_AT_macro_info";
6810 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6811 case DW_AT_priority
: return "DW_AT_priority";
6812 case DW_AT_segment
: return "DW_AT_segment";
6813 case DW_AT_specification
: return "DW_AT_specification";
6814 case DW_AT_static_link
: return "DW_AT_static_link";
6815 case DW_AT_type
: return "DW_AT_type";
6816 case DW_AT_use_location
: return "DW_AT_use_location";
6817 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6818 case DW_AT_virtuality
: return "DW_AT_virtuality";
6819 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6820 /* DWARF 2.1 values. */
6821 case DW_AT_allocated
: return "DW_AT_allocated";
6822 case DW_AT_associated
: return "DW_AT_associated";
6823 case DW_AT_data_location
: return "DW_AT_data_location";
6824 case DW_AT_stride
: return "DW_AT_stride";
6825 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6826 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6827 case DW_AT_extension
: return "DW_AT_extension";
6828 case DW_AT_ranges
: return "DW_AT_ranges";
6829 case DW_AT_trampoline
: return "DW_AT_trampoline";
6830 case DW_AT_call_column
: return "DW_AT_call_column";
6831 case DW_AT_call_file
: return "DW_AT_call_file";
6832 case DW_AT_call_line
: return "DW_AT_call_line";
6833 /* SGI/MIPS extensions. */
6834 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6835 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6836 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6837 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6838 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6839 case DW_AT_MIPS_software_pipeline_depth
:
6840 return "DW_AT_MIPS_software_pipeline_depth";
6841 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6842 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6843 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6844 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6845 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6846 /* GNU extensions. */
6847 case DW_AT_sf_names
: return "DW_AT_sf_names";
6848 case DW_AT_src_info
: return "DW_AT_src_info";
6849 case DW_AT_mac_info
: return "DW_AT_mac_info";
6850 case DW_AT_src_coords
: return "DW_AT_src_coords";
6851 case DW_AT_body_begin
: return "DW_AT_body_begin";
6852 case DW_AT_body_end
: return "DW_AT_body_end";
6853 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6854 /* UPC extension. */
6855 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
6858 static char buffer
[100];
6860 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6867 get_FORM_name (form
)
6872 case DW_FORM_addr
: return "DW_FORM_addr";
6873 case DW_FORM_block2
: return "DW_FORM_block2";
6874 case DW_FORM_block4
: return "DW_FORM_block4";
6875 case DW_FORM_data2
: return "DW_FORM_data2";
6876 case DW_FORM_data4
: return "DW_FORM_data4";
6877 case DW_FORM_data8
: return "DW_FORM_data8";
6878 case DW_FORM_string
: return "DW_FORM_string";
6879 case DW_FORM_block
: return "DW_FORM_block";
6880 case DW_FORM_block1
: return "DW_FORM_block1";
6881 case DW_FORM_data1
: return "DW_FORM_data1";
6882 case DW_FORM_flag
: return "DW_FORM_flag";
6883 case DW_FORM_sdata
: return "DW_FORM_sdata";
6884 case DW_FORM_strp
: return "DW_FORM_strp";
6885 case DW_FORM_udata
: return "DW_FORM_udata";
6886 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6887 case DW_FORM_ref1
: return "DW_FORM_ref1";
6888 case DW_FORM_ref2
: return "DW_FORM_ref2";
6889 case DW_FORM_ref4
: return "DW_FORM_ref4";
6890 case DW_FORM_ref8
: return "DW_FORM_ref8";
6891 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6892 case DW_FORM_indirect
: return "DW_FORM_indirect";
6895 static char buffer
[100];
6897 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6903 /* FIXME: There are better and more effiecint ways to handle
6904 these structures. For now though, I just want something that
6905 is simple to implement. */
6906 typedef struct abbrev_attr
6908 unsigned long attribute
;
6910 struct abbrev_attr
*next
;
6914 typedef struct abbrev_entry
6916 unsigned long entry
;
6919 struct abbrev_attr
*first_attr
;
6920 struct abbrev_attr
*last_attr
;
6921 struct abbrev_entry
*next
;
6925 static abbrev_entry
*first_abbrev
= NULL
;
6926 static abbrev_entry
*last_abbrev
= NULL
;
6931 abbrev_entry
*abbrev
;
6933 for (abbrev
= first_abbrev
; abbrev
;)
6935 abbrev_entry
*next
= abbrev
->next
;
6938 for (attr
= abbrev
->first_attr
; attr
;)
6940 abbrev_attr
*next
= attr
->next
;
6950 last_abbrev
= first_abbrev
= NULL
;
6954 add_abbrev (number
, tag
, children
)
6955 unsigned long number
;
6959 abbrev_entry
*entry
;
6961 entry
= (abbrev_entry
*) malloc (sizeof (*entry
));
6967 entry
->entry
= number
;
6969 entry
->children
= children
;
6970 entry
->first_attr
= NULL
;
6971 entry
->last_attr
= NULL
;
6974 if (first_abbrev
== NULL
)
6975 first_abbrev
= entry
;
6977 last_abbrev
->next
= entry
;
6979 last_abbrev
= entry
;
6983 add_abbrev_attr (attribute
, form
)
6984 unsigned long attribute
;
6989 attr
= (abbrev_attr
*) malloc (sizeof (*attr
));
6995 attr
->attribute
= attribute
;
6999 if (last_abbrev
->first_attr
== NULL
)
7000 last_abbrev
->first_attr
= attr
;
7002 last_abbrev
->last_attr
->next
= attr
;
7004 last_abbrev
->last_attr
= attr
;
7007 /* Processes the (partial) contents of a .debug_abbrev section.
7008 Returns NULL if the end of the section was encountered.
7009 Returns the address after the last byte read if the end of
7010 an abbreviation set was found. */
7012 static unsigned char *
7013 process_abbrev_section (start
, end
)
7014 unsigned char *start
;
7017 if (first_abbrev
!= NULL
)
7023 unsigned long entry
;
7025 unsigned long attribute
;
7028 entry
= read_leb128 (start
, & bytes_read
, 0);
7029 start
+= bytes_read
;
7031 /* A single zero is supposed to end the section according
7032 to the standard. If there's more, then signal that to
7035 return start
== end
? NULL
: start
;
7037 tag
= read_leb128 (start
, & bytes_read
, 0);
7038 start
+= bytes_read
;
7040 children
= *start
++;
7042 add_abbrev (entry
, tag
, children
);
7048 attribute
= read_leb128 (start
, & bytes_read
, 0);
7049 start
+= bytes_read
;
7051 form
= read_leb128 (start
, & bytes_read
, 0);
7052 start
+= bytes_read
;
7055 add_abbrev_attr (attribute
, form
);
7057 while (attribute
!= 0);
7065 display_debug_macinfo (section
, start
, file
)
7066 Elf_Internal_Shdr
*section
;
7067 unsigned char *start
;
7068 FILE *file ATTRIBUTE_UNUSED
;
7070 unsigned char *end
= start
+ section
->sh_size
;
7071 unsigned char *curr
= start
;
7072 unsigned int bytes_read
;
7073 enum dwarf_macinfo_record_type op
;
7075 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7079 unsigned int lineno
;
7087 case DW_MACINFO_start_file
:
7089 unsigned int filenum
;
7091 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7093 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7096 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7100 case DW_MACINFO_end_file
:
7101 printf (_(" DW_MACINFO_end_file\n"));
7104 case DW_MACINFO_define
:
7105 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7108 curr
+= strlen (string
) + 1;
7109 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7112 case DW_MACINFO_undef
:
7113 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7116 curr
+= strlen (string
) + 1;
7117 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7120 case DW_MACINFO_vendor_ext
:
7122 unsigned int constant
;
7124 constant
= read_leb128 (curr
, & bytes_read
, 0);
7127 curr
+= strlen (string
) + 1;
7128 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7139 display_debug_abbrev (section
, start
, file
)
7140 Elf_Internal_Shdr
*section
;
7141 unsigned char *start
;
7142 FILE *file ATTRIBUTE_UNUSED
;
7144 abbrev_entry
*entry
;
7145 unsigned char *end
= start
+ section
->sh_size
;
7147 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7151 start
= process_abbrev_section (start
, end
);
7153 if (first_abbrev
== NULL
)
7156 printf (_(" Number TAG\n"));
7158 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7162 printf (_(" %ld %s [%s]\n"),
7164 get_TAG_name (entry
->tag
),
7165 entry
->children
? _("has children") : _("no children"));
7167 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7169 printf (_(" %-18s %s\n"),
7170 get_AT_name (attr
->attribute
),
7171 get_FORM_name (attr
->form
));
7185 static unsigned char *
7186 display_block (data
, length
)
7187 unsigned char *data
;
7188 unsigned long length
;
7190 printf (_(" %lu byte block: "), length
);
7193 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7199 decode_location_expression (data
, pointer_size
, length
)
7200 unsigned char * data
;
7201 unsigned int pointer_size
;
7202 unsigned long length
;
7206 unsigned long uvalue
;
7207 unsigned char *end
= data
+ length
;
7216 printf ("DW_OP_addr: %lx",
7217 (unsigned long) byte_get (data
, pointer_size
));
7218 data
+= pointer_size
;
7221 printf ("DW_OP_deref");
7224 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7227 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7230 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7234 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7238 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7242 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7246 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7247 (unsigned long) byte_get (data
+ 4, 4));
7251 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7252 (long) byte_get (data
+ 4, 4));
7256 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7260 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7264 printf ("DW_OP_dup");
7267 printf ("DW_OP_drop");
7270 printf ("DW_OP_over");
7273 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7276 printf ("DW_OP_swap");
7279 printf ("DW_OP_rot");
7282 printf ("DW_OP_xderef");
7285 printf ("DW_OP_abs");
7288 printf ("DW_OP_and");
7291 printf ("DW_OP_div");
7294 printf ("DW_OP_minus");
7297 printf ("DW_OP_mod");
7300 printf ("DW_OP_mul");
7303 printf ("DW_OP_neg");
7306 printf ("DW_OP_not");
7309 printf ("DW_OP_or");
7312 printf ("DW_OP_plus");
7314 case DW_OP_plus_uconst
:
7315 printf ("DW_OP_plus_uconst: %lu",
7316 read_leb128 (data
, &bytes_read
, 0));
7320 printf ("DW_OP_shl");
7323 printf ("DW_OP_shr");
7326 printf ("DW_OP_shra");
7329 printf ("DW_OP_xor");
7332 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7336 printf ("DW_OP_eq");
7339 printf ("DW_OP_ge");
7342 printf ("DW_OP_gt");
7345 printf ("DW_OP_le");
7348 printf ("DW_OP_lt");
7351 printf ("DW_OP_ne");
7354 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7390 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7425 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7460 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7461 read_leb128 (data
, &bytes_read
, 1));
7466 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7470 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7474 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7476 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7477 read_leb128 (data
, &bytes_read
, 1));
7481 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7484 case DW_OP_deref_size
:
7485 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7487 case DW_OP_xderef_size
:
7488 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7491 printf ("DW_OP_nop");
7494 /* DWARF 3 extensions. */
7495 case DW_OP_push_object_address
:
7496 printf ("DW_OP_push_object_address");
7499 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7503 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7506 case DW_OP_call_ref
:
7507 printf ("DW_OP_call_ref");
7510 /* GNU extensions. */
7511 case DW_OP_GNU_push_tls_address
:
7512 printf ("DW_OP_GNU_push_tls_address");
7516 if (op
>= DW_OP_lo_user
7517 && op
<= DW_OP_hi_user
)
7518 printf (_("(User defined location op)"));
7520 printf (_("(Unknown location op)"));
7521 /* No way to tell where the next op is, so just bail. */
7525 /* Separate the ops. */
7530 static const char *debug_loc_contents
;
7531 static bfd_vma debug_loc_size
;
7534 load_debug_loc (file
)
7537 Elf_Internal_Shdr
*sec
;
7540 /* If it is already loaded, do nothing. */
7541 if (debug_loc_contents
!= NULL
)
7544 /* Locate the .debug_loc section. */
7545 for (i
= 0, sec
= section_headers
;
7546 i
< elf_header
.e_shnum
;
7548 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7551 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7554 debug_loc_size
= sec
->sh_size
;
7556 debug_loc_contents
= ((char *)
7557 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7558 _("debug_loc section data")));
7564 if (debug_loc_contents
== NULL
)
7567 free ((char *) debug_loc_contents
);
7568 debug_loc_contents
= NULL
;
7574 display_debug_loc (section
, start
, file
)
7575 Elf_Internal_Shdr
*section
;
7576 unsigned char *start
;
7577 FILE *file ATTRIBUTE_UNUSED
;
7579 unsigned char *section_end
;
7580 unsigned long bytes
;
7581 unsigned char *section_begin
= start
;
7584 addr
= section
->sh_addr
;
7585 bytes
= section
->sh_size
;
7586 section_end
= start
+ bytes
;
7590 printf (_("\nThe .debug_loc section is empty.\n"));
7594 printf (_("Contents of the .debug_loc section:\n\n"));
7595 printf (_("\n Offset Begin End Expression\n"));
7597 while (start
< section_end
)
7599 unsigned long begin
;
7601 unsigned short length
;
7602 unsigned long offset
;
7604 offset
= start
- section_begin
;
7608 /* Normally, the lists in the debug_loc section are related to a
7609 given compilation unit, and thus, we would use the
7610 pointer size of that compilation unit. However, since we are
7611 displaying it seperately here, we either have to store
7612 pointer sizes of all compilation units, or assume they don't
7613 change. We assume, like the debug_line display, that
7614 it doesn't change. */
7615 begin
= byte_get (start
, debug_line_pointer_size
);
7616 start
+= debug_line_pointer_size
;
7617 end
= byte_get (start
, debug_line_pointer_size
);
7618 start
+= debug_line_pointer_size
;
7620 if (begin
== 0 && end
== 0)
7626 length
= byte_get (start
, 2);
7629 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7630 decode_location_expression (start
, debug_line_pointer_size
, length
);
7640 static const char *debug_str_contents
;
7641 static bfd_vma debug_str_size
;
7644 load_debug_str (file
)
7647 Elf_Internal_Shdr
*sec
;
7650 /* If it is already loaded, do nothing. */
7651 if (debug_str_contents
!= NULL
)
7654 /* Locate the .debug_str section. */
7655 for (i
= 0, sec
= section_headers
;
7656 i
< elf_header
.e_shnum
;
7658 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7661 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7664 debug_str_size
= sec
->sh_size
;
7666 debug_str_contents
= ((char *)
7667 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7668 _("debug_str section data")));
7674 if (debug_str_contents
== NULL
)
7677 free ((char *) debug_str_contents
);
7678 debug_str_contents
= NULL
;
7683 fetch_indirect_string (offset
)
7684 unsigned long offset
;
7686 if (debug_str_contents
== NULL
)
7687 return _("<no .debug_str section>");
7689 if (offset
> debug_str_size
)
7690 return _("<offset is too big>");
7692 return debug_str_contents
+ offset
;
7696 display_debug_str (section
, start
, file
)
7697 Elf_Internal_Shdr
*section
;
7698 unsigned char *start
;
7699 FILE *file ATTRIBUTE_UNUSED
;
7701 unsigned long bytes
;
7704 addr
= section
->sh_addr
;
7705 bytes
= section
->sh_size
;
7709 printf (_("\nThe .debug_str section is empty.\n"));
7713 printf (_("Contents of the .debug_str section:\n\n"));
7721 lbytes
= (bytes
> 16 ? 16 : bytes
);
7723 printf (" 0x%8.8lx ", (unsigned long) addr
);
7725 for (j
= 0; j
< 16; j
++)
7728 printf ("%2.2x", start
[j
]);
7736 for (j
= 0; j
< lbytes
; j
++)
7739 if (k
>= ' ' && k
< 0x80)
7755 static unsigned char *
7756 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
7757 unsigned long attribute
;
7759 unsigned char *data
;
7760 unsigned long cu_offset
;
7761 unsigned long pointer_size
;
7763 unsigned long uvalue
= 0;
7764 unsigned char *block_start
= NULL
;
7772 case DW_FORM_ref_addr
:
7774 uvalue
= byte_get (data
, pointer_size
);
7775 data
+= pointer_size
;
7779 uvalue
= byte_get (data
, /* offset_size */ 4);
7780 data
+= /* offset_size */ 4;
7786 uvalue
= byte_get (data
++, 1);
7791 uvalue
= byte_get (data
, 2);
7797 uvalue
= byte_get (data
, 4);
7802 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7806 case DW_FORM_ref_udata
:
7808 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7812 case DW_FORM_indirect
:
7813 form
= read_leb128 (data
, & bytes_read
, 0);
7815 printf (" %s", get_FORM_name (form
));
7816 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7822 case DW_FORM_ref_addr
:
7823 printf (" <#%lx>", uvalue
);
7829 case DW_FORM_ref_udata
:
7830 printf (" <%lx>", uvalue
+ cu_offset
);
7834 printf (" %#lx", uvalue
);
7842 printf (" %ld", uvalue
);
7847 uvalue
= byte_get (data
, 4);
7848 printf (" %lx", uvalue
);
7849 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7853 case DW_FORM_string
:
7854 printf (" %s", data
);
7855 data
+= strlen ((char *) data
) + 1;
7859 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7860 block_start
= data
+ bytes_read
;
7861 data
= display_block (block_start
, uvalue
);
7864 case DW_FORM_block1
:
7865 uvalue
= byte_get (data
, 1);
7866 block_start
= data
+ 1;
7867 data
= display_block (block_start
, uvalue
);
7870 case DW_FORM_block2
:
7871 uvalue
= byte_get (data
, 2);
7872 block_start
= data
+ 2;
7873 data
= display_block (block_start
, uvalue
);
7876 case DW_FORM_block4
:
7877 uvalue
= byte_get (data
, 4);
7878 block_start
= data
+ 4;
7879 data
= display_block (block_start
, uvalue
);
7883 printf (_(" (indirect string, offset: 0x%lx): %s"),
7884 uvalue
, fetch_indirect_string (uvalue
));
7887 case DW_FORM_indirect
:
7888 /* Handled above. */
7892 warn (_("Unrecognized form: %d\n"), form
);
7896 /* For some attributes we can display futher information. */
7905 case DW_INL_not_inlined
:
7906 printf (_("(not inlined)"));
7908 case DW_INL_inlined
:
7909 printf (_("(inlined)"));
7911 case DW_INL_declared_not_inlined
:
7912 printf (_("(declared as inline but ignored)"));
7914 case DW_INL_declared_inlined
:
7915 printf (_("(declared as inline and inlined)"));
7918 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
7923 case DW_AT_language
:
7926 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7927 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7928 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7929 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7930 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7931 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7932 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7933 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7934 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7935 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7936 /* DWARF 2.1 values. */
7937 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7938 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7939 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7940 /* MIPS extension. */
7941 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7942 /* UPC extension. */
7943 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
7945 printf ("(Unknown: %lx)", uvalue
);
7950 case DW_AT_encoding
:
7953 case DW_ATE_void
: printf ("(void)"); break;
7954 case DW_ATE_address
: printf ("(machine address)"); break;
7955 case DW_ATE_boolean
: printf ("(boolean)"); break;
7956 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7957 case DW_ATE_float
: printf ("(float)"); break;
7958 case DW_ATE_signed
: printf ("(signed)"); break;
7959 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7960 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7961 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7962 /* DWARF 2.1 value. */
7963 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7965 if (uvalue
>= DW_ATE_lo_user
7966 && uvalue
<= DW_ATE_hi_user
)
7967 printf ("(user defined type)");
7969 printf ("(unknown type)");
7974 case DW_AT_accessibility
:
7977 case DW_ACCESS_public
: printf ("(public)"); break;
7978 case DW_ACCESS_protected
: printf ("(protected)"); break;
7979 case DW_ACCESS_private
: printf ("(private)"); break;
7981 printf ("(unknown accessibility)");
7986 case DW_AT_visibility
:
7989 case DW_VIS_local
: printf ("(local)"); break;
7990 case DW_VIS_exported
: printf ("(exported)"); break;
7991 case DW_VIS_qualified
: printf ("(qualified)"); break;
7992 default: printf ("(unknown visibility)"); break;
7996 case DW_AT_virtuality
:
7999 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8000 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8001 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8002 default: printf ("(unknown virtuality)"); break;
8006 case DW_AT_identifier_case
:
8009 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8010 case DW_ID_up_case
: printf ("(up_case)"); break;
8011 case DW_ID_down_case
: printf ("(down_case)"); break;
8012 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8013 default: printf ("(unknown case)"); break;
8017 case DW_AT_calling_convention
:
8020 case DW_CC_normal
: printf ("(normal)"); break;
8021 case DW_CC_program
: printf ("(program)"); break;
8022 case DW_CC_nocall
: printf ("(nocall)"); break;
8024 if (uvalue
>= DW_CC_lo_user
8025 && uvalue
<= DW_CC_hi_user
)
8026 printf ("(user defined)");
8028 printf ("(unknown convention)");
8032 case DW_AT_ordering
:
8035 case -1: printf ("(undefined)"); break;
8036 case 0: printf ("(row major)"); break;
8037 case 1: printf ("(column major)"); break;
8041 case DW_AT_frame_base
:
8042 case DW_AT_location
:
8043 case DW_AT_data_member_location
:
8044 case DW_AT_vtable_elem_location
:
8045 case DW_AT_allocated
:
8046 case DW_AT_associated
:
8047 case DW_AT_data_location
:
8049 case DW_AT_upper_bound
:
8050 case DW_AT_lower_bound
:
8054 decode_location_expression (block_start
, pointer_size
, uvalue
);
8057 else if (form
== DW_FORM_data4
)
8060 printf ("location list");
8072 static unsigned char *
8073 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
8074 unsigned long attribute
;
8076 unsigned char *data
;
8077 unsigned long cu_offset
;
8078 unsigned long pointer_size
;
8080 printf (" %-18s:", get_AT_name (attribute
));
8081 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8088 display_debug_info (section
, start
, file
)
8089 Elf_Internal_Shdr
*section
;
8090 unsigned char *start
;
8093 unsigned char *end
= start
+ section
->sh_size
;
8094 unsigned char *section_begin
= start
;
8096 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8098 load_debug_str (file
);
8099 load_debug_loc (file
);
8103 DWARF2_External_CompUnit
*external
;
8104 DWARF2_Internal_CompUnit compunit
;
8105 Elf_Internal_Shdr
*relsec
;
8106 unsigned char *tags
;
8109 unsigned long cu_offset
;
8111 external
= (DWARF2_External_CompUnit
*) start
;
8113 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
8114 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
8115 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
8116 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8118 if (compunit
.cu_length
== 0xffffffff)
8120 warn (_("64-bit DWARF debug info is not supported yet.\n"));
8124 /* Check for RELA relocations in the
8125 abbrev_offset address, and apply them. */
8126 for (relsec
= section_headers
;
8127 relsec
< section_headers
+ elf_header
.e_shnum
;
8130 unsigned long nrelas
;
8131 Elf_Internal_Rela
*rela
, *rp
;
8132 Elf_Internal_Shdr
*symsec
;
8133 Elf_Internal_Sym
*symtab
;
8134 Elf_Internal_Sym
*sym
;
8136 if (relsec
->sh_type
!= SHT_RELA
8137 || SECTION_HEADER (relsec
->sh_info
) != section
8138 || relsec
->sh_size
== 0)
8141 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8145 symsec
= SECTION_HEADER (relsec
->sh_link
);
8146 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8148 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8151 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
8157 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8159 if (ELF32_R_SYM (rp
->r_info
) != 0
8160 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8162 warn (_("Skipping unexpected symbol type %u\n"),
8163 ELF32_ST_TYPE (sym
->st_info
));
8169 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8171 if (ELF64_R_SYM (rp
->r_info
) != 0
8172 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8174 warn (_("Skipping unexpected symbol type %u\n"),
8175 ELF64_ST_TYPE (sym
->st_info
));
8180 compunit
.cu_abbrev_offset
= rp
->r_addend
;
8188 tags
= start
+ sizeof (*external
);
8189 cu_offset
= start
- section_begin
;
8190 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
8192 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8193 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8194 printf (_(" Version: %d\n"), compunit
.cu_version
);
8195 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8196 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8198 if (compunit
.cu_version
!= 2)
8200 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8206 /* Read in the abbrevs used by this compilation unit. */
8208 Elf_Internal_Shdr
*sec
;
8209 unsigned char *begin
;
8211 /* Locate the .debug_abbrev section and process it. */
8212 for (i
= 0, sec
= section_headers
;
8213 i
< elf_header
.e_shnum
;
8215 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
8218 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
8220 warn (_("Unable to locate .debug_abbrev section!\n"));
8224 begin
= ((unsigned char *)
8225 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8226 _("debug_abbrev section data")));
8230 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8231 begin
+ sec
->sh_size
);
8237 while (tags
< start
)
8240 unsigned long abbrev_number
;
8241 abbrev_entry
*entry
;
8244 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8247 /* A null DIE marks the end of a list of children. */
8248 if (abbrev_number
== 0)
8254 /* Scan through the abbreviation list until we reach the
8256 for (entry
= first_abbrev
;
8257 entry
&& entry
->entry
!= abbrev_number
;
8258 entry
= entry
->next
)
8263 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8268 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8270 (unsigned long) (tags
- section_begin
- bytes_read
),
8272 get_TAG_name (entry
->tag
));
8274 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8275 tags
= read_and_display_attr (attr
->attribute
,
8278 compunit
.cu_pointer_size
);
8280 if (entry
->children
)
8294 display_debug_aranges (section
, start
, file
)
8295 Elf_Internal_Shdr
*section
;
8296 unsigned char *start
;
8297 FILE *file ATTRIBUTE_UNUSED
;
8299 unsigned char *end
= start
+ section
->sh_size
;
8301 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8305 DWARF2_External_ARange
*external
;
8306 DWARF2_Internal_ARange arange
;
8307 unsigned char *ranges
;
8308 unsigned long length
;
8309 unsigned long address
;
8312 external
= (DWARF2_External_ARange
*) start
;
8314 arange
.ar_length
= BYTE_GET (external
->ar_length
);
8315 arange
.ar_version
= BYTE_GET (external
->ar_version
);
8316 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
8317 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
8318 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
8320 if (arange
.ar_length
== 0xffffffff)
8322 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8326 if (arange
.ar_version
!= 2)
8328 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8332 printf (_(" Length: %ld\n"), arange
.ar_length
);
8333 printf (_(" Version: %d\n"), arange
.ar_version
);
8334 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8335 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8336 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8338 printf (_("\n Address Length\n"));
8340 ranges
= start
+ sizeof (*external
);
8342 /* Must pad to an alignment boundary that is twice the pointer size. */
8343 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
8345 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8349 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8351 ranges
+= arange
.ar_pointer_size
;
8353 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8355 ranges
+= arange
.ar_pointer_size
;
8357 /* A pair of zeros marks the end of the list. */
8358 if (address
== 0 && length
== 0)
8361 printf (" %8.8lx %lu\n", address
, length
);
8364 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
8372 typedef struct Frame_Chunk
8374 struct Frame_Chunk
*next
;
8375 unsigned char *chunk_start
;
8377 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8378 short int *col_type
;
8381 unsigned int code_factor
;
8383 unsigned long pc_begin
;
8384 unsigned long pc_range
;
8388 unsigned char fde_encoding
;
8392 /* A marker for a col_type that means this column was never referenced
8393 in the frame info. */
8394 #define DW_CFA_unreferenced (-1)
8396 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
8397 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
8398 static int size_of_encoded_value
PARAMS ((int));
8401 frame_need_space (fc
, reg
)
8405 int prev
= fc
->ncols
;
8407 if (reg
< fc
->ncols
)
8410 fc
->ncols
= reg
+ 1;
8411 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
8412 fc
->ncols
* sizeof (short int));
8413 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
8414 fc
->ncols
* sizeof (int));
8416 while (prev
< fc
->ncols
)
8418 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8419 fc
->col_offset
[prev
] = 0;
8425 frame_display_row (fc
, need_col_headers
, max_regs
)
8427 int *need_col_headers
;
8433 if (*max_regs
< fc
->ncols
)
8434 *max_regs
= fc
->ncols
;
8436 if (*need_col_headers
)
8438 *need_col_headers
= 0;
8440 printf (" LOC CFA ");
8442 for (r
= 0; r
< *max_regs
; r
++)
8443 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8448 printf ("r%-4d", r
);
8454 printf ("%08lx ", fc
->pc_begin
);
8455 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8456 printf ("%-8s ", tmp
);
8458 for (r
= 0; r
< fc
->ncols
; r
++)
8460 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8462 switch (fc
->col_type
[r
])
8464 case DW_CFA_undefined
:
8467 case DW_CFA_same_value
:
8471 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8473 case DW_CFA_register
:
8474 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8477 strcpy (tmp
, "n/a");
8480 printf ("%-5s", tmp
);
8487 size_of_encoded_value (encoding
)
8490 switch (encoding
& 0x7)
8493 case 0: return is_32bit_elf
? 4 : 8;
8500 #define GET(N) byte_get (start, N); start += N
8501 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8502 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8505 display_debug_frames (section
, start
, file
)
8506 Elf_Internal_Shdr
*section
;
8507 unsigned char *start
;
8508 FILE *file ATTRIBUTE_UNUSED
;
8510 unsigned char *end
= start
+ section
->sh_size
;
8511 unsigned char *section_start
= start
;
8512 Frame_Chunk
*chunks
= 0;
8513 Frame_Chunk
*remembered_state
= 0;
8515 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8518 int addr_size
= is_32bit_elf
? 4 : 8;
8520 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8524 unsigned char *saved_start
;
8525 unsigned char *block_end
;
8526 unsigned long length
;
8527 unsigned long cie_id
;
8530 int need_col_headers
= 1;
8531 unsigned char *augmentation_data
= NULL
;
8532 unsigned long augmentation_data_len
= 0;
8533 int encoded_ptr_size
= addr_size
;
8535 saved_start
= start
;
8536 length
= byte_get (start
, 4); start
+= 4;
8540 printf ("\n%08lx ZERO terminator\n\n",
8541 (unsigned long)(saved_start
- section_start
));
8545 if (length
== 0xffffffff)
8547 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8551 block_end
= saved_start
+ length
+ 4;
8552 cie_id
= byte_get (start
, 4); start
+= 4;
8554 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8558 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8559 memset (fc
, 0, sizeof (Frame_Chunk
));
8563 fc
->chunk_start
= saved_start
;
8565 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8566 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8567 frame_need_space (fc
, max_regs
-1);
8571 fc
->augmentation
= start
;
8572 start
= strchr (start
, '\0') + 1;
8574 if (fc
->augmentation
[0] == 'z')
8576 fc
->code_factor
= LEB ();
8577 fc
->data_factor
= SLEB ();
8578 fc
->ra
= byte_get (start
, 1); start
+= 1;
8579 augmentation_data_len
= LEB ();
8580 augmentation_data
= start
;
8581 start
+= augmentation_data_len
;
8583 else if (strcmp (fc
->augmentation
, "eh") == 0)
8586 fc
->code_factor
= LEB ();
8587 fc
->data_factor
= SLEB ();
8588 fc
->ra
= byte_get (start
, 1); start
+= 1;
8592 fc
->code_factor
= LEB ();
8593 fc
->data_factor
= SLEB ();
8594 fc
->ra
= byte_get (start
, 1); start
+= 1;
8598 if (do_debug_frames_interp
)
8599 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8600 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8601 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8605 printf ("\n%08lx %08lx %08lx CIE\n",
8606 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8607 printf (" Version: %d\n", version
);
8608 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8609 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8610 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8611 printf (" Return address column: %d\n", fc
->ra
);
8613 if (augmentation_data_len
)
8616 printf (" Augmentation data: ");
8617 for (i
= 0; i
< augmentation_data_len
; ++i
)
8618 printf (" %02x", augmentation_data
[i
]);
8624 if (augmentation_data_len
)
8626 unsigned char *p
, *q
;
8627 p
= fc
->augmentation
+ 1;
8628 q
= augmentation_data
;
8635 q
+= 1 + size_of_encoded_value (*q
);
8637 fc
->fde_encoding
= *q
++;
8643 if (fc
->fde_encoding
)
8644 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8647 frame_need_space (fc
, fc
->ra
);
8651 unsigned char *look_for
;
8652 static Frame_Chunk fde_fc
;
8655 memset (fc
, 0, sizeof (Frame_Chunk
));
8657 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8659 for (cie
= chunks
; cie
; cie
= cie
->next
)
8660 if (cie
->chunk_start
== look_for
)
8665 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8666 cie_id
, saved_start
);
8669 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
8670 fc
->col_offset
= (int *) xmalloc (sizeof (int));
8671 frame_need_space (fc
, max_regs
- 1);
8673 fc
->augmentation
= "";
8674 fc
->fde_encoding
= 0;
8678 fc
->ncols
= cie
->ncols
;
8679 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
8680 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
8681 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8682 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8683 fc
->augmentation
= cie
->augmentation
;
8684 fc
->code_factor
= cie
->code_factor
;
8685 fc
->data_factor
= cie
->data_factor
;
8686 fc
->cfa_reg
= cie
->cfa_reg
;
8687 fc
->cfa_offset
= cie
->cfa_offset
;
8689 frame_need_space (fc
, max_regs
-1);
8690 fc
->fde_encoding
= cie
->fde_encoding
;
8693 if (fc
->fde_encoding
)
8694 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8696 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
8697 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8698 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
8699 start
+= encoded_ptr_size
;
8700 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8701 start
+= encoded_ptr_size
;
8703 if (cie
->augmentation
[0] == 'z')
8705 augmentation_data_len
= LEB ();
8706 augmentation_data
= start
;
8707 start
+= augmentation_data_len
;
8710 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8711 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8712 (unsigned long)(cie
->chunk_start
- section_start
),
8713 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8714 if (! do_debug_frames_interp
&& augmentation_data_len
)
8717 printf (" Augmentation data: ");
8718 for (i
= 0; i
< augmentation_data_len
; ++i
)
8719 printf (" %02x", augmentation_data
[i
]);
8725 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8726 about to interpret instructions for the chunk. */
8728 if (do_debug_frames_interp
)
8730 /* Start by making a pass over the chunk, allocating storage
8731 and taking note of what registers are used. */
8732 unsigned char *tmp
= start
;
8734 while (start
< block_end
)
8744 /* Warning: if you add any more cases to this switch, be
8745 sure to add them to the corresponding switch below. */
8748 case DW_CFA_advance_loc
:
8752 frame_need_space (fc
, opa
);
8753 fc
->col_type
[opa
] = DW_CFA_undefined
;
8755 case DW_CFA_restore
:
8756 frame_need_space (fc
, opa
);
8757 fc
->col_type
[opa
] = DW_CFA_undefined
;
8759 case DW_CFA_set_loc
:
8760 start
+= encoded_ptr_size
;
8762 case DW_CFA_advance_loc1
:
8765 case DW_CFA_advance_loc2
:
8768 case DW_CFA_advance_loc4
:
8771 case DW_CFA_offset_extended
:
8772 reg
= LEB (); LEB ();
8773 frame_need_space (fc
, reg
);
8774 fc
->col_type
[reg
] = DW_CFA_undefined
;
8776 case DW_CFA_restore_extended
:
8778 frame_need_space (fc
, reg
);
8779 fc
->col_type
[reg
] = DW_CFA_undefined
;
8781 case DW_CFA_undefined
:
8783 frame_need_space (fc
, reg
);
8784 fc
->col_type
[reg
] = DW_CFA_undefined
;
8786 case DW_CFA_same_value
:
8788 frame_need_space (fc
, reg
);
8789 fc
->col_type
[reg
] = DW_CFA_undefined
;
8791 case DW_CFA_register
:
8792 reg
= LEB (); LEB ();
8793 frame_need_space (fc
, reg
);
8794 fc
->col_type
[reg
] = DW_CFA_undefined
;
8796 case DW_CFA_def_cfa
:
8799 case DW_CFA_def_cfa_register
:
8802 case DW_CFA_def_cfa_offset
:
8805 case DW_CFA_offset_extended_sf
:
8806 reg
= LEB (); SLEB ();
8807 frame_need_space (fc
, reg
);
8808 fc
->col_type
[reg
] = DW_CFA_undefined
;
8810 case DW_CFA_def_cfa_sf
:
8813 case DW_CFA_def_cfa_offset_sf
:
8816 case DW_CFA_GNU_args_size
:
8819 case DW_CFA_GNU_negative_offset_extended
:
8820 reg
= LEB (); LEB ();
8821 frame_need_space (fc
, reg
);
8822 fc
->col_type
[reg
] = DW_CFA_undefined
;
8831 /* Now we know what registers are used, make a second pass over
8832 the chunk, this time actually printing out the info. */
8834 while (start
< block_end
)
8837 unsigned long ul
, reg
, roffs
;
8846 /* Warning: if you add any more cases to this switch, be
8847 sure to add them to the corresponding switch above. */
8850 case DW_CFA_advance_loc
:
8851 if (do_debug_frames_interp
)
8852 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8854 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8855 opa
* fc
->code_factor
,
8856 fc
->pc_begin
+ opa
* fc
->code_factor
);
8857 fc
->pc_begin
+= opa
* fc
->code_factor
;
8862 if (! do_debug_frames_interp
)
8863 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8864 opa
, roffs
* fc
->data_factor
);
8865 fc
->col_type
[opa
] = DW_CFA_offset
;
8866 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8869 case DW_CFA_restore
:
8870 if (! do_debug_frames_interp
)
8871 printf (" DW_CFA_restore: r%d\n", opa
);
8872 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8873 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8876 case DW_CFA_set_loc
:
8877 vma
= byte_get (start
, encoded_ptr_size
);
8878 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8879 vma
+= section
->sh_addr
+ (start
- section_start
);
8880 start
+= encoded_ptr_size
;
8881 if (do_debug_frames_interp
)
8882 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8884 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8888 case DW_CFA_advance_loc1
:
8889 ofs
= byte_get (start
, 1); start
+= 1;
8890 if (do_debug_frames_interp
)
8891 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8893 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8894 ofs
* fc
->code_factor
,
8895 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8896 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8899 case DW_CFA_advance_loc2
:
8900 ofs
= byte_get (start
, 2); start
+= 2;
8901 if (do_debug_frames_interp
)
8902 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8904 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8905 ofs
* fc
->code_factor
,
8906 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8907 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8910 case DW_CFA_advance_loc4
:
8911 ofs
= byte_get (start
, 4); start
+= 4;
8912 if (do_debug_frames_interp
)
8913 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8915 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8916 ofs
* fc
->code_factor
,
8917 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8918 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8921 case DW_CFA_offset_extended
:
8924 if (! do_debug_frames_interp
)
8925 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8926 reg
, roffs
* fc
->data_factor
);
8927 fc
->col_type
[reg
] = DW_CFA_offset
;
8928 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8931 case DW_CFA_restore_extended
:
8933 if (! do_debug_frames_interp
)
8934 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8935 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8936 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8939 case DW_CFA_undefined
:
8941 if (! do_debug_frames_interp
)
8942 printf (" DW_CFA_undefined: r%ld\n", reg
);
8943 fc
->col_type
[reg
] = DW_CFA_undefined
;
8944 fc
->col_offset
[reg
] = 0;
8947 case DW_CFA_same_value
:
8949 if (! do_debug_frames_interp
)
8950 printf (" DW_CFA_same_value: r%ld\n", reg
);
8951 fc
->col_type
[reg
] = DW_CFA_same_value
;
8952 fc
->col_offset
[reg
] = 0;
8955 case DW_CFA_register
:
8958 if (! do_debug_frames_interp
)
8959 printf (" DW_CFA_register: r%ld\n", reg
);
8960 fc
->col_type
[reg
] = DW_CFA_register
;
8961 fc
->col_offset
[reg
] = roffs
;
8964 case DW_CFA_remember_state
:
8965 if (! do_debug_frames_interp
)
8966 printf (" DW_CFA_remember_state\n");
8967 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8968 rs
->ncols
= fc
->ncols
;
8969 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8970 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8971 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8972 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8973 rs
->next
= remembered_state
;
8974 remembered_state
= rs
;
8977 case DW_CFA_restore_state
:
8978 if (! do_debug_frames_interp
)
8979 printf (" DW_CFA_restore_state\n");
8980 rs
= remembered_state
;
8981 remembered_state
= rs
->next
;
8982 frame_need_space (fc
, rs
->ncols
-1);
8983 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8984 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8985 free (rs
->col_type
);
8986 free (rs
->col_offset
);
8990 case DW_CFA_def_cfa
:
8991 fc
->cfa_reg
= LEB ();
8992 fc
->cfa_offset
= LEB ();
8993 if (! do_debug_frames_interp
)
8994 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8995 fc
->cfa_reg
, fc
->cfa_offset
);
8998 case DW_CFA_def_cfa_register
:
8999 fc
->cfa_reg
= LEB ();
9000 if (! do_debug_frames_interp
)
9001 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9004 case DW_CFA_def_cfa_offset
:
9005 fc
->cfa_offset
= LEB ();
9006 if (! do_debug_frames_interp
)
9007 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9011 if (! do_debug_frames_interp
)
9012 printf (" DW_CFA_nop\n");
9015 case DW_CFA_offset_extended_sf
:
9018 frame_need_space (fc
, reg
);
9019 if (! do_debug_frames_interp
)
9020 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9021 reg
, l
* fc
->data_factor
);
9022 fc
->col_type
[reg
] = DW_CFA_offset
;
9023 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9026 case DW_CFA_def_cfa_sf
:
9027 fc
->cfa_reg
= LEB ();
9028 fc
->cfa_offset
= SLEB ();
9029 if (! do_debug_frames_interp
)
9030 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9031 fc
->cfa_reg
, fc
->cfa_offset
);
9034 case DW_CFA_def_cfa_offset_sf
:
9035 fc
->cfa_offset
= SLEB ();
9036 if (! do_debug_frames_interp
)
9037 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9040 case DW_CFA_GNU_window_save
:
9041 if (! do_debug_frames_interp
)
9042 printf (" DW_CFA_GNU_window_save\n");
9045 case DW_CFA_GNU_args_size
:
9047 if (! do_debug_frames_interp
)
9048 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9051 case DW_CFA_GNU_negative_offset_extended
:
9054 frame_need_space (fc
, reg
);
9055 if (! do_debug_frames_interp
)
9056 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9057 reg
, l
* fc
->data_factor
);
9058 fc
->col_type
[reg
] = DW_CFA_offset
;
9059 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9062 /* FIXME: How do we handle these? */
9063 case DW_CFA_def_cfa_expression
:
9064 fprintf (stderr
, "unsupported DW_CFA_def_cfa_expression\n");
9068 case DW_CFA_expression
:
9069 fprintf (stderr
, "unsupported DW_CFA_expression\n");
9074 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9079 if (do_debug_frames_interp
)
9080 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9095 display_debug_not_supported (section
, start
, file
)
9096 Elf_Internal_Shdr
*section
;
9097 unsigned char *start ATTRIBUTE_UNUSED
;
9098 FILE *file ATTRIBUTE_UNUSED
;
9100 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9101 SECTION_NAME (section
));
9106 /* Pre-scan the .debug_info section to record the size of address.
9107 When dumping the .debug_line, we use that size information, assuming
9108 that all compilation units have the same address size. */
9110 prescan_debug_info (section
, start
, file
)
9111 Elf_Internal_Shdr
*section ATTRIBUTE_UNUSED
;
9112 unsigned char *start
;
9113 FILE *file ATTRIBUTE_UNUSED
;
9115 DWARF2_External_CompUnit
*external
;
9117 external
= (DWARF2_External_CompUnit
*) start
;
9119 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
9123 /* A structure containing the name of a debug section and a pointer
9124 to a function that can decode it. The third field is a prescan
9125 function to be run over the section before displaying any of the
9129 const char *const name
;
9130 int (*display
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
9131 int (*prescan
) PARAMS ((Elf_Internal_Shdr
*, unsigned char *, FILE *));
9135 { ".debug_abbrev", display_debug_abbrev
, NULL
},
9136 { ".debug_aranges", display_debug_aranges
, NULL
},
9137 { ".debug_frame", display_debug_frames
, NULL
},
9138 { ".debug_info", display_debug_info
, prescan_debug_info
},
9139 { ".debug_line", display_debug_lines
, NULL
},
9140 { ".debug_pubnames", display_debug_pubnames
, NULL
},
9141 { ".eh_frame", display_debug_frames
, NULL
},
9142 { ".debug_macinfo", display_debug_macinfo
, NULL
},
9143 { ".debug_str", display_debug_str
, NULL
},
9144 { ".debug_loc", display_debug_loc
, NULL
},
9145 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
9146 { ".debug_ranges", display_debug_not_supported
, NULL
},
9147 { ".debug_static_func", display_debug_not_supported
, NULL
},
9148 { ".debug_static_vars", display_debug_not_supported
, NULL
},
9149 { ".debug_types", display_debug_not_supported
, NULL
},
9150 { ".debug_weaknames", display_debug_not_supported
, NULL
}
9154 display_debug_section (section
, file
)
9155 Elf_Internal_Shdr
*section
;
9158 char *name
= SECTION_NAME (section
);
9159 bfd_size_type length
;
9160 unsigned char *start
;
9163 length
= section
->sh_size
;
9166 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9170 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
9171 _("debug section data"));
9175 /* See if we know how to display the contents of this section. */
9176 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9177 name
= ".debug_info";
9179 for (i
= NUM_ELEM (debug_displays
); i
--;)
9180 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9182 debug_displays
[i
].display (section
, start
, file
);
9187 printf (_("Unrecognized debug section: %s\n"), name
);
9191 /* If we loaded in the abbrev section at some point,
9192 we must release it here. */
9199 process_section_contents (file
)
9202 Elf_Internal_Shdr
*section
;
9208 /* Pre-scan the debug sections to find some debug information not
9209 present in some of them. For the .debug_line, we must find out the
9210 size of address (specified in .debug_info and .debug_aranges). */
9211 for (i
= 0, section
= section_headers
;
9212 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9215 char *name
= SECTION_NAME (section
);
9218 if (section
->sh_size
== 0)
9221 /* See if there is some pre-scan operation for this section. */
9222 for (j
= NUM_ELEM (debug_displays
); j
--;)
9223 if (strcmp (debug_displays
[j
].name
, name
) == 0)
9225 if (debug_displays
[j
].prescan
!= NULL
)
9227 bfd_size_type length
;
9228 unsigned char *start
;
9230 length
= section
->sh_size
;
9231 start
= ((unsigned char *)
9232 get_data (NULL
, file
, section
->sh_offset
, length
,
9233 _("debug section data")));
9237 debug_displays
[j
].prescan (section
, start
, file
);
9245 for (i
= 0, section
= section_headers
;
9246 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9249 #ifdef SUPPORT_DISASSEMBLY
9250 if (dump_sects
[i
] & DISASS_DUMP
)
9251 disassemble_section (section
, file
);
9253 if (dump_sects
[i
] & HEX_DUMP
)
9254 dump_section (section
, file
);
9256 if (dump_sects
[i
] & DEBUG_DUMP
)
9257 display_debug_section (section
, file
);
9260 if (i
< num_dump_sects
)
9261 warn (_("Some sections were not dumped because they do not exist!\n"));
9267 process_mips_fpe_exception (mask
)
9273 if (mask
& OEX_FPU_INEX
)
9274 fputs ("INEX", stdout
), first
= 0;
9275 if (mask
& OEX_FPU_UFLO
)
9276 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9277 if (mask
& OEX_FPU_OFLO
)
9278 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9279 if (mask
& OEX_FPU_DIV0
)
9280 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9281 if (mask
& OEX_FPU_INVAL
)
9282 printf ("%sINVAL", first
? "" : "|");
9285 fputs ("0", stdout
);
9289 process_mips_specific (file
)
9292 Elf_Internal_Dyn
*entry
;
9293 size_t liblist_offset
= 0;
9294 size_t liblistno
= 0;
9295 size_t conflictsno
= 0;
9296 size_t options_offset
= 0;
9297 size_t conflicts_offset
= 0;
9299 /* We have a lot of special sections. Thanks SGI! */
9300 if (dynamic_segment
== NULL
)
9301 /* No information available. */
9304 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9305 switch (entry
->d_tag
)
9307 case DT_MIPS_LIBLIST
:
9308 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
9310 case DT_MIPS_LIBLISTNO
:
9311 liblistno
= entry
->d_un
.d_val
;
9313 case DT_MIPS_OPTIONS
:
9314 options_offset
= entry
->d_un
.d_val
- loadaddr
;
9316 case DT_MIPS_CONFLICT
:
9317 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
9319 case DT_MIPS_CONFLICTNO
:
9320 conflictsno
= entry
->d_un
.d_val
;
9326 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9328 Elf32_External_Lib
*elib
;
9331 elib
= ((Elf32_External_Lib
*)
9332 get_data (NULL
, file
, liblist_offset
,
9333 liblistno
* sizeof (Elf32_External_Lib
),
9337 printf ("\nSection '.liblist' contains %lu entries:\n",
9338 (unsigned long) liblistno
);
9339 fputs (" Library Time Stamp Checksum Version Flags\n",
9342 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9349 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9350 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9351 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9352 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9353 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9355 tmp
= gmtime (&time
);
9356 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9357 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9358 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9360 printf ("%3lu: ", (unsigned long) cnt
);
9361 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9362 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9365 if (liblist
.l_flags
== 0)
9376 { " EXACT_MATCH", LL_EXACT_MATCH
},
9377 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9378 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9379 { " EXPORTS", LL_EXPORTS
},
9380 { " DELAY_LOAD", LL_DELAY_LOAD
},
9381 { " DELTA", LL_DELTA
}
9383 int flags
= liblist
.l_flags
;
9387 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9389 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9391 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9392 flags
^= l_flags_vals
[fcnt
].bit
;
9395 printf (" %#x", (unsigned int) flags
);
9405 if (options_offset
!= 0)
9407 Elf_External_Options
*eopt
;
9408 Elf_Internal_Shdr
*sect
= section_headers
;
9409 Elf_Internal_Options
*iopt
;
9410 Elf_Internal_Options
*option
;
9414 /* Find the section header so that we get the size. */
9415 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9418 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
9419 sect
->sh_size
, _("options"));
9422 iopt
= ((Elf_Internal_Options
*)
9423 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
)));
9426 error (_("Out of memory"));
9433 while (offset
< sect
->sh_size
)
9435 Elf_External_Options
*eoption
;
9437 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9439 option
->kind
= BYTE_GET (eoption
->kind
);
9440 option
->size
= BYTE_GET (eoption
->size
);
9441 option
->section
= BYTE_GET (eoption
->section
);
9442 option
->info
= BYTE_GET (eoption
->info
);
9444 offset
+= option
->size
;
9450 printf (_("\nSection '%s' contains %d entries:\n"),
9451 SECTION_NAME (sect
), cnt
);
9459 switch (option
->kind
)
9462 /* This shouldn't happen. */
9463 printf (" NULL %d %lx", option
->section
, option
->info
);
9466 printf (" REGINFO ");
9467 if (elf_header
.e_machine
== EM_MIPS
)
9470 Elf32_External_RegInfo
*ereg
;
9471 Elf32_RegInfo reginfo
;
9473 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9474 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9475 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9476 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9477 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9478 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9479 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9481 printf ("GPR %08lx GP 0x%lx\n",
9483 (unsigned long) reginfo
.ri_gp_value
);
9484 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9485 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9486 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9491 Elf64_External_RegInfo
*ereg
;
9492 Elf64_Internal_RegInfo reginfo
;
9494 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9495 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9496 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9497 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9498 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9499 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9500 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9502 printf ("GPR %08lx GP 0x",
9503 reginfo
.ri_gprmask
);
9504 printf_vma (reginfo
.ri_gp_value
);
9507 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9508 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9509 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9513 case ODK_EXCEPTIONS
:
9514 fputs (" EXCEPTIONS fpe_min(", stdout
);
9515 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9516 fputs (") fpe_max(", stdout
);
9517 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9518 fputs (")", stdout
);
9520 if (option
->info
& OEX_PAGE0
)
9521 fputs (" PAGE0", stdout
);
9522 if (option
->info
& OEX_SMM
)
9523 fputs (" SMM", stdout
);
9524 if (option
->info
& OEX_FPDBUG
)
9525 fputs (" FPDBUG", stdout
);
9526 if (option
->info
& OEX_DISMISS
)
9527 fputs (" DISMISS", stdout
);
9530 fputs (" PAD ", stdout
);
9531 if (option
->info
& OPAD_PREFIX
)
9532 fputs (" PREFIX", stdout
);
9533 if (option
->info
& OPAD_POSTFIX
)
9534 fputs (" POSTFIX", stdout
);
9535 if (option
->info
& OPAD_SYMBOL
)
9536 fputs (" SYMBOL", stdout
);
9539 fputs (" HWPATCH ", stdout
);
9540 if (option
->info
& OHW_R4KEOP
)
9541 fputs (" R4KEOP", stdout
);
9542 if (option
->info
& OHW_R8KPFETCH
)
9543 fputs (" R8KPFETCH", stdout
);
9544 if (option
->info
& OHW_R5KEOP
)
9545 fputs (" R5KEOP", stdout
);
9546 if (option
->info
& OHW_R5KCVTL
)
9547 fputs (" R5KCVTL", stdout
);
9550 fputs (" FILL ", stdout
);
9551 /* XXX Print content of info word? */
9554 fputs (" TAGS ", stdout
);
9555 /* XXX Print content of info word? */
9558 fputs (" HWAND ", stdout
);
9559 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9560 fputs (" R4KEOP_CHECKED", stdout
);
9561 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9562 fputs (" R4KEOP_CLEAN", stdout
);
9565 fputs (" HWOR ", stdout
);
9566 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9567 fputs (" R4KEOP_CHECKED", stdout
);
9568 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9569 fputs (" R4KEOP_CLEAN", stdout
);
9572 printf (" GP_GROUP %#06lx self-contained %#06lx",
9573 option
->info
& OGP_GROUP
,
9574 (option
->info
& OGP_SELF
) >> 16);
9577 printf (" IDENT %#06lx self-contained %#06lx",
9578 option
->info
& OGP_GROUP
,
9579 (option
->info
& OGP_SELF
) >> 16);
9582 /* This shouldn't happen. */
9583 printf (" %3d ??? %d %lx",
9584 option
->kind
, option
->section
, option
->info
);
9588 len
= sizeof (*eopt
);
9589 while (len
< option
->size
)
9590 if (((char *) option
)[len
] >= ' '
9591 && ((char *) option
)[len
] < 0x7f)
9592 printf ("%c", ((char *) option
)[len
++]);
9594 printf ("\\%03o", ((char *) option
)[len
++]);
9596 fputs ("\n", stdout
);
9604 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9606 Elf32_Conflict
*iconf
;
9609 if (dynamic_symbols
== NULL
)
9611 error (_("conflict list found without a dynamic symbol table"));
9615 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
9618 error (_("Out of memory"));
9624 Elf32_External_Conflict
*econf32
;
9626 econf32
= ((Elf32_External_Conflict
*)
9627 get_data (NULL
, file
, conflicts_offset
,
9628 conflictsno
* sizeof (*econf32
),
9633 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9634 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9640 Elf64_External_Conflict
*econf64
;
9642 econf64
= ((Elf64_External_Conflict
*)
9643 get_data (NULL
, file
, conflicts_offset
,
9644 conflictsno
* sizeof (*econf64
),
9649 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9650 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9655 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9656 (long) conflictsno
);
9657 puts (_(" Num: Index Value Name"));
9659 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9661 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9663 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9664 print_vma (psym
->st_value
, FULL_HEX
);
9666 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9677 process_gnu_liblist (file
)
9680 Elf_Internal_Shdr
*section
, *string_sec
;
9681 Elf32_External_Lib
*elib
;
9689 for (i
= 0, section
= section_headers
;
9690 i
< elf_header
.e_shnum
;
9693 switch (section
->sh_type
)
9695 case SHT_GNU_LIBLIST
:
9696 elib
= ((Elf32_External_Lib
*)
9697 get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9702 string_sec
= SECTION_HEADER (section
->sh_link
);
9704 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9705 string_sec
->sh_size
,
9706 _("liblist string table"));
9709 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9715 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9716 SECTION_NAME (section
),
9717 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9719 puts (" Library Time Stamp Checksum Version Flags");
9721 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9729 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9730 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9731 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9732 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9733 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9735 tmp
= gmtime (&time
);
9736 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9737 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9738 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9740 printf ("%3lu: ", (unsigned long) cnt
);
9742 printf ("%-20s", strtab
+ liblist
.l_name
);
9744 printf ("%-20.20s", strtab
+ liblist
.l_name
);
9745 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9746 liblist
.l_version
, liblist
.l_flags
);
9757 get_note_type (e_type
)
9760 static char buff
[64];
9764 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9765 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9766 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9767 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9768 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9769 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9770 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9771 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9772 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9773 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9774 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9776 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9782 get_netbsd_elfcore_note_type (e_type
)
9785 static char buff
[64];
9787 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9789 /* NetBSD core "procinfo" structure. */
9790 return _("NetBSD procinfo structure");
9793 /* As of Jan 2002 there are no other machine-independent notes
9794 defined for NetBSD core files. If the note type is less
9795 than the start of the machine-dependent note types, we don't
9798 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9800 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9804 switch (elf_header
.e_machine
)
9806 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9807 and PT_GETFPREGS == mach+2. */
9812 case EM_SPARC32PLUS
:
9816 case NT_NETBSDCORE_FIRSTMACH
+0:
9817 return _("PT_GETREGS (reg structure)");
9818 case NT_NETBSDCORE_FIRSTMACH
+2:
9819 return _("PT_GETFPREGS (fpreg structure)");
9825 /* On all other arch's, PT_GETREGS == mach+1 and
9826 PT_GETFPREGS == mach+3. */
9830 case NT_NETBSDCORE_FIRSTMACH
+1:
9831 return _("PT_GETREGS (reg structure)");
9832 case NT_NETBSDCORE_FIRSTMACH
+3:
9833 return _("PT_GETFPREGS (fpreg structure)");
9839 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9843 /* Note that by the ELF standard, the name field is already null byte
9844 terminated, and namesz includes the terminating null byte.
9845 I.E. the value of namesz for the name "FSF" is 4.
9847 If the value of namesz is zero, there is no name present. */
9849 process_note (pnote
)
9850 Elf_Internal_Note
*pnote
;
9854 if (pnote
->namesz
== 0)
9856 /* If there is no note name, then use the default set of
9857 note type strings. */
9858 nt
= get_note_type (pnote
->type
);
9860 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9862 /* NetBSD-specific core file notes. */
9863 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9867 /* Don't recognize this note name; just use the default set of
9868 note type strings. */
9869 nt
= get_note_type (pnote
->type
);
9872 printf (" %s\t\t0x%08lx\t%s\n",
9873 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9880 process_corefile_note_segment (file
, offset
, length
)
9885 Elf_External_Note
*pnotes
;
9886 Elf_External_Note
*external
;
9892 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
9899 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9900 (unsigned long) offset
, (unsigned long) length
);
9901 printf (_(" Owner\t\tData size\tDescription\n"));
9903 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9905 Elf_External_Note
*next
;
9906 Elf_Internal_Note inote
;
9909 inote
.type
= BYTE_GET (external
->type
);
9910 inote
.namesz
= BYTE_GET (external
->namesz
);
9911 inote
.namedata
= external
->name
;
9912 inote
.descsz
= BYTE_GET (external
->descsz
);
9913 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9914 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9916 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9918 if (((char *) next
) > (((char *) pnotes
) + length
))
9920 warn (_("corrupt note found at offset %x into core notes\n"),
9921 ((char *) external
) - ((char *) pnotes
));
9922 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9923 inote
.type
, inote
.namesz
, inote
.descsz
);
9929 /* Verify that name is null terminated. It appears that at least
9930 one version of Linux (RedHat 6.0) generates corefiles that don't
9931 comply with the ELF spec by failing to include the null byte in
9933 if (inote
.namedata
[inote
.namesz
] != '\0')
9935 temp
= malloc (inote
.namesz
+ 1);
9939 error (_("Out of memory\n"));
9944 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9945 temp
[inote
.namesz
] = 0;
9947 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9948 inote
.namedata
= temp
;
9951 res
&= process_note (& inote
);
9966 process_corefile_note_segments (file
)
9969 Elf_Internal_Phdr
*program_headers
;
9970 Elf_Internal_Phdr
*segment
;
9974 program_headers
= (Elf_Internal_Phdr
*) malloc
9975 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
9977 if (program_headers
== NULL
)
9979 error (_("Out of memory\n"));
9984 i
= get_32bit_program_headers (file
, program_headers
);
9986 i
= get_64bit_program_headers (file
, program_headers
);
9990 free (program_headers
);
9994 for (i
= 0, segment
= program_headers
;
9995 i
< elf_header
.e_phnum
;
9998 if (segment
->p_type
== PT_NOTE
)
9999 res
&= process_corefile_note_segment (file
,
10000 (bfd_vma
) segment
->p_offset
,
10001 (bfd_vma
) segment
->p_filesz
);
10004 free (program_headers
);
10010 process_corefile_contents (file
)
10013 /* If we have not been asked to display the notes then do nothing. */
10017 /* If file is not a core file then exit. */
10018 if (elf_header
.e_type
!= ET_CORE
)
10021 /* No program headers means no NOTE segment. */
10022 if (elf_header
.e_phnum
== 0)
10024 printf (_("No note segments present in the core file.\n"));
10028 return process_corefile_note_segments (file
);
10032 process_arch_specific (file
)
10038 switch (elf_header
.e_machine
)
10041 case EM_MIPS_RS3_LE
:
10042 return process_mips_specific (file
);
10051 get_file_header (file
)
10054 /* Read in the identity array. */
10055 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10058 /* Determine how to read the rest of the header. */
10059 switch (elf_header
.e_ident
[EI_DATA
])
10061 default: /* fall through */
10062 case ELFDATANONE
: /* fall through */
10063 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
10064 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
10067 /* For now we only support 32 bit and 64 bit ELF files. */
10068 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10070 /* Read in the rest of the header. */
10073 Elf32_External_Ehdr ehdr32
;
10075 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10078 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10079 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10080 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10081 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10082 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10083 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10084 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10085 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10086 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10087 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10088 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10089 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10090 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10094 Elf64_External_Ehdr ehdr64
;
10096 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10097 we will not be able to cope with the 64bit data found in
10098 64 ELF files. Detect this now and abort before we start
10099 overwritting things. */
10100 if (sizeof (bfd_vma
) < 8)
10102 error (_("This instance of readelf has been built without support for a\n\
10103 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10107 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10110 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10111 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10112 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10113 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10114 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10115 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10116 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10117 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10118 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10119 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10120 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10121 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10122 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10125 if (elf_header
.e_shoff
)
10127 /* There may be some extensions in the first section header. Don't
10128 bomb if we can't read it. */
10130 get_32bit_section_headers (file
, 1);
10132 get_64bit_section_headers (file
, 1);
10139 process_file (file_name
)
10143 struct stat statbuf
;
10146 if (stat (file_name
, & statbuf
) < 0)
10148 error (_("Cannot stat input file %s.\n"), file_name
);
10152 file
= fopen (file_name
, "rb");
10155 error (_("Input file %s not found.\n"), file_name
);
10159 if (! get_file_header (file
))
10161 error (_("%s: Failed to read file header\n"), file_name
);
10166 /* Initialise per file variables. */
10167 for (i
= NUM_ELEM (version_info
); i
--;)
10168 version_info
[i
] = 0;
10170 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10171 dynamic_info
[i
] = 0;
10173 /* Process the file. */
10175 printf (_("\nFile: %s\n"), file_name
);
10177 if (! process_file_header ())
10183 if (! process_section_headers (file
))
10185 /* Without loaded section headers we
10186 cannot process lots of things. */
10187 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10189 if (! do_using_dynamic
)
10190 do_syms
= do_reloc
= 0;
10193 if (process_program_headers (file
))
10194 process_dynamic_segment (file
);
10196 process_relocs (file
);
10198 process_unwind (file
);
10200 process_symbol_table (file
);
10202 process_syminfo (file
);
10204 process_version_sections (file
);
10206 process_section_contents (file
);
10208 process_corefile_contents (file
);
10210 process_gnu_liblist (file
);
10212 process_arch_specific (file
);
10216 if (section_headers
)
10218 free (section_headers
);
10219 section_headers
= NULL
;
10224 free (string_table
);
10225 string_table
= NULL
;
10226 string_table_length
= 0;
10229 if (dynamic_strings
)
10231 free (dynamic_strings
);
10232 dynamic_strings
= NULL
;
10235 if (dynamic_symbols
)
10237 free (dynamic_symbols
);
10238 dynamic_symbols
= NULL
;
10239 num_dynamic_syms
= 0;
10242 if (dynamic_syminfo
)
10244 free (dynamic_syminfo
);
10245 dynamic_syminfo
= NULL
;
10251 #ifdef SUPPORT_DISASSEMBLY
10252 /* Needed by the i386 disassembler. For extra credit, someone could
10253 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10257 print_address (unsigned int addr
, FILE *outfile
)
10259 fprintf (outfile
,"0x%8.8x", addr
);
10262 /* Needed by the i386 disassembler. */
10264 db_task_printsym (unsigned int addr
)
10266 print_address (addr
, stderr
);
10270 int main
PARAMS ((int, char **));
10278 char *cmdline_dump_sects
= NULL
;
10279 unsigned num_cmdline_dump_sects
= 0;
10281 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10282 setlocale (LC_MESSAGES
, "");
10284 #if defined (HAVE_SETLOCALE)
10285 setlocale (LC_CTYPE
, "");
10287 bindtextdomain (PACKAGE
, LOCALEDIR
);
10288 textdomain (PACKAGE
);
10290 parse_args (argc
, argv
);
10292 if (optind
< (argc
- 1))
10295 /* When processing more than one file remember the dump requests
10296 issued on command line to reset them after each file. */
10297 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
10299 cmdline_dump_sects
= malloc (num_dump_sects
);
10300 if (cmdline_dump_sects
== NULL
)
10301 error (_("Out of memory allocating dump request table."));
10304 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
10305 num_cmdline_dump_sects
= num_dump_sects
;
10310 while (optind
< argc
)
10312 err
|= process_file (argv
[optind
++]);
10314 /* Reset dump requests. */
10315 if (optind
< argc
&& dump_sects
!= NULL
)
10317 num_dump_sects
= num_cmdline_dump_sects
;
10318 if (num_cmdline_dump_sects
> 0)
10319 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
10323 if (dump_sects
!= NULL
)
10325 if (cmdline_dump_sects
!= NULL
)
10326 free (cmdline_dump_sects
);