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"
80 char * program_name
= "readelf";
81 unsigned int dynamic_addr
;
82 bfd_size_type dynamic_size
;
83 unsigned int rela_addr
;
84 unsigned int rela_size
;
85 char * dynamic_strings
;
87 unsigned long num_dynamic_syms
;
88 Elf_Internal_Sym
* dynamic_symbols
;
89 Elf_Internal_Syminfo
* dynamic_syminfo
;
90 unsigned long dynamic_syminfo_offset
;
91 unsigned int dynamic_syminfo_nent
;
92 char program_interpreter
[64];
93 int dynamic_info
[DT_JMPREL
+ 1];
96 Elf_Internal_Ehdr elf_header
;
97 Elf_Internal_Shdr
* section_headers
;
98 Elf_Internal_Dyn
* dynamic_segment
;
105 int do_using_dynamic
;
112 int do_debug_abbrevs
;
114 int do_debug_pubnames
;
115 int do_debug_aranges
;
120 /* A dynamic array of flags indicating which sections require dumping. */
121 char * dump_sects
= NULL
;
122 unsigned int num_dump_sects
= 0;
124 #define HEX_DUMP (1 << 0)
125 #define DISASS_DUMP (1 << 1)
126 #define DEBUG_DUMP (1 << 2)
128 /* How to rpint a vma value. */
129 typedef enum print_mode
141 /* Forward declarations for dumb compilers. */
142 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
143 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
144 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
145 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
146 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
147 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
148 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
149 static const char * get_dynamic_type
PARAMS ((unsigned long));
150 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
151 static char * get_file_type
PARAMS ((unsigned));
152 static char * get_machine_name
PARAMS ((unsigned));
153 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
154 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
155 static const char * get_mips_segment_type
PARAMS ((unsigned long));
156 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
157 static const char * get_segment_type
PARAMS ((unsigned long));
158 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
159 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
160 static const char * get_section_type_name
PARAMS ((unsigned int));
161 static const char * get_symbol_binding
PARAMS ((unsigned int));
162 static const char * get_symbol_type
PARAMS ((unsigned int));
163 static const char * get_symbol_visibility
PARAMS ((unsigned int));
164 static const char * get_symbol_index_type
PARAMS ((unsigned int));
165 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
166 static void usage
PARAMS ((void));
167 static void parse_args
PARAMS ((int, char **));
168 static int process_file_header
PARAMS ((void));
169 static int process_program_headers
PARAMS ((FILE *));
170 static int process_section_headers
PARAMS ((FILE *));
171 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
172 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
173 static int process_dynamic_segment
PARAMS ((FILE *));
174 static int process_symbol_table
PARAMS ((FILE *));
175 static int process_section_contents
PARAMS ((FILE *));
176 static void process_file
PARAMS ((char *));
177 static int process_relocs
PARAMS ((FILE *));
178 static int process_version_sections
PARAMS ((FILE *));
179 static char * get_ver_flags
PARAMS ((unsigned int));
180 static int get_32bit_section_headers
PARAMS ((FILE *));
181 static int get_64bit_section_headers
PARAMS ((FILE *));
182 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
183 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
184 static int get_file_header
PARAMS ((FILE *));
185 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
186 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
187 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
188 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
189 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
190 #ifdef SUPPORT_DISASSEMBLY
191 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
193 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
194 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
195 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
196 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
197 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
198 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
199 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
200 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
201 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
202 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
203 static void reset_state_machine
PARAMS ((int));
204 static char * get_TAG_name
PARAMS ((unsigned long));
205 static char * get_AT_name
PARAMS ((unsigned long));
206 static char * get_FORM_name
PARAMS ((unsigned long));
207 static void free_abbrevs
PARAMS ((void));
208 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
209 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
210 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
211 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
212 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
213 static void request_dump
PARAMS ((unsigned int, char));
214 static const char * get_elf_class
PARAMS ((unsigned char));
215 static const char * get_data_encoding
PARAMS ((unsigned char));
216 static const char * get_osabi_name
PARAMS ((unsigned char));
217 static int guess_is_rela
PARAMS ((unsigned long));
218 static char * get_note_type
PARAMS ((unsigned int));
219 static int process_note
PARAMS ((Elf32_Internal_Note
*));
220 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
221 static int process_corefile_note_segments
PARAMS ((FILE *));
222 static int process_corefile_contents
PARAMS ((FILE *));
224 typedef int Elf32_Word
;
232 #define SECTION_NAME(X) (string_table + (X)->sh_name)
234 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
236 #define BYTE_GET(field) byte_get (field, sizeof (field))
238 /* If we can support a 64 bit data type then BFD64 should be defined
239 and sizeof (bfd_vma) == 8. In this case when translating from an
240 external 8 byte field to an internal field, we can assume that the
241 internal field is also 8 bytes wide and so we can extact all the data.
242 If, however, BFD64 is not defined, then we must assume that the
243 internal data structure only has 4 byte wide fields that are the
244 equivalent of the 8 byte wide external counterparts, and so we must
245 truncate the data. */
247 #define BYTE_GET8(field) byte_get (field, -8)
249 #define BYTE_GET8(field) byte_get (field, 8)
252 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
254 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
255 if (fseek (file, offset, SEEK_SET)) \
257 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
261 var = (type) malloc (size); \
265 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
269 if (fread (var, size, 1, file) != 1) \
271 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
278 #define GET_DATA(offset, var, reason) \
279 if (fseek (file, offset, SEEK_SET)) \
281 error (_("Unable to seek to %x for %s\n"), offset, reason); \
284 else if (fread (& var, sizeof (var), 1, file) != 1) \
286 error (_("Unable to read data at %x for %s\n"), offset, reason); \
290 #define GET_ELF_SYMBOLS(file, offset, size) \
291 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
292 : get_64bit_elf_symbols (file, offset, size))
295 #ifdef ANSI_PROTOTYPES
297 error (const char * message
, ...)
301 fprintf (stderr
, _("%s: Error: "), program_name
);
302 va_start (args
, message
);
303 vfprintf (stderr
, message
, args
);
309 warn (const char * message
, ...)
313 fprintf (stderr
, _("%s: Warning: "), program_name
);
314 va_start (args
, message
);
315 vfprintf (stderr
, message
, args
);
327 fprintf (stderr
, _("%s: Error: "), program_name
);
329 message
= va_arg (args
, char *);
330 vfprintf (stderr
, message
, args
);
342 fprintf (stderr
, _("%s: Warning: "), program_name
);
344 message
= va_arg (args
, char *);
345 vfprintf (stderr
, message
, args
);
352 byte_get_little_endian (field
, size
)
353 unsigned char * field
;
362 return ((unsigned int) (field
[0]))
363 | (((unsigned int) (field
[1])) << 8);
366 /* We want to extract data from an 8 byte wide field and
367 place it into a 4 byte wide field. Since this is a little
368 endian source we can juts use the 4 byte extraction code. */
371 return ((unsigned long) (field
[0]))
372 | (((unsigned long) (field
[1])) << 8)
373 | (((unsigned long) (field
[2])) << 16)
374 | (((unsigned long) (field
[3])) << 24);
378 /* This is a special case, generated by the BYTE_GET8 macro.
379 It means that we are loading an 8 byte value from a field
380 in an external structure into an 8 byte value in a field
381 in an internal strcuture. */
382 return ((bfd_vma
) (field
[0]))
383 | (((bfd_vma
) (field
[1])) << 8)
384 | (((bfd_vma
) (field
[2])) << 16)
385 | (((bfd_vma
) (field
[3])) << 24)
386 | (((bfd_vma
) (field
[4])) << 32)
387 | (((bfd_vma
) (field
[5])) << 40)
388 | (((bfd_vma
) (field
[6])) << 48)
389 | (((bfd_vma
) (field
[7])) << 56);
392 error (_("Unhandled data length: %d\n"), size
);
397 /* Print a VMA value. */
399 print_vma (vma
, mode
)
409 case FULL_HEX
: printf ("0x"); /* drop through */
410 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
411 case PREFIX_HEX
: printf ("0x"); /* drop through */
412 case HEX
: printf ("%lx", (unsigned long) vma
); break;
413 case DEC
: printf ("%ld", (unsigned long) vma
); break;
414 case DEC_5
: printf ("%5ld", (long) vma
); break;
415 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
436 #if BFD_HOST_64BIT_LONG
439 if (_bfd_int64_high (vma
))
440 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
442 printf ("%lx", _bfd_int64_low (vma
));
447 #if BFD_HOST_64BIT_LONG
450 if (_bfd_int64_high (vma
))
452 printf ("++%ld", _bfd_int64_low (vma
));
454 printf ("%ld", _bfd_int64_low (vma
));
459 #if BFD_HOST_64BIT_LONG
460 printf ("%5ld", vma
);
462 if (_bfd_int64_high (vma
))
464 printf ("++%ld", _bfd_int64_low (vma
));
466 printf ("%5ld", _bfd_int64_low (vma
));
471 #if BFD_HOST_64BIT_LONG
474 if (_bfd_int64_high (vma
))
476 printf ("++%lu", _bfd_int64_low (vma
));
478 printf ("%lu", _bfd_int64_low (vma
));
487 byte_get_big_endian (field
, size
)
488 unsigned char * field
;
497 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
500 return ((unsigned long) (field
[3]))
501 | (((unsigned long) (field
[2])) << 8)
502 | (((unsigned long) (field
[1])) << 16)
503 | (((unsigned long) (field
[0])) << 24);
506 /* Although we are extracing data from an 8 byte wide field, we
507 are returning only 4 bytes of data. */
508 return ((unsigned long) (field
[7]))
509 | (((unsigned long) (field
[6])) << 8)
510 | (((unsigned long) (field
[5])) << 16)
511 | (((unsigned long) (field
[4])) << 24);
515 /* This is a special case, generated by the BYTE_GET8 macro.
516 It means that we are loading an 8 byte value from a field
517 in an external structure into an 8 byte value in a field
518 in an internal strcuture. */
519 return ((bfd_vma
) (field
[7]))
520 | (((bfd_vma
) (field
[6])) << 8)
521 | (((bfd_vma
) (field
[5])) << 16)
522 | (((bfd_vma
) (field
[4])) << 24)
523 | (((bfd_vma
) (field
[3])) << 32)
524 | (((bfd_vma
) (field
[2])) << 40)
525 | (((bfd_vma
) (field
[1])) << 48)
526 | (((bfd_vma
) (field
[0])) << 56);
530 error (_("Unhandled data length: %d\n"), size
);
536 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
538 guess_is_rela (e_machine
)
539 unsigned long e_machine
;
543 /* Targets that use REL relocations. */
554 /* Targets that use RELA relocations. */
562 case EM_CYGNUS_MN10200
:
563 case EM_CYGNUS_MN10300
:
593 warn (_("Don't know about relocations on this machine architecture\n"));
598 /* Display the contents of the relocation data found at the specified offset. */
600 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
602 unsigned long rel_offset
;
603 unsigned long rel_size
;
604 Elf_Internal_Sym
* symtab
;
610 Elf_Internal_Rel
* rels
;
611 Elf_Internal_Rela
* relas
;
614 if (is_rela
== UNKNOWN
)
615 is_rela
= guess_is_rela (elf_header
.e_machine
);
621 Elf32_External_Rela
* erelas
;
623 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
624 Elf32_External_Rela
*, "relocs");
626 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
628 relas
= (Elf_Internal_Rela
*)
629 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
633 error(_("out of memory parsing relocs"));
637 for (i
= 0; i
< rel_size
; i
++)
639 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
640 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
641 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
646 rels
= (Elf_Internal_Rel
*) relas
;
650 Elf64_External_Rela
* erelas
;
652 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
653 Elf64_External_Rela
*, "relocs");
655 rel_size
= rel_size
/ sizeof (Elf64_External_Rela
);
657 relas
= (Elf_Internal_Rela
*)
658 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
662 error(_("out of memory parsing relocs"));
666 for (i
= 0; i
< rel_size
; i
++)
668 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
669 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
670 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
675 rels
= (Elf_Internal_Rel
*) relas
;
682 Elf32_External_Rel
* erels
;
684 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
685 Elf32_External_Rel
*, "relocs");
687 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
689 rels
= (Elf_Internal_Rel
*)
690 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
694 error(_("out of memory parsing relocs"));
698 for (i
= 0; i
< rel_size
; i
++)
700 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
701 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
706 relas
= (Elf_Internal_Rela
*) rels
;
710 Elf64_External_Rel
* erels
;
712 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
713 Elf64_External_Rel
*, "relocs");
715 rel_size
= rel_size
/ sizeof (Elf64_External_Rel
);
717 rels
= (Elf_Internal_Rel
*)
718 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
722 error(_("out of memory parsing relocs"));
726 for (i
= 0; i
< rel_size
; i
++)
728 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
729 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
734 relas
= (Elf_Internal_Rela
*) rels
;
740 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
743 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
745 for (i
= 0; i
< rel_size
; i
++)
750 bfd_vma symtab_index
;
755 offset
= relas
[i
].r_offset
;
756 info
= relas
[i
].r_info
;
760 offset
= rels
[i
].r_offset
;
761 info
= rels
[i
].r_info
;
766 type
= ELF32_R_TYPE (info
);
767 symtab_index
= ELF32_R_SYM (info
);
771 if (elf_header
.e_machine
== EM_SPARCV9
)
772 type
= ELF64_R_TYPE_ID (info
);
774 type
= ELF64_R_TYPE (info
);
775 /* The #ifdef BFD64 below is to prevent a compile time warning.
776 We know that if we do not have a 64 bit data type that we
777 will never execute this code anyway. */
779 symtab_index
= ELF64_R_SYM (info
);
783 #ifdef _bfd_int64_low
784 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
786 printf (" %8.8lx %5.5lx ", offset
, info
);
789 switch (elf_header
.e_machine
)
796 rtype
= elf_m32r_reloc_type (type
);
801 rtype
= elf_i386_reloc_type (type
);
805 rtype
= elf_m68k_reloc_type (type
);
809 rtype
= elf_i960_reloc_type (type
);
813 rtype
= elf_avr_reloc_type (type
);
820 rtype
= elf_sparc_reloc_type (type
);
824 rtype
= v850_reloc_type (type
);
828 rtype
= elf_d10v_reloc_type (type
);
832 rtype
= elf_d30v_reloc_type (type
);
836 rtype
= elf_sh_reloc_type (type
);
839 case EM_CYGNUS_MN10300
:
840 rtype
= elf_mn10300_reloc_type (type
);
843 case EM_CYGNUS_MN10200
:
844 rtype
= elf_mn10200_reloc_type (type
);
848 rtype
= elf_fr30_reloc_type (type
);
852 rtype
= elf_mcore_reloc_type (type
);
856 rtype
= elf_ppc_reloc_type (type
);
861 rtype
= elf_mips_reloc_type (type
);
865 rtype
= elf_alpha_reloc_type (type
);
869 rtype
= elf_arm_reloc_type (type
);
873 rtype
= elf_arc_reloc_type (type
);
877 rtype
= elf_hppa_reloc_type (type
);
881 rtype
= elf_pj_reloc_type (type
);
884 rtype
= elf_ia64_reloc_type (type
);
888 rtype
= elf_cris_reloc_type (type
);
892 rtype
= elf_i860_reloc_type (type
);
897 #ifdef _bfd_int64_low
898 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
900 printf (_("unrecognised: %-7lx"), type
);
903 printf ("%-21.21s", rtype
);
909 if (symtab_index
>= nsyms
)
910 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
913 Elf_Internal_Sym
* psym
;
915 psym
= symtab
+ symtab_index
;
918 print_vma (psym
->st_value
, LONG_HEX
);
921 if (psym
->st_name
== 0)
923 SECTION_NAME (section_headers
+ psym
->st_shndx
));
924 else if (strtab
== NULL
)
925 printf (_("<string table index %3ld>"), psym
->st_name
);
927 printf ("%-25.25s", strtab
+ psym
->st_name
);
930 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
936 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
937 print_vma (relas
[i
].r_addend
, LONG_HEX
);
940 if (elf_header
.e_machine
== EM_SPARCV9
941 && !strcmp (rtype
, "R_SPARC_OLO10"))
942 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
953 get_mips_dynamic_type (type
)
958 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
959 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
960 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
961 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
962 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
963 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
964 case DT_MIPS_MSYM
: return "MIPS_MSYM";
965 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
966 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
967 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
968 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
969 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
970 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
971 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
972 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
973 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
974 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
975 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
976 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
977 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
978 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
979 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
980 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
981 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
982 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
983 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
984 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
985 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
986 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
987 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
988 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
989 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
990 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
991 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
992 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
993 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
994 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
995 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
996 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
997 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
998 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
999 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1000 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1007 get_sparc64_dynamic_type (type
)
1012 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1019 get_parisc_dynamic_type (type
)
1024 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1025 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1026 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1027 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1028 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1029 case DT_HP_PREINIT
: return "HP_PREINIT";
1030 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1031 case DT_HP_NEEDED
: return "HP_NEEDED";
1032 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1033 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1034 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1035 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1036 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1043 get_dynamic_type (type
)
1046 static char buff
[32];
1050 case DT_NULL
: return "NULL";
1051 case DT_NEEDED
: return "NEEDED";
1052 case DT_PLTRELSZ
: return "PLTRELSZ";
1053 case DT_PLTGOT
: return "PLTGOT";
1054 case DT_HASH
: return "HASH";
1055 case DT_STRTAB
: return "STRTAB";
1056 case DT_SYMTAB
: return "SYMTAB";
1057 case DT_RELA
: return "RELA";
1058 case DT_RELASZ
: return "RELASZ";
1059 case DT_RELAENT
: return "RELAENT";
1060 case DT_STRSZ
: return "STRSZ";
1061 case DT_SYMENT
: return "SYMENT";
1062 case DT_INIT
: return "INIT";
1063 case DT_FINI
: return "FINI";
1064 case DT_SONAME
: return "SONAME";
1065 case DT_RPATH
: return "RPATH";
1066 case DT_SYMBOLIC
: return "SYMBOLIC";
1067 case DT_REL
: return "REL";
1068 case DT_RELSZ
: return "RELSZ";
1069 case DT_RELENT
: return "RELENT";
1070 case DT_PLTREL
: return "PLTREL";
1071 case DT_DEBUG
: return "DEBUG";
1072 case DT_TEXTREL
: return "TEXTREL";
1073 case DT_JMPREL
: return "JMPREL";
1074 case DT_BIND_NOW
: return "BIND_NOW";
1075 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1076 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1077 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1078 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1079 case DT_RUNPATH
: return "RUNPATH";
1080 case DT_FLAGS
: return "FLAGS";
1082 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1083 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1085 case DT_CHECKSUM
: return "CHECKSUM";
1086 case DT_PLTPADSZ
: return "PLTPADSZ";
1087 case DT_MOVEENT
: return "MOVEENT";
1088 case DT_MOVESZ
: return "MOVESZ";
1089 case DT_FEATURE
: return "FEATURE";
1090 case DT_POSFLAG_1
: return "POSFLAG_1";
1091 case DT_SYMINSZ
: return "SYMINSZ";
1092 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1094 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1095 case DT_CONFIG
: return "CONFIG";
1096 case DT_DEPAUDIT
: return "DEPAUDIT";
1097 case DT_AUDIT
: return "AUDIT";
1098 case DT_PLTPAD
: return "PLTPAD";
1099 case DT_MOVETAB
: return "MOVETAB";
1100 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1102 case DT_VERSYM
: return "VERSYM";
1104 case DT_RELACOUNT
: return "RELACOUNT";
1105 case DT_RELCOUNT
: return "RELCOUNT";
1106 case DT_FLAGS_1
: return "FLAGS_1";
1107 case DT_VERDEF
: return "VERDEF";
1108 case DT_VERDEFNUM
: return "VERDEFNUM";
1109 case DT_VERNEED
: return "VERNEED";
1110 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1112 case DT_AUXILIARY
: return "AUXILIARY";
1113 case DT_USED
: return "USED";
1114 case DT_FILTER
: return "FILTER";
1117 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1119 const char * result
;
1121 switch (elf_header
.e_machine
)
1124 case EM_MIPS_RS4_BE
:
1125 result
= get_mips_dynamic_type (type
);
1128 result
= get_sparc64_dynamic_type (type
);
1138 sprintf (buff
, _("Processor Specific: %lx"), type
);
1140 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1142 const char * result
;
1144 switch (elf_header
.e_machine
)
1147 result
= get_parisc_dynamic_type (type
);
1157 sprintf (buff
, _("Operating System specific: %lx"), type
);
1160 sprintf (buff
, _("<unknown>: %lx"), type
);
1167 get_file_type (e_type
)
1170 static char buff
[32];
1174 case ET_NONE
: return _("NONE (None)");
1175 case ET_REL
: return _("REL (Relocatable file)");
1176 case ET_EXEC
: return _("EXEC (Executable file)");
1177 case ET_DYN
: return _("DYN (Shared object file)");
1178 case ET_CORE
: return _("CORE (Core file)");
1181 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1182 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1183 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1184 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1186 sprintf (buff
, _("<unknown>: %x"), e_type
);
1192 get_machine_name (e_machine
)
1195 static char buff
[64]; /* XXX */
1199 case EM_NONE
: return _("None");
1200 case EM_M32
: return "WE32100";
1201 case EM_SPARC
: return "Sparc";
1202 case EM_386
: return "Intel 80386";
1203 case EM_68K
: return "MC68000";
1204 case EM_88K
: return "MC88000";
1205 case EM_486
: return "Intel 80486";
1206 case EM_860
: return "Intel 80860";
1207 case EM_MIPS
: return "MIPS R3000";
1208 case EM_S370
: return "IBM System/370";
1209 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1210 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1211 case EM_PARISC
: return "HPPA";
1212 case EM_PPC_OLD
: return "Power PC (old)";
1213 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1214 case EM_960
: return "Intel 90860";
1215 case EM_PPC
: return "PowerPC";
1216 case EM_V800
: return "NEC V800";
1217 case EM_FR20
: return "Fujitsu FR20";
1218 case EM_RH32
: return "TRW RH32";
1219 case EM_MCORE
: return "MCORE";
1220 case EM_ARM
: return "ARM";
1221 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1222 case EM_SH
: return "Hitachi SH";
1223 case EM_SPARCV9
: return "Sparc v9";
1224 case EM_TRICORE
: return "Siemens Tricore";
1225 case EM_ARC
: return "Argonaut RISC Core";
1226 case EM_H8_300
: return "Hitachi H8/300";
1227 case EM_H8_300H
: return "Hitachi H8/300H";
1228 case EM_H8S
: return "Hitachi H8S";
1229 case EM_H8_500
: return "Hitachi H8/500";
1230 case EM_IA_64
: return "Intel IA-64";
1231 case EM_MIPS_X
: return "Stanford MIPS-X";
1232 case EM_COLDFIRE
: return "Motorola Coldfire";
1233 case EM_68HC12
: return "Motorola M68HC12";
1234 case EM_ALPHA
: return "Alpha";
1235 case EM_CYGNUS_D10V
: return "d10v";
1236 case EM_CYGNUS_D30V
: return "d30v";
1237 case EM_CYGNUS_ARC
: return "Arc";
1238 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1239 case EM_CYGNUS_V850
: return "NEC v850";
1240 case EM_CYGNUS_MN10300
: return "mn10300";
1241 case EM_CYGNUS_MN10200
: return "mn10200";
1242 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1243 case EM_PJ
: return "picoJava";
1244 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1245 case EM_PCP
: return "Siemens PCP";
1246 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1247 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1248 case EM_STARCORE
: return "Motorola Star*Core processor";
1249 case EM_ME16
: return "Toyota ME16 processor";
1250 case EM_ST100
: return "STMicroelectronics ST100 processor";
1251 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1252 case EM_FX66
: return "Siemens FX66 microcontroller";
1253 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1254 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1255 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1256 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1257 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1258 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1259 case EM_SVX
: return "Silicon Graphics SVx";
1260 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1261 case EM_VAX
: return "Digital VAX";
1262 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1263 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1265 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1271 decode_ARM_machine_flags (e_flags
, buf
)
1278 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1279 e_flags
&= ~ EF_ARM_EABIMASK
;
1281 /* Handle "generic" ARM flags. */
1282 if (e_flags
& EF_ARM_RELEXEC
)
1284 strcat (buf
, ", relocatable executable");
1285 e_flags
&= ~ EF_ARM_RELEXEC
;
1288 if (e_flags
& EF_ARM_HASENTRY
)
1290 strcat (buf
, ", has entry point");
1291 e_flags
&= ~ EF_ARM_HASENTRY
;
1294 /* Now handle EABI specific flags. */
1298 strcat (buf
, ", <unknown EABI>");
1303 case EF_ARM_EABI_VER1
:
1308 /* Process flags one bit at a time. */
1309 flag
= e_flags
& - e_flags
;
1314 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_INTERWORK. */
1315 strcat (buf
, ", sorted symbol tables");
1325 case EF_ARM_EABI_UNKNOWN
:
1330 /* Process flags one bit at a time. */
1331 flag
= e_flags
& - e_flags
;
1337 strcat (buf
, ", interworking enabled");
1341 strcat (buf
, ", uses APCS/26");
1345 strcat (buf
, ", uses APCS/float");
1349 strcat (buf
, ", position independent");
1353 strcat (buf
, ", 8 bit structure alignment");
1357 strcat (buf
, ", uses new ABI");
1361 strcat (buf
, ", uses old ABI");
1365 strcat (buf
, ", software FP");
1376 strcat (buf
,", <unknown>");
1380 get_machine_flags (e_flags
, e_machine
)
1384 static char buf
[1024];
1396 decode_ARM_machine_flags (e_flags
, buf
);
1400 if (e_flags
& EF_CPU32
)
1401 strcat (buf
, ", cpu32");
1405 if (e_flags
& EF_PPC_EMB
)
1406 strcat (buf
, ", emb");
1408 if (e_flags
& EF_PPC_RELOCATABLE
)
1409 strcat (buf
, ", relocatable");
1411 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1412 strcat (buf
, ", relocatable-lib");
1415 case EM_CYGNUS_V850
:
1416 switch (e_flags
& EF_V850_ARCH
)
1419 strcat (buf
, ", v850e");
1422 strcat (buf
, ", v850ea");
1425 strcat (buf
, ", v850");
1428 strcat (buf
, ", unknown v850 architecture variant");
1433 case EM_CYGNUS_M32R
:
1434 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1435 strcat (buf
, ", m32r");
1440 case EM_MIPS_RS4_BE
:
1441 if (e_flags
& EF_MIPS_NOREORDER
)
1442 strcat (buf
, ", noreorder");
1444 if (e_flags
& EF_MIPS_PIC
)
1445 strcat (buf
, ", pic");
1447 if (e_flags
& EF_MIPS_CPIC
)
1448 strcat (buf
, ", cpic");
1450 if (e_flags
& EF_MIPS_ABI2
)
1451 strcat (buf
, ", abi2");
1453 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1454 strcat (buf
, ", mips1");
1456 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1457 strcat (buf
, ", mips2");
1459 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1460 strcat (buf
, ", mips3");
1462 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1463 strcat (buf
, ", mips4");
1467 if (e_flags
& EF_SPARC_32PLUS
)
1468 strcat (buf
, ", v8+");
1470 if (e_flags
& EF_SPARC_SUN_US1
)
1471 strcat (buf
, ", ultrasparcI");
1473 if (e_flags
& EF_SPARC_SUN_US3
)
1474 strcat (buf
, ", ultrasparcIII");
1476 if (e_flags
& EF_SPARC_HAL_R1
)
1477 strcat (buf
, ", halr1");
1479 if (e_flags
& EF_SPARC_LEDATA
)
1480 strcat (buf
, ", ledata");
1482 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1483 strcat (buf
, ", tso");
1485 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1486 strcat (buf
, ", pso");
1488 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1489 strcat (buf
, ", rmo");
1493 switch (e_flags
& EF_PARISC_ARCH
)
1495 case EFA_PARISC_1_0
:
1496 strcpy (buf
, ", PA-RISC 1.0");
1498 case EFA_PARISC_1_1
:
1499 strcpy (buf
, ", PA-RISC 1.1");
1501 case EFA_PARISC_2_0
:
1502 strcpy (buf
, ", PA-RISC 2.0");
1507 if (e_flags
& EF_PARISC_TRAPNIL
)
1508 strcat (buf
, ", trapnil");
1509 if (e_flags
& EF_PARISC_EXT
)
1510 strcat (buf
, ", ext");
1511 if (e_flags
& EF_PARISC_LSB
)
1512 strcat (buf
, ", lsb");
1513 if (e_flags
& EF_PARISC_WIDE
)
1514 strcat (buf
, ", wide");
1515 if (e_flags
& EF_PARISC_NO_KABP
)
1516 strcat (buf
, ", no kabp");
1517 if (e_flags
& EF_PARISC_LAZYSWAP
)
1518 strcat (buf
, ", lazyswap");
1522 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1523 strcat (buf
, ", new calling convention");
1525 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1526 strcat (buf
, ", gnu calling convention");
1535 get_mips_segment_type (type
)
1540 case PT_MIPS_REGINFO
:
1542 case PT_MIPS_RTPROC
:
1544 case PT_MIPS_OPTIONS
:
1554 get_parisc_segment_type (type
)
1559 case PT_HP_TLS
: return "HP_TLS";
1560 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1561 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1562 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1563 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1564 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1565 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1566 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1567 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1568 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1569 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1570 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1571 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1572 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1581 get_segment_type (p_type
)
1582 unsigned long p_type
;
1584 static char buff
[32];
1588 case PT_NULL
: return "NULL";
1589 case PT_LOAD
: return "LOAD";
1590 case PT_DYNAMIC
: return "DYNAMIC";
1591 case PT_INTERP
: return "INTERP";
1592 case PT_NOTE
: return "NOTE";
1593 case PT_SHLIB
: return "SHLIB";
1594 case PT_PHDR
: return "PHDR";
1597 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1599 const char * result
;
1601 switch (elf_header
.e_machine
)
1604 case EM_MIPS_RS4_BE
:
1605 result
= get_mips_segment_type (p_type
);
1608 result
= get_parisc_segment_type (p_type
);
1618 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1620 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1622 const char * result
;
1624 switch (elf_header
.e_machine
)
1627 result
= get_parisc_segment_type (p_type
);
1637 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1640 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1647 get_mips_section_type_name (sh_type
)
1648 unsigned int sh_type
;
1652 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1653 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1654 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1655 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1656 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1657 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1658 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1659 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1660 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1661 case SHT_MIPS_RELD
: return "MIPS_RELD";
1662 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1663 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1664 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1665 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1666 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1667 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1668 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1669 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1670 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1671 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1672 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1673 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1674 case SHT_MIPS_LINE
: return "MIPS_LINE";
1675 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1676 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1677 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1678 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1679 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1680 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1681 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1682 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1683 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1684 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1685 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1686 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1687 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1688 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1689 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1690 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1698 get_parisc_section_type_name (sh_type
)
1699 unsigned int sh_type
;
1703 case SHT_PARISC_EXT
: return "PARISC_EXT";
1704 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1705 case SHT_PARISC_DOC
: return "PARISC_DOC";
1713 get_section_type_name (sh_type
)
1714 unsigned int sh_type
;
1716 static char buff
[32];
1720 case SHT_NULL
: return "NULL";
1721 case SHT_PROGBITS
: return "PROGBITS";
1722 case SHT_SYMTAB
: return "SYMTAB";
1723 case SHT_STRTAB
: return "STRTAB";
1724 case SHT_RELA
: return "RELA";
1725 case SHT_HASH
: return "HASH";
1726 case SHT_DYNAMIC
: return "DYNAMIC";
1727 case SHT_NOTE
: return "NOTE";
1728 case SHT_NOBITS
: return "NOBITS";
1729 case SHT_REL
: return "REL";
1730 case SHT_SHLIB
: return "SHLIB";
1731 case SHT_DYNSYM
: return "DYNSYM";
1732 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1733 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1734 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1735 case SHT_GNU_verdef
: return "VERDEF";
1736 case SHT_GNU_verneed
: return "VERNEED";
1737 case SHT_GNU_versym
: return "VERSYM";
1738 case 0x6ffffff0: return "VERSYM";
1739 case 0x6ffffffc: return "VERDEF";
1740 case 0x7ffffffd: return "AUXILIARY";
1741 case 0x7fffffff: return "FILTER";
1744 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1746 const char * result
;
1748 switch (elf_header
.e_machine
)
1751 case EM_MIPS_RS4_BE
:
1752 result
= get_mips_section_type_name (sh_type
);
1755 result
= get_parisc_section_type_name (sh_type
);
1765 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1767 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1768 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1769 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1770 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1772 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1778 struct option options
[] =
1780 {"all", no_argument
, 0, 'a'},
1781 {"file-header", no_argument
, 0, 'h'},
1782 {"program-headers", no_argument
, 0, 'l'},
1783 {"headers", no_argument
, 0, 'e'},
1784 {"histogram", no_argument
, 0, 'I'},
1785 {"segments", no_argument
, 0, 'l'},
1786 {"sections", no_argument
, 0, 'S'},
1787 {"section-headers", no_argument
, 0, 'S'},
1788 {"symbols", no_argument
, 0, 's'},
1789 {"syms", no_argument
, 0, 's'},
1790 {"relocs", no_argument
, 0, 'r'},
1791 {"notes", no_argument
, 0, 'n'},
1792 {"dynamic", no_argument
, 0, 'd'},
1793 {"arch-specific", no_argument
, 0, 'A'},
1794 {"version-info", no_argument
, 0, 'V'},
1795 {"use-dynamic", no_argument
, 0, 'D'},
1796 {"hex-dump", required_argument
, 0, 'x'},
1797 {"debug-dump", optional_argument
, 0, 'w'},
1798 #ifdef SUPPORT_DISASSEMBLY
1799 {"instruction-dump", required_argument
, 0, 'i'},
1802 {"version", no_argument
, 0, 'v'},
1803 {"help", no_argument
, 0, 'H'},
1804 {0, no_argument
, 0, 0}
1810 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1811 fprintf (stdout
, _(" Options are:\n"));
1812 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1813 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1814 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1815 fprintf (stdout
, _(" Display the program headers\n"));
1816 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1817 fprintf (stdout
, _(" Display the sections' header\n"));
1818 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1819 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1820 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1821 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1822 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1823 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1824 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1825 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1826 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1827 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1828 fprintf (stdout
, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1829 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1830 #ifdef SUPPORT_DISASSEMBLY
1831 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1832 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1834 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1835 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1836 fprintf (stdout
, _(" -H or --help Display this information\n"));
1837 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
1843 request_dump (section
, type
)
1844 unsigned int section
;
1847 if (section
>= num_dump_sects
)
1849 char * new_dump_sects
;
1851 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1853 if (new_dump_sects
== NULL
)
1854 error (_("Out of memory allocating dump request table."));
1857 /* Copy current flag settings. */
1858 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1862 dump_sects
= new_dump_sects
;
1863 num_dump_sects
= section
+ 1;
1868 dump_sects
[section
] |= type
;
1874 parse_args (argc
, argv
)
1883 while ((c
= getopt_long
1884 (argc
, argv
, "ersahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
1919 do_using_dynamic
++;
1947 section
= strtoul (optarg
, & cp
, 0);
1948 if (! * cp
&& section
>= 0)
1950 request_dump (section
, HEX_DUMP
);
1970 do_debug_abbrevs
= 1;
1980 do_debug_pubnames
= 1;
1985 do_debug_aranges
= 1;
1989 warn (_("Unrecognised debug option '%s'\n"), optarg
);
1994 #ifdef SUPPORT_DISASSEMBLY
1997 section
= strtoul (optarg
, & cp
, 0);
1998 if (! * cp
&& section
>= 0)
2000 request_dump (section
, DISASS_DUMP
);
2006 print_version (program_name
);
2013 /* xgettext:c-format */
2014 error (_("Invalid option '-%c'\n"), c
);
2021 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
2022 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2023 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2027 warn (_("Nothing to do.\n"));
2033 get_elf_class (elf_class
)
2034 unsigned char elf_class
;
2036 static char buff
[32];
2040 case ELFCLASSNONE
: return _("none");
2041 case ELFCLASS32
: return _("ELF32");
2042 case ELFCLASS64
: return _("ELF64");
2044 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2050 get_data_encoding (encoding
)
2051 unsigned char encoding
;
2053 static char buff
[32];
2057 case ELFDATANONE
: return _("none");
2058 case ELFDATA2LSB
: return _("2's complement, little endian");
2059 case ELFDATA2MSB
: return _("2's complement, big endian");
2061 sprintf (buff
, _("<unknown: %x>"), encoding
);
2067 get_osabi_name (osabi
)
2068 unsigned char osabi
;
2070 static char buff
[32];
2074 case ELFOSABI_NONE
: return _("UNIX - System V");
2075 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
2076 case ELFOSABI_NETBSD
: return _("UNIX - NetBSD");
2077 case ELFOSABI_LINUX
: return _("UNIX - Linux");
2078 case ELFOSABI_HURD
: return _("GNU/Hurd");
2079 case ELFOSABI_SOLARIS
: return _("UNIX - Solaris");
2080 case ELFOSABI_MONTEREY
: return _("UNIX - Monterey");
2081 case ELFOSABI_IRIX
: return _("UNIX - IRIX");
2082 case ELFOSABI_FREEBSD
: return _("UNIX - FreeBSD");
2083 case ELFOSABI_TRU64
: return _("UNIX - TRU64");
2084 case ELFOSABI_MODESTO
: return _("Novell - Modesto");
2085 case ELFOSABI_OPENBSD
: return _("UNIX - OpenBSD");
2086 case ELFOSABI_STANDALONE
: return _("Standalone App");
2087 case ELFOSABI_ARM
: return _("ARM");
2089 sprintf (buff
, _("<unknown: %x>"), osabi
);
2094 /* Decode the data held in 'elf_header'. */
2096 process_file_header ()
2098 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2099 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2100 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2101 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2104 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2112 printf (_("ELF Header:\n"));
2113 printf (_(" Magic: "));
2114 for (i
= 0; i
< EI_NIDENT
; i
++)
2115 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2117 printf (_(" Class: %s\n"),
2118 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2119 printf (_(" Data: %s\n"),
2120 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2121 printf (_(" Version: %d %s\n"),
2122 elf_header
.e_ident
[EI_VERSION
],
2123 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2125 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2128 printf (_(" OS/ABI: %s\n"),
2129 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2130 printf (_(" ABI Version: %d\n"),
2131 elf_header
.e_ident
[EI_ABIVERSION
]);
2132 printf (_(" Type: %s\n"),
2133 get_file_type (elf_header
.e_type
));
2134 printf (_(" Machine: %s\n"),
2135 get_machine_name (elf_header
.e_machine
));
2136 printf (_(" Version: 0x%lx\n"),
2137 (unsigned long) elf_header
.e_version
);
2139 printf (_(" Entry point address: "));
2140 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2141 printf (_("\n Start of program headers: "));
2142 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2143 printf (_(" (bytes into file)\n Start of section headers: "));
2144 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2145 printf (_(" (bytes into file)\n"));
2147 printf (_(" Flags: 0x%lx%s\n"),
2148 (unsigned long) elf_header
.e_flags
,
2149 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2150 printf (_(" Size of this header: %ld (bytes)\n"),
2151 (long) elf_header
.e_ehsize
);
2152 printf (_(" Size of program headers: %ld (bytes)\n"),
2153 (long) elf_header
.e_phentsize
);
2154 printf (_(" Number of program headers: %ld\n"),
2155 (long) elf_header
.e_phnum
);
2156 printf (_(" Size of section headers: %ld (bytes)\n"),
2157 (long) elf_header
.e_shentsize
);
2158 printf (_(" Number of section headers: %ld\n"),
2159 (long) elf_header
.e_shnum
);
2160 printf (_(" Section header string table index: %ld\n"),
2161 (long) elf_header
.e_shstrndx
);
2169 get_32bit_program_headers (file
, program_headers
)
2171 Elf_Internal_Phdr
* program_headers
;
2173 Elf32_External_Phdr
* phdrs
;
2174 Elf32_External_Phdr
* external
;
2175 Elf32_Internal_Phdr
* internal
;
2178 GET_DATA_ALLOC (elf_header
.e_phoff
,
2179 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2180 phdrs
, Elf32_External_Phdr
*, "program headers");
2182 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2183 i
< elf_header
.e_phnum
;
2184 i
++, internal
++, external
++)
2186 internal
->p_type
= BYTE_GET (external
->p_type
);
2187 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2188 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2189 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2190 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2191 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2192 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2193 internal
->p_align
= BYTE_GET (external
->p_align
);
2202 get_64bit_program_headers (file
, program_headers
)
2204 Elf_Internal_Phdr
* program_headers
;
2206 Elf64_External_Phdr
* phdrs
;
2207 Elf64_External_Phdr
* external
;
2208 Elf64_Internal_Phdr
* internal
;
2211 GET_DATA_ALLOC (elf_header
.e_phoff
,
2212 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2213 phdrs
, Elf64_External_Phdr
*, "program headers");
2215 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2216 i
< elf_header
.e_phnum
;
2217 i
++, internal
++, external
++)
2219 internal
->p_type
= BYTE_GET (external
->p_type
);
2220 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2221 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2222 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2223 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2224 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2225 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2226 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2235 process_program_headers (file
)
2238 Elf_Internal_Phdr
* program_headers
;
2239 Elf_Internal_Phdr
* segment
;
2242 if (elf_header
.e_phnum
== 0)
2245 printf (_("\nThere are no program headers in this file.\n"));
2249 if (do_segments
&& !do_header
)
2251 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2252 printf (_("Entry point "));
2253 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2254 printf (_("\nThere are %d program headers, starting at offset "),
2255 elf_header
.e_phnum
);
2256 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2260 program_headers
= (Elf_Internal_Phdr
*) malloc
2261 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2263 if (program_headers
== NULL
)
2265 error (_("Out of memory\n"));
2270 i
= get_32bit_program_headers (file
, program_headers
);
2272 i
= get_64bit_program_headers (file
, program_headers
);
2276 free (program_headers
);
2283 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2287 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2291 (_(" Type Offset VirtAddr PhysAddr\n"));
2293 (_(" FileSiz MemSiz Flags Align\n"));
2301 for (i
= 0, segment
= program_headers
;
2302 i
< elf_header
.e_phnum
;
2307 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2311 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2312 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2313 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2314 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2315 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2317 (segment
->p_flags
& PF_R
? 'R' : ' '),
2318 (segment
->p_flags
& PF_W
? 'W' : ' '),
2319 (segment
->p_flags
& PF_X
? 'E' : ' '));
2320 printf ("%#lx", (unsigned long) segment
->p_align
);
2324 print_vma (segment
->p_offset
, FULL_HEX
);
2326 print_vma (segment
->p_vaddr
, FULL_HEX
);
2328 print_vma (segment
->p_paddr
, FULL_HEX
);
2330 print_vma (segment
->p_filesz
, FULL_HEX
);
2332 print_vma (segment
->p_memsz
, FULL_HEX
);
2334 (segment
->p_flags
& PF_R
? 'R' : ' '),
2335 (segment
->p_flags
& PF_W
? 'W' : ' '),
2336 (segment
->p_flags
& PF_X
? 'E' : ' '));
2337 print_vma (segment
->p_align
, HEX
);
2341 switch (segment
->p_type
)
2345 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2346 - (segment
->p_offset
& 0xfffff000);
2351 error (_("more than one dynamic segment\n"));
2353 dynamic_addr
= segment
->p_offset
;
2354 dynamic_size
= segment
->p_filesz
;
2358 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2359 error (_("Unable to find program interpreter name\n"));
2362 program_interpreter
[0] = 0;
2363 fscanf (file
, "%63s", program_interpreter
);
2366 printf (_("\n [Requesting program interpreter: %s]"),
2367 program_interpreter
);
2373 putc ('\n', stdout
);
2382 if (do_segments
&& section_headers
!= NULL
)
2384 printf (_("\n Section to Segment mapping:\n"));
2385 printf (_(" Segment Sections...\n"));
2387 assert (string_table
!= NULL
);
2389 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2392 Elf_Internal_Shdr
* section
;
2394 segment
= program_headers
+ i
;
2395 section
= section_headers
;
2397 printf (" %2.2d ", i
);
2399 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2401 if (section
->sh_size
> 0
2402 /* Compare allocated sections by VMA, unallocated
2403 sections by file offset. */
2404 && (section
->sh_flags
& SHF_ALLOC
2405 ? (section
->sh_addr
>= segment
->p_vaddr
2406 && section
->sh_addr
+ section
->sh_size
2407 <= segment
->p_vaddr
+ segment
->p_memsz
)
2408 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2409 && (section
->sh_offset
+ section
->sh_size
2410 <= segment
->p_offset
+ segment
->p_filesz
))))
2411 printf ("%s ", SECTION_NAME (section
));
2418 free (program_headers
);
2425 get_32bit_section_headers (file
)
2428 Elf32_External_Shdr
* shdrs
;
2429 Elf32_Internal_Shdr
* internal
;
2432 GET_DATA_ALLOC (elf_header
.e_shoff
,
2433 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2434 shdrs
, Elf32_External_Shdr
*, "section headers");
2436 section_headers
= (Elf_Internal_Shdr
*) malloc
2437 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2439 if (section_headers
== NULL
)
2441 error (_("Out of memory\n"));
2445 for (i
= 0, internal
= section_headers
;
2446 i
< elf_header
.e_shnum
;
2449 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2450 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2451 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2452 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2453 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2454 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2455 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2456 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2457 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2458 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2467 get_64bit_section_headers (file
)
2470 Elf64_External_Shdr
* shdrs
;
2471 Elf64_Internal_Shdr
* internal
;
2474 GET_DATA_ALLOC (elf_header
.e_shoff
,
2475 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2476 shdrs
, Elf64_External_Shdr
*, "section headers");
2478 section_headers
= (Elf_Internal_Shdr
*) malloc
2479 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2481 if (section_headers
== NULL
)
2483 error (_("Out of memory\n"));
2487 for (i
= 0, internal
= section_headers
;
2488 i
< elf_header
.e_shnum
;
2491 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2492 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2493 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2494 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2495 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2496 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2497 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2498 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2499 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2500 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2508 static Elf_Internal_Sym
*
2509 get_32bit_elf_symbols (file
, offset
, number
)
2511 unsigned long offset
;
2512 unsigned long number
;
2514 Elf32_External_Sym
* esyms
;
2515 Elf_Internal_Sym
* isyms
;
2516 Elf_Internal_Sym
* psym
;
2519 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2520 esyms
, Elf32_External_Sym
*, "symbols");
2522 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2526 error (_("Out of memory\n"));
2532 for (j
= 0, psym
= isyms
;
2536 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2537 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2538 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2539 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2540 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2541 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2549 static Elf_Internal_Sym
*
2550 get_64bit_elf_symbols (file
, offset
, number
)
2552 unsigned long offset
;
2553 unsigned long number
;
2555 Elf64_External_Sym
* esyms
;
2556 Elf_Internal_Sym
* isyms
;
2557 Elf_Internal_Sym
* psym
;
2560 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2561 esyms
, Elf64_External_Sym
*, "symbols");
2563 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2567 error (_("Out of memory\n"));
2573 for (j
= 0, psym
= isyms
;
2577 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2578 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2579 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2580 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2581 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2582 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2591 get_elf_section_flags (sh_flags
)
2594 static char buff
[32];
2602 flag
= sh_flags
& - sh_flags
;
2607 case SHF_WRITE
: strcat (buff
, "W"); break;
2608 case SHF_ALLOC
: strcat (buff
, "A"); break;
2609 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2610 case SHF_MERGE
: strcat (buff
, "M"); break;
2611 case SHF_STRINGS
: strcat (buff
, "S"); break;
2612 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2613 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2614 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2617 if (flag
& SHF_MASKOS
)
2620 sh_flags
&= ~ SHF_MASKOS
;
2622 else if (flag
& SHF_MASKPROC
)
2625 sh_flags
&= ~ SHF_MASKPROC
;
2637 process_section_headers (file
)
2640 Elf_Internal_Shdr
* section
;
2643 section_headers
= NULL
;
2645 if (elf_header
.e_shnum
== 0)
2648 printf (_("\nThere are no sections in this file.\n"));
2653 if (do_sections
&& !do_header
)
2654 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2655 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2659 if (! get_32bit_section_headers (file
))
2662 else if (! get_64bit_section_headers (file
))
2665 /* Read in the string table, so that we have names to display. */
2666 section
= section_headers
+ elf_header
.e_shstrndx
;
2668 if (section
->sh_size
!= 0)
2670 unsigned long string_table_offset
;
2672 string_table_offset
= section
->sh_offset
;
2674 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2675 string_table
, char *, "string table");
2678 /* Scan the sections for the dynamic symbol table
2679 and dynamic string table and debug sections. */
2680 dynamic_symbols
= NULL
;
2681 dynamic_strings
= NULL
;
2682 dynamic_syminfo
= NULL
;
2684 for (i
= 0, section
= section_headers
;
2685 i
< elf_header
.e_shnum
;
2688 char * name
= SECTION_NAME (section
);
2690 if (section
->sh_type
== SHT_DYNSYM
)
2692 if (dynamic_symbols
!= NULL
)
2694 error (_("File contains multiple dynamic symbol tables\n"));
2698 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2700 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2702 else if (section
->sh_type
== SHT_STRTAB
2703 && strcmp (name
, ".dynstr") == 0)
2705 if (dynamic_strings
!= NULL
)
2707 error (_("File contains multiple dynamic string tables\n"));
2711 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2712 dynamic_strings
, char *, "dynamic strings");
2714 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2715 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
)
2716 && strncmp (name
, ".debug_", 7) == 0)
2721 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2722 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2723 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2724 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2725 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2727 request_dump (i
, DEBUG_DUMP
);
2734 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2738 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2741 printf (_(" [Nr] Name Type Address Offset\n"));
2742 printf (_(" Size EntSize Flags Link Info Align\n"));
2745 for (i
= 0, section
= section_headers
;
2746 i
< elf_header
.e_shnum
;
2749 printf (" [%2d] %-17.17s %-15.15s ",
2751 SECTION_NAME (section
),
2752 get_section_type_name (section
->sh_type
));
2756 print_vma (section
->sh_addr
, LONG_HEX
);
2758 printf ( " %6.6lx %6.6lx %2.2lx",
2759 (unsigned long) section
->sh_offset
,
2760 (unsigned long) section
->sh_size
,
2761 (unsigned long) section
->sh_entsize
);
2763 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2765 printf (" %2ld %3lx %ld\n",
2766 (unsigned long) section
->sh_link
,
2767 (unsigned long) section
->sh_info
,
2768 (unsigned long) section
->sh_addralign
);
2773 print_vma (section
->sh_addr
, LONG_HEX
);
2774 printf (" %8.8lx", section
->sh_offset
);
2776 print_vma (section
->sh_size
, LONG_HEX
);
2778 print_vma (section
->sh_entsize
, LONG_HEX
);
2780 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2782 printf (" %2ld %3lx %ld\n",
2783 (unsigned long) section
->sh_link
,
2784 (unsigned long) section
->sh_info
,
2785 (unsigned long) section
->sh_addralign
);
2789 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2790 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2791 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2796 /* Process the reloc section. */
2798 process_relocs (file
)
2801 unsigned long rel_size
;
2802 unsigned long rel_offset
;
2808 if (do_using_dynamic
)
2810 int is_rela
= FALSE
;
2815 if (dynamic_info
[DT_REL
])
2817 rel_offset
= dynamic_info
[DT_REL
];
2818 rel_size
= dynamic_info
[DT_RELSZ
];
2821 else if (dynamic_info
[DT_RELA
])
2823 rel_offset
= dynamic_info
[DT_RELA
];
2824 rel_size
= dynamic_info
[DT_RELASZ
];
2827 else if (dynamic_info
[DT_JMPREL
])
2829 rel_offset
= dynamic_info
[DT_JMPREL
];
2830 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2832 switch (dynamic_info
[DT_PLTREL
])
2849 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2850 rel_offset
, rel_size
);
2852 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2853 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
2856 printf (_("\nThere are no dynamic relocations in this file.\n"));
2860 Elf32_Internal_Shdr
* section
;
2864 for (i
= 0, section
= section_headers
;
2865 i
< elf_header
.e_shnum
;
2868 if ( section
->sh_type
!= SHT_RELA
2869 && section
->sh_type
!= SHT_REL
)
2872 rel_offset
= section
->sh_offset
;
2873 rel_size
= section
->sh_size
;
2877 Elf32_Internal_Shdr
* strsec
;
2878 Elf32_Internal_Shdr
* symsec
;
2879 Elf_Internal_Sym
* symtab
;
2882 unsigned long nsyms
;
2884 printf (_("\nRelocation section "));
2886 if (string_table
== NULL
)
2887 printf ("%d", section
->sh_name
);
2889 printf ("'%s'", SECTION_NAME (section
));
2891 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2892 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
2894 symsec
= section_headers
+ section
->sh_link
;
2896 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
2897 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
2902 strsec
= section_headers
+ symsec
->sh_link
;
2904 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2905 char *, "string table");
2907 is_rela
= section
->sh_type
== SHT_RELA
;
2909 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
2919 printf (_("\nThere are no relocations in this file.\n"));
2927 dynamic_segment_mips_val (entry
)
2928 Elf_Internal_Dyn
* entry
;
2930 switch (entry
->d_tag
)
2933 if (entry
->d_un
.d_val
== 0)
2937 static const char * opts
[] =
2939 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2940 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2941 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2942 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2947 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
2948 if (entry
->d_un
.d_val
& (1 << cnt
))
2950 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2957 case DT_MIPS_IVERSION
:
2958 if (dynamic_strings
!= NULL
)
2959 printf ("Interface Version: %s\n",
2960 dynamic_strings
+ entry
->d_un
.d_val
);
2962 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2965 case DT_MIPS_TIME_STAMP
:
2970 time_t time
= entry
->d_un
.d_val
;
2971 tmp
= gmtime (&time
);
2972 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
2973 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
2974 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
2975 printf ("Time Stamp: %s\n", timebuf
);
2979 case DT_MIPS_RLD_VERSION
:
2980 case DT_MIPS_LOCAL_GOTNO
:
2981 case DT_MIPS_CONFLICTNO
:
2982 case DT_MIPS_LIBLISTNO
:
2983 case DT_MIPS_SYMTABNO
:
2984 case DT_MIPS_UNREFEXTNO
:
2985 case DT_MIPS_HIPAGENO
:
2986 case DT_MIPS_DELTA_CLASS_NO
:
2987 case DT_MIPS_DELTA_INSTANCE_NO
:
2988 case DT_MIPS_DELTA_RELOC_NO
:
2989 case DT_MIPS_DELTA_SYM_NO
:
2990 case DT_MIPS_DELTA_CLASSSYM_NO
:
2991 case DT_MIPS_COMPACT_SIZE
:
2992 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2996 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
3002 dynamic_segment_parisc_val (entry
)
3003 Elf_Internal_Dyn
* entry
;
3005 switch (entry
->d_tag
)
3007 case DT_HP_DLD_FLAGS
:
3016 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
3017 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
3018 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
3019 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
3020 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
3021 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
3022 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
3023 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
3024 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
3025 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
3026 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
3030 bfd_vma val
= entry
->d_un
.d_val
;
3032 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
3033 if (val
& flags
[cnt
].bit
)
3037 fputs (flags
[cnt
].str
, stdout
);
3039 val
^= flags
[cnt
].bit
;
3042 if (val
!= 0 || first
)
3046 print_vma (val
, HEX
);
3052 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
3058 get_32bit_dynamic_segment (file
)
3061 Elf32_External_Dyn
* edyn
;
3062 Elf_Internal_Dyn
* entry
;
3065 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3066 edyn
, Elf32_External_Dyn
*, "dynamic segment");
3068 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3069 how large this .dynamic is now. We can do this even before the byte
3070 swapping since the DT_NULL tag is recognizable. */
3072 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3075 dynamic_segment
= (Elf_Internal_Dyn
*)
3076 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3078 if (dynamic_segment
== NULL
)
3080 error (_("Out of memory\n"));
3085 for (i
= 0, entry
= dynamic_segment
;
3089 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
3090 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
3099 get_64bit_dynamic_segment (file
)
3102 Elf64_External_Dyn
* edyn
;
3103 Elf_Internal_Dyn
* entry
;
3106 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3107 edyn
, Elf64_External_Dyn
*, "dynamic segment");
3109 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3110 how large this .dynamic is now. We can do this even before the byte
3111 swapping since the DT_NULL tag is recognizable. */
3113 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3116 dynamic_segment
= (Elf_Internal_Dyn
*)
3117 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3119 if (dynamic_segment
== NULL
)
3121 error (_("Out of memory\n"));
3126 for (i
= 0, entry
= dynamic_segment
;
3130 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
3131 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
3140 get_dynamic_flags (flags
)
3143 static char buff
[64];
3148 flag
= flags
& - flags
;
3153 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3154 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3155 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3156 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3157 default: strcat (buff
, "unknown "); break;
3163 /* Parse and display the contents of the dynamic segment. */
3165 process_dynamic_segment (file
)
3168 Elf_Internal_Dyn
* entry
;
3171 if (dynamic_size
== 0)
3174 printf (_("\nThere is no dynamic segment in this file.\n"));
3181 if (! get_32bit_dynamic_segment (file
))
3184 else if (! get_64bit_dynamic_segment (file
))
3187 /* Find the appropriate symbol table. */
3188 if (dynamic_symbols
== NULL
)
3190 for (i
= 0, entry
= dynamic_segment
;
3194 unsigned long offset
;
3196 if (entry
->d_tag
!= DT_SYMTAB
)
3199 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3201 /* Since we do not know how big the symbol table is,
3202 we default to reading in the entire file (!) and
3203 processing that. This is overkill, I know, but it
3205 offset
= entry
->d_un
.d_val
- loadaddr
;
3207 if (fseek (file
, 0, SEEK_END
))
3208 error (_("Unable to seek to end of file!"));
3211 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3213 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3215 if (num_dynamic_syms
< 1)
3217 error (_("Unable to determine the number of symbols to load\n"));
3221 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3225 /* Similarly find a string table. */
3226 if (dynamic_strings
== NULL
)
3228 for (i
= 0, entry
= dynamic_segment
;
3232 unsigned long offset
;
3235 if (entry
->d_tag
!= DT_STRTAB
)
3238 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3240 /* Since we do not know how big the string table is,
3241 we default to reading in the entire file (!) and
3242 processing that. This is overkill, I know, but it
3245 offset
= entry
->d_un
.d_val
- loadaddr
;
3246 if (fseek (file
, 0, SEEK_END
))
3247 error (_("Unable to seek to end of file\n"));
3248 str_tab_len
= ftell (file
) - offset
;
3250 if (str_tab_len
< 1)
3253 (_("Unable to determine the length of the dynamic string table\n"));
3257 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
3258 "dynamic string table");
3264 /* And find the syminfo section if available. */
3265 if (dynamic_syminfo
== NULL
)
3267 unsigned int syminsz
= 0;
3269 for (i
= 0, entry
= dynamic_segment
;
3273 if (entry
->d_tag
== DT_SYMINENT
)
3275 /* Note: these braces are necessary to avoid a syntax
3276 error from the SunOS4 C compiler. */
3277 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3279 else if (entry
->d_tag
== DT_SYMINSZ
)
3280 syminsz
= entry
->d_un
.d_val
;
3281 else if (entry
->d_tag
== DT_SYMINFO
)
3282 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
3285 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3287 Elf_External_Syminfo
* extsyminfo
;
3288 Elf_Internal_Syminfo
* syminfo
;
3290 /* There is a syminfo section. Read the data. */
3291 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3292 Elf_External_Syminfo
*, "symbol information");
3294 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3295 if (dynamic_syminfo
== NULL
)
3297 error (_("Out of memory\n"));
3301 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3302 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3305 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3306 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3313 if (do_dynamic
&& dynamic_addr
)
3314 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3315 dynamic_addr
, (long) dynamic_size
);
3317 printf (_(" Tag Type Name/Value\n"));
3319 for (i
= 0, entry
= dynamic_segment
;
3328 print_vma (entry
->d_tag
, FULL_HEX
);
3329 dtype
= get_dynamic_type (entry
->d_tag
);
3330 printf (" (%s)%*s", dtype
,
3331 ((is_32bit_elf
? 27 : 19)
3332 - (int) strlen (dtype
)),
3336 switch (entry
->d_tag
)
3340 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
3350 switch (entry
->d_tag
)
3353 printf (_("Auxiliary library"));
3357 printf (_("Filter library"));
3361 printf (_("Configuration file"));
3365 printf (_("Dependency audit library"));
3369 printf (_("Audit library"));
3373 if (dynamic_strings
)
3374 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3378 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3387 printf (_("Flags:"));
3388 if (entry
->d_un
.d_val
== 0)
3389 printf (_(" None\n"));
3392 unsigned long int val
= entry
->d_un
.d_val
;
3393 if (val
& DTF_1_PARINIT
)
3395 printf (" PARINIT");
3396 val
^= DTF_1_PARINIT
;
3398 if (val
& DTF_1_CONFEXP
)
3400 printf (" CONFEXP");
3401 val
^= DTF_1_CONFEXP
;
3404 printf (" %lx", val
);
3413 printf (_("Flags:"));
3414 if (entry
->d_un
.d_val
== 0)
3415 printf (_(" None\n"));
3418 unsigned long int val
= entry
->d_un
.d_val
;
3419 if (val
& DF_P1_LAZYLOAD
)
3421 printf (" LAZYLOAD");
3422 val
^= DF_P1_LAZYLOAD
;
3424 if (val
& DF_P1_GROUPPERM
)
3426 printf (" GROUPPERM");
3427 val
^= DF_P1_GROUPPERM
;
3430 printf (" %lx", val
);
3439 printf (_("Flags:"));
3440 if (entry
->d_un
.d_val
== 0)
3441 printf (_(" None\n"));
3444 unsigned long int val
= entry
->d_un
.d_val
;
3450 if (val
& DF_1_GLOBAL
)
3455 if (val
& DF_1_GROUP
)
3460 if (val
& DF_1_NODELETE
)
3462 printf (" NODELETE");
3463 val
^= DF_1_NODELETE
;
3465 if (val
& DF_1_LOADFLTR
)
3467 printf (" LOADFLTR");
3468 val
^= DF_1_LOADFLTR
;
3470 if (val
& DF_1_INITFIRST
)
3472 printf (" INITFIRST");
3473 val
^= DF_1_INITFIRST
;
3475 if (val
& DF_1_NOOPEN
)
3480 if (val
& DF_1_ORIGIN
)
3485 if (val
& DF_1_DIRECT
)
3490 if (val
& DF_1_TRANS
)
3495 if (val
& DF_1_INTERPOSE
)
3497 printf (" INTERPOSE");
3498 val
^= DF_1_INTERPOSE
;
3500 if (val
& DF_1_NODEFLIB
)
3502 printf (" NODEFLIB");
3503 val
^= DF_1_NODEFLIB
;
3505 if (val
& DF_1_NODUMP
)
3510 if (val
& DF_1_CONLFAT
)
3512 printf (" CONLFAT");
3513 val
^= DF_1_CONLFAT
;
3516 printf (" %lx", val
);
3524 puts (get_dynamic_type (entry
->d_un
.d_val
));
3544 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
3550 if (dynamic_strings
== NULL
)
3553 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3557 switch (entry
->d_tag
)
3560 printf (_("Shared library: [%s]"), name
);
3562 if (strcmp (name
, program_interpreter
) == 0)
3563 printf (_(" program interpreter"));
3567 printf (_("Library soname: [%s]"), name
);
3571 printf (_("Library rpath: [%s]"), name
);
3575 printf (_("Library runpath: [%s]"), name
);
3579 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3584 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3600 case DT_INIT_ARRAYSZ
:
3601 case DT_FINI_ARRAYSZ
:
3604 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3605 printf (" (bytes)\n");
3615 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3628 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
3632 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3636 printf (_("Not needed object: [%s]\n"), name
);
3641 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3647 /* The value of this entry is ignored. */
3651 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
3652 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
3657 switch (elf_header
.e_machine
)
3660 case EM_MIPS_RS4_BE
:
3661 dynamic_segment_mips_val (entry
);
3664 dynamic_segment_parisc_val (entry
);
3667 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3679 get_ver_flags (flags
)
3682 static char buff
[32];
3689 if (flags
& VER_FLG_BASE
)
3690 strcat (buff
, "BASE ");
3692 if (flags
& VER_FLG_WEAK
)
3694 if (flags
& VER_FLG_BASE
)
3695 strcat (buff
, "| ");
3697 strcat (buff
, "WEAK ");
3700 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
3701 strcat (buff
, "| <unknown>");
3706 /* Display the contents of the version sections. */
3708 process_version_sections (file
)
3711 Elf32_Internal_Shdr
* section
;
3718 for (i
= 0, section
= section_headers
;
3719 i
< elf_header
.e_shnum
;
3722 switch (section
->sh_type
)
3724 case SHT_GNU_verdef
:
3726 Elf_External_Verdef
* edefs
;
3733 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3734 SECTION_NAME (section
), section
->sh_info
);
3736 printf (_(" Addr: 0x"));
3737 printf_vma (section
->sh_addr
);
3738 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3739 (unsigned long) section
->sh_offset
, section
->sh_link
,
3740 SECTION_NAME (section_headers
+ section
->sh_link
));
3742 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3743 edefs
, Elf_External_Verdef
*,
3744 "version definition section");
3746 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
3749 Elf_External_Verdef
* edef
;
3750 Elf_Internal_Verdef ent
;
3751 Elf_External_Verdaux
* eaux
;
3752 Elf_Internal_Verdaux aux
;
3756 vstart
= ((char *) edefs
) + idx
;
3758 edef
= (Elf_External_Verdef
*) vstart
;
3760 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
3761 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
3762 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
3763 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
3764 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
3765 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
3766 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
3768 printf (_(" %#06x: Rev: %d Flags: %s"),
3769 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
3771 printf (_(" Index: %d Cnt: %d "),
3772 ent
.vd_ndx
, ent
.vd_cnt
);
3774 vstart
+= ent
.vd_aux
;
3776 eaux
= (Elf_External_Verdaux
*) vstart
;
3778 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3779 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3781 if (dynamic_strings
)
3782 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
3784 printf (_("Name index: %ld\n"), aux
.vda_name
);
3786 isum
= idx
+ ent
.vd_aux
;
3788 for (j
= 1; j
< ent
.vd_cnt
; j
++)
3790 isum
+= aux
.vda_next
;
3791 vstart
+= aux
.vda_next
;
3793 eaux
= (Elf_External_Verdaux
*) vstart
;
3795 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3796 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3798 if (dynamic_strings
)
3799 printf (_(" %#06x: Parent %d: %s\n"),
3800 isum
, j
, dynamic_strings
+ aux
.vda_name
);
3802 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3803 isum
, j
, aux
.vda_name
);
3813 case SHT_GNU_verneed
:
3815 Elf_External_Verneed
* eneed
;
3821 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3822 SECTION_NAME (section
), section
->sh_info
);
3824 printf (_(" Addr: 0x"));
3825 printf_vma (section
->sh_addr
);
3826 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3827 (unsigned long) section
->sh_offset
, section
->sh_link
,
3828 SECTION_NAME (section_headers
+ section
->sh_link
));
3830 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3831 eneed
, Elf_External_Verneed
*,
3832 "version need section");
3834 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
3836 Elf_External_Verneed
* entry
;
3837 Elf_Internal_Verneed ent
;
3842 vstart
= ((char *) eneed
) + idx
;
3844 entry
= (Elf_External_Verneed
*) vstart
;
3846 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
3847 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
3848 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
3849 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
3850 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
3852 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
3854 if (dynamic_strings
)
3855 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
3857 printf (_(" File: %lx"), ent
.vn_file
);
3859 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
3861 vstart
+= ent
.vn_aux
;
3863 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
3865 Elf_External_Vernaux
* eaux
;
3866 Elf_Internal_Vernaux aux
;
3868 eaux
= (Elf_External_Vernaux
*) vstart
;
3870 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
3871 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
3872 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
3873 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
3874 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
3876 if (dynamic_strings
)
3877 printf (_(" %#06x: Name: %s"),
3878 isum
, dynamic_strings
+ aux
.vna_name
);
3880 printf (_(" %#06x: Name index: %lx"),
3881 isum
, aux
.vna_name
);
3883 printf (_(" Flags: %s Version: %d\n"),
3884 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
3886 isum
+= aux
.vna_next
;
3887 vstart
+= aux
.vna_next
;
3897 case SHT_GNU_versym
:
3899 Elf32_Internal_Shdr
* link_section
;
3902 unsigned char * edata
;
3903 unsigned short * data
;
3905 Elf_Internal_Sym
* symbols
;
3906 Elf32_Internal_Shdr
* string_sec
;
3908 link_section
= section_headers
+ section
->sh_link
;
3909 total
= section
->sh_size
/ section
->sh_entsize
;
3913 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
3914 link_section
->sh_size
/ link_section
->sh_entsize
);
3916 string_sec
= section_headers
+ link_section
->sh_link
;
3918 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3919 strtab
, char *, "version string table");
3921 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3922 SECTION_NAME (section
), total
);
3924 printf (_(" Addr: "));
3925 printf_vma (section
->sh_addr
);
3926 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3927 (unsigned long) section
->sh_offset
, section
->sh_link
,
3928 SECTION_NAME (link_section
));
3930 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3932 total
* sizeof (short), edata
,
3933 unsigned char *, "version symbol data");
3935 data
= (unsigned short *) malloc (total
* sizeof (short));
3937 for (cnt
= total
; cnt
--;)
3938 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
3943 for (cnt
= 0; cnt
< total
; cnt
+= 4)
3948 printf (" %03x:", cnt
);
3950 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
3951 switch (data
[cnt
+ j
])
3954 fputs (_(" 0 (*local*) "), stdout
);
3958 fputs (_(" 1 (*global*) "), stdout
);
3962 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
3963 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
3965 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
3966 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
3969 /* We must test both. */
3970 Elf_Internal_Verneed ivn
;
3971 unsigned long offset
;
3973 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3978 Elf_External_Verneed evn
;
3979 Elf_External_Vernaux evna
;
3980 Elf_Internal_Vernaux ivna
;
3981 unsigned long vna_off
;
3983 GET_DATA (offset
, evn
, "version need");
3985 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3986 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3988 vna_off
= offset
+ ivn
.vn_aux
;
3992 GET_DATA (vna_off
, evna
,
3993 "version need aux (1)");
3995 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3996 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3998 vna_off
+= ivna
.vna_next
;
4000 while (ivna
.vna_other
!= data
[cnt
+ j
]
4001 && ivna
.vna_next
!= 0);
4003 if (ivna
.vna_other
== data
[cnt
+ j
])
4005 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4007 name
= strtab
+ ivna
.vna_name
;
4008 nn
+= printf ("(%s%-*s",
4010 12 - (int) strlen (name
),
4014 else if (ivn
.vn_next
== 0)
4016 if (data
[cnt
+ j
] != 0x8001)
4018 Elf_Internal_Verdef ivd
;
4019 Elf_External_Verdef evd
;
4021 offset
= version_info
4022 [DT_VERSIONTAGIDX (DT_VERDEF
)]
4027 GET_DATA (offset
, evd
,
4028 "version definition");
4030 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4031 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4033 offset
+= ivd
.vd_next
;
4036 != (data
[cnt
+ j
] & 0x7fff)
4037 && ivd
.vd_next
!= 0);
4040 == (data
[cnt
+ j
] & 0x7fff))
4042 Elf_External_Verdaux evda
;
4043 Elf_Internal_Verdaux ivda
;
4045 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4047 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
4048 "version definition aux");
4051 BYTE_GET (evda
.vda_name
);
4053 name
= strtab
+ ivda
.vda_name
;
4057 12 - (int) strlen (name
),
4065 offset
+= ivn
.vn_next
;
4067 while (ivn
.vn_next
);
4069 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
4071 Elf_Internal_Verneed ivn
;
4072 unsigned long offset
;
4074 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4079 Elf_Internal_Vernaux ivna
;
4080 Elf_External_Verneed evn
;
4081 Elf_External_Vernaux evna
;
4082 unsigned long a_off
;
4084 GET_DATA (offset
, evn
, "version need");
4086 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4087 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4089 a_off
= offset
+ ivn
.vn_aux
;
4093 GET_DATA (a_off
, evna
,
4094 "version need aux (2)");
4096 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4097 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4099 a_off
+= ivna
.vna_next
;
4101 while (ivna
.vna_other
!= data
[cnt
+ j
]
4102 && ivna
.vna_next
!= 0);
4104 if (ivna
.vna_other
== data
[cnt
+ j
])
4106 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4108 name
= strtab
+ ivna
.vna_name
;
4109 nn
+= printf ("(%s%-*s",
4111 12 - (int) strlen (name
),
4116 offset
+= ivn
.vn_next
;
4118 while (ivn
.vn_next
);
4120 else if (data
[cnt
+ j
] != 0x8001)
4122 Elf_Internal_Verdef ivd
;
4123 Elf_External_Verdef evd
;
4124 unsigned long offset
;
4126 offset
= version_info
4127 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
4131 GET_DATA (offset
, evd
, "version def");
4133 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4134 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4136 offset
+= ivd
.vd_next
;
4138 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
4139 && ivd
.vd_next
!= 0);
4141 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
4143 Elf_External_Verdaux evda
;
4144 Elf_Internal_Verdaux ivda
;
4146 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4148 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
4149 evda
, "version def aux");
4151 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4153 name
= strtab
+ ivda
.vda_name
;
4154 nn
+= printf ("(%s%-*s",
4156 12 - (int) strlen (name
),
4162 printf ("%*c", 18 - nn
, ' ');
4180 printf (_("\nNo version information found in this file.\n"));
4186 get_symbol_binding (binding
)
4187 unsigned int binding
;
4189 static char buff
[32];
4193 case STB_LOCAL
: return "LOCAL";
4194 case STB_GLOBAL
: return "GLOBAL";
4195 case STB_WEAK
: return "WEAK";
4197 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4198 sprintf (buff
, _("<processor specific>: %d"), binding
);
4199 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4200 sprintf (buff
, _("<OS specific>: %d"), binding
);
4202 sprintf (buff
, _("<unknown>: %d"), binding
);
4208 get_symbol_type (type
)
4211 static char buff
[32];
4215 case STT_NOTYPE
: return "NOTYPE";
4216 case STT_OBJECT
: return "OBJECT";
4217 case STT_FUNC
: return "FUNC";
4218 case STT_SECTION
: return "SECTION";
4219 case STT_FILE
: return "FILE";
4220 case STT_COMMON
: return "COMMON";
4222 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4224 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4225 return "THUMB_FUNC";
4227 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4230 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4231 return "PARISC_MILLI";
4233 sprintf (buff
, _("<processor specific>: %d"), type
);
4235 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4237 if (elf_header
.e_machine
== EM_PARISC
)
4239 if (type
== STT_HP_OPAQUE
)
4241 if (type
== STT_HP_STUB
)
4245 sprintf (buff
, _("<OS specific>: %d"), type
);
4248 sprintf (buff
, _("<unknown>: %d"), type
);
4254 get_symbol_visibility (visibility
)
4255 unsigned int visibility
;
4259 case STV_DEFAULT
: return "DEFAULT";
4260 case STV_INTERNAL
: return "INTERNAL";
4261 case STV_HIDDEN
: return "HIDDEN";
4262 case STV_PROTECTED
: return "PROTECTED";
4268 get_symbol_index_type (type
)
4273 case SHN_UNDEF
: return "UND";
4274 case SHN_ABS
: return "ABS";
4275 case SHN_COMMON
: return "COM";
4277 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4279 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4281 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4285 static char buff
[32];
4287 sprintf (buff
, "%3d", type
);
4294 get_dynamic_data (file
, number
)
4296 unsigned int number
;
4298 unsigned char * e_data
;
4301 e_data
= (unsigned char *) malloc (number
* 4);
4305 error (_("Out of memory\n"));
4309 if (fread (e_data
, 4, number
, file
) != number
)
4311 error (_("Unable to read in dynamic data\n"));
4315 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4319 error (_("Out of memory\n"));
4325 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4332 /* Dump the symbol table */
4334 process_symbol_table (file
)
4337 Elf32_Internal_Shdr
* section
;
4338 unsigned char nb
[4];
4339 unsigned char nc
[4];
4342 int * buckets
= NULL
;
4343 int * chains
= NULL
;
4345 if (! do_syms
&& !do_histogram
)
4348 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
4351 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
4353 error (_("Unable to seek to start of dynamic information"));
4357 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4359 error (_("Failed to read in number of buckets\n"));
4363 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4365 error (_("Failed to read in number of chains\n"));
4369 nbuckets
= byte_get (nb
, 4);
4370 nchains
= byte_get (nc
, 4);
4372 buckets
= get_dynamic_data (file
, nbuckets
);
4373 chains
= get_dynamic_data (file
, nchains
);
4375 if (buckets
== NULL
|| chains
== NULL
)
4380 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4385 printf (_("\nSymbol table for image:\n"));
4387 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4389 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4391 for (hn
= 0; hn
< nbuckets
; hn
++)
4396 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4398 Elf_Internal_Sym
* psym
;
4400 psym
= dynamic_symbols
+ si
;
4402 printf (" %3d %3d: ", si
, hn
);
4403 print_vma (psym
->st_value
, LONG_HEX
);
4405 print_vma (psym
->st_size
, DEC_5
);
4407 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4408 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4409 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4410 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
4411 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4415 else if (do_syms
&& !do_using_dynamic
)
4419 for (i
= 0, section
= section_headers
;
4420 i
< elf_header
.e_shnum
;
4425 Elf_Internal_Sym
* symtab
;
4426 Elf_Internal_Sym
* psym
;
4429 if ( section
->sh_type
!= SHT_SYMTAB
4430 && section
->sh_type
!= SHT_DYNSYM
)
4433 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4434 SECTION_NAME (section
),
4435 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4437 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4439 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4441 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4442 section
->sh_size
/ section
->sh_entsize
);
4446 if (section
->sh_link
== elf_header
.e_shstrndx
)
4447 strtab
= string_table
;
4450 Elf32_Internal_Shdr
* string_sec
;
4452 string_sec
= section_headers
+ section
->sh_link
;
4454 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4455 strtab
, char *, "string table");
4458 for (si
= 0, psym
= symtab
;
4459 si
< section
->sh_size
/ section
->sh_entsize
;
4462 printf ("%6d: ", si
);
4463 print_vma (psym
->st_value
, LONG_HEX
);
4465 print_vma (psym
->st_size
, DEC_5
);
4466 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4467 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4468 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4469 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
4470 printf (" %s", strtab
+ psym
->st_name
);
4472 if (section
->sh_type
== SHT_DYNSYM
&&
4473 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
4475 unsigned char data
[2];
4476 unsigned short vers_data
;
4477 unsigned long offset
;
4481 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4484 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
4487 vers_data
= byte_get (data
, 2);
4489 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
4490 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
4493 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
4495 if ((vers_data
& 0x8000) || vers_data
> 1)
4497 if (is_nobits
|| ! check_def
)
4499 Elf_External_Verneed evn
;
4500 Elf_Internal_Verneed ivn
;
4501 Elf_Internal_Vernaux ivna
;
4503 /* We must test both. */
4504 offset
= version_info
4505 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
4509 unsigned long vna_off
;
4511 GET_DATA (offset
, evn
, "version need");
4513 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4514 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4516 vna_off
= offset
+ ivn
.vn_aux
;
4520 Elf_External_Vernaux evna
;
4522 GET_DATA (vna_off
, evna
,
4523 "version need aux (3)");
4525 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4526 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4527 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4529 vna_off
+= ivna
.vna_next
;
4531 while (ivna
.vna_other
!= vers_data
4532 && ivna
.vna_next
!= 0);
4534 if (ivna
.vna_other
== vers_data
)
4537 offset
+= ivn
.vn_next
;
4539 while (ivn
.vn_next
!= 0);
4541 if (ivna
.vna_other
== vers_data
)
4544 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
4547 else if (! is_nobits
)
4548 error (_("bad dynamic symbol"));
4555 if (vers_data
!= 0x8001)
4557 Elf_Internal_Verdef ivd
;
4558 Elf_Internal_Verdaux ivda
;
4559 Elf_External_Verdaux evda
;
4560 unsigned long offset
;
4563 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
4568 Elf_External_Verdef evd
;
4570 GET_DATA (offset
, evd
, "version def");
4572 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4573 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4574 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4576 offset
+= ivd
.vd_next
;
4578 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
4579 && ivd
.vd_next
!= 0);
4581 offset
-= ivd
.vd_next
;
4582 offset
+= ivd
.vd_aux
;
4584 GET_DATA (offset
, evda
, "version def aux");
4586 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4588 if (psym
->st_name
!= ivda
.vda_name
)
4589 printf ((vers_data
& 0x8000)
4591 strtab
+ ivda
.vda_name
);
4601 if (strtab
!= string_table
)
4607 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4609 if (do_histogram
&& buckets
!= NULL
)
4616 int nzero_counts
= 0;
4619 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4621 printf (_(" Length Number %% of total Coverage\n"));
4623 lengths
= (int *) calloc (nbuckets
, sizeof (int));
4624 if (lengths
== NULL
)
4626 error (_("Out of memory"));
4629 for (hn
= 0; hn
< nbuckets
; ++hn
)
4634 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
4637 if (maxlength
< ++lengths
[hn
])
4642 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
4645 error (_("Out of memory"));
4649 for (hn
= 0; hn
< nbuckets
; ++hn
)
4650 ++ counts
[lengths
[hn
]];
4654 printf (" 0 %-10d (%5.1f%%)\n",
4655 counts
[0], (counts
[0] * 100.0) / nbuckets
);
4656 for (si
= 1; si
<= maxlength
; ++si
)
4658 nzero_counts
+= counts
[si
] * si
;
4659 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4660 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
4661 (nzero_counts
* 100.0) / nsyms
);
4669 if (buckets
!= NULL
)
4679 process_syminfo (file
)
4680 FILE * file ATTRIBUTE_UNUSED
;
4684 if (dynamic_syminfo
== NULL
4686 /* No syminfo, this is ok. */
4689 /* There better should be a dynamic symbol section. */
4690 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
4694 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4695 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
4697 printf (_(" Num: Name BoundTo Flags\n"));
4698 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
4700 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
4702 printf ("%4d: %-30s ", i
,
4703 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
4705 switch (dynamic_syminfo
[i
].si_boundto
)
4707 case SYMINFO_BT_SELF
:
4708 fputs ("SELF ", stdout
);
4710 case SYMINFO_BT_PARENT
:
4711 fputs ("PARENT ", stdout
);
4714 if (dynamic_syminfo
[i
].si_boundto
> 0
4715 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
4718 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
4720 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
4724 if (flags
& SYMINFO_FLG_DIRECT
)
4726 if (flags
& SYMINFO_FLG_PASSTHRU
)
4727 printf (" PASSTHRU");
4728 if (flags
& SYMINFO_FLG_COPY
)
4730 if (flags
& SYMINFO_FLG_LAZYLOAD
)
4731 printf (" LAZYLOAD");
4739 #ifdef SUPPORT_DISASSEMBLY
4741 disassemble_section (section
, file
)
4742 Elf32_Internal_Shdr
* section
;
4745 printf (_("\nAssembly dump of section %s\n"),
4746 SECTION_NAME (section
));
4748 /* XXX -- to be done --- XXX */
4755 dump_section (section
, file
)
4756 Elf32_Internal_Shdr
* section
;
4759 bfd_size_type bytes
;
4761 unsigned char * data
;
4762 unsigned char * start
;
4764 bytes
= section
->sh_size
;
4768 printf (_("\nSection '%s' has no data to dump.\n"),
4769 SECTION_NAME (section
));
4773 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
4775 addr
= section
->sh_addr
;
4777 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
4788 lbytes
= (bytes
> 16 ? 16 : bytes
);
4790 printf (" 0x%8.8lx ", (unsigned long) addr
);
4792 switch (elf_header
.e_ident
[EI_DATA
])
4796 for (j
= 15; j
>= 0; j
--)
4799 printf ("%2.2x", data
[j
]);
4809 for (j
= 0; j
< 16; j
++)
4812 printf ("%2.2x", data
[j
]);
4822 for (j
= 0; j
< lbytes
; j
++)
4825 if (k
>= ' ' && k
< 0x80)
4844 static unsigned long int
4845 read_leb128 (data
, length_return
, sign
)
4846 unsigned char * data
;
4847 int * length_return
;
4850 unsigned long int result
= 0;
4851 unsigned int num_read
= 0;
4860 result
|= (byte
& 0x7f) << shift
;
4865 while (byte
& 0x80);
4867 if (length_return
!= NULL
)
4868 * length_return
= num_read
;
4870 if (sign
&& (shift
< 32) && (byte
& 0x40))
4871 result
|= -1 << shift
;
4876 typedef struct State_Machine_Registers
4878 unsigned long address
;
4881 unsigned int column
;
4885 /* This variable hold the number of the last entry seen
4886 in the File Table. */
4887 unsigned int last_file_entry
;
4890 static SMR state_machine_regs
;
4893 reset_state_machine (is_stmt
)
4896 state_machine_regs
.address
= 0;
4897 state_machine_regs
.file
= 1;
4898 state_machine_regs
.line
= 1;
4899 state_machine_regs
.column
= 0;
4900 state_machine_regs
.is_stmt
= is_stmt
;
4901 state_machine_regs
.basic_block
= 0;
4902 state_machine_regs
.end_sequence
= 0;
4903 state_machine_regs
.last_file_entry
= 0;
4906 /* Handled an extend line op. Returns true if this is the end
4909 process_extended_line_op (data
, is_stmt
, pointer_size
)
4910 unsigned char * data
;
4914 unsigned char op_code
;
4917 unsigned char * name
;
4920 len
= read_leb128 (data
, & bytes_read
, 0);
4925 warn (_("badly formed extended line op encountered!"));
4930 op_code
= * data
++;
4932 printf (_(" Extended opcode %d: "), op_code
);
4936 case DW_LNE_end_sequence
:
4937 printf (_("End of Sequence\n\n"));
4938 reset_state_machine (is_stmt
);
4941 case DW_LNE_set_address
:
4942 adr
= byte_get (data
, pointer_size
);
4943 printf (_("set Address to 0x%lx\n"), adr
);
4944 state_machine_regs
.address
= adr
;
4947 case DW_LNE_define_file
:
4948 printf (_(" define new File Table entry\n"));
4949 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4951 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4953 data
+= strlen ((char *) data
) + 1;
4954 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4956 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4958 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4959 printf (_("%s\n\n"), name
);
4963 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
4970 /* Size of pointers in the .debug_line section. This information is not
4971 really present in that section. It's obtained before dumping the debug
4972 sections by doing some pre-scan of the .debug_info section. */
4973 static int debug_line_pointer_size
= 4;
4976 display_debug_lines (section
, start
, file
)
4977 Elf32_Internal_Shdr
* section
;
4978 unsigned char * start
;
4979 FILE * file ATTRIBUTE_UNUSED
;
4981 DWARF2_External_LineInfo
* external
;
4982 DWARF2_Internal_LineInfo info
;
4983 unsigned char * standard_opcodes
;
4984 unsigned char * data
= start
;
4985 unsigned char * end
= start
+ section
->sh_size
;
4986 unsigned char * end_of_sequence
;
4989 printf (_("\nDump of debug contents of section %s:\n\n"),
4990 SECTION_NAME (section
));
4994 external
= (DWARF2_External_LineInfo
*) data
;
4996 /* Check the length of the block. */
4997 info
.li_length
= BYTE_GET (external
->li_length
);
4998 if (info
.li_length
> section
->sh_size
)
5001 (_("The line info appears to be corrupt - the section is too small\n"));
5005 /* Check its version number. */
5006 info
.li_version
= BYTE_GET (external
->li_version
);
5007 if (info
.li_version
!= 2)
5009 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5013 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
5014 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
5015 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
5016 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
5017 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
5018 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
5020 /* Sign extend the line base field. */
5021 info
.li_line_base
<<= 24;
5022 info
.li_line_base
>>= 24;
5024 printf (_(" Length: %ld\n"), info
.li_length
);
5025 printf (_(" DWARF Version: %d\n"), info
.li_version
);
5026 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
5027 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
5028 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
5029 printf (_(" Line Base: %d\n"), info
.li_line_base
);
5030 printf (_(" Line Range: %d\n"), info
.li_line_range
);
5031 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
5033 end_of_sequence
= data
+ info
.li_length
+ sizeof (info
.li_length
);
5035 reset_state_machine (info
.li_default_is_stmt
);
5037 /* Display the contents of the Opcodes table. */
5038 standard_opcodes
= data
+ sizeof (* external
);
5040 printf (_("\n Opcodes:\n"));
5042 for (i
= 1; i
< info
.li_opcode_base
; i
++)
5043 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
5045 /* Display the contents of the Directory table. */
5046 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
5049 printf (_("\n The Directory Table is empty.\n"));
5052 printf (_("\n The Directory Table:\n"));
5056 printf (_(" %s\n"), data
);
5058 data
+= strlen ((char *) data
) + 1;
5062 /* Skip the NUL at the end of the table. */
5065 /* Display the contents of the File Name table. */
5067 printf (_("\n The File Name Table is empty.\n"));
5070 printf (_("\n The File Name Table:\n"));
5071 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5075 unsigned char * name
;
5078 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5081 data
+= strlen ((char *) data
) + 1;
5083 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5085 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5087 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5089 printf (_("%s\n"), name
);
5093 /* Skip the NUL at the end of the table. */
5096 /* Now display the statements. */
5097 printf (_("\n Line Number Statements:\n"));
5100 while (data
< end_of_sequence
)
5102 unsigned char op_code
;
5106 op_code
= * data
++;
5110 case DW_LNS_extended_op
:
5111 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
5112 debug_line_pointer_size
);
5116 printf (_(" Copy\n"));
5119 case DW_LNS_advance_pc
:
5120 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
5122 state_machine_regs
.address
+= adv
;
5123 printf (_(" Advance PC by %d to %lx\n"), adv
,
5124 state_machine_regs
.address
);
5127 case DW_LNS_advance_line
:
5128 adv
= read_leb128 (data
, & bytes_read
, 1);
5130 state_machine_regs
.line
+= adv
;
5131 printf (_(" Advance Line by %d to %d\n"), adv
,
5132 state_machine_regs
.line
);
5135 case DW_LNS_set_file
:
5136 adv
= read_leb128 (data
, & bytes_read
, 0);
5138 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5140 state_machine_regs
.file
= adv
;
5143 case DW_LNS_set_column
:
5144 adv
= read_leb128 (data
, & bytes_read
, 0);
5146 printf (_(" Set column to %d\n"), adv
);
5147 state_machine_regs
.column
= adv
;
5150 case DW_LNS_negate_stmt
:
5151 adv
= state_machine_regs
.is_stmt
;
5153 printf (_(" Set is_stmt to %d\n"), adv
);
5154 state_machine_regs
.is_stmt
= adv
;
5157 case DW_LNS_set_basic_block
:
5158 printf (_(" Set basic block\n"));
5159 state_machine_regs
.basic_block
= 1;
5162 case DW_LNS_const_add_pc
:
5163 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
5164 * info
.li_min_insn_length
);
5165 state_machine_regs
.address
+= adv
;
5166 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
5167 state_machine_regs
.address
);
5170 case DW_LNS_fixed_advance_pc
:
5171 adv
= byte_get (data
, 2);
5173 state_machine_regs
.address
+= adv
;
5174 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5175 adv
, state_machine_regs
.address
);
5179 op_code
-= info
.li_opcode_base
;
5180 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
5181 state_machine_regs
.address
+= adv
;
5182 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5183 op_code
, adv
, state_machine_regs
.address
);
5184 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
5185 state_machine_regs
.line
+= adv
;
5186 printf (_(" and Line by %d to %d\n"),
5187 adv
, state_machine_regs
.line
);
5198 display_debug_pubnames (section
, start
, file
)
5199 Elf32_Internal_Shdr
* section
;
5200 unsigned char * start
;
5201 FILE * file ATTRIBUTE_UNUSED
;
5203 DWARF2_External_PubNames
* external
;
5204 DWARF2_Internal_PubNames pubnames
;
5205 unsigned char * end
;
5207 end
= start
+ section
->sh_size
;
5209 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5213 unsigned char * data
;
5214 unsigned long offset
;
5216 external
= (DWARF2_External_PubNames
*) start
;
5218 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5219 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5220 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5221 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5223 data
= start
+ sizeof (* external
);
5224 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5226 if (pubnames
.pn_version
!= 2)
5228 warn (_("Only DWARF 2 pubnames are currently supported"));
5232 printf (_(" Length: %ld\n"),
5233 pubnames
.pn_length
);
5234 printf (_(" Version: %d\n"),
5235 pubnames
.pn_version
);
5236 printf (_(" Offset into .debug_info section: %ld\n"),
5237 pubnames
.pn_offset
);
5238 printf (_(" Size of area in .debug_info section: %ld\n"),
5241 printf (_("\n Offset\tName\n"));
5245 offset
= byte_get (data
, 4);
5250 printf (" %ld\t\t%s\n", offset
, data
);
5251 data
+= strlen ((char *) data
) + 1;
5254 while (offset
!= 0);
5267 case DW_TAG_padding
: return "DW_TAG_padding";
5268 case DW_TAG_array_type
: return "DW_TAG_array_type";
5269 case DW_TAG_class_type
: return "DW_TAG_class_type";
5270 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5271 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5272 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5273 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5274 case DW_TAG_label
: return "DW_TAG_label";
5275 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5276 case DW_TAG_member
: return "DW_TAG_member";
5277 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5278 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5279 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5280 case DW_TAG_string_type
: return "DW_TAG_string_type";
5281 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5282 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5283 case DW_TAG_typedef
: return "DW_TAG_typedef";
5284 case DW_TAG_union_type
: return "DW_TAG_union_type";
5285 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5286 case DW_TAG_variant
: return "DW_TAG_variant";
5287 case DW_TAG_common_block
: return "DW_TAG_common_block";
5288 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5289 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5290 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5291 case DW_TAG_module
: return "DW_TAG_module";
5292 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5293 case DW_TAG_set_type
: return "DW_TAG_set_type";
5294 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5295 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5296 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5297 case DW_TAG_base_type
: return "DW_TAG_base_type";
5298 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5299 case DW_TAG_const_type
: return "DW_TAG_const_type";
5300 case DW_TAG_constant
: return "DW_TAG_constant";
5301 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5302 case DW_TAG_file_type
: return "DW_TAG_file_type";
5303 case DW_TAG_friend
: return "DW_TAG_friend";
5304 case DW_TAG_namelist
: return "DW_TAG_namelist";
5305 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5306 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5307 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5308 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5309 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5310 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5311 case DW_TAG_try_block
: return "DW_TAG_try_block";
5312 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5313 case DW_TAG_variable
: return "DW_TAG_variable";
5314 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5315 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5316 case DW_TAG_format_label
: return "DW_TAG_format_label";
5317 case DW_TAG_function_template
: return "DW_TAG_function_template";
5318 case DW_TAG_class_template
: return "DW_TAG_class_template";
5321 static char buffer
[100];
5323 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
5330 get_AT_name (attribute
)
5331 unsigned long attribute
;
5335 case DW_AT_sibling
: return "DW_AT_sibling";
5336 case DW_AT_location
: return "DW_AT_location";
5337 case DW_AT_name
: return "DW_AT_name";
5338 case DW_AT_ordering
: return "DW_AT_ordering";
5339 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
5340 case DW_AT_byte_size
: return "DW_AT_byte_size";
5341 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
5342 case DW_AT_bit_size
: return "DW_AT_bit_size";
5343 case DW_AT_element_list
: return "DW_AT_element_list";
5344 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
5345 case DW_AT_low_pc
: return "DW_AT_low_pc";
5346 case DW_AT_high_pc
: return "DW_AT_high_pc";
5347 case DW_AT_language
: return "DW_AT_language";
5348 case DW_AT_member
: return "DW_AT_member";
5349 case DW_AT_discr
: return "DW_AT_discr";
5350 case DW_AT_discr_value
: return "DW_AT_discr_value";
5351 case DW_AT_visibility
: return "DW_AT_visibility";
5352 case DW_AT_import
: return "DW_AT_import";
5353 case DW_AT_string_length
: return "DW_AT_string_length";
5354 case DW_AT_common_reference
: return "DW_AT_common_reference";
5355 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5356 case DW_AT_const_value
: return "DW_AT_const_value";
5357 case DW_AT_containing_type
: return "DW_AT_containing_type";
5358 case DW_AT_default_value
: return "DW_AT_default_value";
5359 case DW_AT_inline
: return "DW_AT_inline";
5360 case DW_AT_is_optional
: return "DW_AT_is_optional";
5361 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5362 case DW_AT_producer
: return "DW_AT_producer";
5363 case DW_AT_prototyped
: return "DW_AT_prototyped";
5364 case DW_AT_return_addr
: return "DW_AT_return_addr";
5365 case DW_AT_start_scope
: return "DW_AT_start_scope";
5366 case DW_AT_stride_size
: return "DW_AT_stride_size";
5367 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5368 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5369 case DW_AT_accessibility
: return "DW_AT_accessibility";
5370 case DW_AT_address_class
: return "DW_AT_address_class";
5371 case DW_AT_artificial
: return "DW_AT_artificial";
5372 case DW_AT_base_types
: return "DW_AT_base_types";
5373 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5374 case DW_AT_count
: return "DW_AT_count";
5375 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5376 case DW_AT_decl_column
: return "DW_AT_decl_column";
5377 case DW_AT_decl_file
: return "DW_AT_decl_file";
5378 case DW_AT_decl_line
: return "DW_AT_decl_line";
5379 case DW_AT_declaration
: return "DW_AT_declaration";
5380 case DW_AT_discr_list
: return "DW_AT_discr_list";
5381 case DW_AT_encoding
: return "DW_AT_encoding";
5382 case DW_AT_external
: return "DW_AT_external";
5383 case DW_AT_frame_base
: return "DW_AT_frame_base";
5384 case DW_AT_friend
: return "DW_AT_friend";
5385 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5386 case DW_AT_macro_info
: return "DW_AT_macro_info";
5387 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5388 case DW_AT_priority
: return "DW_AT_priority";
5389 case DW_AT_segment
: return "DW_AT_segment";
5390 case DW_AT_specification
: return "DW_AT_specification";
5391 case DW_AT_static_link
: return "DW_AT_static_link";
5392 case DW_AT_type
: return "DW_AT_type";
5393 case DW_AT_use_location
: return "DW_AT_use_location";
5394 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5395 case DW_AT_virtuality
: return "DW_AT_virtuality";
5396 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5397 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5398 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5399 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5400 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5401 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5402 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5403 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5404 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5405 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5406 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5407 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5408 case DW_AT_sf_names
: return "DW_AT_sf_names";
5409 case DW_AT_src_info
: return "DW_AT_src_info";
5410 case DW_AT_mac_info
: return "DW_AT_mac_info";
5411 case DW_AT_src_coords
: return "DW_AT_src_coords";
5412 case DW_AT_body_begin
: return "DW_AT_body_begin";
5413 case DW_AT_body_end
: return "DW_AT_body_end";
5416 static char buffer
[100];
5418 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5425 get_FORM_name (form
)
5430 case DW_FORM_addr
: return "DW_FORM_addr";
5431 case DW_FORM_block2
: return "DW_FORM_block2";
5432 case DW_FORM_block4
: return "DW_FORM_block4";
5433 case DW_FORM_data2
: return "DW_FORM_data2";
5434 case DW_FORM_data4
: return "DW_FORM_data4";
5435 case DW_FORM_data8
: return "DW_FORM_data8";
5436 case DW_FORM_string
: return "DW_FORM_string";
5437 case DW_FORM_block
: return "DW_FORM_block";
5438 case DW_FORM_block1
: return "DW_FORM_block1";
5439 case DW_FORM_data1
: return "DW_FORM_data1";
5440 case DW_FORM_flag
: return "DW_FORM_flag";
5441 case DW_FORM_sdata
: return "DW_FORM_sdata";
5442 case DW_FORM_strp
: return "DW_FORM_strp";
5443 case DW_FORM_udata
: return "DW_FORM_udata";
5444 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5445 case DW_FORM_ref1
: return "DW_FORM_ref1";
5446 case DW_FORM_ref2
: return "DW_FORM_ref2";
5447 case DW_FORM_ref4
: return "DW_FORM_ref4";
5448 case DW_FORM_ref8
: return "DW_FORM_ref8";
5449 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5450 case DW_FORM_indirect
: return "DW_FORM_indirect";
5453 static char buffer
[100];
5455 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5461 /* FIXME: There are better and more effiecint ways to handle
5462 these structures. For now though, I just want something that
5463 is simple to implement. */
5464 typedef struct abbrev_attr
5466 unsigned long attribute
;
5468 struct abbrev_attr
* next
;
5472 typedef struct abbrev_entry
5474 unsigned long entry
;
5477 struct abbrev_attr
* first_attr
;
5478 struct abbrev_attr
* last_attr
;
5479 struct abbrev_entry
* next
;
5483 static abbrev_entry
* first_abbrev
= NULL
;
5484 static abbrev_entry
* last_abbrev
= NULL
;
5487 free_abbrevs
PARAMS ((void))
5489 abbrev_entry
* abbrev
;
5491 for (abbrev
= first_abbrev
; abbrev
;)
5493 abbrev_entry
* next
= abbrev
->next
;
5496 for (attr
= abbrev
->first_attr
; attr
;)
5498 abbrev_attr
* next
= attr
->next
;
5508 last_abbrev
= first_abbrev
= NULL
;
5512 add_abbrev (number
, tag
, children
)
5513 unsigned long number
;
5517 abbrev_entry
* entry
;
5519 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
5525 entry
->entry
= number
;
5527 entry
->children
= children
;
5528 entry
->first_attr
= NULL
;
5529 entry
->last_attr
= NULL
;
5532 if (first_abbrev
== NULL
)
5533 first_abbrev
= entry
;
5535 last_abbrev
->next
= entry
;
5537 last_abbrev
= entry
;
5541 add_abbrev_attr (attribute
, form
)
5542 unsigned long attribute
;
5547 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
5553 attr
->attribute
= attribute
;
5557 if (last_abbrev
->first_attr
== NULL
)
5558 last_abbrev
->first_attr
= attr
;
5560 last_abbrev
->last_attr
->next
= attr
;
5562 last_abbrev
->last_attr
= attr
;
5565 /* Processes the (partial) contents of a .debug_abbrev section.
5566 Returns NULL if the end of the section was encountered.
5567 Returns the address after the last byte read if the end of
5568 an abbreviation set was found. */
5570 static unsigned char *
5571 process_abbrev_section (start
, end
)
5572 unsigned char * start
;
5573 unsigned char * end
;
5575 if (first_abbrev
!= NULL
)
5581 unsigned long entry
;
5583 unsigned long attribute
;
5586 entry
= read_leb128 (start
, & bytes_read
, 0);
5587 start
+= bytes_read
;
5589 /* A single zero is supposed to end the section according
5590 to the standard. If there's more, then signal that to
5593 return start
== end
? NULL
: start
;
5595 tag
= read_leb128 (start
, & bytes_read
, 0);
5596 start
+= bytes_read
;
5598 children
= * start
++;
5600 add_abbrev (entry
, tag
, children
);
5606 attribute
= read_leb128 (start
, & bytes_read
, 0);
5607 start
+= bytes_read
;
5609 form
= read_leb128 (start
, & bytes_read
, 0);
5610 start
+= bytes_read
;
5613 add_abbrev_attr (attribute
, form
);
5615 while (attribute
!= 0);
5623 display_debug_abbrev (section
, start
, file
)
5624 Elf32_Internal_Shdr
* section
;
5625 unsigned char * start
;
5626 FILE * file ATTRIBUTE_UNUSED
;
5628 abbrev_entry
* entry
;
5629 unsigned char * end
= start
+ section
->sh_size
;
5631 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5635 start
= process_abbrev_section (start
, end
);
5637 printf (_(" Number TAG\n"));
5639 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5643 printf (_(" %ld %s [%s]\n"),
5645 get_TAG_name (entry
->tag
),
5646 entry
->children
? _("has children") : _("no children"));
5648 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5650 printf (_(" %-18s %s\n"),
5651 get_AT_name (attr
->attribute
),
5652 get_FORM_name (attr
->form
));
5664 static unsigned char *
5665 display_block (data
, length
)
5666 unsigned char * data
;
5667 unsigned long length
;
5669 printf (_(" %lu byte block: "), length
);
5672 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
5678 decode_location_expression (data
, pointer_size
, length
)
5679 unsigned char * data
;
5680 unsigned int pointer_size
;
5681 unsigned long length
;
5685 unsigned long uvalue
;
5686 unsigned char *end
= data
+ length
;
5695 printf ("DW_OP_addr: %lx",
5696 (unsigned long) byte_get (data
, pointer_size
));
5697 data
+= pointer_size
;
5700 printf ("DW_OP_deref");
5703 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
5706 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
5709 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
5713 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
5717 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
5721 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
5725 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
5726 (unsigned long) byte_get (data
+ 4, 4));
5730 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
5731 (long) byte_get (data
+ 4, 4));
5735 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
5739 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
5743 printf ("DW_OP_dup");
5746 printf ("DW_OP_drop");
5749 printf ("DW_OP_over");
5752 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
5755 printf ("DW_OP_swap");
5758 printf ("DW_OP_rot");
5761 printf ("DW_OP_xderef");
5764 printf ("DW_OP_abs");
5767 printf ("DW_OP_and");
5770 printf ("DW_OP_div");
5773 printf ("DW_OP_minus");
5776 printf ("DW_OP_mod");
5779 printf ("DW_OP_mul");
5782 printf ("DW_OP_neg");
5785 printf ("DW_OP_not");
5788 printf ("DW_OP_or");
5791 printf ("DW_OP_plus");
5793 case DW_OP_plus_uconst
:
5794 printf ("DW_OP_plus_uconst: %lu",
5795 read_leb128 (data
, &bytes_read
, 0));
5799 printf ("DW_OP_shl");
5802 printf ("DW_OP_shr");
5805 printf ("DW_OP_shra");
5808 printf ("DW_OP_xor");
5811 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
5815 printf ("DW_OP_eq");
5818 printf ("DW_OP_ge");
5821 printf ("DW_OP_gt");
5824 printf ("DW_OP_le");
5827 printf ("DW_OP_lt");
5830 printf ("DW_OP_ne");
5833 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
5869 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
5904 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
5939 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
5940 read_leb128 (data
, &bytes_read
, 1));
5945 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
5949 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
5953 uvalue
= read_leb128 (data
, &bytes_read
, 0);
5955 printf ("DW_OP_bregx: %lu %ld", uvalue
,
5956 read_leb128 (data
, &bytes_read
, 1));
5960 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
5963 case DW_OP_deref_size
:
5964 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
5966 case DW_OP_xderef_size
:
5967 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
5970 printf ("DW_OP_nop");
5974 if (op
>= DW_OP_lo_user
5975 && op
<= DW_OP_hi_user
)
5976 printf (_("(User defined location op)"));
5978 printf (_("(Unknown location op)"));
5979 /* No way to tell where the next op is, so just bail. */
5986 static unsigned char *
5987 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
5988 unsigned long attribute
;
5990 unsigned char * data
;
5991 unsigned long cu_offset
;
5992 unsigned long pointer_size
;
5994 unsigned long uvalue
= 0;
5995 unsigned char * block_start
= NULL
;
5998 printf (" %-18s:", get_AT_name (attribute
));
6005 case DW_FORM_ref_addr
:
6007 uvalue
= byte_get (data
, pointer_size
);
6008 data
+= pointer_size
;
6014 uvalue
= byte_get (data
++, 1);
6019 uvalue
= byte_get (data
, 2);
6025 uvalue
= byte_get (data
, 4);
6030 uvalue
= read_leb128 (data
, & bytes_read
, 1);
6034 case DW_FORM_ref_udata
:
6036 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6043 case DW_FORM_ref_addr
:
6044 printf (" <#%lx>", uvalue
);
6050 case DW_FORM_ref_udata
:
6051 printf (" <%lx>", uvalue
+ cu_offset
);
6055 printf (" %#lx", uvalue
);
6063 printf (" %ld", uvalue
);
6068 uvalue
= byte_get (data
, 4);
6069 printf (" %lx", uvalue
);
6070 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
6074 case DW_FORM_string
:
6075 printf (" %s", data
);
6076 data
+= strlen ((char *) data
) + 1;
6080 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6081 block_start
= data
+ bytes_read
;
6082 data
= display_block (block_start
, uvalue
);
6085 case DW_FORM_block1
:
6086 uvalue
= byte_get (data
, 1);
6087 block_start
= data
+ 1;
6088 data
= display_block (block_start
, uvalue
);
6091 case DW_FORM_block2
:
6092 uvalue
= byte_get (data
, 2);
6093 block_start
= data
+ 2;
6094 data
= display_block (block_start
, uvalue
);
6097 case DW_FORM_block4
:
6098 uvalue
= byte_get (data
, 4);
6099 block_start
= data
+ 4;
6100 data
= display_block (block_start
, uvalue
);
6104 case DW_FORM_indirect
:
6105 warn (_("Unable to handle FORM: %d"), form
);
6109 warn (_("Unrecognised form: %d"), form
);
6113 /* For some attributes we can display futher information. */
6122 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6123 case DW_INL_inlined
: printf (_("(inlined)")); break;
6124 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6125 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6126 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6130 case DW_AT_language
:
6133 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6134 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6135 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6136 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6137 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6138 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6139 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6140 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6141 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6142 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6143 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6144 default: printf ("(Unknown: %lx)", uvalue
); break;
6148 case DW_AT_encoding
:
6151 case DW_ATE_void
: printf ("(void)"); break;
6152 case DW_ATE_address
: printf ("(machine address)"); break;
6153 case DW_ATE_boolean
: printf ("(boolean)"); break;
6154 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6155 case DW_ATE_float
: printf ("(float)"); break;
6156 case DW_ATE_signed
: printf ("(signed)"); break;
6157 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6158 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6159 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6161 if (uvalue
>= DW_ATE_lo_user
6162 && uvalue
<= DW_ATE_hi_user
)
6163 printf ("(user defined type)");
6165 printf ("(unknown type)");
6170 case DW_AT_accessibility
:
6173 case DW_ACCESS_public
: printf ("(public)"); break;
6174 case DW_ACCESS_protected
: printf ("(protected)"); break;
6175 case DW_ACCESS_private
: printf ("(private)"); break;
6176 default: printf ("(unknown accessibility)"); break;
6180 case DW_AT_visibility
:
6183 case DW_VIS_local
: printf ("(local)"); break;
6184 case DW_VIS_exported
: printf ("(exported)"); break;
6185 case DW_VIS_qualified
: printf ("(qualified)"); break;
6186 default: printf ("(unknown visibility)"); break;
6190 case DW_AT_virtuality
:
6193 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6194 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6195 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6196 default: printf ("(unknown virtuality)"); break;
6200 case DW_AT_identifier_case
:
6203 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6204 case DW_ID_up_case
: printf ("(up_case)"); break;
6205 case DW_ID_down_case
: printf ("(down_case)"); break;
6206 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6207 default: printf ("(unknown case)"); break;
6211 case DW_AT_calling_convention
:
6214 case DW_CC_normal
: printf ("(normal)"); break;
6215 case DW_CC_program
: printf ("(program)"); break;
6216 case DW_CC_nocall
: printf ("(nocall)"); break;
6218 if (uvalue
>= DW_CC_lo_user
6219 && uvalue
<= DW_CC_hi_user
)
6220 printf ("(user defined)");
6222 printf ("(unknown convention)");
6226 case DW_AT_frame_base
:
6227 case DW_AT_location
:
6228 case DW_AT_data_member_location
:
6229 case DW_AT_vtable_elem_location
:
6233 decode_location_expression (block_start
, pointer_size
, uvalue
);
6247 display_debug_info (section
, start
, file
)
6248 Elf32_Internal_Shdr
* section
;
6249 unsigned char * start
;
6252 unsigned char * end
= start
+ section
->sh_size
;
6253 unsigned char * section_begin
= start
;
6255 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6259 DWARF2_External_CompUnit
* external
;
6260 DWARF2_Internal_CompUnit compunit
;
6261 unsigned char * tags
;
6264 unsigned long cu_offset
;
6266 external
= (DWARF2_External_CompUnit
*) start
;
6268 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6269 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6270 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6271 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6273 tags
= start
+ sizeof (* external
);
6274 cu_offset
= start
- section_begin
;
6275 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6277 if (compunit
.cu_version
!= 2)
6279 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6283 printf (_(" Compilation Unit:\n"));
6284 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6285 printf (_(" Version: %d\n"), compunit
.cu_version
);
6286 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6287 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6289 if (first_abbrev
!= NULL
)
6292 /* Read in the abbrevs used by this compilation unit. */
6295 Elf32_Internal_Shdr
* sec
;
6296 unsigned char * begin
;
6298 /* Locate the .debug_abbrev section and process it. */
6299 for (i
= 0, sec
= section_headers
;
6300 i
< elf_header
.e_shnum
;
6302 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6305 if (i
== -1 || sec
->sh_size
== 0)
6307 warn (_("Unable to locate .debug_abbrev section!\n"));
6311 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6312 "debug_abbrev section data");
6314 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6315 begin
+ sec
->sh_size
);
6321 while (tags
< start
)
6324 unsigned long abbrev_number
;
6325 abbrev_entry
* entry
;
6328 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6331 /* A null DIE marks the end of a list of children. */
6332 if (abbrev_number
== 0)
6338 /* Scan through the abbreviation list until we reach the
6340 for (entry
= first_abbrev
;
6341 entry
&& entry
->entry
!= abbrev_number
;
6342 entry
= entry
->next
)
6347 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6352 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6353 level
, tags
- section_begin
- bytes_read
,
6355 get_TAG_name (entry
->tag
));
6357 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6358 tags
= read_and_display_attr (attr
->attribute
,
6361 compunit
.cu_pointer_size
);
6363 if (entry
->children
)
6374 display_debug_aranges (section
, start
, file
)
6375 Elf32_Internal_Shdr
* section
;
6376 unsigned char * start
;
6377 FILE * file ATTRIBUTE_UNUSED
;
6379 unsigned char * end
= start
+ section
->sh_size
;
6381 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6385 DWARF2_External_ARange
* external
;
6386 DWARF2_Internal_ARange arange
;
6387 unsigned char * ranges
;
6388 unsigned long length
;
6389 unsigned long address
;
6392 external
= (DWARF2_External_ARange
*) start
;
6394 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6395 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6396 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6397 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6398 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6400 printf (_(" Length: %ld\n"), arange
.ar_length
);
6401 printf (_(" Version: %d\n"), arange
.ar_version
);
6402 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6403 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6404 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6406 printf (_("\n Address Length\n"));
6408 ranges
= start
+ sizeof (* external
);
6410 /* Must pad to an alignment boundary that is twice the pointer size. */
6411 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
6413 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6417 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6419 ranges
+= arange
.ar_pointer_size
;
6421 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6423 ranges
+= arange
.ar_pointer_size
;
6425 /* A pair of zeros marks the end of the list. */
6426 if (address
== 0 && length
== 0)
6429 printf (" %8.8lx %lu\n", address
, length
);
6432 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6442 display_debug_not_supported (section
, start
, file
)
6443 Elf32_Internal_Shdr
* section
;
6444 unsigned char * start ATTRIBUTE_UNUSED
;
6445 FILE * file ATTRIBUTE_UNUSED
;
6447 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6448 SECTION_NAME (section
));
6453 /* Pre-scan the .debug_info section to record the size of address.
6454 When dumping the .debug_line, we use that size information, assuming
6455 that all compilation units have the same address size. */
6457 prescan_debug_info (section
, start
, file
)
6458 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
6459 unsigned char * start
;
6460 FILE * file ATTRIBUTE_UNUSED
;
6462 DWARF2_External_CompUnit
* external
;
6464 external
= (DWARF2_External_CompUnit
*) start
;
6466 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6470 /* A structure containing the name of a debug section and a pointer
6471 to a function that can decode it. The third field is a prescan
6472 function to be run over the section before displaying any of the
6477 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6478 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6482 { ".debug_info", display_debug_info
, prescan_debug_info
},
6483 { ".debug_abbrev", display_debug_abbrev
, NULL
},
6484 { ".debug_line", display_debug_lines
, NULL
},
6485 { ".debug_aranges", display_debug_aranges
, NULL
},
6486 { ".debug_pubnames", display_debug_pubnames
, NULL
},
6487 { ".debug_macinfo", display_debug_not_supported
, NULL
},
6488 { ".debug_frame", display_debug_not_supported
, NULL
},
6489 { ".debug_str", display_debug_not_supported
, NULL
},
6490 { ".debug_static_func", display_debug_not_supported
, NULL
},
6491 { ".debug_static_vars", display_debug_not_supported
, NULL
},
6492 { ".debug_types", display_debug_not_supported
, NULL
},
6493 { ".debug_weaknames", display_debug_not_supported
, NULL
}
6497 display_debug_section (section
, file
)
6498 Elf32_Internal_Shdr
* section
;
6501 char * name
= SECTION_NAME (section
);
6502 bfd_size_type length
;
6503 unsigned char * start
;
6506 length
= section
->sh_size
;
6509 printf (_("\nSection '%s' has no debugging data.\n"), name
);
6513 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6514 "debug section data");
6516 /* See if we know how to display the contents of this section. */
6517 for (i
= NUM_ELEM (debug_displays
); i
--;)
6518 if (strcmp (debug_displays
[i
].name
, name
) == 0)
6520 debug_displays
[i
].display (section
, start
, file
);
6525 printf (_("Unrecognised debug section: %s\n"), name
);
6529 /* If we loaded in the abbrev section at some point,
6530 we must release it here. */
6531 if (first_abbrev
!= NULL
)
6538 process_section_contents (file
)
6541 Elf32_Internal_Shdr
* section
;
6547 /* Pre-scan the debug sections to find some debug information not
6548 present in some of them. For the .debug_line, we must find out the
6549 size of address (specified in .debug_info and .debug_aranges). */
6550 for (i
= 0, section
= section_headers
;
6551 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6554 char * name
= SECTION_NAME (section
);
6557 if (section
->sh_size
== 0)
6560 /* See if there is some pre-scan operation for this section. */
6561 for (j
= NUM_ELEM (debug_displays
); j
--;)
6562 if (strcmp (debug_displays
[j
].name
, name
) == 0)
6564 if (debug_displays
[j
].prescan
!= NULL
)
6566 bfd_size_type length
;
6567 unsigned char * start
;
6569 length
= section
->sh_size
;
6570 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6571 "debug section data");
6573 debug_displays
[j
].prescan (section
, start
, file
);
6581 for (i
= 0, section
= section_headers
;
6582 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6585 #ifdef SUPPORT_DISASSEMBLY
6586 if (dump_sects
[i
] & DISASS_DUMP
)
6587 disassemble_section (section
, file
);
6589 if (dump_sects
[i
] & HEX_DUMP
)
6590 dump_section (section
, file
);
6592 if (dump_sects
[i
] & DEBUG_DUMP
)
6593 display_debug_section (section
, file
);
6596 if (i
< num_dump_sects
)
6597 warn (_("Some sections were not dumped because they do not exist!\n"));
6603 process_mips_fpe_exception (mask
)
6609 if (mask
& OEX_FPU_INEX
)
6610 fputs ("INEX", stdout
), first
= 0;
6611 if (mask
& OEX_FPU_UFLO
)
6612 printf ("%sUFLO", first
? "" : "|"), first
= 0;
6613 if (mask
& OEX_FPU_OFLO
)
6614 printf ("%sOFLO", first
? "" : "|"), first
= 0;
6615 if (mask
& OEX_FPU_DIV0
)
6616 printf ("%sDIV0", first
? "" : "|"), first
= 0;
6617 if (mask
& OEX_FPU_INVAL
)
6618 printf ("%sINVAL", first
? "" : "|");
6621 fputs ("0", stdout
);
6625 process_mips_specific (file
)
6628 Elf_Internal_Dyn
* entry
;
6629 size_t liblist_offset
= 0;
6630 size_t liblistno
= 0;
6631 size_t conflictsno
= 0;
6632 size_t options_offset
= 0;
6633 size_t conflicts_offset
= 0;
6635 /* We have a lot of special sections. Thanks SGI! */
6636 if (dynamic_segment
== NULL
)
6637 /* No information available. */
6640 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
6641 switch (entry
->d_tag
)
6643 case DT_MIPS_LIBLIST
:
6644 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
6646 case DT_MIPS_LIBLISTNO
:
6647 liblistno
= entry
->d_un
.d_val
;
6649 case DT_MIPS_OPTIONS
:
6650 options_offset
= entry
->d_un
.d_val
- loadaddr
;
6652 case DT_MIPS_CONFLICT
:
6653 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
6655 case DT_MIPS_CONFLICTNO
:
6656 conflictsno
= entry
->d_un
.d_val
;
6662 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
6664 Elf32_External_Lib
* elib
;
6667 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
6668 elib
, Elf32_External_Lib
*, "liblist");
6670 printf ("\nSection '.liblist' contains %lu entries:\n",
6671 (unsigned long) liblistno
);
6672 fputs (" Library Time Stamp Checksum Version Flags\n",
6675 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
6682 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
6683 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
6684 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
6685 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
6686 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
6688 tmp
= gmtime (&time
);
6689 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
6690 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6691 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6693 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
6694 dynamic_strings
+ liblist
.l_name
, timebuf
,
6695 liblist
.l_checksum
, liblist
.l_version
);
6697 if (liblist
.l_flags
== 0)
6708 { " EXACT_MATCH", LL_EXACT_MATCH
},
6709 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
6710 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
6711 { " EXPORTS", LL_EXPORTS
},
6712 { " DELAY_LOAD", LL_DELAY_LOAD
},
6713 { " DELTA", LL_DELTA
}
6715 int flags
= liblist
.l_flags
;
6719 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
6721 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
6723 fputs (l_flags_vals
[fcnt
].name
, stdout
);
6724 flags
^= l_flags_vals
[fcnt
].bit
;
6727 printf (" %#x", (unsigned int) flags
);
6736 if (options_offset
!= 0)
6738 Elf_External_Options
* eopt
;
6739 Elf_Internal_Shdr
* sect
= section_headers
;
6740 Elf_Internal_Options
* iopt
;
6741 Elf_Internal_Options
* option
;
6745 /* Find the section header so that we get the size. */
6746 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
6749 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
6750 Elf_External_Options
*, "options");
6752 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
6756 error (_("Out of memory"));
6763 while (offset
< sect
->sh_size
)
6765 Elf_External_Options
* eoption
;
6767 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
6769 option
->kind
= BYTE_GET (eoption
->kind
);
6770 option
->size
= BYTE_GET (eoption
->size
);
6771 option
->section
= BYTE_GET (eoption
->section
);
6772 option
->info
= BYTE_GET (eoption
->info
);
6774 offset
+= option
->size
;
6780 printf (_("\nSection '%s' contains %d entries:\n"),
6781 string_table
+ sect
->sh_name
, cnt
);
6789 switch (option
->kind
)
6792 /* This shouldn't happen. */
6793 printf (" NULL %d %lx", option
->section
, option
->info
);
6796 printf (" REGINFO ");
6797 if (elf_header
.e_machine
== EM_MIPS
)
6800 Elf32_External_RegInfo
*ereg
;
6801 Elf32_RegInfo reginfo
;
6803 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
6804 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6805 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6806 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6807 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6808 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6809 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
6811 printf ("GPR %08lx GP 0x%lx\n",
6813 (unsigned long) reginfo
.ri_gp_value
);
6814 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6815 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6816 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6821 Elf64_External_RegInfo
* ereg
;
6822 Elf64_Internal_RegInfo reginfo
;
6824 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
6825 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6826 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6827 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6828 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6829 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6830 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
6832 printf ("GPR %08lx GP 0x",
6833 reginfo
.ri_gprmask
);
6834 printf_vma (reginfo
.ri_gp_value
);
6837 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6838 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6839 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6843 case ODK_EXCEPTIONS
:
6844 fputs (" EXCEPTIONS fpe_min(", stdout
);
6845 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
6846 fputs (") fpe_max(", stdout
);
6847 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
6848 fputs (")", stdout
);
6850 if (option
->info
& OEX_PAGE0
)
6851 fputs (" PAGE0", stdout
);
6852 if (option
->info
& OEX_SMM
)
6853 fputs (" SMM", stdout
);
6854 if (option
->info
& OEX_FPDBUG
)
6855 fputs (" FPDBUG", stdout
);
6856 if (option
->info
& OEX_DISMISS
)
6857 fputs (" DISMISS", stdout
);
6860 fputs (" PAD ", stdout
);
6861 if (option
->info
& OPAD_PREFIX
)
6862 fputs (" PREFIX", stdout
);
6863 if (option
->info
& OPAD_POSTFIX
)
6864 fputs (" POSTFIX", stdout
);
6865 if (option
->info
& OPAD_SYMBOL
)
6866 fputs (" SYMBOL", stdout
);
6869 fputs (" HWPATCH ", stdout
);
6870 if (option
->info
& OHW_R4KEOP
)
6871 fputs (" R4KEOP", stdout
);
6872 if (option
->info
& OHW_R8KPFETCH
)
6873 fputs (" R8KPFETCH", stdout
);
6874 if (option
->info
& OHW_R5KEOP
)
6875 fputs (" R5KEOP", stdout
);
6876 if (option
->info
& OHW_R5KCVTL
)
6877 fputs (" R5KCVTL", stdout
);
6880 fputs (" FILL ", stdout
);
6881 /* XXX Print content of info word? */
6884 fputs (" TAGS ", stdout
);
6885 /* XXX Print content of info word? */
6888 fputs (" HWAND ", stdout
);
6889 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6890 fputs (" R4KEOP_CHECKED", stdout
);
6891 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6892 fputs (" R4KEOP_CLEAN", stdout
);
6895 fputs (" HWOR ", stdout
);
6896 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6897 fputs (" R4KEOP_CHECKED", stdout
);
6898 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6899 fputs (" R4KEOP_CLEAN", stdout
);
6902 printf (" GP_GROUP %#06lx self-contained %#06lx",
6903 option
->info
& OGP_GROUP
,
6904 (option
->info
& OGP_SELF
) >> 16);
6907 printf (" IDENT %#06lx self-contained %#06lx",
6908 option
->info
& OGP_GROUP
,
6909 (option
->info
& OGP_SELF
) >> 16);
6912 /* This shouldn't happen. */
6913 printf (" %3d ??? %d %lx",
6914 option
->kind
, option
->section
, option
->info
);
6918 len
= sizeof (*eopt
);
6919 while (len
< option
->size
)
6920 if (((char *) option
)[len
] >= ' '
6921 && ((char *) option
)[len
] < 0x7f)
6922 printf ("%c", ((char *) option
)[len
++]);
6924 printf ("\\%03o", ((char *) option
)[len
++]);
6926 fputs ("\n", stdout
);
6933 if (conflicts_offset
!= 0 && conflictsno
!= 0)
6935 Elf32_External_Conflict
* econf32
;
6936 Elf64_External_Conflict
* econf64
;
6937 Elf32_Conflict
* iconf
;
6940 if (dynamic_symbols
== NULL
)
6942 error (_("conflict list with without table"));
6946 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
6949 error (_("Out of memory"));
6955 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
6956 econf32
, Elf32_External_Conflict
*, "conflict");
6958 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6959 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
6963 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
6964 econf64
, Elf64_External_Conflict
*, "conflict");
6966 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6967 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
6970 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
6971 puts (_(" Num: Index Value Name"));
6973 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6975 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
6977 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
6978 print_vma (psym
->st_value
, FULL_HEX
);
6979 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
6989 get_note_type (e_type
)
6992 static char buff
[64];
6996 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
6997 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
6998 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
6999 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
7000 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
7001 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
7002 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
7003 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
7004 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
7005 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7006 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7008 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
7013 /* Note that by the ELF standard, the name field is already null byte
7014 terminated, and namesz includes the terminating null byte.
7015 I.E. the value of namesz for the name "FSF" is 4.
7017 If the value of namesz is zero, there is no name present. */
7019 process_note (pnote
)
7020 Elf32_Internal_Note
* pnote
;
7022 printf (" %s\t\t0x%08lx\t%s\n",
7023 pnote
->namesz
? pnote
->namedata
: "(NONE)",
7024 pnote
->descsz
, get_note_type (pnote
->type
));
7030 process_corefile_note_segment (file
, offset
, length
)
7035 Elf_External_Note
* pnotes
;
7036 Elf_External_Note
* external
;
7042 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
7046 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7047 (unsigned long) offset
, (unsigned long) length
);
7048 printf (_(" Owner\t\tData size\tDescription\n"));
7050 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
7052 Elf32_Internal_Note inote
;
7055 inote
.type
= BYTE_GET (external
->type
);
7056 inote
.namesz
= BYTE_GET (external
->namesz
);
7057 inote
.namedata
= external
->name
;
7058 inote
.descsz
= BYTE_GET (external
->descsz
);
7059 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
7060 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
7062 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
7064 /* Verify that name is null terminated. It appears that at least
7065 one version of Linux (RedHat 6.0) generates corefiles that don't
7066 comply with the ELF spec by failing to include the null byte in
7068 if (inote
.namedata
[inote
.namesz
] != '\0')
7070 temp
= malloc (inote
.namesz
+ 1);
7074 error (_("Out of memory\n"));
7079 strncpy (temp
, inote
.namedata
, inote
.namesz
);
7080 temp
[inote
.namesz
] = 0;
7082 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7083 inote
.namedata
= temp
;
7086 res
&= process_note (& inote
);
7101 process_corefile_note_segments (file
)
7104 Elf_Internal_Phdr
* program_headers
;
7105 Elf_Internal_Phdr
* segment
;
7109 program_headers
= (Elf_Internal_Phdr
*) malloc
7110 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
7112 if (program_headers
== NULL
)
7114 error (_("Out of memory\n"));
7119 i
= get_32bit_program_headers (file
, program_headers
);
7121 i
= get_64bit_program_headers (file
, program_headers
);
7125 free (program_headers
);
7129 for (i
= 0, segment
= program_headers
;
7130 i
< elf_header
.e_phnum
;
7133 if (segment
->p_type
== PT_NOTE
)
7134 res
&= process_corefile_note_segment (file
,
7135 (bfd_vma
) segment
->p_offset
,
7136 (bfd_vma
) segment
->p_filesz
);
7139 free (program_headers
);
7145 process_corefile_contents (file
)
7148 /* If we have not been asked to display the notes then do nothing. */
7152 /* If file is not a core file then exit. */
7153 if (elf_header
.e_type
!= ET_CORE
)
7156 /* No program headers means no NOTE segment. */
7157 if (elf_header
.e_phnum
== 0)
7159 printf (_("No note segments present in the core file.\n"));
7163 return process_corefile_note_segments (file
);
7167 process_arch_specific (file
)
7173 switch (elf_header
.e_machine
)
7176 case EM_MIPS_RS4_BE
:
7177 return process_mips_specific (file
);
7186 get_file_header (file
)
7189 /* Read in the identity array. */
7190 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
7193 /* Determine how to read the rest of the header. */
7194 switch (elf_header
.e_ident
[EI_DATA
])
7196 default: /* fall through */
7197 case ELFDATANONE
: /* fall through */
7198 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
7199 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
7202 /* For now we only support 32 bit and 64 bit ELF files. */
7203 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
7205 /* Read in the rest of the header. */
7208 Elf32_External_Ehdr ehdr32
;
7210 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
7213 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
7214 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
7215 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
7216 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
7217 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
7218 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
7219 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
7220 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
7221 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
7222 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
7223 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
7224 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
7225 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
7229 Elf64_External_Ehdr ehdr64
;
7231 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7232 we will not be able to cope with the 64bit data found in
7233 64 ELF files. Detect this now and abort before we start
7234 overwritting things. */
7235 if (sizeof (bfd_vma
) < 8)
7237 error (_("This instance of readelf has been built without support for a\n"));
7238 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7242 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
7245 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
7246 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
7247 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
7248 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
7249 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
7250 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
7251 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
7252 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
7253 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
7254 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
7255 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
7256 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
7257 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
7264 process_file (file_name
)
7268 struct stat statbuf
;
7271 if (stat (file_name
, & statbuf
) < 0)
7273 error (_("Cannot stat input file %s.\n"), file_name
);
7277 file
= fopen (file_name
, "rb");
7280 error (_("Input file %s not found.\n"), file_name
);
7284 if (! get_file_header (file
))
7286 error (_("%s: Failed to read file header\n"), file_name
);
7291 /* Initialise per file variables. */
7292 for (i
= NUM_ELEM (version_info
); i
--;)
7293 version_info
[i
] = 0;
7295 for (i
= NUM_ELEM (dynamic_info
); i
--;)
7296 dynamic_info
[i
] = 0;
7298 /* Process the file. */
7300 printf (_("\nFile: %s\n"), file_name
);
7302 if (! process_file_header ())
7308 process_section_headers (file
);
7310 process_program_headers (file
);
7312 process_dynamic_segment (file
);
7314 process_relocs (file
);
7316 process_symbol_table (file
);
7318 process_syminfo (file
);
7320 process_version_sections (file
);
7322 process_section_contents (file
);
7324 process_corefile_contents (file
);
7326 process_arch_specific (file
);
7330 if (section_headers
)
7332 free (section_headers
);
7333 section_headers
= NULL
;
7338 free (string_table
);
7339 string_table
= NULL
;
7342 if (dynamic_strings
)
7344 free (dynamic_strings
);
7345 dynamic_strings
= NULL
;
7348 if (dynamic_symbols
)
7350 free (dynamic_symbols
);
7351 dynamic_symbols
= NULL
;
7352 num_dynamic_syms
= 0;
7355 if (dynamic_syminfo
)
7357 free (dynamic_syminfo
);
7358 dynamic_syminfo
= NULL
;
7362 #ifdef SUPPORT_DISASSEMBLY
7363 /* Needed by the i386 disassembler. For extra credit, someone could
7364 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7368 print_address (unsigned int addr
, FILE * outfile
)
7370 fprintf (outfile
,"0x%8.8x", addr
);
7373 /* Needed by the i386 disassembler. */
7375 db_task_printsym (unsigned int addr
)
7377 print_address (addr
, stderr
);
7386 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7387 setlocale (LC_MESSAGES
, "");
7389 bindtextdomain (PACKAGE
, LOCALEDIR
);
7390 textdomain (PACKAGE
);
7392 parse_args (argc
, argv
);
7394 if (optind
< (argc
- 1))
7397 while (optind
< argc
)
7398 process_file (argv
[optind
++]);
7400 if (dump_sects
!= NULL
)