1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 99, 2000 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we belive that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
56 #include "elf/alpha.h"
59 #include "elf/sparc.h"
64 #include "elf/mn10200.h"
65 #include "elf/mn10300.h"
69 #include "elf/mcore.h"
78 char * program_name
= "readelf";
79 unsigned int dynamic_addr
;
80 bfd_size_type dynamic_size
;
81 unsigned int rela_addr
;
82 unsigned int rela_size
;
83 char * dynamic_strings
;
85 unsigned long num_dynamic_syms
;
86 Elf_Internal_Sym
* dynamic_symbols
;
87 Elf_Internal_Syminfo
* dynamic_syminfo
;
88 unsigned long dynamic_syminfo_offset
;
89 unsigned int dynamic_syminfo_nent
;
90 char program_interpreter
[64];
91 int dynamic_info
[DT_JMPREL
+ 1];
94 Elf_Internal_Ehdr elf_header
;
95 Elf_Internal_Shdr
* section_headers
;
96 Elf_Internal_Dyn
* dynamic_segment
;
103 int do_using_dynamic
;
110 int do_debug_abbrevs
;
112 int do_debug_pubnames
;
113 int do_debug_aranges
;
118 /* A dynamic array of flags indicating which sections require dumping. */
119 char * dump_sects
= NULL
;
120 unsigned int num_dump_sects
= 0;
122 #define HEX_DUMP (1 << 0)
123 #define DISASS_DUMP (1 << 1)
124 #define DEBUG_DUMP (1 << 2)
126 /* How to rpint a vma value. */
127 typedef enum print_mode
139 /* Forward declarations for dumb compilers. */
140 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
141 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
142 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
143 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
144 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
145 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
146 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
147 static const char * get_dynamic_type
PARAMS ((unsigned long));
148 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
149 static char * get_file_type
PARAMS ((unsigned));
150 static char * get_machine_name
PARAMS ((unsigned));
151 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
152 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
153 static const char * get_mips_segment_type
PARAMS ((unsigned long));
154 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
155 static const char * get_segment_type
PARAMS ((unsigned long));
156 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
157 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
158 static const char * get_section_type_name
PARAMS ((unsigned int));
159 static const char * get_symbol_binding
PARAMS ((unsigned int));
160 static const char * get_symbol_type
PARAMS ((unsigned int));
161 static const char * get_symbol_visibility
PARAMS ((unsigned int));
162 static const char * get_symbol_index_type
PARAMS ((unsigned int));
163 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
164 static void usage
PARAMS ((void));
165 static void parse_args
PARAMS ((int, char **));
166 static int process_file_header
PARAMS ((void));
167 static int process_program_headers
PARAMS ((FILE *));
168 static int process_section_headers
PARAMS ((FILE *));
169 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
170 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
171 static int process_dynamic_segment
PARAMS ((FILE *));
172 static int process_symbol_table
PARAMS ((FILE *));
173 static int process_section_contents
PARAMS ((FILE *));
174 static void process_file
PARAMS ((char *));
175 static int process_relocs
PARAMS ((FILE *));
176 static int process_version_sections
PARAMS ((FILE *));
177 static char * get_ver_flags
PARAMS ((unsigned int));
178 static int get_32bit_section_headers
PARAMS ((FILE *));
179 static int get_64bit_section_headers
PARAMS ((FILE *));
180 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
181 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
182 static int get_file_header
PARAMS ((FILE *));
183 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
184 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
185 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
186 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
187 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
188 #ifdef SUPPORT_DISASSEMBLY
189 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
191 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
192 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
193 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
194 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
195 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
196 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
197 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
198 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
199 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
200 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
201 static void reset_state_machine
PARAMS ((int));
202 static char * get_TAG_name
PARAMS ((unsigned long));
203 static char * get_AT_name
PARAMS ((unsigned long));
204 static char * get_FORM_name
PARAMS ((unsigned long));
205 static void free_abbrevs
PARAMS ((void));
206 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
207 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
208 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
209 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
210 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
211 static void request_dump
PARAMS ((unsigned int, char));
212 static const char * get_elf_class
PARAMS ((unsigned char));
213 static const char * get_data_encoding
PARAMS ((unsigned char));
214 static const char * get_osabi_name
PARAMS ((unsigned char));
215 static int guess_is_rela
PARAMS ((unsigned long));
216 static char * get_note_type
PARAMS ((unsigned int));
217 static int process_note
PARAMS ((Elf32_Internal_Note
*));
218 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
219 static int process_corefile_note_segments
PARAMS ((FILE *));
220 static int process_corefile_contents
PARAMS ((FILE *));
222 typedef int Elf32_Word
;
230 #define SECTION_NAME(X) (string_table + (X)->sh_name)
232 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
234 #define BYTE_GET(field) byte_get (field, sizeof (field))
236 /* If we can support a 64 bit data type then BFD64 should be defined
237 and sizeof (bfd_vma) == 8. In this case when translating from an
238 external 8 byte field to an internal field, we can assume that the
239 internal field is also 8 bytes wide and so we can extact all the data.
240 If, however, BFD64 is not defined, then we must assume that the
241 internal data structure only has 4 byte wide fields that are the
242 equivalent of the 8 byte wide external counterparts, and so we must
243 truncate the data. */
245 #define BYTE_GET8(field) byte_get (field, -8)
247 #define BYTE_GET8(field) byte_get (field, 8)
250 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
252 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
253 if (fseek (file, offset, SEEK_SET)) \
255 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
259 var = (type) malloc (size); \
263 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
267 if (fread (var, size, 1, file) != 1) \
269 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
276 #define GET_DATA(offset, var, reason) \
277 if (fseek (file, offset, SEEK_SET)) \
279 error (_("Unable to seek to %x for %s\n"), offset, reason); \
282 else if (fread (& var, sizeof (var), 1, file) != 1) \
284 error (_("Unable to read data at %x for %s\n"), offset, reason); \
288 #define GET_ELF_SYMBOLS(file, offset, size) \
289 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
290 : get_64bit_elf_symbols (file, offset, size))
293 #ifdef ANSI_PROTOTYPES
295 error (const char * message
, ...)
299 fprintf (stderr
, _("%s: Error: "), program_name
);
300 va_start (args
, message
);
301 vfprintf (stderr
, message
, args
);
307 warn (const char * message
, ...)
311 fprintf (stderr
, _("%s: Warning: "), program_name
);
312 va_start (args
, message
);
313 vfprintf (stderr
, message
, args
);
325 fprintf (stderr
, _("%s: Error: "), program_name
);
327 message
= va_arg (args
, char *);
328 vfprintf (stderr
, message
, args
);
340 fprintf (stderr
, _("%s: Warning: "), program_name
);
342 message
= va_arg (args
, char *);
343 vfprintf (stderr
, message
, args
);
350 byte_get_little_endian (field
, size
)
351 unsigned char * field
;
360 return ((unsigned int) (field
[0]))
361 | (((unsigned int) (field
[1])) << 8);
364 /* We want to extract data from an 8 byte wide field and
365 place it into a 4 byte wide field. Since this is a little
366 endian source we can juts use the 4 byte extraction code. */
369 return ((unsigned long) (field
[0]))
370 | (((unsigned long) (field
[1])) << 8)
371 | (((unsigned long) (field
[2])) << 16)
372 | (((unsigned long) (field
[3])) << 24);
376 /* This is a special case, generated by the BYTE_GET8 macro.
377 It means that we are loading an 8 byte value from a field
378 in an external structure into an 8 byte value in a field
379 in an internal strcuture. */
380 return ((bfd_vma
) (field
[0]))
381 | (((bfd_vma
) (field
[1])) << 8)
382 | (((bfd_vma
) (field
[2])) << 16)
383 | (((bfd_vma
) (field
[3])) << 24)
384 | (((bfd_vma
) (field
[4])) << 32)
385 | (((bfd_vma
) (field
[5])) << 40)
386 | (((bfd_vma
) (field
[6])) << 48)
387 | (((bfd_vma
) (field
[7])) << 56);
390 error (_("Unhandled data length: %d\n"), size
);
395 /* Print a VMA value. */
397 print_vma (vma
, mode
)
407 case FULL_HEX
: printf ("0x"); /* drop through */
408 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
409 case PREFIX_HEX
: printf ("0x"); /* drop through */
410 case HEX
: printf ("%lx", (unsigned long) vma
); break;
411 case DEC
: printf ("%ld", (unsigned long) vma
); break;
412 case DEC_5
: printf ("%5ld", (long) vma
); break;
413 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
434 #if BFD_HOST_64BIT_LONG
437 if (_bfd_int64_high (vma
))
438 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
440 printf ("%lx", _bfd_int64_low (vma
));
445 #if BFD_HOST_64BIT_LONG
448 if (_bfd_int64_high (vma
))
450 printf ("++%ld", _bfd_int64_low (vma
));
452 printf ("%ld", _bfd_int64_low (vma
));
457 #if BFD_HOST_64BIT_LONG
458 printf ("%5ld", vma
);
460 if (_bfd_int64_high (vma
))
462 printf ("++%ld", _bfd_int64_low (vma
));
464 printf ("%5ld", _bfd_int64_low (vma
));
469 #if BFD_HOST_64BIT_LONG
472 if (_bfd_int64_high (vma
))
474 printf ("++%lu", _bfd_int64_low (vma
));
476 printf ("%lu", _bfd_int64_low (vma
));
485 byte_get_big_endian (field
, size
)
486 unsigned char * field
;
495 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
498 return ((unsigned long) (field
[3]))
499 | (((unsigned long) (field
[2])) << 8)
500 | (((unsigned long) (field
[1])) << 16)
501 | (((unsigned long) (field
[0])) << 24);
504 /* Although we are extracing data from an 8 byte wide field, we
505 are returning only 4 bytes of data. */
506 return ((unsigned long) (field
[7]))
507 | (((unsigned long) (field
[6])) << 8)
508 | (((unsigned long) (field
[5])) << 16)
509 | (((unsigned long) (field
[4])) << 24);
513 /* This is a special case, generated by the BYTE_GET8 macro.
514 It means that we are loading an 8 byte value from a field
515 in an external structure into an 8 byte value in a field
516 in an internal strcuture. */
517 return ((bfd_vma
) (field
[7]))
518 | (((bfd_vma
) (field
[6])) << 8)
519 | (((bfd_vma
) (field
[5])) << 16)
520 | (((bfd_vma
) (field
[4])) << 24)
521 | (((bfd_vma
) (field
[3])) << 32)
522 | (((bfd_vma
) (field
[2])) << 40)
523 | (((bfd_vma
) (field
[1])) << 48)
524 | (((bfd_vma
) (field
[0])) << 56);
528 error (_("Unhandled data length: %d\n"), size
);
534 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
536 guess_is_rela (e_machine
)
537 unsigned long e_machine
;
541 /* Targets that use REL relocations. */
552 /* Targets that use RELA relocations. */
560 case EM_CYGNUS_MN10200
:
561 case EM_CYGNUS_MN10300
:
589 warn (_("Don't know about relocations on this machine architecture\n"));
594 /* Display the contents of the relocation data found at the specified offset. */
596 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
598 unsigned long rel_offset
;
599 unsigned long rel_size
;
600 Elf_Internal_Sym
* symtab
;
606 Elf_Internal_Rel
* rels
;
607 Elf_Internal_Rela
* relas
;
610 if (is_rela
== UNKNOWN
)
611 is_rela
= guess_is_rela (elf_header
.e_machine
);
617 Elf32_External_Rela
* erelas
;
619 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
620 Elf32_External_Rela
*, "relocs");
622 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
624 relas
= (Elf_Internal_Rela
*)
625 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
629 error(_("out of memory parsing relocs"));
633 for (i
= 0; i
< rel_size
; i
++)
635 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
636 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
637 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
642 rels
= (Elf_Internal_Rel
*) relas
;
646 Elf64_External_Rela
* erelas
;
648 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
649 Elf64_External_Rela
*, "relocs");
651 rel_size
= rel_size
/ sizeof (Elf64_External_Rela
);
653 relas
= (Elf_Internal_Rela
*)
654 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
658 error(_("out of memory parsing relocs"));
662 for (i
= 0; i
< rel_size
; i
++)
664 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
665 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
666 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
671 rels
= (Elf_Internal_Rel
*) relas
;
678 Elf32_External_Rel
* erels
;
680 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
681 Elf32_External_Rel
*, "relocs");
683 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
685 rels
= (Elf_Internal_Rel
*)
686 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
690 error(_("out of memory parsing relocs"));
694 for (i
= 0; i
< rel_size
; i
++)
696 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
697 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
702 relas
= (Elf_Internal_Rela
*) rels
;
706 Elf64_External_Rel
* erels
;
708 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
709 Elf64_External_Rel
*, "relocs");
711 rel_size
= rel_size
/ sizeof (Elf64_External_Rel
);
713 rels
= (Elf_Internal_Rel
*)
714 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
718 error(_("out of memory parsing relocs"));
722 for (i
= 0; i
< rel_size
; i
++)
724 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
725 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
730 relas
= (Elf_Internal_Rela
*) rels
;
736 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
739 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
741 for (i
= 0; i
< rel_size
; i
++)
746 bfd_vma symtab_index
;
751 offset
= relas
[i
].r_offset
;
752 info
= relas
[i
].r_info
;
756 offset
= rels
[i
].r_offset
;
757 info
= rels
[i
].r_info
;
762 type
= ELF32_R_TYPE (info
);
763 symtab_index
= ELF32_R_SYM (info
);
767 if (elf_header
.e_machine
== EM_SPARCV9
)
768 type
= ELF64_R_TYPE_ID (info
);
770 type
= ELF64_R_TYPE (info
);
771 /* The #ifdef BFD64 below is to prevent a compile time warning.
772 We know that if we do not have a 64 bit data type that we
773 will never execute this code anyway. */
775 symtab_index
= ELF64_R_SYM (info
);
779 #ifdef _bfd_int64_low
780 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
782 printf (" %8.8lx %5.5lx ", offset
, info
);
785 switch (elf_header
.e_machine
)
792 rtype
= elf_m32r_reloc_type (type
);
797 rtype
= elf_i386_reloc_type (type
);
801 rtype
= elf_m68k_reloc_type (type
);
805 rtype
= elf_i960_reloc_type (type
);
809 rtype
= elf_avr_reloc_type (type
);
816 rtype
= elf_sparc_reloc_type (type
);
820 rtype
= v850_reloc_type (type
);
824 rtype
= elf_d10v_reloc_type (type
);
828 rtype
= elf_d30v_reloc_type (type
);
832 rtype
= elf_sh_reloc_type (type
);
835 case EM_CYGNUS_MN10300
:
836 rtype
= elf_mn10300_reloc_type (type
);
839 case EM_CYGNUS_MN10200
:
840 rtype
= elf_mn10200_reloc_type (type
);
844 rtype
= elf_fr30_reloc_type (type
);
848 rtype
= elf_mcore_reloc_type (type
);
852 rtype
= elf_ppc_reloc_type (type
);
857 rtype
= elf_mips_reloc_type (type
);
861 rtype
= elf_alpha_reloc_type (type
);
865 rtype
= elf_arm_reloc_type (type
);
869 rtype
= elf_arc_reloc_type (type
);
873 rtype
= elf_hppa_reloc_type (type
);
877 rtype
= elf_pj_reloc_type (type
);
880 rtype
= elf_ia64_reloc_type (type
);
885 #ifdef _bfd_int64_low
886 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
888 printf (_("unrecognised: %-7lx"), type
);
891 printf ("%-21.21s", rtype
);
897 if (symtab_index
>= nsyms
)
898 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
901 Elf_Internal_Sym
* psym
;
903 psym
= symtab
+ symtab_index
;
906 print_vma (psym
->st_value
, LONG_HEX
);
909 if (psym
->st_name
== 0)
911 SECTION_NAME (section_headers
+ psym
->st_shndx
));
912 else if (strtab
== NULL
)
913 printf (_("<string table index %3ld>"), psym
->st_name
);
915 printf ("%-25.25s", strtab
+ psym
->st_name
);
918 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
924 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
925 print_vma (relas
[i
].r_addend
, LONG_HEX
);
928 if (elf_header
.e_machine
== EM_SPARCV9
929 && !strcmp (rtype
, "R_SPARC_OLO10"))
930 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
941 get_mips_dynamic_type (type
)
946 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
947 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
948 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
949 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
950 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
951 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
952 case DT_MIPS_MSYM
: return "MIPS_MSYM";
953 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
954 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
955 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
956 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
957 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
958 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
959 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
960 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
961 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
962 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
963 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
964 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
965 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
966 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
967 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
968 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
969 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
970 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
971 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
972 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
973 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
974 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
975 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
976 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
977 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
978 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
979 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
980 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
981 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
982 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
983 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
984 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
985 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
986 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
987 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
988 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
995 get_sparc64_dynamic_type (type
)
1000 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1007 get_parisc_dynamic_type (type
)
1012 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1013 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1014 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1015 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1016 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1017 case DT_HP_PREINIT
: return "HP_PREINIT";
1018 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1019 case DT_HP_NEEDED
: return "HP_NEEDED";
1020 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1021 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1022 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1023 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1024 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1031 get_dynamic_type (type
)
1034 static char buff
[32];
1038 case DT_NULL
: return "NULL";
1039 case DT_NEEDED
: return "NEEDED";
1040 case DT_PLTRELSZ
: return "PLTRELSZ";
1041 case DT_PLTGOT
: return "PLTGOT";
1042 case DT_HASH
: return "HASH";
1043 case DT_STRTAB
: return "STRTAB";
1044 case DT_SYMTAB
: return "SYMTAB";
1045 case DT_RELA
: return "RELA";
1046 case DT_RELASZ
: return "RELASZ";
1047 case DT_RELAENT
: return "RELAENT";
1048 case DT_STRSZ
: return "STRSZ";
1049 case DT_SYMENT
: return "SYMENT";
1050 case DT_INIT
: return "INIT";
1051 case DT_FINI
: return "FINI";
1052 case DT_SONAME
: return "SONAME";
1053 case DT_RPATH
: return "RPATH";
1054 case DT_SYMBOLIC
: return "SYMBOLIC";
1055 case DT_REL
: return "REL";
1056 case DT_RELSZ
: return "RELSZ";
1057 case DT_RELENT
: return "RELENT";
1058 case DT_PLTREL
: return "PLTREL";
1059 case DT_DEBUG
: return "DEBUG";
1060 case DT_TEXTREL
: return "TEXTREL";
1061 case DT_JMPREL
: return "JMPREL";
1062 case DT_BIND_NOW
: return "BIND_NOW";
1063 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1064 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1065 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1066 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1067 case DT_RUNPATH
: return "RUNPATH";
1068 case DT_FLAGS
: return "FLAGS";
1070 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1071 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1073 case DT_PLTPADSZ
: return "PLTPADSZ";
1074 case DT_MOVEENT
: return "MOVEENT";
1075 case DT_MOVESZ
: return "MOVESZ";
1076 case DT_FEATURE
: return "FEATURE";
1077 case DT_POSFLAG_1
: return "POSFLAG_1";
1078 case DT_SYMINSZ
: return "SYMINSZ";
1079 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1081 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1082 case DT_CONFIG
: return "CONFIG";
1083 case DT_DEPAUDIT
: return "DEPAUDIT";
1084 case DT_AUDIT
: return "AUDIT";
1085 case DT_PLTPAD
: return "PLTPAD";
1086 case DT_MOVETAB
: return "MOVETAB";
1087 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1089 case DT_VERSYM
: return "VERSYM";
1091 case DT_RELACOUNT
: return "RELACOUNT";
1092 case DT_RELCOUNT
: return "RELCOUNT";
1093 case DT_FLAGS_1
: return "FLAGS_1";
1094 case DT_VERDEF
: return "VERDEF";
1095 case DT_VERDEFNUM
: return "VERDEFNUM";
1096 case DT_VERNEED
: return "VERNEED";
1097 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1099 case DT_AUXILIARY
: return "AUXILARY";
1100 case DT_USED
: return "USED";
1101 case DT_FILTER
: return "FILTER";
1103 #if DT_CHECKSUM != 0
1104 case DT_CHECKSUM
: return "CHECKSUM";
1108 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1110 const char * result
;
1112 switch (elf_header
.e_machine
)
1115 case EM_MIPS_RS4_BE
:
1116 result
= get_mips_dynamic_type (type
);
1119 result
= get_sparc64_dynamic_type (type
);
1129 sprintf (buff
, _("Processor Specific: %lx"), type
);
1131 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1133 const char * result
;
1135 switch (elf_header
.e_machine
)
1138 result
= get_parisc_dynamic_type (type
);
1148 sprintf (buff
, _("Operating System specific: %lx"), type
);
1151 sprintf (buff
, _("<unknown>: %lx"), type
);
1158 get_file_type (e_type
)
1161 static char buff
[32];
1165 case ET_NONE
: return _("NONE (None)");
1166 case ET_REL
: return _("REL (Relocatable file)");
1167 case ET_EXEC
: return _("EXEC (Executable file)");
1168 case ET_DYN
: return _("DYN (Shared object file)");
1169 case ET_CORE
: return _("CORE (Core file)");
1172 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1173 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1174 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1175 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1177 sprintf (buff
, _("<unknown>: %x"), e_type
);
1183 get_machine_name (e_machine
)
1186 static char buff
[64]; /* XXX */
1190 case EM_NONE
: return _("None");
1191 case EM_M32
: return "WE32100";
1192 case EM_SPARC
: return "Sparc";
1193 case EM_386
: return "Intel 80386";
1194 case EM_68K
: return "MC68000";
1195 case EM_88K
: return "MC88000";
1196 case EM_486
: return "Intel 80486";
1197 case EM_860
: return "Intel 80860";
1198 case EM_MIPS
: return "MIPS R3000";
1199 case EM_S370
: return "IBM System/370";
1200 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1201 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1202 case EM_PARISC
: return "HPPA";
1203 case EM_PPC_OLD
: return "Power PC (old)";
1204 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1205 case EM_960
: return "Intel 90860";
1206 case EM_PPC
: return "PowerPC";
1207 case EM_V800
: return "NEC V800";
1208 case EM_FR20
: return "Fujitsu FR20";
1209 case EM_RH32
: return "TRW RH32";
1210 case EM_MCORE
: return "MCORE";
1211 case EM_ARM
: return "ARM";
1212 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1213 case EM_SH
: return "Hitachi SH";
1214 case EM_SPARCV9
: return "Sparc v9";
1215 case EM_TRICORE
: return "Siemens Tricore";
1216 case EM_ARC
: return "Argonaut RISC Core";
1217 case EM_H8_300
: return "Hitachi H8/300";
1218 case EM_H8_300H
: return "Hitachi H8/300H";
1219 case EM_H8S
: return "Hitachi H8S";
1220 case EM_H8_500
: return "Hitachi H8/500";
1221 case EM_IA_64
: return "Intel IA-64";
1222 case EM_MIPS_X
: return "Stanford MIPS-X";
1223 case EM_COLDFIRE
: return "Motorola Coldfire";
1224 case EM_68HC12
: return "Motorola M68HC12";
1225 case EM_ALPHA
: return "Alpha";
1226 case EM_CYGNUS_D10V
: return "d10v";
1227 case EM_CYGNUS_D30V
: return "d30v";
1228 case EM_CYGNUS_ARC
: return "Arc";
1229 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1230 case EM_CYGNUS_V850
: return "NEC v850";
1231 case EM_CYGNUS_MN10300
: return "mn10300";
1232 case EM_CYGNUS_MN10200
: return "mn10200";
1233 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1234 case EM_PJ
: return "picoJava";
1235 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1236 case EM_PCP
: return "Siemens PCP";
1237 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1238 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1239 case EM_STARCORE
: return "Motorola Star*Core processor";
1240 case EM_ME16
: return "Toyota ME16 processor";
1241 case EM_ST100
: return "STMicroelectronics ST100 processor";
1242 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1243 case EM_FX66
: return "Siemens FX66 microcontroller";
1244 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1245 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1246 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1247 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1248 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1249 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1250 case EM_SVX
: return "Silicon Graphics SVx";
1251 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1252 case EM_VAX
: return "Digital VAX";
1253 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1255 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1261 decode_ARM_machine_flags (e_flags
, buf
)
1268 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1269 e_flags
&= ~ EF_ARM_EABIMASK
;
1271 /* Handle "generic" ARM flags. */
1272 if (e_flags
& EF_ARM_RELEXEC
)
1274 strcat (buf
, ", relocatable executable");
1275 e_flags
&= ~ EF_ARM_RELEXEC
;
1278 if (e_flags
& EF_ARM_HASENTRY
)
1280 strcat (buf
, ", has entry point");
1281 e_flags
&= ~ EF_ARM_HASENTRY
;
1284 /* Now handle EABI specific flags. */
1288 strcat (buf
, ", <unknown EABI>");
1293 case EF_ARM_EABI_VER1
:
1298 /* Process flags one bit at a time. */
1299 flag
= e_flags
& - e_flags
;
1304 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_INTERWORK. */
1305 strcat (buf
, ", sorted symbol tables");
1315 case EF_ARM_EABI_UNKNOWN
:
1320 /* Process flags one bit at a time. */
1321 flag
= e_flags
& - e_flags
;
1327 strcat (buf
, ", interworking enabled");
1331 strcat (buf
, ", uses APCS/26");
1335 strcat (buf
, ", uses APCS/float");
1339 strcat (buf
, ", position independent");
1343 strcat (buf
, ", 8 bit structure alignment");
1347 strcat (buf
, ", uses new ABI");
1351 strcat (buf
, ", uses old ABI");
1355 strcat (buf
, ", software FP");
1366 strcat (buf
,", <unknown>");
1370 get_machine_flags (e_flags
, e_machine
)
1374 static char buf
[1024];
1386 decode_ARM_machine_flags (e_flags
, buf
);
1390 if (e_flags
& EF_CPU32
)
1391 strcat (buf
, ", cpu32");
1395 if (e_flags
& EF_PPC_EMB
)
1396 strcat (buf
, ", emb");
1398 if (e_flags
& EF_PPC_RELOCATABLE
)
1399 strcat (buf
, ", relocatable");
1401 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1402 strcat (buf
, ", relocatable-lib");
1405 case EM_CYGNUS_V850
:
1406 switch (e_flags
& EF_V850_ARCH
)
1409 strcat (buf
, ", v850e");
1412 strcat (buf
, ", v850ea");
1415 strcat (buf
, ", v850");
1418 strcat (buf
, ", unknown v850 architecture variant");
1423 case EM_CYGNUS_M32R
:
1424 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1425 strcat (buf
, ", m32r");
1430 case EM_MIPS_RS4_BE
:
1431 if (e_flags
& EF_MIPS_NOREORDER
)
1432 strcat (buf
, ", noreorder");
1434 if (e_flags
& EF_MIPS_PIC
)
1435 strcat (buf
, ", pic");
1437 if (e_flags
& EF_MIPS_CPIC
)
1438 strcat (buf
, ", cpic");
1440 if (e_flags
& EF_MIPS_ABI2
)
1441 strcat (buf
, ", abi2");
1443 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1444 strcat (buf
, ", mips1");
1446 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1447 strcat (buf
, ", mips2");
1449 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1450 strcat (buf
, ", mips3");
1452 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1453 strcat (buf
, ", mips4");
1457 if (e_flags
& EF_SPARC_32PLUS
)
1458 strcat (buf
, ", v8+");
1460 if (e_flags
& EF_SPARC_SUN_US1
)
1461 strcat (buf
, ", ultrasparcI");
1463 if (e_flags
& EF_SPARC_SUN_US3
)
1464 strcat (buf
, ", ultrasparcIII");
1466 if (e_flags
& EF_SPARC_HAL_R1
)
1467 strcat (buf
, ", halr1");
1469 if (e_flags
& EF_SPARC_LEDATA
)
1470 strcat (buf
, ", ledata");
1472 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1473 strcat (buf
, ", tso");
1475 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1476 strcat (buf
, ", pso");
1478 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1479 strcat (buf
, ", rmo");
1483 switch (e_flags
& EF_PARISC_ARCH
)
1485 case EFA_PARISC_1_0
:
1486 strcpy (buf
, ", PA-RISC 1.0");
1488 case EFA_PARISC_1_1
:
1489 strcpy (buf
, ", PA-RISC 1.1");
1491 case EFA_PARISC_2_0
:
1492 strcpy (buf
, ", PA-RISC 2.0");
1497 if (e_flags
& EF_PARISC_TRAPNIL
)
1498 strcat (buf
, ", trapnil");
1499 if (e_flags
& EF_PARISC_EXT
)
1500 strcat (buf
, ", ext");
1501 if (e_flags
& EF_PARISC_LSB
)
1502 strcat (buf
, ", lsb");
1503 if (e_flags
& EF_PARISC_WIDE
)
1504 strcat (buf
, ", wide");
1505 if (e_flags
& EF_PARISC_NO_KABP
)
1506 strcat (buf
, ", no kabp");
1507 if (e_flags
& EF_PARISC_LAZYSWAP
)
1508 strcat (buf
, ", lazyswap");
1512 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1513 strcat (buf
, ", new calling convention");
1515 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1516 strcat (buf
, ", gnu calling convention");
1525 get_mips_segment_type (type
)
1530 case PT_MIPS_REGINFO
:
1532 case PT_MIPS_RTPROC
:
1534 case PT_MIPS_OPTIONS
:
1544 get_parisc_segment_type (type
)
1549 case PT_HP_TLS
: return "HP_TLS";
1550 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1551 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1552 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1553 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1554 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1555 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1556 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1557 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1558 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1559 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1560 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1561 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1562 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1571 get_segment_type (p_type
)
1572 unsigned long p_type
;
1574 static char buff
[32];
1578 case PT_NULL
: return "NULL";
1579 case PT_LOAD
: return "LOAD";
1580 case PT_DYNAMIC
: return "DYNAMIC";
1581 case PT_INTERP
: return "INTERP";
1582 case PT_NOTE
: return "NOTE";
1583 case PT_SHLIB
: return "SHLIB";
1584 case PT_PHDR
: return "PHDR";
1587 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1589 const char * result
;
1591 switch (elf_header
.e_machine
)
1594 case EM_MIPS_RS4_BE
:
1595 result
= get_mips_segment_type (p_type
);
1598 result
= get_parisc_segment_type (p_type
);
1608 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1610 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1612 const char * result
;
1614 switch (elf_header
.e_machine
)
1617 result
= get_parisc_segment_type (p_type
);
1627 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1630 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1637 get_mips_section_type_name (sh_type
)
1638 unsigned int sh_type
;
1642 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1643 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1644 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1645 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1646 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1647 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1648 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1649 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1650 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1651 case SHT_MIPS_RELD
: return "MIPS_RELD";
1652 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1653 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1654 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1655 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1656 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1657 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1658 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1659 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1660 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1661 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1662 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1663 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1664 case SHT_MIPS_LINE
: return "MIPS_LINE";
1665 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1666 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1667 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1668 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1669 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1670 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1671 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1672 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1673 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1674 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1675 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1676 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1677 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1678 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1679 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1680 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1688 get_parisc_section_type_name (sh_type
)
1689 unsigned int sh_type
;
1693 case SHT_PARISC_EXT
: return "PARISC_EXT";
1694 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1695 case SHT_PARISC_DOC
: return "PARISC_DOC";
1703 get_section_type_name (sh_type
)
1704 unsigned int sh_type
;
1706 static char buff
[32];
1710 case SHT_NULL
: return "NULL";
1711 case SHT_PROGBITS
: return "PROGBITS";
1712 case SHT_SYMTAB
: return "SYMTAB";
1713 case SHT_STRTAB
: return "STRTAB";
1714 case SHT_RELA
: return "RELA";
1715 case SHT_HASH
: return "HASH";
1716 case SHT_DYNAMIC
: return "DYNAMIC";
1717 case SHT_NOTE
: return "NOTE";
1718 case SHT_NOBITS
: return "NOBITS";
1719 case SHT_REL
: return "REL";
1720 case SHT_SHLIB
: return "SHLIB";
1721 case SHT_DYNSYM
: return "DYNSYM";
1722 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1723 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1724 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1725 case SHT_GNU_verdef
: return "VERDEF";
1726 case SHT_GNU_verneed
: return "VERNEED";
1727 case SHT_GNU_versym
: return "VERSYM";
1728 case 0x6ffffff0: return "VERSYM";
1729 case 0x6ffffffc: return "VERDEF";
1730 case 0x7ffffffd: return "AUXILIARY";
1731 case 0x7fffffff: return "FILTER";
1734 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1736 const char * result
;
1738 switch (elf_header
.e_machine
)
1741 case EM_MIPS_RS4_BE
:
1742 result
= get_mips_section_type_name (sh_type
);
1745 result
= get_parisc_section_type_name (sh_type
);
1755 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1757 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1758 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1759 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1760 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1762 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1768 struct option options
[] =
1770 {"all", no_argument
, 0, 'a'},
1771 {"file-header", no_argument
, 0, 'h'},
1772 {"program-headers", no_argument
, 0, 'l'},
1773 {"headers", no_argument
, 0, 'e'},
1774 {"histogram", no_argument
, 0, 'I'},
1775 {"segments", no_argument
, 0, 'l'},
1776 {"sections", no_argument
, 0, 'S'},
1777 {"section-headers", no_argument
, 0, 'S'},
1778 {"symbols", no_argument
, 0, 's'},
1779 {"syms", no_argument
, 0, 's'},
1780 {"relocs", no_argument
, 0, 'r'},
1781 {"notes", no_argument
, 0, 'n'},
1782 {"dynamic", no_argument
, 0, 'd'},
1783 {"arch-specific", no_argument
, 0, 'A'},
1784 {"version-info", no_argument
, 0, 'V'},
1785 {"use-dynamic", no_argument
, 0, 'D'},
1786 {"hex-dump", required_argument
, 0, 'x'},
1787 {"debug-dump", optional_argument
, 0, 'w'},
1788 #ifdef SUPPORT_DISASSEMBLY
1789 {"instruction-dump", required_argument
, 0, 'i'},
1792 {"version", no_argument
, 0, 'v'},
1793 {"help", no_argument
, 0, 'H'},
1794 {0, no_argument
, 0, 0}
1800 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1801 fprintf (stdout
, _(" Options are:\n"));
1802 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1803 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1804 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1805 fprintf (stdout
, _(" Display the program headers\n"));
1806 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1807 fprintf (stdout
, _(" Display the sections' header\n"));
1808 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1809 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1810 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1811 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1812 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1813 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1814 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1815 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1816 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1817 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1818 fprintf (stdout
, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1819 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1820 #ifdef SUPPORT_DISASSEMBLY
1821 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1822 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1824 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1825 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1826 fprintf (stdout
, _(" -H or --help Display this information\n"));
1827 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
1833 request_dump (section
, type
)
1834 unsigned int section
;
1837 if (section
>= num_dump_sects
)
1839 char * new_dump_sects
;
1841 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1843 if (new_dump_sects
== NULL
)
1844 error (_("Out of memory allocating dump request table."));
1847 /* Copy current flag settings. */
1848 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1852 dump_sects
= new_dump_sects
;
1853 num_dump_sects
= section
+ 1;
1858 dump_sects
[section
] |= type
;
1864 parse_args (argc
, argv
)
1873 while ((c
= getopt_long
1874 (argc
, argv
, "ersahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
1909 do_using_dynamic
++;
1937 section
= strtoul (optarg
, & cp
, 0);
1938 if (! * cp
&& section
>= 0)
1940 request_dump (section
, HEX_DUMP
);
1960 do_debug_abbrevs
= 1;
1970 do_debug_pubnames
= 1;
1975 do_debug_aranges
= 1;
1979 warn (_("Unrecognised debug option '%s'\n"), optarg
);
1984 #ifdef SUPPORT_DISASSEMBLY
1987 section
= strtoul (optarg
, & cp
, 0);
1988 if (! * cp
&& section
>= 0)
1990 request_dump (section
, DISASS_DUMP
);
1996 print_version (program_name
);
2003 /* xgettext:c-format */
2004 error (_("Invalid option '-%c'\n"), c
);
2011 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
2012 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2013 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2017 warn (_("Nothing to do.\n"));
2023 get_elf_class (elf_class
)
2024 unsigned char elf_class
;
2026 static char buff
[32];
2030 case ELFCLASSNONE
: return _("none");
2031 case ELFCLASS32
: return _("ELF32");
2032 case ELFCLASS64
: return _("ELF64");
2034 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2040 get_data_encoding (encoding
)
2041 unsigned char encoding
;
2043 static char buff
[32];
2047 case ELFDATANONE
: return _("none");
2048 case ELFDATA2LSB
: return _("2's complement, little endian");
2049 case ELFDATA2MSB
: return _("2's complement, big endian");
2051 sprintf (buff
, _("<unknown: %x>"), encoding
);
2057 get_osabi_name (osabi
)
2058 unsigned char osabi
;
2060 static char buff
[32];
2064 case ELFOSABI_NONE
: return _("UNIX - System V");
2065 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
2066 case ELFOSABI_NETBSD
: return _("UNIX - NetBSD");
2067 case ELFOSABI_LINUX
: return _("UNIX - Linux");
2068 case ELFOSABI_HURD
: return _("GNU/Hurd");
2069 case ELFOSABI_SOLARIS
: return _("UNIX - Solaris");
2070 case ELFOSABI_MONTEREY
: return _("UNIX - Monterey");
2071 case ELFOSABI_IRIX
: return _("UNIX - IRIX");
2072 case ELFOSABI_FREEBSD
: return _("UNIX - FreeBSD");
2073 case ELFOSABI_TRU64
: return _("UNIX - TRU64");
2074 case ELFOSABI_MODESTO
: return _("Novell - Modesto");
2075 case ELFOSABI_OPENBSD
: return _("UNIX - OpenBSD");
2076 case ELFOSABI_STANDALONE
: return _("Standalone App");
2077 case ELFOSABI_ARM
: return _("ARM");
2079 sprintf (buff
, _("<unknown: %x>"), osabi
);
2084 /* Decode the data held in 'elf_header'. */
2086 process_file_header ()
2088 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2089 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2090 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2091 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2094 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2102 printf (_("ELF Header:\n"));
2103 printf (_(" Magic: "));
2104 for (i
= 0; i
< EI_NIDENT
; i
++)
2105 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2107 printf (_(" Class: %s\n"),
2108 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2109 printf (_(" Data: %s\n"),
2110 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2111 printf (_(" Version: %d %s\n"),
2112 elf_header
.e_ident
[EI_VERSION
],
2113 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2115 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2118 printf (_(" OS/ABI: %s\n"),
2119 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2120 printf (_(" ABI Version: %d\n"),
2121 elf_header
.e_ident
[EI_ABIVERSION
]);
2122 printf (_(" Type: %s\n"),
2123 get_file_type (elf_header
.e_type
));
2124 printf (_(" Machine: %s\n"),
2125 get_machine_name (elf_header
.e_machine
));
2126 printf (_(" Version: 0x%lx\n"),
2127 (unsigned long) elf_header
.e_version
);
2129 printf (_(" Entry point address: "));
2130 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2131 printf (_("\n Start of program headers: "));
2132 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2133 printf (_(" (bytes into file)\n Start of section headers: "));
2134 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2135 printf (_(" (bytes into file)\n"));
2137 printf (_(" Flags: 0x%lx%s\n"),
2138 (unsigned long) elf_header
.e_flags
,
2139 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2140 printf (_(" Size of this header: %ld (bytes)\n"),
2141 (long) elf_header
.e_ehsize
);
2142 printf (_(" Size of program headers: %ld (bytes)\n"),
2143 (long) elf_header
.e_phentsize
);
2144 printf (_(" Number of program headers: %ld\n"),
2145 (long) elf_header
.e_phnum
);
2146 printf (_(" Size of section headers: %ld (bytes)\n"),
2147 (long) elf_header
.e_shentsize
);
2148 printf (_(" Number of section headers: %ld\n"),
2149 (long) elf_header
.e_shnum
);
2150 printf (_(" Section header string table index: %ld\n"),
2151 (long) elf_header
.e_shstrndx
);
2159 get_32bit_program_headers (file
, program_headers
)
2161 Elf_Internal_Phdr
* program_headers
;
2163 Elf32_External_Phdr
* phdrs
;
2164 Elf32_External_Phdr
* external
;
2165 Elf32_Internal_Phdr
* internal
;
2168 GET_DATA_ALLOC (elf_header
.e_phoff
,
2169 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2170 phdrs
, Elf32_External_Phdr
*, "program headers");
2172 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2173 i
< elf_header
.e_phnum
;
2174 i
++, internal
++, external
++)
2176 internal
->p_type
= BYTE_GET (external
->p_type
);
2177 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2178 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2179 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2180 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2181 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2182 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2183 internal
->p_align
= BYTE_GET (external
->p_align
);
2192 get_64bit_program_headers (file
, program_headers
)
2194 Elf_Internal_Phdr
* program_headers
;
2196 Elf64_External_Phdr
* phdrs
;
2197 Elf64_External_Phdr
* external
;
2198 Elf64_Internal_Phdr
* internal
;
2201 GET_DATA_ALLOC (elf_header
.e_phoff
,
2202 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2203 phdrs
, Elf64_External_Phdr
*, "program headers");
2205 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2206 i
< elf_header
.e_phnum
;
2207 i
++, internal
++, external
++)
2209 internal
->p_type
= BYTE_GET (external
->p_type
);
2210 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2211 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2212 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2213 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2214 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2215 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2216 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2225 process_program_headers (file
)
2228 Elf_Internal_Phdr
* program_headers
;
2229 Elf_Internal_Phdr
* segment
;
2232 if (elf_header
.e_phnum
== 0)
2235 printf (_("\nThere are no program headers in this file.\n"));
2239 if (do_segments
&& !do_header
)
2241 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2242 printf (_("Entry point "));
2243 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2244 printf (_("\nThere are %d program headers, starting at offset "),
2245 elf_header
.e_phnum
);
2246 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2250 program_headers
= (Elf_Internal_Phdr
*) malloc
2251 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2253 if (program_headers
== NULL
)
2255 error (_("Out of memory\n"));
2260 i
= get_32bit_program_headers (file
, program_headers
);
2262 i
= get_64bit_program_headers (file
, program_headers
);
2266 free (program_headers
);
2273 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2277 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2281 (_(" Type Offset VirtAddr PhysAddr\n"));
2283 (_(" FileSiz MemSiz Flags Align\n"));
2291 for (i
= 0, segment
= program_headers
;
2292 i
< elf_header
.e_phnum
;
2297 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2301 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2302 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2303 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2304 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2305 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2307 (segment
->p_flags
& PF_R
? 'R' : ' '),
2308 (segment
->p_flags
& PF_W
? 'W' : ' '),
2309 (segment
->p_flags
& PF_X
? 'E' : ' '));
2310 printf ("%#lx", (unsigned long) segment
->p_align
);
2314 print_vma (segment
->p_offset
, FULL_HEX
);
2316 print_vma (segment
->p_vaddr
, FULL_HEX
);
2318 print_vma (segment
->p_paddr
, FULL_HEX
);
2320 print_vma (segment
->p_filesz
, FULL_HEX
);
2322 print_vma (segment
->p_memsz
, FULL_HEX
);
2324 (segment
->p_flags
& PF_R
? 'R' : ' '),
2325 (segment
->p_flags
& PF_W
? 'W' : ' '),
2326 (segment
->p_flags
& PF_X
? 'E' : ' '));
2327 print_vma (segment
->p_align
, HEX
);
2331 switch (segment
->p_type
)
2335 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2336 - (segment
->p_offset
& 0xfffff000);
2341 error (_("more than one dynamic segment\n"));
2343 dynamic_addr
= segment
->p_offset
;
2344 dynamic_size
= segment
->p_filesz
;
2348 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2349 error (_("Unable to find program interpreter name\n"));
2352 program_interpreter
[0] = 0;
2353 fscanf (file
, "%63s", program_interpreter
);
2356 printf (_("\n [Requesting program interpreter: %s]"),
2357 program_interpreter
);
2363 putc ('\n', stdout
);
2372 if (do_segments
&& section_headers
!= NULL
)
2374 printf (_("\n Section to Segment mapping:\n"));
2375 printf (_(" Segment Sections...\n"));
2377 assert (string_table
!= NULL
);
2379 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2382 Elf_Internal_Shdr
* section
;
2384 segment
= program_headers
+ i
;
2385 section
= section_headers
;
2387 printf (" %2.2d ", i
);
2389 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2391 if (section
->sh_size
> 0
2392 /* Compare allocated sections by VMA, unallocated
2393 sections by file offset. */
2394 && (section
->sh_flags
& SHF_ALLOC
2395 ? (section
->sh_addr
>= segment
->p_vaddr
2396 && section
->sh_addr
+ section
->sh_size
2397 <= segment
->p_vaddr
+ segment
->p_memsz
)
2398 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2399 && (section
->sh_offset
+ section
->sh_size
2400 <= segment
->p_offset
+ segment
->p_filesz
))))
2401 printf ("%s ", SECTION_NAME (section
));
2408 free (program_headers
);
2415 get_32bit_section_headers (file
)
2418 Elf32_External_Shdr
* shdrs
;
2419 Elf32_Internal_Shdr
* internal
;
2422 GET_DATA_ALLOC (elf_header
.e_shoff
,
2423 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2424 shdrs
, Elf32_External_Shdr
*, "section headers");
2426 section_headers
= (Elf_Internal_Shdr
*) malloc
2427 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2429 if (section_headers
== NULL
)
2431 error (_("Out of memory\n"));
2435 for (i
= 0, internal
= section_headers
;
2436 i
< elf_header
.e_shnum
;
2439 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2440 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2441 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2442 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2443 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2444 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2445 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2446 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2447 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2448 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2457 get_64bit_section_headers (file
)
2460 Elf64_External_Shdr
* shdrs
;
2461 Elf64_Internal_Shdr
* internal
;
2464 GET_DATA_ALLOC (elf_header
.e_shoff
,
2465 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2466 shdrs
, Elf64_External_Shdr
*, "section headers");
2468 section_headers
= (Elf_Internal_Shdr
*) malloc
2469 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2471 if (section_headers
== NULL
)
2473 error (_("Out of memory\n"));
2477 for (i
= 0, internal
= section_headers
;
2478 i
< elf_header
.e_shnum
;
2481 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2482 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2483 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2484 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2485 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2486 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2487 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2488 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2489 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2490 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2498 static Elf_Internal_Sym
*
2499 get_32bit_elf_symbols (file
, offset
, number
)
2501 unsigned long offset
;
2502 unsigned long number
;
2504 Elf32_External_Sym
* esyms
;
2505 Elf_Internal_Sym
* isyms
;
2506 Elf_Internal_Sym
* psym
;
2509 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2510 esyms
, Elf32_External_Sym
*, "symbols");
2512 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2516 error (_("Out of memory\n"));
2522 for (j
= 0, psym
= isyms
;
2526 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2527 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2528 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2529 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2530 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2531 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2539 static Elf_Internal_Sym
*
2540 get_64bit_elf_symbols (file
, offset
, number
)
2542 unsigned long offset
;
2543 unsigned long number
;
2545 Elf64_External_Sym
* esyms
;
2546 Elf_Internal_Sym
* isyms
;
2547 Elf_Internal_Sym
* psym
;
2550 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2551 esyms
, Elf64_External_Sym
*, "symbols");
2553 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2557 error (_("Out of memory\n"));
2563 for (j
= 0, psym
= isyms
;
2567 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2568 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2569 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2570 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2571 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2572 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2581 get_elf_section_flags (sh_flags
)
2584 static char buff
[32];
2592 flag
= sh_flags
& - sh_flags
;
2597 case SHF_WRITE
: strcat (buff
, "W"); break;
2598 case SHF_ALLOC
: strcat (buff
, "A"); break;
2599 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2600 case SHF_MERGE
: strcat (buff
, "M"); break;
2601 case SHF_STRINGS
: strcat (buff
, "S"); break;
2602 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2603 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2604 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2607 if (flag
& SHF_MASKOS
)
2610 sh_flags
&= ~ SHF_MASKOS
;
2612 else if (flag
& SHF_MASKPROC
)
2615 sh_flags
&= ~ SHF_MASKPROC
;
2627 process_section_headers (file
)
2630 Elf_Internal_Shdr
* section
;
2633 section_headers
= NULL
;
2635 if (elf_header
.e_shnum
== 0)
2638 printf (_("\nThere are no sections in this file.\n"));
2643 if (do_sections
&& !do_header
)
2644 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2645 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2649 if (! get_32bit_section_headers (file
))
2652 else if (! get_64bit_section_headers (file
))
2655 /* Read in the string table, so that we have names to display. */
2656 section
= section_headers
+ elf_header
.e_shstrndx
;
2658 if (section
->sh_size
!= 0)
2660 unsigned long string_table_offset
;
2662 string_table_offset
= section
->sh_offset
;
2664 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2665 string_table
, char *, "string table");
2668 /* Scan the sections for the dynamic symbol table
2669 and dynamic string table and debug sections. */
2670 dynamic_symbols
= NULL
;
2671 dynamic_strings
= NULL
;
2672 dynamic_syminfo
= NULL
;
2674 for (i
= 0, section
= section_headers
;
2675 i
< elf_header
.e_shnum
;
2678 char * name
= SECTION_NAME (section
);
2680 if (section
->sh_type
== SHT_DYNSYM
)
2682 if (dynamic_symbols
!= NULL
)
2684 error (_("File contains multiple dynamic symbol tables\n"));
2688 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2690 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2692 else if (section
->sh_type
== SHT_STRTAB
2693 && strcmp (name
, ".dynstr") == 0)
2695 if (dynamic_strings
!= NULL
)
2697 error (_("File contains multiple dynamic string tables\n"));
2701 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2702 dynamic_strings
, char *, "dynamic strings");
2704 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2705 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
)
2706 && strncmp (name
, ".debug_", 7) == 0)
2711 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2712 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2713 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2714 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2715 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2717 request_dump (i
, DEBUG_DUMP
);
2724 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2728 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2731 printf (_(" [Nr] Name Type Address Offset\n"));
2732 printf (_(" Size EntSize Flags Link Info Align\n"));
2735 for (i
= 0, section
= section_headers
;
2736 i
< elf_header
.e_shnum
;
2739 printf (" [%2d] %-17.17s %-15.15s ",
2741 SECTION_NAME (section
),
2742 get_section_type_name (section
->sh_type
));
2746 print_vma (section
->sh_addr
, LONG_HEX
);
2748 printf ( " %6.6lx %6.6lx %2.2lx",
2749 (unsigned long) section
->sh_offset
,
2750 (unsigned long) section
->sh_size
,
2751 (unsigned long) section
->sh_entsize
);
2753 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2755 printf (" %2ld %3lx %ld\n",
2756 (unsigned long) section
->sh_link
,
2757 (unsigned long) section
->sh_info
,
2758 (unsigned long) section
->sh_addralign
);
2763 print_vma (section
->sh_addr
, LONG_HEX
);
2764 printf (" %8.8lx", section
->sh_offset
);
2766 print_vma (section
->sh_size
, LONG_HEX
);
2768 print_vma (section
->sh_entsize
, LONG_HEX
);
2770 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2772 printf (" %2ld %3lx %ld\n",
2773 (unsigned long) section
->sh_link
,
2774 (unsigned long) section
->sh_info
,
2775 (unsigned long) section
->sh_addralign
);
2779 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2780 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2781 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2786 /* Process the reloc section. */
2788 process_relocs (file
)
2791 unsigned long rel_size
;
2792 unsigned long rel_offset
;
2798 if (do_using_dynamic
)
2800 int is_rela
= FALSE
;
2805 if (dynamic_info
[DT_REL
])
2807 rel_offset
= dynamic_info
[DT_REL
];
2808 rel_size
= dynamic_info
[DT_RELSZ
];
2811 else if (dynamic_info
[DT_RELA
])
2813 rel_offset
= dynamic_info
[DT_RELA
];
2814 rel_size
= dynamic_info
[DT_RELASZ
];
2817 else if (dynamic_info
[DT_JMPREL
])
2819 rel_offset
= dynamic_info
[DT_JMPREL
];
2820 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2822 switch (dynamic_info
[DT_PLTREL
])
2839 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2840 rel_offset
, rel_size
);
2842 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2843 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
2846 printf (_("\nThere are no dynamic relocations in this file.\n"));
2850 Elf32_Internal_Shdr
* section
;
2854 for (i
= 0, section
= section_headers
;
2855 i
< elf_header
.e_shnum
;
2858 if ( section
->sh_type
!= SHT_RELA
2859 && section
->sh_type
!= SHT_REL
)
2862 rel_offset
= section
->sh_offset
;
2863 rel_size
= section
->sh_size
;
2867 Elf32_Internal_Shdr
* strsec
;
2868 Elf32_Internal_Shdr
* symsec
;
2869 Elf_Internal_Sym
* symtab
;
2872 unsigned long nsyms
;
2874 printf (_("\nRelocation section "));
2876 if (string_table
== NULL
)
2877 printf ("%d", section
->sh_name
);
2879 printf ("'%s'", SECTION_NAME (section
));
2881 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2882 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
2884 symsec
= section_headers
+ section
->sh_link
;
2886 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
2887 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
2892 strsec
= section_headers
+ symsec
->sh_link
;
2894 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2895 char *, "string table");
2897 is_rela
= section
->sh_type
== SHT_RELA
;
2899 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
2909 printf (_("\nThere are no relocations in this file.\n"));
2917 dynamic_segment_mips_val (entry
)
2918 Elf_Internal_Dyn
* entry
;
2920 switch (entry
->d_tag
)
2923 if (entry
->d_un
.d_val
== 0)
2927 static const char * opts
[] =
2929 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2930 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2931 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2932 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2937 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
2938 if (entry
->d_un
.d_val
& (1 << cnt
))
2940 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2947 case DT_MIPS_IVERSION
:
2948 if (dynamic_strings
!= NULL
)
2949 printf ("Interface Version: %s\n",
2950 dynamic_strings
+ entry
->d_un
.d_val
);
2952 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2955 case DT_MIPS_TIME_STAMP
:
2960 time_t time
= entry
->d_un
.d_val
;
2961 tmp
= gmtime (&time
);
2962 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
2963 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
2964 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
2965 printf ("Time Stamp: %s\n", timebuf
);
2969 case DT_MIPS_RLD_VERSION
:
2970 case DT_MIPS_LOCAL_GOTNO
:
2971 case DT_MIPS_CONFLICTNO
:
2972 case DT_MIPS_LIBLISTNO
:
2973 case DT_MIPS_SYMTABNO
:
2974 case DT_MIPS_UNREFEXTNO
:
2975 case DT_MIPS_HIPAGENO
:
2976 case DT_MIPS_DELTA_CLASS_NO
:
2977 case DT_MIPS_DELTA_INSTANCE_NO
:
2978 case DT_MIPS_DELTA_RELOC_NO
:
2979 case DT_MIPS_DELTA_SYM_NO
:
2980 case DT_MIPS_DELTA_CLASSSYM_NO
:
2981 case DT_MIPS_COMPACT_SIZE
:
2982 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2986 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2992 dynamic_segment_parisc_val (entry
)
2993 Elf_Internal_Dyn
* entry
;
2995 switch (entry
->d_tag
)
2997 case DT_HP_DLD_FLAGS
:
3006 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
3007 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
3008 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
3009 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
3010 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
3011 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
3012 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
3013 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
3014 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
3015 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
3016 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
3020 bfd_vma val
= entry
->d_un
.d_val
;
3022 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
3023 if (val
& flags
[cnt
].bit
)
3027 fputs (flags
[cnt
].str
, stdout
);
3029 val
^= flags
[cnt
].bit
;
3032 if (val
!= 0 || first
)
3036 print_vma (val
, HEX
);
3042 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
3048 get_32bit_dynamic_segment (file
)
3051 Elf32_External_Dyn
* edyn
;
3052 Elf_Internal_Dyn
* entry
;
3055 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3056 edyn
, Elf32_External_Dyn
*, "dynamic segment");
3058 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3059 how large this .dynamic is now. We can do this even before the byte
3060 swapping since the DT_NULL tag is recognizable. */
3062 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3065 dynamic_segment
= (Elf_Internal_Dyn
*)
3066 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3068 if (dynamic_segment
== NULL
)
3070 error (_("Out of memory\n"));
3075 for (i
= 0, entry
= dynamic_segment
;
3079 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
3080 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
3089 get_64bit_dynamic_segment (file
)
3092 Elf64_External_Dyn
* edyn
;
3093 Elf_Internal_Dyn
* entry
;
3096 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3097 edyn
, Elf64_External_Dyn
*, "dynamic segment");
3099 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3100 how large this .dynamic is now. We can do this even before the byte
3101 swapping since the DT_NULL tag is recognizable. */
3103 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3106 dynamic_segment
= (Elf_Internal_Dyn
*)
3107 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3109 if (dynamic_segment
== NULL
)
3111 error (_("Out of memory\n"));
3116 for (i
= 0, entry
= dynamic_segment
;
3120 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
3121 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
3130 get_dynamic_flags (flags
)
3133 static char buff
[64];
3138 flag
= flags
& - flags
;
3143 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3144 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3145 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3146 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3147 default: strcat (buff
, "unknown "); break;
3153 /* Parse and display the contents of the dynamic segment. */
3155 process_dynamic_segment (file
)
3158 Elf_Internal_Dyn
* entry
;
3161 if (dynamic_size
== 0)
3164 printf (_("\nThere is no dynamic segment in this file.\n"));
3171 if (! get_32bit_dynamic_segment (file
))
3174 else if (! get_64bit_dynamic_segment (file
))
3177 /* Find the appropriate symbol table. */
3178 if (dynamic_symbols
== NULL
)
3180 for (i
= 0, entry
= dynamic_segment
;
3184 unsigned long offset
;
3186 if (entry
->d_tag
!= DT_SYMTAB
)
3189 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3191 /* Since we do not know how big the symbol table is,
3192 we default to reading in the entire file (!) and
3193 processing that. This is overkill, I know, but it
3195 offset
= entry
->d_un
.d_val
- loadaddr
;
3197 if (fseek (file
, 0, SEEK_END
))
3198 error (_("Unable to seek to end of file!"));
3201 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3203 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3205 if (num_dynamic_syms
< 1)
3207 error (_("Unable to determine the number of symbols to load\n"));
3211 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3215 /* Similarly find a string table. */
3216 if (dynamic_strings
== NULL
)
3218 for (i
= 0, entry
= dynamic_segment
;
3222 unsigned long offset
;
3225 if (entry
->d_tag
!= DT_STRTAB
)
3228 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3230 /* Since we do not know how big the string table is,
3231 we default to reading in the entire file (!) and
3232 processing that. This is overkill, I know, but it
3235 offset
= entry
->d_un
.d_val
- loadaddr
;
3236 if (fseek (file
, 0, SEEK_END
))
3237 error (_("Unable to seek to end of file\n"));
3238 str_tab_len
= ftell (file
) - offset
;
3240 if (str_tab_len
< 1)
3243 (_("Unable to determine the length of the dynamic string table\n"));
3247 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
3248 "dynamic string table");
3254 /* And find the syminfo section if available. */
3255 if (dynamic_syminfo
== NULL
)
3257 unsigned int syminsz
= 0;
3259 for (i
= 0, entry
= dynamic_segment
;
3263 if (entry
->d_tag
== DT_SYMINENT
)
3265 /* Note: these braces are necessary to avoid a syntax
3266 error from the SunOS4 C compiler. */
3267 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3269 else if (entry
->d_tag
== DT_SYMINSZ
)
3270 syminsz
= entry
->d_un
.d_val
;
3271 else if (entry
->d_tag
== DT_SYMINFO
)
3272 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
3275 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3277 Elf_External_Syminfo
* extsyminfo
;
3278 Elf_Internal_Syminfo
* syminfo
;
3280 /* There is a syminfo section. Read the data. */
3281 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3282 Elf_External_Syminfo
*, "symbol information");
3284 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3285 if (dynamic_syminfo
== NULL
)
3287 error (_("Out of memory\n"));
3291 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3292 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3295 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3296 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3303 if (do_dynamic
&& dynamic_addr
)
3304 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3305 dynamic_addr
, (long) dynamic_size
);
3307 printf (_(" Tag Type Name/Value\n"));
3309 for (i
= 0, entry
= dynamic_segment
;
3318 print_vma (entry
->d_tag
, FULL_HEX
);
3319 dtype
= get_dynamic_type (entry
->d_tag
);
3320 printf (" (%s)%*s", dtype
,
3321 ((is_32bit_elf
? 27 : 19)
3322 - (int) strlen (dtype
)),
3326 switch (entry
->d_tag
)
3330 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
3337 if (entry
->d_tag
== DT_AUXILIARY
)
3338 printf (_("Auxiliary library"));
3340 printf (_("Filter library"));
3342 if (dynamic_strings
)
3343 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3347 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3356 printf (_("Flags:"));
3357 if (entry
->d_un
.d_val
== 0)
3358 printf (_(" None\n"));
3361 unsigned long int val
= entry
->d_un
.d_val
;
3362 if (val
& DTF_1_PARINIT
)
3364 printf (" PARINIT");
3365 val
^= DTF_1_PARINIT
;
3367 if (val
& DTF_1_CONFEXP
)
3369 printf (" CONFEXP");
3370 val
^= DTF_1_CONFEXP
;
3373 printf (" %lx", val
);
3382 printf (_("Flags:"));
3383 if (entry
->d_un
.d_val
== 0)
3384 printf (_(" None\n"));
3387 unsigned long int val
= entry
->d_un
.d_val
;
3388 if (val
& DF_P1_LAZYLOAD
)
3390 printf (" LAZYLOAD");
3391 val
^= DF_P1_LAZYLOAD
;
3393 if (val
& DF_P1_GROUPPERM
)
3395 printf (" GROUPPERM");
3396 val
^= DF_P1_GROUPPERM
;
3399 printf (" %lx", val
);
3408 printf (_("Flags:"));
3409 if (entry
->d_un
.d_val
== 0)
3410 printf (_(" None\n"));
3413 unsigned long int val
= entry
->d_un
.d_val
;
3419 if (val
& DF_1_GLOBAL
)
3424 if (val
& DF_1_GROUP
)
3429 if (val
& DF_1_NODELETE
)
3431 printf (" NODELETE");
3432 val
^= DF_1_NODELETE
;
3434 if (val
& DF_1_LOADFLTR
)
3436 printf (" LOADFLTR");
3437 val
^= DF_1_LOADFLTR
;
3439 if (val
& DF_1_INITFIRST
)
3441 printf (" INITFIRST");
3442 val
^= DF_1_INITFIRST
;
3444 if (val
& DF_1_NOOPEN
)
3449 if (val
& DF_1_ORIGIN
)
3454 if (val
& DF_1_DIRECT
)
3459 if (val
& DF_1_TRANS
)
3464 if (val
& DF_1_INTERPOSE
)
3466 printf (" INTERPOSE");
3467 val
^= DF_1_INTERPOSE
;
3469 if (val
& DF_1_NODEPLIB
)
3471 printf (" NODEPLIB");
3472 val
^= DF_1_NODEPLIB
;
3474 if (val
& DF_1_NODUMP
)
3479 if (val
& DF_1_CONLFAT
)
3481 printf (" CONLFAT");
3482 val
^= DF_1_CONLFAT
;
3485 printf (" %lx", val
);
3493 puts (get_dynamic_type (entry
->d_un
.d_val
));
3512 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
3518 if (dynamic_strings
== NULL
)
3521 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3525 switch (entry
->d_tag
)
3528 printf (_("Shared library: [%s]"), name
);
3530 if (strcmp (name
, program_interpreter
) == 0)
3531 printf (_(" program interpreter"));
3535 printf (_("Library soname: [%s]"), name
);
3539 printf (_("Library rpath: [%s]"), name
);
3543 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3548 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3564 case DT_INIT_ARRAYSZ
:
3565 case DT_FINI_ARRAYSZ
:
3568 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3569 printf (" (bytes)\n");
3579 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3592 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
3596 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3600 printf (_("Not needed object: [%s]\n"), name
);
3605 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3611 /* The value of this entry is ignored. */
3615 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
3616 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
3621 switch (elf_header
.e_machine
)
3624 case EM_MIPS_RS4_BE
:
3625 dynamic_segment_mips_val (entry
);
3628 dynamic_segment_parisc_val (entry
);
3631 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3643 get_ver_flags (flags
)
3646 static char buff
[32];
3653 if (flags
& VER_FLG_BASE
)
3654 strcat (buff
, "BASE ");
3656 if (flags
& VER_FLG_WEAK
)
3658 if (flags
& VER_FLG_BASE
)
3659 strcat (buff
, "| ");
3661 strcat (buff
, "WEAK ");
3664 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
3665 strcat (buff
, "| <unknown>");
3670 /* Display the contents of the version sections. */
3672 process_version_sections (file
)
3675 Elf32_Internal_Shdr
* section
;
3682 for (i
= 0, section
= section_headers
;
3683 i
< elf_header
.e_shnum
;
3686 switch (section
->sh_type
)
3688 case SHT_GNU_verdef
:
3690 Elf_External_Verdef
* edefs
;
3697 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3698 SECTION_NAME (section
), section
->sh_info
);
3700 printf (_(" Addr: 0x"));
3701 printf_vma (section
->sh_addr
);
3702 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3703 (unsigned long) section
->sh_offset
, section
->sh_link
,
3704 SECTION_NAME (section_headers
+ section
->sh_link
));
3706 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3707 edefs
, Elf_External_Verdef
*,
3708 "version definition section");
3710 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
3713 Elf_External_Verdef
* edef
;
3714 Elf_Internal_Verdef ent
;
3715 Elf_External_Verdaux
* eaux
;
3716 Elf_Internal_Verdaux aux
;
3720 vstart
= ((char *) edefs
) + idx
;
3722 edef
= (Elf_External_Verdef
*) vstart
;
3724 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
3725 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
3726 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
3727 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
3728 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
3729 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
3730 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
3732 printf (_(" %#06x: Rev: %d Flags: %s"),
3733 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
3735 printf (_(" Index: %d Cnt: %d "),
3736 ent
.vd_ndx
, ent
.vd_cnt
);
3738 vstart
+= ent
.vd_aux
;
3740 eaux
= (Elf_External_Verdaux
*) vstart
;
3742 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3743 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3745 if (dynamic_strings
)
3746 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
3748 printf (_("Name index: %ld\n"), aux
.vda_name
);
3750 isum
= idx
+ ent
.vd_aux
;
3752 for (j
= 1; j
< ent
.vd_cnt
; j
++)
3754 isum
+= aux
.vda_next
;
3755 vstart
+= aux
.vda_next
;
3757 eaux
= (Elf_External_Verdaux
*) vstart
;
3759 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3760 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3762 if (dynamic_strings
)
3763 printf (_(" %#06x: Parent %d: %s\n"),
3764 isum
, j
, dynamic_strings
+ aux
.vda_name
);
3766 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3767 isum
, j
, aux
.vda_name
);
3777 case SHT_GNU_verneed
:
3779 Elf_External_Verneed
* eneed
;
3785 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3786 SECTION_NAME (section
), section
->sh_info
);
3788 printf (_(" Addr: 0x"));
3789 printf_vma (section
->sh_addr
);
3790 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3791 (unsigned long) section
->sh_offset
, section
->sh_link
,
3792 SECTION_NAME (section_headers
+ section
->sh_link
));
3794 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3795 eneed
, Elf_External_Verneed
*,
3796 "version need section");
3798 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
3800 Elf_External_Verneed
* entry
;
3801 Elf_Internal_Verneed ent
;
3806 vstart
= ((char *) eneed
) + idx
;
3808 entry
= (Elf_External_Verneed
*) vstart
;
3810 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
3811 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
3812 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
3813 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
3814 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
3816 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
3818 if (dynamic_strings
)
3819 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
3821 printf (_(" File: %lx"), ent
.vn_file
);
3823 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
3825 vstart
+= ent
.vn_aux
;
3827 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
3829 Elf_External_Vernaux
* eaux
;
3830 Elf_Internal_Vernaux aux
;
3832 eaux
= (Elf_External_Vernaux
*) vstart
;
3834 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
3835 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
3836 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
3837 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
3838 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
3840 if (dynamic_strings
)
3841 printf (_(" %#06x: Name: %s"),
3842 isum
, dynamic_strings
+ aux
.vna_name
);
3844 printf (_(" %#06x: Name index: %lx"),
3845 isum
, aux
.vna_name
);
3847 printf (_(" Flags: %s Version: %d\n"),
3848 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
3850 isum
+= aux
.vna_next
;
3851 vstart
+= aux
.vna_next
;
3861 case SHT_GNU_versym
:
3863 Elf32_Internal_Shdr
* link_section
;
3866 unsigned char * edata
;
3867 unsigned short * data
;
3869 Elf_Internal_Sym
* symbols
;
3870 Elf32_Internal_Shdr
* string_sec
;
3872 link_section
= section_headers
+ section
->sh_link
;
3873 total
= section
->sh_size
/ section
->sh_entsize
;
3877 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
3878 link_section
->sh_size
/ link_section
->sh_entsize
);
3880 string_sec
= section_headers
+ link_section
->sh_link
;
3882 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3883 strtab
, char *, "version string table");
3885 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3886 SECTION_NAME (section
), total
);
3888 printf (_(" Addr: "));
3889 printf_vma (section
->sh_addr
);
3890 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3891 (unsigned long) section
->sh_offset
, section
->sh_link
,
3892 SECTION_NAME (link_section
));
3894 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3896 total
* sizeof (short), edata
,
3897 unsigned char *, "version symbol data");
3899 data
= (unsigned short *) malloc (total
* sizeof (short));
3901 for (cnt
= total
; cnt
--;)
3902 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
3907 for (cnt
= 0; cnt
< total
; cnt
+= 4)
3912 printf (" %03x:", cnt
);
3914 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
3915 switch (data
[cnt
+ j
])
3918 fputs (_(" 0 (*local*) "), stdout
);
3922 fputs (_(" 1 (*global*) "), stdout
);
3926 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
3927 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
3929 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
3930 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
3933 /* We must test both. */
3934 Elf_Internal_Verneed ivn
;
3935 unsigned long offset
;
3937 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3942 Elf_External_Verneed evn
;
3943 Elf_External_Vernaux evna
;
3944 Elf_Internal_Vernaux ivna
;
3945 unsigned long vna_off
;
3947 GET_DATA (offset
, evn
, "version need");
3949 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3950 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3952 vna_off
= offset
+ ivn
.vn_aux
;
3956 GET_DATA (vna_off
, evna
,
3957 "version need aux (1)");
3959 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3960 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3962 vna_off
+= ivna
.vna_next
;
3964 while (ivna
.vna_other
!= data
[cnt
+ j
]
3965 && ivna
.vna_next
!= 0);
3967 if (ivna
.vna_other
== data
[cnt
+ j
])
3969 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3971 name
= strtab
+ ivna
.vna_name
;
3972 nn
+= printf ("(%s%-*s",
3974 12 - (int) strlen (name
),
3978 else if (ivn
.vn_next
== 0)
3980 if (data
[cnt
+ j
] != 0x8001)
3982 Elf_Internal_Verdef ivd
;
3983 Elf_External_Verdef evd
;
3985 offset
= version_info
3986 [DT_VERSIONTAGIDX (DT_VERDEF
)]
3991 GET_DATA (offset
, evd
,
3992 "version definition");
3994 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3995 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3997 offset
+= ivd
.vd_next
;
4000 != (data
[cnt
+ j
] & 0x7fff)
4001 && ivd
.vd_next
!= 0);
4004 == (data
[cnt
+ j
] & 0x7fff))
4006 Elf_External_Verdaux evda
;
4007 Elf_Internal_Verdaux ivda
;
4009 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4011 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
4012 "version definition aux");
4015 BYTE_GET (evda
.vda_name
);
4017 name
= strtab
+ ivda
.vda_name
;
4021 12 - (int) strlen (name
),
4029 offset
+= ivn
.vn_next
;
4031 while (ivn
.vn_next
);
4033 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
4035 Elf_Internal_Verneed ivn
;
4036 unsigned long offset
;
4038 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4043 Elf_Internal_Vernaux ivna
;
4044 Elf_External_Verneed evn
;
4045 Elf_External_Vernaux evna
;
4046 unsigned long a_off
;
4048 GET_DATA (offset
, evn
, "version need");
4050 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4051 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4053 a_off
= offset
+ ivn
.vn_aux
;
4057 GET_DATA (a_off
, evna
,
4058 "version need aux (2)");
4060 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4061 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4063 a_off
+= ivna
.vna_next
;
4065 while (ivna
.vna_other
!= data
[cnt
+ j
]
4066 && ivna
.vna_next
!= 0);
4068 if (ivna
.vna_other
== data
[cnt
+ j
])
4070 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4072 name
= strtab
+ ivna
.vna_name
;
4073 nn
+= printf ("(%s%-*s",
4075 12 - (int) strlen (name
),
4080 offset
+= ivn
.vn_next
;
4082 while (ivn
.vn_next
);
4084 else if (data
[cnt
+ j
] != 0x8001)
4086 Elf_Internal_Verdef ivd
;
4087 Elf_External_Verdef evd
;
4088 unsigned long offset
;
4090 offset
= version_info
4091 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
4095 GET_DATA (offset
, evd
, "version def");
4097 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4098 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4100 offset
+= ivd
.vd_next
;
4102 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
4103 && ivd
.vd_next
!= 0);
4105 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
4107 Elf_External_Verdaux evda
;
4108 Elf_Internal_Verdaux ivda
;
4110 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4112 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
4113 evda
, "version def aux");
4115 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4117 name
= strtab
+ ivda
.vda_name
;
4118 nn
+= printf ("(%s%-*s",
4120 12 - (int) strlen (name
),
4126 printf ("%*c", 18 - nn
, ' ');
4144 printf (_("\nNo version information found in this file.\n"));
4150 get_symbol_binding (binding
)
4151 unsigned int binding
;
4153 static char buff
[32];
4157 case STB_LOCAL
: return "LOCAL";
4158 case STB_GLOBAL
: return "GLOBAL";
4159 case STB_WEAK
: return "WEAK";
4161 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4162 sprintf (buff
, _("<processor specific>: %d"), binding
);
4163 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4164 sprintf (buff
, _("<OS specific>: %d"), binding
);
4166 sprintf (buff
, _("<unknown>: %d"), binding
);
4172 get_symbol_type (type
)
4175 static char buff
[32];
4179 case STT_NOTYPE
: return "NOTYPE";
4180 case STT_OBJECT
: return "OBJECT";
4181 case STT_FUNC
: return "FUNC";
4182 case STT_SECTION
: return "SECTION";
4183 case STT_FILE
: return "FILE";
4184 case STT_COMMON
: return "COMMON";
4186 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4188 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4189 return "THUMB_FUNC";
4191 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4194 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4195 return "PARISC_MILLI";
4197 sprintf (buff
, _("<processor specific>: %d"), type
);
4199 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4201 if (elf_header
.e_machine
== EM_PARISC
)
4203 if (type
== STT_HP_OPAQUE
)
4205 if (type
== STT_HP_STUB
)
4209 sprintf (buff
, _("<OS specific>: %d"), type
);
4212 sprintf (buff
, _("<unknown>: %d"), type
);
4218 get_symbol_visibility (visibility
)
4219 unsigned int visibility
;
4223 case STV_DEFAULT
: return "DEFAULT";
4224 case STV_INTERNAL
: return "INTERNAL";
4225 case STV_HIDDEN
: return "HIDDEN";
4226 case STV_PROTECTED
: return "PROTECTED";
4232 get_symbol_index_type (type
)
4237 case SHN_UNDEF
: return "UND";
4238 case SHN_ABS
: return "ABS";
4239 case SHN_COMMON
: return "COM";
4241 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4243 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4245 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4249 static char buff
[32];
4251 sprintf (buff
, "%3d", type
);
4258 get_dynamic_data (file
, number
)
4260 unsigned int number
;
4262 unsigned char * e_data
;
4265 e_data
= (unsigned char *) malloc (number
* 4);
4269 error (_("Out of memory\n"));
4273 if (fread (e_data
, 4, number
, file
) != number
)
4275 error (_("Unable to read in dynamic data\n"));
4279 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4283 error (_("Out of memory\n"));
4289 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4296 /* Dump the symbol table */
4298 process_symbol_table (file
)
4301 Elf32_Internal_Shdr
* section
;
4302 unsigned char nb
[4];
4303 unsigned char nc
[4];
4306 int * buckets
= NULL
;
4307 int * chains
= NULL
;
4309 if (! do_syms
&& !do_histogram
)
4312 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
4315 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
4317 error (_("Unable to seek to start of dynamic information"));
4321 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4323 error (_("Failed to read in number of buckets\n"));
4327 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4329 error (_("Failed to read in number of chains\n"));
4333 nbuckets
= byte_get (nb
, 4);
4334 nchains
= byte_get (nc
, 4);
4336 buckets
= get_dynamic_data (file
, nbuckets
);
4337 chains
= get_dynamic_data (file
, nchains
);
4339 if (buckets
== NULL
|| chains
== NULL
)
4344 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4349 printf (_("\nSymbol table for image:\n"));
4351 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4353 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4355 for (hn
= 0; hn
< nbuckets
; hn
++)
4360 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4362 Elf_Internal_Sym
* psym
;
4364 psym
= dynamic_symbols
+ si
;
4366 printf (" %3d %3d: ", si
, hn
);
4367 print_vma (psym
->st_value
, LONG_HEX
);
4369 print_vma (psym
->st_size
, DEC_5
);
4371 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4372 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4373 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4374 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
4375 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4379 else if (do_syms
&& !do_using_dynamic
)
4383 for (i
= 0, section
= section_headers
;
4384 i
< elf_header
.e_shnum
;
4389 Elf_Internal_Sym
* symtab
;
4390 Elf_Internal_Sym
* psym
;
4393 if ( section
->sh_type
!= SHT_SYMTAB
4394 && section
->sh_type
!= SHT_DYNSYM
)
4397 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4398 SECTION_NAME (section
),
4399 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4401 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4403 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4405 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4406 section
->sh_size
/ section
->sh_entsize
);
4410 if (section
->sh_link
== elf_header
.e_shstrndx
)
4411 strtab
= string_table
;
4414 Elf32_Internal_Shdr
* string_sec
;
4416 string_sec
= section_headers
+ section
->sh_link
;
4418 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4419 strtab
, char *, "string table");
4422 for (si
= 0, psym
= symtab
;
4423 si
< section
->sh_size
/ section
->sh_entsize
;
4426 printf ("%6d: ", si
);
4427 print_vma (psym
->st_value
, LONG_HEX
);
4429 print_vma (psym
->st_size
, DEC_5
);
4430 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4431 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4432 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4433 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
4434 printf (" %s", strtab
+ psym
->st_name
);
4436 if (section
->sh_type
== SHT_DYNSYM
&&
4437 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
4439 unsigned char data
[2];
4440 unsigned short vers_data
;
4441 unsigned long offset
;
4445 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4448 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
4451 vers_data
= byte_get (data
, 2);
4453 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
4454 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
4457 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
4459 if ((vers_data
& 0x8000) || vers_data
> 1)
4461 if (is_nobits
|| ! check_def
)
4463 Elf_External_Verneed evn
;
4464 Elf_Internal_Verneed ivn
;
4465 Elf_Internal_Vernaux ivna
;
4467 /* We must test both. */
4468 offset
= version_info
4469 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
4473 unsigned long vna_off
;
4475 GET_DATA (offset
, evn
, "version need");
4477 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4478 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4480 vna_off
= offset
+ ivn
.vn_aux
;
4484 Elf_External_Vernaux evna
;
4486 GET_DATA (vna_off
, evna
,
4487 "version need aux (3)");
4489 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4490 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4491 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4493 vna_off
+= ivna
.vna_next
;
4495 while (ivna
.vna_other
!= vers_data
4496 && ivna
.vna_next
!= 0);
4498 if (ivna
.vna_other
== vers_data
)
4501 offset
+= ivn
.vn_next
;
4503 while (ivn
.vn_next
!= 0);
4505 if (ivna
.vna_other
== vers_data
)
4508 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
4511 else if (! is_nobits
)
4512 error (_("bad dynamic symbol"));
4519 if (vers_data
!= 0x8001)
4521 Elf_Internal_Verdef ivd
;
4522 Elf_Internal_Verdaux ivda
;
4523 Elf_External_Verdaux evda
;
4524 unsigned long offset
;
4527 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
4532 Elf_External_Verdef evd
;
4534 GET_DATA (offset
, evd
, "version def");
4536 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4537 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4538 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4540 offset
+= ivd
.vd_next
;
4542 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
4543 && ivd
.vd_next
!= 0);
4545 offset
-= ivd
.vd_next
;
4546 offset
+= ivd
.vd_aux
;
4548 GET_DATA (offset
, evda
, "version def aux");
4550 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4552 if (psym
->st_name
!= ivda
.vda_name
)
4553 printf ((vers_data
& 0x8000)
4555 strtab
+ ivda
.vda_name
);
4565 if (strtab
!= string_table
)
4571 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4573 if (do_histogram
&& buckets
!= NULL
)
4580 int nzero_counts
= 0;
4583 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4585 printf (_(" Length Number %% of total Coverage\n"));
4587 lengths
= (int *) calloc (nbuckets
, sizeof (int));
4588 if (lengths
== NULL
)
4590 error (_("Out of memory"));
4593 for (hn
= 0; hn
< nbuckets
; ++hn
)
4598 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
4601 if (maxlength
< ++lengths
[hn
])
4606 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
4609 error (_("Out of memory"));
4613 for (hn
= 0; hn
< nbuckets
; ++hn
)
4614 ++ counts
[lengths
[hn
]];
4618 printf (" 0 %-10d (%5.1f%%)\n",
4619 counts
[0], (counts
[0] * 100.0) / nbuckets
);
4620 for (si
= 1; si
<= maxlength
; ++si
)
4622 nzero_counts
+= counts
[si
] * si
;
4623 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4624 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
4625 (nzero_counts
* 100.0) / nsyms
);
4633 if (buckets
!= NULL
)
4643 process_syminfo (file
)
4644 FILE * file ATTRIBUTE_UNUSED
;
4648 if (dynamic_syminfo
== NULL
4650 /* No syminfo, this is ok. */
4653 /* There better should be a dynamic symbol section. */
4654 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
4658 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4659 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
4661 printf (_(" Num: Name BoundTo Flags\n"));
4662 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
4664 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
4666 printf ("%4d: %-30s ", i
,
4667 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
4669 switch (dynamic_syminfo
[i
].si_boundto
)
4671 case SYMINFO_BT_SELF
:
4672 fputs ("SELF ", stdout
);
4674 case SYMINFO_BT_PARENT
:
4675 fputs ("PARENT ", stdout
);
4678 if (dynamic_syminfo
[i
].si_boundto
> 0
4679 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
4682 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
4684 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
4688 if (flags
& SYMINFO_FLG_DIRECT
)
4690 if (flags
& SYMINFO_FLG_PASSTHRU
)
4691 printf (" PASSTHRU");
4692 if (flags
& SYMINFO_FLG_COPY
)
4694 if (flags
& SYMINFO_FLG_LAZYLOAD
)
4695 printf (" LAZYLOAD");
4703 #ifdef SUPPORT_DISASSEMBLY
4705 disassemble_section (section
, file
)
4706 Elf32_Internal_Shdr
* section
;
4709 printf (_("\nAssembly dump of section %s\n"),
4710 SECTION_NAME (section
));
4712 /* XXX -- to be done --- XXX */
4719 dump_section (section
, file
)
4720 Elf32_Internal_Shdr
* section
;
4723 bfd_size_type bytes
;
4725 unsigned char * data
;
4726 unsigned char * start
;
4728 bytes
= section
->sh_size
;
4732 printf (_("\nSection '%s' has no data to dump.\n"),
4733 SECTION_NAME (section
));
4737 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
4739 addr
= section
->sh_addr
;
4741 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
4752 lbytes
= (bytes
> 16 ? 16 : bytes
);
4754 printf (" 0x%8.8lx ", (unsigned long) addr
);
4756 switch (elf_header
.e_ident
[EI_DATA
])
4760 for (j
= 15; j
>= 0; j
--)
4763 printf ("%2.2x", data
[j
]);
4773 for (j
= 0; j
< 16; j
++)
4776 printf ("%2.2x", data
[j
]);
4786 for (j
= 0; j
< lbytes
; j
++)
4789 if (k
>= ' ' && k
< 0x80)
4808 static unsigned long int
4809 read_leb128 (data
, length_return
, sign
)
4810 unsigned char * data
;
4811 int * length_return
;
4814 unsigned long int result
= 0;
4815 unsigned int num_read
= 0;
4824 result
|= (byte
& 0x7f) << shift
;
4829 while (byte
& 0x80);
4831 if (length_return
!= NULL
)
4832 * length_return
= num_read
;
4834 if (sign
&& (shift
< 32) && (byte
& 0x40))
4835 result
|= -1 << shift
;
4840 typedef struct State_Machine_Registers
4842 unsigned long address
;
4845 unsigned int column
;
4849 /* This variable hold the number of the last entry seen
4850 in the File Table. */
4851 unsigned int last_file_entry
;
4854 static SMR state_machine_regs
;
4857 reset_state_machine (is_stmt
)
4860 state_machine_regs
.address
= 0;
4861 state_machine_regs
.file
= 1;
4862 state_machine_regs
.line
= 1;
4863 state_machine_regs
.column
= 0;
4864 state_machine_regs
.is_stmt
= is_stmt
;
4865 state_machine_regs
.basic_block
= 0;
4866 state_machine_regs
.end_sequence
= 0;
4867 state_machine_regs
.last_file_entry
= 0;
4870 /* Handled an extend line op. Returns true if this is the end
4873 process_extended_line_op (data
, is_stmt
, pointer_size
)
4874 unsigned char * data
;
4878 unsigned char op_code
;
4881 unsigned char * name
;
4884 len
= read_leb128 (data
, & bytes_read
, 0);
4889 warn (_("badly formed extended line op encountered!"));
4894 op_code
= * data
++;
4896 printf (_(" Extended opcode %d: "), op_code
);
4900 case DW_LNE_end_sequence
:
4901 printf (_("End of Sequence\n\n"));
4902 reset_state_machine (is_stmt
);
4905 case DW_LNE_set_address
:
4906 adr
= byte_get (data
, pointer_size
);
4907 printf (_("set Address to 0x%lx\n"), adr
);
4908 state_machine_regs
.address
= adr
;
4911 case DW_LNE_define_file
:
4912 printf (_(" define new File Table entry\n"));
4913 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4915 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4917 data
+= strlen ((char *) data
) + 1;
4918 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4920 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4922 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4923 printf (_("%s\n\n"), name
);
4927 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
4934 /* Size of pointers in the .debug_line section. This information is not
4935 really present in that section. It's obtained before dumping the debug
4936 sections by doing some pre-scan of the .debug_info section. */
4937 static int debug_line_pointer_size
= 4;
4940 display_debug_lines (section
, start
, file
)
4941 Elf32_Internal_Shdr
* section
;
4942 unsigned char * start
;
4943 FILE * file ATTRIBUTE_UNUSED
;
4945 DWARF2_External_LineInfo
* external
;
4946 DWARF2_Internal_LineInfo info
;
4947 unsigned char * standard_opcodes
;
4948 unsigned char * data
= start
;
4949 unsigned char * end
= start
+ section
->sh_size
;
4950 unsigned char * end_of_sequence
;
4953 printf (_("\nDump of debug contents of section %s:\n\n"),
4954 SECTION_NAME (section
));
4958 external
= (DWARF2_External_LineInfo
*) data
;
4960 /* Check the length of the block. */
4961 info
.li_length
= BYTE_GET (external
->li_length
);
4962 if (info
.li_length
> section
->sh_size
)
4965 (_("The line info appears to be corrupt - the section is too small\n"));
4969 /* Check its version number. */
4970 info
.li_version
= BYTE_GET (external
->li_version
);
4971 if (info
.li_version
!= 2)
4973 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4977 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
4978 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
4979 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
4980 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
4981 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
4982 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
4984 /* Sign extend the line base field. */
4985 info
.li_line_base
<<= 24;
4986 info
.li_line_base
>>= 24;
4988 printf (_(" Length: %ld\n"), info
.li_length
);
4989 printf (_(" DWARF Version: %d\n"), info
.li_version
);
4990 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
4991 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
4992 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
4993 printf (_(" Line Base: %d\n"), info
.li_line_base
);
4994 printf (_(" Line Range: %d\n"), info
.li_line_range
);
4995 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
4997 end_of_sequence
= data
+ info
.li_length
+ sizeof (info
.li_length
);
4999 reset_state_machine (info
.li_default_is_stmt
);
5001 /* Display the contents of the Opcodes table. */
5002 standard_opcodes
= data
+ sizeof (* external
);
5004 printf (_("\n Opcodes:\n"));
5006 for (i
= 1; i
< info
.li_opcode_base
; i
++)
5007 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
5009 /* Display the contents of the Directory table. */
5010 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
5013 printf (_("\n The Directory Table is empty.\n"));
5016 printf (_("\n The Directory Table:\n"));
5020 printf (_(" %s\n"), data
);
5022 data
+= strlen ((char *) data
) + 1;
5026 /* Skip the NUL at the end of the table. */
5029 /* Display the contents of the File Name table. */
5031 printf (_("\n The File Name Table is empty.\n"));
5034 printf (_("\n The File Name Table:\n"));
5035 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5039 unsigned char * name
;
5042 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5045 data
+= strlen ((char *) data
) + 1;
5047 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5049 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5051 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5053 printf (_("%s\n"), name
);
5057 /* Skip the NUL at the end of the table. */
5060 /* Now display the statements. */
5061 printf (_("\n Line Number Statements:\n"));
5064 while (data
< end_of_sequence
)
5066 unsigned char op_code
;
5070 op_code
= * data
++;
5074 case DW_LNS_extended_op
:
5075 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
5076 debug_line_pointer_size
);
5080 printf (_(" Copy\n"));
5083 case DW_LNS_advance_pc
:
5084 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
5086 state_machine_regs
.address
+= adv
;
5087 printf (_(" Advance PC by %d to %lx\n"), adv
,
5088 state_machine_regs
.address
);
5091 case DW_LNS_advance_line
:
5092 adv
= read_leb128 (data
, & bytes_read
, 1);
5094 state_machine_regs
.line
+= adv
;
5095 printf (_(" Advance Line by %d to %d\n"), adv
,
5096 state_machine_regs
.line
);
5099 case DW_LNS_set_file
:
5100 adv
= read_leb128 (data
, & bytes_read
, 0);
5102 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5104 state_machine_regs
.file
= adv
;
5107 case DW_LNS_set_column
:
5108 adv
= read_leb128 (data
, & bytes_read
, 0);
5110 printf (_(" Set column to %d\n"), adv
);
5111 state_machine_regs
.column
= adv
;
5114 case DW_LNS_negate_stmt
:
5115 adv
= state_machine_regs
.is_stmt
;
5117 printf (_(" Set is_stmt to %d\n"), adv
);
5118 state_machine_regs
.is_stmt
= adv
;
5121 case DW_LNS_set_basic_block
:
5122 printf (_(" Set basic block\n"));
5123 state_machine_regs
.basic_block
= 1;
5126 case DW_LNS_const_add_pc
:
5127 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
5128 * info
.li_min_insn_length
);
5129 state_machine_regs
.address
+= adv
;
5130 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
5131 state_machine_regs
.address
);
5134 case DW_LNS_fixed_advance_pc
:
5135 adv
= byte_get (data
, 2);
5137 state_machine_regs
.address
+= adv
;
5138 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5139 adv
, state_machine_regs
.address
);
5143 op_code
-= info
.li_opcode_base
;
5144 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
5145 state_machine_regs
.address
+= adv
;
5146 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5147 op_code
, adv
, state_machine_regs
.address
);
5148 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
5149 state_machine_regs
.line
+= adv
;
5150 printf (_(" and Line by %d to %d\n"),
5151 adv
, state_machine_regs
.line
);
5162 display_debug_pubnames (section
, start
, file
)
5163 Elf32_Internal_Shdr
* section
;
5164 unsigned char * start
;
5165 FILE * file ATTRIBUTE_UNUSED
;
5167 DWARF2_External_PubNames
* external
;
5168 DWARF2_Internal_PubNames pubnames
;
5169 unsigned char * end
;
5171 end
= start
+ section
->sh_size
;
5173 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5177 unsigned char * data
;
5178 unsigned long offset
;
5180 external
= (DWARF2_External_PubNames
*) start
;
5182 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5183 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5184 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5185 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5187 data
= start
+ sizeof (* external
);
5188 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5190 if (pubnames
.pn_version
!= 2)
5192 warn (_("Only DWARF 2 pubnames are currently supported"));
5196 printf (_(" Length: %ld\n"),
5197 pubnames
.pn_length
);
5198 printf (_(" Version: %d\n"),
5199 pubnames
.pn_version
);
5200 printf (_(" Offset into .debug_info section: %ld\n"),
5201 pubnames
.pn_offset
);
5202 printf (_(" Size of area in .debug_info section: %ld\n"),
5205 printf (_("\n Offset\tName\n"));
5209 offset
= byte_get (data
, 4);
5214 printf (" %ld\t\t%s\n", offset
, data
);
5215 data
+= strlen ((char *) data
) + 1;
5218 while (offset
!= 0);
5231 case DW_TAG_padding
: return "DW_TAG_padding";
5232 case DW_TAG_array_type
: return "DW_TAG_array_type";
5233 case DW_TAG_class_type
: return "DW_TAG_class_type";
5234 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5235 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5236 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5237 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5238 case DW_TAG_label
: return "DW_TAG_label";
5239 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5240 case DW_TAG_member
: return "DW_TAG_member";
5241 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5242 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5243 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5244 case DW_TAG_string_type
: return "DW_TAG_string_type";
5245 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5246 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5247 case DW_TAG_typedef
: return "DW_TAG_typedef";
5248 case DW_TAG_union_type
: return "DW_TAG_union_type";
5249 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5250 case DW_TAG_variant
: return "DW_TAG_variant";
5251 case DW_TAG_common_block
: return "DW_TAG_common_block";
5252 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5253 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5254 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5255 case DW_TAG_module
: return "DW_TAG_module";
5256 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5257 case DW_TAG_set_type
: return "DW_TAG_set_type";
5258 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5259 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5260 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5261 case DW_TAG_base_type
: return "DW_TAG_base_type";
5262 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5263 case DW_TAG_const_type
: return "DW_TAG_const_type";
5264 case DW_TAG_constant
: return "DW_TAG_constant";
5265 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5266 case DW_TAG_file_type
: return "DW_TAG_file_type";
5267 case DW_TAG_friend
: return "DW_TAG_friend";
5268 case DW_TAG_namelist
: return "DW_TAG_namelist";
5269 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5270 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5271 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5272 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5273 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5274 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5275 case DW_TAG_try_block
: return "DW_TAG_try_block";
5276 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5277 case DW_TAG_variable
: return "DW_TAG_variable";
5278 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5279 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5280 case DW_TAG_format_label
: return "DW_TAG_format_label";
5281 case DW_TAG_function_template
: return "DW_TAG_function_template";
5282 case DW_TAG_class_template
: return "DW_TAG_class_template";
5285 static char buffer
[100];
5287 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
5294 get_AT_name (attribute
)
5295 unsigned long attribute
;
5299 case DW_AT_sibling
: return "DW_AT_sibling";
5300 case DW_AT_location
: return "DW_AT_location";
5301 case DW_AT_name
: return "DW_AT_name";
5302 case DW_AT_ordering
: return "DW_AT_ordering";
5303 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
5304 case DW_AT_byte_size
: return "DW_AT_byte_size";
5305 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
5306 case DW_AT_bit_size
: return "DW_AT_bit_size";
5307 case DW_AT_element_list
: return "DW_AT_element_list";
5308 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
5309 case DW_AT_low_pc
: return "DW_AT_low_pc";
5310 case DW_AT_high_pc
: return "DW_AT_high_pc";
5311 case DW_AT_language
: return "DW_AT_language";
5312 case DW_AT_member
: return "DW_AT_member";
5313 case DW_AT_discr
: return "DW_AT_discr";
5314 case DW_AT_discr_value
: return "DW_AT_discr_value";
5315 case DW_AT_visibility
: return "DW_AT_visibility";
5316 case DW_AT_import
: return "DW_AT_import";
5317 case DW_AT_string_length
: return "DW_AT_string_length";
5318 case DW_AT_common_reference
: return "DW_AT_common_reference";
5319 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5320 case DW_AT_const_value
: return "DW_AT_const_value";
5321 case DW_AT_containing_type
: return "DW_AT_containing_type";
5322 case DW_AT_default_value
: return "DW_AT_default_value";
5323 case DW_AT_inline
: return "DW_AT_inline";
5324 case DW_AT_is_optional
: return "DW_AT_is_optional";
5325 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5326 case DW_AT_producer
: return "DW_AT_producer";
5327 case DW_AT_prototyped
: return "DW_AT_prototyped";
5328 case DW_AT_return_addr
: return "DW_AT_return_addr";
5329 case DW_AT_start_scope
: return "DW_AT_start_scope";
5330 case DW_AT_stride_size
: return "DW_AT_stride_size";
5331 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5332 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5333 case DW_AT_accessibility
: return "DW_AT_accessibility";
5334 case DW_AT_address_class
: return "DW_AT_address_class";
5335 case DW_AT_artificial
: return "DW_AT_artificial";
5336 case DW_AT_base_types
: return "DW_AT_base_types";
5337 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5338 case DW_AT_count
: return "DW_AT_count";
5339 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5340 case DW_AT_decl_column
: return "DW_AT_decl_column";
5341 case DW_AT_decl_file
: return "DW_AT_decl_file";
5342 case DW_AT_decl_line
: return "DW_AT_decl_line";
5343 case DW_AT_declaration
: return "DW_AT_declaration";
5344 case DW_AT_discr_list
: return "DW_AT_discr_list";
5345 case DW_AT_encoding
: return "DW_AT_encoding";
5346 case DW_AT_external
: return "DW_AT_external";
5347 case DW_AT_frame_base
: return "DW_AT_frame_base";
5348 case DW_AT_friend
: return "DW_AT_friend";
5349 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5350 case DW_AT_macro_info
: return "DW_AT_macro_info";
5351 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5352 case DW_AT_priority
: return "DW_AT_priority";
5353 case DW_AT_segment
: return "DW_AT_segment";
5354 case DW_AT_specification
: return "DW_AT_specification";
5355 case DW_AT_static_link
: return "DW_AT_static_link";
5356 case DW_AT_type
: return "DW_AT_type";
5357 case DW_AT_use_location
: return "DW_AT_use_location";
5358 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5359 case DW_AT_virtuality
: return "DW_AT_virtuality";
5360 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5361 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5362 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5363 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5364 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5365 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5366 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5367 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5368 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5369 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5370 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5371 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5372 case DW_AT_sf_names
: return "DW_AT_sf_names";
5373 case DW_AT_src_info
: return "DW_AT_src_info";
5374 case DW_AT_mac_info
: return "DW_AT_mac_info";
5375 case DW_AT_src_coords
: return "DW_AT_src_coords";
5376 case DW_AT_body_begin
: return "DW_AT_body_begin";
5377 case DW_AT_body_end
: return "DW_AT_body_end";
5380 static char buffer
[100];
5382 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5389 get_FORM_name (form
)
5394 case DW_FORM_addr
: return "DW_FORM_addr";
5395 case DW_FORM_block2
: return "DW_FORM_block2";
5396 case DW_FORM_block4
: return "DW_FORM_block4";
5397 case DW_FORM_data2
: return "DW_FORM_data2";
5398 case DW_FORM_data4
: return "DW_FORM_data4";
5399 case DW_FORM_data8
: return "DW_FORM_data8";
5400 case DW_FORM_string
: return "DW_FORM_string";
5401 case DW_FORM_block
: return "DW_FORM_block";
5402 case DW_FORM_block1
: return "DW_FORM_block1";
5403 case DW_FORM_data1
: return "DW_FORM_data1";
5404 case DW_FORM_flag
: return "DW_FORM_flag";
5405 case DW_FORM_sdata
: return "DW_FORM_sdata";
5406 case DW_FORM_strp
: return "DW_FORM_strp";
5407 case DW_FORM_udata
: return "DW_FORM_udata";
5408 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5409 case DW_FORM_ref1
: return "DW_FORM_ref1";
5410 case DW_FORM_ref2
: return "DW_FORM_ref2";
5411 case DW_FORM_ref4
: return "DW_FORM_ref4";
5412 case DW_FORM_ref8
: return "DW_FORM_ref8";
5413 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5414 case DW_FORM_indirect
: return "DW_FORM_indirect";
5417 static char buffer
[100];
5419 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5425 /* FIXME: There are better and more effiecint ways to handle
5426 these structures. For now though, I just want something that
5427 is simple to implement. */
5428 typedef struct abbrev_attr
5430 unsigned long attribute
;
5432 struct abbrev_attr
* next
;
5436 typedef struct abbrev_entry
5438 unsigned long entry
;
5441 struct abbrev_attr
* first_attr
;
5442 struct abbrev_attr
* last_attr
;
5443 struct abbrev_entry
* next
;
5447 static abbrev_entry
* first_abbrev
= NULL
;
5448 static abbrev_entry
* last_abbrev
= NULL
;
5451 free_abbrevs
PARAMS ((void))
5453 abbrev_entry
* abbrev
;
5455 for (abbrev
= first_abbrev
; abbrev
;)
5457 abbrev_entry
* next
= abbrev
->next
;
5460 for (attr
= abbrev
->first_attr
; attr
;)
5462 abbrev_attr
* next
= attr
->next
;
5472 last_abbrev
= first_abbrev
= NULL
;
5476 add_abbrev (number
, tag
, children
)
5477 unsigned long number
;
5481 abbrev_entry
* entry
;
5483 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
5489 entry
->entry
= number
;
5491 entry
->children
= children
;
5492 entry
->first_attr
= NULL
;
5493 entry
->last_attr
= NULL
;
5496 if (first_abbrev
== NULL
)
5497 first_abbrev
= entry
;
5499 last_abbrev
->next
= entry
;
5501 last_abbrev
= entry
;
5505 add_abbrev_attr (attribute
, form
)
5506 unsigned long attribute
;
5511 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
5517 attr
->attribute
= attribute
;
5521 if (last_abbrev
->first_attr
== NULL
)
5522 last_abbrev
->first_attr
= attr
;
5524 last_abbrev
->last_attr
->next
= attr
;
5526 last_abbrev
->last_attr
= attr
;
5529 /* Processes the (partial) contents of a .debug_abbrev section.
5530 Returns NULL if the end of the section was encountered.
5531 Returns the address after the last byte read if the end of
5532 an abbreviation set was found. */
5534 static unsigned char *
5535 process_abbrev_section (start
, end
)
5536 unsigned char * start
;
5537 unsigned char * end
;
5539 if (first_abbrev
!= NULL
)
5545 unsigned long entry
;
5547 unsigned long attribute
;
5550 entry
= read_leb128 (start
, & bytes_read
, 0);
5551 start
+= bytes_read
;
5553 /* A single zero is supposed to end the section according
5554 to the standard. If there's more, then signal that to
5557 return start
== end
? NULL
: start
;
5559 tag
= read_leb128 (start
, & bytes_read
, 0);
5560 start
+= bytes_read
;
5562 children
= * start
++;
5564 add_abbrev (entry
, tag
, children
);
5570 attribute
= read_leb128 (start
, & bytes_read
, 0);
5571 start
+= bytes_read
;
5573 form
= read_leb128 (start
, & bytes_read
, 0);
5574 start
+= bytes_read
;
5577 add_abbrev_attr (attribute
, form
);
5579 while (attribute
!= 0);
5587 display_debug_abbrev (section
, start
, file
)
5588 Elf32_Internal_Shdr
* section
;
5589 unsigned char * start
;
5590 FILE * file ATTRIBUTE_UNUSED
;
5592 abbrev_entry
* entry
;
5593 unsigned char * end
= start
+ section
->sh_size
;
5595 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5599 start
= process_abbrev_section (start
, end
);
5601 printf (_(" Number TAG\n"));
5603 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5607 printf (_(" %ld %s [%s]\n"),
5609 get_TAG_name (entry
->tag
),
5610 entry
->children
? _("has children") : _("no children"));
5612 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5614 printf (_(" %-18s %s\n"),
5615 get_AT_name (attr
->attribute
),
5616 get_FORM_name (attr
->form
));
5628 static unsigned char *
5629 display_block (data
, length
)
5630 unsigned char * data
;
5631 unsigned long length
;
5633 printf (_(" %lu byte block: "), length
);
5636 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
5642 decode_location_expression (data
, pointer_size
, length
)
5643 unsigned char * data
;
5644 unsigned int pointer_size
;
5645 unsigned long length
;
5649 unsigned long uvalue
;
5650 unsigned char *end
= data
+ length
;
5659 printf ("DW_OP_addr: %lx",
5660 (unsigned long) byte_get (data
, pointer_size
));
5661 data
+= pointer_size
;
5664 printf ("DW_OP_deref");
5667 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
5670 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
5673 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
5677 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
5681 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
5685 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
5689 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
5690 (unsigned long) byte_get (data
+ 4, 4));
5694 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
5695 (long) byte_get (data
+ 4, 4));
5699 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
5703 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
5707 printf ("DW_OP_dup");
5710 printf ("DW_OP_drop");
5713 printf ("DW_OP_over");
5716 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
5719 printf ("DW_OP_swap");
5722 printf ("DW_OP_rot");
5725 printf ("DW_OP_xderef");
5728 printf ("DW_OP_abs");
5731 printf ("DW_OP_and");
5734 printf ("DW_OP_div");
5737 printf ("DW_OP_minus");
5740 printf ("DW_OP_mod");
5743 printf ("DW_OP_mul");
5746 printf ("DW_OP_neg");
5749 printf ("DW_OP_not");
5752 printf ("DW_OP_or");
5755 printf ("DW_OP_plus");
5757 case DW_OP_plus_uconst
:
5758 printf ("DW_OP_plus_uconst: %lu",
5759 read_leb128 (data
, &bytes_read
, 0));
5763 printf ("DW_OP_shl");
5766 printf ("DW_OP_shr");
5769 printf ("DW_OP_shra");
5772 printf ("DW_OP_xor");
5775 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
5779 printf ("DW_OP_eq");
5782 printf ("DW_OP_ge");
5785 printf ("DW_OP_gt");
5788 printf ("DW_OP_le");
5791 printf ("DW_OP_lt");
5794 printf ("DW_OP_ne");
5797 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
5833 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
5868 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
5903 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
5904 read_leb128 (data
, &bytes_read
, 1));
5909 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
5913 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
5917 uvalue
= read_leb128 (data
, &bytes_read
, 0);
5919 printf ("DW_OP_bregx: %lu %ld", uvalue
,
5920 read_leb128 (data
, &bytes_read
, 1));
5924 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
5927 case DW_OP_deref_size
:
5928 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
5930 case DW_OP_xderef_size
:
5931 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
5934 printf ("DW_OP_nop");
5938 if (op
>= DW_OP_lo_user
5939 && op
<= DW_OP_hi_user
)
5940 printf (_("(User defined location op)"));
5942 printf (_("(Unknown location op)"));
5943 /* No way to tell where the next op is, so just bail. */
5950 static unsigned char *
5951 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
5952 unsigned long attribute
;
5954 unsigned char * data
;
5955 unsigned long cu_offset
;
5956 unsigned long pointer_size
;
5958 unsigned long uvalue
= 0;
5959 unsigned char * block_start
= NULL
;
5962 printf (" %-18s:", get_AT_name (attribute
));
5969 case DW_FORM_ref_addr
:
5971 uvalue
= byte_get (data
, pointer_size
);
5972 data
+= pointer_size
;
5978 uvalue
= byte_get (data
++, 1);
5983 uvalue
= byte_get (data
, 2);
5989 uvalue
= byte_get (data
, 4);
5994 uvalue
= read_leb128 (data
, & bytes_read
, 1);
5998 case DW_FORM_ref_udata
:
6000 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6007 case DW_FORM_ref_addr
:
6008 printf (" <#%lx>", uvalue
);
6014 case DW_FORM_ref_udata
:
6015 printf (" <%lx>", uvalue
+ cu_offset
);
6019 printf (" %#lx", uvalue
);
6027 printf (" %ld", uvalue
);
6032 uvalue
= byte_get (data
, 4);
6033 printf (" %lx", uvalue
);
6034 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
6038 case DW_FORM_string
:
6039 printf (" %s", data
);
6040 data
+= strlen ((char *) data
) + 1;
6044 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6045 block_start
= data
+ bytes_read
;
6046 data
= display_block (block_start
, uvalue
);
6049 case DW_FORM_block1
:
6050 uvalue
= byte_get (data
, 1);
6051 block_start
= data
+ 1;
6052 data
= display_block (block_start
, uvalue
);
6055 case DW_FORM_block2
:
6056 uvalue
= byte_get (data
, 2);
6057 block_start
= data
+ 2;
6058 data
= display_block (block_start
, uvalue
);
6061 case DW_FORM_block4
:
6062 uvalue
= byte_get (data
, 4);
6063 block_start
= data
+ 4;
6064 data
= display_block (block_start
, uvalue
);
6068 case DW_FORM_indirect
:
6069 warn (_("Unable to handle FORM: %d"), form
);
6073 warn (_("Unrecognised form: %d"), form
);
6077 /* For some attributes we can display futher information. */
6086 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6087 case DW_INL_inlined
: printf (_("(inlined)")); break;
6088 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6089 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6090 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6094 case DW_AT_language
:
6097 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6098 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6099 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6100 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6101 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6102 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6103 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6104 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6105 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6106 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6107 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6108 default: printf ("(Unknown: %lx)", uvalue
); break;
6112 case DW_AT_encoding
:
6115 case DW_ATE_void
: printf ("(void)"); break;
6116 case DW_ATE_address
: printf ("(machine address)"); break;
6117 case DW_ATE_boolean
: printf ("(boolean)"); break;
6118 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6119 case DW_ATE_float
: printf ("(float)"); break;
6120 case DW_ATE_signed
: printf ("(signed)"); break;
6121 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6122 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6123 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6125 if (uvalue
>= DW_ATE_lo_user
6126 && uvalue
<= DW_ATE_hi_user
)
6127 printf ("(user defined type)");
6129 printf ("(unknown type)");
6134 case DW_AT_accessibility
:
6137 case DW_ACCESS_public
: printf ("(public)"); break;
6138 case DW_ACCESS_protected
: printf ("(protected)"); break;
6139 case DW_ACCESS_private
: printf ("(private)"); break;
6140 default: printf ("(unknown accessibility)"); break;
6144 case DW_AT_visibility
:
6147 case DW_VIS_local
: printf ("(local)"); break;
6148 case DW_VIS_exported
: printf ("(exported)"); break;
6149 case DW_VIS_qualified
: printf ("(qualified)"); break;
6150 default: printf ("(unknown visibility)"); break;
6154 case DW_AT_virtuality
:
6157 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6158 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6159 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6160 default: printf ("(unknown virtuality)"); break;
6164 case DW_AT_identifier_case
:
6167 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6168 case DW_ID_up_case
: printf ("(up_case)"); break;
6169 case DW_ID_down_case
: printf ("(down_case)"); break;
6170 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6171 default: printf ("(unknown case)"); break;
6175 case DW_AT_calling_convention
:
6178 case DW_CC_normal
: printf ("(normal)"); break;
6179 case DW_CC_program
: printf ("(program)"); break;
6180 case DW_CC_nocall
: printf ("(nocall)"); break;
6182 if (uvalue
>= DW_CC_lo_user
6183 && uvalue
<= DW_CC_hi_user
)
6184 printf ("(user defined)");
6186 printf ("(unknown convention)");
6190 case DW_AT_frame_base
:
6191 case DW_AT_location
:
6192 case DW_AT_data_member_location
:
6193 case DW_AT_vtable_elem_location
:
6197 decode_location_expression (block_start
, pointer_size
, uvalue
);
6211 display_debug_info (section
, start
, file
)
6212 Elf32_Internal_Shdr
* section
;
6213 unsigned char * start
;
6216 unsigned char * end
= start
+ section
->sh_size
;
6217 unsigned char * section_begin
= start
;
6219 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6223 DWARF2_External_CompUnit
* external
;
6224 DWARF2_Internal_CompUnit compunit
;
6225 unsigned char * tags
;
6228 unsigned long cu_offset
;
6230 external
= (DWARF2_External_CompUnit
*) start
;
6232 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6233 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6234 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6235 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6237 tags
= start
+ sizeof (* external
);
6238 cu_offset
= start
- section_begin
;
6239 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6241 if (compunit
.cu_version
!= 2)
6243 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6247 printf (_(" Compilation Unit:\n"));
6248 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6249 printf (_(" Version: %d\n"), compunit
.cu_version
);
6250 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6251 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6253 if (first_abbrev
!= NULL
)
6256 /* Read in the abbrevs used by this compilation unit. */
6259 Elf32_Internal_Shdr
* sec
;
6260 unsigned char * begin
;
6262 /* Locate the .debug_abbrev section and process it. */
6263 for (i
= 0, sec
= section_headers
;
6264 i
< elf_header
.e_shnum
;
6266 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6269 if (i
== -1 || sec
->sh_size
== 0)
6271 warn (_("Unable to locate .debug_abbrev section!\n"));
6275 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6276 "debug_abbrev section data");
6278 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6279 begin
+ sec
->sh_size
);
6285 while (tags
< start
)
6288 unsigned long abbrev_number
;
6289 abbrev_entry
* entry
;
6292 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6295 /* A null DIE marks the end of a list of children. */
6296 if (abbrev_number
== 0)
6302 /* Scan through the abbreviation list until we reach the
6304 for (entry
= first_abbrev
;
6305 entry
&& entry
->entry
!= abbrev_number
;
6306 entry
= entry
->next
)
6311 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6316 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6317 level
, tags
- section_begin
- bytes_read
,
6319 get_TAG_name (entry
->tag
));
6321 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6322 tags
= read_and_display_attr (attr
->attribute
,
6325 compunit
.cu_pointer_size
);
6327 if (entry
->children
)
6338 display_debug_aranges (section
, start
, file
)
6339 Elf32_Internal_Shdr
* section
;
6340 unsigned char * start
;
6341 FILE * file ATTRIBUTE_UNUSED
;
6343 unsigned char * end
= start
+ section
->sh_size
;
6345 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6349 DWARF2_External_ARange
* external
;
6350 DWARF2_Internal_ARange arange
;
6351 unsigned char * ranges
;
6352 unsigned long length
;
6353 unsigned long address
;
6356 external
= (DWARF2_External_ARange
*) start
;
6358 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6359 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6360 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6361 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6362 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6364 printf (_(" Length: %ld\n"), arange
.ar_length
);
6365 printf (_(" Version: %d\n"), arange
.ar_version
);
6366 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6367 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6368 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6370 printf (_("\n Address Length\n"));
6372 ranges
= start
+ sizeof (* external
);
6374 /* Must pad to an alignment boundary that is twice the pointer size. */
6375 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
6377 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6381 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6383 ranges
+= arange
.ar_pointer_size
;
6385 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6387 ranges
+= arange
.ar_pointer_size
;
6389 /* A pair of zeros marks the end of the list. */
6390 if (address
== 0 && length
== 0)
6393 printf (" %8.8lx %lu\n", address
, length
);
6396 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6406 display_debug_not_supported (section
, start
, file
)
6407 Elf32_Internal_Shdr
* section
;
6408 unsigned char * start ATTRIBUTE_UNUSED
;
6409 FILE * file ATTRIBUTE_UNUSED
;
6411 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6412 SECTION_NAME (section
));
6417 /* Pre-scan the .debug_info section to record the size of address.
6418 When dumping the .debug_line, we use that size information, assuming
6419 that all compilation units have the same address size. */
6421 prescan_debug_info (section
, start
, file
)
6422 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
6423 unsigned char * start
;
6424 FILE * file ATTRIBUTE_UNUSED
;
6426 DWARF2_External_CompUnit
* external
;
6428 external
= (DWARF2_External_CompUnit
*) start
;
6430 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6434 /* A structure containing the name of a debug section and a pointer
6435 to a function that can decode it. The third field is a prescan
6436 function to be run over the section before displaying any of the
6441 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6442 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6446 { ".debug_info", display_debug_info
, prescan_debug_info
},
6447 { ".debug_abbrev", display_debug_abbrev
, NULL
},
6448 { ".debug_line", display_debug_lines
, NULL
},
6449 { ".debug_aranges", display_debug_aranges
, NULL
},
6450 { ".debug_pubnames", display_debug_pubnames
, NULL
},
6451 { ".debug_macinfo", display_debug_not_supported
, NULL
},
6452 { ".debug_frame", display_debug_not_supported
, NULL
},
6453 { ".debug_str", display_debug_not_supported
, NULL
},
6454 { ".debug_static_func", display_debug_not_supported
, NULL
},
6455 { ".debug_static_vars", display_debug_not_supported
, NULL
},
6456 { ".debug_types", display_debug_not_supported
, NULL
},
6457 { ".debug_weaknames", display_debug_not_supported
, NULL
}
6461 display_debug_section (section
, file
)
6462 Elf32_Internal_Shdr
* section
;
6465 char * name
= SECTION_NAME (section
);
6466 bfd_size_type length
;
6467 unsigned char * start
;
6470 length
= section
->sh_size
;
6473 printf (_("\nSection '%s' has no debugging data.\n"), name
);
6477 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6478 "debug section data");
6480 /* See if we know how to display the contents of this section. */
6481 for (i
= NUM_ELEM (debug_displays
); i
--;)
6482 if (strcmp (debug_displays
[i
].name
, name
) == 0)
6484 debug_displays
[i
].display (section
, start
, file
);
6489 printf (_("Unrecognised debug section: %s\n"), name
);
6493 /* If we loaded in the abbrev section at some point,
6494 we must release it here. */
6495 if (first_abbrev
!= NULL
)
6502 process_section_contents (file
)
6505 Elf32_Internal_Shdr
* section
;
6511 /* Pre-scan the debug sections to find some debug information not
6512 present in some of them. For the .debug_line, we must find out the
6513 size of address (specified in .debug_info and .debug_aranges). */
6514 for (i
= 0, section
= section_headers
;
6515 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6518 char * name
= SECTION_NAME (section
);
6521 if (section
->sh_size
== 0)
6524 /* See if there is some pre-scan operation for this section. */
6525 for (j
= NUM_ELEM (debug_displays
); j
--;)
6526 if (strcmp (debug_displays
[j
].name
, name
) == 0)
6528 if (debug_displays
[j
].prescan
!= NULL
)
6530 bfd_size_type length
;
6531 unsigned char * start
;
6533 length
= section
->sh_size
;
6534 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6535 "debug section data");
6537 debug_displays
[j
].prescan (section
, start
, file
);
6545 for (i
= 0, section
= section_headers
;
6546 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6549 #ifdef SUPPORT_DISASSEMBLY
6550 if (dump_sects
[i
] & DISASS_DUMP
)
6551 disassemble_section (section
, file
);
6553 if (dump_sects
[i
] & HEX_DUMP
)
6554 dump_section (section
, file
);
6556 if (dump_sects
[i
] & DEBUG_DUMP
)
6557 display_debug_section (section
, file
);
6560 if (i
< num_dump_sects
)
6561 warn (_("Some sections were not dumped because they do not exist!\n"));
6567 process_mips_fpe_exception (mask
)
6573 if (mask
& OEX_FPU_INEX
)
6574 fputs ("INEX", stdout
), first
= 0;
6575 if (mask
& OEX_FPU_UFLO
)
6576 printf ("%sUFLO", first
? "" : "|"), first
= 0;
6577 if (mask
& OEX_FPU_OFLO
)
6578 printf ("%sOFLO", first
? "" : "|"), first
= 0;
6579 if (mask
& OEX_FPU_DIV0
)
6580 printf ("%sDIV0", first
? "" : "|"), first
= 0;
6581 if (mask
& OEX_FPU_INVAL
)
6582 printf ("%sINVAL", first
? "" : "|");
6585 fputs ("0", stdout
);
6589 process_mips_specific (file
)
6592 Elf_Internal_Dyn
* entry
;
6593 size_t liblist_offset
= 0;
6594 size_t liblistno
= 0;
6595 size_t conflictsno
= 0;
6596 size_t options_offset
= 0;
6597 size_t conflicts_offset
= 0;
6599 /* We have a lot of special sections. Thanks SGI! */
6600 if (dynamic_segment
== NULL
)
6601 /* No information available. */
6604 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
6605 switch (entry
->d_tag
)
6607 case DT_MIPS_LIBLIST
:
6608 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
6610 case DT_MIPS_LIBLISTNO
:
6611 liblistno
= entry
->d_un
.d_val
;
6613 case DT_MIPS_OPTIONS
:
6614 options_offset
= entry
->d_un
.d_val
- loadaddr
;
6616 case DT_MIPS_CONFLICT
:
6617 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
6619 case DT_MIPS_CONFLICTNO
:
6620 conflictsno
= entry
->d_un
.d_val
;
6626 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
6628 Elf32_External_Lib
* elib
;
6631 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
6632 elib
, Elf32_External_Lib
*, "liblist");
6634 printf ("\nSection '.liblist' contains %lu entries:\n",
6635 (unsigned long) liblistno
);
6636 fputs (" Library Time Stamp Checksum Version Flags\n",
6639 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
6646 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
6647 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
6648 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
6649 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
6650 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
6652 tmp
= gmtime (&time
);
6653 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
6654 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6655 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6657 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
6658 dynamic_strings
+ liblist
.l_name
, timebuf
,
6659 liblist
.l_checksum
, liblist
.l_version
);
6661 if (liblist
.l_flags
== 0)
6672 { " EXACT_MATCH", LL_EXACT_MATCH
},
6673 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
6674 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
6675 { " EXPORTS", LL_EXPORTS
},
6676 { " DELAY_LOAD", LL_DELAY_LOAD
},
6677 { " DELTA", LL_DELTA
}
6679 int flags
= liblist
.l_flags
;
6683 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
6685 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
6687 fputs (l_flags_vals
[fcnt
].name
, stdout
);
6688 flags
^= l_flags_vals
[fcnt
].bit
;
6691 printf (" %#x", (unsigned int) flags
);
6700 if (options_offset
!= 0)
6702 Elf_External_Options
* eopt
;
6703 Elf_Internal_Shdr
* sect
= section_headers
;
6704 Elf_Internal_Options
* iopt
;
6705 Elf_Internal_Options
* option
;
6709 /* Find the section header so that we get the size. */
6710 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
6713 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
6714 Elf_External_Options
*, "options");
6716 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
6720 error (_("Out of memory"));
6727 while (offset
< sect
->sh_size
)
6729 Elf_External_Options
* eoption
;
6731 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
6733 option
->kind
= BYTE_GET (eoption
->kind
);
6734 option
->size
= BYTE_GET (eoption
->size
);
6735 option
->section
= BYTE_GET (eoption
->section
);
6736 option
->info
= BYTE_GET (eoption
->info
);
6738 offset
+= option
->size
;
6744 printf (_("\nSection '%s' contains %d entries:\n"),
6745 string_table
+ sect
->sh_name
, cnt
);
6753 switch (option
->kind
)
6756 /* This shouldn't happen. */
6757 printf (" NULL %d %lx", option
->section
, option
->info
);
6760 printf (" REGINFO ");
6761 if (elf_header
.e_machine
== EM_MIPS
)
6764 Elf32_External_RegInfo
*ereg
;
6765 Elf32_RegInfo reginfo
;
6767 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
6768 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6769 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6770 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6771 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6772 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6773 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
6775 printf ("GPR %08lx GP 0x%lx\n",
6777 (unsigned long) reginfo
.ri_gp_value
);
6778 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6779 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6780 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6785 Elf64_External_RegInfo
* ereg
;
6786 Elf64_Internal_RegInfo reginfo
;
6788 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
6789 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6790 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6791 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6792 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6793 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6794 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
6796 printf ("GPR %08lx GP 0x",
6797 reginfo
.ri_gprmask
);
6798 printf_vma (reginfo
.ri_gp_value
);
6801 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6802 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6803 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6807 case ODK_EXCEPTIONS
:
6808 fputs (" EXCEPTIONS fpe_min(", stdout
);
6809 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
6810 fputs (") fpe_max(", stdout
);
6811 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
6812 fputs (")", stdout
);
6814 if (option
->info
& OEX_PAGE0
)
6815 fputs (" PAGE0", stdout
);
6816 if (option
->info
& OEX_SMM
)
6817 fputs (" SMM", stdout
);
6818 if (option
->info
& OEX_FPDBUG
)
6819 fputs (" FPDBUG", stdout
);
6820 if (option
->info
& OEX_DISMISS
)
6821 fputs (" DISMISS", stdout
);
6824 fputs (" PAD ", stdout
);
6825 if (option
->info
& OPAD_PREFIX
)
6826 fputs (" PREFIX", stdout
);
6827 if (option
->info
& OPAD_POSTFIX
)
6828 fputs (" POSTFIX", stdout
);
6829 if (option
->info
& OPAD_SYMBOL
)
6830 fputs (" SYMBOL", stdout
);
6833 fputs (" HWPATCH ", stdout
);
6834 if (option
->info
& OHW_R4KEOP
)
6835 fputs (" R4KEOP", stdout
);
6836 if (option
->info
& OHW_R8KPFETCH
)
6837 fputs (" R8KPFETCH", stdout
);
6838 if (option
->info
& OHW_R5KEOP
)
6839 fputs (" R5KEOP", stdout
);
6840 if (option
->info
& OHW_R5KCVTL
)
6841 fputs (" R5KCVTL", stdout
);
6844 fputs (" FILL ", stdout
);
6845 /* XXX Print content of info word? */
6848 fputs (" TAGS ", stdout
);
6849 /* XXX Print content of info word? */
6852 fputs (" HWAND ", stdout
);
6853 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6854 fputs (" R4KEOP_CHECKED", stdout
);
6855 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6856 fputs (" R4KEOP_CLEAN", stdout
);
6859 fputs (" HWOR ", stdout
);
6860 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6861 fputs (" R4KEOP_CHECKED", stdout
);
6862 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6863 fputs (" R4KEOP_CLEAN", stdout
);
6866 printf (" GP_GROUP %#06lx self-contained %#06lx",
6867 option
->info
& OGP_GROUP
,
6868 (option
->info
& OGP_SELF
) >> 16);
6871 printf (" IDENT %#06lx self-contained %#06lx",
6872 option
->info
& OGP_GROUP
,
6873 (option
->info
& OGP_SELF
) >> 16);
6876 /* This shouldn't happen. */
6877 printf (" %3d ??? %d %lx",
6878 option
->kind
, option
->section
, option
->info
);
6882 len
= sizeof (*eopt
);
6883 while (len
< option
->size
)
6884 if (((char *) option
)[len
] >= ' '
6885 && ((char *) option
)[len
] < 0x7f)
6886 printf ("%c", ((char *) option
)[len
++]);
6888 printf ("\\%03o", ((char *) option
)[len
++]);
6890 fputs ("\n", stdout
);
6897 if (conflicts_offset
!= 0 && conflictsno
!= 0)
6899 Elf32_External_Conflict
* econf32
;
6900 Elf64_External_Conflict
* econf64
;
6901 Elf32_Conflict
* iconf
;
6904 if (dynamic_symbols
== NULL
)
6906 error (_("conflict list with without table"));
6910 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
6913 error (_("Out of memory"));
6919 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
6920 econf32
, Elf32_External_Conflict
*, "conflict");
6922 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6923 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
6927 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
6928 econf64
, Elf64_External_Conflict
*, "conflict");
6930 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6931 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
6934 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
6935 puts (_(" Num: Index Value Name"));
6937 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6939 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
6941 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
6942 print_vma (psym
->st_value
, FULL_HEX
);
6943 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
6953 get_note_type (e_type
)
6956 static char buff
[64];
6960 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
6961 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
6962 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
6963 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
6964 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
6965 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
6966 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
6967 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
6968 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6969 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
6970 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
6972 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
6977 /* Note that by the ELF standard, the name field is already null byte
6978 terminated, and namesz includes the terminating null byte.
6979 I.E. the value of namesz for the name "FSF" is 4.
6981 If the value of namesz is zero, there is no name present. */
6983 process_note (pnote
)
6984 Elf32_Internal_Note
* pnote
;
6986 printf (" %s\t\t0x%08lx\t%s\n",
6987 pnote
->namesz
? pnote
->namedata
: "(NONE)",
6988 pnote
->descsz
, get_note_type (pnote
->type
));
6994 process_corefile_note_segment (file
, offset
, length
)
6999 Elf_External_Note
* pnotes
;
7000 Elf_External_Note
* external
;
7006 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
7010 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7011 (unsigned long) offset
, (unsigned long) length
);
7012 printf (_(" Owner\t\tData size\tDescription\n"));
7014 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
7016 Elf32_Internal_Note inote
;
7019 inote
.type
= BYTE_GET (external
->type
);
7020 inote
.namesz
= BYTE_GET (external
->namesz
);
7021 inote
.namedata
= external
->name
;
7022 inote
.descsz
= BYTE_GET (external
->descsz
);
7023 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
7024 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
7026 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
7028 /* Verify that name is null terminated. It appears that at least
7029 one version of Linux (RedHat 6.0) generates corefiles that don't
7030 comply with the ELF spec by failing to include the null byte in
7032 if (inote
.namedata
[inote
.namesz
] != '\0')
7034 temp
= malloc (inote
.namesz
+ 1);
7038 error (_("Out of memory\n"));
7043 strncpy (temp
, inote
.namedata
, inote
.namesz
);
7044 temp
[inote
.namesz
] = 0;
7046 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7047 inote
.namedata
= temp
;
7050 res
&= process_note (& inote
);
7065 process_corefile_note_segments (file
)
7068 Elf_Internal_Phdr
* program_headers
;
7069 Elf_Internal_Phdr
* segment
;
7073 program_headers
= (Elf_Internal_Phdr
*) malloc
7074 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
7076 if (program_headers
== NULL
)
7078 error (_("Out of memory\n"));
7083 i
= get_32bit_program_headers (file
, program_headers
);
7085 i
= get_64bit_program_headers (file
, program_headers
);
7089 free (program_headers
);
7093 for (i
= 0, segment
= program_headers
;
7094 i
< elf_header
.e_phnum
;
7097 if (segment
->p_type
== PT_NOTE
)
7098 res
&= process_corefile_note_segment (file
,
7099 (bfd_vma
) segment
->p_offset
,
7100 (bfd_vma
) segment
->p_filesz
);
7103 free (program_headers
);
7109 process_corefile_contents (file
)
7112 /* If we have not been asked to display the notes then do nothing. */
7116 /* If file is not a core file then exit. */
7117 if (elf_header
.e_type
!= ET_CORE
)
7120 /* No program headers means no NOTE segment. */
7121 if (elf_header
.e_phnum
== 0)
7123 printf (_("No note segments present in the core file.\n"));
7127 return process_corefile_note_segments (file
);
7131 process_arch_specific (file
)
7137 switch (elf_header
.e_machine
)
7140 case EM_MIPS_RS4_BE
:
7141 return process_mips_specific (file
);
7150 get_file_header (file
)
7153 /* Read in the identity array. */
7154 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
7157 /* Determine how to read the rest of the header. */
7158 switch (elf_header
.e_ident
[EI_DATA
])
7160 default: /* fall through */
7161 case ELFDATANONE
: /* fall through */
7162 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
7163 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
7166 /* For now we only support 32 bit and 64 bit ELF files. */
7167 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
7169 /* Read in the rest of the header. */
7172 Elf32_External_Ehdr ehdr32
;
7174 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
7177 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
7178 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
7179 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
7180 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
7181 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
7182 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
7183 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
7184 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
7185 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
7186 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
7187 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
7188 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
7189 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
7193 Elf64_External_Ehdr ehdr64
;
7195 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7196 we will not be able to cope with the 64bit data found in
7197 64 ELF files. Detect this now and abort before we start
7198 overwritting things. */
7199 if (sizeof (bfd_vma
) < 8)
7201 error (_("This instance of readelf has been built without support for a\n"));
7202 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7206 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
7209 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
7210 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
7211 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
7212 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
7213 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
7214 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
7215 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
7216 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
7217 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
7218 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
7219 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
7220 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
7221 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
7228 process_file (file_name
)
7232 struct stat statbuf
;
7235 if (stat (file_name
, & statbuf
) < 0)
7237 error (_("Cannot stat input file %s.\n"), file_name
);
7241 file
= fopen (file_name
, "rb");
7244 error (_("Input file %s not found.\n"), file_name
);
7248 if (! get_file_header (file
))
7250 error (_("%s: Failed to read file header\n"), file_name
);
7255 /* Initialise per file variables. */
7256 for (i
= NUM_ELEM (version_info
); i
--;)
7257 version_info
[i
] = 0;
7259 for (i
= NUM_ELEM (dynamic_info
); i
--;)
7260 dynamic_info
[i
] = 0;
7262 /* Process the file. */
7264 printf (_("\nFile: %s\n"), file_name
);
7266 if (! process_file_header ())
7272 process_section_headers (file
);
7274 process_program_headers (file
);
7276 process_dynamic_segment (file
);
7278 process_relocs (file
);
7280 process_symbol_table (file
);
7282 process_syminfo (file
);
7284 process_version_sections (file
);
7286 process_section_contents (file
);
7288 process_corefile_contents (file
);
7290 process_arch_specific (file
);
7294 if (section_headers
)
7296 free (section_headers
);
7297 section_headers
= NULL
;
7302 free (string_table
);
7303 string_table
= NULL
;
7306 if (dynamic_strings
)
7308 free (dynamic_strings
);
7309 dynamic_strings
= NULL
;
7312 if (dynamic_symbols
)
7314 free (dynamic_symbols
);
7315 dynamic_symbols
= NULL
;
7316 num_dynamic_syms
= 0;
7319 if (dynamic_syminfo
)
7321 free (dynamic_syminfo
);
7322 dynamic_syminfo
= NULL
;
7326 #ifdef SUPPORT_DISASSEMBLY
7327 /* Needed by the i386 disassembler. For extra credit, someone could
7328 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7332 print_address (unsigned int addr
, FILE * outfile
)
7334 fprintf (outfile
,"0x%8.8x", addr
);
7337 /* Needed by the i386 disassembler. */
7339 db_task_printsym (unsigned int addr
)
7341 print_address (addr
, stderr
);
7350 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7351 setlocale (LC_MESSAGES
, "");
7353 bindtextdomain (PACKAGE
, LOCALEDIR
);
7354 textdomain (PACKAGE
);
7356 parse_args (argc
, argv
);
7358 if (optind
< (argc
- 1))
7361 while (optind
< argc
)
7362 process_file (argv
[optind
++]);
7364 if (dump_sects
!= NULL
)