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";
1264 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1265 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1266 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1267 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1268 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1269 case EM_PRISM
: return "SiTera Prism";
1272 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1278 decode_ARM_machine_flags (e_flags
, buf
)
1285 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1286 e_flags
&= ~ EF_ARM_EABIMASK
;
1288 /* Handle "generic" ARM flags. */
1289 if (e_flags
& EF_ARM_RELEXEC
)
1291 strcat (buf
, ", relocatable executable");
1292 e_flags
&= ~ EF_ARM_RELEXEC
;
1295 if (e_flags
& EF_ARM_HASENTRY
)
1297 strcat (buf
, ", has entry point");
1298 e_flags
&= ~ EF_ARM_HASENTRY
;
1301 /* Now handle EABI specific flags. */
1305 strcat (buf
, ", <unknown EABI>");
1310 case EF_ARM_EABI_VER1
:
1315 /* Process flags one bit at a time. */
1316 flag
= e_flags
& - e_flags
;
1321 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_INTERWORK. */
1322 strcat (buf
, ", sorted symbol tables");
1332 case EF_ARM_EABI_UNKNOWN
:
1337 /* Process flags one bit at a time. */
1338 flag
= e_flags
& - e_flags
;
1344 strcat (buf
, ", interworking enabled");
1348 strcat (buf
, ", uses APCS/26");
1352 strcat (buf
, ", uses APCS/float");
1356 strcat (buf
, ", position independent");
1360 strcat (buf
, ", 8 bit structure alignment");
1364 strcat (buf
, ", uses new ABI");
1368 strcat (buf
, ", uses old ABI");
1372 strcat (buf
, ", software FP");
1383 strcat (buf
,", <unknown>");
1387 get_machine_flags (e_flags
, e_machine
)
1391 static char buf
[1024];
1403 decode_ARM_machine_flags (e_flags
, buf
);
1407 if (e_flags
& EF_CPU32
)
1408 strcat (buf
, ", cpu32");
1412 if (e_flags
& EF_PPC_EMB
)
1413 strcat (buf
, ", emb");
1415 if (e_flags
& EF_PPC_RELOCATABLE
)
1416 strcat (buf
, ", relocatable");
1418 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1419 strcat (buf
, ", relocatable-lib");
1422 case EM_CYGNUS_V850
:
1423 switch (e_flags
& EF_V850_ARCH
)
1426 strcat (buf
, ", v850e");
1429 strcat (buf
, ", v850ea");
1432 strcat (buf
, ", v850");
1435 strcat (buf
, ", unknown v850 architecture variant");
1440 case EM_CYGNUS_M32R
:
1441 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1442 strcat (buf
, ", m32r");
1447 case EM_MIPS_RS4_BE
:
1448 if (e_flags
& EF_MIPS_NOREORDER
)
1449 strcat (buf
, ", noreorder");
1451 if (e_flags
& EF_MIPS_PIC
)
1452 strcat (buf
, ", pic");
1454 if (e_flags
& EF_MIPS_CPIC
)
1455 strcat (buf
, ", cpic");
1457 if (e_flags
& EF_MIPS_ABI2
)
1458 strcat (buf
, ", abi2");
1460 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1461 strcat (buf
, ", mips1");
1463 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1464 strcat (buf
, ", mips2");
1466 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1467 strcat (buf
, ", mips3");
1469 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1470 strcat (buf
, ", mips4");
1472 switch ((e_flags
& EF_MIPS_MACH
))
1474 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1475 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1476 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1477 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1478 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1479 case E_MIPS_MACH_MIPS32
: strcat (buf
, ", mips32"); break;
1484 if (e_flags
& EF_SPARC_32PLUS
)
1485 strcat (buf
, ", v8+");
1487 if (e_flags
& EF_SPARC_SUN_US1
)
1488 strcat (buf
, ", ultrasparcI");
1490 if (e_flags
& EF_SPARC_SUN_US3
)
1491 strcat (buf
, ", ultrasparcIII");
1493 if (e_flags
& EF_SPARC_HAL_R1
)
1494 strcat (buf
, ", halr1");
1496 if (e_flags
& EF_SPARC_LEDATA
)
1497 strcat (buf
, ", ledata");
1499 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1500 strcat (buf
, ", tso");
1502 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1503 strcat (buf
, ", pso");
1505 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1506 strcat (buf
, ", rmo");
1510 switch (e_flags
& EF_PARISC_ARCH
)
1512 case EFA_PARISC_1_0
:
1513 strcpy (buf
, ", PA-RISC 1.0");
1515 case EFA_PARISC_1_1
:
1516 strcpy (buf
, ", PA-RISC 1.1");
1518 case EFA_PARISC_2_0
:
1519 strcpy (buf
, ", PA-RISC 2.0");
1524 if (e_flags
& EF_PARISC_TRAPNIL
)
1525 strcat (buf
, ", trapnil");
1526 if (e_flags
& EF_PARISC_EXT
)
1527 strcat (buf
, ", ext");
1528 if (e_flags
& EF_PARISC_LSB
)
1529 strcat (buf
, ", lsb");
1530 if (e_flags
& EF_PARISC_WIDE
)
1531 strcat (buf
, ", wide");
1532 if (e_flags
& EF_PARISC_NO_KABP
)
1533 strcat (buf
, ", no kabp");
1534 if (e_flags
& EF_PARISC_LAZYSWAP
)
1535 strcat (buf
, ", lazyswap");
1539 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1540 strcat (buf
, ", new calling convention");
1542 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1543 strcat (buf
, ", gnu calling convention");
1552 get_mips_segment_type (type
)
1557 case PT_MIPS_REGINFO
:
1559 case PT_MIPS_RTPROC
:
1561 case PT_MIPS_OPTIONS
:
1571 get_parisc_segment_type (type
)
1576 case PT_HP_TLS
: return "HP_TLS";
1577 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1578 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1579 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1580 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1581 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1582 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1583 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1584 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1585 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1586 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1587 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1588 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1589 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1598 get_segment_type (p_type
)
1599 unsigned long p_type
;
1601 static char buff
[32];
1605 case PT_NULL
: return "NULL";
1606 case PT_LOAD
: return "LOAD";
1607 case PT_DYNAMIC
: return "DYNAMIC";
1608 case PT_INTERP
: return "INTERP";
1609 case PT_NOTE
: return "NOTE";
1610 case PT_SHLIB
: return "SHLIB";
1611 case PT_PHDR
: return "PHDR";
1614 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1616 const char * result
;
1618 switch (elf_header
.e_machine
)
1621 case EM_MIPS_RS4_BE
:
1622 result
= get_mips_segment_type (p_type
);
1625 result
= get_parisc_segment_type (p_type
);
1635 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1637 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1639 const char * result
;
1641 switch (elf_header
.e_machine
)
1644 result
= get_parisc_segment_type (p_type
);
1654 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1657 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1664 get_mips_section_type_name (sh_type
)
1665 unsigned int sh_type
;
1669 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1670 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1671 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1672 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1673 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1674 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1675 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1676 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1677 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1678 case SHT_MIPS_RELD
: return "MIPS_RELD";
1679 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1680 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1681 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1682 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1683 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1684 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1685 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1686 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1687 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1688 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1689 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1690 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1691 case SHT_MIPS_LINE
: return "MIPS_LINE";
1692 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1693 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1694 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1695 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1696 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1697 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1698 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1699 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1700 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1701 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1702 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1703 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1704 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1705 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1706 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1707 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1715 get_parisc_section_type_name (sh_type
)
1716 unsigned int sh_type
;
1720 case SHT_PARISC_EXT
: return "PARISC_EXT";
1721 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1722 case SHT_PARISC_DOC
: return "PARISC_DOC";
1730 get_section_type_name (sh_type
)
1731 unsigned int sh_type
;
1733 static char buff
[32];
1737 case SHT_NULL
: return "NULL";
1738 case SHT_PROGBITS
: return "PROGBITS";
1739 case SHT_SYMTAB
: return "SYMTAB";
1740 case SHT_STRTAB
: return "STRTAB";
1741 case SHT_RELA
: return "RELA";
1742 case SHT_HASH
: return "HASH";
1743 case SHT_DYNAMIC
: return "DYNAMIC";
1744 case SHT_NOTE
: return "NOTE";
1745 case SHT_NOBITS
: return "NOBITS";
1746 case SHT_REL
: return "REL";
1747 case SHT_SHLIB
: return "SHLIB";
1748 case SHT_DYNSYM
: return "DYNSYM";
1749 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1750 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1751 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1752 case SHT_GROUP
: return "GROUP";
1753 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
1754 case SHT_GNU_verdef
: return "VERDEF";
1755 case SHT_GNU_verneed
: return "VERNEED";
1756 case SHT_GNU_versym
: return "VERSYM";
1757 case 0x6ffffff0: return "VERSYM";
1758 case 0x6ffffffc: return "VERDEF";
1759 case 0x7ffffffd: return "AUXILIARY";
1760 case 0x7fffffff: return "FILTER";
1763 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1765 const char * result
;
1767 switch (elf_header
.e_machine
)
1770 case EM_MIPS_RS4_BE
:
1771 result
= get_mips_section_type_name (sh_type
);
1774 result
= get_parisc_section_type_name (sh_type
);
1784 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1786 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1787 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1788 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1789 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1791 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1797 struct option options
[] =
1799 {"all", no_argument
, 0, 'a'},
1800 {"file-header", no_argument
, 0, 'h'},
1801 {"program-headers", no_argument
, 0, 'l'},
1802 {"headers", no_argument
, 0, 'e'},
1803 {"histogram", no_argument
, 0, 'I'},
1804 {"segments", no_argument
, 0, 'l'},
1805 {"sections", no_argument
, 0, 'S'},
1806 {"section-headers", no_argument
, 0, 'S'},
1807 {"symbols", no_argument
, 0, 's'},
1808 {"syms", no_argument
, 0, 's'},
1809 {"relocs", no_argument
, 0, 'r'},
1810 {"notes", no_argument
, 0, 'n'},
1811 {"dynamic", no_argument
, 0, 'd'},
1812 {"arch-specific", no_argument
, 0, 'A'},
1813 {"version-info", no_argument
, 0, 'V'},
1814 {"use-dynamic", no_argument
, 0, 'D'},
1815 {"hex-dump", required_argument
, 0, 'x'},
1816 {"debug-dump", optional_argument
, 0, 'w'},
1817 #ifdef SUPPORT_DISASSEMBLY
1818 {"instruction-dump", required_argument
, 0, 'i'},
1821 {"version", no_argument
, 0, 'v'},
1822 {"help", no_argument
, 0, 'H'},
1823 {0, no_argument
, 0, 0}
1829 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1830 fprintf (stdout
, _(" Options are:\n"));
1831 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1832 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1833 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1834 fprintf (stdout
, _(" Display the program headers\n"));
1835 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1836 fprintf (stdout
, _(" Display the sections' header\n"));
1837 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1838 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1839 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1840 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1841 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1842 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1843 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1844 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1845 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1846 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1847 fprintf (stdout
, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1848 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1849 #ifdef SUPPORT_DISASSEMBLY
1850 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1851 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1853 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1854 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1855 fprintf (stdout
, _(" -H or --help Display this information\n"));
1856 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
1862 request_dump (section
, type
)
1863 unsigned int section
;
1866 if (section
>= num_dump_sects
)
1868 char * new_dump_sects
;
1870 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1872 if (new_dump_sects
== NULL
)
1873 error (_("Out of memory allocating dump request table."));
1876 /* Copy current flag settings. */
1877 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1881 dump_sects
= new_dump_sects
;
1882 num_dump_sects
= section
+ 1;
1887 dump_sects
[section
] |= type
;
1893 parse_args (argc
, argv
)
1902 while ((c
= getopt_long
1903 (argc
, argv
, "ersahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
1938 do_using_dynamic
++;
1966 section
= strtoul (optarg
, & cp
, 0);
1967 if (! * cp
&& section
>= 0)
1969 request_dump (section
, HEX_DUMP
);
1989 do_debug_abbrevs
= 1;
1999 do_debug_pubnames
= 1;
2004 do_debug_aranges
= 1;
2008 warn (_("Unrecognised debug option '%s'\n"), optarg
);
2013 #ifdef SUPPORT_DISASSEMBLY
2016 section
= strtoul (optarg
, & cp
, 0);
2017 if (! * cp
&& section
>= 0)
2019 request_dump (section
, DISASS_DUMP
);
2025 print_version (program_name
);
2032 /* xgettext:c-format */
2033 error (_("Invalid option '-%c'\n"), c
);
2040 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
2041 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2042 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2046 warn (_("Nothing to do.\n"));
2052 get_elf_class (elf_class
)
2053 unsigned char elf_class
;
2055 static char buff
[32];
2059 case ELFCLASSNONE
: return _("none");
2060 case ELFCLASS32
: return _("ELF32");
2061 case ELFCLASS64
: return _("ELF64");
2063 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2069 get_data_encoding (encoding
)
2070 unsigned char encoding
;
2072 static char buff
[32];
2076 case ELFDATANONE
: return _("none");
2077 case ELFDATA2LSB
: return _("2's complement, little endian");
2078 case ELFDATA2MSB
: return _("2's complement, big endian");
2080 sprintf (buff
, _("<unknown: %x>"), encoding
);
2086 get_osabi_name (osabi
)
2087 unsigned char osabi
;
2089 static char buff
[32];
2093 case ELFOSABI_NONE
: return _("UNIX - System V");
2094 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
2095 case ELFOSABI_NETBSD
: return _("UNIX - NetBSD");
2096 case ELFOSABI_LINUX
: return _("UNIX - Linux");
2097 case ELFOSABI_HURD
: return _("GNU/Hurd");
2098 case ELFOSABI_SOLARIS
: return _("UNIX - Solaris");
2099 case ELFOSABI_AIX
: return _("UNIX - AIX");
2100 case ELFOSABI_IRIX
: return _("UNIX - IRIX");
2101 case ELFOSABI_FREEBSD
: return _("UNIX - FreeBSD");
2102 case ELFOSABI_TRU64
: return _("UNIX - TRU64");
2103 case ELFOSABI_MODESTO
: return _("Novell - Modesto");
2104 case ELFOSABI_OPENBSD
: return _("UNIX - OpenBSD");
2105 case ELFOSABI_STANDALONE
: return _("Standalone App");
2106 case ELFOSABI_ARM
: return _("ARM");
2108 sprintf (buff
, _("<unknown: %x>"), osabi
);
2113 /* Decode the data held in 'elf_header'. */
2115 process_file_header ()
2117 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2118 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2119 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2120 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2123 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2131 printf (_("ELF Header:\n"));
2132 printf (_(" Magic: "));
2133 for (i
= 0; i
< EI_NIDENT
; i
++)
2134 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2136 printf (_(" Class: %s\n"),
2137 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2138 printf (_(" Data: %s\n"),
2139 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2140 printf (_(" Version: %d %s\n"),
2141 elf_header
.e_ident
[EI_VERSION
],
2142 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2144 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2147 printf (_(" OS/ABI: %s\n"),
2148 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2149 printf (_(" ABI Version: %d\n"),
2150 elf_header
.e_ident
[EI_ABIVERSION
]);
2151 printf (_(" Type: %s\n"),
2152 get_file_type (elf_header
.e_type
));
2153 printf (_(" Machine: %s\n"),
2154 get_machine_name (elf_header
.e_machine
));
2155 printf (_(" Version: 0x%lx\n"),
2156 (unsigned long) elf_header
.e_version
);
2158 printf (_(" Entry point address: "));
2159 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2160 printf (_("\n Start of program headers: "));
2161 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2162 printf (_(" (bytes into file)\n Start of section headers: "));
2163 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2164 printf (_(" (bytes into file)\n"));
2166 printf (_(" Flags: 0x%lx%s\n"),
2167 (unsigned long) elf_header
.e_flags
,
2168 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2169 printf (_(" Size of this header: %ld (bytes)\n"),
2170 (long) elf_header
.e_ehsize
);
2171 printf (_(" Size of program headers: %ld (bytes)\n"),
2172 (long) elf_header
.e_phentsize
);
2173 printf (_(" Number of program headers: %ld\n"),
2174 (long) elf_header
.e_phnum
);
2175 printf (_(" Size of section headers: %ld (bytes)\n"),
2176 (long) elf_header
.e_shentsize
);
2177 printf (_(" Number of section headers: %ld\n"),
2178 (long) elf_header
.e_shnum
);
2179 printf (_(" Section header string table index: %ld\n"),
2180 (long) elf_header
.e_shstrndx
);
2188 get_32bit_program_headers (file
, program_headers
)
2190 Elf_Internal_Phdr
* program_headers
;
2192 Elf32_External_Phdr
* phdrs
;
2193 Elf32_External_Phdr
* external
;
2194 Elf32_Internal_Phdr
* internal
;
2197 GET_DATA_ALLOC (elf_header
.e_phoff
,
2198 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2199 phdrs
, Elf32_External_Phdr
*, "program headers");
2201 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2202 i
< elf_header
.e_phnum
;
2203 i
++, internal
++, external
++)
2205 internal
->p_type
= BYTE_GET (external
->p_type
);
2206 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2207 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2208 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2209 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2210 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2211 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2212 internal
->p_align
= BYTE_GET (external
->p_align
);
2221 get_64bit_program_headers (file
, program_headers
)
2223 Elf_Internal_Phdr
* program_headers
;
2225 Elf64_External_Phdr
* phdrs
;
2226 Elf64_External_Phdr
* external
;
2227 Elf64_Internal_Phdr
* internal
;
2230 GET_DATA_ALLOC (elf_header
.e_phoff
,
2231 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2232 phdrs
, Elf64_External_Phdr
*, "program headers");
2234 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2235 i
< elf_header
.e_phnum
;
2236 i
++, internal
++, external
++)
2238 internal
->p_type
= BYTE_GET (external
->p_type
);
2239 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2240 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2241 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2242 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2243 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2244 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2245 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2254 process_program_headers (file
)
2257 Elf_Internal_Phdr
* program_headers
;
2258 Elf_Internal_Phdr
* segment
;
2261 if (elf_header
.e_phnum
== 0)
2264 printf (_("\nThere are no program headers in this file.\n"));
2268 if (do_segments
&& !do_header
)
2270 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2271 printf (_("Entry point "));
2272 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2273 printf (_("\nThere are %d program headers, starting at offset "),
2274 elf_header
.e_phnum
);
2275 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2279 program_headers
= (Elf_Internal_Phdr
*) malloc
2280 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2282 if (program_headers
== NULL
)
2284 error (_("Out of memory\n"));
2289 i
= get_32bit_program_headers (file
, program_headers
);
2291 i
= get_64bit_program_headers (file
, program_headers
);
2295 free (program_headers
);
2302 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2306 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2310 (_(" Type Offset VirtAddr PhysAddr\n"));
2312 (_(" FileSiz MemSiz Flags Align\n"));
2320 for (i
= 0, segment
= program_headers
;
2321 i
< elf_header
.e_phnum
;
2326 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2330 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2331 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2332 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2333 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2334 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2336 (segment
->p_flags
& PF_R
? 'R' : ' '),
2337 (segment
->p_flags
& PF_W
? 'W' : ' '),
2338 (segment
->p_flags
& PF_X
? 'E' : ' '));
2339 printf ("%#lx", (unsigned long) segment
->p_align
);
2343 print_vma (segment
->p_offset
, FULL_HEX
);
2345 print_vma (segment
->p_vaddr
, FULL_HEX
);
2347 print_vma (segment
->p_paddr
, FULL_HEX
);
2349 print_vma (segment
->p_filesz
, FULL_HEX
);
2351 print_vma (segment
->p_memsz
, FULL_HEX
);
2353 (segment
->p_flags
& PF_R
? 'R' : ' '),
2354 (segment
->p_flags
& PF_W
? 'W' : ' '),
2355 (segment
->p_flags
& PF_X
? 'E' : ' '));
2356 print_vma (segment
->p_align
, HEX
);
2360 switch (segment
->p_type
)
2364 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2365 - (segment
->p_offset
& 0xfffff000);
2370 error (_("more than one dynamic segment\n"));
2372 dynamic_addr
= segment
->p_offset
;
2373 dynamic_size
= segment
->p_filesz
;
2377 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2378 error (_("Unable to find program interpreter name\n"));
2381 program_interpreter
[0] = 0;
2382 fscanf (file
, "%63s", program_interpreter
);
2385 printf (_("\n [Requesting program interpreter: %s]"),
2386 program_interpreter
);
2392 putc ('\n', stdout
);
2401 if (do_segments
&& section_headers
!= NULL
)
2403 printf (_("\n Section to Segment mapping:\n"));
2404 printf (_(" Segment Sections...\n"));
2406 assert (string_table
!= NULL
);
2408 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2411 Elf_Internal_Shdr
* section
;
2413 segment
= program_headers
+ i
;
2414 section
= section_headers
;
2416 printf (" %2.2d ", i
);
2418 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2420 if (section
->sh_size
> 0
2421 /* Compare allocated sections by VMA, unallocated
2422 sections by file offset. */
2423 && (section
->sh_flags
& SHF_ALLOC
2424 ? (section
->sh_addr
>= segment
->p_vaddr
2425 && section
->sh_addr
+ section
->sh_size
2426 <= segment
->p_vaddr
+ segment
->p_memsz
)
2427 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2428 && (section
->sh_offset
+ section
->sh_size
2429 <= segment
->p_offset
+ segment
->p_filesz
))))
2430 printf ("%s ", SECTION_NAME (section
));
2437 free (program_headers
);
2444 get_32bit_section_headers (file
)
2447 Elf32_External_Shdr
* shdrs
;
2448 Elf32_Internal_Shdr
* internal
;
2451 GET_DATA_ALLOC (elf_header
.e_shoff
,
2452 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2453 shdrs
, Elf32_External_Shdr
*, "section headers");
2455 section_headers
= (Elf_Internal_Shdr
*) malloc
2456 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2458 if (section_headers
== NULL
)
2460 error (_("Out of memory\n"));
2464 for (i
= 0, internal
= section_headers
;
2465 i
< elf_header
.e_shnum
;
2468 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2469 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2470 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2471 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2472 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2473 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2474 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2475 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2476 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2477 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2486 get_64bit_section_headers (file
)
2489 Elf64_External_Shdr
* shdrs
;
2490 Elf64_Internal_Shdr
* internal
;
2493 GET_DATA_ALLOC (elf_header
.e_shoff
,
2494 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2495 shdrs
, Elf64_External_Shdr
*, "section headers");
2497 section_headers
= (Elf_Internal_Shdr
*) malloc
2498 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2500 if (section_headers
== NULL
)
2502 error (_("Out of memory\n"));
2506 for (i
= 0, internal
= section_headers
;
2507 i
< elf_header
.e_shnum
;
2510 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2511 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2512 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2513 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2514 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2515 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2516 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2517 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2518 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2519 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2527 static Elf_Internal_Sym
*
2528 get_32bit_elf_symbols (file
, offset
, number
)
2530 unsigned long offset
;
2531 unsigned long number
;
2533 Elf32_External_Sym
* esyms
;
2534 Elf_Internal_Sym
* isyms
;
2535 Elf_Internal_Sym
* psym
;
2538 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2539 esyms
, Elf32_External_Sym
*, "symbols");
2541 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2545 error (_("Out of memory\n"));
2551 for (j
= 0, psym
= isyms
;
2555 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2556 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2557 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2558 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2559 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2560 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2568 static Elf_Internal_Sym
*
2569 get_64bit_elf_symbols (file
, offset
, number
)
2571 unsigned long offset
;
2572 unsigned long number
;
2574 Elf64_External_Sym
* esyms
;
2575 Elf_Internal_Sym
* isyms
;
2576 Elf_Internal_Sym
* psym
;
2579 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2580 esyms
, Elf64_External_Sym
*, "symbols");
2582 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2586 error (_("Out of memory\n"));
2592 for (j
= 0, psym
= isyms
;
2596 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2597 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2598 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2599 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2600 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2601 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2610 get_elf_section_flags (sh_flags
)
2613 static char buff
[32];
2621 flag
= sh_flags
& - sh_flags
;
2626 case SHF_WRITE
: strcat (buff
, "W"); break;
2627 case SHF_ALLOC
: strcat (buff
, "A"); break;
2628 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2629 case SHF_MERGE
: strcat (buff
, "M"); break;
2630 case SHF_STRINGS
: strcat (buff
, "S"); break;
2631 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2632 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2633 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2634 case SHF_GROUP
: strcat (buff
, "G"); break;
2637 if (flag
& SHF_MASKOS
)
2640 sh_flags
&= ~ SHF_MASKOS
;
2642 else if (flag
& SHF_MASKPROC
)
2645 sh_flags
&= ~ SHF_MASKPROC
;
2657 process_section_headers (file
)
2660 Elf_Internal_Shdr
* section
;
2663 section_headers
= NULL
;
2665 if (elf_header
.e_shnum
== 0)
2668 printf (_("\nThere are no sections in this file.\n"));
2673 if (do_sections
&& !do_header
)
2674 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2675 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2679 if (! get_32bit_section_headers (file
))
2682 else if (! get_64bit_section_headers (file
))
2685 /* Read in the string table, so that we have names to display. */
2686 section
= section_headers
+ elf_header
.e_shstrndx
;
2688 if (section
->sh_size
!= 0)
2690 unsigned long string_table_offset
;
2692 string_table_offset
= section
->sh_offset
;
2694 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2695 string_table
, char *, "string table");
2698 /* Scan the sections for the dynamic symbol table
2699 and dynamic string table and debug sections. */
2700 dynamic_symbols
= NULL
;
2701 dynamic_strings
= NULL
;
2702 dynamic_syminfo
= NULL
;
2704 for (i
= 0, section
= section_headers
;
2705 i
< elf_header
.e_shnum
;
2708 char * name
= SECTION_NAME (section
);
2710 if (section
->sh_type
== SHT_DYNSYM
)
2712 if (dynamic_symbols
!= NULL
)
2714 error (_("File contains multiple dynamic symbol tables\n"));
2718 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2720 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2722 else if (section
->sh_type
== SHT_STRTAB
2723 && strcmp (name
, ".dynstr") == 0)
2725 if (dynamic_strings
!= NULL
)
2727 error (_("File contains multiple dynamic string tables\n"));
2731 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2732 dynamic_strings
, char *, "dynamic strings");
2734 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2735 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
)
2736 && strncmp (name
, ".debug_", 7) == 0)
2741 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2742 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2743 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2744 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2745 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2747 request_dump (i
, DEBUG_DUMP
);
2754 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2758 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2761 printf (_(" [Nr] Name Type Address Offset\n"));
2762 printf (_(" Size EntSize Flags Link Info Align\n"));
2765 for (i
= 0, section
= section_headers
;
2766 i
< elf_header
.e_shnum
;
2769 printf (" [%2d] %-17.17s %-15.15s ",
2771 SECTION_NAME (section
),
2772 get_section_type_name (section
->sh_type
));
2776 print_vma (section
->sh_addr
, LONG_HEX
);
2778 printf ( " %6.6lx %6.6lx %2.2lx",
2779 (unsigned long) section
->sh_offset
,
2780 (unsigned long) section
->sh_size
,
2781 (unsigned long) section
->sh_entsize
);
2783 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2785 printf ("%2ld %3lx %2ld\n",
2786 (unsigned long) section
->sh_link
,
2787 (unsigned long) section
->sh_info
,
2788 (unsigned long) section
->sh_addralign
);
2793 print_vma (section
->sh_addr
, LONG_HEX
);
2794 printf (" %8.8lx", section
->sh_offset
);
2796 print_vma (section
->sh_size
, LONG_HEX
);
2798 print_vma (section
->sh_entsize
, LONG_HEX
);
2800 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2802 printf (" %2ld %3lx %ld\n",
2803 (unsigned long) section
->sh_link
,
2804 (unsigned long) section
->sh_info
,
2805 (unsigned long) section
->sh_addralign
);
2809 printf (_("Key to Flags:\n"));
2810 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2811 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
2812 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
2817 /* Process the reloc section. */
2819 process_relocs (file
)
2822 unsigned long rel_size
;
2823 unsigned long rel_offset
;
2829 if (do_using_dynamic
)
2831 int is_rela
= FALSE
;
2836 if (dynamic_info
[DT_REL
])
2838 rel_offset
= dynamic_info
[DT_REL
];
2839 rel_size
= dynamic_info
[DT_RELSZ
];
2842 else if (dynamic_info
[DT_RELA
])
2844 rel_offset
= dynamic_info
[DT_RELA
];
2845 rel_size
= dynamic_info
[DT_RELASZ
];
2848 else if (dynamic_info
[DT_JMPREL
])
2850 rel_offset
= dynamic_info
[DT_JMPREL
];
2851 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2853 switch (dynamic_info
[DT_PLTREL
])
2870 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2871 rel_offset
, rel_size
);
2873 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2874 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
2877 printf (_("\nThere are no dynamic relocations in this file.\n"));
2881 Elf32_Internal_Shdr
* section
;
2885 for (i
= 0, section
= section_headers
;
2886 i
< elf_header
.e_shnum
;
2889 if ( section
->sh_type
!= SHT_RELA
2890 && section
->sh_type
!= SHT_REL
)
2893 rel_offset
= section
->sh_offset
;
2894 rel_size
= section
->sh_size
;
2898 Elf32_Internal_Shdr
* strsec
;
2899 Elf32_Internal_Shdr
* symsec
;
2900 Elf_Internal_Sym
* symtab
;
2903 unsigned long nsyms
;
2905 printf (_("\nRelocation section "));
2907 if (string_table
== NULL
)
2908 printf ("%d", section
->sh_name
);
2910 printf ("'%s'", SECTION_NAME (section
));
2912 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2913 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
2915 symsec
= section_headers
+ section
->sh_link
;
2917 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
2918 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
2923 strsec
= section_headers
+ symsec
->sh_link
;
2925 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2926 char *, "string table");
2928 is_rela
= section
->sh_type
== SHT_RELA
;
2930 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
2940 printf (_("\nThere are no relocations in this file.\n"));
2948 dynamic_segment_mips_val (entry
)
2949 Elf_Internal_Dyn
* entry
;
2951 switch (entry
->d_tag
)
2954 if (entry
->d_un
.d_val
== 0)
2958 static const char * opts
[] =
2960 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2961 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2962 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2963 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2968 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
2969 if (entry
->d_un
.d_val
& (1 << cnt
))
2971 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2978 case DT_MIPS_IVERSION
:
2979 if (dynamic_strings
!= NULL
)
2980 printf ("Interface Version: %s\n",
2981 dynamic_strings
+ entry
->d_un
.d_val
);
2983 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2986 case DT_MIPS_TIME_STAMP
:
2991 time_t time
= entry
->d_un
.d_val
;
2992 tmp
= gmtime (&time
);
2993 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
2994 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
2995 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
2996 printf ("Time Stamp: %s\n", timebuf
);
3000 case DT_MIPS_RLD_VERSION
:
3001 case DT_MIPS_LOCAL_GOTNO
:
3002 case DT_MIPS_CONFLICTNO
:
3003 case DT_MIPS_LIBLISTNO
:
3004 case DT_MIPS_SYMTABNO
:
3005 case DT_MIPS_UNREFEXTNO
:
3006 case DT_MIPS_HIPAGENO
:
3007 case DT_MIPS_DELTA_CLASS_NO
:
3008 case DT_MIPS_DELTA_INSTANCE_NO
:
3009 case DT_MIPS_DELTA_RELOC_NO
:
3010 case DT_MIPS_DELTA_SYM_NO
:
3011 case DT_MIPS_DELTA_CLASSSYM_NO
:
3012 case DT_MIPS_COMPACT_SIZE
:
3013 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
3017 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
3023 dynamic_segment_parisc_val (entry
)
3024 Elf_Internal_Dyn
* entry
;
3026 switch (entry
->d_tag
)
3028 case DT_HP_DLD_FLAGS
:
3037 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
3038 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
3039 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
3040 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
3041 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
3042 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
3043 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
3044 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
3045 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
3046 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
3047 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
3051 bfd_vma val
= entry
->d_un
.d_val
;
3053 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
3054 if (val
& flags
[cnt
].bit
)
3058 fputs (flags
[cnt
].str
, stdout
);
3060 val
^= flags
[cnt
].bit
;
3063 if (val
!= 0 || first
)
3067 print_vma (val
, HEX
);
3073 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
3079 get_32bit_dynamic_segment (file
)
3082 Elf32_External_Dyn
* edyn
;
3083 Elf_Internal_Dyn
* entry
;
3086 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3087 edyn
, Elf32_External_Dyn
*, "dynamic segment");
3089 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3090 how large this .dynamic is now. We can do this even before the byte
3091 swapping since the DT_NULL tag is recognizable. */
3093 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3096 dynamic_segment
= (Elf_Internal_Dyn
*)
3097 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3099 if (dynamic_segment
== NULL
)
3101 error (_("Out of memory\n"));
3106 for (i
= 0, entry
= dynamic_segment
;
3110 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
3111 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
3120 get_64bit_dynamic_segment (file
)
3123 Elf64_External_Dyn
* edyn
;
3124 Elf_Internal_Dyn
* entry
;
3127 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3128 edyn
, Elf64_External_Dyn
*, "dynamic segment");
3130 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3131 how large this .dynamic is now. We can do this even before the byte
3132 swapping since the DT_NULL tag is recognizable. */
3134 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3137 dynamic_segment
= (Elf_Internal_Dyn
*)
3138 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3140 if (dynamic_segment
== NULL
)
3142 error (_("Out of memory\n"));
3147 for (i
= 0, entry
= dynamic_segment
;
3151 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
3152 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
3161 get_dynamic_flags (flags
)
3164 static char buff
[64];
3169 flag
= flags
& - flags
;
3174 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3175 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3176 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3177 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3178 default: strcat (buff
, "unknown "); break;
3184 /* Parse and display the contents of the dynamic segment. */
3186 process_dynamic_segment (file
)
3189 Elf_Internal_Dyn
* entry
;
3192 if (dynamic_size
== 0)
3195 printf (_("\nThere is no dynamic segment in this file.\n"));
3202 if (! get_32bit_dynamic_segment (file
))
3205 else if (! get_64bit_dynamic_segment (file
))
3208 /* Find the appropriate symbol table. */
3209 if (dynamic_symbols
== NULL
)
3211 for (i
= 0, entry
= dynamic_segment
;
3215 unsigned long offset
;
3217 if (entry
->d_tag
!= DT_SYMTAB
)
3220 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3222 /* Since we do not know how big the symbol table is,
3223 we default to reading in the entire file (!) and
3224 processing that. This is overkill, I know, but it
3226 offset
= entry
->d_un
.d_val
- loadaddr
;
3228 if (fseek (file
, 0, SEEK_END
))
3229 error (_("Unable to seek to end of file!"));
3232 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3234 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3236 if (num_dynamic_syms
< 1)
3238 error (_("Unable to determine the number of symbols to load\n"));
3242 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3246 /* Similarly find a string table. */
3247 if (dynamic_strings
== NULL
)
3249 for (i
= 0, entry
= dynamic_segment
;
3253 unsigned long offset
;
3256 if (entry
->d_tag
!= DT_STRTAB
)
3259 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3261 /* Since we do not know how big the string table is,
3262 we default to reading in the entire file (!) and
3263 processing that. This is overkill, I know, but it
3266 offset
= entry
->d_un
.d_val
- loadaddr
;
3267 if (fseek (file
, 0, SEEK_END
))
3268 error (_("Unable to seek to end of file\n"));
3269 str_tab_len
= ftell (file
) - offset
;
3271 if (str_tab_len
< 1)
3274 (_("Unable to determine the length of the dynamic string table\n"));
3278 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
3279 "dynamic string table");
3285 /* And find the syminfo section if available. */
3286 if (dynamic_syminfo
== NULL
)
3288 unsigned int syminsz
= 0;
3290 for (i
= 0, entry
= dynamic_segment
;
3294 if (entry
->d_tag
== DT_SYMINENT
)
3296 /* Note: these braces are necessary to avoid a syntax
3297 error from the SunOS4 C compiler. */
3298 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3300 else if (entry
->d_tag
== DT_SYMINSZ
)
3301 syminsz
= entry
->d_un
.d_val
;
3302 else if (entry
->d_tag
== DT_SYMINFO
)
3303 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
3306 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3308 Elf_External_Syminfo
* extsyminfo
;
3309 Elf_Internal_Syminfo
* syminfo
;
3311 /* There is a syminfo section. Read the data. */
3312 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3313 Elf_External_Syminfo
*, "symbol information");
3315 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3316 if (dynamic_syminfo
== NULL
)
3318 error (_("Out of memory\n"));
3322 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3323 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3326 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3327 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3334 if (do_dynamic
&& dynamic_addr
)
3335 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3336 dynamic_addr
, (long) dynamic_size
);
3338 printf (_(" Tag Type Name/Value\n"));
3340 for (i
= 0, entry
= dynamic_segment
;
3349 print_vma (entry
->d_tag
, FULL_HEX
);
3350 dtype
= get_dynamic_type (entry
->d_tag
);
3351 printf (" (%s)%*s", dtype
,
3352 ((is_32bit_elf
? 27 : 19)
3353 - (int) strlen (dtype
)),
3357 switch (entry
->d_tag
)
3361 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
3371 switch (entry
->d_tag
)
3374 printf (_("Auxiliary library"));
3378 printf (_("Filter library"));
3382 printf (_("Configuration file"));
3386 printf (_("Dependency audit library"));
3390 printf (_("Audit library"));
3394 if (dynamic_strings
)
3395 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3399 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3408 printf (_("Flags:"));
3409 if (entry
->d_un
.d_val
== 0)
3410 printf (_(" None\n"));
3413 unsigned long int val
= entry
->d_un
.d_val
;
3414 if (val
& DTF_1_PARINIT
)
3416 printf (" PARINIT");
3417 val
^= DTF_1_PARINIT
;
3419 if (val
& DTF_1_CONFEXP
)
3421 printf (" CONFEXP");
3422 val
^= DTF_1_CONFEXP
;
3425 printf (" %lx", val
);
3434 printf (_("Flags:"));
3435 if (entry
->d_un
.d_val
== 0)
3436 printf (_(" None\n"));
3439 unsigned long int val
= entry
->d_un
.d_val
;
3440 if (val
& DF_P1_LAZYLOAD
)
3442 printf (" LAZYLOAD");
3443 val
^= DF_P1_LAZYLOAD
;
3445 if (val
& DF_P1_GROUPPERM
)
3447 printf (" GROUPPERM");
3448 val
^= DF_P1_GROUPPERM
;
3451 printf (" %lx", val
);
3460 printf (_("Flags:"));
3461 if (entry
->d_un
.d_val
== 0)
3462 printf (_(" None\n"));
3465 unsigned long int val
= entry
->d_un
.d_val
;
3471 if (val
& DF_1_GLOBAL
)
3476 if (val
& DF_1_GROUP
)
3481 if (val
& DF_1_NODELETE
)
3483 printf (" NODELETE");
3484 val
^= DF_1_NODELETE
;
3486 if (val
& DF_1_LOADFLTR
)
3488 printf (" LOADFLTR");
3489 val
^= DF_1_LOADFLTR
;
3491 if (val
& DF_1_INITFIRST
)
3493 printf (" INITFIRST");
3494 val
^= DF_1_INITFIRST
;
3496 if (val
& DF_1_NOOPEN
)
3501 if (val
& DF_1_ORIGIN
)
3506 if (val
& DF_1_DIRECT
)
3511 if (val
& DF_1_TRANS
)
3516 if (val
& DF_1_INTERPOSE
)
3518 printf (" INTERPOSE");
3519 val
^= DF_1_INTERPOSE
;
3521 if (val
& DF_1_NODEFLIB
)
3523 printf (" NODEFLIB");
3524 val
^= DF_1_NODEFLIB
;
3526 if (val
& DF_1_NODUMP
)
3531 if (val
& DF_1_CONLFAT
)
3533 printf (" CONLFAT");
3534 val
^= DF_1_CONLFAT
;
3537 printf (" %lx", val
);
3545 puts (get_dynamic_type (entry
->d_un
.d_val
));
3565 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
3571 if (dynamic_strings
== NULL
)
3574 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3578 switch (entry
->d_tag
)
3581 printf (_("Shared library: [%s]"), name
);
3583 if (strcmp (name
, program_interpreter
) == 0)
3584 printf (_(" program interpreter"));
3588 printf (_("Library soname: [%s]"), name
);
3592 printf (_("Library rpath: [%s]"), name
);
3596 printf (_("Library runpath: [%s]"), name
);
3600 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3605 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3621 case DT_INIT_ARRAYSZ
:
3622 case DT_FINI_ARRAYSZ
:
3625 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3626 printf (" (bytes)\n");
3636 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3649 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
3653 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3657 printf (_("Not needed object: [%s]\n"), name
);
3662 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3668 /* The value of this entry is ignored. */
3672 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
3673 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
3678 switch (elf_header
.e_machine
)
3681 case EM_MIPS_RS4_BE
:
3682 dynamic_segment_mips_val (entry
);
3685 dynamic_segment_parisc_val (entry
);
3688 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3700 get_ver_flags (flags
)
3703 static char buff
[32];
3710 if (flags
& VER_FLG_BASE
)
3711 strcat (buff
, "BASE ");
3713 if (flags
& VER_FLG_WEAK
)
3715 if (flags
& VER_FLG_BASE
)
3716 strcat (buff
, "| ");
3718 strcat (buff
, "WEAK ");
3721 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
3722 strcat (buff
, "| <unknown>");
3727 /* Display the contents of the version sections. */
3729 process_version_sections (file
)
3732 Elf32_Internal_Shdr
* section
;
3739 for (i
= 0, section
= section_headers
;
3740 i
< elf_header
.e_shnum
;
3743 switch (section
->sh_type
)
3745 case SHT_GNU_verdef
:
3747 Elf_External_Verdef
* edefs
;
3754 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3755 SECTION_NAME (section
), section
->sh_info
);
3757 printf (_(" Addr: 0x"));
3758 printf_vma (section
->sh_addr
);
3759 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3760 (unsigned long) section
->sh_offset
, section
->sh_link
,
3761 SECTION_NAME (section_headers
+ section
->sh_link
));
3763 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3764 edefs
, Elf_External_Verdef
*,
3765 "version definition section");
3767 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
3770 Elf_External_Verdef
* edef
;
3771 Elf_Internal_Verdef ent
;
3772 Elf_External_Verdaux
* eaux
;
3773 Elf_Internal_Verdaux aux
;
3777 vstart
= ((char *) edefs
) + idx
;
3779 edef
= (Elf_External_Verdef
*) vstart
;
3781 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
3782 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
3783 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
3784 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
3785 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
3786 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
3787 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
3789 printf (_(" %#06x: Rev: %d Flags: %s"),
3790 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
3792 printf (_(" Index: %d Cnt: %d "),
3793 ent
.vd_ndx
, ent
.vd_cnt
);
3795 vstart
+= ent
.vd_aux
;
3797 eaux
= (Elf_External_Verdaux
*) vstart
;
3799 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3800 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3802 if (dynamic_strings
)
3803 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
3805 printf (_("Name index: %ld\n"), aux
.vda_name
);
3807 isum
= idx
+ ent
.vd_aux
;
3809 for (j
= 1; j
< ent
.vd_cnt
; j
++)
3811 isum
+= aux
.vda_next
;
3812 vstart
+= aux
.vda_next
;
3814 eaux
= (Elf_External_Verdaux
*) vstart
;
3816 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3817 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3819 if (dynamic_strings
)
3820 printf (_(" %#06x: Parent %d: %s\n"),
3821 isum
, j
, dynamic_strings
+ aux
.vda_name
);
3823 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3824 isum
, j
, aux
.vda_name
);
3834 case SHT_GNU_verneed
:
3836 Elf_External_Verneed
* eneed
;
3842 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3843 SECTION_NAME (section
), section
->sh_info
);
3845 printf (_(" Addr: 0x"));
3846 printf_vma (section
->sh_addr
);
3847 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3848 (unsigned long) section
->sh_offset
, section
->sh_link
,
3849 SECTION_NAME (section_headers
+ section
->sh_link
));
3851 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3852 eneed
, Elf_External_Verneed
*,
3853 "version need section");
3855 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
3857 Elf_External_Verneed
* entry
;
3858 Elf_Internal_Verneed ent
;
3863 vstart
= ((char *) eneed
) + idx
;
3865 entry
= (Elf_External_Verneed
*) vstart
;
3867 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
3868 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
3869 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
3870 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
3871 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
3873 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
3875 if (dynamic_strings
)
3876 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
3878 printf (_(" File: %lx"), ent
.vn_file
);
3880 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
3882 vstart
+= ent
.vn_aux
;
3884 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
3886 Elf_External_Vernaux
* eaux
;
3887 Elf_Internal_Vernaux aux
;
3889 eaux
= (Elf_External_Vernaux
*) vstart
;
3891 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
3892 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
3893 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
3894 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
3895 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
3897 if (dynamic_strings
)
3898 printf (_(" %#06x: Name: %s"),
3899 isum
, dynamic_strings
+ aux
.vna_name
);
3901 printf (_(" %#06x: Name index: %lx"),
3902 isum
, aux
.vna_name
);
3904 printf (_(" Flags: %s Version: %d\n"),
3905 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
3907 isum
+= aux
.vna_next
;
3908 vstart
+= aux
.vna_next
;
3918 case SHT_GNU_versym
:
3920 Elf32_Internal_Shdr
* link_section
;
3923 unsigned char * edata
;
3924 unsigned short * data
;
3926 Elf_Internal_Sym
* symbols
;
3927 Elf32_Internal_Shdr
* string_sec
;
3929 link_section
= section_headers
+ section
->sh_link
;
3930 total
= section
->sh_size
/ section
->sh_entsize
;
3934 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
3935 link_section
->sh_size
/ link_section
->sh_entsize
);
3937 string_sec
= section_headers
+ link_section
->sh_link
;
3939 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3940 strtab
, char *, "version string table");
3942 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3943 SECTION_NAME (section
), total
);
3945 printf (_(" Addr: "));
3946 printf_vma (section
->sh_addr
);
3947 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3948 (unsigned long) section
->sh_offset
, section
->sh_link
,
3949 SECTION_NAME (link_section
));
3951 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3953 total
* sizeof (short), edata
,
3954 unsigned char *, "version symbol data");
3956 data
= (unsigned short *) malloc (total
* sizeof (short));
3958 for (cnt
= total
; cnt
--;)
3959 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
3964 for (cnt
= 0; cnt
< total
; cnt
+= 4)
3969 printf (" %03x:", cnt
);
3971 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
3972 switch (data
[cnt
+ j
])
3975 fputs (_(" 0 (*local*) "), stdout
);
3979 fputs (_(" 1 (*global*) "), stdout
);
3983 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
3984 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
3986 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
3987 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
3990 /* We must test both. */
3991 Elf_Internal_Verneed ivn
;
3992 unsigned long offset
;
3994 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3999 Elf_External_Verneed evn
;
4000 Elf_External_Vernaux evna
;
4001 Elf_Internal_Vernaux ivna
;
4002 unsigned long vna_off
;
4004 GET_DATA (offset
, evn
, "version need");
4006 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4007 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4009 vna_off
= offset
+ ivn
.vn_aux
;
4013 GET_DATA (vna_off
, evna
,
4014 "version need aux (1)");
4016 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4017 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4019 vna_off
+= ivna
.vna_next
;
4021 while (ivna
.vna_other
!= data
[cnt
+ j
]
4022 && ivna
.vna_next
!= 0);
4024 if (ivna
.vna_other
== data
[cnt
+ j
])
4026 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4028 name
= strtab
+ ivna
.vna_name
;
4029 nn
+= printf ("(%s%-*s",
4031 12 - (int) strlen (name
),
4035 else if (ivn
.vn_next
== 0)
4037 if (data
[cnt
+ j
] != 0x8001)
4039 Elf_Internal_Verdef ivd
;
4040 Elf_External_Verdef evd
;
4042 offset
= version_info
4043 [DT_VERSIONTAGIDX (DT_VERDEF
)]
4048 GET_DATA (offset
, evd
,
4049 "version definition");
4051 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4052 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4054 offset
+= ivd
.vd_next
;
4057 != (data
[cnt
+ j
] & 0x7fff)
4058 && ivd
.vd_next
!= 0);
4061 == (data
[cnt
+ j
] & 0x7fff))
4063 Elf_External_Verdaux evda
;
4064 Elf_Internal_Verdaux ivda
;
4066 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4068 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
4069 "version definition aux");
4072 BYTE_GET (evda
.vda_name
);
4074 name
= strtab
+ ivda
.vda_name
;
4078 12 - (int) strlen (name
),
4086 offset
+= ivn
.vn_next
;
4088 while (ivn
.vn_next
);
4090 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
4092 Elf_Internal_Verneed ivn
;
4093 unsigned long offset
;
4095 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4100 Elf_Internal_Vernaux ivna
;
4101 Elf_External_Verneed evn
;
4102 Elf_External_Vernaux evna
;
4103 unsigned long a_off
;
4105 GET_DATA (offset
, evn
, "version need");
4107 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4108 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4110 a_off
= offset
+ ivn
.vn_aux
;
4114 GET_DATA (a_off
, evna
,
4115 "version need aux (2)");
4117 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4118 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4120 a_off
+= ivna
.vna_next
;
4122 while (ivna
.vna_other
!= data
[cnt
+ j
]
4123 && ivna
.vna_next
!= 0);
4125 if (ivna
.vna_other
== data
[cnt
+ j
])
4127 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4129 name
= strtab
+ ivna
.vna_name
;
4130 nn
+= printf ("(%s%-*s",
4132 12 - (int) strlen (name
),
4137 offset
+= ivn
.vn_next
;
4139 while (ivn
.vn_next
);
4141 else if (data
[cnt
+ j
] != 0x8001)
4143 Elf_Internal_Verdef ivd
;
4144 Elf_External_Verdef evd
;
4145 unsigned long offset
;
4147 offset
= version_info
4148 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
4152 GET_DATA (offset
, evd
, "version def");
4154 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4155 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4157 offset
+= ivd
.vd_next
;
4159 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
4160 && ivd
.vd_next
!= 0);
4162 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
4164 Elf_External_Verdaux evda
;
4165 Elf_Internal_Verdaux ivda
;
4167 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4169 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
4170 evda
, "version def aux");
4172 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4174 name
= strtab
+ ivda
.vda_name
;
4175 nn
+= printf ("(%s%-*s",
4177 12 - (int) strlen (name
),
4183 printf ("%*c", 18 - nn
, ' ');
4201 printf (_("\nNo version information found in this file.\n"));
4207 get_symbol_binding (binding
)
4208 unsigned int binding
;
4210 static char buff
[32];
4214 case STB_LOCAL
: return "LOCAL";
4215 case STB_GLOBAL
: return "GLOBAL";
4216 case STB_WEAK
: return "WEAK";
4218 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4219 sprintf (buff
, _("<processor specific>: %d"), binding
);
4220 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4221 sprintf (buff
, _("<OS specific>: %d"), binding
);
4223 sprintf (buff
, _("<unknown>: %d"), binding
);
4229 get_symbol_type (type
)
4232 static char buff
[32];
4236 case STT_NOTYPE
: return "NOTYPE";
4237 case STT_OBJECT
: return "OBJECT";
4238 case STT_FUNC
: return "FUNC";
4239 case STT_SECTION
: return "SECTION";
4240 case STT_FILE
: return "FILE";
4241 case STT_COMMON
: return "COMMON";
4243 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4245 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4246 return "THUMB_FUNC";
4248 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4251 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4252 return "PARISC_MILLI";
4254 sprintf (buff
, _("<processor specific>: %d"), type
);
4256 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4258 if (elf_header
.e_machine
== EM_PARISC
)
4260 if (type
== STT_HP_OPAQUE
)
4262 if (type
== STT_HP_STUB
)
4266 sprintf (buff
, _("<OS specific>: %d"), type
);
4269 sprintf (buff
, _("<unknown>: %d"), type
);
4275 get_symbol_visibility (visibility
)
4276 unsigned int visibility
;
4280 case STV_DEFAULT
: return "DEFAULT";
4281 case STV_INTERNAL
: return "INTERNAL";
4282 case STV_HIDDEN
: return "HIDDEN";
4283 case STV_PROTECTED
: return "PROTECTED";
4289 get_symbol_index_type (type
)
4294 case SHN_UNDEF
: return "UND";
4295 case SHN_ABS
: return "ABS";
4296 case SHN_COMMON
: return "COM";
4298 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4300 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4302 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4306 static char buff
[32];
4308 sprintf (buff
, "%3d", type
);
4315 get_dynamic_data (file
, number
)
4317 unsigned int number
;
4319 unsigned char * e_data
;
4322 e_data
= (unsigned char *) malloc (number
* 4);
4326 error (_("Out of memory\n"));
4330 if (fread (e_data
, 4, number
, file
) != number
)
4332 error (_("Unable to read in dynamic data\n"));
4336 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4340 error (_("Out of memory\n"));
4346 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4353 /* Dump the symbol table */
4355 process_symbol_table (file
)
4358 Elf32_Internal_Shdr
* section
;
4359 unsigned char nb
[4];
4360 unsigned char nc
[4];
4363 int * buckets
= NULL
;
4364 int * chains
= NULL
;
4366 if (! do_syms
&& !do_histogram
)
4369 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
4372 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
4374 error (_("Unable to seek to start of dynamic information"));
4378 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4380 error (_("Failed to read in number of buckets\n"));
4384 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4386 error (_("Failed to read in number of chains\n"));
4390 nbuckets
= byte_get (nb
, 4);
4391 nchains
= byte_get (nc
, 4);
4393 buckets
= get_dynamic_data (file
, nbuckets
);
4394 chains
= get_dynamic_data (file
, nchains
);
4396 if (buckets
== NULL
|| chains
== NULL
)
4401 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4406 printf (_("\nSymbol table for image:\n"));
4408 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4410 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4412 for (hn
= 0; hn
< nbuckets
; hn
++)
4417 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4419 Elf_Internal_Sym
* psym
;
4421 psym
= dynamic_symbols
+ si
;
4423 printf (" %3d %3d: ", si
, hn
);
4424 print_vma (psym
->st_value
, LONG_HEX
);
4426 print_vma (psym
->st_size
, DEC_5
);
4428 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4429 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4430 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4431 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
4432 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4436 else if (do_syms
&& !do_using_dynamic
)
4440 for (i
= 0, section
= section_headers
;
4441 i
< elf_header
.e_shnum
;
4446 Elf_Internal_Sym
* symtab
;
4447 Elf_Internal_Sym
* psym
;
4450 if ( section
->sh_type
!= SHT_SYMTAB
4451 && section
->sh_type
!= SHT_DYNSYM
)
4454 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4455 SECTION_NAME (section
),
4456 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4458 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4460 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4462 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4463 section
->sh_size
/ section
->sh_entsize
);
4467 if (section
->sh_link
== elf_header
.e_shstrndx
)
4468 strtab
= string_table
;
4471 Elf32_Internal_Shdr
* string_sec
;
4473 string_sec
= section_headers
+ section
->sh_link
;
4475 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4476 strtab
, char *, "string table");
4479 for (si
= 0, psym
= symtab
;
4480 si
< section
->sh_size
/ section
->sh_entsize
;
4483 printf ("%6d: ", si
);
4484 print_vma (psym
->st_value
, LONG_HEX
);
4486 print_vma (psym
->st_size
, DEC_5
);
4487 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4488 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4489 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4490 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
4491 printf (" %s", strtab
+ psym
->st_name
);
4493 if (section
->sh_type
== SHT_DYNSYM
&&
4494 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
4496 unsigned char data
[2];
4497 unsigned short vers_data
;
4498 unsigned long offset
;
4502 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4505 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
4508 vers_data
= byte_get (data
, 2);
4510 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
4511 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
4514 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
4516 if ((vers_data
& 0x8000) || vers_data
> 1)
4518 if (is_nobits
|| ! check_def
)
4520 Elf_External_Verneed evn
;
4521 Elf_Internal_Verneed ivn
;
4522 Elf_Internal_Vernaux ivna
;
4524 /* We must test both. */
4525 offset
= version_info
4526 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
4530 unsigned long vna_off
;
4532 GET_DATA (offset
, evn
, "version need");
4534 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4535 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4537 vna_off
= offset
+ ivn
.vn_aux
;
4541 Elf_External_Vernaux evna
;
4543 GET_DATA (vna_off
, evna
,
4544 "version need aux (3)");
4546 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4547 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4548 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4550 vna_off
+= ivna
.vna_next
;
4552 while (ivna
.vna_other
!= vers_data
4553 && ivna
.vna_next
!= 0);
4555 if (ivna
.vna_other
== vers_data
)
4558 offset
+= ivn
.vn_next
;
4560 while (ivn
.vn_next
!= 0);
4562 if (ivna
.vna_other
== vers_data
)
4565 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
4568 else if (! is_nobits
)
4569 error (_("bad dynamic symbol"));
4576 if (vers_data
!= 0x8001)
4578 Elf_Internal_Verdef ivd
;
4579 Elf_Internal_Verdaux ivda
;
4580 Elf_External_Verdaux evda
;
4581 unsigned long offset
;
4584 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
4589 Elf_External_Verdef evd
;
4591 GET_DATA (offset
, evd
, "version def");
4593 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4594 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4595 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4597 offset
+= ivd
.vd_next
;
4599 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
4600 && ivd
.vd_next
!= 0);
4602 offset
-= ivd
.vd_next
;
4603 offset
+= ivd
.vd_aux
;
4605 GET_DATA (offset
, evda
, "version def aux");
4607 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4609 if (psym
->st_name
!= ivda
.vda_name
)
4610 printf ((vers_data
& 0x8000)
4612 strtab
+ ivda
.vda_name
);
4622 if (strtab
!= string_table
)
4628 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4630 if (do_histogram
&& buckets
!= NULL
)
4637 int nzero_counts
= 0;
4640 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4642 printf (_(" Length Number %% of total Coverage\n"));
4644 lengths
= (int *) calloc (nbuckets
, sizeof (int));
4645 if (lengths
== NULL
)
4647 error (_("Out of memory"));
4650 for (hn
= 0; hn
< nbuckets
; ++hn
)
4655 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
4658 if (maxlength
< ++lengths
[hn
])
4663 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
4666 error (_("Out of memory"));
4670 for (hn
= 0; hn
< nbuckets
; ++hn
)
4671 ++ counts
[lengths
[hn
]];
4675 printf (" 0 %-10d (%5.1f%%)\n",
4676 counts
[0], (counts
[0] * 100.0) / nbuckets
);
4677 for (si
= 1; si
<= maxlength
; ++si
)
4679 nzero_counts
+= counts
[si
] * si
;
4680 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4681 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
4682 (nzero_counts
* 100.0) / nsyms
);
4690 if (buckets
!= NULL
)
4700 process_syminfo (file
)
4701 FILE * file ATTRIBUTE_UNUSED
;
4705 if (dynamic_syminfo
== NULL
4707 /* No syminfo, this is ok. */
4710 /* There better should be a dynamic symbol section. */
4711 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
4715 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4716 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
4718 printf (_(" Num: Name BoundTo Flags\n"));
4719 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
4721 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
4723 printf ("%4d: %-30s ", i
,
4724 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
4726 switch (dynamic_syminfo
[i
].si_boundto
)
4728 case SYMINFO_BT_SELF
:
4729 fputs ("SELF ", stdout
);
4731 case SYMINFO_BT_PARENT
:
4732 fputs ("PARENT ", stdout
);
4735 if (dynamic_syminfo
[i
].si_boundto
> 0
4736 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
4739 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
4741 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
4745 if (flags
& SYMINFO_FLG_DIRECT
)
4747 if (flags
& SYMINFO_FLG_PASSTHRU
)
4748 printf (" PASSTHRU");
4749 if (flags
& SYMINFO_FLG_COPY
)
4751 if (flags
& SYMINFO_FLG_LAZYLOAD
)
4752 printf (" LAZYLOAD");
4760 #ifdef SUPPORT_DISASSEMBLY
4762 disassemble_section (section
, file
)
4763 Elf32_Internal_Shdr
* section
;
4766 printf (_("\nAssembly dump of section %s\n"),
4767 SECTION_NAME (section
));
4769 /* XXX -- to be done --- XXX */
4776 dump_section (section
, file
)
4777 Elf32_Internal_Shdr
* section
;
4780 bfd_size_type bytes
;
4782 unsigned char * data
;
4783 unsigned char * start
;
4785 bytes
= section
->sh_size
;
4789 printf (_("\nSection '%s' has no data to dump.\n"),
4790 SECTION_NAME (section
));
4794 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
4796 addr
= section
->sh_addr
;
4798 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
4809 lbytes
= (bytes
> 16 ? 16 : bytes
);
4811 printf (" 0x%8.8lx ", (unsigned long) addr
);
4813 switch (elf_header
.e_ident
[EI_DATA
])
4817 for (j
= 15; j
>= 0; j
--)
4820 printf ("%2.2x", data
[j
]);
4830 for (j
= 0; j
< 16; j
++)
4833 printf ("%2.2x", data
[j
]);
4843 for (j
= 0; j
< lbytes
; j
++)
4846 if (k
>= ' ' && k
< 0x80)
4865 static unsigned long int
4866 read_leb128 (data
, length_return
, sign
)
4867 unsigned char * data
;
4868 int * length_return
;
4871 unsigned long int result
= 0;
4872 unsigned int num_read
= 0;
4881 result
|= (byte
& 0x7f) << shift
;
4886 while (byte
& 0x80);
4888 if (length_return
!= NULL
)
4889 * length_return
= num_read
;
4891 if (sign
&& (shift
< 32) && (byte
& 0x40))
4892 result
|= -1 << shift
;
4897 typedef struct State_Machine_Registers
4899 unsigned long address
;
4902 unsigned int column
;
4906 /* This variable hold the number of the last entry seen
4907 in the File Table. */
4908 unsigned int last_file_entry
;
4911 static SMR state_machine_regs
;
4914 reset_state_machine (is_stmt
)
4917 state_machine_regs
.address
= 0;
4918 state_machine_regs
.file
= 1;
4919 state_machine_regs
.line
= 1;
4920 state_machine_regs
.column
= 0;
4921 state_machine_regs
.is_stmt
= is_stmt
;
4922 state_machine_regs
.basic_block
= 0;
4923 state_machine_regs
.end_sequence
= 0;
4924 state_machine_regs
.last_file_entry
= 0;
4927 /* Handled an extend line op. Returns true if this is the end
4930 process_extended_line_op (data
, is_stmt
, pointer_size
)
4931 unsigned char * data
;
4935 unsigned char op_code
;
4938 unsigned char * name
;
4941 len
= read_leb128 (data
, & bytes_read
, 0);
4946 warn (_("badly formed extended line op encountered!"));
4951 op_code
= * data
++;
4953 printf (_(" Extended opcode %d: "), op_code
);
4957 case DW_LNE_end_sequence
:
4958 printf (_("End of Sequence\n\n"));
4959 reset_state_machine (is_stmt
);
4962 case DW_LNE_set_address
:
4963 adr
= byte_get (data
, pointer_size
);
4964 printf (_("set Address to 0x%lx\n"), adr
);
4965 state_machine_regs
.address
= adr
;
4968 case DW_LNE_define_file
:
4969 printf (_(" define new File Table entry\n"));
4970 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4972 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4974 data
+= strlen ((char *) data
) + 1;
4975 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4977 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4979 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4980 printf (_("%s\n\n"), name
);
4984 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
4991 /* Size of pointers in the .debug_line section. This information is not
4992 really present in that section. It's obtained before dumping the debug
4993 sections by doing some pre-scan of the .debug_info section. */
4994 static int debug_line_pointer_size
= 4;
4997 display_debug_lines (section
, start
, file
)
4998 Elf32_Internal_Shdr
* section
;
4999 unsigned char * start
;
5000 FILE * file ATTRIBUTE_UNUSED
;
5002 DWARF2_External_LineInfo
* external
;
5003 DWARF2_Internal_LineInfo info
;
5004 unsigned char * standard_opcodes
;
5005 unsigned char * data
= start
;
5006 unsigned char * end
= start
+ section
->sh_size
;
5007 unsigned char * end_of_sequence
;
5010 printf (_("\nDump of debug contents of section %s:\n\n"),
5011 SECTION_NAME (section
));
5015 external
= (DWARF2_External_LineInfo
*) data
;
5017 /* Check the length of the block. */
5018 info
.li_length
= BYTE_GET (external
->li_length
);
5019 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
5022 (_("The line info appears to be corrupt - the section is too small\n"));
5026 /* Check its version number. */
5027 info
.li_version
= BYTE_GET (external
->li_version
);
5028 if (info
.li_version
!= 2)
5030 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5034 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
5035 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
5036 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
5037 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
5038 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
5039 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
5041 /* Sign extend the line base field. */
5042 info
.li_line_base
<<= 24;
5043 info
.li_line_base
>>= 24;
5045 printf (_(" Length: %ld\n"), info
.li_length
);
5046 printf (_(" DWARF Version: %d\n"), info
.li_version
);
5047 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
5048 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
5049 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
5050 printf (_(" Line Base: %d\n"), info
.li_line_base
);
5051 printf (_(" Line Range: %d\n"), info
.li_line_range
);
5052 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
5054 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
5056 reset_state_machine (info
.li_default_is_stmt
);
5058 /* Display the contents of the Opcodes table. */
5059 standard_opcodes
= data
+ sizeof (* external
);
5061 printf (_("\n Opcodes:\n"));
5063 for (i
= 1; i
< info
.li_opcode_base
; i
++)
5064 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
5066 /* Display the contents of the Directory table. */
5067 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
5070 printf (_("\n The Directory Table is empty.\n"));
5073 printf (_("\n The Directory Table:\n"));
5077 printf (_(" %s\n"), data
);
5079 data
+= strlen ((char *) data
) + 1;
5083 /* Skip the NUL at the end of the table. */
5086 /* Display the contents of the File Name table. */
5088 printf (_("\n The File Name Table is empty.\n"));
5091 printf (_("\n The File Name Table:\n"));
5092 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5096 unsigned char * name
;
5099 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5102 data
+= strlen ((char *) data
) + 1;
5104 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5106 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5108 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5110 printf (_("%s\n"), name
);
5114 /* Skip the NUL at the end of the table. */
5117 /* Now display the statements. */
5118 printf (_("\n Line Number Statements:\n"));
5121 while (data
< end_of_sequence
)
5123 unsigned char op_code
;
5127 op_code
= * data
++;
5131 case DW_LNS_extended_op
:
5132 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
5133 debug_line_pointer_size
);
5137 printf (_(" Copy\n"));
5140 case DW_LNS_advance_pc
:
5141 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
5143 state_machine_regs
.address
+= adv
;
5144 printf (_(" Advance PC by %d to %lx\n"), adv
,
5145 state_machine_regs
.address
);
5148 case DW_LNS_advance_line
:
5149 adv
= read_leb128 (data
, & bytes_read
, 1);
5151 state_machine_regs
.line
+= adv
;
5152 printf (_(" Advance Line by %d to %d\n"), adv
,
5153 state_machine_regs
.line
);
5156 case DW_LNS_set_file
:
5157 adv
= read_leb128 (data
, & bytes_read
, 0);
5159 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5161 state_machine_regs
.file
= adv
;
5164 case DW_LNS_set_column
:
5165 adv
= read_leb128 (data
, & bytes_read
, 0);
5167 printf (_(" Set column to %d\n"), adv
);
5168 state_machine_regs
.column
= adv
;
5171 case DW_LNS_negate_stmt
:
5172 adv
= state_machine_regs
.is_stmt
;
5174 printf (_(" Set is_stmt to %d\n"), adv
);
5175 state_machine_regs
.is_stmt
= adv
;
5178 case DW_LNS_set_basic_block
:
5179 printf (_(" Set basic block\n"));
5180 state_machine_regs
.basic_block
= 1;
5183 case DW_LNS_const_add_pc
:
5184 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
5185 * info
.li_min_insn_length
);
5186 state_machine_regs
.address
+= adv
;
5187 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
5188 state_machine_regs
.address
);
5191 case DW_LNS_fixed_advance_pc
:
5192 adv
= byte_get (data
, 2);
5194 state_machine_regs
.address
+= adv
;
5195 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5196 adv
, state_machine_regs
.address
);
5200 op_code
-= info
.li_opcode_base
;
5201 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
5202 state_machine_regs
.address
+= adv
;
5203 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5204 op_code
, adv
, state_machine_regs
.address
);
5205 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
5206 state_machine_regs
.line
+= adv
;
5207 printf (_(" and Line by %d to %d\n"),
5208 adv
, state_machine_regs
.line
);
5219 display_debug_pubnames (section
, start
, file
)
5220 Elf32_Internal_Shdr
* section
;
5221 unsigned char * start
;
5222 FILE * file ATTRIBUTE_UNUSED
;
5224 DWARF2_External_PubNames
* external
;
5225 DWARF2_Internal_PubNames pubnames
;
5226 unsigned char * end
;
5228 end
= start
+ section
->sh_size
;
5230 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5234 unsigned char * data
;
5235 unsigned long offset
;
5237 external
= (DWARF2_External_PubNames
*) start
;
5239 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5240 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5241 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5242 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5244 data
= start
+ sizeof (* external
);
5245 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5247 if (pubnames
.pn_version
!= 2)
5249 static int warned
= 0;
5253 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5260 printf (_(" Length: %ld\n"),
5261 pubnames
.pn_length
);
5262 printf (_(" Version: %d\n"),
5263 pubnames
.pn_version
);
5264 printf (_(" Offset into .debug_info section: %ld\n"),
5265 pubnames
.pn_offset
);
5266 printf (_(" Size of area in .debug_info section: %ld\n"),
5269 printf (_("\n Offset\tName\n"));
5273 offset
= byte_get (data
, 4);
5278 printf (" %ld\t\t%s\n", offset
, data
);
5279 data
+= strlen ((char *) data
) + 1;
5282 while (offset
!= 0);
5295 case DW_TAG_padding
: return "DW_TAG_padding";
5296 case DW_TAG_array_type
: return "DW_TAG_array_type";
5297 case DW_TAG_class_type
: return "DW_TAG_class_type";
5298 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5299 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5300 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5301 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5302 case DW_TAG_label
: return "DW_TAG_label";
5303 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5304 case DW_TAG_member
: return "DW_TAG_member";
5305 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5306 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5307 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5308 case DW_TAG_string_type
: return "DW_TAG_string_type";
5309 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5310 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5311 case DW_TAG_typedef
: return "DW_TAG_typedef";
5312 case DW_TAG_union_type
: return "DW_TAG_union_type";
5313 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5314 case DW_TAG_variant
: return "DW_TAG_variant";
5315 case DW_TAG_common_block
: return "DW_TAG_common_block";
5316 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5317 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5318 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5319 case DW_TAG_module
: return "DW_TAG_module";
5320 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5321 case DW_TAG_set_type
: return "DW_TAG_set_type";
5322 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5323 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5324 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5325 case DW_TAG_base_type
: return "DW_TAG_base_type";
5326 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5327 case DW_TAG_const_type
: return "DW_TAG_const_type";
5328 case DW_TAG_constant
: return "DW_TAG_constant";
5329 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5330 case DW_TAG_file_type
: return "DW_TAG_file_type";
5331 case DW_TAG_friend
: return "DW_TAG_friend";
5332 case DW_TAG_namelist
: return "DW_TAG_namelist";
5333 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5334 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5335 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5336 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5337 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5338 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5339 case DW_TAG_try_block
: return "DW_TAG_try_block";
5340 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5341 case DW_TAG_variable
: return "DW_TAG_variable";
5342 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5343 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5344 case DW_TAG_format_label
: return "DW_TAG_format_label";
5345 case DW_TAG_function_template
: return "DW_TAG_function_template";
5346 case DW_TAG_class_template
: return "DW_TAG_class_template";
5349 static char buffer
[100];
5351 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
5358 get_AT_name (attribute
)
5359 unsigned long attribute
;
5363 case DW_AT_sibling
: return "DW_AT_sibling";
5364 case DW_AT_location
: return "DW_AT_location";
5365 case DW_AT_name
: return "DW_AT_name";
5366 case DW_AT_ordering
: return "DW_AT_ordering";
5367 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
5368 case DW_AT_byte_size
: return "DW_AT_byte_size";
5369 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
5370 case DW_AT_bit_size
: return "DW_AT_bit_size";
5371 case DW_AT_element_list
: return "DW_AT_element_list";
5372 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
5373 case DW_AT_low_pc
: return "DW_AT_low_pc";
5374 case DW_AT_high_pc
: return "DW_AT_high_pc";
5375 case DW_AT_language
: return "DW_AT_language";
5376 case DW_AT_member
: return "DW_AT_member";
5377 case DW_AT_discr
: return "DW_AT_discr";
5378 case DW_AT_discr_value
: return "DW_AT_discr_value";
5379 case DW_AT_visibility
: return "DW_AT_visibility";
5380 case DW_AT_import
: return "DW_AT_import";
5381 case DW_AT_string_length
: return "DW_AT_string_length";
5382 case DW_AT_common_reference
: return "DW_AT_common_reference";
5383 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5384 case DW_AT_const_value
: return "DW_AT_const_value";
5385 case DW_AT_containing_type
: return "DW_AT_containing_type";
5386 case DW_AT_default_value
: return "DW_AT_default_value";
5387 case DW_AT_inline
: return "DW_AT_inline";
5388 case DW_AT_is_optional
: return "DW_AT_is_optional";
5389 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5390 case DW_AT_producer
: return "DW_AT_producer";
5391 case DW_AT_prototyped
: return "DW_AT_prototyped";
5392 case DW_AT_return_addr
: return "DW_AT_return_addr";
5393 case DW_AT_start_scope
: return "DW_AT_start_scope";
5394 case DW_AT_stride_size
: return "DW_AT_stride_size";
5395 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5396 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5397 case DW_AT_accessibility
: return "DW_AT_accessibility";
5398 case DW_AT_address_class
: return "DW_AT_address_class";
5399 case DW_AT_artificial
: return "DW_AT_artificial";
5400 case DW_AT_base_types
: return "DW_AT_base_types";
5401 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5402 case DW_AT_count
: return "DW_AT_count";
5403 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5404 case DW_AT_decl_column
: return "DW_AT_decl_column";
5405 case DW_AT_decl_file
: return "DW_AT_decl_file";
5406 case DW_AT_decl_line
: return "DW_AT_decl_line";
5407 case DW_AT_declaration
: return "DW_AT_declaration";
5408 case DW_AT_discr_list
: return "DW_AT_discr_list";
5409 case DW_AT_encoding
: return "DW_AT_encoding";
5410 case DW_AT_external
: return "DW_AT_external";
5411 case DW_AT_frame_base
: return "DW_AT_frame_base";
5412 case DW_AT_friend
: return "DW_AT_friend";
5413 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5414 case DW_AT_macro_info
: return "DW_AT_macro_info";
5415 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5416 case DW_AT_priority
: return "DW_AT_priority";
5417 case DW_AT_segment
: return "DW_AT_segment";
5418 case DW_AT_specification
: return "DW_AT_specification";
5419 case DW_AT_static_link
: return "DW_AT_static_link";
5420 case DW_AT_type
: return "DW_AT_type";
5421 case DW_AT_use_location
: return "DW_AT_use_location";
5422 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5423 case DW_AT_virtuality
: return "DW_AT_virtuality";
5424 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5425 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5426 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5427 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5428 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5429 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5430 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5431 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5432 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5433 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5434 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5435 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5436 case DW_AT_sf_names
: return "DW_AT_sf_names";
5437 case DW_AT_src_info
: return "DW_AT_src_info";
5438 case DW_AT_mac_info
: return "DW_AT_mac_info";
5439 case DW_AT_src_coords
: return "DW_AT_src_coords";
5440 case DW_AT_body_begin
: return "DW_AT_body_begin";
5441 case DW_AT_body_end
: return "DW_AT_body_end";
5444 static char buffer
[100];
5446 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5453 get_FORM_name (form
)
5458 case DW_FORM_addr
: return "DW_FORM_addr";
5459 case DW_FORM_block2
: return "DW_FORM_block2";
5460 case DW_FORM_block4
: return "DW_FORM_block4";
5461 case DW_FORM_data2
: return "DW_FORM_data2";
5462 case DW_FORM_data4
: return "DW_FORM_data4";
5463 case DW_FORM_data8
: return "DW_FORM_data8";
5464 case DW_FORM_string
: return "DW_FORM_string";
5465 case DW_FORM_block
: return "DW_FORM_block";
5466 case DW_FORM_block1
: return "DW_FORM_block1";
5467 case DW_FORM_data1
: return "DW_FORM_data1";
5468 case DW_FORM_flag
: return "DW_FORM_flag";
5469 case DW_FORM_sdata
: return "DW_FORM_sdata";
5470 case DW_FORM_strp
: return "DW_FORM_strp";
5471 case DW_FORM_udata
: return "DW_FORM_udata";
5472 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5473 case DW_FORM_ref1
: return "DW_FORM_ref1";
5474 case DW_FORM_ref2
: return "DW_FORM_ref2";
5475 case DW_FORM_ref4
: return "DW_FORM_ref4";
5476 case DW_FORM_ref8
: return "DW_FORM_ref8";
5477 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5478 case DW_FORM_indirect
: return "DW_FORM_indirect";
5481 static char buffer
[100];
5483 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5489 /* FIXME: There are better and more effiecint ways to handle
5490 these structures. For now though, I just want something that
5491 is simple to implement. */
5492 typedef struct abbrev_attr
5494 unsigned long attribute
;
5496 struct abbrev_attr
* next
;
5500 typedef struct abbrev_entry
5502 unsigned long entry
;
5505 struct abbrev_attr
* first_attr
;
5506 struct abbrev_attr
* last_attr
;
5507 struct abbrev_entry
* next
;
5511 static abbrev_entry
* first_abbrev
= NULL
;
5512 static abbrev_entry
* last_abbrev
= NULL
;
5515 free_abbrevs
PARAMS ((void))
5517 abbrev_entry
* abbrev
;
5519 for (abbrev
= first_abbrev
; abbrev
;)
5521 abbrev_entry
* next
= abbrev
->next
;
5524 for (attr
= abbrev
->first_attr
; attr
;)
5526 abbrev_attr
* next
= attr
->next
;
5536 last_abbrev
= first_abbrev
= NULL
;
5540 add_abbrev (number
, tag
, children
)
5541 unsigned long number
;
5545 abbrev_entry
* entry
;
5547 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
5553 entry
->entry
= number
;
5555 entry
->children
= children
;
5556 entry
->first_attr
= NULL
;
5557 entry
->last_attr
= NULL
;
5560 if (first_abbrev
== NULL
)
5561 first_abbrev
= entry
;
5563 last_abbrev
->next
= entry
;
5565 last_abbrev
= entry
;
5569 add_abbrev_attr (attribute
, form
)
5570 unsigned long attribute
;
5575 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
5581 attr
->attribute
= attribute
;
5585 if (last_abbrev
->first_attr
== NULL
)
5586 last_abbrev
->first_attr
= attr
;
5588 last_abbrev
->last_attr
->next
= attr
;
5590 last_abbrev
->last_attr
= attr
;
5593 /* Processes the (partial) contents of a .debug_abbrev section.
5594 Returns NULL if the end of the section was encountered.
5595 Returns the address after the last byte read if the end of
5596 an abbreviation set was found. */
5598 static unsigned char *
5599 process_abbrev_section (start
, end
)
5600 unsigned char * start
;
5601 unsigned char * end
;
5603 if (first_abbrev
!= NULL
)
5609 unsigned long entry
;
5611 unsigned long attribute
;
5614 entry
= read_leb128 (start
, & bytes_read
, 0);
5615 start
+= bytes_read
;
5617 /* A single zero is supposed to end the section according
5618 to the standard. If there's more, then signal that to
5621 return start
== end
? NULL
: start
;
5623 tag
= read_leb128 (start
, & bytes_read
, 0);
5624 start
+= bytes_read
;
5626 children
= * start
++;
5628 add_abbrev (entry
, tag
, children
);
5634 attribute
= read_leb128 (start
, & bytes_read
, 0);
5635 start
+= bytes_read
;
5637 form
= read_leb128 (start
, & bytes_read
, 0);
5638 start
+= bytes_read
;
5641 add_abbrev_attr (attribute
, form
);
5643 while (attribute
!= 0);
5651 display_debug_abbrev (section
, start
, file
)
5652 Elf32_Internal_Shdr
* section
;
5653 unsigned char * start
;
5654 FILE * file ATTRIBUTE_UNUSED
;
5656 abbrev_entry
* entry
;
5657 unsigned char * end
= start
+ section
->sh_size
;
5659 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5663 start
= process_abbrev_section (start
, end
);
5665 printf (_(" Number TAG\n"));
5667 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5671 printf (_(" %ld %s [%s]\n"),
5673 get_TAG_name (entry
->tag
),
5674 entry
->children
? _("has children") : _("no children"));
5676 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5678 printf (_(" %-18s %s\n"),
5679 get_AT_name (attr
->attribute
),
5680 get_FORM_name (attr
->form
));
5692 static unsigned char *
5693 display_block (data
, length
)
5694 unsigned char * data
;
5695 unsigned long length
;
5697 printf (_(" %lu byte block: "), length
);
5700 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
5706 decode_location_expression (data
, pointer_size
, length
)
5707 unsigned char * data
;
5708 unsigned int pointer_size
;
5709 unsigned long length
;
5713 unsigned long uvalue
;
5714 unsigned char *end
= data
+ length
;
5723 printf ("DW_OP_addr: %lx",
5724 (unsigned long) byte_get (data
, pointer_size
));
5725 data
+= pointer_size
;
5728 printf ("DW_OP_deref");
5731 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
5734 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
5737 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
5741 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
5745 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
5749 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
5753 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
5754 (unsigned long) byte_get (data
+ 4, 4));
5758 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
5759 (long) byte_get (data
+ 4, 4));
5763 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
5767 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
5771 printf ("DW_OP_dup");
5774 printf ("DW_OP_drop");
5777 printf ("DW_OP_over");
5780 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
5783 printf ("DW_OP_swap");
5786 printf ("DW_OP_rot");
5789 printf ("DW_OP_xderef");
5792 printf ("DW_OP_abs");
5795 printf ("DW_OP_and");
5798 printf ("DW_OP_div");
5801 printf ("DW_OP_minus");
5804 printf ("DW_OP_mod");
5807 printf ("DW_OP_mul");
5810 printf ("DW_OP_neg");
5813 printf ("DW_OP_not");
5816 printf ("DW_OP_or");
5819 printf ("DW_OP_plus");
5821 case DW_OP_plus_uconst
:
5822 printf ("DW_OP_plus_uconst: %lu",
5823 read_leb128 (data
, &bytes_read
, 0));
5827 printf ("DW_OP_shl");
5830 printf ("DW_OP_shr");
5833 printf ("DW_OP_shra");
5836 printf ("DW_OP_xor");
5839 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
5843 printf ("DW_OP_eq");
5846 printf ("DW_OP_ge");
5849 printf ("DW_OP_gt");
5852 printf ("DW_OP_le");
5855 printf ("DW_OP_lt");
5858 printf ("DW_OP_ne");
5861 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
5897 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
5932 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
5967 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
5968 read_leb128 (data
, &bytes_read
, 1));
5973 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
5977 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
5981 uvalue
= read_leb128 (data
, &bytes_read
, 0);
5983 printf ("DW_OP_bregx: %lu %ld", uvalue
,
5984 read_leb128 (data
, &bytes_read
, 1));
5988 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
5991 case DW_OP_deref_size
:
5992 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
5994 case DW_OP_xderef_size
:
5995 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
5998 printf ("DW_OP_nop");
6002 if (op
>= DW_OP_lo_user
6003 && op
<= DW_OP_hi_user
)
6004 printf (_("(User defined location op)"));
6006 printf (_("(Unknown location op)"));
6007 /* No way to tell where the next op is, so just bail. */
6014 static unsigned char *
6015 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
6016 unsigned long attribute
;
6018 unsigned char * data
;
6019 unsigned long cu_offset
;
6020 unsigned long pointer_size
;
6022 unsigned long uvalue
= 0;
6023 unsigned char * block_start
= NULL
;
6026 printf (" %-18s:", get_AT_name (attribute
));
6033 case DW_FORM_ref_addr
:
6035 uvalue
= byte_get (data
, pointer_size
);
6036 data
+= pointer_size
;
6042 uvalue
= byte_get (data
++, 1);
6047 uvalue
= byte_get (data
, 2);
6053 uvalue
= byte_get (data
, 4);
6058 uvalue
= read_leb128 (data
, & bytes_read
, 1);
6062 case DW_FORM_ref_udata
:
6064 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6071 case DW_FORM_ref_addr
:
6072 printf (" <#%lx>", uvalue
);
6078 case DW_FORM_ref_udata
:
6079 printf (" <%lx>", uvalue
+ cu_offset
);
6083 printf (" %#lx", uvalue
);
6091 printf (" %ld", uvalue
);
6096 uvalue
= byte_get (data
, 4);
6097 printf (" %lx", uvalue
);
6098 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
6102 case DW_FORM_string
:
6103 printf (" %s", data
);
6104 data
+= strlen ((char *) data
) + 1;
6108 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6109 block_start
= data
+ bytes_read
;
6110 data
= display_block (block_start
, uvalue
);
6113 case DW_FORM_block1
:
6114 uvalue
= byte_get (data
, 1);
6115 block_start
= data
+ 1;
6116 data
= display_block (block_start
, uvalue
);
6119 case DW_FORM_block2
:
6120 uvalue
= byte_get (data
, 2);
6121 block_start
= data
+ 2;
6122 data
= display_block (block_start
, uvalue
);
6125 case DW_FORM_block4
:
6126 uvalue
= byte_get (data
, 4);
6127 block_start
= data
+ 4;
6128 data
= display_block (block_start
, uvalue
);
6132 case DW_FORM_indirect
:
6133 warn (_("Unable to handle FORM: %d"), form
);
6137 warn (_("Unrecognised form: %d"), form
);
6141 /* For some attributes we can display futher information. */
6150 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6151 case DW_INL_inlined
: printf (_("(inlined)")); break;
6152 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6153 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6154 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6158 case DW_AT_language
:
6161 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6162 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6163 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6164 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6165 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6166 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6167 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6168 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6169 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6170 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6171 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6172 default: printf ("(Unknown: %lx)", uvalue
); break;
6176 case DW_AT_encoding
:
6179 case DW_ATE_void
: printf ("(void)"); break;
6180 case DW_ATE_address
: printf ("(machine address)"); break;
6181 case DW_ATE_boolean
: printf ("(boolean)"); break;
6182 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6183 case DW_ATE_float
: printf ("(float)"); break;
6184 case DW_ATE_signed
: printf ("(signed)"); break;
6185 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6186 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6187 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6189 if (uvalue
>= DW_ATE_lo_user
6190 && uvalue
<= DW_ATE_hi_user
)
6191 printf ("(user defined type)");
6193 printf ("(unknown type)");
6198 case DW_AT_accessibility
:
6201 case DW_ACCESS_public
: printf ("(public)"); break;
6202 case DW_ACCESS_protected
: printf ("(protected)"); break;
6203 case DW_ACCESS_private
: printf ("(private)"); break;
6204 default: printf ("(unknown accessibility)"); break;
6208 case DW_AT_visibility
:
6211 case DW_VIS_local
: printf ("(local)"); break;
6212 case DW_VIS_exported
: printf ("(exported)"); break;
6213 case DW_VIS_qualified
: printf ("(qualified)"); break;
6214 default: printf ("(unknown visibility)"); break;
6218 case DW_AT_virtuality
:
6221 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6222 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6223 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6224 default: printf ("(unknown virtuality)"); break;
6228 case DW_AT_identifier_case
:
6231 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6232 case DW_ID_up_case
: printf ("(up_case)"); break;
6233 case DW_ID_down_case
: printf ("(down_case)"); break;
6234 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6235 default: printf ("(unknown case)"); break;
6239 case DW_AT_calling_convention
:
6242 case DW_CC_normal
: printf ("(normal)"); break;
6243 case DW_CC_program
: printf ("(program)"); break;
6244 case DW_CC_nocall
: printf ("(nocall)"); break;
6246 if (uvalue
>= DW_CC_lo_user
6247 && uvalue
<= DW_CC_hi_user
)
6248 printf ("(user defined)");
6250 printf ("(unknown convention)");
6254 case DW_AT_frame_base
:
6255 case DW_AT_location
:
6256 case DW_AT_data_member_location
:
6257 case DW_AT_vtable_elem_location
:
6261 decode_location_expression (block_start
, pointer_size
, uvalue
);
6275 display_debug_info (section
, start
, file
)
6276 Elf32_Internal_Shdr
* section
;
6277 unsigned char * start
;
6280 unsigned char * end
= start
+ section
->sh_size
;
6281 unsigned char * section_begin
= start
;
6283 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6287 DWARF2_External_CompUnit
* external
;
6288 DWARF2_Internal_CompUnit compunit
;
6289 unsigned char * tags
;
6292 unsigned long cu_offset
;
6294 external
= (DWARF2_External_CompUnit
*) start
;
6296 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6297 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6298 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6299 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6301 tags
= start
+ sizeof (* external
);
6302 cu_offset
= start
- section_begin
;
6303 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6305 if (compunit
.cu_version
!= 2)
6307 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6311 printf (_(" Compilation Unit:\n"));
6312 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6313 printf (_(" Version: %d\n"), compunit
.cu_version
);
6314 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6315 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6317 if (first_abbrev
!= NULL
)
6320 /* Read in the abbrevs used by this compilation unit. */
6323 Elf32_Internal_Shdr
* sec
;
6324 unsigned char * begin
;
6326 /* Locate the .debug_abbrev section and process it. */
6327 for (i
= 0, sec
= section_headers
;
6328 i
< elf_header
.e_shnum
;
6330 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6333 if (i
== -1 || sec
->sh_size
== 0)
6335 warn (_("Unable to locate .debug_abbrev section!\n"));
6339 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6340 "debug_abbrev section data");
6342 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6343 begin
+ sec
->sh_size
);
6349 while (tags
< start
)
6352 unsigned long abbrev_number
;
6353 abbrev_entry
* entry
;
6356 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6359 /* A null DIE marks the end of a list of children. */
6360 if (abbrev_number
== 0)
6366 /* Scan through the abbreviation list until we reach the
6368 for (entry
= first_abbrev
;
6369 entry
&& entry
->entry
!= abbrev_number
;
6370 entry
= entry
->next
)
6375 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6380 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6381 level
, tags
- section_begin
- bytes_read
,
6383 get_TAG_name (entry
->tag
));
6385 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6386 tags
= read_and_display_attr (attr
->attribute
,
6389 compunit
.cu_pointer_size
);
6391 if (entry
->children
)
6402 display_debug_aranges (section
, start
, file
)
6403 Elf32_Internal_Shdr
* section
;
6404 unsigned char * start
;
6405 FILE * file ATTRIBUTE_UNUSED
;
6407 unsigned char * end
= start
+ section
->sh_size
;
6409 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6413 DWARF2_External_ARange
* external
;
6414 DWARF2_Internal_ARange arange
;
6415 unsigned char * ranges
;
6416 unsigned long length
;
6417 unsigned long address
;
6420 external
= (DWARF2_External_ARange
*) start
;
6422 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6423 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6424 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6425 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6426 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6428 if (arange
.ar_version
!= 2)
6430 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6434 printf (_(" Length: %ld\n"), arange
.ar_length
);
6435 printf (_(" Version: %d\n"), arange
.ar_version
);
6436 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6437 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6438 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6440 printf (_("\n Address Length\n"));
6442 ranges
= start
+ sizeof (* external
);
6444 /* Must pad to an alignment boundary that is twice the pointer size. */
6445 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
6447 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6451 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6453 ranges
+= arange
.ar_pointer_size
;
6455 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6457 ranges
+= arange
.ar_pointer_size
;
6459 /* A pair of zeros marks the end of the list. */
6460 if (address
== 0 && length
== 0)
6463 printf (" %8.8lx %lu\n", address
, length
);
6466 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6476 display_debug_not_supported (section
, start
, file
)
6477 Elf32_Internal_Shdr
* section
;
6478 unsigned char * start ATTRIBUTE_UNUSED
;
6479 FILE * file ATTRIBUTE_UNUSED
;
6481 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6482 SECTION_NAME (section
));
6487 /* Pre-scan the .debug_info section to record the size of address.
6488 When dumping the .debug_line, we use that size information, assuming
6489 that all compilation units have the same address size. */
6491 prescan_debug_info (section
, start
, file
)
6492 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
6493 unsigned char * start
;
6494 FILE * file ATTRIBUTE_UNUSED
;
6496 DWARF2_External_CompUnit
* external
;
6498 external
= (DWARF2_External_CompUnit
*) start
;
6500 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6504 /* A structure containing the name of a debug section and a pointer
6505 to a function that can decode it. The third field is a prescan
6506 function to be run over the section before displaying any of the
6511 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6512 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6516 { ".debug_info", display_debug_info
, prescan_debug_info
},
6517 { ".debug_abbrev", display_debug_abbrev
, NULL
},
6518 { ".debug_line", display_debug_lines
, NULL
},
6519 { ".debug_aranges", display_debug_aranges
, NULL
},
6520 { ".debug_pubnames", display_debug_pubnames
, NULL
},
6521 { ".debug_macinfo", display_debug_not_supported
, NULL
},
6522 { ".debug_frame", display_debug_not_supported
, NULL
},
6523 { ".debug_str", display_debug_not_supported
, NULL
},
6524 { ".debug_static_func", display_debug_not_supported
, NULL
},
6525 { ".debug_static_vars", display_debug_not_supported
, NULL
},
6526 { ".debug_types", display_debug_not_supported
, NULL
},
6527 { ".debug_weaknames", display_debug_not_supported
, NULL
}
6531 display_debug_section (section
, file
)
6532 Elf32_Internal_Shdr
* section
;
6535 char * name
= SECTION_NAME (section
);
6536 bfd_size_type length
;
6537 unsigned char * start
;
6540 length
= section
->sh_size
;
6543 printf (_("\nSection '%s' has no debugging data.\n"), name
);
6547 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6548 "debug section data");
6550 /* See if we know how to display the contents of this section. */
6551 for (i
= NUM_ELEM (debug_displays
); i
--;)
6552 if (strcmp (debug_displays
[i
].name
, name
) == 0)
6554 debug_displays
[i
].display (section
, start
, file
);
6559 printf (_("Unrecognised debug section: %s\n"), name
);
6563 /* If we loaded in the abbrev section at some point,
6564 we must release it here. */
6565 if (first_abbrev
!= NULL
)
6572 process_section_contents (file
)
6575 Elf32_Internal_Shdr
* section
;
6581 /* Pre-scan the debug sections to find some debug information not
6582 present in some of them. For the .debug_line, we must find out the
6583 size of address (specified in .debug_info and .debug_aranges). */
6584 for (i
= 0, section
= section_headers
;
6585 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6588 char * name
= SECTION_NAME (section
);
6591 if (section
->sh_size
== 0)
6594 /* See if there is some pre-scan operation for this section. */
6595 for (j
= NUM_ELEM (debug_displays
); j
--;)
6596 if (strcmp (debug_displays
[j
].name
, name
) == 0)
6598 if (debug_displays
[j
].prescan
!= NULL
)
6600 bfd_size_type length
;
6601 unsigned char * start
;
6603 length
= section
->sh_size
;
6604 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6605 "debug section data");
6607 debug_displays
[j
].prescan (section
, start
, file
);
6615 for (i
= 0, section
= section_headers
;
6616 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6619 #ifdef SUPPORT_DISASSEMBLY
6620 if (dump_sects
[i
] & DISASS_DUMP
)
6621 disassemble_section (section
, file
);
6623 if (dump_sects
[i
] & HEX_DUMP
)
6624 dump_section (section
, file
);
6626 if (dump_sects
[i
] & DEBUG_DUMP
)
6627 display_debug_section (section
, file
);
6630 if (i
< num_dump_sects
)
6631 warn (_("Some sections were not dumped because they do not exist!\n"));
6637 process_mips_fpe_exception (mask
)
6643 if (mask
& OEX_FPU_INEX
)
6644 fputs ("INEX", stdout
), first
= 0;
6645 if (mask
& OEX_FPU_UFLO
)
6646 printf ("%sUFLO", first
? "" : "|"), first
= 0;
6647 if (mask
& OEX_FPU_OFLO
)
6648 printf ("%sOFLO", first
? "" : "|"), first
= 0;
6649 if (mask
& OEX_FPU_DIV0
)
6650 printf ("%sDIV0", first
? "" : "|"), first
= 0;
6651 if (mask
& OEX_FPU_INVAL
)
6652 printf ("%sINVAL", first
? "" : "|");
6655 fputs ("0", stdout
);
6659 process_mips_specific (file
)
6662 Elf_Internal_Dyn
* entry
;
6663 size_t liblist_offset
= 0;
6664 size_t liblistno
= 0;
6665 size_t conflictsno
= 0;
6666 size_t options_offset
= 0;
6667 size_t conflicts_offset
= 0;
6669 /* We have a lot of special sections. Thanks SGI! */
6670 if (dynamic_segment
== NULL
)
6671 /* No information available. */
6674 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
6675 switch (entry
->d_tag
)
6677 case DT_MIPS_LIBLIST
:
6678 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
6680 case DT_MIPS_LIBLISTNO
:
6681 liblistno
= entry
->d_un
.d_val
;
6683 case DT_MIPS_OPTIONS
:
6684 options_offset
= entry
->d_un
.d_val
- loadaddr
;
6686 case DT_MIPS_CONFLICT
:
6687 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
6689 case DT_MIPS_CONFLICTNO
:
6690 conflictsno
= entry
->d_un
.d_val
;
6696 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
6698 Elf32_External_Lib
* elib
;
6701 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
6702 elib
, Elf32_External_Lib
*, "liblist");
6704 printf ("\nSection '.liblist' contains %lu entries:\n",
6705 (unsigned long) liblistno
);
6706 fputs (" Library Time Stamp Checksum Version Flags\n",
6709 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
6716 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
6717 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
6718 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
6719 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
6720 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
6722 tmp
= gmtime (&time
);
6723 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
6724 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6725 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6727 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
6728 dynamic_strings
+ liblist
.l_name
, timebuf
,
6729 liblist
.l_checksum
, liblist
.l_version
);
6731 if (liblist
.l_flags
== 0)
6742 { " EXACT_MATCH", LL_EXACT_MATCH
},
6743 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
6744 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
6745 { " EXPORTS", LL_EXPORTS
},
6746 { " DELAY_LOAD", LL_DELAY_LOAD
},
6747 { " DELTA", LL_DELTA
}
6749 int flags
= liblist
.l_flags
;
6753 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
6755 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
6757 fputs (l_flags_vals
[fcnt
].name
, stdout
);
6758 flags
^= l_flags_vals
[fcnt
].bit
;
6761 printf (" %#x", (unsigned int) flags
);
6770 if (options_offset
!= 0)
6772 Elf_External_Options
* eopt
;
6773 Elf_Internal_Shdr
* sect
= section_headers
;
6774 Elf_Internal_Options
* iopt
;
6775 Elf_Internal_Options
* option
;
6779 /* Find the section header so that we get the size. */
6780 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
6783 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
6784 Elf_External_Options
*, "options");
6786 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
6790 error (_("Out of memory"));
6797 while (offset
< sect
->sh_size
)
6799 Elf_External_Options
* eoption
;
6801 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
6803 option
->kind
= BYTE_GET (eoption
->kind
);
6804 option
->size
= BYTE_GET (eoption
->size
);
6805 option
->section
= BYTE_GET (eoption
->section
);
6806 option
->info
= BYTE_GET (eoption
->info
);
6808 offset
+= option
->size
;
6814 printf (_("\nSection '%s' contains %d entries:\n"),
6815 string_table
+ sect
->sh_name
, cnt
);
6823 switch (option
->kind
)
6826 /* This shouldn't happen. */
6827 printf (" NULL %d %lx", option
->section
, option
->info
);
6830 printf (" REGINFO ");
6831 if (elf_header
.e_machine
== EM_MIPS
)
6834 Elf32_External_RegInfo
*ereg
;
6835 Elf32_RegInfo reginfo
;
6837 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
6838 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6839 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6840 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6841 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6842 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6843 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
6845 printf ("GPR %08lx GP 0x%lx\n",
6847 (unsigned long) reginfo
.ri_gp_value
);
6848 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6849 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6850 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6855 Elf64_External_RegInfo
* ereg
;
6856 Elf64_Internal_RegInfo reginfo
;
6858 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
6859 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6860 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6861 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6862 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6863 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6864 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
6866 printf ("GPR %08lx GP 0x",
6867 reginfo
.ri_gprmask
);
6868 printf_vma (reginfo
.ri_gp_value
);
6871 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6872 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6873 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6877 case ODK_EXCEPTIONS
:
6878 fputs (" EXCEPTIONS fpe_min(", stdout
);
6879 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
6880 fputs (") fpe_max(", stdout
);
6881 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
6882 fputs (")", stdout
);
6884 if (option
->info
& OEX_PAGE0
)
6885 fputs (" PAGE0", stdout
);
6886 if (option
->info
& OEX_SMM
)
6887 fputs (" SMM", stdout
);
6888 if (option
->info
& OEX_FPDBUG
)
6889 fputs (" FPDBUG", stdout
);
6890 if (option
->info
& OEX_DISMISS
)
6891 fputs (" DISMISS", stdout
);
6894 fputs (" PAD ", stdout
);
6895 if (option
->info
& OPAD_PREFIX
)
6896 fputs (" PREFIX", stdout
);
6897 if (option
->info
& OPAD_POSTFIX
)
6898 fputs (" POSTFIX", stdout
);
6899 if (option
->info
& OPAD_SYMBOL
)
6900 fputs (" SYMBOL", stdout
);
6903 fputs (" HWPATCH ", stdout
);
6904 if (option
->info
& OHW_R4KEOP
)
6905 fputs (" R4KEOP", stdout
);
6906 if (option
->info
& OHW_R8KPFETCH
)
6907 fputs (" R8KPFETCH", stdout
);
6908 if (option
->info
& OHW_R5KEOP
)
6909 fputs (" R5KEOP", stdout
);
6910 if (option
->info
& OHW_R5KCVTL
)
6911 fputs (" R5KCVTL", stdout
);
6914 fputs (" FILL ", stdout
);
6915 /* XXX Print content of info word? */
6918 fputs (" TAGS ", stdout
);
6919 /* XXX Print content of info word? */
6922 fputs (" HWAND ", stdout
);
6923 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6924 fputs (" R4KEOP_CHECKED", stdout
);
6925 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6926 fputs (" R4KEOP_CLEAN", stdout
);
6929 fputs (" HWOR ", stdout
);
6930 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6931 fputs (" R4KEOP_CHECKED", stdout
);
6932 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6933 fputs (" R4KEOP_CLEAN", stdout
);
6936 printf (" GP_GROUP %#06lx self-contained %#06lx",
6937 option
->info
& OGP_GROUP
,
6938 (option
->info
& OGP_SELF
) >> 16);
6941 printf (" IDENT %#06lx self-contained %#06lx",
6942 option
->info
& OGP_GROUP
,
6943 (option
->info
& OGP_SELF
) >> 16);
6946 /* This shouldn't happen. */
6947 printf (" %3d ??? %d %lx",
6948 option
->kind
, option
->section
, option
->info
);
6952 len
= sizeof (*eopt
);
6953 while (len
< option
->size
)
6954 if (((char *) option
)[len
] >= ' '
6955 && ((char *) option
)[len
] < 0x7f)
6956 printf ("%c", ((char *) option
)[len
++]);
6958 printf ("\\%03o", ((char *) option
)[len
++]);
6960 fputs ("\n", stdout
);
6967 if (conflicts_offset
!= 0 && conflictsno
!= 0)
6969 Elf32_External_Conflict
* econf32
;
6970 Elf64_External_Conflict
* econf64
;
6971 Elf32_Conflict
* iconf
;
6974 if (dynamic_symbols
== NULL
)
6976 error (_("conflict list with without table"));
6980 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
6983 error (_("Out of memory"));
6989 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
6990 econf32
, Elf32_External_Conflict
*, "conflict");
6992 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6993 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
6997 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
6998 econf64
, Elf64_External_Conflict
*, "conflict");
7000 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
7001 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
7004 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
7005 puts (_(" Num: Index Value Name"));
7007 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
7009 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
7011 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
7012 print_vma (psym
->st_value
, FULL_HEX
);
7013 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
7023 get_note_type (e_type
)
7026 static char buff
[64];
7030 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
7031 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
7032 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
7033 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
7034 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
7035 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
7036 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
7037 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
7038 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
7039 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7040 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7042 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
7047 /* Note that by the ELF standard, the name field is already null byte
7048 terminated, and namesz includes the terminating null byte.
7049 I.E. the value of namesz for the name "FSF" is 4.
7051 If the value of namesz is zero, there is no name present. */
7053 process_note (pnote
)
7054 Elf32_Internal_Note
* pnote
;
7056 printf (" %s\t\t0x%08lx\t%s\n",
7057 pnote
->namesz
? pnote
->namedata
: "(NONE)",
7058 pnote
->descsz
, get_note_type (pnote
->type
));
7064 process_corefile_note_segment (file
, offset
, length
)
7069 Elf_External_Note
* pnotes
;
7070 Elf_External_Note
* external
;
7076 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
7080 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7081 (unsigned long) offset
, (unsigned long) length
);
7082 printf (_(" Owner\t\tData size\tDescription\n"));
7084 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
7086 Elf32_Internal_Note inote
;
7089 inote
.type
= BYTE_GET (external
->type
);
7090 inote
.namesz
= BYTE_GET (external
->namesz
);
7091 inote
.namedata
= external
->name
;
7092 inote
.descsz
= BYTE_GET (external
->descsz
);
7093 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
7094 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
7096 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
7098 /* Verify that name is null terminated. It appears that at least
7099 one version of Linux (RedHat 6.0) generates corefiles that don't
7100 comply with the ELF spec by failing to include the null byte in
7102 if (inote
.namedata
[inote
.namesz
] != '\0')
7104 temp
= malloc (inote
.namesz
+ 1);
7108 error (_("Out of memory\n"));
7113 strncpy (temp
, inote
.namedata
, inote
.namesz
);
7114 temp
[inote
.namesz
] = 0;
7116 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7117 inote
.namedata
= temp
;
7120 res
&= process_note (& inote
);
7135 process_corefile_note_segments (file
)
7138 Elf_Internal_Phdr
* program_headers
;
7139 Elf_Internal_Phdr
* segment
;
7143 program_headers
= (Elf_Internal_Phdr
*) malloc
7144 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
7146 if (program_headers
== NULL
)
7148 error (_("Out of memory\n"));
7153 i
= get_32bit_program_headers (file
, program_headers
);
7155 i
= get_64bit_program_headers (file
, program_headers
);
7159 free (program_headers
);
7163 for (i
= 0, segment
= program_headers
;
7164 i
< elf_header
.e_phnum
;
7167 if (segment
->p_type
== PT_NOTE
)
7168 res
&= process_corefile_note_segment (file
,
7169 (bfd_vma
) segment
->p_offset
,
7170 (bfd_vma
) segment
->p_filesz
);
7173 free (program_headers
);
7179 process_corefile_contents (file
)
7182 /* If we have not been asked to display the notes then do nothing. */
7186 /* If file is not a core file then exit. */
7187 if (elf_header
.e_type
!= ET_CORE
)
7190 /* No program headers means no NOTE segment. */
7191 if (elf_header
.e_phnum
== 0)
7193 printf (_("No note segments present in the core file.\n"));
7197 return process_corefile_note_segments (file
);
7201 process_arch_specific (file
)
7207 switch (elf_header
.e_machine
)
7210 case EM_MIPS_RS4_BE
:
7211 return process_mips_specific (file
);
7220 get_file_header (file
)
7223 /* Read in the identity array. */
7224 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
7227 /* Determine how to read the rest of the header. */
7228 switch (elf_header
.e_ident
[EI_DATA
])
7230 default: /* fall through */
7231 case ELFDATANONE
: /* fall through */
7232 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
7233 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
7236 /* For now we only support 32 bit and 64 bit ELF files. */
7237 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
7239 /* Read in the rest of the header. */
7242 Elf32_External_Ehdr ehdr32
;
7244 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
7247 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
7248 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
7249 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
7250 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
7251 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
7252 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
7253 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
7254 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
7255 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
7256 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
7257 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
7258 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
7259 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
7263 Elf64_External_Ehdr ehdr64
;
7265 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7266 we will not be able to cope with the 64bit data found in
7267 64 ELF files. Detect this now and abort before we start
7268 overwritting things. */
7269 if (sizeof (bfd_vma
) < 8)
7271 error (_("This instance of readelf has been built without support for a\n"));
7272 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7276 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
7279 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
7280 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
7281 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
7282 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
7283 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
7284 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
7285 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
7286 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
7287 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
7288 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
7289 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
7290 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
7291 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
7298 process_file (file_name
)
7302 struct stat statbuf
;
7305 if (stat (file_name
, & statbuf
) < 0)
7307 error (_("Cannot stat input file %s.\n"), file_name
);
7311 file
= fopen (file_name
, "rb");
7314 error (_("Input file %s not found.\n"), file_name
);
7318 if (! get_file_header (file
))
7320 error (_("%s: Failed to read file header\n"), file_name
);
7325 /* Initialise per file variables. */
7326 for (i
= NUM_ELEM (version_info
); i
--;)
7327 version_info
[i
] = 0;
7329 for (i
= NUM_ELEM (dynamic_info
); i
--;)
7330 dynamic_info
[i
] = 0;
7332 /* Process the file. */
7334 printf (_("\nFile: %s\n"), file_name
);
7336 if (! process_file_header ())
7342 process_section_headers (file
);
7344 process_program_headers (file
);
7346 process_dynamic_segment (file
);
7348 process_relocs (file
);
7350 process_symbol_table (file
);
7352 process_syminfo (file
);
7354 process_version_sections (file
);
7356 process_section_contents (file
);
7358 process_corefile_contents (file
);
7360 process_arch_specific (file
);
7364 if (section_headers
)
7366 free (section_headers
);
7367 section_headers
= NULL
;
7372 free (string_table
);
7373 string_table
= NULL
;
7376 if (dynamic_strings
)
7378 free (dynamic_strings
);
7379 dynamic_strings
= NULL
;
7382 if (dynamic_symbols
)
7384 free (dynamic_symbols
);
7385 dynamic_symbols
= NULL
;
7386 num_dynamic_syms
= 0;
7389 if (dynamic_syminfo
)
7391 free (dynamic_syminfo
);
7392 dynamic_syminfo
= NULL
;
7396 #ifdef SUPPORT_DISASSEMBLY
7397 /* Needed by the i386 disassembler. For extra credit, someone could
7398 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7402 print_address (unsigned int addr
, FILE * outfile
)
7404 fprintf (outfile
,"0x%8.8x", addr
);
7407 /* Needed by the i386 disassembler. */
7409 db_task_printsym (unsigned int addr
)
7411 print_address (addr
, stderr
);
7420 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7421 setlocale (LC_MESSAGES
, "");
7423 bindtextdomain (PACKAGE
, LOCALEDIR
);
7424 textdomain (PACKAGE
);
7426 parse_args (argc
, argv
);
7428 if (optind
< (argc
- 1))
7431 while (optind
< argc
)
7432 process_file (argv
[optind
++]);
7434 if (dump_sects
!= NULL
)