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
31 /* Define BFD64 here, even if our default architecture is 32 bit ELF
32 as this will allow us to read in and parse 64bit and 32bit ELF files.
33 Only do this if we belive that the compiler can support a 64 bit
34 data type. For now we only rely on GCC being able to do this. */
40 #include "elf/common.h"
41 #include "elf/external.h"
42 #include "elf/internal.h"
43 #include "elf/dwarf2.h"
45 /* The following headers use the elf/reloc-macros.h file to
46 automatically generate relocation recognition functions
47 such as elf_mips_reloc_type() */
49 #define RELOC_MACROS_GEN_FUNC
55 #include "elf/alpha.h"
58 #include "elf/sparc.h"
63 #include "elf/mn10200.h"
64 #include "elf/mn10300.h"
68 #include "elf/mcore.h"
75 #ifdef ANSI_PROTOTYPES
81 char * program_name
= "readelf";
82 unsigned int dynamic_addr
;
83 bfd_size_type dynamic_size
;
84 unsigned int rela_addr
;
85 unsigned int rela_size
;
86 char * dynamic_strings
;
88 unsigned long num_dynamic_syms
;
89 Elf_Internal_Sym
* dynamic_symbols
;
90 Elf_Internal_Syminfo
* dynamic_syminfo
;
91 unsigned long dynamic_syminfo_offset
;
92 unsigned int dynamic_syminfo_nent
;
93 char program_interpreter
[64];
94 int dynamic_info
[DT_JMPREL
+ 1];
97 Elf_Internal_Ehdr elf_header
;
98 Elf_Internal_Shdr
* section_headers
;
99 Elf_Internal_Dyn
* dynamic_segment
;
106 int do_using_dynamic
;
113 int do_debug_abbrevs
;
115 int do_debug_pubnames
;
116 int do_debug_aranges
;
121 /* A dynamic array of flags indicating which sections require dumping. */
122 char * dump_sects
= NULL
;
123 unsigned int num_dump_sects
= 0;
125 #define HEX_DUMP (1 << 0)
126 #define DISASS_DUMP (1 << 1)
127 #define DEBUG_DUMP (1 << 2)
129 /* How to rpint a vma value. */
130 typedef enum print_mode
142 /* Forward declarations for dumb compilers. */
143 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
144 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
145 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
146 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
147 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
148 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
149 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
150 static const char * get_dynamic_type
PARAMS ((unsigned long));
151 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
152 static char * get_file_type
PARAMS ((unsigned));
153 static char * get_machine_name
PARAMS ((unsigned));
154 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
155 static const char * get_mips_segment_type
PARAMS ((unsigned long));
156 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
157 static const char * get_segment_type
PARAMS ((unsigned long));
158 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
159 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
160 static const char * get_section_type_name
PARAMS ((unsigned int));
161 static const char * get_symbol_binding
PARAMS ((unsigned int));
162 static const char * get_symbol_type
PARAMS ((unsigned int));
163 static const char * get_symbol_visibility
PARAMS ((unsigned int));
164 static const char * get_symbol_index_type
PARAMS ((unsigned int));
165 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
166 static void usage
PARAMS ((void));
167 static void parse_args
PARAMS ((int, char **));
168 static int process_file_header
PARAMS ((void));
169 static int process_program_headers
PARAMS ((FILE *));
170 static int process_section_headers
PARAMS ((FILE *));
171 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
172 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
173 static int process_dynamic_segment
PARAMS ((FILE *));
174 static int process_symbol_table
PARAMS ((FILE *));
175 static int process_section_contents
PARAMS ((FILE *));
176 static void process_file
PARAMS ((char *));
177 static int process_relocs
PARAMS ((FILE *));
178 static int process_version_sections
PARAMS ((FILE *));
179 static char * get_ver_flags
PARAMS ((unsigned int));
180 static int get_32bit_section_headers
PARAMS ((FILE *));
181 static int get_64bit_section_headers
PARAMS ((FILE *));
182 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
183 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
184 static int get_file_header
PARAMS ((FILE *));
185 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
186 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
187 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
188 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
189 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
190 #ifdef SUPPORT_DISASSEMBLY
191 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
193 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
194 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
195 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
196 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
197 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
198 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
199 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
200 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
201 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
202 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
203 static void reset_state_machine
PARAMS ((int));
204 static char * get_TAG_name
PARAMS ((unsigned long));
205 static char * get_AT_name
PARAMS ((unsigned long));
206 static char * get_FORM_name
PARAMS ((unsigned long));
207 static void free_abbrevs
PARAMS ((void));
208 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
209 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
210 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
211 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
212 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int));
213 static void request_dump
PARAMS ((unsigned int, char));
214 static const char * get_elf_class
PARAMS ((unsigned char));
215 static const char * get_data_encoding
PARAMS ((unsigned char));
216 static const char * get_osabi_name
PARAMS ((unsigned char));
217 static int guess_is_rela
PARAMS ((unsigned long));
218 static char * get_note_type
PARAMS ((unsigned int));
219 static int process_note
PARAMS ((Elf32_Internal_Note
*));
220 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
221 static int process_corefile_note_segments
PARAMS ((FILE *));
222 static int process_corefile_contents
PARAMS ((FILE *));
224 typedef int Elf32_Word
;
232 #define SECTION_NAME(X) (string_table + (X)->sh_name)
234 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
236 #define BYTE_GET(field) byte_get (field, sizeof (field))
238 /* If we can support a 64 bit data type then BFD64 should be defined
239 and sizeof (bfd_vma) == 8. In this case when translating from an
240 external 8 byte field to an internal field, we can assume that the
241 internal field is also 8 bytes wide and so we can extact all the data.
242 If, however, BFD64 is not defined, then we must assume that the
243 internal data structure only has 4 byte wide fields that are the
244 equivalent of the 8 byte wide external counterparts, and so we must
245 truncate the data. */
247 #define BYTE_GET8(field) byte_get (field, -8)
249 #define BYTE_GET8(field) byte_get (field, 8)
252 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
254 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
255 if (fseek (file, offset, SEEK_SET)) \
257 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
261 var = (type) malloc (size); \
265 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
269 if (fread (var, size, 1, file) != 1) \
271 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
278 #define GET_DATA(offset, var, reason) \
279 if (fseek (file, offset, SEEK_SET)) \
281 error (_("Unable to seek to %x for %s\n"), offset, reason); \
284 else if (fread (& var, sizeof (var), 1, file) != 1) \
286 error (_("Unable to read data at %x for %s\n"), offset, reason); \
290 #define GET_ELF_SYMBOLS(file, offset, size) \
291 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
292 : get_64bit_elf_symbols (file, offset, size))
295 #ifdef ANSI_PROTOTYPES
297 error (const char * message
, ...)
301 fprintf (stderr
, _("%s: Error: "), program_name
);
302 va_start (args
, message
);
303 vfprintf (stderr
, message
, args
);
309 warn (const char * message
, ...)
313 fprintf (stderr
, _("%s: Warning: "), program_name
);
314 va_start (args
, message
);
315 vfprintf (stderr
, message
, args
);
327 fprintf (stderr
, _("%s: Error: "), program_name
);
329 message
= va_arg (args
, char *);
330 vfprintf (stderr
, message
, args
);
342 fprintf (stderr
, _("%s: Warning: "), program_name
);
344 message
= va_arg (args
, char *);
345 vfprintf (stderr
, message
, args
);
352 byte_get_little_endian (field
, size
)
353 unsigned char * field
;
362 return ((unsigned int) (field
[0]))
363 | (((unsigned int) (field
[1])) << 8);
366 /* We want to extract data from an 8 byte wide field and
367 place it into a 4 byte wide field. Since this is a little
368 endian source we can juts use the 4 byte extraction code. */
371 return ((unsigned long) (field
[0]))
372 | (((unsigned long) (field
[1])) << 8)
373 | (((unsigned long) (field
[2])) << 16)
374 | (((unsigned long) (field
[3])) << 24);
378 /* This is a special case, generated by the BYTE_GET8 macro.
379 It means that we are loading an 8 byte value from a field
380 in an external structure into an 8 byte value in a field
381 in an internal strcuture. */
382 return ((bfd_vma
) (field
[0]))
383 | (((bfd_vma
) (field
[1])) << 8)
384 | (((bfd_vma
) (field
[2])) << 16)
385 | (((bfd_vma
) (field
[3])) << 24)
386 | (((bfd_vma
) (field
[4])) << 32)
387 | (((bfd_vma
) (field
[5])) << 40)
388 | (((bfd_vma
) (field
[6])) << 48)
389 | (((bfd_vma
) (field
[7])) << 56);
392 error (_("Unhandled data length: %d\n"), size
);
397 /* Print a VMA value. */
399 print_vma (vma
, mode
)
409 case FULL_HEX
: printf ("0x"); /* drop through */
410 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
411 case PREFIX_HEX
: printf ("0x"); /* drop through */
412 case HEX
: printf ("%lx", (unsigned long) vma
); break;
413 case DEC
: printf ("%ld", (unsigned long) vma
); break;
414 case DEC_5
: printf ("%5ld", (long) vma
); break;
415 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
436 #if BFD_HOST_64BIT_LONG
439 if (_bfd_int64_high (vma
))
440 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
442 printf ("%lx", _bfd_int64_low (vma
));
447 #if BFD_HOST_64BIT_LONG
450 if (_bfd_int64_high (vma
))
452 printf ("++%ld", _bfd_int64_low (vma
));
454 printf ("%ld", _bfd_int64_low (vma
));
459 #if BFD_HOST_64BIT_LONG
460 printf ("%5ld", vma
);
462 if (_bfd_int64_high (vma
))
464 printf ("++%ld", _bfd_int64_low (vma
));
466 printf ("%5ld", _bfd_int64_low (vma
));
471 #if BFD_HOST_64BIT_LONG
474 if (_bfd_int64_high (vma
))
476 printf ("++%lu", _bfd_int64_low (vma
));
478 printf ("%lu", _bfd_int64_low (vma
));
487 byte_get_big_endian (field
, size
)
488 unsigned char * field
;
497 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
500 return ((unsigned long) (field
[3]))
501 | (((unsigned long) (field
[2])) << 8)
502 | (((unsigned long) (field
[1])) << 16)
503 | (((unsigned long) (field
[0])) << 24);
506 /* Although we are extracing data from an 8 byte wide field, we
507 are returning only 4 bytes of data. */
508 return ((unsigned long) (field
[7]))
509 | (((unsigned long) (field
[6])) << 8)
510 | (((unsigned long) (field
[5])) << 16)
511 | (((unsigned long) (field
[4])) << 24);
515 /* This is a special case, generated by the BYTE_GET8 macro.
516 It means that we are loading an 8 byte value from a field
517 in an external structure into an 8 byte value in a field
518 in an internal strcuture. */
519 return ((bfd_vma
) (field
[7]))
520 | (((bfd_vma
) (field
[6])) << 8)
521 | (((bfd_vma
) (field
[5])) << 16)
522 | (((bfd_vma
) (field
[4])) << 24)
523 | (((bfd_vma
) (field
[3])) << 32)
524 | (((bfd_vma
) (field
[2])) << 40)
525 | (((bfd_vma
) (field
[1])) << 48)
526 | (((bfd_vma
) (field
[0])) << 56);
530 error (_("Unhandled data length: %d\n"), size
);
536 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
538 guess_is_rela (e_machine
)
539 unsigned long e_machine
;
543 /* Targets that use REL relocations. */
554 /* Targets that use RELA relocations. */
562 case EM_CYGNUS_MN10200
:
563 case EM_CYGNUS_MN10300
:
589 warn (_("Don't know about relocations on this machine architecture\n"));
594 /* Display the contents of the relocation data found at the specified offset. */
596 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
598 unsigned long rel_offset
;
599 unsigned long rel_size
;
600 Elf_Internal_Sym
* symtab
;
606 Elf_Internal_Rel
* rels
;
607 Elf_Internal_Rela
* relas
;
610 if (is_rela
== UNKNOWN
)
611 is_rela
= guess_is_rela (elf_header
.e_machine
);
617 Elf32_External_Rela
* erelas
;
619 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
620 Elf32_External_Rela
*, "relocs");
622 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
624 relas
= (Elf_Internal_Rela
*)
625 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
629 error(_("out of memory parsing relocs"));
633 for (i
= 0; i
< rel_size
; i
++)
635 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
636 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
637 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
642 rels
= (Elf_Internal_Rel
*) relas
;
646 Elf64_External_Rela
* erelas
;
648 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
649 Elf64_External_Rela
*, "relocs");
651 rel_size
= rel_size
/ sizeof (Elf64_External_Rela
);
653 relas
= (Elf_Internal_Rela
*)
654 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
658 error(_("out of memory parsing relocs"));
662 for (i
= 0; i
< rel_size
; i
++)
664 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
665 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
666 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
671 rels
= (Elf_Internal_Rel
*) relas
;
678 Elf32_External_Rel
* erels
;
680 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
681 Elf32_External_Rel
*, "relocs");
683 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
685 rels
= (Elf_Internal_Rel
*)
686 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
690 error(_("out of memory parsing relocs"));
694 for (i
= 0; i
< rel_size
; i
++)
696 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
697 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
702 relas
= (Elf_Internal_Rela
*) rels
;
706 Elf64_External_Rel
* erels
;
708 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
709 Elf64_External_Rel
*, "relocs");
711 rel_size
= rel_size
/ sizeof (Elf64_External_Rel
);
713 rels
= (Elf_Internal_Rel
*)
714 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
718 error(_("out of memory parsing relocs"));
722 for (i
= 0; i
< rel_size
; i
++)
724 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
725 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
730 relas
= (Elf_Internal_Rela
*) rels
;
736 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
739 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
741 for (i
= 0; i
< rel_size
; i
++)
746 bfd_vma symtab_index
;
751 offset
= relas
[i
].r_offset
;
752 info
= relas
[i
].r_info
;
756 offset
= rels
[i
].r_offset
;
757 info
= rels
[i
].r_info
;
762 type
= ELF32_R_TYPE (info
);
763 symtab_index
= ELF32_R_SYM (info
);
767 if (elf_header
.e_machine
== EM_SPARCV9
)
768 type
= ELF64_R_TYPE_ID (info
);
770 type
= ELF64_R_TYPE (info
);
771 /* The #ifdef BFD64 below is to prevent a compile time warning.
772 We know that if we do not have a 64 bit data type that we
773 will never execute this code anyway. */
775 symtab_index
= ELF64_R_SYM (info
);
779 #ifdef _bfd_int64_low
780 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
782 printf (" %8.8lx %5.5lx ", offset
, info
);
785 switch (elf_header
.e_machine
)
792 rtype
= elf_m32r_reloc_type (type
);
797 rtype
= elf_i386_reloc_type (type
);
801 rtype
= elf_m68k_reloc_type (type
);
805 rtype
= elf_i960_reloc_type (type
);
812 rtype
= elf_sparc_reloc_type (type
);
816 rtype
= v850_reloc_type (type
);
820 rtype
= elf_d10v_reloc_type (type
);
824 rtype
= elf_d30v_reloc_type (type
);
828 rtype
= elf_sh_reloc_type (type
);
831 case EM_CYGNUS_MN10300
:
832 rtype
= elf_mn10300_reloc_type (type
);
835 case EM_CYGNUS_MN10200
:
836 rtype
= elf_mn10200_reloc_type (type
);
840 rtype
= elf_fr30_reloc_type (type
);
844 rtype
= elf_mcore_reloc_type (type
);
848 rtype
= elf_ppc_reloc_type (type
);
853 rtype
= elf_mips_reloc_type (type
);
857 rtype
= elf_alpha_reloc_type (type
);
861 rtype
= elf_arm_reloc_type (type
);
865 rtype
= elf_arc_reloc_type (type
);
869 rtype
= elf_hppa_reloc_type (type
);
873 rtype
= elf_pj_reloc_type (type
);
878 #ifdef _bfd_int64_low
879 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
881 printf (_("unrecognised: %-7lx"), type
);
884 printf ("%-21.21s", rtype
);
890 if (symtab_index
>= nsyms
)
891 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
894 Elf_Internal_Sym
* psym
;
896 psym
= symtab
+ symtab_index
;
899 print_vma (psym
->st_value
, LONG_HEX
);
902 if (psym
->st_name
== 0)
904 SECTION_NAME (section_headers
+ psym
->st_shndx
));
905 else if (strtab
== NULL
)
906 printf (_("<string table index %3ld>"), psym
->st_name
);
908 printf ("%-25.25s", strtab
+ psym
->st_name
);
911 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
917 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
918 print_vma (relas
[i
].r_addend
, LONG_HEX
);
921 if (elf_header
.e_machine
== EM_SPARCV9
922 && !strcmp (rtype
, "R_SPARC_OLO10"))
923 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
934 get_mips_dynamic_type (type
)
939 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
940 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
941 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
942 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
943 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
944 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
945 case DT_MIPS_MSYM
: return "MIPS_MSYM";
946 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
947 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
948 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
949 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
950 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
951 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
952 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
953 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
954 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
955 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
956 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
957 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
958 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
959 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
960 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
961 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
962 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
963 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
964 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
965 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
966 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
967 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
968 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
969 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
970 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
971 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
972 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
973 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
974 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
975 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
976 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
977 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
978 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
979 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
980 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
981 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
988 get_sparc64_dynamic_type (type
)
993 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1000 get_parisc_dynamic_type (type
)
1005 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1006 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1007 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1008 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1009 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1010 case DT_HP_PREINIT
: return "HP_PREINIT";
1011 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1012 case DT_HP_NEEDED
: return "HP_NEEDED";
1013 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1014 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1015 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1016 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1017 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1024 get_dynamic_type (type
)
1027 static char buff
[32];
1031 case DT_NULL
: return "NULL";
1032 case DT_NEEDED
: return "NEEDED";
1033 case DT_PLTRELSZ
: return "PLTRELSZ";
1034 case DT_PLTGOT
: return "PLTGOT";
1035 case DT_HASH
: return "HASH";
1036 case DT_STRTAB
: return "STRTAB";
1037 case DT_SYMTAB
: return "SYMTAB";
1038 case DT_RELA
: return "RELA";
1039 case DT_RELASZ
: return "RELASZ";
1040 case DT_RELAENT
: return "RELAENT";
1041 case DT_STRSZ
: return "STRSZ";
1042 case DT_SYMENT
: return "SYMENT";
1043 case DT_INIT
: return "INIT";
1044 case DT_FINI
: return "FINI";
1045 case DT_SONAME
: return "SONAME";
1046 case DT_RPATH
: return "RPATH";
1047 case DT_SYMBOLIC
: return "SYMBOLIC";
1048 case DT_REL
: return "REL";
1049 case DT_RELSZ
: return "RELSZ";
1050 case DT_RELENT
: return "RELENT";
1051 case DT_PLTREL
: return "PLTREL";
1052 case DT_DEBUG
: return "DEBUG";
1053 case DT_TEXTREL
: return "TEXTREL";
1054 case DT_JMPREL
: return "JMPREL";
1055 case DT_BIND_NOW
: return "BIND_NOW";
1056 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1057 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1058 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1059 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1060 case DT_RUNPATH
: return "RUNPATH";
1061 case DT_FLAGS
: return "FLAGS";
1063 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1064 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1066 case DT_PLTPADSZ
: return "PLTPADSZ";
1067 case DT_MOVEENT
: return "MOVEENT";
1068 case DT_MOVESZ
: return "MOVESZ";
1069 case DT_FEATURE_1
: return "FEATURE_1";
1070 case DT_POSFLAG_1
: return "POSFLAG_1";
1071 case DT_SYMINSZ
: return "SYMINSZ";
1072 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1074 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1075 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1077 case DT_VERSYM
: return "VERSYM";
1079 case DT_RELACOUNT
: return "RELACOUNT";
1080 case DT_RELCOUNT
: return "RELCOUNT";
1081 case DT_FLAGS_1
: return "FLAGS_1";
1082 case DT_VERDEF
: return "VERDEF";
1083 case DT_VERDEFNUM
: return "VERDEFNUM";
1084 case DT_VERNEED
: return "VERNEED";
1085 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1087 case DT_AUXILIARY
: return "AUXILARY";
1088 case DT_USED
: return "USED";
1089 case DT_FILTER
: return "FILTER";
1092 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1094 const char * result
;
1096 switch (elf_header
.e_machine
)
1099 case EM_MIPS_RS4_BE
:
1100 result
= get_mips_dynamic_type (type
);
1103 result
= get_sparc64_dynamic_type (type
);
1113 sprintf (buff
, _("Processor Specific: %lx"), type
);
1115 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1117 const char * result
;
1119 switch (elf_header
.e_machine
)
1122 result
= get_parisc_dynamic_type (type
);
1132 sprintf (buff
, _("Operating System specific: %lx"), type
);
1135 sprintf (buff
, _("<unknown>: %lx"), type
);
1142 get_file_type (e_type
)
1145 static char buff
[32];
1149 case ET_NONE
: return _("NONE (None)");
1150 case ET_REL
: return _("REL (Relocatable file)");
1151 case ET_EXEC
: return _("EXEC (Executable file)");
1152 case ET_DYN
: return _("DYN (Shared object file)");
1153 case ET_CORE
: return _("CORE (Core file)");
1156 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1157 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1158 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1159 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1161 sprintf (buff
, _("<unknown>: %x"), e_type
);
1167 get_machine_name (e_machine
)
1170 static char buff
[64]; /* XXX */
1174 case EM_NONE
: return _("None");
1175 case EM_M32
: return "WE32100";
1176 case EM_SPARC
: return "Sparc";
1177 case EM_386
: return "Intel 80386";
1178 case EM_68K
: return "MC68000";
1179 case EM_88K
: return "MC88000";
1180 case EM_486
: return "Intel 80486";
1181 case EM_860
: return "Intel 80860";
1182 case EM_MIPS
: return "MIPS R3000";
1183 case EM_S370
: return "IBM System/370";
1184 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1185 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1186 case EM_PARISC
: return "HPPA";
1187 case EM_PPC_OLD
: return "Power PC (old)";
1188 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1189 case EM_960
: return "Intel 90860";
1190 case EM_PPC
: return "PowerPC";
1191 case EM_V800
: return "NEC V800";
1192 case EM_FR20
: return "Fujitsu FR20";
1193 case EM_RH32
: return "TRW RH32";
1194 case EM_MCORE
: return "MCORE";
1195 case EM_ARM
: return "ARM";
1196 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1197 case EM_SH
: return "Hitachi SH";
1198 case EM_SPARCV9
: return "Sparc v9";
1199 case EM_TRICORE
: return "Siemens Tricore";
1200 case EM_ARC
: return "Argonaut RISC Core";
1201 case EM_H8_300
: return "Hitachi H8/300";
1202 case EM_H8_300H
: return "Hitachi H8/300H";
1203 case EM_H8S
: return "Hitachi H8S";
1204 case EM_H8_500
: return "Hitachi H8/500";
1205 case EM_IA_64
: return "Intel IA-64";
1206 case EM_MIPS_X
: return "Stanford MIPS-X";
1207 case EM_COLDFIRE
: return "Motorola Coldfire";
1208 case EM_68HC12
: return "Motorola M68HC12";
1209 case EM_ALPHA
: return "Alpha";
1210 case EM_CYGNUS_D10V
: return "d10v";
1211 case EM_CYGNUS_D30V
: return "d30v";
1212 case EM_CYGNUS_ARC
: return "Arc";
1213 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1214 case EM_CYGNUS_V850
: return "NEC v850";
1215 case EM_CYGNUS_MN10300
: return "mn10300";
1216 case EM_CYGNUS_MN10200
: return "mn10200";
1217 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1218 case EM_PJ
: return "picoJava";
1219 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1220 case EM_PCP
: return "Siemens PCP";
1221 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1222 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1223 case EM_STARCORE
: return "Motorola Star*Core processor";
1224 case EM_ME16
: return "Toyota ME16 processor";
1225 case EM_ST100
: return "STMicroelectronics ST100 processor";
1226 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1227 case EM_FX66
: return "Siemens FX66 microcontroller";
1228 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1229 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1230 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1231 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1232 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1233 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1234 case EM_SVX
: return "Silicon Graphics SVx";
1235 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1236 case EM_VAX
: return "Digital VAX";
1238 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1244 get_machine_flags (e_flags
, e_machine
)
1248 static char buf
[1024];
1260 if (e_flags
& EF_CPU32
)
1261 strcat (buf
, ", cpu32");
1265 if (e_flags
& EF_PPC_EMB
)
1266 strcat (buf
, ", emb");
1268 if (e_flags
& EF_PPC_RELOCATABLE
)
1269 strcat (buf
, ", relocatable");
1271 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1272 strcat (buf
, ", relocatable-lib");
1275 case EM_CYGNUS_V850
:
1276 switch (e_flags
& EF_V850_ARCH
)
1279 strcat (buf
, ", v850e");
1282 strcat (buf
, ", v850ea");
1285 strcat (buf
, ", v850");
1288 strcat (buf
, ", unknown v850 architecture variant");
1293 case EM_CYGNUS_M32R
:
1294 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1295 strcat (buf
, ", m32r");
1300 case EM_MIPS_RS4_BE
:
1301 if (e_flags
& EF_MIPS_NOREORDER
)
1302 strcat (buf
, ", noreorder");
1304 if (e_flags
& EF_MIPS_PIC
)
1305 strcat (buf
, ", pic");
1307 if (e_flags
& EF_MIPS_CPIC
)
1308 strcat (buf
, ", cpic");
1310 if (e_flags
& EF_MIPS_ABI2
)
1311 strcat (buf
, ", abi2");
1313 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1314 strcat (buf
, ", mips1");
1316 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1317 strcat (buf
, ", mips2");
1319 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1320 strcat (buf
, ", mips3");
1322 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1323 strcat (buf
, ", mips4");
1327 if (e_flags
& EF_SPARC_32PLUS
)
1328 strcat (buf
, ", v8+");
1330 if (e_flags
& EF_SPARC_SUN_US1
)
1331 strcat (buf
, ", ultrasparcI");
1333 if (e_flags
& EF_SPARC_SUN_US3
)
1334 strcat (buf
, ", ultrasparcIII");
1336 if (e_flags
& EF_SPARC_HAL_R1
)
1337 strcat (buf
, ", halr1");
1339 if (e_flags
& EF_SPARC_LEDATA
)
1340 strcat (buf
, ", ledata");
1342 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1343 strcat (buf
, ", tso");
1345 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1346 strcat (buf
, ", pso");
1348 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1349 strcat (buf
, ", rmo");
1353 switch (e_flags
& EF_PARISC_ARCH
)
1355 case EFA_PARISC_1_0
:
1356 strcpy (buf
, ", PA-RISC 1.0");
1358 case EFA_PARISC_1_1
:
1359 strcpy (buf
, ", PA-RISC 1.1");
1361 case EFA_PARISC_2_0
:
1362 strcpy (buf
, ", PA-RISC 2.0");
1367 if (e_flags
& EF_PARISC_TRAPNIL
)
1368 strcat (buf
, ", trapnil");
1369 if (e_flags
& EF_PARISC_EXT
)
1370 strcat (buf
, ", ext");
1371 if (e_flags
& EF_PARISC_LSB
)
1372 strcat (buf
, ", lsb");
1373 if (e_flags
& EF_PARISC_WIDE
)
1374 strcat (buf
, ", wide");
1375 if (e_flags
& EF_PARISC_NO_KABP
)
1376 strcat (buf
, ", no kabp");
1377 if (e_flags
& EF_PARISC_LAZYSWAP
)
1378 strcat (buf
, ", lazyswap");
1382 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1383 strcat (buf
, ", new calling convention");
1385 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1386 strcat (buf
, ", gnu calling convention");
1395 get_mips_segment_type (type
)
1400 case PT_MIPS_REGINFO
:
1402 case PT_MIPS_RTPROC
:
1404 case PT_MIPS_OPTIONS
:
1414 get_parisc_segment_type (type
)
1419 case PT_HP_TLS
: return "HP_TLS";
1420 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1421 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1422 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1423 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1424 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1425 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1426 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1427 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1428 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1429 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1430 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1431 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1432 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1441 get_segment_type (p_type
)
1442 unsigned long p_type
;
1444 static char buff
[32];
1448 case PT_NULL
: return "NULL";
1449 case PT_LOAD
: return "LOAD";
1450 case PT_DYNAMIC
: return "DYNAMIC";
1451 case PT_INTERP
: return "INTERP";
1452 case PT_NOTE
: return "NOTE";
1453 case PT_SHLIB
: return "SHLIB";
1454 case PT_PHDR
: return "PHDR";
1457 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1459 const char * result
;
1461 switch (elf_header
.e_machine
)
1464 case EM_MIPS_RS4_BE
:
1465 result
= get_mips_segment_type (p_type
);
1468 result
= get_parisc_segment_type (p_type
);
1478 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1480 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1482 const char * result
;
1484 switch (elf_header
.e_machine
)
1487 result
= get_parisc_segment_type (p_type
);
1497 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1500 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1507 get_mips_section_type_name (sh_type
)
1508 unsigned int sh_type
;
1512 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1513 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1514 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1515 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1516 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1517 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1518 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1519 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1520 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1521 case SHT_MIPS_RELD
: return "MIPS_RELD";
1522 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1523 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1524 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1525 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1526 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1527 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1528 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1529 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1530 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1531 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1532 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1533 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1534 case SHT_MIPS_LINE
: return "MIPS_LINE";
1535 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1536 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1537 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1538 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1539 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1540 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1541 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1542 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1543 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1544 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1545 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1546 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1547 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1548 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1549 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1550 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1558 get_parisc_section_type_name (sh_type
)
1559 unsigned int sh_type
;
1563 case SHT_PARISC_EXT
: return "PARISC_EXT";
1564 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1565 case SHT_PARISC_DOC
: return "PARISC_DOC";
1573 get_section_type_name (sh_type
)
1574 unsigned int sh_type
;
1576 static char buff
[32];
1580 case SHT_NULL
: return "NULL";
1581 case SHT_PROGBITS
: return "PROGBITS";
1582 case SHT_SYMTAB
: return "SYMTAB";
1583 case SHT_STRTAB
: return "STRTAB";
1584 case SHT_RELA
: return "RELA";
1585 case SHT_HASH
: return "HASH";
1586 case SHT_DYNAMIC
: return "DYNAMIC";
1587 case SHT_NOTE
: return "NOTE";
1588 case SHT_NOBITS
: return "NOBITS";
1589 case SHT_REL
: return "REL";
1590 case SHT_SHLIB
: return "SHLIB";
1591 case SHT_DYNSYM
: return "DYNSYM";
1592 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1593 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1594 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1595 case SHT_GNU_verdef
: return "VERDEF";
1596 case SHT_GNU_verneed
: return "VERNEED";
1597 case SHT_GNU_versym
: return "VERSYM";
1598 case 0x6ffffff0: return "VERSYM";
1599 case 0x6ffffffc: return "VERDEF";
1600 case 0x7ffffffd: return "AUXILIARY";
1601 case 0x7fffffff: return "FILTER";
1604 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1606 const char * result
;
1608 switch (elf_header
.e_machine
)
1611 case EM_MIPS_RS4_BE
:
1612 result
= get_mips_section_type_name (sh_type
);
1615 result
= get_parisc_section_type_name (sh_type
);
1625 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1627 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1628 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1629 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1630 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1632 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1638 struct option options
[] =
1640 {"all", no_argument
, 0, 'a'},
1641 {"file-header", no_argument
, 0, 'h'},
1642 {"program-headers", no_argument
, 0, 'l'},
1643 {"headers", no_argument
, 0, 'e'},
1644 {"histogram", no_argument
, 0, 'I'},
1645 {"segments", no_argument
, 0, 'l'},
1646 {"sections", no_argument
, 0, 'S'},
1647 {"section-headers", no_argument
, 0, 'S'},
1648 {"symbols", no_argument
, 0, 's'},
1649 {"syms", no_argument
, 0, 's'},
1650 {"relocs", no_argument
, 0, 'r'},
1651 {"notes", no_argument
, 0, 'n'},
1652 {"dynamic", no_argument
, 0, 'd'},
1653 {"arch-specific", no_argument
, 0, 'A'},
1654 {"version-info", no_argument
, 0, 'V'},
1655 {"use-dynamic", no_argument
, 0, 'D'},
1656 {"hex-dump", required_argument
, 0, 'x'},
1657 {"debug-dump", optional_argument
, 0, 'w'},
1658 #ifdef SUPPORT_DISASSEMBLY
1659 {"instruction-dump", required_argument
, 0, 'i'},
1662 {"version", no_argument
, 0, 'v'},
1663 {"help", no_argument
, 0, 'H'},
1664 {0, no_argument
, 0, 0}
1670 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1671 fprintf (stdout
, _(" Options are:\n"));
1672 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1673 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1674 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1675 fprintf (stdout
, _(" Display the program headers\n"));
1676 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1677 fprintf (stdout
, _(" Display the sections' header\n"));
1678 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1679 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1680 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1681 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1682 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1683 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1684 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1685 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1686 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1687 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1688 fprintf (stdout
, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1689 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1690 #ifdef SUPPORT_DISASSEMBLY
1691 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1692 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1694 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1695 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1696 fprintf (stdout
, _(" -H or --help Display this information\n"));
1697 fprintf (stdout
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1703 request_dump (section
, type
)
1704 unsigned int section
;
1707 if (section
>= num_dump_sects
)
1709 char * new_dump_sects
;
1711 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1713 if (new_dump_sects
== NULL
)
1714 error (_("Out of memory allocating dump request table."));
1717 /* Copy current flag settings. */
1718 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1722 dump_sects
= new_dump_sects
;
1723 num_dump_sects
= section
+ 1;
1728 dump_sects
[section
] |= type
;
1734 parse_args (argc
, argv
)
1743 while ((c
= getopt_long
1744 (argc
, argv
, "ersahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
1779 do_using_dynamic
++;
1807 section
= strtoul (optarg
, & cp
, 0);
1808 if (! * cp
&& section
>= 0)
1810 request_dump (section
, HEX_DUMP
);
1830 do_debug_abbrevs
= 1;
1840 do_debug_pubnames
= 1;
1845 do_debug_aranges
= 1;
1849 warn (_("Unrecognised debug option '%s'\n"), optarg
);
1854 #ifdef SUPPORT_DISASSEMBLY
1857 section
= strtoul (optarg
, & cp
, 0);
1858 if (! * cp
&& section
>= 0)
1860 request_dump (section
, DISASS_DUMP
);
1866 print_version (program_name
);
1873 /* xgettext:c-format */
1874 error (_("Invalid option '-%c'\n"), c
);
1881 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
1882 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
1883 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
1887 warn (_("Nothing to do.\n"));
1893 get_elf_class (elf_class
)
1894 unsigned char elf_class
;
1896 static char buff
[32];
1900 case ELFCLASSNONE
: return _("none");
1901 case ELFCLASS32
: return _("ELF32");
1902 case ELFCLASS64
: return _("ELF64");
1904 sprintf (buff
, _("<unknown: %x>"), elf_class
);
1910 get_data_encoding (encoding
)
1911 unsigned char encoding
;
1913 static char buff
[32];
1917 case ELFDATANONE
: return _("none");
1918 case ELFDATA2LSB
: return _("2's complement, little endian");
1919 case ELFDATA2MSB
: return _("2's complement, big endian");
1921 sprintf (buff
, _("<unknown: %x>"), encoding
);
1927 get_osabi_name (osabi
)
1928 unsigned char osabi
;
1930 static char buff
[32];
1934 case ELFOSABI_SYSV
: return _("UNIX - System V");
1935 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
1936 case ELFOSABI_LINUX
: return _("UNIX - Linux");
1937 case ELFOSABI_STANDALONE
: return _("Standalone App");
1938 case ELFOSABI_ARM
: return _("ARM");
1940 sprintf (buff
, _("<unknown: %x>"), osabi
);
1945 /* Decode the data held in 'elf_header'. */
1947 process_file_header ()
1949 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
1950 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
1951 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
1952 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1955 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1963 printf (_("ELF Header:\n"));
1964 printf (_(" Magic: "));
1965 for (i
= 0; i
< EI_NIDENT
; i
++)
1966 printf ("%2.2x ", elf_header
.e_ident
[i
]);
1968 printf (_(" Class: %s\n"),
1969 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
1970 printf (_(" Data: %s\n"),
1971 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
1972 printf (_(" Version: %d %s\n"),
1973 elf_header
.e_ident
[EI_VERSION
],
1974 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
1976 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
1979 printf (_(" OS/ABI: %s\n"),
1980 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
1981 printf (_(" ABI Version: %d\n"),
1982 elf_header
.e_ident
[EI_ABIVERSION
]);
1983 printf (_(" Type: %s\n"),
1984 get_file_type (elf_header
.e_type
));
1985 printf (_(" Machine: %s\n"),
1986 get_machine_name (elf_header
.e_machine
));
1987 printf (_(" Version: 0x%lx\n"),
1988 (unsigned long) elf_header
.e_version
);
1990 printf (_(" Entry point address: "));
1991 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
1992 printf (_("\n Start of program headers: "));
1993 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
1994 printf (_(" (bytes into file)\n Start of section headers: "));
1995 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
1996 printf (_(" (bytes into file)\n"));
1998 printf (_(" Flags: 0x%lx%s\n"),
1999 (unsigned long) elf_header
.e_flags
,
2000 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2001 printf (_(" Size of this header: %ld (bytes)\n"),
2002 (long) elf_header
.e_ehsize
);
2003 printf (_(" Size of program headers: %ld (bytes)\n"),
2004 (long) elf_header
.e_phentsize
);
2005 printf (_(" Number of program headers: %ld\n"),
2006 (long) elf_header
.e_phnum
);
2007 printf (_(" Size of section headers: %ld (bytes)\n"),
2008 (long) elf_header
.e_shentsize
);
2009 printf (_(" Number of section headers: %ld\n"),
2010 (long) elf_header
.e_shnum
);
2011 printf (_(" Section header string table index: %ld\n"),
2012 (long) elf_header
.e_shstrndx
);
2020 get_32bit_program_headers (file
, program_headers
)
2022 Elf_Internal_Phdr
* program_headers
;
2024 Elf32_External_Phdr
* phdrs
;
2025 Elf32_External_Phdr
* external
;
2026 Elf32_Internal_Phdr
* internal
;
2029 GET_DATA_ALLOC (elf_header
.e_phoff
,
2030 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2031 phdrs
, Elf32_External_Phdr
*, "program headers");
2033 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2034 i
< elf_header
.e_phnum
;
2035 i
++, internal
++, external
++)
2037 internal
->p_type
= BYTE_GET (external
->p_type
);
2038 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2039 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2040 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2041 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2042 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2043 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2044 internal
->p_align
= BYTE_GET (external
->p_align
);
2053 get_64bit_program_headers (file
, program_headers
)
2055 Elf_Internal_Phdr
* program_headers
;
2057 Elf64_External_Phdr
* phdrs
;
2058 Elf64_External_Phdr
* external
;
2059 Elf64_Internal_Phdr
* internal
;
2062 GET_DATA_ALLOC (elf_header
.e_phoff
,
2063 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2064 phdrs
, Elf64_External_Phdr
*, "program headers");
2066 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2067 i
< elf_header
.e_phnum
;
2068 i
++, internal
++, external
++)
2070 internal
->p_type
= BYTE_GET (external
->p_type
);
2071 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2072 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2073 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2074 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2075 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2076 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2077 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2086 process_program_headers (file
)
2089 Elf_Internal_Phdr
* program_headers
;
2090 Elf_Internal_Phdr
* segment
;
2093 if (elf_header
.e_phnum
== 0)
2096 printf (_("\nThere are no program headers in this file.\n"));
2100 if (do_segments
&& !do_header
)
2102 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2103 printf (_("Entry point "));
2104 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2105 printf (_("\nThere are %d program headers, starting at offset "),
2106 elf_header
.e_phnum
);
2107 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2111 program_headers
= (Elf_Internal_Phdr
*) malloc
2112 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2114 if (program_headers
== NULL
)
2116 error (_("Out of memory\n"));
2121 i
= get_32bit_program_headers (file
, program_headers
);
2123 i
= get_64bit_program_headers (file
, program_headers
);
2127 free (program_headers
);
2134 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2138 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2142 (_(" Type Offset VirtAddr PhysAddr\n"));
2144 (_(" FileSiz MemSiz Flags Align\n"));
2152 for (i
= 0, segment
= program_headers
;
2153 i
< elf_header
.e_phnum
;
2158 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2162 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2163 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2164 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2165 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2166 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2168 (segment
->p_flags
& PF_R
? 'R' : ' '),
2169 (segment
->p_flags
& PF_W
? 'W' : ' '),
2170 (segment
->p_flags
& PF_X
? 'E' : ' '));
2171 printf ("%#lx", (unsigned long) segment
->p_align
);
2175 print_vma (segment
->p_offset
, FULL_HEX
);
2177 print_vma (segment
->p_vaddr
, FULL_HEX
);
2179 print_vma (segment
->p_paddr
, FULL_HEX
);
2181 print_vma (segment
->p_filesz
, FULL_HEX
);
2183 print_vma (segment
->p_memsz
, FULL_HEX
);
2185 (segment
->p_flags
& PF_R
? 'R' : ' '),
2186 (segment
->p_flags
& PF_W
? 'W' : ' '),
2187 (segment
->p_flags
& PF_X
? 'E' : ' '));
2188 print_vma (segment
->p_align
, HEX
);
2192 switch (segment
->p_type
)
2196 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2197 - (segment
->p_offset
& 0xfffff000);
2202 error (_("more than one dynamic segment\n"));
2204 dynamic_addr
= segment
->p_offset
;
2205 dynamic_size
= segment
->p_filesz
;
2209 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2210 error (_("Unable to find program interpreter name\n"));
2213 program_interpreter
[0] = 0;
2214 fscanf (file
, "%63s", program_interpreter
);
2217 printf (_("\n [Requesting program interpreter: %s]"),
2218 program_interpreter
);
2224 putc ('\n', stdout
);
2233 if (do_segments
&& section_headers
!= NULL
)
2235 printf (_("\n Section to Segment mapping:\n"));
2236 printf (_(" Segment Sections...\n"));
2238 assert (string_table
!= NULL
);
2240 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2243 Elf_Internal_Shdr
* section
;
2245 segment
= program_headers
+ i
;
2246 section
= section_headers
;
2248 printf (" %2.2d ", i
);
2250 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2252 if (section
->sh_size
> 0
2253 /* Compare allocated sections by VMA, unallocated
2254 sections by file offset. */
2255 && (section
->sh_flags
& SHF_ALLOC
2256 ? (section
->sh_addr
>= segment
->p_vaddr
2257 && section
->sh_addr
+ section
->sh_size
2258 <= segment
->p_vaddr
+ segment
->p_memsz
)
2259 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2260 && (section
->sh_offset
+ section
->sh_size
2261 <= segment
->p_offset
+ segment
->p_filesz
))))
2262 printf ("%s ", SECTION_NAME (section
));
2269 free (program_headers
);
2276 get_32bit_section_headers (file
)
2279 Elf32_External_Shdr
* shdrs
;
2280 Elf32_Internal_Shdr
* internal
;
2283 GET_DATA_ALLOC (elf_header
.e_shoff
,
2284 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2285 shdrs
, Elf32_External_Shdr
*, "section headers");
2287 section_headers
= (Elf_Internal_Shdr
*) malloc
2288 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2290 if (section_headers
== NULL
)
2292 error (_("Out of memory\n"));
2296 for (i
= 0, internal
= section_headers
;
2297 i
< elf_header
.e_shnum
;
2300 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2301 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2302 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2303 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2304 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2305 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2306 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2307 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2308 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2309 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2318 get_64bit_section_headers (file
)
2321 Elf64_External_Shdr
* shdrs
;
2322 Elf64_Internal_Shdr
* internal
;
2325 GET_DATA_ALLOC (elf_header
.e_shoff
,
2326 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2327 shdrs
, Elf64_External_Shdr
*, "section headers");
2329 section_headers
= (Elf_Internal_Shdr
*) malloc
2330 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2332 if (section_headers
== NULL
)
2334 error (_("Out of memory\n"));
2338 for (i
= 0, internal
= section_headers
;
2339 i
< elf_header
.e_shnum
;
2342 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2343 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2344 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2345 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2346 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2347 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2348 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2349 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2350 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2351 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2359 static Elf_Internal_Sym
*
2360 get_32bit_elf_symbols (file
, offset
, number
)
2362 unsigned long offset
;
2363 unsigned long number
;
2365 Elf32_External_Sym
* esyms
;
2366 Elf_Internal_Sym
* isyms
;
2367 Elf_Internal_Sym
* psym
;
2370 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2371 esyms
, Elf32_External_Sym
*, "symbols");
2373 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2377 error (_("Out of memory\n"));
2383 for (j
= 0, psym
= isyms
;
2387 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2388 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2389 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2390 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2391 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2392 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2400 static Elf_Internal_Sym
*
2401 get_64bit_elf_symbols (file
, offset
, number
)
2403 unsigned long offset
;
2404 unsigned long number
;
2406 Elf64_External_Sym
* esyms
;
2407 Elf_Internal_Sym
* isyms
;
2408 Elf_Internal_Sym
* psym
;
2411 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2412 esyms
, Elf64_External_Sym
*, "symbols");
2414 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2418 error (_("Out of memory\n"));
2424 for (j
= 0, psym
= isyms
;
2428 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2429 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2430 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2431 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2432 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2433 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2442 get_elf_section_flags (sh_flags
)
2445 static char buff
[32];
2453 flag
= sh_flags
& - sh_flags
;
2458 case SHF_WRITE
: strcat (buff
, "W"); break;
2459 case SHF_ALLOC
: strcat (buff
, "A"); break;
2460 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2461 case SHF_MERGE
: strcat (buff
, "M"); break;
2462 case SHF_STRINGS
: strcat (buff
, "S"); break;
2463 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2464 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2465 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2468 if (flag
& SHF_MASKOS
)
2471 sh_flags
&= ~ SHF_MASKOS
;
2473 else if (flag
& SHF_MASKPROC
)
2476 sh_flags
&= ~ SHF_MASKPROC
;
2488 process_section_headers (file
)
2491 Elf_Internal_Shdr
* section
;
2494 section_headers
= NULL
;
2496 if (elf_header
.e_shnum
== 0)
2499 printf (_("\nThere are no sections in this file.\n"));
2504 if (do_sections
&& !do_header
)
2505 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2506 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2510 if (! get_32bit_section_headers (file
))
2513 else if (! get_64bit_section_headers (file
))
2516 /* Read in the string table, so that we have names to display. */
2517 section
= section_headers
+ elf_header
.e_shstrndx
;
2519 if (section
->sh_size
!= 0)
2521 unsigned long string_table_offset
;
2523 string_table_offset
= section
->sh_offset
;
2525 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2526 string_table
, char *, "string table");
2529 /* Scan the sections for the dynamic symbol table
2530 and dynamic string table and debug sections. */
2531 dynamic_symbols
= NULL
;
2532 dynamic_strings
= NULL
;
2533 dynamic_syminfo
= NULL
;
2535 for (i
= 0, section
= section_headers
;
2536 i
< elf_header
.e_shnum
;
2539 char * name
= SECTION_NAME (section
);
2541 if (section
->sh_type
== SHT_DYNSYM
)
2543 if (dynamic_symbols
!= NULL
)
2545 error (_("File contains multiple dynamic symbol tables\n"));
2549 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2551 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2553 else if (section
->sh_type
== SHT_STRTAB
2554 && strcmp (name
, ".dynstr") == 0)
2556 if (dynamic_strings
!= NULL
)
2558 error (_("File contains multiple dynamic string tables\n"));
2562 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2563 dynamic_strings
, char *, "dynamic strings");
2565 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2566 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
)
2567 && strncmp (name
, ".debug_", 7) == 0)
2572 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2573 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2574 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2575 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2576 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2578 request_dump (i
, DEBUG_DUMP
);
2585 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2589 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2592 printf (_(" [Nr] Name Type Address Offset\n"));
2593 printf (_(" Size EntSize Flags Link Info Align\n"));
2596 for (i
= 0, section
= section_headers
;
2597 i
< elf_header
.e_shnum
;
2600 printf (" [%2d] %-17.17s %-15.15s ",
2602 SECTION_NAME (section
),
2603 get_section_type_name (section
->sh_type
));
2607 print_vma (section
->sh_addr
, LONG_HEX
);
2609 printf ( " %6.6lx %6.6lx %2.2lx",
2610 (unsigned long) section
->sh_offset
,
2611 (unsigned long) section
->sh_size
,
2612 (unsigned long) section
->sh_entsize
);
2614 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2616 printf (" %2ld %3lx %ld\n",
2617 (unsigned long) section
->sh_link
,
2618 (unsigned long) section
->sh_info
,
2619 (unsigned long) section
->sh_addralign
);
2624 print_vma (section
->sh_addr
, LONG_HEX
);
2625 printf (" %8.8lx", section
->sh_offset
);
2627 print_vma (section
->sh_size
, LONG_HEX
);
2629 print_vma (section
->sh_entsize
, LONG_HEX
);
2631 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2633 printf (" %2ld %3lx %ld\n",
2634 (unsigned long) section
->sh_link
,
2635 (unsigned long) section
->sh_info
,
2636 (unsigned long) section
->sh_addralign
);
2640 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2641 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2642 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2647 /* Process the reloc section. */
2649 process_relocs (file
)
2652 unsigned long rel_size
;
2653 unsigned long rel_offset
;
2659 if (do_using_dynamic
)
2661 int is_rela
= FALSE
;
2666 if (dynamic_info
[DT_REL
])
2668 rel_offset
= dynamic_info
[DT_REL
];
2669 rel_size
= dynamic_info
[DT_RELSZ
];
2672 else if (dynamic_info
[DT_RELA
])
2674 rel_offset
= dynamic_info
[DT_RELA
];
2675 rel_size
= dynamic_info
[DT_RELASZ
];
2678 else if (dynamic_info
[DT_JMPREL
])
2680 rel_offset
= dynamic_info
[DT_JMPREL
];
2681 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2683 switch (dynamic_info
[DT_PLTREL
])
2700 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2701 rel_offset
, rel_size
);
2703 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2704 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
2707 printf (_("\nThere are no dynamic relocations in this file.\n"));
2711 Elf32_Internal_Shdr
* section
;
2715 for (i
= 0, section
= section_headers
;
2716 i
< elf_header
.e_shnum
;
2719 if ( section
->sh_type
!= SHT_RELA
2720 && section
->sh_type
!= SHT_REL
)
2723 rel_offset
= section
->sh_offset
;
2724 rel_size
= section
->sh_size
;
2728 Elf32_Internal_Shdr
* strsec
;
2729 Elf32_Internal_Shdr
* symsec
;
2730 Elf_Internal_Sym
* symtab
;
2733 unsigned long nsyms
;
2735 printf (_("\nRelocation section "));
2737 if (string_table
== NULL
)
2738 printf ("%d", section
->sh_name
);
2740 printf ("'%s'", SECTION_NAME (section
));
2742 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2743 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
2745 symsec
= section_headers
+ section
->sh_link
;
2747 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
2748 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
2753 strsec
= section_headers
+ symsec
->sh_link
;
2755 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2756 char *, "string table");
2758 is_rela
= section
->sh_type
== SHT_RELA
;
2760 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
2770 printf (_("\nThere are no relocations in this file.\n"));
2778 dynamic_segment_mips_val (entry
)
2779 Elf_Internal_Dyn
* entry
;
2781 switch (entry
->d_tag
)
2784 if (entry
->d_un
.d_val
== 0)
2788 static const char * opts
[] =
2790 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2791 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2792 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2793 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2798 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
2799 if (entry
->d_un
.d_val
& (1 << cnt
))
2801 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2808 case DT_MIPS_IVERSION
:
2809 if (dynamic_strings
!= NULL
)
2810 printf ("Interface Version: %s\n",
2811 dynamic_strings
+ entry
->d_un
.d_val
);
2813 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2816 case DT_MIPS_TIME_STAMP
:
2819 time_t time
= entry
->d_un
.d_val
;
2820 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
2821 printf ("Time Stamp: %s\n", timebuf
);
2825 case DT_MIPS_RLD_VERSION
:
2826 case DT_MIPS_LOCAL_GOTNO
:
2827 case DT_MIPS_CONFLICTNO
:
2828 case DT_MIPS_LIBLISTNO
:
2829 case DT_MIPS_SYMTABNO
:
2830 case DT_MIPS_UNREFEXTNO
:
2831 case DT_MIPS_HIPAGENO
:
2832 case DT_MIPS_DELTA_CLASS_NO
:
2833 case DT_MIPS_DELTA_INSTANCE_NO
:
2834 case DT_MIPS_DELTA_RELOC_NO
:
2835 case DT_MIPS_DELTA_SYM_NO
:
2836 case DT_MIPS_DELTA_CLASSSYM_NO
:
2837 case DT_MIPS_COMPACT_SIZE
:
2838 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2842 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2848 dynamic_segment_parisc_val (entry
)
2849 Elf_Internal_Dyn
* entry
;
2851 switch (entry
->d_tag
)
2853 case DT_HP_DLD_FLAGS
:
2862 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
2863 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
2864 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
2865 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
2866 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
2867 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
2868 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
2869 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
2870 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
2871 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
2872 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
2876 bfd_vma val
= entry
->d_un
.d_val
;
2878 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
2879 if (val
& flags
[cnt
].bit
)
2883 fputs (flags
[cnt
].str
, stdout
);
2885 val
^= flags
[cnt
].bit
;
2888 if (val
!= 0 || first
)
2892 print_vma (val
, HEX
);
2898 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
2904 get_32bit_dynamic_segment (file
)
2907 Elf32_External_Dyn
* edyn
;
2908 Elf_Internal_Dyn
* entry
;
2911 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
2912 edyn
, Elf32_External_Dyn
*, "dynamic segment");
2914 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2915 how large this .dynamic is now. We can do this even before the byte
2916 swapping since the DT_NULL tag is recognizable. */
2918 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
2921 dynamic_segment
= (Elf_Internal_Dyn
*)
2922 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
2924 if (dynamic_segment
== NULL
)
2926 error (_("Out of memory\n"));
2931 for (i
= 0, entry
= dynamic_segment
;
2935 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
2936 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
2945 get_64bit_dynamic_segment (file
)
2948 Elf64_External_Dyn
* edyn
;
2949 Elf_Internal_Dyn
* entry
;
2952 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
2953 edyn
, Elf64_External_Dyn
*, "dynamic segment");
2955 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2956 how large this .dynamic is now. We can do this even before the byte
2957 swapping since the DT_NULL tag is recognizable. */
2959 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
2962 dynamic_segment
= (Elf_Internal_Dyn
*)
2963 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
2965 if (dynamic_segment
== NULL
)
2967 error (_("Out of memory\n"));
2972 for (i
= 0, entry
= dynamic_segment
;
2976 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
2977 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
2986 get_dynamic_flags (flags
)
2989 static char buff
[64];
2994 flag
= flags
& - flags
;
2999 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3000 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3001 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3002 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3003 default: strcat (buff
, "unknown "); break;
3009 /* Parse and display the contents of the dynamic segment. */
3011 process_dynamic_segment (file
)
3014 Elf_Internal_Dyn
* entry
;
3017 if (dynamic_size
== 0)
3020 printf (_("\nThere is no dynamic segment in this file.\n"));
3027 if (! get_32bit_dynamic_segment (file
))
3030 else if (! get_64bit_dynamic_segment (file
))
3033 /* Find the appropriate symbol table. */
3034 if (dynamic_symbols
== NULL
)
3036 for (i
= 0, entry
= dynamic_segment
;
3040 unsigned long offset
;
3042 if (entry
->d_tag
!= DT_SYMTAB
)
3045 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3047 /* Since we do not know how big the symbol table is,
3048 we default to reading in the entire file (!) and
3049 processing that. This is overkill, I know, but it
3051 offset
= entry
->d_un
.d_val
- loadaddr
;
3053 if (fseek (file
, 0, SEEK_END
))
3054 error (_("Unable to seek to end of file!"));
3057 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3059 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3061 if (num_dynamic_syms
< 1)
3063 error (_("Unable to determine the number of symbols to load\n"));
3067 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3071 /* Similarly find a string table. */
3072 if (dynamic_strings
== NULL
)
3074 for (i
= 0, entry
= dynamic_segment
;
3078 unsigned long offset
;
3081 if (entry
->d_tag
!= DT_STRTAB
)
3084 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3086 /* Since we do not know how big the string table is,
3087 we default to reading in the entire file (!) and
3088 processing that. This is overkill, I know, but it
3091 offset
= entry
->d_un
.d_val
- loadaddr
;
3092 if (fseek (file
, 0, SEEK_END
))
3093 error (_("Unable to seek to end of file\n"));
3094 str_tab_len
= ftell (file
) - offset
;
3096 if (str_tab_len
< 1)
3099 (_("Unable to determine the length of the dynamic string table\n"));
3103 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
3104 "dynamic string table");
3110 /* And find the syminfo section if available. */
3111 if (dynamic_syminfo
== NULL
)
3113 unsigned int syminsz
= 0;
3115 for (i
= 0, entry
= dynamic_segment
;
3119 if (entry
->d_tag
== DT_SYMINENT
)
3121 /* Note: these braces are necessary to avoid a syntax
3122 error from the SunOS4 C compiler. */
3123 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3125 else if (entry
->d_tag
== DT_SYMINSZ
)
3126 syminsz
= entry
->d_un
.d_val
;
3127 else if (entry
->d_tag
== DT_SYMINFO
)
3128 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
3131 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3133 Elf_External_Syminfo
* extsyminfo
;
3134 Elf_Internal_Syminfo
* syminfo
;
3136 /* There is a syminfo section. Read the data. */
3137 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3138 Elf_External_Syminfo
*, "symbol information");
3140 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3141 if (dynamic_syminfo
== NULL
)
3143 error (_("Out of memory\n"));
3147 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3148 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3151 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3152 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3159 if (do_dynamic
&& dynamic_addr
)
3160 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3161 dynamic_addr
, (long) dynamic_size
);
3163 printf (_(" Tag Type Name/Value\n"));
3165 for (i
= 0, entry
= dynamic_segment
;
3172 print_vma (entry
->d_tag
, FULL_HEX
);
3174 get_dynamic_type (entry
->d_tag
),
3175 (is_32bit_elf
? 27 : 19) - strlen (get_dynamic_type (entry
->d_tag
)),
3179 switch (entry
->d_tag
)
3183 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
3190 if (entry
->d_tag
== DT_AUXILIARY
)
3191 printf (_("Auxiliary library"));
3193 printf (_("Filter library"));
3195 if (dynamic_strings
)
3196 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3200 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3209 printf (_("Flags:"));
3210 if (entry
->d_un
.d_val
== 0)
3211 printf (_(" None\n"));
3214 unsigned long int val
= entry
->d_un
.d_val
;
3215 if (val
& DTF_1_PARINIT
)
3217 printf (" PARINIT");
3218 val
^= DTF_1_PARINIT
;
3221 printf (" %lx", val
);
3230 printf (_("Flags:"));
3231 if (entry
->d_un
.d_val
== 0)
3232 printf (_(" None\n"));
3235 unsigned long int val
= entry
->d_un
.d_val
;
3236 if (val
& DF_P1_LAZYLOAD
)
3238 printf (" LAZYLOAD");
3239 val
^= DF_P1_LAZYLOAD
;
3241 if (val
& DF_P1_GROUPPERM
)
3243 printf (" GROUPPERM");
3244 val
^= DF_P1_GROUPPERM
;
3247 printf (" %lx", val
);
3256 printf (_("Flags:"));
3257 if (entry
->d_un
.d_val
== 0)
3258 printf (_(" None\n"));
3261 unsigned long int val
= entry
->d_un
.d_val
;
3267 if (val
& DF_1_GLOBAL
)
3272 if (val
& DF_1_GROUP
)
3277 if (val
& DF_1_NODELETE
)
3279 printf (" NODELETE");
3280 val
^= DF_1_NODELETE
;
3282 if (val
& DF_1_LOADFLTR
)
3284 printf (" LOADFLTR");
3285 val
^= DF_1_LOADFLTR
;
3287 if (val
& DF_1_INITFIRST
)
3289 printf (" INITFIRST");
3290 val
^= DF_1_INITFIRST
;
3292 if (val
& DF_1_NOOPEN
)
3297 if (val
& DF_1_ORIGIN
)
3302 if (val
& DF_1_DIRECT
)
3307 if (val
& DF_1_TRANS
)
3312 if (val
& DF_1_INTERPOSE
)
3314 printf (" INTERPOSE");
3315 val
^= DF_1_INTERPOSE
;
3318 printf (" %lx", val
);
3326 puts (get_dynamic_type (entry
->d_un
.d_val
));
3345 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
3351 if (dynamic_strings
== NULL
)
3354 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3358 switch (entry
->d_tag
)
3361 printf (_("Shared library: [%s]"), name
);
3363 if (strcmp (name
, program_interpreter
) == 0)
3364 printf (_(" program interpreter"));
3368 printf (_("Library soname: [%s]"), name
);
3372 printf (_("Library rpath: [%s]"), name
);
3376 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3381 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3397 case DT_INIT_ARRAYSZ
:
3398 case DT_FINI_ARRAYSZ
:
3401 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3402 printf (" (bytes)\n");
3412 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3425 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
3429 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3433 printf (_("Not needed object: [%s]\n"), name
);
3438 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3444 /* The value of this entry is ignored. */
3448 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
3449 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
3454 switch (elf_header
.e_machine
)
3457 case EM_MIPS_RS4_BE
:
3458 dynamic_segment_mips_val (entry
);
3461 dynamic_segment_parisc_val (entry
);
3464 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3476 get_ver_flags (flags
)
3479 static char buff
[32];
3486 if (flags
& VER_FLG_BASE
)
3487 strcat (buff
, "BASE ");
3489 if (flags
& VER_FLG_WEAK
)
3491 if (flags
& VER_FLG_BASE
)
3492 strcat (buff
, "| ");
3494 strcat (buff
, "WEAK ");
3497 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
3498 strcat (buff
, "| <unknown>");
3503 /* Display the contents of the version sections. */
3505 process_version_sections (file
)
3508 Elf32_Internal_Shdr
* section
;
3515 for (i
= 0, section
= section_headers
;
3516 i
< elf_header
.e_shnum
;
3519 switch (section
->sh_type
)
3521 case SHT_GNU_verdef
:
3523 Elf_External_Verdef
* edefs
;
3530 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3531 SECTION_NAME (section
), section
->sh_info
);
3533 printf (_(" Addr: 0x"));
3534 printf_vma (section
->sh_addr
);
3535 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3536 (unsigned long) section
->sh_offset
, section
->sh_link
,
3537 SECTION_NAME (section_headers
+ section
->sh_link
));
3539 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3540 edefs
, Elf_External_Verdef
*,
3541 "version definition section");
3543 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
3546 Elf_External_Verdef
* edef
;
3547 Elf_Internal_Verdef ent
;
3548 Elf_External_Verdaux
* eaux
;
3549 Elf_Internal_Verdaux aux
;
3553 vstart
= ((char *) edefs
) + idx
;
3555 edef
= (Elf_External_Verdef
*) vstart
;
3557 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
3558 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
3559 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
3560 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
3561 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
3562 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
3563 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
3565 printf (_(" %#06x: Rev: %d Flags: %s"),
3566 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
3568 printf (_(" Index: %d Cnt: %d "),
3569 ent
.vd_ndx
, ent
.vd_cnt
);
3571 vstart
+= ent
.vd_aux
;
3573 eaux
= (Elf_External_Verdaux
*) vstart
;
3575 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3576 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3578 if (dynamic_strings
)
3579 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
3581 printf (_("Name index: %ld\n"), aux
.vda_name
);
3583 isum
= idx
+ ent
.vd_aux
;
3585 for (j
= 1; j
< ent
.vd_cnt
; j
++)
3587 isum
+= aux
.vda_next
;
3588 vstart
+= aux
.vda_next
;
3590 eaux
= (Elf_External_Verdaux
*) vstart
;
3592 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3593 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3595 if (dynamic_strings
)
3596 printf (_(" %#06x: Parent %d: %s\n"),
3597 isum
, j
, dynamic_strings
+ aux
.vda_name
);
3599 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3600 isum
, j
, aux
.vda_name
);
3610 case SHT_GNU_verneed
:
3612 Elf_External_Verneed
* eneed
;
3618 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3619 SECTION_NAME (section
), section
->sh_info
);
3621 printf (_(" Addr: 0x"));
3622 printf_vma (section
->sh_addr
);
3623 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3624 (unsigned long) section
->sh_offset
, section
->sh_link
,
3625 SECTION_NAME (section_headers
+ section
->sh_link
));
3627 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3628 eneed
, Elf_External_Verneed
*,
3629 "version need section");
3631 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
3633 Elf_External_Verneed
* entry
;
3634 Elf_Internal_Verneed ent
;
3639 vstart
= ((char *) eneed
) + idx
;
3641 entry
= (Elf_External_Verneed
*) vstart
;
3643 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
3644 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
3645 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
3646 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
3647 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
3649 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
3651 if (dynamic_strings
)
3652 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
3654 printf (_(" File: %lx"), ent
.vn_file
);
3656 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
3658 vstart
+= ent
.vn_aux
;
3660 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
3662 Elf_External_Vernaux
* eaux
;
3663 Elf_Internal_Vernaux aux
;
3665 eaux
= (Elf_External_Vernaux
*) vstart
;
3667 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
3668 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
3669 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
3670 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
3671 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
3673 if (dynamic_strings
)
3674 printf (_(" %#06x: Name: %s"),
3675 isum
, dynamic_strings
+ aux
.vna_name
);
3677 printf (_(" %#06x: Name index: %lx"),
3678 isum
, aux
.vna_name
);
3680 printf (_(" Flags: %s Version: %d\n"),
3681 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
3683 isum
+= aux
.vna_next
;
3684 vstart
+= aux
.vna_next
;
3694 case SHT_GNU_versym
:
3696 Elf32_Internal_Shdr
* link_section
;
3699 unsigned char * edata
;
3700 unsigned short * data
;
3702 Elf_Internal_Sym
* symbols
;
3703 Elf32_Internal_Shdr
* string_sec
;
3705 link_section
= section_headers
+ section
->sh_link
;
3706 total
= section
->sh_size
/ section
->sh_entsize
;
3710 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
3711 link_section
->sh_size
/ link_section
->sh_entsize
);
3713 string_sec
= section_headers
+ link_section
->sh_link
;
3715 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3716 strtab
, char *, "version string table");
3718 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3719 SECTION_NAME (section
), total
);
3721 printf (_(" Addr: "));
3722 printf_vma (section
->sh_addr
);
3723 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3724 (unsigned long) section
->sh_offset
, section
->sh_link
,
3725 SECTION_NAME (link_section
));
3727 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3729 total
* sizeof (short), edata
,
3730 unsigned char *, "version symbol data");
3732 data
= (unsigned short *) malloc (total
* sizeof (short));
3734 for (cnt
= total
; cnt
--;)
3735 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
3740 for (cnt
= 0; cnt
< total
; cnt
+= 4)
3745 printf (" %03x:", cnt
);
3747 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
3748 switch (data
[cnt
+ j
])
3751 fputs (_(" 0 (*local*) "), stdout
);
3755 fputs (_(" 1 (*global*) "), stdout
);
3759 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
3760 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
3762 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
3763 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
3766 /* We must test both. */
3767 Elf_Internal_Verneed ivn
;
3768 unsigned long offset
;
3770 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3775 Elf_External_Verneed evn
;
3776 Elf_External_Vernaux evna
;
3777 Elf_Internal_Vernaux ivna
;
3778 unsigned long vna_off
;
3780 GET_DATA (offset
, evn
, "version need");
3782 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3783 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3785 vna_off
= offset
+ ivn
.vn_aux
;
3789 GET_DATA (vna_off
, evna
,
3790 "version need aux (1)");
3792 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3793 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3795 vna_off
+= ivna
.vna_next
;
3797 while (ivna
.vna_other
!= data
[cnt
+ j
]
3798 && ivna
.vna_next
!= 0);
3800 if (ivna
.vna_other
== data
[cnt
+ j
])
3802 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3804 name
= strtab
+ ivna
.vna_name
;
3805 nn
+= printf ("(%s%-*s",
3807 12 - (int) strlen (name
),
3811 else if (ivn
.vn_next
== 0)
3813 if (data
[cnt
+ j
] != 0x8001)
3815 Elf_Internal_Verdef ivd
;
3816 Elf_External_Verdef evd
;
3818 offset
= version_info
3819 [DT_VERSIONTAGIDX (DT_VERDEF
)]
3824 GET_DATA (offset
, evd
,
3825 "version definition");
3827 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3828 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3830 offset
+= ivd
.vd_next
;
3833 != (data
[cnt
+ j
] & 0x7fff)
3834 && ivd
.vd_next
!= 0);
3837 == (data
[cnt
+ j
] & 0x7fff))
3839 Elf_External_Verdaux evda
;
3840 Elf_Internal_Verdaux ivda
;
3842 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3844 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
3845 "version definition aux");
3848 BYTE_GET (evda
.vda_name
);
3850 name
= strtab
+ ivda
.vda_name
;
3854 12 - (int) strlen (name
),
3862 offset
+= ivn
.vn_next
;
3864 while (ivn
.vn_next
);
3866 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
3868 Elf_Internal_Verneed ivn
;
3869 unsigned long offset
;
3871 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3876 Elf_Internal_Vernaux ivna
;
3877 Elf_External_Verneed evn
;
3878 Elf_External_Vernaux evna
;
3879 unsigned long a_off
;
3881 GET_DATA (offset
, evn
, "version need");
3883 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3884 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3886 a_off
= offset
+ ivn
.vn_aux
;
3890 GET_DATA (a_off
, evna
,
3891 "version need aux (2)");
3893 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3894 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3896 a_off
+= ivna
.vna_next
;
3898 while (ivna
.vna_other
!= data
[cnt
+ j
]
3899 && ivna
.vna_next
!= 0);
3901 if (ivna
.vna_other
== data
[cnt
+ j
])
3903 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3905 name
= strtab
+ ivna
.vna_name
;
3906 nn
+= printf ("(%s%-*s",
3908 12 - (int) strlen (name
),
3913 offset
+= ivn
.vn_next
;
3915 while (ivn
.vn_next
);
3917 else if (data
[cnt
+ j
] != 0x8001)
3919 Elf_Internal_Verdef ivd
;
3920 Elf_External_Verdef evd
;
3921 unsigned long offset
;
3923 offset
= version_info
3924 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
3928 GET_DATA (offset
, evd
, "version def");
3930 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3931 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3933 offset
+= ivd
.vd_next
;
3935 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
3936 && ivd
.vd_next
!= 0);
3938 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
3940 Elf_External_Verdaux evda
;
3941 Elf_Internal_Verdaux ivda
;
3943 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3945 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
3946 evda
, "version def aux");
3948 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
3950 name
= strtab
+ ivda
.vda_name
;
3951 nn
+= printf ("(%s%-*s",
3953 12 - (int) strlen (name
),
3959 printf ("%*c", 18 - nn
, ' ');
3977 printf (_("\nNo version information found in this file.\n"));
3983 get_symbol_binding (binding
)
3984 unsigned int binding
;
3986 static char buff
[32];
3990 case STB_LOCAL
: return "LOCAL";
3991 case STB_GLOBAL
: return "GLOBAL";
3992 case STB_WEAK
: return "WEAK";
3994 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
3995 sprintf (buff
, _("<processor specific>: %d"), binding
);
3996 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
3997 sprintf (buff
, _("<OS specific>: %d"), binding
);
3999 sprintf (buff
, _("<unknown>: %d"), binding
);
4005 get_symbol_type (type
)
4008 static char buff
[32];
4012 case STT_NOTYPE
: return "NOTYPE";
4013 case STT_OBJECT
: return "OBJECT";
4014 case STT_FUNC
: return "FUNC";
4015 case STT_SECTION
: return "SECTION";
4016 case STT_FILE
: return "FILE";
4017 case STT_COMMON
: return "COMMON";
4019 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4021 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4022 return "THUMB_FUNC";
4024 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4027 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4028 return "PARISC_MILLI";
4030 sprintf (buff
, _("<processor specific>: %d"), type
);
4032 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4034 if (elf_header
.e_machine
== EM_PARISC
)
4036 if (type
== STT_HP_OPAQUE
)
4038 if (type
== STT_HP_STUB
)
4042 sprintf (buff
, _("<OS specific>: %d"), type
);
4045 sprintf (buff
, _("<unknown>: %d"), type
);
4051 get_symbol_visibility (visibility
)
4052 unsigned int visibility
;
4056 case STV_DEFAULT
: return "DEFAULT";
4057 case STV_INTERNAL
: return "INTERNAL";
4058 case STV_HIDDEN
: return "HIDDEN";
4059 case STV_PROTECTED
: return "PROTECTED";
4065 get_symbol_index_type (type
)
4070 case SHN_UNDEF
: return "UND";
4071 case SHN_ABS
: return "ABS";
4072 case SHN_COMMON
: return "COM";
4074 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4076 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4078 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4082 static char buff
[32];
4084 sprintf (buff
, "%3d", type
);
4091 get_dynamic_data (file
, number
)
4093 unsigned int number
;
4098 e_data
= (char *) malloc (number
* 4);
4102 error (_("Out of memory\n"));
4106 if (fread (e_data
, 4, number
, file
) != number
)
4108 error (_("Unable to read in dynamic data\n"));
4112 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4116 error (_("Out of memory\n"));
4122 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4129 /* Dump the symbol table */
4131 process_symbol_table (file
)
4134 Elf32_Internal_Shdr
* section
;
4139 int * buckets
= NULL
;
4140 int * chains
= NULL
;
4142 if (! do_syms
&& !do_histogram
)
4145 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
4148 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
4150 error (_("Unable to seek to start of dynamic information"));
4154 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4156 error (_("Failed to read in number of buckets\n"));
4160 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4162 error (_("Failed to read in number of chains\n"));
4166 nbuckets
= byte_get (nb
, 4);
4167 nchains
= byte_get (nc
, 4);
4169 buckets
= get_dynamic_data (file
, nbuckets
);
4170 chains
= get_dynamic_data (file
, nchains
);
4172 if (buckets
== NULL
|| chains
== NULL
)
4177 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4182 printf (_("\nSymbol table for image:\n"));
4184 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4186 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4188 for (hn
= 0; hn
< nbuckets
; hn
++)
4193 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4195 Elf_Internal_Sym
* psym
;
4197 psym
= dynamic_symbols
+ si
;
4199 printf (" %3d %3d: ", si
, hn
);
4200 print_vma (psym
->st_value
, LONG_HEX
);
4202 print_vma (psym
->st_size
, DEC_5
);
4204 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4205 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4206 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4207 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
4208 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4212 else if (do_syms
&& !do_using_dynamic
)
4216 for (i
= 0, section
= section_headers
;
4217 i
< elf_header
.e_shnum
;
4222 Elf_Internal_Sym
* symtab
;
4223 Elf_Internal_Sym
* psym
;
4226 if ( section
->sh_type
!= SHT_SYMTAB
4227 && section
->sh_type
!= SHT_DYNSYM
)
4230 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4231 SECTION_NAME (section
),
4232 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4234 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4236 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4238 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4239 section
->sh_size
/ section
->sh_entsize
);
4243 if (section
->sh_link
== elf_header
.e_shstrndx
)
4244 strtab
= string_table
;
4247 Elf32_Internal_Shdr
* string_sec
;
4249 string_sec
= section_headers
+ section
->sh_link
;
4251 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4252 strtab
, char *, "string table");
4255 for (si
= 0, psym
= symtab
;
4256 si
< section
->sh_size
/ section
->sh_entsize
;
4259 printf ("%6d: ", si
);
4260 print_vma (psym
->st_value
, LONG_HEX
);
4262 print_vma (psym
->st_size
, DEC_5
);
4263 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4264 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4265 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4266 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
4267 printf (" %s", strtab
+ psym
->st_name
);
4269 if (section
->sh_type
== SHT_DYNSYM
&&
4270 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
4272 unsigned char data
[2];
4273 unsigned short vers_data
;
4274 unsigned long offset
;
4278 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4281 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
4284 vers_data
= byte_get (data
, 2);
4286 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
4287 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
4290 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
4292 if ((vers_data
& 0x8000) || vers_data
> 1)
4294 if (is_nobits
|| ! check_def
)
4296 Elf_External_Verneed evn
;
4297 Elf_Internal_Verneed ivn
;
4298 Elf_Internal_Vernaux ivna
;
4300 /* We must test both. */
4301 offset
= version_info
4302 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
4304 GET_DATA (offset
, evn
, "version need");
4306 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4307 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4311 unsigned long vna_off
;
4313 vna_off
= offset
+ ivn
.vn_aux
;
4317 Elf_External_Vernaux evna
;
4319 GET_DATA (vna_off
, evna
,
4320 "version need aux (3)");
4322 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4323 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4324 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4326 vna_off
+= ivna
.vna_next
;
4328 while (ivna
.vna_other
!= vers_data
4329 && ivna
.vna_next
!= 0);
4331 if (ivna
.vna_other
== vers_data
)
4334 offset
+= ivn
.vn_next
;
4336 while (ivn
.vn_next
!= 0);
4338 if (ivna
.vna_other
== vers_data
)
4341 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
4344 else if (! is_nobits
)
4345 error (_("bad dynamic symbol"));
4352 if (vers_data
!= 0x8001)
4354 Elf_Internal_Verdef ivd
;
4355 Elf_Internal_Verdaux ivda
;
4356 Elf_External_Verdaux evda
;
4357 unsigned long offset
;
4360 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
4365 Elf_External_Verdef evd
;
4367 GET_DATA (offset
, evd
, "version def");
4369 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4370 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4371 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4373 offset
+= ivd
.vd_next
;
4375 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
4376 && ivd
.vd_next
!= 0);
4378 offset
-= ivd
.vd_next
;
4379 offset
+= ivd
.vd_aux
;
4381 GET_DATA (offset
, evda
, "version def aux");
4383 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4385 if (psym
->st_name
!= ivda
.vda_name
)
4386 printf ((vers_data
& 0x8000)
4388 strtab
+ ivda
.vda_name
);
4398 if (strtab
!= string_table
)
4404 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4406 if (do_histogram
&& buckets
!= NULL
)
4413 int nzero_counts
= 0;
4416 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4418 printf (_(" Length Number %% of total Coverage\n"));
4420 lengths
= (int *) calloc (nbuckets
, sizeof (int));
4421 if (lengths
== NULL
)
4423 error (_("Out of memory"));
4426 for (hn
= 0; hn
< nbuckets
; ++hn
)
4431 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
4434 if (maxlength
< ++lengths
[hn
])
4439 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
4442 error (_("Out of memory"));
4446 for (hn
= 0; hn
< nbuckets
; ++hn
)
4447 ++ counts
[lengths
[hn
]];
4451 printf (" 0 %-10d (%5.1f%%)\n",
4452 counts
[0], (counts
[0] * 100.0) / nbuckets
);
4453 for (si
= 1; si
<= maxlength
; ++si
)
4455 nzero_counts
+= counts
[si
] * si
;
4456 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4457 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
4458 (nzero_counts
* 100.0) / nsyms
);
4466 if (buckets
!= NULL
)
4476 process_syminfo (file
)
4477 FILE * file ATTRIBUTE_UNUSED
;
4481 if (dynamic_syminfo
== NULL
4483 /* No syminfo, this is ok. */
4486 /* There better should be a dynamic symbol section. */
4487 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
4491 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4492 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
4494 printf (_(" Num: Name BoundTo Flags\n"));
4495 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
4497 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
4499 printf ("%4d: %-30s ", i
,
4500 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
4502 switch (dynamic_syminfo
[i
].si_boundto
)
4504 case SYMINFO_BT_SELF
:
4505 fputs ("SELF ", stdout
);
4507 case SYMINFO_BT_PARENT
:
4508 fputs ("PARENT ", stdout
);
4511 if (dynamic_syminfo
[i
].si_boundto
> 0
4512 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
4515 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
4517 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
4521 if (flags
& SYMINFO_FLG_DIRECT
)
4523 if (flags
& SYMINFO_FLG_PASSTHRU
)
4524 printf (" PASSTHRU");
4525 if (flags
& SYMINFO_FLG_COPY
)
4527 if (flags
& SYMINFO_FLG_LAZYLOAD
)
4528 printf (" LAZYLOAD");
4536 #ifdef SUPPORT_DISASSEMBLY
4538 disassemble_section (section
, file
)
4539 Elf32_Internal_Shdr
* section
;
4542 printf (_("\nAssembly dump of section %s\n"),
4543 SECTION_NAME (section
));
4545 /* XXX -- to be done --- XXX */
4552 dump_section (section
, file
)
4553 Elf32_Internal_Shdr
* section
;
4556 bfd_size_type bytes
;
4558 unsigned char * data
;
4559 unsigned char * start
;
4561 bytes
= section
->sh_size
;
4565 printf (_("\nSection '%s' has no data to dump.\n"),
4566 SECTION_NAME (section
));
4570 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
4572 addr
= section
->sh_addr
;
4574 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
4585 lbytes
= (bytes
> 16 ? 16 : bytes
);
4587 printf (" 0x%8.8lx ", (unsigned long) addr
);
4589 switch (elf_header
.e_ident
[EI_DATA
])
4593 for (j
= 15; j
>= 0; j
--)
4596 printf ("%2.2x", data
[j
]);
4606 for (j
= 0; j
< 16; j
++)
4609 printf ("%2.2x", data
[j
]);
4619 for (j
= 0; j
< lbytes
; j
++)
4622 if (k
>= ' ' && k
< 0x80)
4641 static unsigned long int
4642 read_leb128 (data
, length_return
, sign
)
4643 unsigned char * data
;
4644 int * length_return
;
4647 unsigned long int result
= 0;
4648 unsigned int num_read
= 0;
4657 result
|= (byte
& 0x7f) << shift
;
4662 while (byte
& 0x80);
4664 if (length_return
!= NULL
)
4665 * length_return
= num_read
;
4667 if (sign
&& (shift
< 32) && (byte
& 0x40))
4668 result
|= -1 << shift
;
4673 typedef struct State_Machine_Registers
4675 unsigned long address
;
4678 unsigned int column
;
4682 /* This variable hold the number of the last entry seen
4683 in the File Table. */
4684 unsigned int last_file_entry
;
4687 static SMR state_machine_regs
;
4690 reset_state_machine (is_stmt
)
4693 state_machine_regs
.address
= 0;
4694 state_machine_regs
.file
= 1;
4695 state_machine_regs
.line
= 1;
4696 state_machine_regs
.column
= 0;
4697 state_machine_regs
.is_stmt
= is_stmt
;
4698 state_machine_regs
.basic_block
= 0;
4699 state_machine_regs
.end_sequence
= 0;
4700 state_machine_regs
.last_file_entry
= 0;
4703 /* Handled an extend line op. Returns true if this is the end
4706 process_extended_line_op (data
, is_stmt
, pointer_size
)
4707 unsigned char * data
;
4711 unsigned char op_code
;
4714 unsigned char * name
;
4717 len
= read_leb128 (data
, & bytes_read
, 0);
4722 warn (_("badly formed extended line op encountered!"));
4727 op_code
= * data
++;
4729 printf (_(" Extended opcode %d: "), op_code
);
4733 case DW_LNE_end_sequence
:
4734 printf (_("End of Sequence\n\n"));
4735 reset_state_machine (is_stmt
);
4738 case DW_LNE_set_address
:
4739 adr
= byte_get (data
, pointer_size
);
4740 printf (_("set Address to 0x%lx\n"), adr
);
4741 state_machine_regs
.address
= adr
;
4744 case DW_LNE_define_file
:
4745 printf (_(" define new File Table entry\n"));
4746 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4748 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4750 data
+= strlen (data
) + 1;
4751 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4753 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4755 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4756 printf (_("%s\n\n"), name
);
4760 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
4767 /* Size of pointers in the .debug_line section. This information is not
4768 really present in that section. It's obtained before dumping the debug
4769 sections by doing some pre-scan of the .debug_info section. */
4770 static int debug_line_pointer_size
= 4;
4773 display_debug_lines (section
, start
, file
)
4774 Elf32_Internal_Shdr
* section
;
4775 unsigned char * start
;
4776 FILE * file ATTRIBUTE_UNUSED
;
4778 DWARF2_External_LineInfo
* external
;
4779 DWARF2_Internal_LineInfo info
;
4780 unsigned char * standard_opcodes
;
4781 unsigned char * data
= start
;
4782 unsigned char * end
= start
+ section
->sh_size
;
4783 unsigned char * end_of_sequence
;
4786 printf (_("\nDump of debug contents of section %s:\n\n"),
4787 SECTION_NAME (section
));
4791 external
= (DWARF2_External_LineInfo
*) data
;
4793 /* Check the length of the block. */
4794 info
.li_length
= BYTE_GET (external
->li_length
);
4795 if (info
.li_length
> section
->sh_size
)
4798 (_("The line info appears to be corrupt - the section is too small\n"));
4802 /* Check its version number. */
4803 info
.li_version
= BYTE_GET (external
->li_version
);
4804 if (info
.li_version
!= 2)
4806 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4810 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
4811 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
4812 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
4813 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
4814 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
4815 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
4817 /* Sign extend the line base field. */
4818 info
.li_line_base
<<= 24;
4819 info
.li_line_base
>>= 24;
4821 printf (_(" Length: %ld\n"), info
.li_length
);
4822 printf (_(" DWARF Version: %d\n"), info
.li_version
);
4823 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
4824 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
4825 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
4826 printf (_(" Line Base: %d\n"), info
.li_line_base
);
4827 printf (_(" Line Range: %d\n"), info
.li_line_range
);
4828 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
4830 end_of_sequence
= data
+ info
.li_length
+ sizeof (info
.li_length
);
4832 reset_state_machine (info
.li_default_is_stmt
);
4834 /* Display the contents of the Opcodes table. */
4835 standard_opcodes
= data
+ sizeof (* external
);
4837 printf (_("\n Opcodes:\n"));
4839 for (i
= 1; i
< info
.li_opcode_base
; i
++)
4840 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
4842 /* Display the contents of the Directory table. */
4843 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
4846 printf (_("\n The Directory Table is empty.\n"));
4849 printf (_("\n The Directory Table:\n"));
4853 printf (_(" %s\n"), data
);
4855 data
+= strlen (data
) + 1;
4859 /* Skip the NUL at the end of the table. */
4862 /* Display the contents of the File Name table. */
4864 printf (_("\n The File Name Table is empty.\n"));
4867 printf (_("\n The File Name Table:\n"));
4868 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4875 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4878 data
+= strlen (data
) + 1;
4880 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4882 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4884 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4886 printf (_("%s\n"), name
);
4890 /* Skip the NUL at the end of the table. */
4893 /* Now display the statements. */
4894 printf (_("\n Line Number Statements:\n"));
4897 while (data
< end_of_sequence
)
4899 unsigned char op_code
;
4903 op_code
= * data
++;
4907 case DW_LNS_extended_op
:
4908 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
4909 debug_line_pointer_size
);
4913 printf (_(" Copy\n"));
4916 case DW_LNS_advance_pc
:
4917 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
4919 state_machine_regs
.address
+= adv
;
4920 printf (_(" Advance PC by %d to %lx\n"), adv
,
4921 state_machine_regs
.address
);
4924 case DW_LNS_advance_line
:
4925 adv
= read_leb128 (data
, & bytes_read
, 1);
4927 state_machine_regs
.line
+= adv
;
4928 printf (_(" Advance Line by %d to %d\n"), adv
,
4929 state_machine_regs
.line
);
4932 case DW_LNS_set_file
:
4933 adv
= read_leb128 (data
, & bytes_read
, 0);
4935 printf (_(" Set File Name to entry %d in the File Name Table\n"),
4937 state_machine_regs
.file
= adv
;
4940 case DW_LNS_set_column
:
4941 adv
= read_leb128 (data
, & bytes_read
, 0);
4943 printf (_(" Set column to %d\n"), adv
);
4944 state_machine_regs
.column
= adv
;
4947 case DW_LNS_negate_stmt
:
4948 adv
= state_machine_regs
.is_stmt
;
4950 printf (_(" Set is_stmt to %d\n"), adv
);
4951 state_machine_regs
.is_stmt
= adv
;
4954 case DW_LNS_set_basic_block
:
4955 printf (_(" Set basic block\n"));
4956 state_machine_regs
.basic_block
= 1;
4959 case DW_LNS_const_add_pc
:
4960 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
4961 * info
.li_min_insn_length
);
4962 state_machine_regs
.address
+= adv
;
4963 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
4964 state_machine_regs
.address
);
4967 case DW_LNS_fixed_advance_pc
:
4968 adv
= byte_get (data
, 2);
4970 state_machine_regs
.address
+= adv
;
4971 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
4972 adv
, state_machine_regs
.address
);
4976 op_code
-= info
.li_opcode_base
;
4977 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
4978 state_machine_regs
.address
+= adv
;
4979 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
4980 op_code
, adv
, state_machine_regs
.address
);
4981 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
4982 state_machine_regs
.line
+= adv
;
4983 printf (_(" and Line by %d to %d\n"),
4984 adv
, state_machine_regs
.line
);
4995 display_debug_pubnames (section
, start
, file
)
4996 Elf32_Internal_Shdr
* section
;
4997 unsigned char * start
;
4998 FILE * file ATTRIBUTE_UNUSED
;
5000 DWARF2_External_PubNames
* external
;
5001 DWARF2_Internal_PubNames pubnames
;
5002 unsigned char * end
;
5004 end
= start
+ section
->sh_size
;
5006 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5010 unsigned char * data
;
5011 unsigned long offset
;
5013 external
= (DWARF2_External_PubNames
*) start
;
5015 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5016 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5017 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5018 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5020 data
= start
+ sizeof (* external
);
5021 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5023 if (pubnames
.pn_version
!= 2)
5025 warn (_("Only DWARF 2 pubnames are currently supported"));
5029 printf (_(" Length: %ld\n"),
5030 pubnames
.pn_length
);
5031 printf (_(" Version: %d\n"),
5032 pubnames
.pn_version
);
5033 printf (_(" Offset into .debug_info section: %ld\n"),
5034 pubnames
.pn_offset
);
5035 printf (_(" Size of area in .debug_info section: %ld\n"),
5038 printf (_("\n Offset\tName\n"));
5042 offset
= byte_get (data
, 4);
5047 printf (" %ld\t\t%s\n", offset
, data
);
5048 data
+= strlen (data
) + 1;
5051 while (offset
!= 0);
5064 case DW_TAG_padding
: return "DW_TAG_padding";
5065 case DW_TAG_array_type
: return "DW_TAG_array_type";
5066 case DW_TAG_class_type
: return "DW_TAG_class_type";
5067 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5068 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5069 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5070 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5071 case DW_TAG_label
: return "DW_TAG_label";
5072 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5073 case DW_TAG_member
: return "DW_TAG_member";
5074 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5075 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5076 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5077 case DW_TAG_string_type
: return "DW_TAG_string_type";
5078 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5079 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5080 case DW_TAG_typedef
: return "DW_TAG_typedef";
5081 case DW_TAG_union_type
: return "DW_TAG_union_type";
5082 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5083 case DW_TAG_variant
: return "DW_TAG_variant";
5084 case DW_TAG_common_block
: return "DW_TAG_common_block";
5085 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5086 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5087 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5088 case DW_TAG_module
: return "DW_TAG_module";
5089 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5090 case DW_TAG_set_type
: return "DW_TAG_set_type";
5091 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5092 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5093 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5094 case DW_TAG_base_type
: return "DW_TAG_base_type";
5095 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5096 case DW_TAG_const_type
: return "DW_TAG_const_type";
5097 case DW_TAG_constant
: return "DW_TAG_constant";
5098 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5099 case DW_TAG_file_type
: return "DW_TAG_file_type";
5100 case DW_TAG_friend
: return "DW_TAG_friend";
5101 case DW_TAG_namelist
: return "DW_TAG_namelist";
5102 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5103 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5104 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5105 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5106 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5107 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5108 case DW_TAG_try_block
: return "DW_TAG_try_block";
5109 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5110 case DW_TAG_variable
: return "DW_TAG_variable";
5111 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5112 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5113 case DW_TAG_format_label
: return "DW_TAG_format_label";
5114 case DW_TAG_function_template
: return "DW_TAG_function_template";
5115 case DW_TAG_class_template
: return "DW_TAG_class_template";
5118 static char buffer
[100];
5120 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
5127 get_AT_name (attribute
)
5128 unsigned long attribute
;
5132 case DW_AT_sibling
: return "DW_AT_sibling";
5133 case DW_AT_location
: return "DW_AT_location";
5134 case DW_AT_name
: return "DW_AT_name";
5135 case DW_AT_ordering
: return "DW_AT_ordering";
5136 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
5137 case DW_AT_byte_size
: return "DW_AT_byte_size";
5138 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
5139 case DW_AT_bit_size
: return "DW_AT_bit_size";
5140 case DW_AT_element_list
: return "DW_AT_element_list";
5141 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
5142 case DW_AT_low_pc
: return "DW_AT_low_pc";
5143 case DW_AT_high_pc
: return "DW_AT_high_pc";
5144 case DW_AT_language
: return "DW_AT_language";
5145 case DW_AT_member
: return "DW_AT_member";
5146 case DW_AT_discr
: return "DW_AT_discr";
5147 case DW_AT_discr_value
: return "DW_AT_discr_value";
5148 case DW_AT_visibility
: return "DW_AT_visibility";
5149 case DW_AT_import
: return "DW_AT_import";
5150 case DW_AT_string_length
: return "DW_AT_string_length";
5151 case DW_AT_common_reference
: return "DW_AT_common_reference";
5152 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5153 case DW_AT_const_value
: return "DW_AT_const_value";
5154 case DW_AT_containing_type
: return "DW_AT_containing_type";
5155 case DW_AT_default_value
: return "DW_AT_default_value";
5156 case DW_AT_inline
: return "DW_AT_inline";
5157 case DW_AT_is_optional
: return "DW_AT_is_optional";
5158 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5159 case DW_AT_producer
: return "DW_AT_producer";
5160 case DW_AT_prototyped
: return "DW_AT_prototyped";
5161 case DW_AT_return_addr
: return "DW_AT_return_addr";
5162 case DW_AT_start_scope
: return "DW_AT_start_scope";
5163 case DW_AT_stride_size
: return "DW_AT_stride_size";
5164 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5165 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5166 case DW_AT_accessibility
: return "DW_AT_accessibility";
5167 case DW_AT_address_class
: return "DW_AT_address_class";
5168 case DW_AT_artificial
: return "DW_AT_artificial";
5169 case DW_AT_base_types
: return "DW_AT_base_types";
5170 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5171 case DW_AT_count
: return "DW_AT_count";
5172 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5173 case DW_AT_decl_column
: return "DW_AT_decl_column";
5174 case DW_AT_decl_file
: return "DW_AT_decl_file";
5175 case DW_AT_decl_line
: return "DW_AT_decl_line";
5176 case DW_AT_declaration
: return "DW_AT_declaration";
5177 case DW_AT_discr_list
: return "DW_AT_discr_list";
5178 case DW_AT_encoding
: return "DW_AT_encoding";
5179 case DW_AT_external
: return "DW_AT_external";
5180 case DW_AT_frame_base
: return "DW_AT_frame_base";
5181 case DW_AT_friend
: return "DW_AT_friend";
5182 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5183 case DW_AT_macro_info
: return "DW_AT_macro_info";
5184 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5185 case DW_AT_priority
: return "DW_AT_priority";
5186 case DW_AT_segment
: return "DW_AT_segment";
5187 case DW_AT_specification
: return "DW_AT_specification";
5188 case DW_AT_static_link
: return "DW_AT_static_link";
5189 case DW_AT_type
: return "DW_AT_type";
5190 case DW_AT_use_location
: return "DW_AT_use_location";
5191 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5192 case DW_AT_virtuality
: return "DW_AT_virtuality";
5193 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5194 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5195 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5196 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5197 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5198 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5199 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5200 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5201 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5202 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5203 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5204 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5205 case DW_AT_sf_names
: return "DW_AT_sf_names";
5206 case DW_AT_src_info
: return "DW_AT_src_info";
5207 case DW_AT_mac_info
: return "DW_AT_mac_info";
5208 case DW_AT_src_coords
: return "DW_AT_src_coords";
5209 case DW_AT_body_begin
: return "DW_AT_body_begin";
5210 case DW_AT_body_end
: return "DW_AT_body_end";
5213 static char buffer
[100];
5215 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5222 get_FORM_name (form
)
5227 case DW_FORM_addr
: return "DW_FORM_addr";
5228 case DW_FORM_block2
: return "DW_FORM_block2";
5229 case DW_FORM_block4
: return "DW_FORM_block4";
5230 case DW_FORM_data2
: return "DW_FORM_data2";
5231 case DW_FORM_data4
: return "DW_FORM_data4";
5232 case DW_FORM_data8
: return "DW_FORM_data8";
5233 case DW_FORM_string
: return "DW_FORM_string";
5234 case DW_FORM_block
: return "DW_FORM_block";
5235 case DW_FORM_block1
: return "DW_FORM_block1";
5236 case DW_FORM_data1
: return "DW_FORM_data1";
5237 case DW_FORM_flag
: return "DW_FORM_flag";
5238 case DW_FORM_sdata
: return "DW_FORM_sdata";
5239 case DW_FORM_strp
: return "DW_FORM_strp";
5240 case DW_FORM_udata
: return "DW_FORM_udata";
5241 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5242 case DW_FORM_ref1
: return "DW_FORM_ref1";
5243 case DW_FORM_ref2
: return "DW_FORM_ref2";
5244 case DW_FORM_ref4
: return "DW_FORM_ref4";
5245 case DW_FORM_ref8
: return "DW_FORM_ref8";
5246 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5247 case DW_FORM_indirect
: return "DW_FORM_indirect";
5250 static char buffer
[100];
5252 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5258 /* FIXME: There are better and more effiecint ways to handle
5259 these structures. For now though, I just want something that
5260 is simple to implement. */
5261 typedef struct abbrev_attr
5263 unsigned long attribute
;
5265 struct abbrev_attr
* next
;
5269 typedef struct abbrev_entry
5271 unsigned long entry
;
5274 struct abbrev_attr
* first_attr
;
5275 struct abbrev_attr
* last_attr
;
5276 struct abbrev_entry
* next
;
5280 static abbrev_entry
* first_abbrev
= NULL
;
5281 static abbrev_entry
* last_abbrev
= NULL
;
5284 free_abbrevs
PARAMS ((void))
5286 abbrev_entry
* abbrev
;
5288 for (abbrev
= first_abbrev
; abbrev
;)
5290 abbrev_entry
* next
= abbrev
->next
;
5293 for (attr
= abbrev
->first_attr
; attr
;)
5295 abbrev_attr
* next
= attr
->next
;
5305 last_abbrev
= first_abbrev
= NULL
;
5309 add_abbrev (number
, tag
, children
)
5310 unsigned long number
;
5314 abbrev_entry
* entry
;
5316 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
5322 entry
->entry
= number
;
5324 entry
->children
= children
;
5325 entry
->first_attr
= NULL
;
5326 entry
->last_attr
= NULL
;
5329 if (first_abbrev
== NULL
)
5330 first_abbrev
= entry
;
5332 last_abbrev
->next
= entry
;
5334 last_abbrev
= entry
;
5338 add_abbrev_attr (attribute
, form
)
5339 unsigned long attribute
;
5344 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
5350 attr
->attribute
= attribute
;
5354 if (last_abbrev
->first_attr
== NULL
)
5355 last_abbrev
->first_attr
= attr
;
5357 last_abbrev
->last_attr
->next
= attr
;
5359 last_abbrev
->last_attr
= attr
;
5362 /* Processes the (partial) contents of a .debug_abbrev section.
5363 Returns NULL if the end of the section was encountered.
5364 Returns the address after the last byte read if the end of
5365 an abbreviation set was found. */
5367 static unsigned char *
5368 process_abbrev_section (start
, end
)
5369 unsigned char * start
;
5370 unsigned char * end
;
5372 if (first_abbrev
!= NULL
)
5378 unsigned long entry
;
5380 unsigned long attribute
;
5383 entry
= read_leb128 (start
, & bytes_read
, 0);
5384 start
+= bytes_read
;
5386 /* A single zero is supposed to end the section according
5387 to the standard. If there's more, then signal that to
5390 return start
== end
? NULL
: start
;
5392 tag
= read_leb128 (start
, & bytes_read
, 0);
5393 start
+= bytes_read
;
5395 children
= * start
++;
5397 add_abbrev (entry
, tag
, children
);
5403 attribute
= read_leb128 (start
, & bytes_read
, 0);
5404 start
+= bytes_read
;
5406 form
= read_leb128 (start
, & bytes_read
, 0);
5407 start
+= bytes_read
;
5410 add_abbrev_attr (attribute
, form
);
5412 while (attribute
!= 0);
5420 display_debug_abbrev (section
, start
, file
)
5421 Elf32_Internal_Shdr
* section
;
5422 unsigned char * start
;
5423 FILE * file ATTRIBUTE_UNUSED
;
5425 abbrev_entry
* entry
;
5426 unsigned char * end
= start
+ section
->sh_size
;
5428 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5432 start
= process_abbrev_section (start
, end
);
5434 printf (_(" Number TAG\n"));
5436 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5440 printf (_(" %ld %s [%s]\n"),
5442 get_TAG_name (entry
->tag
),
5443 entry
->children
? _("has children") : _("no children"));
5445 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5447 printf (_(" %-18s %s\n"),
5448 get_AT_name (attr
->attribute
),
5449 get_FORM_name (attr
->form
));
5461 static unsigned char *
5462 display_block (data
, length
)
5463 unsigned char * data
;
5464 unsigned long length
;
5466 printf (_(" %lu byte block: "), length
);
5469 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
5475 decode_location_expression (data
, pointer_size
)
5476 unsigned char * data
;
5477 unsigned int pointer_size
;
5481 unsigned long uvalue
;
5488 printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data
, pointer_size
));
5491 printf ("DW_OP_deref");
5494 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
, 1));
5497 printf ("DW_OP_const1s: %ld", (long) byte_get (data
, 1));
5500 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
5503 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
5506 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
5509 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
5512 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
5513 (unsigned long) byte_get (data
+ 4, 4));
5516 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
5517 (long) byte_get (data
+ 4, 4));
5520 printf ("DW_OP_constu: %lu", read_leb128 (data
, NULL
, 0));
5523 printf ("DW_OP_consts: %ld", read_leb128 (data
, NULL
, 1));
5526 printf ("DW_OP_dup");
5529 printf ("DW_OP_drop");
5532 printf ("DW_OP_over");
5535 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
, 1));
5538 printf ("DW_OP_swap");
5541 printf ("DW_OP_rot");
5544 printf ("DW_OP_xderef");
5547 printf ("DW_OP_abs");
5550 printf ("DW_OP_and");
5553 printf ("DW_OP_div");
5556 printf ("DW_OP_minus");
5559 printf ("DW_OP_mod");
5562 printf ("DW_OP_mul");
5565 printf ("DW_OP_neg");
5568 printf ("DW_OP_not");
5571 printf ("DW_OP_or");
5574 printf ("DW_OP_plus");
5576 case DW_OP_plus_uconst
:
5577 printf ("DW_OP_plus_uconst: %lu", read_leb128 (data
, NULL
, 0));
5580 printf ("DW_OP_shl");
5583 printf ("DW_OP_shr");
5586 printf ("DW_OP_shra");
5589 printf ("DW_OP_xor");
5592 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
5595 printf ("DW_OP_eq");
5598 printf ("DW_OP_ge");
5601 printf ("DW_OP_gt");
5604 printf ("DW_OP_le");
5607 printf ("DW_OP_lt");
5610 printf ("DW_OP_ne");
5613 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
5616 printf ("DW_OP_lit0");
5619 printf ("DW_OP_lit1");
5622 printf ("DW_OP_lit2");
5625 printf ("DW_OP_lit3");
5628 printf ("DW_OP_lit4");
5631 printf ("DW_OP_lit5");
5634 printf ("DW_OP_lit6");
5637 printf ("DW_OP_lit7");
5640 printf ("DW_OP_lit8");
5643 printf ("DW_OP_lit9");
5646 printf ("DW_OP_lit10");
5649 printf ("DW_OP_lit11");
5652 printf ("DW_OP_lit12");
5655 printf ("DW_OP_lit13");
5658 printf ("DW_OP_lit14");
5661 printf ("DW_OP_lit15");
5664 printf ("DW_OP_lit16");
5667 printf ("DW_OP_lit17");
5670 printf ("DW_OP_lit18");
5673 printf ("DW_OP_lit19");
5676 printf ("DW_OP_lit20");
5679 printf ("DW_OP_lit21");
5682 printf ("DW_OP_lit22");
5685 printf ("DW_OP_lit23");
5688 printf ("DW_OP_lit24");
5691 printf ("DW_OP_lit25");
5694 printf ("DW_OP_lit26");
5697 printf ("DW_OP_lit27");
5700 printf ("DW_OP_lit28");
5703 printf ("DW_OP_lit29");
5706 printf ("DW_OP_lit30");
5709 printf ("DW_OP_lit31");
5712 printf ("DW_OP_reg0");
5715 printf ("DW_OP_reg1");
5718 printf ("DW_OP_reg2");
5721 printf ("DW_OP_reg3");
5724 printf ("DW_OP_reg4");
5727 printf ("DW_OP_reg5");
5730 printf ("DW_OP_reg6");
5733 printf ("DW_OP_reg7");
5736 printf ("DW_OP_reg8");
5739 printf ("DW_OP_reg9");
5742 printf ("DW_OP_reg10");
5745 printf ("DW_OP_reg11");
5748 printf ("DW_OP_reg12");
5751 printf ("DW_OP_reg13");
5754 printf ("DW_OP_reg14");
5757 printf ("DW_OP_reg15");
5760 printf ("DW_OP_reg16");
5763 printf ("DW_OP_reg17");
5766 printf ("DW_OP_reg18");
5769 printf ("DW_OP_reg19");
5772 printf ("DW_OP_reg20");
5775 printf ("DW_OP_reg21");
5778 printf ("DW_OP_reg22");
5781 printf ("DW_OP_reg23");
5784 printf ("DW_OP_reg24");
5787 printf ("DW_OP_reg25");
5790 printf ("DW_OP_reg26");
5793 printf ("DW_OP_reg27");
5796 printf ("DW_OP_reg28");
5799 printf ("DW_OP_reg29");
5802 printf ("DW_OP_reg30");
5805 printf ("DW_OP_reg31");
5808 printf ("DW_OP_breg0: %ld", read_leb128 (data
, NULL
, 1));
5811 printf ("DW_OP_breg1: %ld", read_leb128 (data
, NULL
, 1));
5814 printf ("DW_OP_breg2: %ld", read_leb128 (data
, NULL
, 1));
5817 printf ("DW_OP_breg3: %ld", read_leb128 (data
, NULL
, 1));
5820 printf ("DW_OP_breg4: %ld", read_leb128 (data
, NULL
, 1));
5823 printf ("DW_OP_breg5: %ld", read_leb128 (data
, NULL
, 1));
5826 printf ("DW_OP_breg6: %ld", read_leb128 (data
, NULL
, 1));
5829 printf ("DW_OP_breg7: %ld", read_leb128 (data
, NULL
, 1));
5832 printf ("DW_OP_breg8: %ld", read_leb128 (data
, NULL
, 1));
5835 printf ("DW_OP_breg9: %ld", read_leb128 (data
, NULL
, 1));
5838 printf ("DW_OP_breg10: %ld", read_leb128 (data
, NULL
, 1));
5841 printf ("DW_OP_breg11: %ld", read_leb128 (data
, NULL
, 1));
5844 printf ("DW_OP_breg12: %ld", read_leb128 (data
, NULL
, 1));
5847 printf ("DW_OP_breg13: %ld", read_leb128 (data
, NULL
, 1));
5850 printf ("DW_OP_breg14: %ld", read_leb128 (data
, NULL
, 1));
5853 printf ("DW_OP_breg15: %ld", read_leb128 (data
, NULL
, 1));
5856 printf ("DW_OP_breg16: %ld", read_leb128 (data
, NULL
, 1));
5859 printf ("DW_OP_breg17: %ld", read_leb128 (data
, NULL
, 1));
5862 printf ("DW_OP_breg18: %ld", read_leb128 (data
, NULL
, 1));
5865 printf ("DW_OP_breg19: %ld", read_leb128 (data
, NULL
, 1));
5868 printf ("DW_OP_breg20: %ld", read_leb128 (data
, NULL
, 1));
5871 printf ("DW_OP_breg21: %ld", read_leb128 (data
, NULL
, 1));
5874 printf ("DW_OP_breg22: %ld", read_leb128 (data
, NULL
, 1));
5877 printf ("DW_OP_breg23: %ld", read_leb128 (data
, NULL
, 1));
5880 printf ("DW_OP_breg24: %ld", read_leb128 (data
, NULL
, 1));
5883 printf ("DW_OP_breg25: %ld", read_leb128 (data
, NULL
, 1));
5886 printf ("DW_OP_breg26: %ld", read_leb128 (data
, NULL
, 1));
5889 printf ("DW_OP_breg27: %ld", read_leb128 (data
, NULL
, 1));
5892 printf ("DW_OP_breg28: %ld", read_leb128 (data
, NULL
, 1));
5895 printf ("DW_OP_breg29: %ld", read_leb128 (data
, NULL
, 1));
5898 printf ("DW_OP_breg30: %ld", read_leb128 (data
, NULL
, 1));
5901 printf ("DW_OP_breg31: %ld", read_leb128 (data
, NULL
, 1));
5904 printf ("DW_OP_regx: %lu", read_leb128 (data
, NULL
, 0));
5907 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, NULL
, 1));
5910 uvalue
= read_leb128 (data
, &bytes_read
, 0);
5911 printf ("DW_OP_bregx: %lu %ld", uvalue
,
5912 read_leb128 (data
+ bytes_read
, NULL
, 1));
5915 printf ("DW_OP_piece: %lu", read_leb128 (data
, NULL
, 0));
5917 case DW_OP_deref_size
:
5918 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
, 1));
5920 case DW_OP_xderef_size
:
5921 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
, 1));
5924 printf ("DW_OP_nop");
5928 if (op
>= DW_OP_lo_user
5929 && op
<= DW_OP_hi_user
)
5930 printf (_("(User defined location op)"));
5932 printf (_("(Unknown location op)"));
5938 static unsigned char *
5939 read_and_display_attr (attribute
, form
, data
, pointer_size
)
5940 unsigned long attribute
;
5942 unsigned char * data
;
5943 unsigned long pointer_size
;
5945 unsigned long uvalue
= 0;
5946 unsigned char * block_start
= NULL
;
5950 printf (" %-18s:", get_AT_name (attribute
));
5954 case DW_FORM_ref_addr
:
5959 case DW_FORM_ref_udata
:
5965 case DW_FORM_ref_addr
:
5967 uvalue
= byte_get (data
, pointer_size
);
5968 printf (is_ref
? " <%lx>" : " %#lx", uvalue
);
5969 data
+= pointer_size
;
5975 uvalue
= byte_get (data
++, 1);
5976 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
5981 uvalue
= byte_get (data
, 2);
5983 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
5988 uvalue
= byte_get (data
, 4);
5990 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
5995 uvalue
= byte_get (data
, 4);
5996 printf (" %lx", uvalue
);
5997 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
6001 case DW_FORM_string
:
6002 printf (" %s", data
);
6003 data
+= strlen (data
) + 1;
6007 uvalue
= read_leb128 (data
, & bytes_read
, 1);
6009 printf (" %ld", (long) uvalue
);
6012 case DW_FORM_ref_udata
:
6014 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6016 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
6020 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6021 block_start
= data
+ bytes_read
;
6022 data
= display_block (block_start
, uvalue
);
6023 uvalue
= * block_start
;
6026 case DW_FORM_block1
:
6027 uvalue
= byte_get (data
, 1);
6028 block_start
= data
+ 1;
6029 data
= display_block (block_start
, uvalue
);
6030 uvalue
= * block_start
;
6033 case DW_FORM_block2
:
6034 uvalue
= byte_get (data
, 2);
6035 block_start
= data
+ 2;
6036 data
= display_block (block_start
, uvalue
);
6037 uvalue
= * block_start
;
6040 case DW_FORM_block4
:
6041 uvalue
= byte_get (data
, 4);
6042 block_start
= data
+ 4;
6043 data
= display_block (block_start
, uvalue
);
6044 uvalue
= * block_start
;
6048 case DW_FORM_indirect
:
6049 warn (_("Unable to handle FORM: %d"), form
);
6053 warn (_("Unrecognised form: %d"), form
);
6057 /* For some attributes we can display futher information. */
6066 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6067 case DW_INL_inlined
: printf (_("(inlined)")); break;
6068 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6069 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6070 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6074 case DW_AT_frame_base
:
6075 if (uvalue
>= DW_OP_reg0
&& uvalue
<= DW_OP_reg31
)
6076 printf ("(reg %ld)", uvalue
- DW_OP_reg0
);
6079 case DW_AT_language
:
6082 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6083 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6084 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6085 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6086 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6087 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6088 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6089 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6090 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6091 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6092 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6093 default: printf ("(Unknown: %lx)", uvalue
); break;
6097 case DW_AT_encoding
:
6100 case DW_ATE_void
: printf ("(void)"); break;
6101 case DW_ATE_address
: printf ("(machine address)"); break;
6102 case DW_ATE_boolean
: printf ("(boolean)"); break;
6103 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6104 case DW_ATE_float
: printf ("(float)"); break;
6105 case DW_ATE_signed
: printf ("(signed)"); break;
6106 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6107 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6108 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6110 if (uvalue
>= DW_ATE_lo_user
6111 && uvalue
<= DW_ATE_hi_user
)
6112 printf ("(user defined type)");
6114 printf ("(unknown type)");
6119 case DW_AT_accessibility
:
6122 case DW_ACCESS_public
: printf ("(public)"); break;
6123 case DW_ACCESS_protected
: printf ("(protected)"); break;
6124 case DW_ACCESS_private
: printf ("(private)"); break;
6125 default: printf ("(unknown accessibility)"); break;
6129 case DW_AT_visibility
:
6132 case DW_VIS_local
: printf ("(local)"); break;
6133 case DW_VIS_exported
: printf ("(exported)"); break;
6134 case DW_VIS_qualified
: printf ("(qualified)"); break;
6135 default: printf ("(unknown visibility)"); break;
6139 case DW_AT_virtuality
:
6142 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6143 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6144 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6145 default: printf ("(unknown virtuality)"); break;
6149 case DW_AT_identifier_case
:
6152 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6153 case DW_ID_up_case
: printf ("(up_case)"); break;
6154 case DW_ID_down_case
: printf ("(down_case)"); break;
6155 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6156 default: printf ("(unknown case)"); break;
6160 case DW_AT_calling_convention
:
6163 case DW_CC_normal
: printf ("(normal)"); break;
6164 case DW_CC_program
: printf ("(program)"); break;
6165 case DW_CC_nocall
: printf ("(nocall)"); break;
6167 if (uvalue
>= DW_CC_lo_user
6168 && uvalue
<= DW_CC_hi_user
)
6169 printf ("(user defined)");
6171 printf ("(unknown convention)");
6175 case DW_AT_location
:
6176 case DW_AT_data_member_location
:
6177 case DW_AT_vtable_elem_location
:
6179 decode_location_expression (block_start
, pointer_size
);
6192 display_debug_info (section
, start
, file
)
6193 Elf32_Internal_Shdr
* section
;
6194 unsigned char * start
;
6197 unsigned char * end
= start
+ section
->sh_size
;
6198 unsigned char * section_begin
= start
;
6200 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6204 DWARF2_External_CompUnit
* external
;
6205 DWARF2_Internal_CompUnit compunit
;
6206 unsigned char * tags
;
6210 external
= (DWARF2_External_CompUnit
*) start
;
6212 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6213 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6214 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6215 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6217 tags
= start
+ sizeof (* external
);
6218 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6220 if (compunit
.cu_version
!= 2)
6222 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6226 printf (_(" Compilation Unit:\n"));
6227 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6228 printf (_(" Version: %d\n"), compunit
.cu_version
);
6229 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6230 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6232 if (first_abbrev
!= NULL
)
6235 /* Read in the abbrevs used by this compilation unit. */
6238 Elf32_Internal_Shdr
* sec
;
6239 unsigned char * begin
;
6241 /* Locate the .debug_abbrev section and process it. */
6242 for (i
= 0, sec
= section_headers
;
6243 i
< elf_header
.e_shnum
;
6245 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6248 if (i
== -1 || sec
->sh_size
== 0)
6250 warn (_("Unable to locate .debug_abbrev section!\n"));
6254 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6255 "debug_abbrev section data");
6257 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6258 begin
+ sec
->sh_size
);
6264 while (tags
< start
)
6267 unsigned long abbrev_number
;
6268 abbrev_entry
* entry
;
6271 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6274 /* A null DIE marks the end of a list of children. */
6275 if (abbrev_number
== 0)
6281 /* Scan through the abbreviation list until we reach the
6283 for (entry
= first_abbrev
;
6284 entry
&& entry
->entry
!= abbrev_number
;
6285 entry
= entry
->next
)
6290 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6295 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6296 level
, tags
- section_begin
- bytes_read
,
6298 get_TAG_name (entry
->tag
));
6300 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6301 tags
= read_and_display_attr (attr
->attribute
,
6304 compunit
.cu_pointer_size
);
6306 if (entry
->children
)
6317 display_debug_aranges (section
, start
, file
)
6318 Elf32_Internal_Shdr
* section
;
6319 unsigned char * start
;
6320 FILE * file ATTRIBUTE_UNUSED
;
6322 unsigned char * end
= start
+ section
->sh_size
;
6324 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6328 DWARF2_External_ARange
* external
;
6329 DWARF2_Internal_ARange arange
;
6330 unsigned char * ranges
;
6331 unsigned long length
;
6332 unsigned long address
;
6335 external
= (DWARF2_External_ARange
*) start
;
6337 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6338 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6339 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6340 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6341 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6343 printf (_(" Length: %ld\n"), arange
.ar_length
);
6344 printf (_(" Version: %d\n"), arange
.ar_version
);
6345 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6346 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6347 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6349 printf (_("\n Address Length\n"));
6351 ranges
= start
+ sizeof (* external
);
6353 /* Must pad to an alignment boundary that is twice the pointer size. */
6354 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
6356 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6360 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6362 ranges
+= arange
.ar_pointer_size
;
6364 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6366 ranges
+= arange
.ar_pointer_size
;
6368 /* A pair of zeros marks the end of the list. */
6369 if (address
== 0 && length
== 0)
6372 printf (" %8.8lx %lu\n", address
, length
);
6375 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6385 display_debug_not_supported (section
, start
, file
)
6386 Elf32_Internal_Shdr
* section
;
6387 unsigned char * start ATTRIBUTE_UNUSED
;
6388 FILE * file ATTRIBUTE_UNUSED
;
6390 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6391 SECTION_NAME (section
));
6396 /* Pre-scan the .debug_info section to record the size of address.
6397 When dumping the .debug_line, we use that size information, assuming
6398 that all compilation units have the same address size. */
6400 prescan_debug_info (section
, start
, file
)
6401 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
6402 unsigned char * start
;
6403 FILE * file ATTRIBUTE_UNUSED
;
6405 DWARF2_External_CompUnit
* external
;
6407 external
= (DWARF2_External_CompUnit
*) start
;
6409 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6413 /* A structure containing the name of a debug section and a pointer
6414 to a function that can decode it. The third field is a prescan
6415 function to be run over the section before displaying any of the
6420 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6421 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6425 { ".debug_info", display_debug_info
, prescan_debug_info
},
6426 { ".debug_abbrev", display_debug_abbrev
, NULL
},
6427 { ".debug_line", display_debug_lines
, NULL
},
6428 { ".debug_aranges", display_debug_aranges
, NULL
},
6429 { ".debug_pubnames", display_debug_pubnames
, NULL
},
6430 { ".debug_macinfo", display_debug_not_supported
, NULL
},
6431 { ".debug_frame", display_debug_not_supported
, NULL
},
6432 { ".debug_str", display_debug_not_supported
, NULL
},
6433 { ".debug_static_func", display_debug_not_supported
, NULL
},
6434 { ".debug_static_vars", display_debug_not_supported
, NULL
},
6435 { ".debug_types", display_debug_not_supported
, NULL
},
6436 { ".debug_weaknames", display_debug_not_supported
, NULL
}
6440 display_debug_section (section
, file
)
6441 Elf32_Internal_Shdr
* section
;
6444 char * name
= SECTION_NAME (section
);
6445 bfd_size_type length
;
6446 unsigned char * start
;
6449 length
= section
->sh_size
;
6452 printf (_("\nSection '%s' has no debugging data.\n"), name
);
6456 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6457 "debug section data");
6459 /* See if we know how to display the contents of this section. */
6460 for (i
= NUM_ELEM (debug_displays
); i
--;)
6461 if (strcmp (debug_displays
[i
].name
, name
) == 0)
6463 debug_displays
[i
].display (section
, start
, file
);
6468 printf (_("Unrecognised debug section: %s\n"), name
);
6472 /* If we loaded in the abbrev section at some point,
6473 we must release it here. */
6474 if (first_abbrev
!= NULL
)
6481 process_section_contents (file
)
6484 Elf32_Internal_Shdr
* section
;
6490 /* Pre-scan the debug sections to find some debug information not
6491 present in some of them. For the .debug_line, we must find out the
6492 size of address (specified in .debug_info and .debug_aranges). */
6493 for (i
= 0, section
= section_headers
;
6494 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6497 char * name
= SECTION_NAME (section
);
6500 if (section
->sh_size
== 0)
6503 /* See if there is some pre-scan operation for this section. */
6504 for (j
= NUM_ELEM (debug_displays
); j
--;)
6505 if (strcmp (debug_displays
[j
].name
, name
) == 0)
6507 if (debug_displays
[j
].prescan
!= NULL
)
6509 bfd_size_type length
;
6510 unsigned char * start
;
6512 length
= section
->sh_size
;
6513 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6514 "debug section data");
6516 debug_displays
[j
].prescan (section
, start
, file
);
6524 for (i
= 0, section
= section_headers
;
6525 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6528 #ifdef SUPPORT_DISASSEMBLY
6529 if (dump_sects
[i
] & DISASS_DUMP
)
6530 disassemble_section (section
, file
);
6532 if (dump_sects
[i
] & HEX_DUMP
)
6533 dump_section (section
, file
);
6535 if (dump_sects
[i
] & DEBUG_DUMP
)
6536 display_debug_section (section
, file
);
6539 if (i
< num_dump_sects
)
6540 warn (_("Some sections were not dumped because they do not exist!\n"));
6546 process_mips_fpe_exception (mask
)
6552 if (mask
& OEX_FPU_INEX
)
6553 fputs ("INEX", stdout
), first
= 0;
6554 if (mask
& OEX_FPU_UFLO
)
6555 printf ("%sUFLO", first
? "" : "|"), first
= 0;
6556 if (mask
& OEX_FPU_OFLO
)
6557 printf ("%sOFLO", first
? "" : "|"), first
= 0;
6558 if (mask
& OEX_FPU_DIV0
)
6559 printf ("%sDIV0", first
? "" : "|"), first
= 0;
6560 if (mask
& OEX_FPU_INVAL
)
6561 printf ("%sINVAL", first
? "" : "|");
6564 fputs ("0", stdout
);
6568 process_mips_specific (file
)
6571 Elf_Internal_Dyn
* entry
;
6572 size_t liblist_offset
= 0;
6573 size_t liblistno
= 0;
6574 size_t conflictsno
= 0;
6575 size_t options_offset
= 0;
6576 size_t conflicts_offset
= 0;
6578 /* We have a lot of special sections. Thanks SGI! */
6579 if (dynamic_segment
== NULL
)
6580 /* No information available. */
6583 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
6584 switch (entry
->d_tag
)
6586 case DT_MIPS_LIBLIST
:
6587 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
6589 case DT_MIPS_LIBLISTNO
:
6590 liblistno
= entry
->d_un
.d_val
;
6592 case DT_MIPS_OPTIONS
:
6593 options_offset
= entry
->d_un
.d_val
- loadaddr
;
6595 case DT_MIPS_CONFLICT
:
6596 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
6598 case DT_MIPS_CONFLICTNO
:
6599 conflictsno
= entry
->d_un
.d_val
;
6605 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
6607 Elf32_External_Lib
* elib
;
6610 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
6611 elib
, Elf32_External_Lib
*, "liblist");
6613 printf ("\nSection '.liblist' contains %lu entries:\n",
6614 (unsigned long) liblistno
);
6615 fputs (" Library Time Stamp Checksum Version Flags\n",
6618 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
6624 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
6625 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
6626 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
6627 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
6628 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
6630 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
6632 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
6633 dynamic_strings
+ liblist
.l_name
, timebuf
,
6634 liblist
.l_checksum
, liblist
.l_version
);
6636 if (liblist
.l_flags
== 0)
6647 { " EXACT_MATCH", LL_EXACT_MATCH
},
6648 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
6649 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
6650 { " EXPORTS", LL_EXPORTS
},
6651 { " DELAY_LOAD", LL_DELAY_LOAD
},
6652 { " DELTA", LL_DELTA
}
6654 int flags
= liblist
.l_flags
;
6658 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
6660 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
6662 fputs (l_flags_vals
[fcnt
].name
, stdout
);
6663 flags
^= l_flags_vals
[fcnt
].bit
;
6666 printf (" %#x", (unsigned int) flags
);
6675 if (options_offset
!= 0)
6677 Elf_External_Options
* eopt
;
6678 Elf_Internal_Shdr
* sect
= section_headers
;
6679 Elf_Internal_Options
* iopt
;
6680 Elf_Internal_Options
* option
;
6684 /* Find the section header so that we get the size. */
6685 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
6688 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
6689 Elf_External_Options
*, "options");
6691 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
6695 error (_("Out of memory"));
6702 while (offset
< sect
->sh_size
)
6704 Elf_External_Options
* eoption
;
6706 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
6708 option
->kind
= BYTE_GET (eoption
->kind
);
6709 option
->size
= BYTE_GET (eoption
->size
);
6710 option
->section
= BYTE_GET (eoption
->section
);
6711 option
->info
= BYTE_GET (eoption
->info
);
6713 offset
+= option
->size
;
6719 printf (_("\nSection '%s' contains %d entries:\n"),
6720 string_table
+ sect
->sh_name
, cnt
);
6728 switch (option
->kind
)
6731 /* This shouldn't happen. */
6732 printf (" NULL %d %lx", option
->section
, option
->info
);
6735 printf (" REGINFO ");
6736 if (elf_header
.e_machine
== EM_MIPS
)
6739 Elf32_External_RegInfo
*ereg
;
6740 Elf32_RegInfo reginfo
;
6742 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
6743 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6744 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6745 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6746 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6747 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6748 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
6750 printf ("GPR %08lx GP 0x%lx\n",
6752 (unsigned long) reginfo
.ri_gp_value
);
6753 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6754 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6755 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6760 Elf64_External_RegInfo
* ereg
;
6761 Elf64_Internal_RegInfo reginfo
;
6763 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
6764 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6765 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6766 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6767 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6768 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6769 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
6771 printf ("GPR %08lx GP 0x",
6772 reginfo
.ri_gprmask
);
6773 printf_vma (reginfo
.ri_gp_value
);
6776 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6777 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6778 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6782 case ODK_EXCEPTIONS
:
6783 fputs (" EXCEPTIONS fpe_min(", stdout
);
6784 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
6785 fputs (") fpe_max(", stdout
);
6786 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
6787 fputs (")", stdout
);
6789 if (option
->info
& OEX_PAGE0
)
6790 fputs (" PAGE0", stdout
);
6791 if (option
->info
& OEX_SMM
)
6792 fputs (" SMM", stdout
);
6793 if (option
->info
& OEX_FPDBUG
)
6794 fputs (" FPDBUG", stdout
);
6795 if (option
->info
& OEX_DISMISS
)
6796 fputs (" DISMISS", stdout
);
6799 fputs (" PAD ", stdout
);
6800 if (option
->info
& OPAD_PREFIX
)
6801 fputs (" PREFIX", stdout
);
6802 if (option
->info
& OPAD_POSTFIX
)
6803 fputs (" POSTFIX", stdout
);
6804 if (option
->info
& OPAD_SYMBOL
)
6805 fputs (" SYMBOL", stdout
);
6808 fputs (" HWPATCH ", stdout
);
6809 if (option
->info
& OHW_R4KEOP
)
6810 fputs (" R4KEOP", stdout
);
6811 if (option
->info
& OHW_R8KPFETCH
)
6812 fputs (" R8KPFETCH", stdout
);
6813 if (option
->info
& OHW_R5KEOP
)
6814 fputs (" R5KEOP", stdout
);
6815 if (option
->info
& OHW_R5KCVTL
)
6816 fputs (" R5KCVTL", stdout
);
6819 fputs (" FILL ", stdout
);
6820 /* XXX Print content of info word? */
6823 fputs (" TAGS ", stdout
);
6824 /* XXX Print content of info word? */
6827 fputs (" HWAND ", stdout
);
6828 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6829 fputs (" R4KEOP_CHECKED", stdout
);
6830 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6831 fputs (" R4KEOP_CLEAN", stdout
);
6834 fputs (" HWOR ", stdout
);
6835 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6836 fputs (" R4KEOP_CHECKED", stdout
);
6837 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6838 fputs (" R4KEOP_CLEAN", stdout
);
6841 printf (" GP_GROUP %#06lx self-contained %#06lx",
6842 option
->info
& OGP_GROUP
,
6843 (option
->info
& OGP_SELF
) >> 16);
6846 printf (" IDENT %#06lx self-contained %#06lx",
6847 option
->info
& OGP_GROUP
,
6848 (option
->info
& OGP_SELF
) >> 16);
6851 /* This shouldn't happen. */
6852 printf (" %3d ??? %d %lx",
6853 option
->kind
, option
->section
, option
->info
);
6857 len
= sizeof (*eopt
);
6858 while (len
< option
->size
)
6859 if (((char *) option
)[len
] >= ' '
6860 && ((char *) option
)[len
] < 0x7f)
6861 printf ("%c", ((char *) option
)[len
++]);
6863 printf ("\\%03o", ((char *) option
)[len
++]);
6865 fputs ("\n", stdout
);
6872 if (conflicts_offset
!= 0 && conflictsno
!= 0)
6874 Elf32_External_Conflict
* econf32
;
6875 Elf64_External_Conflict
* econf64
;
6876 Elf32_Conflict
* iconf
;
6879 if (dynamic_symbols
== NULL
)
6881 error (_("conflict list with without table"));
6885 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
6888 error (_("Out of memory"));
6894 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
6895 econf32
, Elf32_External_Conflict
*, "conflict");
6897 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6898 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
6902 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
6903 econf64
, Elf64_External_Conflict
*, "conflict");
6905 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6906 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
6909 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
6910 puts (_(" Num: Index Value Name"));
6912 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6914 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
6916 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
6917 print_vma (psym
->st_value
, FULL_HEX
);
6918 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
6928 get_note_type (e_type
)
6931 static char buff
[64];
6935 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
6936 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
6937 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
6938 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
6939 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
6940 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
6941 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
6942 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
6943 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6944 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
6945 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
6947 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
6952 /* Note that by the ELF standard, the name field is already null byte
6953 terminated, and namesz includes the terminating null byte.
6954 I.E. the value of namesz for the name "FSF" is 4.
6956 If the value of namesz is zero, there is no name present. */
6958 process_note (pnote
)
6959 Elf32_Internal_Note
* pnote
;
6961 printf (" %s\t\t0x%08lx\t%s\n",
6962 pnote
->namesz
? pnote
->namedata
: "(NONE)",
6963 pnote
->descsz
, get_note_type (pnote
->type
));
6969 process_corefile_note_segment (file
, offset
, length
)
6974 Elf_External_Note
* pnotes
;
6975 Elf_External_Note
* external
;
6981 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
6985 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
6986 (unsigned long) offset
,
6987 (unsigned long) length
);
6988 printf (_(" Owner\t\tData size\tDescription\n"));
6990 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
6992 Elf32_Internal_Note inote
;
6995 inote
.type
= BYTE_GET (external
->type
);
6996 inote
.namesz
= BYTE_GET (external
->namesz
);
6997 inote
.namedata
= external
->name
;
6998 inote
.descsz
= BYTE_GET (external
->descsz
);
6999 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
7000 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
7002 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
7004 /* Verify that name is null terminated. It appears that at least
7005 one version of Linux (RedHat 6.0) generates corefiles that don't
7006 comply with the ELF spec by failing to include the null byte in
7008 if (inote
.namedata
[inote
.namesz
] != '\0')
7010 temp
= malloc (inote
.namesz
+ 1);
7014 error (_("Out of memory\n"));
7019 strncpy (temp
, inote
.namedata
, inote
.namesz
);
7020 temp
[inote
.namesz
] = 0;
7022 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7023 inote
.namedata
= temp
;
7026 res
&= process_note (& inote
);
7041 process_corefile_note_segments (file
)
7044 Elf_Internal_Phdr
* program_headers
;
7045 Elf_Internal_Phdr
* segment
;
7049 program_headers
= (Elf_Internal_Phdr
*) malloc
7050 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
7052 if (program_headers
== NULL
)
7054 error (_("Out of memory\n"));
7059 i
= get_32bit_program_headers (file
, program_headers
);
7061 i
= get_64bit_program_headers (file
, program_headers
);
7065 free (program_headers
);
7069 for (i
= 0, segment
= program_headers
;
7070 i
< elf_header
.e_phnum
;
7073 if (segment
->p_type
== PT_NOTE
)
7074 res
&= process_corefile_note_segment (file
,
7075 (bfd_vma
) segment
->p_offset
,
7076 (bfd_vma
) segment
->p_filesz
);
7079 free (program_headers
);
7085 process_corefile_contents (file
)
7088 /* If we have not been asked to display the notes then do nothing. */
7092 /* If file is not a core file then exit. */
7093 if (elf_header
.e_type
!= ET_CORE
)
7096 /* No program headers means no NOTE segment. */
7097 if (elf_header
.e_phnum
== 0)
7099 printf (_("No note segments present in the core file.\n"));
7103 return process_corefile_note_segments (file
);
7107 process_arch_specific (file
)
7113 switch (elf_header
.e_machine
)
7116 case EM_MIPS_RS4_BE
:
7117 return process_mips_specific (file
);
7126 get_file_header (file
)
7129 /* Read in the identity array. */
7130 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
7133 /* Determine how to read the rest of the header. */
7134 switch (elf_header
.e_ident
[EI_DATA
])
7136 default: /* fall through */
7137 case ELFDATANONE
: /* fall through */
7138 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
7139 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
7142 /* For now we only support 32 bit and 64 bit ELF files. */
7143 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
7145 /* Read in the rest of the header. */
7148 Elf32_External_Ehdr ehdr32
;
7150 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
7153 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
7154 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
7155 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
7156 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
7157 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
7158 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
7159 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
7160 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
7161 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
7162 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
7163 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
7164 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
7165 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
7169 Elf64_External_Ehdr ehdr64
;
7171 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7172 we will not be able to cope with the 64bit data found in
7173 64 ELF files. Detect this now and abort before we start
7174 overwritting things. */
7175 if (sizeof (bfd_vma
) < 8)
7177 error (_("This instance of readelf has been built without support for a\n"));
7178 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7182 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
7185 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
7186 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
7187 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
7188 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
7189 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
7190 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
7191 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
7192 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
7193 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
7194 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
7195 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
7196 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
7197 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
7204 process_file (file_name
)
7208 struct stat statbuf
;
7211 if (stat (file_name
, & statbuf
) < 0)
7213 error (_("Cannot stat input file %s.\n"), file_name
);
7217 file
= fopen (file_name
, "rb");
7220 error (_("Input file %s not found.\n"), file_name
);
7224 if (! get_file_header (file
))
7226 error (_("%s: Failed to read file header\n"), file_name
);
7231 /* Initialise per file variables. */
7232 for (i
= NUM_ELEM (version_info
); i
--;)
7233 version_info
[i
] = 0;
7235 for (i
= NUM_ELEM (dynamic_info
); i
--;)
7236 dynamic_info
[i
] = 0;
7238 /* Process the file. */
7240 printf (_("\nFile: %s\n"), file_name
);
7242 if (! process_file_header ())
7248 process_section_headers (file
);
7250 process_program_headers (file
);
7252 process_dynamic_segment (file
);
7254 process_relocs (file
);
7256 process_symbol_table (file
);
7258 process_syminfo (file
);
7260 process_version_sections (file
);
7262 process_section_contents (file
);
7264 process_corefile_contents (file
);
7266 process_arch_specific (file
);
7270 if (section_headers
)
7272 free (section_headers
);
7273 section_headers
= NULL
;
7278 free (string_table
);
7279 string_table
= NULL
;
7282 if (dynamic_strings
)
7284 free (dynamic_strings
);
7285 dynamic_strings
= NULL
;
7288 if (dynamic_symbols
)
7290 free (dynamic_symbols
);
7291 dynamic_symbols
= NULL
;
7292 num_dynamic_syms
= 0;
7295 if (dynamic_syminfo
)
7297 free (dynamic_syminfo
);
7298 dynamic_syminfo
= NULL
;
7302 #ifdef SUPPORT_DISASSEMBLY
7303 /* Needed by the i386 disassembler. For extra credit, someone could
7304 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7308 print_address (unsigned int addr
, FILE * outfile
)
7310 fprintf (outfile
,"0x%8.8x", addr
);
7313 /* Needed by the i386 disassembler. */
7315 db_task_printsym (unsigned int addr
)
7317 print_address (addr
, stderr
);
7326 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7327 setlocale (LC_MESSAGES
, "");
7329 bindtextdomain (PACKAGE
, LOCALEDIR
);
7330 textdomain (PACKAGE
);
7332 parse_args (argc
, argv
);
7334 if (optind
< (argc
- 1))
7337 while (optind
< argc
)
7338 process_file (argv
[optind
++]);
7340 if (dump_sects
!= NULL
)