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"
77 #ifdef ANSI_PROTOTYPES
83 char * program_name
= "readelf";
84 unsigned int dynamic_addr
;
85 bfd_size_type dynamic_size
;
86 unsigned int rela_addr
;
87 unsigned int rela_size
;
88 char * dynamic_strings
;
90 unsigned long num_dynamic_syms
;
91 Elf_Internal_Sym
* dynamic_symbols
;
92 Elf_Internal_Syminfo
* dynamic_syminfo
;
93 unsigned long dynamic_syminfo_offset
;
94 unsigned int dynamic_syminfo_nent
;
95 char program_interpreter
[64];
96 int dynamic_info
[DT_JMPREL
+ 1];
99 Elf_Internal_Ehdr elf_header
;
100 Elf_Internal_Shdr
* section_headers
;
101 Elf_Internal_Dyn
* dynamic_segment
;
108 int do_using_dynamic
;
115 int do_debug_abbrevs
;
117 int do_debug_pubnames
;
118 int do_debug_aranges
;
123 /* A dynamic array of flags indicating which sections require dumping. */
124 char * dump_sects
= NULL
;
125 unsigned int num_dump_sects
= 0;
127 #define HEX_DUMP (1 << 0)
128 #define DISASS_DUMP (1 << 1)
129 #define DEBUG_DUMP (1 << 2)
131 /* How to rpint a vma value. */
132 typedef enum print_mode
144 /* Forward declarations for dumb compilers. */
145 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
146 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
147 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
148 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
149 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
150 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
151 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
152 static const char * get_dynamic_type
PARAMS ((unsigned long));
153 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
154 static char * get_file_type
PARAMS ((unsigned));
155 static char * get_machine_name
PARAMS ((unsigned));
156 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
157 static const char * get_mips_segment_type
PARAMS ((unsigned long));
158 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
159 static const char * get_segment_type
PARAMS ((unsigned long));
160 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
161 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
162 static const char * get_section_type_name
PARAMS ((unsigned int));
163 static const char * get_symbol_binding
PARAMS ((unsigned int));
164 static const char * get_symbol_type
PARAMS ((unsigned int));
165 static const char * get_symbol_visibility
PARAMS ((unsigned int));
166 static const char * get_symbol_index_type
PARAMS ((unsigned int));
167 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
168 static void usage
PARAMS ((void));
169 static void parse_args
PARAMS ((int, char **));
170 static int process_file_header
PARAMS ((void));
171 static int process_program_headers
PARAMS ((FILE *));
172 static int process_section_headers
PARAMS ((FILE *));
173 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
174 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
175 static int process_dynamic_segment
PARAMS ((FILE *));
176 static int process_symbol_table
PARAMS ((FILE *));
177 static int process_section_contents
PARAMS ((FILE *));
178 static void process_file
PARAMS ((char *));
179 static int process_relocs
PARAMS ((FILE *));
180 static int process_version_sections
PARAMS ((FILE *));
181 static char * get_ver_flags
PARAMS ((unsigned int));
182 static int get_32bit_section_headers
PARAMS ((FILE *));
183 static int get_64bit_section_headers
PARAMS ((FILE *));
184 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
185 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
186 static int get_file_header
PARAMS ((FILE *));
187 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
188 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
189 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
190 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
191 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
192 #ifdef SUPPORT_DISASSEMBLY
193 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
195 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
196 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
197 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
198 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
199 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
200 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
201 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
202 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
203 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
204 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
205 static void reset_state_machine
PARAMS ((int));
206 static char * get_TAG_name
PARAMS ((unsigned long));
207 static char * get_AT_name
PARAMS ((unsigned long));
208 static char * get_FORM_name
PARAMS ((unsigned long));
209 static void free_abbrevs
PARAMS ((void));
210 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
211 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
212 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
213 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
214 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int));
215 static void request_dump
PARAMS ((unsigned int, char));
216 static const char * get_elf_class
PARAMS ((unsigned char));
217 static const char * get_data_encoding
PARAMS ((unsigned char));
218 static const char * get_osabi_name
PARAMS ((unsigned char));
219 static int guess_is_rela
PARAMS ((unsigned long));
220 static char * get_note_type
PARAMS ((unsigned int));
221 static int process_note
PARAMS ((Elf32_Internal_Note
*));
222 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
223 static int process_corefile_note_segments
PARAMS ((FILE *));
224 static int process_corefile_contents
PARAMS ((FILE *));
226 typedef int Elf32_Word
;
234 #define SECTION_NAME(X) (string_table + (X)->sh_name)
236 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
238 #define BYTE_GET(field) byte_get (field, sizeof (field))
240 /* If we can support a 64 bit data type then BFD64 should be defined
241 and sizeof (bfd_vma) == 8. In this case when translating from an
242 external 8 byte field to an internal field, we can assume that the
243 internal field is also 8 bytes wide and so we can extact all the data.
244 If, however, BFD64 is not defined, then we must assume that the
245 internal data structure only has 4 byte wide fields that are the
246 equivalent of the 8 byte wide external counterparts, and so we must
247 truncate the data. */
249 #define BYTE_GET8(field) byte_get (field, -8)
251 #define BYTE_GET8(field) byte_get (field, 8)
254 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
256 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
257 if (fseek (file, offset, SEEK_SET)) \
259 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
263 var = (type) malloc (size); \
267 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
271 if (fread (var, size, 1, file) != 1) \
273 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
280 #define GET_DATA(offset, var, reason) \
281 if (fseek (file, offset, SEEK_SET)) \
283 error (_("Unable to seek to %x for %s\n"), offset, reason); \
286 else if (fread (& var, sizeof (var), 1, file) != 1) \
288 error (_("Unable to read data at %x for %s\n"), offset, reason); \
292 #define GET_ELF_SYMBOLS(file, offset, size) \
293 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
294 : get_64bit_elf_symbols (file, offset, size))
297 #ifdef ANSI_PROTOTYPES
299 error (const char * message
, ...)
303 fprintf (stderr
, _("%s: Error: "), program_name
);
304 va_start (args
, message
);
305 vfprintf (stderr
, message
, args
);
311 warn (const char * message
, ...)
315 fprintf (stderr
, _("%s: Warning: "), program_name
);
316 va_start (args
, message
);
317 vfprintf (stderr
, message
, args
);
329 fprintf (stderr
, _("%s: Error: "), program_name
);
331 message
= va_arg (args
, char *);
332 vfprintf (stderr
, message
, args
);
344 fprintf (stderr
, _("%s: Warning: "), program_name
);
346 message
= va_arg (args
, char *);
347 vfprintf (stderr
, message
, args
);
354 byte_get_little_endian (field
, size
)
355 unsigned char * field
;
364 return ((unsigned int) (field
[0]))
365 | (((unsigned int) (field
[1])) << 8);
368 /* We want to extract data from an 8 byte wide field and
369 place it into a 4 byte wide field. Since this is a little
370 endian source we can juts use the 4 byte extraction code. */
373 return ((unsigned long) (field
[0]))
374 | (((unsigned long) (field
[1])) << 8)
375 | (((unsigned long) (field
[2])) << 16)
376 | (((unsigned long) (field
[3])) << 24);
380 /* This is a special case, generated by the BYTE_GET8 macro.
381 It means that we are loading an 8 byte value from a field
382 in an external structure into an 8 byte value in a field
383 in an internal strcuture. */
384 return ((bfd_vma
) (field
[0]))
385 | (((bfd_vma
) (field
[1])) << 8)
386 | (((bfd_vma
) (field
[2])) << 16)
387 | (((bfd_vma
) (field
[3])) << 24)
388 | (((bfd_vma
) (field
[4])) << 32)
389 | (((bfd_vma
) (field
[5])) << 40)
390 | (((bfd_vma
) (field
[6])) << 48)
391 | (((bfd_vma
) (field
[7])) << 56);
394 error (_("Unhandled data length: %d\n"), size
);
399 /* Print a VMA value. */
401 print_vma (vma
, mode
)
411 case FULL_HEX
: printf ("0x"); /* drop through */
412 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
413 case PREFIX_HEX
: printf ("0x"); /* drop through */
414 case HEX
: printf ("%lx", (unsigned long) vma
); break;
415 case DEC
: printf ("%ld", (unsigned long) vma
); break;
416 case DEC_5
: printf ("%5ld", (long) vma
); break;
417 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
438 #if BFD_HOST_64BIT_LONG
441 if (_bfd_int64_high (vma
))
442 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
444 printf ("%lx", _bfd_int64_low (vma
));
449 #if BFD_HOST_64BIT_LONG
452 if (_bfd_int64_high (vma
))
454 printf ("++%ld", _bfd_int64_low (vma
));
456 printf ("%ld", _bfd_int64_low (vma
));
461 #if BFD_HOST_64BIT_LONG
462 printf ("%5ld", vma
);
464 if (_bfd_int64_high (vma
))
466 printf ("++%ld", _bfd_int64_low (vma
));
468 printf ("%5ld", _bfd_int64_low (vma
));
473 #if BFD_HOST_64BIT_LONG
476 if (_bfd_int64_high (vma
))
478 printf ("++%lu", _bfd_int64_low (vma
));
480 printf ("%lu", _bfd_int64_low (vma
));
489 byte_get_big_endian (field
, size
)
490 unsigned char * field
;
499 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
502 return ((unsigned long) (field
[3]))
503 | (((unsigned long) (field
[2])) << 8)
504 | (((unsigned long) (field
[1])) << 16)
505 | (((unsigned long) (field
[0])) << 24);
508 /* Although we are extracing data from an 8 byte wide field, we
509 are returning only 4 bytes of data. */
510 return ((unsigned long) (field
[7]))
511 | (((unsigned long) (field
[6])) << 8)
512 | (((unsigned long) (field
[5])) << 16)
513 | (((unsigned long) (field
[4])) << 24);
517 /* This is a special case, generated by the BYTE_GET8 macro.
518 It means that we are loading an 8 byte value from a field
519 in an external structure into an 8 byte value in a field
520 in an internal strcuture. */
521 return ((bfd_vma
) (field
[7]))
522 | (((bfd_vma
) (field
[6])) << 8)
523 | (((bfd_vma
) (field
[5])) << 16)
524 | (((bfd_vma
) (field
[4])) << 24)
525 | (((bfd_vma
) (field
[3])) << 32)
526 | (((bfd_vma
) (field
[2])) << 40)
527 | (((bfd_vma
) (field
[1])) << 48)
528 | (((bfd_vma
) (field
[0])) << 56);
532 error (_("Unhandled data length: %d\n"), size
);
538 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
540 guess_is_rela (e_machine
)
541 unsigned long e_machine
;
545 /* Targets that use REL relocations. */
556 /* Targets that use RELA relocations. */
564 case EM_CYGNUS_MN10200
:
565 case EM_CYGNUS_MN10300
:
591 warn (_("Don't know about relocations on this machine architecture\n"));
596 /* Display the contents of the relocation data found at the specified offset. */
598 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
600 unsigned long rel_offset
;
601 unsigned long rel_size
;
602 Elf_Internal_Sym
* symtab
;
608 Elf_Internal_Rel
* rels
;
609 Elf_Internal_Rela
* relas
;
612 if (is_rela
== UNKNOWN
)
613 is_rela
= guess_is_rela (elf_header
.e_machine
);
619 Elf32_External_Rela
* erelas
;
621 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
622 Elf32_External_Rela
*, "relocs");
624 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
626 relas
= (Elf_Internal_Rela
*)
627 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
631 error(_("out of memory parsing relocs"));
635 for (i
= 0; i
< rel_size
; i
++)
637 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
638 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
639 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
644 rels
= (Elf_Internal_Rel
*) relas
;
648 Elf64_External_Rela
* erelas
;
650 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
651 Elf64_External_Rela
*, "relocs");
653 rel_size
= rel_size
/ sizeof (Elf64_External_Rela
);
655 relas
= (Elf_Internal_Rela
*)
656 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
660 error(_("out of memory parsing relocs"));
664 for (i
= 0; i
< rel_size
; i
++)
666 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
667 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
668 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
673 rels
= (Elf_Internal_Rel
*) relas
;
680 Elf32_External_Rel
* erels
;
682 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
683 Elf32_External_Rel
*, "relocs");
685 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
687 rels
= (Elf_Internal_Rel
*)
688 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
692 error(_("out of memory parsing relocs"));
696 for (i
= 0; i
< rel_size
; i
++)
698 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
699 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
704 relas
= (Elf_Internal_Rela
*) rels
;
708 Elf64_External_Rel
* erels
;
710 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
711 Elf64_External_Rel
*, "relocs");
713 rel_size
= rel_size
/ sizeof (Elf64_External_Rel
);
715 rels
= (Elf_Internal_Rel
*)
716 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
720 error(_("out of memory parsing relocs"));
724 for (i
= 0; i
< rel_size
; i
++)
726 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
727 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
732 relas
= (Elf_Internal_Rela
*) rels
;
738 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
741 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
743 for (i
= 0; i
< rel_size
; i
++)
748 bfd_vma symtab_index
;
753 offset
= relas
[i
].r_offset
;
754 info
= relas
[i
].r_info
;
758 offset
= rels
[i
].r_offset
;
759 info
= rels
[i
].r_info
;
764 type
= ELF32_R_TYPE (info
);
765 symtab_index
= ELF32_R_SYM (info
);
769 if (elf_header
.e_machine
== EM_SPARCV9
)
770 type
= ELF64_R_TYPE_ID (info
);
772 type
= ELF64_R_TYPE (info
);
773 /* The #ifdef BFD64 below is to prevent a compile time warning.
774 We know that if we do not have a 64 bit data type that we
775 will never execute this code anyway. */
777 symtab_index
= ELF64_R_SYM (info
);
781 #ifdef _bfd_int64_low
782 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
784 printf (" %8.8lx %5.5lx ", offset
, info
);
787 switch (elf_header
.e_machine
)
794 rtype
= elf_m32r_reloc_type (type
);
799 rtype
= elf_i386_reloc_type (type
);
803 rtype
= elf_m68k_reloc_type (type
);
807 rtype
= elf_i960_reloc_type (type
);
811 rtype
= elf_avr_reloc_type (type
);
818 rtype
= elf_sparc_reloc_type (type
);
822 rtype
= v850_reloc_type (type
);
826 rtype
= elf_d10v_reloc_type (type
);
830 rtype
= elf_d30v_reloc_type (type
);
834 rtype
= elf_sh_reloc_type (type
);
837 case EM_CYGNUS_MN10300
:
838 rtype
= elf_mn10300_reloc_type (type
);
841 case EM_CYGNUS_MN10200
:
842 rtype
= elf_mn10200_reloc_type (type
);
846 rtype
= elf_fr30_reloc_type (type
);
850 rtype
= elf_mcore_reloc_type (type
);
854 rtype
= elf_ppc_reloc_type (type
);
859 rtype
= elf_mips_reloc_type (type
);
863 rtype
= elf_alpha_reloc_type (type
);
867 rtype
= elf_arm_reloc_type (type
);
871 rtype
= elf_arc_reloc_type (type
);
875 rtype
= elf_hppa_reloc_type (type
);
879 rtype
= elf_pj_reloc_type (type
);
884 #ifdef _bfd_int64_low
885 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
887 printf (_("unrecognised: %-7lx"), type
);
890 printf ("%-21.21s", rtype
);
896 if (symtab_index
>= nsyms
)
897 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
900 Elf_Internal_Sym
* psym
;
902 psym
= symtab
+ symtab_index
;
905 print_vma (psym
->st_value
, LONG_HEX
);
908 if (psym
->st_name
== 0)
910 SECTION_NAME (section_headers
+ psym
->st_shndx
));
911 else if (strtab
== NULL
)
912 printf (_("<string table index %3ld>"), psym
->st_name
);
914 printf ("%-25.25s", strtab
+ psym
->st_name
);
917 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
923 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
924 print_vma (relas
[i
].r_addend
, LONG_HEX
);
927 if (elf_header
.e_machine
== EM_SPARCV9
928 && !strcmp (rtype
, "R_SPARC_OLO10"))
929 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
940 get_mips_dynamic_type (type
)
945 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
946 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
947 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
948 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
949 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
950 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
951 case DT_MIPS_MSYM
: return "MIPS_MSYM";
952 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
953 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
954 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
955 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
956 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
957 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
958 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
959 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
960 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
961 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
962 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
963 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
964 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
965 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
966 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
967 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
968 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
969 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
970 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
971 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
972 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
973 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
974 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
975 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
976 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
977 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
978 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
979 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
980 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
981 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
982 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
983 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
984 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
985 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
986 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
987 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
994 get_sparc64_dynamic_type (type
)
999 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1006 get_parisc_dynamic_type (type
)
1011 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1012 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1013 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1014 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1015 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1016 case DT_HP_PREINIT
: return "HP_PREINIT";
1017 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1018 case DT_HP_NEEDED
: return "HP_NEEDED";
1019 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1020 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1021 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1022 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1023 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1030 get_dynamic_type (type
)
1033 static char buff
[32];
1037 case DT_NULL
: return "NULL";
1038 case DT_NEEDED
: return "NEEDED";
1039 case DT_PLTRELSZ
: return "PLTRELSZ";
1040 case DT_PLTGOT
: return "PLTGOT";
1041 case DT_HASH
: return "HASH";
1042 case DT_STRTAB
: return "STRTAB";
1043 case DT_SYMTAB
: return "SYMTAB";
1044 case DT_RELA
: return "RELA";
1045 case DT_RELASZ
: return "RELASZ";
1046 case DT_RELAENT
: return "RELAENT";
1047 case DT_STRSZ
: return "STRSZ";
1048 case DT_SYMENT
: return "SYMENT";
1049 case DT_INIT
: return "INIT";
1050 case DT_FINI
: return "FINI";
1051 case DT_SONAME
: return "SONAME";
1052 case DT_RPATH
: return "RPATH";
1053 case DT_SYMBOLIC
: return "SYMBOLIC";
1054 case DT_REL
: return "REL";
1055 case DT_RELSZ
: return "RELSZ";
1056 case DT_RELENT
: return "RELENT";
1057 case DT_PLTREL
: return "PLTREL";
1058 case DT_DEBUG
: return "DEBUG";
1059 case DT_TEXTREL
: return "TEXTREL";
1060 case DT_JMPREL
: return "JMPREL";
1061 case DT_BIND_NOW
: return "BIND_NOW";
1062 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1063 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1064 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1065 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1066 case DT_RUNPATH
: return "RUNPATH";
1067 case DT_FLAGS
: return "FLAGS";
1069 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1070 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1072 case DT_PLTPADSZ
: return "PLTPADSZ";
1073 case DT_MOVEENT
: return "MOVEENT";
1074 case DT_MOVESZ
: return "MOVESZ";
1075 case DT_FEATURE_1
: return "FEATURE_1";
1076 case DT_POSFLAG_1
: return "POSFLAG_1";
1077 case DT_SYMINSZ
: return "SYMINSZ";
1078 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1080 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1081 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1083 case DT_VERSYM
: return "VERSYM";
1085 case DT_RELACOUNT
: return "RELACOUNT";
1086 case DT_RELCOUNT
: return "RELCOUNT";
1087 case DT_FLAGS_1
: return "FLAGS_1";
1088 case DT_VERDEF
: return "VERDEF";
1089 case DT_VERDEFNUM
: return "VERDEFNUM";
1090 case DT_VERNEED
: return "VERNEED";
1091 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1093 case DT_AUXILIARY
: return "AUXILARY";
1094 case DT_USED
: return "USED";
1095 case DT_FILTER
: return "FILTER";
1098 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1100 const char * result
;
1102 switch (elf_header
.e_machine
)
1105 case EM_MIPS_RS4_BE
:
1106 result
= get_mips_dynamic_type (type
);
1109 result
= get_sparc64_dynamic_type (type
);
1119 sprintf (buff
, _("Processor Specific: %lx"), type
);
1121 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1123 const char * result
;
1125 switch (elf_header
.e_machine
)
1128 result
= get_parisc_dynamic_type (type
);
1138 sprintf (buff
, _("Operating System specific: %lx"), type
);
1141 sprintf (buff
, _("<unknown>: %lx"), type
);
1148 get_file_type (e_type
)
1151 static char buff
[32];
1155 case ET_NONE
: return _("NONE (None)");
1156 case ET_REL
: return _("REL (Relocatable file)");
1157 case ET_EXEC
: return _("EXEC (Executable file)");
1158 case ET_DYN
: return _("DYN (Shared object file)");
1159 case ET_CORE
: return _("CORE (Core file)");
1162 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1163 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1164 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1165 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1167 sprintf (buff
, _("<unknown>: %x"), e_type
);
1173 get_machine_name (e_machine
)
1176 static char buff
[64]; /* XXX */
1180 case EM_NONE
: return _("None");
1181 case EM_M32
: return "WE32100";
1182 case EM_SPARC
: return "Sparc";
1183 case EM_386
: return "Intel 80386";
1184 case EM_68K
: return "MC68000";
1185 case EM_88K
: return "MC88000";
1186 case EM_486
: return "Intel 80486";
1187 case EM_860
: return "Intel 80860";
1188 case EM_MIPS
: return "MIPS R3000";
1189 case EM_S370
: return "IBM System/370";
1190 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1191 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1192 case EM_PARISC
: return "HPPA";
1193 case EM_PPC_OLD
: return "Power PC (old)";
1194 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1195 case EM_960
: return "Intel 90860";
1196 case EM_PPC
: return "PowerPC";
1197 case EM_V800
: return "NEC V800";
1198 case EM_FR20
: return "Fujitsu FR20";
1199 case EM_RH32
: return "TRW RH32";
1200 case EM_MCORE
: return "MCORE";
1201 case EM_ARM
: return "ARM";
1202 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1203 case EM_SH
: return "Hitachi SH";
1204 case EM_SPARCV9
: return "Sparc v9";
1205 case EM_TRICORE
: return "Siemens Tricore";
1206 case EM_ARC
: return "Argonaut RISC Core";
1207 case EM_H8_300
: return "Hitachi H8/300";
1208 case EM_H8_300H
: return "Hitachi H8/300H";
1209 case EM_H8S
: return "Hitachi H8S";
1210 case EM_H8_500
: return "Hitachi H8/500";
1211 case EM_IA_64
: return "Intel IA-64";
1212 case EM_MIPS_X
: return "Stanford MIPS-X";
1213 case EM_COLDFIRE
: return "Motorola Coldfire";
1214 case EM_68HC12
: return "Motorola M68HC12";
1215 case EM_ALPHA
: return "Alpha";
1216 case EM_CYGNUS_D10V
: return "d10v";
1217 case EM_CYGNUS_D30V
: return "d30v";
1218 case EM_CYGNUS_ARC
: return "Arc";
1219 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1220 case EM_CYGNUS_V850
: return "NEC v850";
1221 case EM_CYGNUS_MN10300
: return "mn10300";
1222 case EM_CYGNUS_MN10200
: return "mn10200";
1223 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1224 case EM_PJ
: return "picoJava";
1225 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1226 case EM_PCP
: return "Siemens PCP";
1227 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1228 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1229 case EM_STARCORE
: return "Motorola Star*Core processor";
1230 case EM_ME16
: return "Toyota ME16 processor";
1231 case EM_ST100
: return "STMicroelectronics ST100 processor";
1232 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1233 case EM_FX66
: return "Siemens FX66 microcontroller";
1234 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1235 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1236 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1237 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1238 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1239 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1240 case EM_SVX
: return "Silicon Graphics SVx";
1241 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1242 case EM_VAX
: return "Digital VAX";
1244 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1250 get_machine_flags (e_flags
, e_machine
)
1254 static char buf
[1024];
1266 if (e_flags
& EF_CPU32
)
1267 strcat (buf
, ", cpu32");
1271 if (e_flags
& EF_PPC_EMB
)
1272 strcat (buf
, ", emb");
1274 if (e_flags
& EF_PPC_RELOCATABLE
)
1275 strcat (buf
, ", relocatable");
1277 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1278 strcat (buf
, ", relocatable-lib");
1281 case EM_CYGNUS_V850
:
1282 switch (e_flags
& EF_V850_ARCH
)
1285 strcat (buf
, ", v850e");
1288 strcat (buf
, ", v850ea");
1291 strcat (buf
, ", v850");
1294 strcat (buf
, ", unknown v850 architecture variant");
1299 case EM_CYGNUS_M32R
:
1300 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1301 strcat (buf
, ", m32r");
1306 case EM_MIPS_RS4_BE
:
1307 if (e_flags
& EF_MIPS_NOREORDER
)
1308 strcat (buf
, ", noreorder");
1310 if (e_flags
& EF_MIPS_PIC
)
1311 strcat (buf
, ", pic");
1313 if (e_flags
& EF_MIPS_CPIC
)
1314 strcat (buf
, ", cpic");
1316 if (e_flags
& EF_MIPS_ABI2
)
1317 strcat (buf
, ", abi2");
1319 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1320 strcat (buf
, ", mips1");
1322 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1323 strcat (buf
, ", mips2");
1325 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1326 strcat (buf
, ", mips3");
1328 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1329 strcat (buf
, ", mips4");
1333 if (e_flags
& EF_SPARC_32PLUS
)
1334 strcat (buf
, ", v8+");
1336 if (e_flags
& EF_SPARC_SUN_US1
)
1337 strcat (buf
, ", ultrasparcI");
1339 if (e_flags
& EF_SPARC_SUN_US3
)
1340 strcat (buf
, ", ultrasparcIII");
1342 if (e_flags
& EF_SPARC_HAL_R1
)
1343 strcat (buf
, ", halr1");
1345 if (e_flags
& EF_SPARC_LEDATA
)
1346 strcat (buf
, ", ledata");
1348 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1349 strcat (buf
, ", tso");
1351 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1352 strcat (buf
, ", pso");
1354 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1355 strcat (buf
, ", rmo");
1359 switch (e_flags
& EF_PARISC_ARCH
)
1361 case EFA_PARISC_1_0
:
1362 strcpy (buf
, ", PA-RISC 1.0");
1364 case EFA_PARISC_1_1
:
1365 strcpy (buf
, ", PA-RISC 1.1");
1367 case EFA_PARISC_2_0
:
1368 strcpy (buf
, ", PA-RISC 2.0");
1373 if (e_flags
& EF_PARISC_TRAPNIL
)
1374 strcat (buf
, ", trapnil");
1375 if (e_flags
& EF_PARISC_EXT
)
1376 strcat (buf
, ", ext");
1377 if (e_flags
& EF_PARISC_LSB
)
1378 strcat (buf
, ", lsb");
1379 if (e_flags
& EF_PARISC_WIDE
)
1380 strcat (buf
, ", wide");
1381 if (e_flags
& EF_PARISC_NO_KABP
)
1382 strcat (buf
, ", no kabp");
1383 if (e_flags
& EF_PARISC_LAZYSWAP
)
1384 strcat (buf
, ", lazyswap");
1388 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1389 strcat (buf
, ", new calling convention");
1391 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1392 strcat (buf
, ", gnu calling convention");
1401 get_mips_segment_type (type
)
1406 case PT_MIPS_REGINFO
:
1408 case PT_MIPS_RTPROC
:
1410 case PT_MIPS_OPTIONS
:
1420 get_parisc_segment_type (type
)
1425 case PT_HP_TLS
: return "HP_TLS";
1426 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1427 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1428 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1429 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1430 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1431 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1432 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1433 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1434 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1435 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1436 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1437 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1438 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1447 get_segment_type (p_type
)
1448 unsigned long p_type
;
1450 static char buff
[32];
1454 case PT_NULL
: return "NULL";
1455 case PT_LOAD
: return "LOAD";
1456 case PT_DYNAMIC
: return "DYNAMIC";
1457 case PT_INTERP
: return "INTERP";
1458 case PT_NOTE
: return "NOTE";
1459 case PT_SHLIB
: return "SHLIB";
1460 case PT_PHDR
: return "PHDR";
1463 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1465 const char * result
;
1467 switch (elf_header
.e_machine
)
1470 case EM_MIPS_RS4_BE
:
1471 result
= get_mips_segment_type (p_type
);
1474 result
= get_parisc_segment_type (p_type
);
1484 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1486 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1488 const char * result
;
1490 switch (elf_header
.e_machine
)
1493 result
= get_parisc_segment_type (p_type
);
1503 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1506 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1513 get_mips_section_type_name (sh_type
)
1514 unsigned int sh_type
;
1518 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1519 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1520 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1521 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1522 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1523 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1524 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1525 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1526 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1527 case SHT_MIPS_RELD
: return "MIPS_RELD";
1528 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1529 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1530 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1531 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1532 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1533 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1534 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1535 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1536 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1537 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1538 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1539 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1540 case SHT_MIPS_LINE
: return "MIPS_LINE";
1541 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1542 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1543 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1544 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1545 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1546 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1547 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1548 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1549 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1550 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1551 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1552 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1553 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1554 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1555 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1556 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1564 get_parisc_section_type_name (sh_type
)
1565 unsigned int sh_type
;
1569 case SHT_PARISC_EXT
: return "PARISC_EXT";
1570 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1571 case SHT_PARISC_DOC
: return "PARISC_DOC";
1579 get_section_type_name (sh_type
)
1580 unsigned int sh_type
;
1582 static char buff
[32];
1586 case SHT_NULL
: return "NULL";
1587 case SHT_PROGBITS
: return "PROGBITS";
1588 case SHT_SYMTAB
: return "SYMTAB";
1589 case SHT_STRTAB
: return "STRTAB";
1590 case SHT_RELA
: return "RELA";
1591 case SHT_HASH
: return "HASH";
1592 case SHT_DYNAMIC
: return "DYNAMIC";
1593 case SHT_NOTE
: return "NOTE";
1594 case SHT_NOBITS
: return "NOBITS";
1595 case SHT_REL
: return "REL";
1596 case SHT_SHLIB
: return "SHLIB";
1597 case SHT_DYNSYM
: return "DYNSYM";
1598 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1599 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1600 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1601 case SHT_GNU_verdef
: return "VERDEF";
1602 case SHT_GNU_verneed
: return "VERNEED";
1603 case SHT_GNU_versym
: return "VERSYM";
1604 case 0x6ffffff0: return "VERSYM";
1605 case 0x6ffffffc: return "VERDEF";
1606 case 0x7ffffffd: return "AUXILIARY";
1607 case 0x7fffffff: return "FILTER";
1610 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1612 const char * result
;
1614 switch (elf_header
.e_machine
)
1617 case EM_MIPS_RS4_BE
:
1618 result
= get_mips_section_type_name (sh_type
);
1621 result
= get_parisc_section_type_name (sh_type
);
1631 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1633 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1634 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1635 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1636 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1638 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1644 struct option options
[] =
1646 {"all", no_argument
, 0, 'a'},
1647 {"file-header", no_argument
, 0, 'h'},
1648 {"program-headers", no_argument
, 0, 'l'},
1649 {"headers", no_argument
, 0, 'e'},
1650 {"histogram", no_argument
, 0, 'I'},
1651 {"segments", no_argument
, 0, 'l'},
1652 {"sections", no_argument
, 0, 'S'},
1653 {"section-headers", no_argument
, 0, 'S'},
1654 {"symbols", no_argument
, 0, 's'},
1655 {"syms", no_argument
, 0, 's'},
1656 {"relocs", no_argument
, 0, 'r'},
1657 {"notes", no_argument
, 0, 'n'},
1658 {"dynamic", no_argument
, 0, 'd'},
1659 {"arch-specific", no_argument
, 0, 'A'},
1660 {"version-info", no_argument
, 0, 'V'},
1661 {"use-dynamic", no_argument
, 0, 'D'},
1662 {"hex-dump", required_argument
, 0, 'x'},
1663 {"debug-dump", optional_argument
, 0, 'w'},
1664 #ifdef SUPPORT_DISASSEMBLY
1665 {"instruction-dump", required_argument
, 0, 'i'},
1668 {"version", no_argument
, 0, 'v'},
1669 {"help", no_argument
, 0, 'H'},
1670 {0, no_argument
, 0, 0}
1676 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1677 fprintf (stdout
, _(" Options are:\n"));
1678 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1679 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1680 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1681 fprintf (stdout
, _(" Display the program headers\n"));
1682 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1683 fprintf (stdout
, _(" Display the sections' header\n"));
1684 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1685 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1686 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1687 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1688 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1689 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1690 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1691 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1692 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1693 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1694 fprintf (stdout
, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1695 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1696 #ifdef SUPPORT_DISASSEMBLY
1697 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1698 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1700 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1701 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1702 fprintf (stdout
, _(" -H or --help Display this information\n"));
1703 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
1709 request_dump (section
, type
)
1710 unsigned int section
;
1713 if (section
>= num_dump_sects
)
1715 char * new_dump_sects
;
1717 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1719 if (new_dump_sects
== NULL
)
1720 error (_("Out of memory allocating dump request table."));
1723 /* Copy current flag settings. */
1724 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1728 dump_sects
= new_dump_sects
;
1729 num_dump_sects
= section
+ 1;
1734 dump_sects
[section
] |= type
;
1740 parse_args (argc
, argv
)
1749 while ((c
= getopt_long
1750 (argc
, argv
, "ersahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
1785 do_using_dynamic
++;
1813 section
= strtoul (optarg
, & cp
, 0);
1814 if (! * cp
&& section
>= 0)
1816 request_dump (section
, HEX_DUMP
);
1836 do_debug_abbrevs
= 1;
1846 do_debug_pubnames
= 1;
1851 do_debug_aranges
= 1;
1855 warn (_("Unrecognised debug option '%s'\n"), optarg
);
1860 #ifdef SUPPORT_DISASSEMBLY
1863 section
= strtoul (optarg
, & cp
, 0);
1864 if (! * cp
&& section
>= 0)
1866 request_dump (section
, DISASS_DUMP
);
1872 print_version (program_name
);
1879 /* xgettext:c-format */
1880 error (_("Invalid option '-%c'\n"), c
);
1887 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
1888 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
1889 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
1893 warn (_("Nothing to do.\n"));
1899 get_elf_class (elf_class
)
1900 unsigned char elf_class
;
1902 static char buff
[32];
1906 case ELFCLASSNONE
: return _("none");
1907 case ELFCLASS32
: return _("ELF32");
1908 case ELFCLASS64
: return _("ELF64");
1910 sprintf (buff
, _("<unknown: %x>"), elf_class
);
1916 get_data_encoding (encoding
)
1917 unsigned char encoding
;
1919 static char buff
[32];
1923 case ELFDATANONE
: return _("none");
1924 case ELFDATA2LSB
: return _("2's complement, little endian");
1925 case ELFDATA2MSB
: return _("2's complement, big endian");
1927 sprintf (buff
, _("<unknown: %x>"), encoding
);
1933 get_osabi_name (osabi
)
1934 unsigned char osabi
;
1936 static char buff
[32];
1940 case ELFOSABI_SYSV
: return _("UNIX - System V");
1941 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
1942 case ELFOSABI_LINUX
: return _("UNIX - Linux");
1943 case ELFOSABI_STANDALONE
: return _("Standalone App");
1944 case ELFOSABI_ARM
: return _("ARM");
1946 sprintf (buff
, _("<unknown: %x>"), osabi
);
1951 /* Decode the data held in 'elf_header'. */
1953 process_file_header ()
1955 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
1956 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
1957 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
1958 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1961 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1969 printf (_("ELF Header:\n"));
1970 printf (_(" Magic: "));
1971 for (i
= 0; i
< EI_NIDENT
; i
++)
1972 printf ("%2.2x ", elf_header
.e_ident
[i
]);
1974 printf (_(" Class: %s\n"),
1975 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
1976 printf (_(" Data: %s\n"),
1977 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
1978 printf (_(" Version: %d %s\n"),
1979 elf_header
.e_ident
[EI_VERSION
],
1980 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
1982 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
1985 printf (_(" OS/ABI: %s\n"),
1986 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
1987 printf (_(" ABI Version: %d\n"),
1988 elf_header
.e_ident
[EI_ABIVERSION
]);
1989 printf (_(" Type: %s\n"),
1990 get_file_type (elf_header
.e_type
));
1991 printf (_(" Machine: %s\n"),
1992 get_machine_name (elf_header
.e_machine
));
1993 printf (_(" Version: 0x%lx\n"),
1994 (unsigned long) elf_header
.e_version
);
1996 printf (_(" Entry point address: "));
1997 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
1998 printf (_("\n Start of program headers: "));
1999 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2000 printf (_(" (bytes into file)\n Start of section headers: "));
2001 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2002 printf (_(" (bytes into file)\n"));
2004 printf (_(" Flags: 0x%lx%s\n"),
2005 (unsigned long) elf_header
.e_flags
,
2006 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2007 printf (_(" Size of this header: %ld (bytes)\n"),
2008 (long) elf_header
.e_ehsize
);
2009 printf (_(" Size of program headers: %ld (bytes)\n"),
2010 (long) elf_header
.e_phentsize
);
2011 printf (_(" Number of program headers: %ld\n"),
2012 (long) elf_header
.e_phnum
);
2013 printf (_(" Size of section headers: %ld (bytes)\n"),
2014 (long) elf_header
.e_shentsize
);
2015 printf (_(" Number of section headers: %ld\n"),
2016 (long) elf_header
.e_shnum
);
2017 printf (_(" Section header string table index: %ld\n"),
2018 (long) elf_header
.e_shstrndx
);
2026 get_32bit_program_headers (file
, program_headers
)
2028 Elf_Internal_Phdr
* program_headers
;
2030 Elf32_External_Phdr
* phdrs
;
2031 Elf32_External_Phdr
* external
;
2032 Elf32_Internal_Phdr
* internal
;
2035 GET_DATA_ALLOC (elf_header
.e_phoff
,
2036 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2037 phdrs
, Elf32_External_Phdr
*, "program headers");
2039 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2040 i
< elf_header
.e_phnum
;
2041 i
++, internal
++, external
++)
2043 internal
->p_type
= BYTE_GET (external
->p_type
);
2044 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2045 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2046 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2047 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2048 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2049 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2050 internal
->p_align
= BYTE_GET (external
->p_align
);
2059 get_64bit_program_headers (file
, program_headers
)
2061 Elf_Internal_Phdr
* program_headers
;
2063 Elf64_External_Phdr
* phdrs
;
2064 Elf64_External_Phdr
* external
;
2065 Elf64_Internal_Phdr
* internal
;
2068 GET_DATA_ALLOC (elf_header
.e_phoff
,
2069 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2070 phdrs
, Elf64_External_Phdr
*, "program headers");
2072 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2073 i
< elf_header
.e_phnum
;
2074 i
++, internal
++, external
++)
2076 internal
->p_type
= BYTE_GET (external
->p_type
);
2077 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2078 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2079 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2080 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2081 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2082 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2083 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2092 process_program_headers (file
)
2095 Elf_Internal_Phdr
* program_headers
;
2096 Elf_Internal_Phdr
* segment
;
2099 if (elf_header
.e_phnum
== 0)
2102 printf (_("\nThere are no program headers in this file.\n"));
2106 if (do_segments
&& !do_header
)
2108 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2109 printf (_("Entry point "));
2110 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2111 printf (_("\nThere are %d program headers, starting at offset "),
2112 elf_header
.e_phnum
);
2113 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2117 program_headers
= (Elf_Internal_Phdr
*) malloc
2118 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2120 if (program_headers
== NULL
)
2122 error (_("Out of memory\n"));
2127 i
= get_32bit_program_headers (file
, program_headers
);
2129 i
= get_64bit_program_headers (file
, program_headers
);
2133 free (program_headers
);
2140 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2144 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2148 (_(" Type Offset VirtAddr PhysAddr\n"));
2150 (_(" FileSiz MemSiz Flags Align\n"));
2158 for (i
= 0, segment
= program_headers
;
2159 i
< elf_header
.e_phnum
;
2164 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2168 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2169 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2170 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2171 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2172 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2174 (segment
->p_flags
& PF_R
? 'R' : ' '),
2175 (segment
->p_flags
& PF_W
? 'W' : ' '),
2176 (segment
->p_flags
& PF_X
? 'E' : ' '));
2177 printf ("%#lx", (unsigned long) segment
->p_align
);
2181 print_vma (segment
->p_offset
, FULL_HEX
);
2183 print_vma (segment
->p_vaddr
, FULL_HEX
);
2185 print_vma (segment
->p_paddr
, FULL_HEX
);
2187 print_vma (segment
->p_filesz
, FULL_HEX
);
2189 print_vma (segment
->p_memsz
, FULL_HEX
);
2191 (segment
->p_flags
& PF_R
? 'R' : ' '),
2192 (segment
->p_flags
& PF_W
? 'W' : ' '),
2193 (segment
->p_flags
& PF_X
? 'E' : ' '));
2194 print_vma (segment
->p_align
, HEX
);
2198 switch (segment
->p_type
)
2202 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2203 - (segment
->p_offset
& 0xfffff000);
2208 error (_("more than one dynamic segment\n"));
2210 dynamic_addr
= segment
->p_offset
;
2211 dynamic_size
= segment
->p_filesz
;
2215 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2216 error (_("Unable to find program interpreter name\n"));
2219 program_interpreter
[0] = 0;
2220 fscanf (file
, "%63s", program_interpreter
);
2223 printf (_("\n [Requesting program interpreter: %s]"),
2224 program_interpreter
);
2230 putc ('\n', stdout
);
2239 if (do_segments
&& section_headers
!= NULL
)
2241 printf (_("\n Section to Segment mapping:\n"));
2242 printf (_(" Segment Sections...\n"));
2244 assert (string_table
!= NULL
);
2246 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2249 Elf_Internal_Shdr
* section
;
2251 segment
= program_headers
+ i
;
2252 section
= section_headers
;
2254 printf (" %2.2d ", i
);
2256 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2258 if (section
->sh_size
> 0
2259 /* Compare allocated sections by VMA, unallocated
2260 sections by file offset. */
2261 && (section
->sh_flags
& SHF_ALLOC
2262 ? (section
->sh_addr
>= segment
->p_vaddr
2263 && section
->sh_addr
+ section
->sh_size
2264 <= segment
->p_vaddr
+ segment
->p_memsz
)
2265 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2266 && (section
->sh_offset
+ section
->sh_size
2267 <= segment
->p_offset
+ segment
->p_filesz
))))
2268 printf ("%s ", SECTION_NAME (section
));
2275 free (program_headers
);
2282 get_32bit_section_headers (file
)
2285 Elf32_External_Shdr
* shdrs
;
2286 Elf32_Internal_Shdr
* internal
;
2289 GET_DATA_ALLOC (elf_header
.e_shoff
,
2290 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2291 shdrs
, Elf32_External_Shdr
*, "section headers");
2293 section_headers
= (Elf_Internal_Shdr
*) malloc
2294 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2296 if (section_headers
== NULL
)
2298 error (_("Out of memory\n"));
2302 for (i
= 0, internal
= section_headers
;
2303 i
< elf_header
.e_shnum
;
2306 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2307 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2308 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2309 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2310 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2311 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2312 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2313 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2314 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2315 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2324 get_64bit_section_headers (file
)
2327 Elf64_External_Shdr
* shdrs
;
2328 Elf64_Internal_Shdr
* internal
;
2331 GET_DATA_ALLOC (elf_header
.e_shoff
,
2332 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2333 shdrs
, Elf64_External_Shdr
*, "section headers");
2335 section_headers
= (Elf_Internal_Shdr
*) malloc
2336 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2338 if (section_headers
== NULL
)
2340 error (_("Out of memory\n"));
2344 for (i
= 0, internal
= section_headers
;
2345 i
< elf_header
.e_shnum
;
2348 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2349 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2350 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2351 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2352 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2353 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2354 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2355 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2356 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2357 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2365 static Elf_Internal_Sym
*
2366 get_32bit_elf_symbols (file
, offset
, number
)
2368 unsigned long offset
;
2369 unsigned long number
;
2371 Elf32_External_Sym
* esyms
;
2372 Elf_Internal_Sym
* isyms
;
2373 Elf_Internal_Sym
* psym
;
2376 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2377 esyms
, Elf32_External_Sym
*, "symbols");
2379 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2383 error (_("Out of memory\n"));
2389 for (j
= 0, psym
= isyms
;
2393 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2394 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2395 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2396 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2397 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2398 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2406 static Elf_Internal_Sym
*
2407 get_64bit_elf_symbols (file
, offset
, number
)
2409 unsigned long offset
;
2410 unsigned long number
;
2412 Elf64_External_Sym
* esyms
;
2413 Elf_Internal_Sym
* isyms
;
2414 Elf_Internal_Sym
* psym
;
2417 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2418 esyms
, Elf64_External_Sym
*, "symbols");
2420 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2424 error (_("Out of memory\n"));
2430 for (j
= 0, psym
= isyms
;
2434 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2435 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2436 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2437 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2438 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2439 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2448 get_elf_section_flags (sh_flags
)
2451 static char buff
[32];
2459 flag
= sh_flags
& - sh_flags
;
2464 case SHF_WRITE
: strcat (buff
, "W"); break;
2465 case SHF_ALLOC
: strcat (buff
, "A"); break;
2466 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2467 case SHF_MERGE
: strcat (buff
, "M"); break;
2468 case SHF_STRINGS
: strcat (buff
, "S"); break;
2469 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2470 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2471 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2474 if (flag
& SHF_MASKOS
)
2477 sh_flags
&= ~ SHF_MASKOS
;
2479 else if (flag
& SHF_MASKPROC
)
2482 sh_flags
&= ~ SHF_MASKPROC
;
2494 process_section_headers (file
)
2497 Elf_Internal_Shdr
* section
;
2500 section_headers
= NULL
;
2502 if (elf_header
.e_shnum
== 0)
2505 printf (_("\nThere are no sections in this file.\n"));
2510 if (do_sections
&& !do_header
)
2511 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2512 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2516 if (! get_32bit_section_headers (file
))
2519 else if (! get_64bit_section_headers (file
))
2522 /* Read in the string table, so that we have names to display. */
2523 section
= section_headers
+ elf_header
.e_shstrndx
;
2525 if (section
->sh_size
!= 0)
2527 unsigned long string_table_offset
;
2529 string_table_offset
= section
->sh_offset
;
2531 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2532 string_table
, char *, "string table");
2535 /* Scan the sections for the dynamic symbol table
2536 and dynamic string table and debug sections. */
2537 dynamic_symbols
= NULL
;
2538 dynamic_strings
= NULL
;
2539 dynamic_syminfo
= NULL
;
2541 for (i
= 0, section
= section_headers
;
2542 i
< elf_header
.e_shnum
;
2545 char * name
= SECTION_NAME (section
);
2547 if (section
->sh_type
== SHT_DYNSYM
)
2549 if (dynamic_symbols
!= NULL
)
2551 error (_("File contains multiple dynamic symbol tables\n"));
2555 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2557 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2559 else if (section
->sh_type
== SHT_STRTAB
2560 && strcmp (name
, ".dynstr") == 0)
2562 if (dynamic_strings
!= NULL
)
2564 error (_("File contains multiple dynamic string tables\n"));
2568 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2569 dynamic_strings
, char *, "dynamic strings");
2571 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2572 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
)
2573 && strncmp (name
, ".debug_", 7) == 0)
2578 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2579 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2580 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2581 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2582 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2584 request_dump (i
, DEBUG_DUMP
);
2591 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2595 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2598 printf (_(" [Nr] Name Type Address Offset\n"));
2599 printf (_(" Size EntSize Flags Link Info Align\n"));
2602 for (i
= 0, section
= section_headers
;
2603 i
< elf_header
.e_shnum
;
2606 printf (" [%2d] %-17.17s %-15.15s ",
2608 SECTION_NAME (section
),
2609 get_section_type_name (section
->sh_type
));
2613 print_vma (section
->sh_addr
, LONG_HEX
);
2615 printf ( " %6.6lx %6.6lx %2.2lx",
2616 (unsigned long) section
->sh_offset
,
2617 (unsigned long) section
->sh_size
,
2618 (unsigned long) section
->sh_entsize
);
2620 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2622 printf (" %2ld %3lx %ld\n",
2623 (unsigned long) section
->sh_link
,
2624 (unsigned long) section
->sh_info
,
2625 (unsigned long) section
->sh_addralign
);
2630 print_vma (section
->sh_addr
, LONG_HEX
);
2631 printf (" %8.8lx", section
->sh_offset
);
2633 print_vma (section
->sh_size
, LONG_HEX
);
2635 print_vma (section
->sh_entsize
, LONG_HEX
);
2637 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2639 printf (" %2ld %3lx %ld\n",
2640 (unsigned long) section
->sh_link
,
2641 (unsigned long) section
->sh_info
,
2642 (unsigned long) section
->sh_addralign
);
2646 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2647 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2648 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2653 /* Process the reloc section. */
2655 process_relocs (file
)
2658 unsigned long rel_size
;
2659 unsigned long rel_offset
;
2665 if (do_using_dynamic
)
2667 int is_rela
= FALSE
;
2672 if (dynamic_info
[DT_REL
])
2674 rel_offset
= dynamic_info
[DT_REL
];
2675 rel_size
= dynamic_info
[DT_RELSZ
];
2678 else if (dynamic_info
[DT_RELA
])
2680 rel_offset
= dynamic_info
[DT_RELA
];
2681 rel_size
= dynamic_info
[DT_RELASZ
];
2684 else if (dynamic_info
[DT_JMPREL
])
2686 rel_offset
= dynamic_info
[DT_JMPREL
];
2687 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2689 switch (dynamic_info
[DT_PLTREL
])
2706 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2707 rel_offset
, rel_size
);
2709 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2710 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
2713 printf (_("\nThere are no dynamic relocations in this file.\n"));
2717 Elf32_Internal_Shdr
* section
;
2721 for (i
= 0, section
= section_headers
;
2722 i
< elf_header
.e_shnum
;
2725 if ( section
->sh_type
!= SHT_RELA
2726 && section
->sh_type
!= SHT_REL
)
2729 rel_offset
= section
->sh_offset
;
2730 rel_size
= section
->sh_size
;
2734 Elf32_Internal_Shdr
* strsec
;
2735 Elf32_Internal_Shdr
* symsec
;
2736 Elf_Internal_Sym
* symtab
;
2739 unsigned long nsyms
;
2741 printf (_("\nRelocation section "));
2743 if (string_table
== NULL
)
2744 printf ("%d", section
->sh_name
);
2746 printf ("'%s'", SECTION_NAME (section
));
2748 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2749 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
2751 symsec
= section_headers
+ section
->sh_link
;
2753 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
2754 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
2759 strsec
= section_headers
+ symsec
->sh_link
;
2761 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2762 char *, "string table");
2764 is_rela
= section
->sh_type
== SHT_RELA
;
2766 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
2776 printf (_("\nThere are no relocations in this file.\n"));
2784 dynamic_segment_mips_val (entry
)
2785 Elf_Internal_Dyn
* entry
;
2787 switch (entry
->d_tag
)
2790 if (entry
->d_un
.d_val
== 0)
2794 static const char * opts
[] =
2796 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2797 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2798 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2799 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2804 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
2805 if (entry
->d_un
.d_val
& (1 << cnt
))
2807 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2814 case DT_MIPS_IVERSION
:
2815 if (dynamic_strings
!= NULL
)
2816 printf ("Interface Version: %s\n",
2817 dynamic_strings
+ entry
->d_un
.d_val
);
2819 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2822 case DT_MIPS_TIME_STAMP
:
2825 time_t time
= entry
->d_un
.d_val
;
2826 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
2827 printf ("Time Stamp: %s\n", timebuf
);
2831 case DT_MIPS_RLD_VERSION
:
2832 case DT_MIPS_LOCAL_GOTNO
:
2833 case DT_MIPS_CONFLICTNO
:
2834 case DT_MIPS_LIBLISTNO
:
2835 case DT_MIPS_SYMTABNO
:
2836 case DT_MIPS_UNREFEXTNO
:
2837 case DT_MIPS_HIPAGENO
:
2838 case DT_MIPS_DELTA_CLASS_NO
:
2839 case DT_MIPS_DELTA_INSTANCE_NO
:
2840 case DT_MIPS_DELTA_RELOC_NO
:
2841 case DT_MIPS_DELTA_SYM_NO
:
2842 case DT_MIPS_DELTA_CLASSSYM_NO
:
2843 case DT_MIPS_COMPACT_SIZE
:
2844 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2848 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2854 dynamic_segment_parisc_val (entry
)
2855 Elf_Internal_Dyn
* entry
;
2857 switch (entry
->d_tag
)
2859 case DT_HP_DLD_FLAGS
:
2868 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
2869 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
2870 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
2871 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
2872 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
2873 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
2874 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
2875 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
2876 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
2877 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
2878 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
2882 bfd_vma val
= entry
->d_un
.d_val
;
2884 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
2885 if (val
& flags
[cnt
].bit
)
2889 fputs (flags
[cnt
].str
, stdout
);
2891 val
^= flags
[cnt
].bit
;
2894 if (val
!= 0 || first
)
2898 print_vma (val
, HEX
);
2904 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
2910 get_32bit_dynamic_segment (file
)
2913 Elf32_External_Dyn
* edyn
;
2914 Elf_Internal_Dyn
* entry
;
2917 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
2918 edyn
, Elf32_External_Dyn
*, "dynamic segment");
2920 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2921 how large this .dynamic is now. We can do this even before the byte
2922 swapping since the DT_NULL tag is recognizable. */
2924 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
2927 dynamic_segment
= (Elf_Internal_Dyn
*)
2928 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
2930 if (dynamic_segment
== NULL
)
2932 error (_("Out of memory\n"));
2937 for (i
= 0, entry
= dynamic_segment
;
2941 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
2942 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
2951 get_64bit_dynamic_segment (file
)
2954 Elf64_External_Dyn
* edyn
;
2955 Elf_Internal_Dyn
* entry
;
2958 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
2959 edyn
, Elf64_External_Dyn
*, "dynamic segment");
2961 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2962 how large this .dynamic is now. We can do this even before the byte
2963 swapping since the DT_NULL tag is recognizable. */
2965 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
2968 dynamic_segment
= (Elf_Internal_Dyn
*)
2969 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
2971 if (dynamic_segment
== NULL
)
2973 error (_("Out of memory\n"));
2978 for (i
= 0, entry
= dynamic_segment
;
2982 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
2983 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
2992 get_dynamic_flags (flags
)
2995 static char buff
[64];
3000 flag
= flags
& - flags
;
3005 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3006 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3007 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3008 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3009 default: strcat (buff
, "unknown "); break;
3015 /* Parse and display the contents of the dynamic segment. */
3017 process_dynamic_segment (file
)
3020 Elf_Internal_Dyn
* entry
;
3023 if (dynamic_size
== 0)
3026 printf (_("\nThere is no dynamic segment in this file.\n"));
3033 if (! get_32bit_dynamic_segment (file
))
3036 else if (! get_64bit_dynamic_segment (file
))
3039 /* Find the appropriate symbol table. */
3040 if (dynamic_symbols
== NULL
)
3042 for (i
= 0, entry
= dynamic_segment
;
3046 unsigned long offset
;
3048 if (entry
->d_tag
!= DT_SYMTAB
)
3051 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3053 /* Since we do not know how big the symbol table is,
3054 we default to reading in the entire file (!) and
3055 processing that. This is overkill, I know, but it
3057 offset
= entry
->d_un
.d_val
- loadaddr
;
3059 if (fseek (file
, 0, SEEK_END
))
3060 error (_("Unable to seek to end of file!"));
3063 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3065 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3067 if (num_dynamic_syms
< 1)
3069 error (_("Unable to determine the number of symbols to load\n"));
3073 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3077 /* Similarly find a string table. */
3078 if (dynamic_strings
== NULL
)
3080 for (i
= 0, entry
= dynamic_segment
;
3084 unsigned long offset
;
3087 if (entry
->d_tag
!= DT_STRTAB
)
3090 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3092 /* Since we do not know how big the string table is,
3093 we default to reading in the entire file (!) and
3094 processing that. This is overkill, I know, but it
3097 offset
= entry
->d_un
.d_val
- loadaddr
;
3098 if (fseek (file
, 0, SEEK_END
))
3099 error (_("Unable to seek to end of file\n"));
3100 str_tab_len
= ftell (file
) - offset
;
3102 if (str_tab_len
< 1)
3105 (_("Unable to determine the length of the dynamic string table\n"));
3109 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
3110 "dynamic string table");
3116 /* And find the syminfo section if available. */
3117 if (dynamic_syminfo
== NULL
)
3119 unsigned int syminsz
= 0;
3121 for (i
= 0, entry
= dynamic_segment
;
3125 if (entry
->d_tag
== DT_SYMINENT
)
3127 /* Note: these braces are necessary to avoid a syntax
3128 error from the SunOS4 C compiler. */
3129 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3131 else if (entry
->d_tag
== DT_SYMINSZ
)
3132 syminsz
= entry
->d_un
.d_val
;
3133 else if (entry
->d_tag
== DT_SYMINFO
)
3134 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
3137 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3139 Elf_External_Syminfo
* extsyminfo
;
3140 Elf_Internal_Syminfo
* syminfo
;
3142 /* There is a syminfo section. Read the data. */
3143 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3144 Elf_External_Syminfo
*, "symbol information");
3146 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3147 if (dynamic_syminfo
== NULL
)
3149 error (_("Out of memory\n"));
3153 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3154 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3157 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3158 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3165 if (do_dynamic
&& dynamic_addr
)
3166 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3167 dynamic_addr
, (long) dynamic_size
);
3169 printf (_(" Tag Type Name/Value\n"));
3171 for (i
= 0, entry
= dynamic_segment
;
3180 print_vma (entry
->d_tag
, FULL_HEX
);
3181 dtype
= get_dynamic_type (entry
->d_tag
);
3182 printf (" (%s)%*s", dtype
,
3183 ((is_32bit_elf
? 27 : 19)
3184 - (int) strlen (dtype
)),
3188 switch (entry
->d_tag
)
3192 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
3199 if (entry
->d_tag
== DT_AUXILIARY
)
3200 printf (_("Auxiliary library"));
3202 printf (_("Filter library"));
3204 if (dynamic_strings
)
3205 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3209 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3218 printf (_("Flags:"));
3219 if (entry
->d_un
.d_val
== 0)
3220 printf (_(" None\n"));
3223 unsigned long int val
= entry
->d_un
.d_val
;
3224 if (val
& DTF_1_PARINIT
)
3226 printf (" PARINIT");
3227 val
^= DTF_1_PARINIT
;
3230 printf (" %lx", val
);
3239 printf (_("Flags:"));
3240 if (entry
->d_un
.d_val
== 0)
3241 printf (_(" None\n"));
3244 unsigned long int val
= entry
->d_un
.d_val
;
3245 if (val
& DF_P1_LAZYLOAD
)
3247 printf (" LAZYLOAD");
3248 val
^= DF_P1_LAZYLOAD
;
3250 if (val
& DF_P1_GROUPPERM
)
3252 printf (" GROUPPERM");
3253 val
^= DF_P1_GROUPPERM
;
3256 printf (" %lx", val
);
3265 printf (_("Flags:"));
3266 if (entry
->d_un
.d_val
== 0)
3267 printf (_(" None\n"));
3270 unsigned long int val
= entry
->d_un
.d_val
;
3276 if (val
& DF_1_GLOBAL
)
3281 if (val
& DF_1_GROUP
)
3286 if (val
& DF_1_NODELETE
)
3288 printf (" NODELETE");
3289 val
^= DF_1_NODELETE
;
3291 if (val
& DF_1_LOADFLTR
)
3293 printf (" LOADFLTR");
3294 val
^= DF_1_LOADFLTR
;
3296 if (val
& DF_1_INITFIRST
)
3298 printf (" INITFIRST");
3299 val
^= DF_1_INITFIRST
;
3301 if (val
& DF_1_NOOPEN
)
3306 if (val
& DF_1_ORIGIN
)
3311 if (val
& DF_1_DIRECT
)
3316 if (val
& DF_1_TRANS
)
3321 if (val
& DF_1_INTERPOSE
)
3323 printf (" INTERPOSE");
3324 val
^= DF_1_INTERPOSE
;
3327 printf (" %lx", val
);
3335 puts (get_dynamic_type (entry
->d_un
.d_val
));
3354 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
3360 if (dynamic_strings
== NULL
)
3363 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3367 switch (entry
->d_tag
)
3370 printf (_("Shared library: [%s]"), name
);
3372 if (strcmp (name
, program_interpreter
) == 0)
3373 printf (_(" program interpreter"));
3377 printf (_("Library soname: [%s]"), name
);
3381 printf (_("Library rpath: [%s]"), name
);
3385 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3390 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3406 case DT_INIT_ARRAYSZ
:
3407 case DT_FINI_ARRAYSZ
:
3410 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3411 printf (" (bytes)\n");
3421 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3434 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
3438 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3442 printf (_("Not needed object: [%s]\n"), name
);
3447 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3453 /* The value of this entry is ignored. */
3457 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
3458 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
3463 switch (elf_header
.e_machine
)
3466 case EM_MIPS_RS4_BE
:
3467 dynamic_segment_mips_val (entry
);
3470 dynamic_segment_parisc_val (entry
);
3473 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3485 get_ver_flags (flags
)
3488 static char buff
[32];
3495 if (flags
& VER_FLG_BASE
)
3496 strcat (buff
, "BASE ");
3498 if (flags
& VER_FLG_WEAK
)
3500 if (flags
& VER_FLG_BASE
)
3501 strcat (buff
, "| ");
3503 strcat (buff
, "WEAK ");
3506 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
3507 strcat (buff
, "| <unknown>");
3512 /* Display the contents of the version sections. */
3514 process_version_sections (file
)
3517 Elf32_Internal_Shdr
* section
;
3524 for (i
= 0, section
= section_headers
;
3525 i
< elf_header
.e_shnum
;
3528 switch (section
->sh_type
)
3530 case SHT_GNU_verdef
:
3532 Elf_External_Verdef
* edefs
;
3539 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3540 SECTION_NAME (section
), section
->sh_info
);
3542 printf (_(" Addr: 0x"));
3543 printf_vma (section
->sh_addr
);
3544 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3545 (unsigned long) section
->sh_offset
, section
->sh_link
,
3546 SECTION_NAME (section_headers
+ section
->sh_link
));
3548 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3549 edefs
, Elf_External_Verdef
*,
3550 "version definition section");
3552 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
3555 Elf_External_Verdef
* edef
;
3556 Elf_Internal_Verdef ent
;
3557 Elf_External_Verdaux
* eaux
;
3558 Elf_Internal_Verdaux aux
;
3562 vstart
= ((char *) edefs
) + idx
;
3564 edef
= (Elf_External_Verdef
*) vstart
;
3566 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
3567 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
3568 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
3569 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
3570 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
3571 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
3572 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
3574 printf (_(" %#06x: Rev: %d Flags: %s"),
3575 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
3577 printf (_(" Index: %d Cnt: %d "),
3578 ent
.vd_ndx
, ent
.vd_cnt
);
3580 vstart
+= ent
.vd_aux
;
3582 eaux
= (Elf_External_Verdaux
*) vstart
;
3584 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3585 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3587 if (dynamic_strings
)
3588 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
3590 printf (_("Name index: %ld\n"), aux
.vda_name
);
3592 isum
= idx
+ ent
.vd_aux
;
3594 for (j
= 1; j
< ent
.vd_cnt
; j
++)
3596 isum
+= aux
.vda_next
;
3597 vstart
+= aux
.vda_next
;
3599 eaux
= (Elf_External_Verdaux
*) vstart
;
3601 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3602 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3604 if (dynamic_strings
)
3605 printf (_(" %#06x: Parent %d: %s\n"),
3606 isum
, j
, dynamic_strings
+ aux
.vda_name
);
3608 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3609 isum
, j
, aux
.vda_name
);
3619 case SHT_GNU_verneed
:
3621 Elf_External_Verneed
* eneed
;
3627 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3628 SECTION_NAME (section
), section
->sh_info
);
3630 printf (_(" Addr: 0x"));
3631 printf_vma (section
->sh_addr
);
3632 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3633 (unsigned long) section
->sh_offset
, section
->sh_link
,
3634 SECTION_NAME (section_headers
+ section
->sh_link
));
3636 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3637 eneed
, Elf_External_Verneed
*,
3638 "version need section");
3640 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
3642 Elf_External_Verneed
* entry
;
3643 Elf_Internal_Verneed ent
;
3648 vstart
= ((char *) eneed
) + idx
;
3650 entry
= (Elf_External_Verneed
*) vstart
;
3652 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
3653 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
3654 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
3655 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
3656 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
3658 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
3660 if (dynamic_strings
)
3661 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
3663 printf (_(" File: %lx"), ent
.vn_file
);
3665 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
3667 vstart
+= ent
.vn_aux
;
3669 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
3671 Elf_External_Vernaux
* eaux
;
3672 Elf_Internal_Vernaux aux
;
3674 eaux
= (Elf_External_Vernaux
*) vstart
;
3676 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
3677 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
3678 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
3679 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
3680 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
3682 if (dynamic_strings
)
3683 printf (_(" %#06x: Name: %s"),
3684 isum
, dynamic_strings
+ aux
.vna_name
);
3686 printf (_(" %#06x: Name index: %lx"),
3687 isum
, aux
.vna_name
);
3689 printf (_(" Flags: %s Version: %d\n"),
3690 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
3692 isum
+= aux
.vna_next
;
3693 vstart
+= aux
.vna_next
;
3703 case SHT_GNU_versym
:
3705 Elf32_Internal_Shdr
* link_section
;
3708 unsigned char * edata
;
3709 unsigned short * data
;
3711 Elf_Internal_Sym
* symbols
;
3712 Elf32_Internal_Shdr
* string_sec
;
3714 link_section
= section_headers
+ section
->sh_link
;
3715 total
= section
->sh_size
/ section
->sh_entsize
;
3719 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
3720 link_section
->sh_size
/ link_section
->sh_entsize
);
3722 string_sec
= section_headers
+ link_section
->sh_link
;
3724 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3725 strtab
, char *, "version string table");
3727 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3728 SECTION_NAME (section
), total
);
3730 printf (_(" Addr: "));
3731 printf_vma (section
->sh_addr
);
3732 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3733 (unsigned long) section
->sh_offset
, section
->sh_link
,
3734 SECTION_NAME (link_section
));
3736 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3738 total
* sizeof (short), edata
,
3739 unsigned char *, "version symbol data");
3741 data
= (unsigned short *) malloc (total
* sizeof (short));
3743 for (cnt
= total
; cnt
--;)
3744 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
3749 for (cnt
= 0; cnt
< total
; cnt
+= 4)
3754 printf (" %03x:", cnt
);
3756 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
3757 switch (data
[cnt
+ j
])
3760 fputs (_(" 0 (*local*) "), stdout
);
3764 fputs (_(" 1 (*global*) "), stdout
);
3768 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
3769 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
3771 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
3772 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
3775 /* We must test both. */
3776 Elf_Internal_Verneed ivn
;
3777 unsigned long offset
;
3779 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3784 Elf_External_Verneed evn
;
3785 Elf_External_Vernaux evna
;
3786 Elf_Internal_Vernaux ivna
;
3787 unsigned long vna_off
;
3789 GET_DATA (offset
, evn
, "version need");
3791 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3792 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3794 vna_off
= offset
+ ivn
.vn_aux
;
3798 GET_DATA (vna_off
, evna
,
3799 "version need aux (1)");
3801 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3802 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3804 vna_off
+= ivna
.vna_next
;
3806 while (ivna
.vna_other
!= data
[cnt
+ j
]
3807 && ivna
.vna_next
!= 0);
3809 if (ivna
.vna_other
== data
[cnt
+ j
])
3811 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3813 name
= strtab
+ ivna
.vna_name
;
3814 nn
+= printf ("(%s%-*s",
3816 12 - (int) strlen (name
),
3820 else if (ivn
.vn_next
== 0)
3822 if (data
[cnt
+ j
] != 0x8001)
3824 Elf_Internal_Verdef ivd
;
3825 Elf_External_Verdef evd
;
3827 offset
= version_info
3828 [DT_VERSIONTAGIDX (DT_VERDEF
)]
3833 GET_DATA (offset
, evd
,
3834 "version definition");
3836 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3837 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3839 offset
+= ivd
.vd_next
;
3842 != (data
[cnt
+ j
] & 0x7fff)
3843 && ivd
.vd_next
!= 0);
3846 == (data
[cnt
+ j
] & 0x7fff))
3848 Elf_External_Verdaux evda
;
3849 Elf_Internal_Verdaux ivda
;
3851 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3853 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
3854 "version definition aux");
3857 BYTE_GET (evda
.vda_name
);
3859 name
= strtab
+ ivda
.vda_name
;
3863 12 - (int) strlen (name
),
3871 offset
+= ivn
.vn_next
;
3873 while (ivn
.vn_next
);
3875 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
3877 Elf_Internal_Verneed ivn
;
3878 unsigned long offset
;
3880 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3885 Elf_Internal_Vernaux ivna
;
3886 Elf_External_Verneed evn
;
3887 Elf_External_Vernaux evna
;
3888 unsigned long a_off
;
3890 GET_DATA (offset
, evn
, "version need");
3892 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3893 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3895 a_off
= offset
+ ivn
.vn_aux
;
3899 GET_DATA (a_off
, evna
,
3900 "version need aux (2)");
3902 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3903 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3905 a_off
+= ivna
.vna_next
;
3907 while (ivna
.vna_other
!= data
[cnt
+ j
]
3908 && ivna
.vna_next
!= 0);
3910 if (ivna
.vna_other
== data
[cnt
+ j
])
3912 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3914 name
= strtab
+ ivna
.vna_name
;
3915 nn
+= printf ("(%s%-*s",
3917 12 - (int) strlen (name
),
3922 offset
+= ivn
.vn_next
;
3924 while (ivn
.vn_next
);
3926 else if (data
[cnt
+ j
] != 0x8001)
3928 Elf_Internal_Verdef ivd
;
3929 Elf_External_Verdef evd
;
3930 unsigned long offset
;
3932 offset
= version_info
3933 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
3937 GET_DATA (offset
, evd
, "version def");
3939 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3940 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3942 offset
+= ivd
.vd_next
;
3944 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
3945 && ivd
.vd_next
!= 0);
3947 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
3949 Elf_External_Verdaux evda
;
3950 Elf_Internal_Verdaux ivda
;
3952 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3954 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
3955 evda
, "version def aux");
3957 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
3959 name
= strtab
+ ivda
.vda_name
;
3960 nn
+= printf ("(%s%-*s",
3962 12 - (int) strlen (name
),
3968 printf ("%*c", 18 - nn
, ' ');
3986 printf (_("\nNo version information found in this file.\n"));
3992 get_symbol_binding (binding
)
3993 unsigned int binding
;
3995 static char buff
[32];
3999 case STB_LOCAL
: return "LOCAL";
4000 case STB_GLOBAL
: return "GLOBAL";
4001 case STB_WEAK
: return "WEAK";
4003 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4004 sprintf (buff
, _("<processor specific>: %d"), binding
);
4005 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4006 sprintf (buff
, _("<OS specific>: %d"), binding
);
4008 sprintf (buff
, _("<unknown>: %d"), binding
);
4014 get_symbol_type (type
)
4017 static char buff
[32];
4021 case STT_NOTYPE
: return "NOTYPE";
4022 case STT_OBJECT
: return "OBJECT";
4023 case STT_FUNC
: return "FUNC";
4024 case STT_SECTION
: return "SECTION";
4025 case STT_FILE
: return "FILE";
4026 case STT_COMMON
: return "COMMON";
4028 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4030 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4031 return "THUMB_FUNC";
4033 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4036 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4037 return "PARISC_MILLI";
4039 sprintf (buff
, _("<processor specific>: %d"), type
);
4041 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4043 if (elf_header
.e_machine
== EM_PARISC
)
4045 if (type
== STT_HP_OPAQUE
)
4047 if (type
== STT_HP_STUB
)
4051 sprintf (buff
, _("<OS specific>: %d"), type
);
4054 sprintf (buff
, _("<unknown>: %d"), type
);
4060 get_symbol_visibility (visibility
)
4061 unsigned int visibility
;
4065 case STV_DEFAULT
: return "DEFAULT";
4066 case STV_INTERNAL
: return "INTERNAL";
4067 case STV_HIDDEN
: return "HIDDEN";
4068 case STV_PROTECTED
: return "PROTECTED";
4074 get_symbol_index_type (type
)
4079 case SHN_UNDEF
: return "UND";
4080 case SHN_ABS
: return "ABS";
4081 case SHN_COMMON
: return "COM";
4083 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4085 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4087 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4091 static char buff
[32];
4093 sprintf (buff
, "%3d", type
);
4100 get_dynamic_data (file
, number
)
4102 unsigned int number
;
4107 e_data
= (char *) malloc (number
* 4);
4111 error (_("Out of memory\n"));
4115 if (fread (e_data
, 4, number
, file
) != number
)
4117 error (_("Unable to read in dynamic data\n"));
4121 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4125 error (_("Out of memory\n"));
4131 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4138 /* Dump the symbol table */
4140 process_symbol_table (file
)
4143 Elf32_Internal_Shdr
* section
;
4148 int * buckets
= NULL
;
4149 int * chains
= NULL
;
4151 if (! do_syms
&& !do_histogram
)
4154 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
4157 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
4159 error (_("Unable to seek to start of dynamic information"));
4163 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4165 error (_("Failed to read in number of buckets\n"));
4169 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4171 error (_("Failed to read in number of chains\n"));
4175 nbuckets
= byte_get (nb
, 4);
4176 nchains
= byte_get (nc
, 4);
4178 buckets
= get_dynamic_data (file
, nbuckets
);
4179 chains
= get_dynamic_data (file
, nchains
);
4181 if (buckets
== NULL
|| chains
== NULL
)
4186 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4191 printf (_("\nSymbol table for image:\n"));
4193 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4195 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4197 for (hn
= 0; hn
< nbuckets
; hn
++)
4202 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4204 Elf_Internal_Sym
* psym
;
4206 psym
= dynamic_symbols
+ si
;
4208 printf (" %3d %3d: ", si
, hn
);
4209 print_vma (psym
->st_value
, LONG_HEX
);
4211 print_vma (psym
->st_size
, DEC_5
);
4213 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4214 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4215 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4216 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
4217 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4221 else if (do_syms
&& !do_using_dynamic
)
4225 for (i
= 0, section
= section_headers
;
4226 i
< elf_header
.e_shnum
;
4231 Elf_Internal_Sym
* symtab
;
4232 Elf_Internal_Sym
* psym
;
4235 if ( section
->sh_type
!= SHT_SYMTAB
4236 && section
->sh_type
!= SHT_DYNSYM
)
4239 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4240 SECTION_NAME (section
),
4241 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4243 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4245 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4247 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4248 section
->sh_size
/ section
->sh_entsize
);
4252 if (section
->sh_link
== elf_header
.e_shstrndx
)
4253 strtab
= string_table
;
4256 Elf32_Internal_Shdr
* string_sec
;
4258 string_sec
= section_headers
+ section
->sh_link
;
4260 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4261 strtab
, char *, "string table");
4264 for (si
= 0, psym
= symtab
;
4265 si
< section
->sh_size
/ section
->sh_entsize
;
4268 printf ("%6d: ", si
);
4269 print_vma (psym
->st_value
, LONG_HEX
);
4271 print_vma (psym
->st_size
, DEC_5
);
4272 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4273 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4274 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4275 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
4276 printf (" %s", strtab
+ psym
->st_name
);
4278 if (section
->sh_type
== SHT_DYNSYM
&&
4279 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
4281 unsigned char data
[2];
4282 unsigned short vers_data
;
4283 unsigned long offset
;
4287 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4290 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
4293 vers_data
= byte_get (data
, 2);
4295 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
4296 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
4299 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
4301 if ((vers_data
& 0x8000) || vers_data
> 1)
4303 if (is_nobits
|| ! check_def
)
4305 Elf_External_Verneed evn
;
4306 Elf_Internal_Verneed ivn
;
4307 Elf_Internal_Vernaux ivna
;
4309 /* We must test both. */
4310 offset
= version_info
4311 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
4315 unsigned long vna_off
;
4317 GET_DATA (offset
, evn
, "version need");
4319 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4320 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4322 vna_off
= offset
+ ivn
.vn_aux
;
4326 Elf_External_Vernaux evna
;
4328 GET_DATA (vna_off
, evna
,
4329 "version need aux (3)");
4331 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4332 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4333 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4335 vna_off
+= ivna
.vna_next
;
4337 while (ivna
.vna_other
!= vers_data
4338 && ivna
.vna_next
!= 0);
4340 if (ivna
.vna_other
== vers_data
)
4343 offset
+= ivn
.vn_next
;
4345 while (ivn
.vn_next
!= 0);
4347 if (ivna
.vna_other
== vers_data
)
4350 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
4353 else if (! is_nobits
)
4354 error (_("bad dynamic symbol"));
4361 if (vers_data
!= 0x8001)
4363 Elf_Internal_Verdef ivd
;
4364 Elf_Internal_Verdaux ivda
;
4365 Elf_External_Verdaux evda
;
4366 unsigned long offset
;
4369 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
4374 Elf_External_Verdef evd
;
4376 GET_DATA (offset
, evd
, "version def");
4378 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4379 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4380 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4382 offset
+= ivd
.vd_next
;
4384 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
4385 && ivd
.vd_next
!= 0);
4387 offset
-= ivd
.vd_next
;
4388 offset
+= ivd
.vd_aux
;
4390 GET_DATA (offset
, evda
, "version def aux");
4392 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4394 if (psym
->st_name
!= ivda
.vda_name
)
4395 printf ((vers_data
& 0x8000)
4397 strtab
+ ivda
.vda_name
);
4407 if (strtab
!= string_table
)
4413 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4415 if (do_histogram
&& buckets
!= NULL
)
4422 int nzero_counts
= 0;
4425 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4427 printf (_(" Length Number %% of total Coverage\n"));
4429 lengths
= (int *) calloc (nbuckets
, sizeof (int));
4430 if (lengths
== NULL
)
4432 error (_("Out of memory"));
4435 for (hn
= 0; hn
< nbuckets
; ++hn
)
4440 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
4443 if (maxlength
< ++lengths
[hn
])
4448 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
4451 error (_("Out of memory"));
4455 for (hn
= 0; hn
< nbuckets
; ++hn
)
4456 ++ counts
[lengths
[hn
]];
4460 printf (" 0 %-10d (%5.1f%%)\n",
4461 counts
[0], (counts
[0] * 100.0) / nbuckets
);
4462 for (si
= 1; si
<= maxlength
; ++si
)
4464 nzero_counts
+= counts
[si
] * si
;
4465 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4466 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
4467 (nzero_counts
* 100.0) / nsyms
);
4475 if (buckets
!= NULL
)
4485 process_syminfo (file
)
4486 FILE * file ATTRIBUTE_UNUSED
;
4490 if (dynamic_syminfo
== NULL
4492 /* No syminfo, this is ok. */
4495 /* There better should be a dynamic symbol section. */
4496 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
4500 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4501 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
4503 printf (_(" Num: Name BoundTo Flags\n"));
4504 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
4506 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
4508 printf ("%4d: %-30s ", i
,
4509 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
4511 switch (dynamic_syminfo
[i
].si_boundto
)
4513 case SYMINFO_BT_SELF
:
4514 fputs ("SELF ", stdout
);
4516 case SYMINFO_BT_PARENT
:
4517 fputs ("PARENT ", stdout
);
4520 if (dynamic_syminfo
[i
].si_boundto
> 0
4521 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
4524 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
4526 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
4530 if (flags
& SYMINFO_FLG_DIRECT
)
4532 if (flags
& SYMINFO_FLG_PASSTHRU
)
4533 printf (" PASSTHRU");
4534 if (flags
& SYMINFO_FLG_COPY
)
4536 if (flags
& SYMINFO_FLG_LAZYLOAD
)
4537 printf (" LAZYLOAD");
4545 #ifdef SUPPORT_DISASSEMBLY
4547 disassemble_section (section
, file
)
4548 Elf32_Internal_Shdr
* section
;
4551 printf (_("\nAssembly dump of section %s\n"),
4552 SECTION_NAME (section
));
4554 /* XXX -- to be done --- XXX */
4561 dump_section (section
, file
)
4562 Elf32_Internal_Shdr
* section
;
4565 bfd_size_type bytes
;
4567 unsigned char * data
;
4568 unsigned char * start
;
4570 bytes
= section
->sh_size
;
4574 printf (_("\nSection '%s' has no data to dump.\n"),
4575 SECTION_NAME (section
));
4579 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
4581 addr
= section
->sh_addr
;
4583 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
4594 lbytes
= (bytes
> 16 ? 16 : bytes
);
4596 printf (" 0x%8.8lx ", (unsigned long) addr
);
4598 switch (elf_header
.e_ident
[EI_DATA
])
4602 for (j
= 15; j
>= 0; j
--)
4605 printf ("%2.2x", data
[j
]);
4615 for (j
= 0; j
< 16; j
++)
4618 printf ("%2.2x", data
[j
]);
4628 for (j
= 0; j
< lbytes
; j
++)
4631 if (k
>= ' ' && k
< 0x80)
4650 static unsigned long int
4651 read_leb128 (data
, length_return
, sign
)
4652 unsigned char * data
;
4653 int * length_return
;
4656 unsigned long int result
= 0;
4657 unsigned int num_read
= 0;
4666 result
|= (byte
& 0x7f) << shift
;
4671 while (byte
& 0x80);
4673 if (length_return
!= NULL
)
4674 * length_return
= num_read
;
4676 if (sign
&& (shift
< 32) && (byte
& 0x40))
4677 result
|= -1 << shift
;
4682 typedef struct State_Machine_Registers
4684 unsigned long address
;
4687 unsigned int column
;
4691 /* This variable hold the number of the last entry seen
4692 in the File Table. */
4693 unsigned int last_file_entry
;
4696 static SMR state_machine_regs
;
4699 reset_state_machine (is_stmt
)
4702 state_machine_regs
.address
= 0;
4703 state_machine_regs
.file
= 1;
4704 state_machine_regs
.line
= 1;
4705 state_machine_regs
.column
= 0;
4706 state_machine_regs
.is_stmt
= is_stmt
;
4707 state_machine_regs
.basic_block
= 0;
4708 state_machine_regs
.end_sequence
= 0;
4709 state_machine_regs
.last_file_entry
= 0;
4712 /* Handled an extend line op. Returns true if this is the end
4715 process_extended_line_op (data
, is_stmt
, pointer_size
)
4716 unsigned char * data
;
4720 unsigned char op_code
;
4723 unsigned char * name
;
4726 len
= read_leb128 (data
, & bytes_read
, 0);
4731 warn (_("badly formed extended line op encountered!"));
4736 op_code
= * data
++;
4738 printf (_(" Extended opcode %d: "), op_code
);
4742 case DW_LNE_end_sequence
:
4743 printf (_("End of Sequence\n\n"));
4744 reset_state_machine (is_stmt
);
4747 case DW_LNE_set_address
:
4748 adr
= byte_get (data
, pointer_size
);
4749 printf (_("set Address to 0x%lx\n"), adr
);
4750 state_machine_regs
.address
= adr
;
4753 case DW_LNE_define_file
:
4754 printf (_(" define new File Table entry\n"));
4755 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4757 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4759 data
+= strlen (data
) + 1;
4760 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4762 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4764 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4765 printf (_("%s\n\n"), name
);
4769 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
4776 /* Size of pointers in the .debug_line section. This information is not
4777 really present in that section. It's obtained before dumping the debug
4778 sections by doing some pre-scan of the .debug_info section. */
4779 static int debug_line_pointer_size
= 4;
4782 display_debug_lines (section
, start
, file
)
4783 Elf32_Internal_Shdr
* section
;
4784 unsigned char * start
;
4785 FILE * file ATTRIBUTE_UNUSED
;
4787 DWARF2_External_LineInfo
* external
;
4788 DWARF2_Internal_LineInfo info
;
4789 unsigned char * standard_opcodes
;
4790 unsigned char * data
= start
;
4791 unsigned char * end
= start
+ section
->sh_size
;
4792 unsigned char * end_of_sequence
;
4795 printf (_("\nDump of debug contents of section %s:\n\n"),
4796 SECTION_NAME (section
));
4800 external
= (DWARF2_External_LineInfo
*) data
;
4802 /* Check the length of the block. */
4803 info
.li_length
= BYTE_GET (external
->li_length
);
4804 if (info
.li_length
> section
->sh_size
)
4807 (_("The line info appears to be corrupt - the section is too small\n"));
4811 /* Check its version number. */
4812 info
.li_version
= BYTE_GET (external
->li_version
);
4813 if (info
.li_version
!= 2)
4815 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4819 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
4820 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
4821 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
4822 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
4823 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
4824 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
4826 /* Sign extend the line base field. */
4827 info
.li_line_base
<<= 24;
4828 info
.li_line_base
>>= 24;
4830 printf (_(" Length: %ld\n"), info
.li_length
);
4831 printf (_(" DWARF Version: %d\n"), info
.li_version
);
4832 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
4833 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
4834 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
4835 printf (_(" Line Base: %d\n"), info
.li_line_base
);
4836 printf (_(" Line Range: %d\n"), info
.li_line_range
);
4837 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
4839 end_of_sequence
= data
+ info
.li_length
+ sizeof (info
.li_length
);
4841 reset_state_machine (info
.li_default_is_stmt
);
4843 /* Display the contents of the Opcodes table. */
4844 standard_opcodes
= data
+ sizeof (* external
);
4846 printf (_("\n Opcodes:\n"));
4848 for (i
= 1; i
< info
.li_opcode_base
; i
++)
4849 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
4851 /* Display the contents of the Directory table. */
4852 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
4855 printf (_("\n The Directory Table is empty.\n"));
4858 printf (_("\n The Directory Table:\n"));
4862 printf (_(" %s\n"), data
);
4864 data
+= strlen (data
) + 1;
4868 /* Skip the NUL at the end of the table. */
4871 /* Display the contents of the File Name table. */
4873 printf (_("\n The File Name Table is empty.\n"));
4876 printf (_("\n The File Name Table:\n"));
4877 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4884 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4887 data
+= strlen (data
) + 1;
4889 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4891 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4893 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4895 printf (_("%s\n"), name
);
4899 /* Skip the NUL at the end of the table. */
4902 /* Now display the statements. */
4903 printf (_("\n Line Number Statements:\n"));
4906 while (data
< end_of_sequence
)
4908 unsigned char op_code
;
4912 op_code
= * data
++;
4916 case DW_LNS_extended_op
:
4917 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
4918 debug_line_pointer_size
);
4922 printf (_(" Copy\n"));
4925 case DW_LNS_advance_pc
:
4926 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
4928 state_machine_regs
.address
+= adv
;
4929 printf (_(" Advance PC by %d to %lx\n"), adv
,
4930 state_machine_regs
.address
);
4933 case DW_LNS_advance_line
:
4934 adv
= read_leb128 (data
, & bytes_read
, 1);
4936 state_machine_regs
.line
+= adv
;
4937 printf (_(" Advance Line by %d to %d\n"), adv
,
4938 state_machine_regs
.line
);
4941 case DW_LNS_set_file
:
4942 adv
= read_leb128 (data
, & bytes_read
, 0);
4944 printf (_(" Set File Name to entry %d in the File Name Table\n"),
4946 state_machine_regs
.file
= adv
;
4949 case DW_LNS_set_column
:
4950 adv
= read_leb128 (data
, & bytes_read
, 0);
4952 printf (_(" Set column to %d\n"), adv
);
4953 state_machine_regs
.column
= adv
;
4956 case DW_LNS_negate_stmt
:
4957 adv
= state_machine_regs
.is_stmt
;
4959 printf (_(" Set is_stmt to %d\n"), adv
);
4960 state_machine_regs
.is_stmt
= adv
;
4963 case DW_LNS_set_basic_block
:
4964 printf (_(" Set basic block\n"));
4965 state_machine_regs
.basic_block
= 1;
4968 case DW_LNS_const_add_pc
:
4969 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
4970 * info
.li_min_insn_length
);
4971 state_machine_regs
.address
+= adv
;
4972 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
4973 state_machine_regs
.address
);
4976 case DW_LNS_fixed_advance_pc
:
4977 adv
= byte_get (data
, 2);
4979 state_machine_regs
.address
+= adv
;
4980 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
4981 adv
, state_machine_regs
.address
);
4985 op_code
-= info
.li_opcode_base
;
4986 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
4987 state_machine_regs
.address
+= adv
;
4988 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
4989 op_code
, adv
, state_machine_regs
.address
);
4990 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
4991 state_machine_regs
.line
+= adv
;
4992 printf (_(" and Line by %d to %d\n"),
4993 adv
, state_machine_regs
.line
);
5004 display_debug_pubnames (section
, start
, file
)
5005 Elf32_Internal_Shdr
* section
;
5006 unsigned char * start
;
5007 FILE * file ATTRIBUTE_UNUSED
;
5009 DWARF2_External_PubNames
* external
;
5010 DWARF2_Internal_PubNames pubnames
;
5011 unsigned char * end
;
5013 end
= start
+ section
->sh_size
;
5015 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5019 unsigned char * data
;
5020 unsigned long offset
;
5022 external
= (DWARF2_External_PubNames
*) start
;
5024 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5025 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5026 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5027 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5029 data
= start
+ sizeof (* external
);
5030 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5032 if (pubnames
.pn_version
!= 2)
5034 warn (_("Only DWARF 2 pubnames are currently supported"));
5038 printf (_(" Length: %ld\n"),
5039 pubnames
.pn_length
);
5040 printf (_(" Version: %d\n"),
5041 pubnames
.pn_version
);
5042 printf (_(" Offset into .debug_info section: %ld\n"),
5043 pubnames
.pn_offset
);
5044 printf (_(" Size of area in .debug_info section: %ld\n"),
5047 printf (_("\n Offset\tName\n"));
5051 offset
= byte_get (data
, 4);
5056 printf (" %ld\t\t%s\n", offset
, data
);
5057 data
+= strlen (data
) + 1;
5060 while (offset
!= 0);
5073 case DW_TAG_padding
: return "DW_TAG_padding";
5074 case DW_TAG_array_type
: return "DW_TAG_array_type";
5075 case DW_TAG_class_type
: return "DW_TAG_class_type";
5076 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5077 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5078 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5079 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5080 case DW_TAG_label
: return "DW_TAG_label";
5081 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5082 case DW_TAG_member
: return "DW_TAG_member";
5083 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5084 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5085 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5086 case DW_TAG_string_type
: return "DW_TAG_string_type";
5087 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5088 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5089 case DW_TAG_typedef
: return "DW_TAG_typedef";
5090 case DW_TAG_union_type
: return "DW_TAG_union_type";
5091 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5092 case DW_TAG_variant
: return "DW_TAG_variant";
5093 case DW_TAG_common_block
: return "DW_TAG_common_block";
5094 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5095 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5096 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5097 case DW_TAG_module
: return "DW_TAG_module";
5098 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5099 case DW_TAG_set_type
: return "DW_TAG_set_type";
5100 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5101 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5102 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5103 case DW_TAG_base_type
: return "DW_TAG_base_type";
5104 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5105 case DW_TAG_const_type
: return "DW_TAG_const_type";
5106 case DW_TAG_constant
: return "DW_TAG_constant";
5107 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5108 case DW_TAG_file_type
: return "DW_TAG_file_type";
5109 case DW_TAG_friend
: return "DW_TAG_friend";
5110 case DW_TAG_namelist
: return "DW_TAG_namelist";
5111 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5112 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5113 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5114 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5115 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5116 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5117 case DW_TAG_try_block
: return "DW_TAG_try_block";
5118 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5119 case DW_TAG_variable
: return "DW_TAG_variable";
5120 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5121 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5122 case DW_TAG_format_label
: return "DW_TAG_format_label";
5123 case DW_TAG_function_template
: return "DW_TAG_function_template";
5124 case DW_TAG_class_template
: return "DW_TAG_class_template";
5127 static char buffer
[100];
5129 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
5136 get_AT_name (attribute
)
5137 unsigned long attribute
;
5141 case DW_AT_sibling
: return "DW_AT_sibling";
5142 case DW_AT_location
: return "DW_AT_location";
5143 case DW_AT_name
: return "DW_AT_name";
5144 case DW_AT_ordering
: return "DW_AT_ordering";
5145 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
5146 case DW_AT_byte_size
: return "DW_AT_byte_size";
5147 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
5148 case DW_AT_bit_size
: return "DW_AT_bit_size";
5149 case DW_AT_element_list
: return "DW_AT_element_list";
5150 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
5151 case DW_AT_low_pc
: return "DW_AT_low_pc";
5152 case DW_AT_high_pc
: return "DW_AT_high_pc";
5153 case DW_AT_language
: return "DW_AT_language";
5154 case DW_AT_member
: return "DW_AT_member";
5155 case DW_AT_discr
: return "DW_AT_discr";
5156 case DW_AT_discr_value
: return "DW_AT_discr_value";
5157 case DW_AT_visibility
: return "DW_AT_visibility";
5158 case DW_AT_import
: return "DW_AT_import";
5159 case DW_AT_string_length
: return "DW_AT_string_length";
5160 case DW_AT_common_reference
: return "DW_AT_common_reference";
5161 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5162 case DW_AT_const_value
: return "DW_AT_const_value";
5163 case DW_AT_containing_type
: return "DW_AT_containing_type";
5164 case DW_AT_default_value
: return "DW_AT_default_value";
5165 case DW_AT_inline
: return "DW_AT_inline";
5166 case DW_AT_is_optional
: return "DW_AT_is_optional";
5167 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5168 case DW_AT_producer
: return "DW_AT_producer";
5169 case DW_AT_prototyped
: return "DW_AT_prototyped";
5170 case DW_AT_return_addr
: return "DW_AT_return_addr";
5171 case DW_AT_start_scope
: return "DW_AT_start_scope";
5172 case DW_AT_stride_size
: return "DW_AT_stride_size";
5173 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5174 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5175 case DW_AT_accessibility
: return "DW_AT_accessibility";
5176 case DW_AT_address_class
: return "DW_AT_address_class";
5177 case DW_AT_artificial
: return "DW_AT_artificial";
5178 case DW_AT_base_types
: return "DW_AT_base_types";
5179 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5180 case DW_AT_count
: return "DW_AT_count";
5181 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5182 case DW_AT_decl_column
: return "DW_AT_decl_column";
5183 case DW_AT_decl_file
: return "DW_AT_decl_file";
5184 case DW_AT_decl_line
: return "DW_AT_decl_line";
5185 case DW_AT_declaration
: return "DW_AT_declaration";
5186 case DW_AT_discr_list
: return "DW_AT_discr_list";
5187 case DW_AT_encoding
: return "DW_AT_encoding";
5188 case DW_AT_external
: return "DW_AT_external";
5189 case DW_AT_frame_base
: return "DW_AT_frame_base";
5190 case DW_AT_friend
: return "DW_AT_friend";
5191 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5192 case DW_AT_macro_info
: return "DW_AT_macro_info";
5193 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5194 case DW_AT_priority
: return "DW_AT_priority";
5195 case DW_AT_segment
: return "DW_AT_segment";
5196 case DW_AT_specification
: return "DW_AT_specification";
5197 case DW_AT_static_link
: return "DW_AT_static_link";
5198 case DW_AT_type
: return "DW_AT_type";
5199 case DW_AT_use_location
: return "DW_AT_use_location";
5200 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5201 case DW_AT_virtuality
: return "DW_AT_virtuality";
5202 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5203 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5204 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5205 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5206 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5207 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5208 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5209 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5210 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5211 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5212 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5213 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5214 case DW_AT_sf_names
: return "DW_AT_sf_names";
5215 case DW_AT_src_info
: return "DW_AT_src_info";
5216 case DW_AT_mac_info
: return "DW_AT_mac_info";
5217 case DW_AT_src_coords
: return "DW_AT_src_coords";
5218 case DW_AT_body_begin
: return "DW_AT_body_begin";
5219 case DW_AT_body_end
: return "DW_AT_body_end";
5222 static char buffer
[100];
5224 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5231 get_FORM_name (form
)
5236 case DW_FORM_addr
: return "DW_FORM_addr";
5237 case DW_FORM_block2
: return "DW_FORM_block2";
5238 case DW_FORM_block4
: return "DW_FORM_block4";
5239 case DW_FORM_data2
: return "DW_FORM_data2";
5240 case DW_FORM_data4
: return "DW_FORM_data4";
5241 case DW_FORM_data8
: return "DW_FORM_data8";
5242 case DW_FORM_string
: return "DW_FORM_string";
5243 case DW_FORM_block
: return "DW_FORM_block";
5244 case DW_FORM_block1
: return "DW_FORM_block1";
5245 case DW_FORM_data1
: return "DW_FORM_data1";
5246 case DW_FORM_flag
: return "DW_FORM_flag";
5247 case DW_FORM_sdata
: return "DW_FORM_sdata";
5248 case DW_FORM_strp
: return "DW_FORM_strp";
5249 case DW_FORM_udata
: return "DW_FORM_udata";
5250 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5251 case DW_FORM_ref1
: return "DW_FORM_ref1";
5252 case DW_FORM_ref2
: return "DW_FORM_ref2";
5253 case DW_FORM_ref4
: return "DW_FORM_ref4";
5254 case DW_FORM_ref8
: return "DW_FORM_ref8";
5255 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5256 case DW_FORM_indirect
: return "DW_FORM_indirect";
5259 static char buffer
[100];
5261 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5267 /* FIXME: There are better and more effiecint ways to handle
5268 these structures. For now though, I just want something that
5269 is simple to implement. */
5270 typedef struct abbrev_attr
5272 unsigned long attribute
;
5274 struct abbrev_attr
* next
;
5278 typedef struct abbrev_entry
5280 unsigned long entry
;
5283 struct abbrev_attr
* first_attr
;
5284 struct abbrev_attr
* last_attr
;
5285 struct abbrev_entry
* next
;
5289 static abbrev_entry
* first_abbrev
= NULL
;
5290 static abbrev_entry
* last_abbrev
= NULL
;
5293 free_abbrevs
PARAMS ((void))
5295 abbrev_entry
* abbrev
;
5297 for (abbrev
= first_abbrev
; abbrev
;)
5299 abbrev_entry
* next
= abbrev
->next
;
5302 for (attr
= abbrev
->first_attr
; attr
;)
5304 abbrev_attr
* next
= attr
->next
;
5314 last_abbrev
= first_abbrev
= NULL
;
5318 add_abbrev (number
, tag
, children
)
5319 unsigned long number
;
5323 abbrev_entry
* entry
;
5325 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
5331 entry
->entry
= number
;
5333 entry
->children
= children
;
5334 entry
->first_attr
= NULL
;
5335 entry
->last_attr
= NULL
;
5338 if (first_abbrev
== NULL
)
5339 first_abbrev
= entry
;
5341 last_abbrev
->next
= entry
;
5343 last_abbrev
= entry
;
5347 add_abbrev_attr (attribute
, form
)
5348 unsigned long attribute
;
5353 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
5359 attr
->attribute
= attribute
;
5363 if (last_abbrev
->first_attr
== NULL
)
5364 last_abbrev
->first_attr
= attr
;
5366 last_abbrev
->last_attr
->next
= attr
;
5368 last_abbrev
->last_attr
= attr
;
5371 /* Processes the (partial) contents of a .debug_abbrev section.
5372 Returns NULL if the end of the section was encountered.
5373 Returns the address after the last byte read if the end of
5374 an abbreviation set was found. */
5376 static unsigned char *
5377 process_abbrev_section (start
, end
)
5378 unsigned char * start
;
5379 unsigned char * end
;
5381 if (first_abbrev
!= NULL
)
5387 unsigned long entry
;
5389 unsigned long attribute
;
5392 entry
= read_leb128 (start
, & bytes_read
, 0);
5393 start
+= bytes_read
;
5395 /* A single zero is supposed to end the section according
5396 to the standard. If there's more, then signal that to
5399 return start
== end
? NULL
: start
;
5401 tag
= read_leb128 (start
, & bytes_read
, 0);
5402 start
+= bytes_read
;
5404 children
= * start
++;
5406 add_abbrev (entry
, tag
, children
);
5412 attribute
= read_leb128 (start
, & bytes_read
, 0);
5413 start
+= bytes_read
;
5415 form
= read_leb128 (start
, & bytes_read
, 0);
5416 start
+= bytes_read
;
5419 add_abbrev_attr (attribute
, form
);
5421 while (attribute
!= 0);
5429 display_debug_abbrev (section
, start
, file
)
5430 Elf32_Internal_Shdr
* section
;
5431 unsigned char * start
;
5432 FILE * file ATTRIBUTE_UNUSED
;
5434 abbrev_entry
* entry
;
5435 unsigned char * end
= start
+ section
->sh_size
;
5437 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5441 start
= process_abbrev_section (start
, end
);
5443 printf (_(" Number TAG\n"));
5445 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5449 printf (_(" %ld %s [%s]\n"),
5451 get_TAG_name (entry
->tag
),
5452 entry
->children
? _("has children") : _("no children"));
5454 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5456 printf (_(" %-18s %s\n"),
5457 get_AT_name (attr
->attribute
),
5458 get_FORM_name (attr
->form
));
5470 static unsigned char *
5471 display_block (data
, length
)
5472 unsigned char * data
;
5473 unsigned long length
;
5475 printf (_(" %lu byte block: "), length
);
5478 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
5484 decode_location_expression (data
, pointer_size
)
5485 unsigned char * data
;
5486 unsigned int pointer_size
;
5490 unsigned long uvalue
;
5497 printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data
, pointer_size
));
5500 printf ("DW_OP_deref");
5503 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
, 1));
5506 printf ("DW_OP_const1s: %ld", (long) byte_get (data
, 1));
5509 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
5512 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
5515 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
5518 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
5521 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
5522 (unsigned long) byte_get (data
+ 4, 4));
5525 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
5526 (long) byte_get (data
+ 4, 4));
5529 printf ("DW_OP_constu: %lu", read_leb128 (data
, NULL
, 0));
5532 printf ("DW_OP_consts: %ld", read_leb128 (data
, NULL
, 1));
5535 printf ("DW_OP_dup");
5538 printf ("DW_OP_drop");
5541 printf ("DW_OP_over");
5544 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
, 1));
5547 printf ("DW_OP_swap");
5550 printf ("DW_OP_rot");
5553 printf ("DW_OP_xderef");
5556 printf ("DW_OP_abs");
5559 printf ("DW_OP_and");
5562 printf ("DW_OP_div");
5565 printf ("DW_OP_minus");
5568 printf ("DW_OP_mod");
5571 printf ("DW_OP_mul");
5574 printf ("DW_OP_neg");
5577 printf ("DW_OP_not");
5580 printf ("DW_OP_or");
5583 printf ("DW_OP_plus");
5585 case DW_OP_plus_uconst
:
5586 printf ("DW_OP_plus_uconst: %lu", read_leb128 (data
, NULL
, 0));
5589 printf ("DW_OP_shl");
5592 printf ("DW_OP_shr");
5595 printf ("DW_OP_shra");
5598 printf ("DW_OP_xor");
5601 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
5604 printf ("DW_OP_eq");
5607 printf ("DW_OP_ge");
5610 printf ("DW_OP_gt");
5613 printf ("DW_OP_le");
5616 printf ("DW_OP_lt");
5619 printf ("DW_OP_ne");
5622 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
5625 printf ("DW_OP_lit0");
5628 printf ("DW_OP_lit1");
5631 printf ("DW_OP_lit2");
5634 printf ("DW_OP_lit3");
5637 printf ("DW_OP_lit4");
5640 printf ("DW_OP_lit5");
5643 printf ("DW_OP_lit6");
5646 printf ("DW_OP_lit7");
5649 printf ("DW_OP_lit8");
5652 printf ("DW_OP_lit9");
5655 printf ("DW_OP_lit10");
5658 printf ("DW_OP_lit11");
5661 printf ("DW_OP_lit12");
5664 printf ("DW_OP_lit13");
5667 printf ("DW_OP_lit14");
5670 printf ("DW_OP_lit15");
5673 printf ("DW_OP_lit16");
5676 printf ("DW_OP_lit17");
5679 printf ("DW_OP_lit18");
5682 printf ("DW_OP_lit19");
5685 printf ("DW_OP_lit20");
5688 printf ("DW_OP_lit21");
5691 printf ("DW_OP_lit22");
5694 printf ("DW_OP_lit23");
5697 printf ("DW_OP_lit24");
5700 printf ("DW_OP_lit25");
5703 printf ("DW_OP_lit26");
5706 printf ("DW_OP_lit27");
5709 printf ("DW_OP_lit28");
5712 printf ("DW_OP_lit29");
5715 printf ("DW_OP_lit30");
5718 printf ("DW_OP_lit31");
5721 printf ("DW_OP_reg0");
5724 printf ("DW_OP_reg1");
5727 printf ("DW_OP_reg2");
5730 printf ("DW_OP_reg3");
5733 printf ("DW_OP_reg4");
5736 printf ("DW_OP_reg5");
5739 printf ("DW_OP_reg6");
5742 printf ("DW_OP_reg7");
5745 printf ("DW_OP_reg8");
5748 printf ("DW_OP_reg9");
5751 printf ("DW_OP_reg10");
5754 printf ("DW_OP_reg11");
5757 printf ("DW_OP_reg12");
5760 printf ("DW_OP_reg13");
5763 printf ("DW_OP_reg14");
5766 printf ("DW_OP_reg15");
5769 printf ("DW_OP_reg16");
5772 printf ("DW_OP_reg17");
5775 printf ("DW_OP_reg18");
5778 printf ("DW_OP_reg19");
5781 printf ("DW_OP_reg20");
5784 printf ("DW_OP_reg21");
5787 printf ("DW_OP_reg22");
5790 printf ("DW_OP_reg23");
5793 printf ("DW_OP_reg24");
5796 printf ("DW_OP_reg25");
5799 printf ("DW_OP_reg26");
5802 printf ("DW_OP_reg27");
5805 printf ("DW_OP_reg28");
5808 printf ("DW_OP_reg29");
5811 printf ("DW_OP_reg30");
5814 printf ("DW_OP_reg31");
5817 printf ("DW_OP_breg0: %ld", read_leb128 (data
, NULL
, 1));
5820 printf ("DW_OP_breg1: %ld", read_leb128 (data
, NULL
, 1));
5823 printf ("DW_OP_breg2: %ld", read_leb128 (data
, NULL
, 1));
5826 printf ("DW_OP_breg3: %ld", read_leb128 (data
, NULL
, 1));
5829 printf ("DW_OP_breg4: %ld", read_leb128 (data
, NULL
, 1));
5832 printf ("DW_OP_breg5: %ld", read_leb128 (data
, NULL
, 1));
5835 printf ("DW_OP_breg6: %ld", read_leb128 (data
, NULL
, 1));
5838 printf ("DW_OP_breg7: %ld", read_leb128 (data
, NULL
, 1));
5841 printf ("DW_OP_breg8: %ld", read_leb128 (data
, NULL
, 1));
5844 printf ("DW_OP_breg9: %ld", read_leb128 (data
, NULL
, 1));
5847 printf ("DW_OP_breg10: %ld", read_leb128 (data
, NULL
, 1));
5850 printf ("DW_OP_breg11: %ld", read_leb128 (data
, NULL
, 1));
5853 printf ("DW_OP_breg12: %ld", read_leb128 (data
, NULL
, 1));
5856 printf ("DW_OP_breg13: %ld", read_leb128 (data
, NULL
, 1));
5859 printf ("DW_OP_breg14: %ld", read_leb128 (data
, NULL
, 1));
5862 printf ("DW_OP_breg15: %ld", read_leb128 (data
, NULL
, 1));
5865 printf ("DW_OP_breg16: %ld", read_leb128 (data
, NULL
, 1));
5868 printf ("DW_OP_breg17: %ld", read_leb128 (data
, NULL
, 1));
5871 printf ("DW_OP_breg18: %ld", read_leb128 (data
, NULL
, 1));
5874 printf ("DW_OP_breg19: %ld", read_leb128 (data
, NULL
, 1));
5877 printf ("DW_OP_breg20: %ld", read_leb128 (data
, NULL
, 1));
5880 printf ("DW_OP_breg21: %ld", read_leb128 (data
, NULL
, 1));
5883 printf ("DW_OP_breg22: %ld", read_leb128 (data
, NULL
, 1));
5886 printf ("DW_OP_breg23: %ld", read_leb128 (data
, NULL
, 1));
5889 printf ("DW_OP_breg24: %ld", read_leb128 (data
, NULL
, 1));
5892 printf ("DW_OP_breg25: %ld", read_leb128 (data
, NULL
, 1));
5895 printf ("DW_OP_breg26: %ld", read_leb128 (data
, NULL
, 1));
5898 printf ("DW_OP_breg27: %ld", read_leb128 (data
, NULL
, 1));
5901 printf ("DW_OP_breg28: %ld", read_leb128 (data
, NULL
, 1));
5904 printf ("DW_OP_breg29: %ld", read_leb128 (data
, NULL
, 1));
5907 printf ("DW_OP_breg30: %ld", read_leb128 (data
, NULL
, 1));
5910 printf ("DW_OP_breg31: %ld", read_leb128 (data
, NULL
, 1));
5913 printf ("DW_OP_regx: %lu", read_leb128 (data
, NULL
, 0));
5916 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, NULL
, 1));
5919 uvalue
= read_leb128 (data
, &bytes_read
, 0);
5920 printf ("DW_OP_bregx: %lu %ld", uvalue
,
5921 read_leb128 (data
+ bytes_read
, NULL
, 1));
5924 printf ("DW_OP_piece: %lu", read_leb128 (data
, NULL
, 0));
5926 case DW_OP_deref_size
:
5927 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
, 1));
5929 case DW_OP_xderef_size
:
5930 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
, 1));
5933 printf ("DW_OP_nop");
5937 if (op
>= DW_OP_lo_user
5938 && op
<= DW_OP_hi_user
)
5939 printf (_("(User defined location op)"));
5941 printf (_("(Unknown location op)"));
5947 static unsigned char *
5948 read_and_display_attr (attribute
, form
, data
, pointer_size
)
5949 unsigned long attribute
;
5951 unsigned char * data
;
5952 unsigned long pointer_size
;
5954 unsigned long uvalue
= 0;
5955 unsigned char * block_start
= NULL
;
5959 printf (" %-18s:", get_AT_name (attribute
));
5963 case DW_FORM_ref_addr
:
5968 case DW_FORM_ref_udata
:
5974 case DW_FORM_ref_addr
:
5976 uvalue
= byte_get (data
, pointer_size
);
5977 printf (is_ref
? " <%lx>" : " %#lx", uvalue
);
5978 data
+= pointer_size
;
5984 uvalue
= byte_get (data
++, 1);
5985 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
5990 uvalue
= byte_get (data
, 2);
5992 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
5997 uvalue
= byte_get (data
, 4);
5999 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
6004 uvalue
= byte_get (data
, 4);
6005 printf (" %lx", uvalue
);
6006 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
6010 case DW_FORM_string
:
6011 printf (" %s", data
);
6012 data
+= strlen (data
) + 1;
6016 uvalue
= read_leb128 (data
, & bytes_read
, 1);
6018 printf (" %ld", (long) uvalue
);
6021 case DW_FORM_ref_udata
:
6023 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6025 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
6029 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6030 block_start
= data
+ bytes_read
;
6031 data
= display_block (block_start
, uvalue
);
6032 uvalue
= * block_start
;
6035 case DW_FORM_block1
:
6036 uvalue
= byte_get (data
, 1);
6037 block_start
= data
+ 1;
6038 data
= display_block (block_start
, uvalue
);
6039 uvalue
= * block_start
;
6042 case DW_FORM_block2
:
6043 uvalue
= byte_get (data
, 2);
6044 block_start
= data
+ 2;
6045 data
= display_block (block_start
, uvalue
);
6046 uvalue
= * block_start
;
6049 case DW_FORM_block4
:
6050 uvalue
= byte_get (data
, 4);
6051 block_start
= data
+ 4;
6052 data
= display_block (block_start
, uvalue
);
6053 uvalue
= * block_start
;
6057 case DW_FORM_indirect
:
6058 warn (_("Unable to handle FORM: %d"), form
);
6062 warn (_("Unrecognised form: %d"), form
);
6066 /* For some attributes we can display futher information. */
6075 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6076 case DW_INL_inlined
: printf (_("(inlined)")); break;
6077 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6078 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6079 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6083 case DW_AT_frame_base
:
6084 if (uvalue
>= DW_OP_reg0
&& uvalue
<= DW_OP_reg31
)
6085 printf ("(reg %ld)", uvalue
- DW_OP_reg0
);
6088 case DW_AT_language
:
6091 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6092 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6093 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6094 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6095 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6096 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6097 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6098 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6099 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6100 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6101 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6102 default: printf ("(Unknown: %lx)", uvalue
); break;
6106 case DW_AT_encoding
:
6109 case DW_ATE_void
: printf ("(void)"); break;
6110 case DW_ATE_address
: printf ("(machine address)"); break;
6111 case DW_ATE_boolean
: printf ("(boolean)"); break;
6112 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6113 case DW_ATE_float
: printf ("(float)"); break;
6114 case DW_ATE_signed
: printf ("(signed)"); break;
6115 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6116 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6117 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6119 if (uvalue
>= DW_ATE_lo_user
6120 && uvalue
<= DW_ATE_hi_user
)
6121 printf ("(user defined type)");
6123 printf ("(unknown type)");
6128 case DW_AT_accessibility
:
6131 case DW_ACCESS_public
: printf ("(public)"); break;
6132 case DW_ACCESS_protected
: printf ("(protected)"); break;
6133 case DW_ACCESS_private
: printf ("(private)"); break;
6134 default: printf ("(unknown accessibility)"); break;
6138 case DW_AT_visibility
:
6141 case DW_VIS_local
: printf ("(local)"); break;
6142 case DW_VIS_exported
: printf ("(exported)"); break;
6143 case DW_VIS_qualified
: printf ("(qualified)"); break;
6144 default: printf ("(unknown visibility)"); break;
6148 case DW_AT_virtuality
:
6151 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6152 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6153 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6154 default: printf ("(unknown virtuality)"); break;
6158 case DW_AT_identifier_case
:
6161 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6162 case DW_ID_up_case
: printf ("(up_case)"); break;
6163 case DW_ID_down_case
: printf ("(down_case)"); break;
6164 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6165 default: printf ("(unknown case)"); break;
6169 case DW_AT_calling_convention
:
6172 case DW_CC_normal
: printf ("(normal)"); break;
6173 case DW_CC_program
: printf ("(program)"); break;
6174 case DW_CC_nocall
: printf ("(nocall)"); break;
6176 if (uvalue
>= DW_CC_lo_user
6177 && uvalue
<= DW_CC_hi_user
)
6178 printf ("(user defined)");
6180 printf ("(unknown convention)");
6184 case DW_AT_location
:
6185 case DW_AT_data_member_location
:
6186 case DW_AT_vtable_elem_location
:
6188 decode_location_expression (block_start
, pointer_size
);
6201 display_debug_info (section
, start
, file
)
6202 Elf32_Internal_Shdr
* section
;
6203 unsigned char * start
;
6206 unsigned char * end
= start
+ section
->sh_size
;
6207 unsigned char * section_begin
= start
;
6209 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6213 DWARF2_External_CompUnit
* external
;
6214 DWARF2_Internal_CompUnit compunit
;
6215 unsigned char * tags
;
6219 external
= (DWARF2_External_CompUnit
*) start
;
6221 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6222 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6223 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6224 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6226 tags
= start
+ sizeof (* external
);
6227 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6229 if (compunit
.cu_version
!= 2)
6231 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6235 printf (_(" Compilation Unit:\n"));
6236 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6237 printf (_(" Version: %d\n"), compunit
.cu_version
);
6238 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6239 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6241 if (first_abbrev
!= NULL
)
6244 /* Read in the abbrevs used by this compilation unit. */
6247 Elf32_Internal_Shdr
* sec
;
6248 unsigned char * begin
;
6250 /* Locate the .debug_abbrev section and process it. */
6251 for (i
= 0, sec
= section_headers
;
6252 i
< elf_header
.e_shnum
;
6254 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6257 if (i
== -1 || sec
->sh_size
== 0)
6259 warn (_("Unable to locate .debug_abbrev section!\n"));
6263 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6264 "debug_abbrev section data");
6266 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6267 begin
+ sec
->sh_size
);
6273 while (tags
< start
)
6276 unsigned long abbrev_number
;
6277 abbrev_entry
* entry
;
6280 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6283 /* A null DIE marks the end of a list of children. */
6284 if (abbrev_number
== 0)
6290 /* Scan through the abbreviation list until we reach the
6292 for (entry
= first_abbrev
;
6293 entry
&& entry
->entry
!= abbrev_number
;
6294 entry
= entry
->next
)
6299 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6304 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6305 level
, tags
- section_begin
- bytes_read
,
6307 get_TAG_name (entry
->tag
));
6309 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6310 tags
= read_and_display_attr (attr
->attribute
,
6313 compunit
.cu_pointer_size
);
6315 if (entry
->children
)
6326 display_debug_aranges (section
, start
, file
)
6327 Elf32_Internal_Shdr
* section
;
6328 unsigned char * start
;
6329 FILE * file ATTRIBUTE_UNUSED
;
6331 unsigned char * end
= start
+ section
->sh_size
;
6333 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6337 DWARF2_External_ARange
* external
;
6338 DWARF2_Internal_ARange arange
;
6339 unsigned char * ranges
;
6340 unsigned long length
;
6341 unsigned long address
;
6344 external
= (DWARF2_External_ARange
*) start
;
6346 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6347 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6348 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6349 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6350 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6352 printf (_(" Length: %ld\n"), arange
.ar_length
);
6353 printf (_(" Version: %d\n"), arange
.ar_version
);
6354 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6355 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6356 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6358 printf (_("\n Address Length\n"));
6360 ranges
= start
+ sizeof (* external
);
6362 /* Must pad to an alignment boundary that is twice the pointer size. */
6363 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
6365 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6369 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6371 ranges
+= arange
.ar_pointer_size
;
6373 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6375 ranges
+= arange
.ar_pointer_size
;
6377 /* A pair of zeros marks the end of the list. */
6378 if (address
== 0 && length
== 0)
6381 printf (" %8.8lx %lu\n", address
, length
);
6384 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6394 display_debug_not_supported (section
, start
, file
)
6395 Elf32_Internal_Shdr
* section
;
6396 unsigned char * start ATTRIBUTE_UNUSED
;
6397 FILE * file ATTRIBUTE_UNUSED
;
6399 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6400 SECTION_NAME (section
));
6405 /* Pre-scan the .debug_info section to record the size of address.
6406 When dumping the .debug_line, we use that size information, assuming
6407 that all compilation units have the same address size. */
6409 prescan_debug_info (section
, start
, file
)
6410 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
6411 unsigned char * start
;
6412 FILE * file ATTRIBUTE_UNUSED
;
6414 DWARF2_External_CompUnit
* external
;
6416 external
= (DWARF2_External_CompUnit
*) start
;
6418 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6422 /* A structure containing the name of a debug section and a pointer
6423 to a function that can decode it. The third field is a prescan
6424 function to be run over the section before displaying any of the
6429 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6430 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6434 { ".debug_info", display_debug_info
, prescan_debug_info
},
6435 { ".debug_abbrev", display_debug_abbrev
, NULL
},
6436 { ".debug_line", display_debug_lines
, NULL
},
6437 { ".debug_aranges", display_debug_aranges
, NULL
},
6438 { ".debug_pubnames", display_debug_pubnames
, NULL
},
6439 { ".debug_macinfo", display_debug_not_supported
, NULL
},
6440 { ".debug_frame", display_debug_not_supported
, NULL
},
6441 { ".debug_str", display_debug_not_supported
, NULL
},
6442 { ".debug_static_func", display_debug_not_supported
, NULL
},
6443 { ".debug_static_vars", display_debug_not_supported
, NULL
},
6444 { ".debug_types", display_debug_not_supported
, NULL
},
6445 { ".debug_weaknames", display_debug_not_supported
, NULL
}
6449 display_debug_section (section
, file
)
6450 Elf32_Internal_Shdr
* section
;
6453 char * name
= SECTION_NAME (section
);
6454 bfd_size_type length
;
6455 unsigned char * start
;
6458 length
= section
->sh_size
;
6461 printf (_("\nSection '%s' has no debugging data.\n"), name
);
6465 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6466 "debug section data");
6468 /* See if we know how to display the contents of this section. */
6469 for (i
= NUM_ELEM (debug_displays
); i
--;)
6470 if (strcmp (debug_displays
[i
].name
, name
) == 0)
6472 debug_displays
[i
].display (section
, start
, file
);
6477 printf (_("Unrecognised debug section: %s\n"), name
);
6481 /* If we loaded in the abbrev section at some point,
6482 we must release it here. */
6483 if (first_abbrev
!= NULL
)
6490 process_section_contents (file
)
6493 Elf32_Internal_Shdr
* section
;
6499 /* Pre-scan the debug sections to find some debug information not
6500 present in some of them. For the .debug_line, we must find out the
6501 size of address (specified in .debug_info and .debug_aranges). */
6502 for (i
= 0, section
= section_headers
;
6503 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6506 char * name
= SECTION_NAME (section
);
6509 if (section
->sh_size
== 0)
6512 /* See if there is some pre-scan operation for this section. */
6513 for (j
= NUM_ELEM (debug_displays
); j
--;)
6514 if (strcmp (debug_displays
[j
].name
, name
) == 0)
6516 if (debug_displays
[j
].prescan
!= NULL
)
6518 bfd_size_type length
;
6519 unsigned char * start
;
6521 length
= section
->sh_size
;
6522 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6523 "debug section data");
6525 debug_displays
[j
].prescan (section
, start
, file
);
6533 for (i
= 0, section
= section_headers
;
6534 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6537 #ifdef SUPPORT_DISASSEMBLY
6538 if (dump_sects
[i
] & DISASS_DUMP
)
6539 disassemble_section (section
, file
);
6541 if (dump_sects
[i
] & HEX_DUMP
)
6542 dump_section (section
, file
);
6544 if (dump_sects
[i
] & DEBUG_DUMP
)
6545 display_debug_section (section
, file
);
6548 if (i
< num_dump_sects
)
6549 warn (_("Some sections were not dumped because they do not exist!\n"));
6555 process_mips_fpe_exception (mask
)
6561 if (mask
& OEX_FPU_INEX
)
6562 fputs ("INEX", stdout
), first
= 0;
6563 if (mask
& OEX_FPU_UFLO
)
6564 printf ("%sUFLO", first
? "" : "|"), first
= 0;
6565 if (mask
& OEX_FPU_OFLO
)
6566 printf ("%sOFLO", first
? "" : "|"), first
= 0;
6567 if (mask
& OEX_FPU_DIV0
)
6568 printf ("%sDIV0", first
? "" : "|"), first
= 0;
6569 if (mask
& OEX_FPU_INVAL
)
6570 printf ("%sINVAL", first
? "" : "|");
6573 fputs ("0", stdout
);
6577 process_mips_specific (file
)
6580 Elf_Internal_Dyn
* entry
;
6581 size_t liblist_offset
= 0;
6582 size_t liblistno
= 0;
6583 size_t conflictsno
= 0;
6584 size_t options_offset
= 0;
6585 size_t conflicts_offset
= 0;
6587 /* We have a lot of special sections. Thanks SGI! */
6588 if (dynamic_segment
== NULL
)
6589 /* No information available. */
6592 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
6593 switch (entry
->d_tag
)
6595 case DT_MIPS_LIBLIST
:
6596 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
6598 case DT_MIPS_LIBLISTNO
:
6599 liblistno
= entry
->d_un
.d_val
;
6601 case DT_MIPS_OPTIONS
:
6602 options_offset
= entry
->d_un
.d_val
- loadaddr
;
6604 case DT_MIPS_CONFLICT
:
6605 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
6607 case DT_MIPS_CONFLICTNO
:
6608 conflictsno
= entry
->d_un
.d_val
;
6614 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
6616 Elf32_External_Lib
* elib
;
6619 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
6620 elib
, Elf32_External_Lib
*, "liblist");
6622 printf ("\nSection '.liblist' contains %lu entries:\n",
6623 (unsigned long) liblistno
);
6624 fputs (" Library Time Stamp Checksum Version Flags\n",
6627 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
6633 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
6634 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
6635 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
6636 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
6637 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
6639 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
6641 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
6642 dynamic_strings
+ liblist
.l_name
, timebuf
,
6643 liblist
.l_checksum
, liblist
.l_version
);
6645 if (liblist
.l_flags
== 0)
6656 { " EXACT_MATCH", LL_EXACT_MATCH
},
6657 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
6658 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
6659 { " EXPORTS", LL_EXPORTS
},
6660 { " DELAY_LOAD", LL_DELAY_LOAD
},
6661 { " DELTA", LL_DELTA
}
6663 int flags
= liblist
.l_flags
;
6667 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
6669 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
6671 fputs (l_flags_vals
[fcnt
].name
, stdout
);
6672 flags
^= l_flags_vals
[fcnt
].bit
;
6675 printf (" %#x", (unsigned int) flags
);
6684 if (options_offset
!= 0)
6686 Elf_External_Options
* eopt
;
6687 Elf_Internal_Shdr
* sect
= section_headers
;
6688 Elf_Internal_Options
* iopt
;
6689 Elf_Internal_Options
* option
;
6693 /* Find the section header so that we get the size. */
6694 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
6697 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
6698 Elf_External_Options
*, "options");
6700 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
6704 error (_("Out of memory"));
6711 while (offset
< sect
->sh_size
)
6713 Elf_External_Options
* eoption
;
6715 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
6717 option
->kind
= BYTE_GET (eoption
->kind
);
6718 option
->size
= BYTE_GET (eoption
->size
);
6719 option
->section
= BYTE_GET (eoption
->section
);
6720 option
->info
= BYTE_GET (eoption
->info
);
6722 offset
+= option
->size
;
6728 printf (_("\nSection '%s' contains %d entries:\n"),
6729 string_table
+ sect
->sh_name
, cnt
);
6737 switch (option
->kind
)
6740 /* This shouldn't happen. */
6741 printf (" NULL %d %lx", option
->section
, option
->info
);
6744 printf (" REGINFO ");
6745 if (elf_header
.e_machine
== EM_MIPS
)
6748 Elf32_External_RegInfo
*ereg
;
6749 Elf32_RegInfo reginfo
;
6751 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
6752 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6753 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6754 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6755 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6756 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6757 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
6759 printf ("GPR %08lx GP 0x%lx\n",
6761 (unsigned long) reginfo
.ri_gp_value
);
6762 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6763 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6764 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6769 Elf64_External_RegInfo
* ereg
;
6770 Elf64_Internal_RegInfo reginfo
;
6772 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
6773 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6774 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6775 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6776 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6777 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6778 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
6780 printf ("GPR %08lx GP 0x",
6781 reginfo
.ri_gprmask
);
6782 printf_vma (reginfo
.ri_gp_value
);
6785 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6786 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6787 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6791 case ODK_EXCEPTIONS
:
6792 fputs (" EXCEPTIONS fpe_min(", stdout
);
6793 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
6794 fputs (") fpe_max(", stdout
);
6795 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
6796 fputs (")", stdout
);
6798 if (option
->info
& OEX_PAGE0
)
6799 fputs (" PAGE0", stdout
);
6800 if (option
->info
& OEX_SMM
)
6801 fputs (" SMM", stdout
);
6802 if (option
->info
& OEX_FPDBUG
)
6803 fputs (" FPDBUG", stdout
);
6804 if (option
->info
& OEX_DISMISS
)
6805 fputs (" DISMISS", stdout
);
6808 fputs (" PAD ", stdout
);
6809 if (option
->info
& OPAD_PREFIX
)
6810 fputs (" PREFIX", stdout
);
6811 if (option
->info
& OPAD_POSTFIX
)
6812 fputs (" POSTFIX", stdout
);
6813 if (option
->info
& OPAD_SYMBOL
)
6814 fputs (" SYMBOL", stdout
);
6817 fputs (" HWPATCH ", stdout
);
6818 if (option
->info
& OHW_R4KEOP
)
6819 fputs (" R4KEOP", stdout
);
6820 if (option
->info
& OHW_R8KPFETCH
)
6821 fputs (" R8KPFETCH", stdout
);
6822 if (option
->info
& OHW_R5KEOP
)
6823 fputs (" R5KEOP", stdout
);
6824 if (option
->info
& OHW_R5KCVTL
)
6825 fputs (" R5KCVTL", stdout
);
6828 fputs (" FILL ", stdout
);
6829 /* XXX Print content of info word? */
6832 fputs (" TAGS ", stdout
);
6833 /* XXX Print content of info word? */
6836 fputs (" HWAND ", stdout
);
6837 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6838 fputs (" R4KEOP_CHECKED", stdout
);
6839 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6840 fputs (" R4KEOP_CLEAN", stdout
);
6843 fputs (" HWOR ", stdout
);
6844 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6845 fputs (" R4KEOP_CHECKED", stdout
);
6846 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6847 fputs (" R4KEOP_CLEAN", stdout
);
6850 printf (" GP_GROUP %#06lx self-contained %#06lx",
6851 option
->info
& OGP_GROUP
,
6852 (option
->info
& OGP_SELF
) >> 16);
6855 printf (" IDENT %#06lx self-contained %#06lx",
6856 option
->info
& OGP_GROUP
,
6857 (option
->info
& OGP_SELF
) >> 16);
6860 /* This shouldn't happen. */
6861 printf (" %3d ??? %d %lx",
6862 option
->kind
, option
->section
, option
->info
);
6866 len
= sizeof (*eopt
);
6867 while (len
< option
->size
)
6868 if (((char *) option
)[len
] >= ' '
6869 && ((char *) option
)[len
] < 0x7f)
6870 printf ("%c", ((char *) option
)[len
++]);
6872 printf ("\\%03o", ((char *) option
)[len
++]);
6874 fputs ("\n", stdout
);
6881 if (conflicts_offset
!= 0 && conflictsno
!= 0)
6883 Elf32_External_Conflict
* econf32
;
6884 Elf64_External_Conflict
* econf64
;
6885 Elf32_Conflict
* iconf
;
6888 if (dynamic_symbols
== NULL
)
6890 error (_("conflict list with without table"));
6894 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
6897 error (_("Out of memory"));
6903 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
6904 econf32
, Elf32_External_Conflict
*, "conflict");
6906 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6907 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
6911 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
6912 econf64
, Elf64_External_Conflict
*, "conflict");
6914 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6915 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
6918 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
6919 puts (_(" Num: Index Value Name"));
6921 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6923 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
6925 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
6926 print_vma (psym
->st_value
, FULL_HEX
);
6927 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
6937 get_note_type (e_type
)
6940 static char buff
[64];
6944 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
6945 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
6946 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
6947 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
6948 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
6949 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
6950 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
6951 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
6952 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6953 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
6954 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
6956 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
6961 /* Note that by the ELF standard, the name field is already null byte
6962 terminated, and namesz includes the terminating null byte.
6963 I.E. the value of namesz for the name "FSF" is 4.
6965 If the value of namesz is zero, there is no name present. */
6967 process_note (pnote
)
6968 Elf32_Internal_Note
* pnote
;
6970 printf (" %s\t\t0x%08lx\t%s\n",
6971 pnote
->namesz
? pnote
->namedata
: "(NONE)",
6972 pnote
->descsz
, get_note_type (pnote
->type
));
6978 process_corefile_note_segment (file
, offset
, length
)
6983 Elf_External_Note
* pnotes
;
6984 Elf_External_Note
* external
;
6990 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
6994 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
6995 (unsigned long) offset
,
6996 (unsigned long) length
);
6997 printf (_(" Owner\t\tData size\tDescription\n"));
6999 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
7001 Elf32_Internal_Note inote
;
7004 inote
.type
= BYTE_GET (external
->type
);
7005 inote
.namesz
= BYTE_GET (external
->namesz
);
7006 inote
.namedata
= external
->name
;
7007 inote
.descsz
= BYTE_GET (external
->descsz
);
7008 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
7009 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
7011 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
7013 /* Verify that name is null terminated. It appears that at least
7014 one version of Linux (RedHat 6.0) generates corefiles that don't
7015 comply with the ELF spec by failing to include the null byte in
7017 if (inote
.namedata
[inote
.namesz
] != '\0')
7019 temp
= malloc (inote
.namesz
+ 1);
7023 error (_("Out of memory\n"));
7028 strncpy (temp
, inote
.namedata
, inote
.namesz
);
7029 temp
[inote
.namesz
] = 0;
7031 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7032 inote
.namedata
= temp
;
7035 res
&= process_note (& inote
);
7050 process_corefile_note_segments (file
)
7053 Elf_Internal_Phdr
* program_headers
;
7054 Elf_Internal_Phdr
* segment
;
7058 program_headers
= (Elf_Internal_Phdr
*) malloc
7059 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
7061 if (program_headers
== NULL
)
7063 error (_("Out of memory\n"));
7068 i
= get_32bit_program_headers (file
, program_headers
);
7070 i
= get_64bit_program_headers (file
, program_headers
);
7074 free (program_headers
);
7078 for (i
= 0, segment
= program_headers
;
7079 i
< elf_header
.e_phnum
;
7082 if (segment
->p_type
== PT_NOTE
)
7083 res
&= process_corefile_note_segment (file
,
7084 (bfd_vma
) segment
->p_offset
,
7085 (bfd_vma
) segment
->p_filesz
);
7088 free (program_headers
);
7094 process_corefile_contents (file
)
7097 /* If we have not been asked to display the notes then do nothing. */
7101 /* If file is not a core file then exit. */
7102 if (elf_header
.e_type
!= ET_CORE
)
7105 /* No program headers means no NOTE segment. */
7106 if (elf_header
.e_phnum
== 0)
7108 printf (_("No note segments present in the core file.\n"));
7112 return process_corefile_note_segments (file
);
7116 process_arch_specific (file
)
7122 switch (elf_header
.e_machine
)
7125 case EM_MIPS_RS4_BE
:
7126 return process_mips_specific (file
);
7135 get_file_header (file
)
7138 /* Read in the identity array. */
7139 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
7142 /* Determine how to read the rest of the header. */
7143 switch (elf_header
.e_ident
[EI_DATA
])
7145 default: /* fall through */
7146 case ELFDATANONE
: /* fall through */
7147 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
7148 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
7151 /* For now we only support 32 bit and 64 bit ELF files. */
7152 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
7154 /* Read in the rest of the header. */
7157 Elf32_External_Ehdr ehdr32
;
7159 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
7162 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
7163 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
7164 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
7165 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
7166 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
7167 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
7168 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
7169 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
7170 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
7171 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
7172 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
7173 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
7174 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
7178 Elf64_External_Ehdr ehdr64
;
7180 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7181 we will not be able to cope with the 64bit data found in
7182 64 ELF files. Detect this now and abort before we start
7183 overwritting things. */
7184 if (sizeof (bfd_vma
) < 8)
7186 error (_("This instance of readelf has been built without support for a\n"));
7187 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7191 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
7194 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
7195 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
7196 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
7197 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
7198 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
7199 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
7200 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
7201 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
7202 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
7203 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
7204 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
7205 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
7206 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
7213 process_file (file_name
)
7217 struct stat statbuf
;
7220 if (stat (file_name
, & statbuf
) < 0)
7222 error (_("Cannot stat input file %s.\n"), file_name
);
7226 file
= fopen (file_name
, "rb");
7229 error (_("Input file %s not found.\n"), file_name
);
7233 if (! get_file_header (file
))
7235 error (_("%s: Failed to read file header\n"), file_name
);
7240 /* Initialise per file variables. */
7241 for (i
= NUM_ELEM (version_info
); i
--;)
7242 version_info
[i
] = 0;
7244 for (i
= NUM_ELEM (dynamic_info
); i
--;)
7245 dynamic_info
[i
] = 0;
7247 /* Process the file. */
7249 printf (_("\nFile: %s\n"), file_name
);
7251 if (! process_file_header ())
7257 process_section_headers (file
);
7259 process_program_headers (file
);
7261 process_dynamic_segment (file
);
7263 process_relocs (file
);
7265 process_symbol_table (file
);
7267 process_syminfo (file
);
7269 process_version_sections (file
);
7271 process_section_contents (file
);
7273 process_corefile_contents (file
);
7275 process_arch_specific (file
);
7279 if (section_headers
)
7281 free (section_headers
);
7282 section_headers
= NULL
;
7287 free (string_table
);
7288 string_table
= NULL
;
7291 if (dynamic_strings
)
7293 free (dynamic_strings
);
7294 dynamic_strings
= NULL
;
7297 if (dynamic_symbols
)
7299 free (dynamic_symbols
);
7300 dynamic_symbols
= NULL
;
7301 num_dynamic_syms
= 0;
7304 if (dynamic_syminfo
)
7306 free (dynamic_syminfo
);
7307 dynamic_syminfo
= NULL
;
7311 #ifdef SUPPORT_DISASSEMBLY
7312 /* Needed by the i386 disassembler. For extra credit, someone could
7313 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7317 print_address (unsigned int addr
, FILE * outfile
)
7319 fprintf (outfile
,"0x%8.8x", addr
);
7322 /* Needed by the i386 disassembler. */
7324 db_task_printsym (unsigned int addr
)
7326 print_address (addr
, stderr
);
7335 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7336 setlocale (LC_MESSAGES
, "");
7338 bindtextdomain (PACKAGE
, LOCALEDIR
);
7339 textdomain (PACKAGE
);
7341 parse_args (argc
, argv
);
7343 if (optind
< (argc
- 1))
7346 while (optind
< argc
)
7347 process_file (argv
[optind
++]);
7349 if (dump_sects
!= NULL
)