1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 1999 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 /* Forward declarations for dumb compilers. */
130 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
131 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
132 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
133 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
134 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
135 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
136 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
137 static const char * get_dynamic_type
PARAMS ((unsigned long));
138 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
139 static char * get_file_type
PARAMS ((unsigned));
140 static char * get_machine_name
PARAMS ((unsigned));
141 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
142 static const char * get_mips_segment_type
PARAMS ((unsigned long));
143 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
144 static const char * get_segment_type
PARAMS ((unsigned long));
145 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
146 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
147 static const char * get_section_type_name
PARAMS ((unsigned int));
148 static char * get_symbol_binding
PARAMS ((unsigned int));
149 static char * get_symbol_type
PARAMS ((unsigned int));
150 static void usage
PARAMS ((void));
151 static void parse_args
PARAMS ((int, char **));
152 static int process_file_header
PARAMS ((void));
153 static int process_program_headers
PARAMS ((FILE *));
154 static int process_section_headers
PARAMS ((FILE *));
155 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
156 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
157 static int process_dynamic_segment
PARAMS ((FILE *));
158 static int process_symbol_table
PARAMS ((FILE *));
159 static int process_section_contents
PARAMS ((FILE *));
160 static void process_file
PARAMS ((char *));
161 static int process_relocs
PARAMS ((FILE *));
162 static int process_version_sections
PARAMS ((FILE *));
163 static char * get_ver_flags
PARAMS ((unsigned int));
164 static char * get_symbol_index_type
PARAMS ((unsigned int));
165 static int get_32bit_section_headers
PARAMS ((FILE *));
166 static int get_64bit_section_headers
PARAMS ((FILE *));
167 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
168 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
169 static int get_file_header
PARAMS ((FILE *));
170 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
171 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
172 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
173 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
174 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
175 #ifdef SUPPORT_DISASSEMBLY
176 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
178 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
179 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
180 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
181 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
182 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
183 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
184 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
185 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
186 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
187 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
188 static void reset_state_machine
PARAMS ((int));
189 static char * get_TAG_name
PARAMS ((unsigned long));
190 static char * get_AT_name
PARAMS ((unsigned long));
191 static char * get_FORM_name
PARAMS ((unsigned long));
192 static void free_abbrevs
PARAMS ((void));
193 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
194 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
195 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
196 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
197 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int));
198 static void request_dump
PARAMS ((unsigned int, char));
199 static const char * get_elf_class
PARAMS ((unsigned char));
200 static const char * get_data_encoding
PARAMS ((unsigned char));
201 static const char * get_osabi_name
PARAMS ((unsigned char));
202 static int guess_is_rela
PARAMS ((unsigned long));
203 static char * get_note_type
PARAMS ((unsigned int));
204 static int process_note
PARAMS ((Elf32_Internal_Note
*));
205 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
206 static int process_corefile_note_segments
PARAMS ((FILE *));
207 static int process_corefile_contents
PARAMS ((FILE *));
209 typedef int Elf32_Word
;
217 #define SECTION_NAME(X) (string_table + (X)->sh_name)
219 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
221 #define BYTE_GET(field) byte_get (field, sizeof (field))
223 /* If we can support a 64 bit data type then BFD64 should be defined
224 and sizeof (bfd_vma) == 8. In this case when translating from an
225 external 8 byte field to an internal field, we can assume that the
226 internal field is also 8 bytes wide and so we can extact all the data.
227 If, however, BFD64 is not defined, then we must assume that the
228 internal data structure only has 4 byte wide fields that are the
229 equivalent of the 8 byte wide external counterparts, and so we must
230 truncate the data. */
232 #define BYTE_GET8(field) byte_get (field, -8)
234 #define BYTE_GET8(field) byte_get (field, 8)
237 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
239 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
240 if (fseek (file, offset, SEEK_SET)) \
242 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
246 var = (type) malloc (size); \
250 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
254 if (fread (var, size, 1, file) != 1) \
256 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
263 #define GET_DATA(offset, var, reason) \
264 if (fseek (file, offset, SEEK_SET)) \
266 error (_("Unable to seek to %x for %s\n"), offset, reason); \
269 else if (fread (& var, sizeof (var), 1, file) != 1) \
271 error (_("Unable to read data at %x for %s\n"), offset, reason); \
275 #define GET_ELF_SYMBOLS(file, offset, size) \
276 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
277 : get_64bit_elf_symbols (file, offset, size))
280 #ifdef ANSI_PROTOTYPES
282 error (const char * message
, ...)
286 fprintf (stderr
, _("%s: Error: "), program_name
);
287 va_start (args
, message
);
288 vfprintf (stderr
, message
, args
);
294 warn (const char * message
, ...)
298 fprintf (stderr
, _("%s: Warning: "), program_name
);
299 va_start (args
, message
);
300 vfprintf (stderr
, message
, args
);
312 fprintf (stderr
, _("%s: Error: "), program_name
);
314 message
= va_arg (args
, char *);
315 vfprintf (stderr
, message
, args
);
327 fprintf (stderr
, _("%s: Warning: "), program_name
);
329 message
= va_arg (args
, char *);
330 vfprintf (stderr
, message
, args
);
337 byte_get_little_endian (field
, size
)
338 unsigned char * field
;
347 return ((unsigned int) (field
[0]))
348 | (((unsigned int) (field
[1])) << 8);
351 /* We want to extract data from an 8 byte wide field and
352 place it into a 4 byte wide field. Since this is a little
353 endian source we can juts use the 4 byte extraction code. */
356 return ((unsigned long) (field
[0]))
357 | (((unsigned long) (field
[1])) << 8)
358 | (((unsigned long) (field
[2])) << 16)
359 | (((unsigned long) (field
[3])) << 24);
363 /* This is a special case, generated by the BYTE_GET8 macro.
364 It means that we are loading an 8 byte value from a field
365 in an external structure into an 8 byte value in a field
366 in an internal strcuture. */
367 return ((bfd_vma
) (field
[0]))
368 | (((bfd_vma
) (field
[1])) << 8)
369 | (((bfd_vma
) (field
[2])) << 16)
370 | (((bfd_vma
) (field
[3])) << 24)
371 | (((bfd_vma
) (field
[4])) << 32)
372 | (((bfd_vma
) (field
[5])) << 40)
373 | (((bfd_vma
) (field
[6])) << 48)
374 | (((bfd_vma
) (field
[7])) << 56);
377 error (_("Unhandled data length: %d\n"), size
);
382 /* Print a VMA value. */
383 typedef enum print_mode
396 print_vma (vma
, mode
)
406 case FULL_HEX
: printf ("0x"); /* drop through */
407 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
408 case PREFIX_HEX
: printf ("0x"); /* drop through */
409 case HEX
: printf ("%lx", (unsigned long) vma
); break;
410 case DEC
: printf ("%ld", (unsigned long) vma
); break;
411 case DEC_5
: printf ("%5ld", (long) vma
); break;
412 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
433 #if BFD_HOST_64BIT_LONG
436 if (_bfd_int64_high (vma
))
437 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
439 printf ("%lx", _bfd_int64_low (vma
));
444 if (_bfd_int64_high (vma
))
446 printf ("++%ld", _bfd_int64_low (vma
));
448 printf ("%ld", _bfd_int64_low (vma
));
452 if (_bfd_int64_high (vma
))
454 printf ("++%ld", _bfd_int64_low (vma
));
456 printf ("%5ld", _bfd_int64_low (vma
));
460 if (_bfd_int64_high (vma
))
462 printf ("++%lu", _bfd_int64_low (vma
));
464 printf ("%lu", _bfd_int64_low (vma
));
472 byte_get_big_endian (field
, size
)
473 unsigned char * field
;
482 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
485 return ((unsigned long) (field
[3]))
486 | (((unsigned long) (field
[2])) << 8)
487 | (((unsigned long) (field
[1])) << 16)
488 | (((unsigned long) (field
[0])) << 24);
491 /* Although we are extracing data from an 8 byte wide field, we
492 are returning only 4 bytes of data. */
493 return ((unsigned long) (field
[7]))
494 | (((unsigned long) (field
[6])) << 8)
495 | (((unsigned long) (field
[5])) << 16)
496 | (((unsigned long) (field
[4])) << 24);
500 /* This is a special case, generated by the BYTE_GET8 macro.
501 It means that we are loading an 8 byte value from a field
502 in an external structure into an 8 byte value in a field
503 in an internal strcuture. */
504 return ((bfd_vma
) (field
[7]))
505 | (((bfd_vma
) (field
[6])) << 8)
506 | (((bfd_vma
) (field
[5])) << 16)
507 | (((bfd_vma
) (field
[4])) << 24)
508 | (((bfd_vma
) (field
[3])) << 32)
509 | (((bfd_vma
) (field
[2])) << 40)
510 | (((bfd_vma
) (field
[1])) << 48)
511 | (((bfd_vma
) (field
[0])) << 56);
515 error (_("Unhandled data length: %d\n"), size
);
521 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
523 guess_is_rela (e_machine
)
524 unsigned long e_machine
;
528 /* Targets that use REL relocations. */
539 /* Targets that use RELA relocations. */
547 case EM_CYGNUS_MN10200
:
548 case EM_CYGNUS_MN10300
:
556 warn (_("Don't know about relocations on this machine architecture\n"));
561 /* Display the contents of the relocation data found at the specified offset. */
563 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
565 unsigned long rel_offset
;
566 unsigned long rel_size
;
567 Elf_Internal_Sym
* symtab
;
573 Elf_Internal_Rel
* rels
;
574 Elf_Internal_Rela
* relas
;
577 if (is_rela
== UNKNOWN
)
578 is_rela
= guess_is_rela (elf_header
.e_machine
);
584 Elf32_External_Rela
* erelas
;
586 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
587 Elf32_External_Rela
*, "relocs");
589 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
591 relas
= (Elf_Internal_Rela
*)
592 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
596 error(_("out of memory parsing relocs"));
600 for (i
= 0; i
< rel_size
; i
++)
602 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
603 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
604 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
609 rels
= (Elf_Internal_Rel
*) relas
;
613 Elf64_External_Rela
* erelas
;
615 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
616 Elf64_External_Rela
*, "relocs");
618 rel_size
= rel_size
/ sizeof (Elf64_External_Rela
);
620 relas
= (Elf_Internal_Rela
*)
621 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
625 error(_("out of memory parsing relocs"));
629 for (i
= 0; i
< rel_size
; i
++)
631 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
632 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
633 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
638 rels
= (Elf_Internal_Rel
*) relas
;
645 Elf32_External_Rel
* erels
;
647 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
648 Elf32_External_Rel
*, "relocs");
650 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
652 rels
= (Elf_Internal_Rel
*)
653 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
657 error(_("out of memory parsing relocs"));
661 for (i
= 0; i
< rel_size
; i
++)
663 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
664 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
669 relas
= (Elf_Internal_Rela
*) rels
;
673 Elf64_External_Rel
* erels
;
675 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
676 Elf64_External_Rel
*, "relocs");
678 rel_size
= rel_size
/ sizeof (Elf64_External_Rel
);
680 rels
= (Elf_Internal_Rel
*)
681 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
685 error(_("out of memory parsing relocs"));
689 for (i
= 0; i
< rel_size
; i
++)
691 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
692 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
697 relas
= (Elf_Internal_Rela
*) rels
;
703 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
706 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
708 for (i
= 0; i
< rel_size
; i
++)
713 bfd_vma symtab_index
;
718 offset
= relas
[i
].r_offset
;
719 info
= relas
[i
].r_info
;
723 offset
= rels
[i
].r_offset
;
724 info
= rels
[i
].r_info
;
729 type
= ELF32_R_TYPE (info
);
730 symtab_index
= ELF32_R_SYM (info
);
734 if (elf_header
.e_machine
== EM_SPARCV9
)
735 type
= ELF64_R_TYPE_ID (info
);
737 type
= ELF64_R_TYPE (info
);
738 /* The #ifdef BFD64 below is to prevent a compile time warning.
739 We know that if we do not have a 64 bit data type that we
740 will never execute this code anyway. */
742 symtab_index
= ELF64_R_SYM (info
);
746 #ifdef _bfd_int64_low
747 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
749 printf (" %8.8lx %5.5lx ", offset
, info
);
752 switch (elf_header
.e_machine
)
759 rtype
= elf_m32r_reloc_type (type
);
764 rtype
= elf_i386_reloc_type (type
);
768 rtype
= elf_m68k_reloc_type (type
);
772 rtype
= elf_i960_reloc_type (type
);
779 rtype
= elf_sparc_reloc_type (type
);
783 rtype
= v850_reloc_type (type
);
787 rtype
= elf_d10v_reloc_type (type
);
791 rtype
= elf_d30v_reloc_type (type
);
795 rtype
= elf_sh_reloc_type (type
);
798 case EM_CYGNUS_MN10300
:
799 rtype
= elf_mn10300_reloc_type (type
);
802 case EM_CYGNUS_MN10200
:
803 rtype
= elf_mn10200_reloc_type (type
);
807 rtype
= elf_fr30_reloc_type (type
);
811 rtype
= elf_mcore_reloc_type (type
);
815 rtype
= elf_ppc_reloc_type (type
);
820 rtype
= elf_mips_reloc_type (type
);
824 rtype
= elf_alpha_reloc_type (type
);
828 rtype
= elf_arm_reloc_type (type
);
832 rtype
= elf_arc_reloc_type (type
);
836 rtype
= elf_hppa_reloc_type (type
);
840 rtype
= elf_pj_reloc_type (type
);
845 #ifdef _bfd_int64_low
846 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
848 printf (_("unrecognised: %-7lx"), type
);
851 printf ("%-21.21s", rtype
);
857 if (symtab_index
>= nsyms
)
858 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
861 Elf_Internal_Sym
* psym
;
863 psym
= symtab
+ symtab_index
;
866 print_vma (psym
->st_value
, LONG_HEX
);
869 if (psym
->st_name
== 0)
871 SECTION_NAME (section_headers
+ psym
->st_shndx
));
872 else if (strtab
== NULL
)
873 printf (_("<string table index %3ld>"), psym
->st_name
);
875 printf ("%-25.25s", strtab
+ psym
->st_name
);
878 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
884 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
885 print_vma (relas
[i
].r_addend
, LONG_HEX
);
888 if (elf_header
.e_machine
== EM_SPARCV9
889 && !strcmp (rtype
, "R_SPARC_OLO10"))
890 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
901 get_mips_dynamic_type (type
)
906 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
907 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
908 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
909 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
910 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
911 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
912 case DT_MIPS_MSYM
: return "MIPS_MSYM";
913 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
914 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
915 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
916 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
917 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
918 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
919 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
920 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
921 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
922 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
923 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
924 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
925 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
926 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
927 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
928 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
929 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
930 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
931 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
932 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
933 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
934 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
935 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
936 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
937 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
938 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
939 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
940 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
941 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
942 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
943 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
944 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
945 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
946 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
947 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
948 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
955 get_sparc64_dynamic_type (type
)
960 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
967 get_parisc_dynamic_type (type
)
972 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
973 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
974 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
975 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
976 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
977 case DT_HP_PREINIT
: return "HP_PREINIT";
978 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
979 case DT_HP_NEEDED
: return "HP_NEEDED";
980 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
981 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
982 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
983 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
984 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
991 get_dynamic_type (type
)
994 static char buff
[32];
998 case DT_NULL
: return "NULL";
999 case DT_NEEDED
: return "NEEDED";
1000 case DT_PLTRELSZ
: return "PLTRELSZ";
1001 case DT_PLTGOT
: return "PLTGOT";
1002 case DT_HASH
: return "HASH";
1003 case DT_STRTAB
: return "STRTAB";
1004 case DT_SYMTAB
: return "SYMTAB";
1005 case DT_RELA
: return "RELA";
1006 case DT_RELASZ
: return "RELASZ";
1007 case DT_RELAENT
: return "RELAENT";
1008 case DT_STRSZ
: return "STRSZ";
1009 case DT_SYMENT
: return "SYMENT";
1010 case DT_INIT
: return "INIT";
1011 case DT_FINI
: return "FINI";
1012 case DT_SONAME
: return "SONAME";
1013 case DT_RPATH
: return "RPATH";
1014 case DT_SYMBOLIC
: return "SYMBOLIC";
1015 case DT_REL
: return "REL";
1016 case DT_RELSZ
: return "RELSZ";
1017 case DT_RELENT
: return "RELENT";
1018 case DT_PLTREL
: return "PLTREL";
1019 case DT_DEBUG
: return "DEBUG";
1020 case DT_TEXTREL
: return "TEXTREL";
1021 case DT_JMPREL
: return "JMPREL";
1022 case DT_BIND_NOW
: return "BIND_NOW";
1023 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1024 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1025 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1026 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1028 case DT_PLTPADSZ
: return "PLTPADSZ";
1029 case DT_MOVEENT
: return "MOVEENT";
1030 case DT_MOVESZ
: return "MOVESZ";
1031 case DT_FEATURE_1
: return "FEATURE_1";
1032 case DT_POSFLAG_1
: return "POSFLAG_1";
1033 case DT_SYMINSZ
: return "SYMINSZ";
1034 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1036 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1037 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1039 case DT_VERSYM
: return "VERSYM";
1041 case DT_RELACOUNT
: return "RELACOUNT";
1042 case DT_RELCOUNT
: return "RELCOUNT";
1043 case DT_FLAGS_1
: return "FLAGS_1";
1044 case DT_VERDEF
: return "VERDEF";
1045 case DT_VERDEFNUM
: return "VERDEFNUM";
1046 case DT_VERNEED
: return "VERNEED";
1047 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1049 case DT_AUXILIARY
: return "AUXILARY";
1050 case DT_USED
: return "USED";
1051 case DT_FILTER
: return "FILTER";
1054 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1056 const char * result
;
1058 switch (elf_header
.e_machine
)
1061 case EM_MIPS_RS4_BE
:
1062 result
= get_mips_dynamic_type (type
);
1065 result
= get_sparc64_dynamic_type (type
);
1075 sprintf (buff
, _("Processor Specific: %lx"), type
);
1077 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1079 const char * result
;
1081 switch (elf_header
.e_machine
)
1084 result
= get_parisc_dynamic_type (type
);
1094 sprintf (buff
, _("Operating System specific: %lx"), type
);
1097 sprintf (buff
, _("<unknown>: %lx"), type
);
1104 get_file_type (e_type
)
1107 static char buff
[32];
1111 case ET_NONE
: return _("NONE (None)");
1112 case ET_REL
: return _("REL (Relocatable file)");
1113 case ET_EXEC
: return _("EXEC (Executable file)");
1114 case ET_DYN
: return _("DYN (Shared object file)");
1115 case ET_CORE
: return _("CORE (Core file)");
1118 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1119 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1120 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1121 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1123 sprintf (buff
, _("<unknown>: %x"), e_type
);
1129 get_machine_name (e_machine
)
1132 static char buff
[32];
1136 case EM_NONE
: return _("None");
1137 case EM_M32
: return "WE32100";
1138 case EM_SPARC
: return "Sparc";
1139 case EM_386
: return "Intel 80386";
1140 case EM_68K
: return "MC68000";
1141 case EM_88K
: return "MC88000";
1142 case EM_486
: return "Intel 80486";
1143 case EM_860
: return "Intel 80860";
1144 case EM_MIPS
: return "MIPS R3000 big-endian";
1145 case EM_S370
: return "Amdahl";
1146 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1147 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1148 case EM_PARISC
: return "HPPA";
1149 case EM_PPC_OLD
: return "Power PC (old)";
1150 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1151 case EM_960
: return "Intel 90860";
1152 case EM_PPC
: return "PowerPC";
1153 case EM_V800
: return "NEC V800";
1154 case EM_FR20
: return "Fujitsu FR20";
1155 case EM_RH32
: return "TRW RH32";
1156 case EM_MCORE
: return "MCORE";
1157 case EM_ARM
: return "ARM";
1158 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1159 case EM_SH
: return "Hitachi SH";
1160 case EM_SPARCV9
: return "Sparc v9";
1161 case EM_TRICORE
: return "Siemens Tricore";
1162 case EM_ARC
: return "Argonaut RISC Core";
1163 case EM_H8_300
: return "Hitachi H8/300";
1164 case EM_H8_300H
: return "Hitachi H8/300H";
1165 case EM_H8S
: return "Hitachi H8S";
1166 case EM_H8_500
: return "Hitachi H8/500";
1167 case EM_IA_64
: return "Intel IA-64";
1168 case EM_MIPS_X
: return "Stanford MIPS-X";
1169 case EM_COLDFIRE
: return "Motorola Coldfire";
1170 case EM_68HC12
: return "Motorola M68HC12";
1171 case EM_ALPHA
: return "Alpha";
1172 case EM_CYGNUS_D10V
: return "d10v";
1173 case EM_CYGNUS_D30V
: return "d30v";
1174 case EM_CYGNUS_ARC
: return "Arc";
1175 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1176 case EM_CYGNUS_V850
: return "NEC v850";
1177 case EM_CYGNUS_MN10300
: return "mn10300";
1178 case EM_CYGNUS_MN10200
: return "mn10200";
1179 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1180 case EM_PJ
: return "picoJava";
1182 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1188 get_machine_flags (e_flags
, e_machine
)
1192 static char buf
[1024];
1203 if (e_flags
& EF_CPU32
)
1204 strcat (buf
, ", cpu32");
1208 if (e_flags
& EF_PPC_EMB
)
1209 strcat (buf
, ", emb");
1211 if (e_flags
& EF_PPC_RELOCATABLE
)
1212 strcat (buf
, ", relocatable");
1214 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1215 strcat (buf
, ", relocatable-lib");
1218 case EM_CYGNUS_V850
:
1219 switch (e_flags
& EF_V850_ARCH
)
1222 strcat (buf
, ", v850e");
1225 strcat (buf
, ", v850ea");
1228 strcat (buf
, ", v850");
1231 strcat (buf
, ", unknown v850 architecture variant");
1236 case EM_CYGNUS_M32R
:
1237 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1238 strcat (buf
, ", m32r");
1243 case EM_MIPS_RS4_BE
:
1244 if (e_flags
& EF_MIPS_NOREORDER
)
1245 strcat (buf
, ", noreorder");
1247 if (e_flags
& EF_MIPS_PIC
)
1248 strcat (buf
, ", pic");
1250 if (e_flags
& EF_MIPS_CPIC
)
1251 strcat (buf
, ", cpic");
1253 if (e_flags
& EF_MIPS_ABI2
)
1254 strcat (buf
, ", abi2");
1256 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1257 strcat (buf
, ", mips1");
1259 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1260 strcat (buf
, ", mips2");
1262 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1263 strcat (buf
, ", mips3");
1265 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1266 strcat (buf
, ", mips4");
1270 if (e_flags
& EF_SPARC_32PLUS
)
1271 strcat (buf
, ", v8+");
1273 if (e_flags
& EF_SPARC_SUN_US1
)
1274 strcat (buf
, ", ultrasparcI");
1276 if (e_flags
& EF_SPARC_SUN_US3
)
1277 strcat (buf
, ", ultrasparcIII");
1279 if (e_flags
& EF_SPARC_HAL_R1
)
1280 strcat (buf
, ", halr1");
1282 if (e_flags
& EF_SPARC_LEDATA
)
1283 strcat (buf
, ", ledata");
1285 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1286 strcat (buf
, ", tso");
1288 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1289 strcat (buf
, ", pso");
1291 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1292 strcat (buf
, ", rmo");
1296 switch (e_flags
& EF_PARISC_ARCH
)
1298 case EFA_PARISC_1_0
:
1299 strcpy (buf
, ", PA-RISC 1.0");
1301 case EFA_PARISC_1_1
:
1302 strcpy (buf
, ", PA-RISC 1.1");
1304 case EFA_PARISC_2_0
:
1305 strcpy (buf
, ", PA-RISC 2.0");
1310 if (e_flags
& EF_PARISC_TRAPNIL
)
1311 strcat (buf
, ", trapnil");
1312 if (e_flags
& EF_PARISC_EXT
)
1313 strcat (buf
, ", ext");
1314 if (e_flags
& EF_PARISC_LSB
)
1315 strcat (buf
, ", lsb");
1316 if (e_flags
& EF_PARISC_WIDE
)
1317 strcat (buf
, ", wide");
1318 if (e_flags
& EF_PARISC_NO_KABP
)
1319 strcat (buf
, ", no kabp");
1320 if (e_flags
& EF_PARISC_LAZYSWAP
)
1321 strcat (buf
, ", lazyswap");
1325 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1326 strcat (buf
, ", new calling convention");
1328 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1329 strcat (buf
, ", gnu calling convention");
1338 get_mips_segment_type (type
)
1343 case PT_MIPS_REGINFO
:
1345 case PT_MIPS_RTPROC
:
1347 case PT_MIPS_OPTIONS
:
1357 get_parisc_segment_type (type
)
1362 case PT_HP_TLS
: return "HP_TLS";
1363 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1364 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1365 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1366 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1367 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1368 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1369 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1370 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1371 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1372 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1373 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1374 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1375 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1384 get_segment_type (p_type
)
1385 unsigned long p_type
;
1387 static char buff
[32];
1391 case PT_NULL
: return "NULL";
1392 case PT_LOAD
: return "LOAD";
1393 case PT_DYNAMIC
: return "DYNAMIC";
1394 case PT_INTERP
: return "INTERP";
1395 case PT_NOTE
: return "NOTE";
1396 case PT_SHLIB
: return "SHLIB";
1397 case PT_PHDR
: return "PHDR";
1400 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1402 const char * result
;
1404 switch (elf_header
.e_machine
)
1407 case EM_MIPS_RS4_BE
:
1408 result
= get_mips_segment_type (p_type
);
1411 result
= get_parisc_segment_type (p_type
);
1421 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1423 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1425 const char * result
;
1427 switch (elf_header
.e_machine
)
1430 result
= get_parisc_segment_type (p_type
);
1440 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1443 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1450 get_mips_section_type_name (sh_type
)
1451 unsigned int sh_type
;
1455 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1456 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1457 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1458 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1459 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1460 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1461 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1462 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1463 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1464 case SHT_MIPS_RELD
: return "MIPS_RELD";
1465 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1466 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1467 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1468 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1469 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1470 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1471 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1472 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1473 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1474 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1475 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1476 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1477 case SHT_MIPS_LINE
: return "MIPS_LINE";
1478 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1479 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1480 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1481 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1482 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1483 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1484 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1485 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1486 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1487 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1488 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1489 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1490 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1491 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1492 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1493 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1501 get_parisc_section_type_name (sh_type
)
1502 unsigned int sh_type
;
1506 case SHT_PARISC_EXT
: return "PARISC_EXT";
1507 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1508 case SHT_PARISC_DOC
: return "PARISC_DOC";
1516 get_section_type_name (sh_type
)
1517 unsigned int sh_type
;
1519 static char buff
[32];
1523 case SHT_NULL
: return "NULL";
1524 case SHT_PROGBITS
: return "PROGBITS";
1525 case SHT_SYMTAB
: return "SYMTAB";
1526 case SHT_STRTAB
: return "STRTAB";
1527 case SHT_RELA
: return "RELA";
1528 case SHT_HASH
: return "HASH";
1529 case SHT_DYNAMIC
: return "DYNAMIC";
1530 case SHT_NOTE
: return "NOTE";
1531 case SHT_NOBITS
: return "NOBITS";
1532 case SHT_REL
: return "REL";
1533 case SHT_SHLIB
: return "SHLIB";
1534 case SHT_DYNSYM
: return "DYNSYM";
1535 case SHT_GNU_verdef
: return "VERDEF";
1536 case SHT_GNU_verneed
: return "VERNEED";
1537 case SHT_GNU_versym
: return "VERSYM";
1538 case 0x6ffffff0: return "VERSYM";
1539 case 0x6ffffffc: return "VERDEF";
1540 case 0x7ffffffd: return "AUXILIARY";
1541 case 0x7fffffff: return "FILTER";
1544 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1546 const char * result
;
1548 switch (elf_header
.e_machine
)
1551 case EM_MIPS_RS4_BE
:
1552 result
= get_mips_section_type_name (sh_type
);
1555 result
= get_parisc_section_type_name (sh_type
);
1565 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1567 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1568 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1569 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1570 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1572 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1578 struct option options
[] =
1580 {"all", no_argument
, 0, 'a'},
1581 {"file-header", no_argument
, 0, 'h'},
1582 {"program-headers", no_argument
, 0, 'l'},
1583 {"headers", no_argument
, 0, 'e'},
1584 {"histogram", no_argument
, 0, 'I'},
1585 {"segments", no_argument
, 0, 'l'},
1586 {"sections", no_argument
, 0, 'S'},
1587 {"section-headers", no_argument
, 0, 'S'},
1588 {"symbols", no_argument
, 0, 's'},
1589 {"syms", no_argument
, 0, 's'},
1590 {"relocs", no_argument
, 0, 'r'},
1591 {"notes", no_argument
, 0, 'n'},
1592 {"dynamic", no_argument
, 0, 'd'},
1593 {"arch-specific", no_argument
, 0, 'A'},
1594 {"version-info", no_argument
, 0, 'V'},
1595 {"use-dynamic", no_argument
, 0, 'D'},
1596 {"hex-dump", required_argument
, 0, 'x'},
1597 {"debug-dump", optional_argument
, 0, 'w'},
1598 #ifdef SUPPORT_DISASSEMBLY
1599 {"instruction-dump", required_argument
, 0, 'i'},
1602 {"version", no_argument
, 0, 'v'},
1603 {"help", no_argument
, 0, 'H'},
1604 {0, no_argument
, 0, 0}
1610 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1611 fprintf (stdout
, _(" Options are:\n"));
1612 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1613 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1614 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1615 fprintf (stdout
, _(" Display the program headers\n"));
1616 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1617 fprintf (stdout
, _(" Display the sections' header\n"));
1618 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1619 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1620 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1621 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1622 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1623 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1624 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1625 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1626 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1627 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1628 fprintf (stdout
, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1629 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1630 #ifdef SUPPORT_DISASSEMBLY
1631 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1632 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1634 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1635 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1636 fprintf (stdout
, _(" -H or --help Display this information\n"));
1637 fprintf (stdout
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1643 request_dump (section
, type
)
1644 unsigned int section
;
1647 if (section
>= num_dump_sects
)
1649 char * new_dump_sects
;
1651 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1653 if (new_dump_sects
== NULL
)
1654 error (_("Out of memory allocating dump request table."));
1657 /* Copy current flag settings. */
1658 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1662 dump_sects
= new_dump_sects
;
1663 num_dump_sects
= section
+ 1;
1668 dump_sects
[section
] |= type
;
1674 parse_args (argc
, argv
)
1683 while ((c
= getopt_long
1684 (argc
, argv
, "ersahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
1719 do_using_dynamic
++;
1747 section
= strtoul (optarg
, & cp
, 0);
1748 if (! * cp
&& section
>= 0)
1750 request_dump (section
, HEX_DUMP
);
1770 do_debug_abbrevs
= 1;
1780 do_debug_pubnames
= 1;
1785 do_debug_aranges
= 1;
1789 warn (_("Unrecognised debug option '%s'\n"), optarg
);
1794 #ifdef SUPPORT_DISASSEMBLY
1797 section
= strtoul (optarg
, & cp
, 0);
1798 if (! * cp
&& section
>= 0)
1800 request_dump (section
, DISASS_DUMP
);
1806 print_version (program_name
);
1813 /* xgettext:c-format */
1814 error (_("Invalid option '-%c'\n"), c
);
1821 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
1822 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
1823 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
1827 warn (_("Nothing to do.\n"));
1833 get_elf_class (elf_class
)
1834 unsigned char elf_class
;
1836 static char buff
[32];
1840 case ELFCLASSNONE
: return _("none");
1841 case ELFCLASS32
: return _("ELF32");
1842 case ELFCLASS64
: return _("ELF64");
1844 sprintf (buff
, _("<unknown: %x>"), elf_class
);
1850 get_data_encoding (encoding
)
1851 unsigned char encoding
;
1853 static char buff
[32];
1857 case ELFDATANONE
: return _("none");
1858 case ELFDATA2LSB
: return _("2's complement, little endian");
1859 case ELFDATA2MSB
: return _("2's complement, big endian");
1861 sprintf (buff
, _("<unknown: %x>"), encoding
);
1867 get_osabi_name (osabi
)
1868 unsigned char osabi
;
1870 static char buff
[32];
1874 case ELFOSABI_SYSV
: return _("UNIX - System V");
1875 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
1876 case ELFOSABI_STANDALONE
: return _("Standalone App");
1878 sprintf (buff
, _("<unknown: %x>"), osabi
);
1883 /* Decode the data held in 'elf_header'. */
1885 process_file_header ()
1887 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
1888 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
1889 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
1890 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1893 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1901 printf (_("ELF Header:\n"));
1902 printf (_(" Magic: "));
1903 for (i
= 0; i
< EI_NIDENT
; i
++)
1904 printf ("%2.2x ", elf_header
.e_ident
[i
]);
1906 printf (_(" Class: %s\n"),
1907 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
1908 printf (_(" Data: %s\n"),
1909 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
1910 printf (_(" Version: %d %s\n"),
1911 elf_header
.e_ident
[EI_VERSION
],
1912 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
1914 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
1917 printf (_(" OS/ABI: %s\n"),
1918 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
1919 printf (_(" ABI Version: %d\n"),
1920 elf_header
.e_ident
[EI_ABIVERSION
]);
1921 printf (_(" Type: %s\n"),
1922 get_file_type (elf_header
.e_type
));
1923 printf (_(" Machine: %s\n"),
1924 get_machine_name (elf_header
.e_machine
));
1925 printf (_(" Version: 0x%lx\n"),
1926 (unsigned long) elf_header
.e_version
);
1928 printf (_(" Entry point address: "));
1929 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
1930 printf (_("\n Start of program headers: "));
1931 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
1932 printf (_(" (bytes into file)\n Start of section headers: "));
1933 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
1934 printf (_(" (bytes into file)\n"));
1936 printf (_(" Flags: 0x%lx%s\n"),
1937 (unsigned long) elf_header
.e_flags
,
1938 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
1939 printf (_(" Size of this header: %ld (bytes)\n"),
1940 (long) elf_header
.e_ehsize
);
1941 printf (_(" Size of program headers: %ld (bytes)\n"),
1942 (long) elf_header
.e_phentsize
);
1943 printf (_(" Number of program headers: %ld\n"),
1944 (long) elf_header
.e_phnum
);
1945 printf (_(" Size of section headers: %ld (bytes)\n"),
1946 (long) elf_header
.e_shentsize
);
1947 printf (_(" Number of section headers: %ld\n"),
1948 (long) elf_header
.e_shnum
);
1949 printf (_(" Section header string table index: %ld\n"),
1950 (long) elf_header
.e_shstrndx
);
1958 get_32bit_program_headers (file
, program_headers
)
1960 Elf_Internal_Phdr
* program_headers
;
1962 Elf32_External_Phdr
* phdrs
;
1963 Elf32_External_Phdr
* external
;
1964 Elf32_Internal_Phdr
* internal
;
1967 GET_DATA_ALLOC (elf_header
.e_phoff
,
1968 elf_header
.e_phentsize
* elf_header
.e_phnum
,
1969 phdrs
, Elf32_External_Phdr
*, "program headers");
1971 for (i
= 0, internal
= program_headers
, external
= phdrs
;
1972 i
< elf_header
.e_phnum
;
1973 i
++, internal
++, external
++)
1975 internal
->p_type
= BYTE_GET (external
->p_type
);
1976 internal
->p_offset
= BYTE_GET (external
->p_offset
);
1977 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
1978 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
1979 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
1980 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
1981 internal
->p_flags
= BYTE_GET (external
->p_flags
);
1982 internal
->p_align
= BYTE_GET (external
->p_align
);
1991 get_64bit_program_headers (file
, program_headers
)
1993 Elf_Internal_Phdr
* program_headers
;
1995 Elf64_External_Phdr
* phdrs
;
1996 Elf64_External_Phdr
* external
;
1997 Elf64_Internal_Phdr
* internal
;
2000 GET_DATA_ALLOC (elf_header
.e_phoff
,
2001 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2002 phdrs
, Elf64_External_Phdr
*, "program headers");
2004 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2005 i
< elf_header
.e_phnum
;
2006 i
++, internal
++, external
++)
2008 internal
->p_type
= BYTE_GET (external
->p_type
);
2009 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2010 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2011 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2012 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2013 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2014 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2015 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2024 process_program_headers (file
)
2027 Elf_Internal_Phdr
* program_headers
;
2028 Elf_Internal_Phdr
* segment
;
2031 if (elf_header
.e_phnum
== 0)
2034 printf (_("\nThere are no program headers in this file.\n"));
2038 if (do_segments
&& !do_header
)
2040 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2041 printf (_("Entry point "));
2042 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2043 printf (_("\nThere are %d program headers, starting at offset "),
2044 elf_header
.e_phnum
);
2045 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2049 program_headers
= (Elf_Internal_Phdr
*) malloc
2050 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2052 if (program_headers
== NULL
)
2054 error (_("Out of memory\n"));
2059 i
= get_32bit_program_headers (file
, program_headers
);
2061 i
= get_64bit_program_headers (file
, program_headers
);
2065 free (program_headers
);
2072 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2076 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2080 (_(" Type Offset VirtAddr PhysAddr\n"));
2082 (_(" FileSiz MemSiz Flags Align\n"));
2090 for (i
= 0, segment
= program_headers
;
2091 i
< elf_header
.e_phnum
;
2096 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2100 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2101 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2102 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2103 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2104 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2106 (segment
->p_flags
& PF_R
? 'R' : ' '),
2107 (segment
->p_flags
& PF_W
? 'W' : ' '),
2108 (segment
->p_flags
& PF_X
? 'E' : ' '));
2109 printf ("%#lx", (unsigned long) segment
->p_align
);
2113 print_vma (segment
->p_offset
, FULL_HEX
);
2115 print_vma (segment
->p_vaddr
, FULL_HEX
);
2117 print_vma (segment
->p_paddr
, FULL_HEX
);
2119 print_vma (segment
->p_filesz
, FULL_HEX
);
2121 print_vma (segment
->p_memsz
, FULL_HEX
);
2123 (segment
->p_flags
& PF_R
? 'R' : ' '),
2124 (segment
->p_flags
& PF_W
? 'W' : ' '),
2125 (segment
->p_flags
& PF_X
? 'E' : ' '));
2126 print_vma (segment
->p_align
, HEX
);
2130 switch (segment
->p_type
)
2134 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2135 - (segment
->p_offset
& 0xfffff000);
2140 error (_("more than one dynamic segment\n"));
2142 dynamic_addr
= segment
->p_offset
;
2143 dynamic_size
= segment
->p_filesz
;
2147 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2148 error (_("Unable to find program interpreter name\n"));
2151 program_interpreter
[0] = 0;
2152 fscanf (file
, "%63s", program_interpreter
);
2155 printf (_("\n [Requesting program interpreter: %s]"),
2156 program_interpreter
);
2162 putc ('\n', stdout
);
2171 if (do_segments
&& section_headers
!= NULL
)
2173 printf (_("\n Section to Segment mapping:\n"));
2174 printf (_(" Segment Sections...\n"));
2176 assert (string_table
!= NULL
);
2178 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2181 Elf_Internal_Shdr
* section
;
2183 segment
= program_headers
+ i
;
2184 section
= section_headers
;
2186 printf (" %2.2d ", i
);
2188 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2190 if (section
->sh_size
> 0
2191 /* Compare allocated sections by VMA, unallocated
2192 sections by file offset. */
2193 && (section
->sh_flags
& SHF_ALLOC
2194 ? (section
->sh_addr
>= segment
->p_vaddr
2195 && section
->sh_addr
+ section
->sh_size
2196 <= segment
->p_vaddr
+ segment
->p_memsz
)
2197 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2198 && (section
->sh_offset
+ section
->sh_size
2199 <= segment
->p_offset
+ segment
->p_filesz
))))
2200 printf ("%s ", SECTION_NAME (section
));
2207 free (program_headers
);
2214 get_32bit_section_headers (file
)
2217 Elf32_External_Shdr
* shdrs
;
2218 Elf32_Internal_Shdr
* internal
;
2221 GET_DATA_ALLOC (elf_header
.e_shoff
,
2222 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2223 shdrs
, Elf32_External_Shdr
*, "section headers");
2225 section_headers
= (Elf_Internal_Shdr
*) malloc
2226 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2228 if (section_headers
== NULL
)
2230 error (_("Out of memory\n"));
2234 for (i
= 0, internal
= section_headers
;
2235 i
< elf_header
.e_shnum
;
2238 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2239 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2240 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2241 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2242 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2243 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2244 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2245 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2246 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2247 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2256 get_64bit_section_headers (file
)
2259 Elf64_External_Shdr
* shdrs
;
2260 Elf64_Internal_Shdr
* internal
;
2263 GET_DATA_ALLOC (elf_header
.e_shoff
,
2264 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2265 shdrs
, Elf64_External_Shdr
*, "section headers");
2267 section_headers
= (Elf_Internal_Shdr
*) malloc
2268 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2270 if (section_headers
== NULL
)
2272 error (_("Out of memory\n"));
2276 for (i
= 0, internal
= section_headers
;
2277 i
< elf_header
.e_shnum
;
2280 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2281 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2282 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2283 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2284 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2285 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2286 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2287 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2288 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2289 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2297 static Elf_Internal_Sym
*
2298 get_32bit_elf_symbols (file
, offset
, number
)
2300 unsigned long offset
;
2301 unsigned long number
;
2303 Elf32_External_Sym
* esyms
;
2304 Elf_Internal_Sym
* isyms
;
2305 Elf_Internal_Sym
* psym
;
2308 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2309 esyms
, Elf32_External_Sym
*, "symbols");
2311 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2315 error (_("Out of memory\n"));
2321 for (j
= 0, psym
= isyms
;
2325 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2326 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2327 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2328 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2329 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2330 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2338 static Elf_Internal_Sym
*
2339 get_64bit_elf_symbols (file
, offset
, number
)
2341 unsigned long offset
;
2342 unsigned long number
;
2344 Elf64_External_Sym
* esyms
;
2345 Elf_Internal_Sym
* isyms
;
2346 Elf_Internal_Sym
* psym
;
2349 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2350 esyms
, Elf64_External_Sym
*, "symbols");
2352 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2356 error (_("Out of memory\n"));
2362 for (j
= 0, psym
= isyms
;
2366 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2367 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2368 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2369 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2370 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2371 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2380 process_section_headers (file
)
2383 Elf_Internal_Shdr
* section
;
2386 section_headers
= NULL
;
2388 if (elf_header
.e_shnum
== 0)
2391 printf (_("\nThere are no sections in this file.\n"));
2396 if (do_sections
&& !do_header
)
2397 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2398 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2402 if (! get_32bit_section_headers (file
))
2405 else if (! get_64bit_section_headers (file
))
2408 /* Read in the string table, so that we have names to display. */
2409 section
= section_headers
+ elf_header
.e_shstrndx
;
2411 if (section
->sh_size
!= 0)
2413 unsigned long string_table_offset
;
2415 string_table_offset
= section
->sh_offset
;
2417 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2418 string_table
, char *, "string table");
2421 /* Scan the sections for the dynamic symbol table
2422 and dynamic string table and debug sections. */
2423 dynamic_symbols
= NULL
;
2424 dynamic_strings
= NULL
;
2425 dynamic_syminfo
= NULL
;
2427 for (i
= 0, section
= section_headers
;
2428 i
< elf_header
.e_shnum
;
2431 char * name
= SECTION_NAME (section
);
2433 if (section
->sh_type
== SHT_DYNSYM
)
2435 if (dynamic_symbols
!= NULL
)
2437 error (_("File contains multiple dynamic symbol tables\n"));
2441 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2443 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2445 else if (section
->sh_type
== SHT_STRTAB
2446 && strcmp (name
, ".dynstr") == 0)
2448 if (dynamic_strings
!= NULL
)
2450 error (_("File contains multiple dynamic string tables\n"));
2454 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2455 dynamic_strings
, char *, "dynamic strings");
2457 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2458 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
)
2459 && strncmp (name
, ".debug_", 7) == 0)
2464 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2465 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2466 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2467 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2468 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2470 request_dump (i
, DEBUG_DUMP
);
2477 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2480 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2483 printf (_(" [Nr] Name Type Address Offset\n"));
2484 printf (_(" Size EntSize Flags Link Info Align\n"));
2487 for (i
= 0, section
= section_headers
;
2488 i
< elf_header
.e_shnum
;
2491 printf (" [%2d] %-17.17s %-15.15s ",
2493 SECTION_NAME (section
),
2494 get_section_type_name (section
->sh_type
));
2498 print_vma (section
->sh_addr
, LONG_HEX
);
2500 printf ( " %6.6lx %6.6lx %2.2lx",
2501 (unsigned long) section
->sh_offset
,
2502 (unsigned long) section
->sh_size
,
2503 (unsigned long) section
->sh_entsize
);
2505 printf (" %c%c%c %2ld %3lx %ld\n",
2506 (section
->sh_flags
& SHF_WRITE
? 'W' : ' '),
2507 (section
->sh_flags
& SHF_ALLOC
? 'A' : ' '),
2508 (section
->sh_flags
& SHF_EXECINSTR
? 'X' : ' '),
2509 (unsigned long) section
->sh_link
,
2510 (unsigned long) section
->sh_info
,
2511 (unsigned long) section
->sh_addralign
);
2516 print_vma (section
->sh_addr
, LONG_HEX
);
2517 printf (" %8.8lx", section
->sh_offset
);
2519 print_vma (section
->sh_size
, LONG_HEX
);
2521 print_vma (section
->sh_entsize
, LONG_HEX
);
2524 (section
->sh_flags
& SHF_WRITE
? 'W' : ' '),
2525 (section
->sh_flags
& SHF_ALLOC
? 'A' : ' '),
2526 (section
->sh_flags
& SHF_EXECINSTR
? 'X' : ' '));
2528 printf (" %2ld %3lx %ld\n",
2529 (unsigned long) section
->sh_link
,
2530 (unsigned long) section
->sh_info
,
2531 (unsigned long) section
->sh_addralign
);
2538 /* Process the reloc section. */
2540 process_relocs (file
)
2543 unsigned long rel_size
;
2544 unsigned long rel_offset
;
2550 if (do_using_dynamic
)
2552 int is_rela
= FALSE
;
2557 if (dynamic_info
[DT_REL
])
2559 rel_offset
= dynamic_info
[DT_REL
];
2560 rel_size
= dynamic_info
[DT_RELSZ
];
2563 else if (dynamic_info
[DT_RELA
])
2565 rel_offset
= dynamic_info
[DT_RELA
];
2566 rel_size
= dynamic_info
[DT_RELASZ
];
2569 else if (dynamic_info
[DT_JMPREL
])
2571 rel_offset
= dynamic_info
[DT_JMPREL
];
2572 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2574 switch (dynamic_info
[DT_PLTREL
])
2591 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2592 rel_offset
, rel_size
);
2594 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2595 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
2598 printf (_("\nThere are no dynamic relocations in this file.\n"));
2602 Elf32_Internal_Shdr
* section
;
2606 for (i
= 0, section
= section_headers
;
2607 i
< elf_header
.e_shnum
;
2610 if ( section
->sh_type
!= SHT_RELA
2611 && section
->sh_type
!= SHT_REL
)
2614 rel_offset
= section
->sh_offset
;
2615 rel_size
= section
->sh_size
;
2619 Elf32_Internal_Shdr
* strsec
;
2620 Elf32_Internal_Shdr
* symsec
;
2621 Elf_Internal_Sym
* symtab
;
2624 unsigned long nsyms
;
2626 printf (_("\nRelocation section "));
2628 if (string_table
== NULL
)
2629 printf ("%d", section
->sh_name
);
2631 printf ("'%s'", SECTION_NAME (section
));
2633 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2634 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
2636 symsec
= section_headers
+ section
->sh_link
;
2638 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
2639 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
2644 strsec
= section_headers
+ symsec
->sh_link
;
2646 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2647 char *, "string table");
2649 is_rela
= section
->sh_type
== SHT_RELA
;
2651 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
2661 printf (_("\nThere are no relocations in this file.\n"));
2669 dynamic_segment_mips_val (entry
)
2670 Elf_Internal_Dyn
* entry
;
2672 switch (entry
->d_tag
)
2675 if (entry
->d_un
.d_val
== 0)
2679 static const char * opts
[] =
2681 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2682 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2683 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2684 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2689 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
2690 if (entry
->d_un
.d_val
& (1 << cnt
))
2692 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2699 case DT_MIPS_IVERSION
:
2700 if (dynamic_strings
!= NULL
)
2701 printf ("Interface Version: %s\n",
2702 dynamic_strings
+ entry
->d_un
.d_val
);
2704 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2707 case DT_MIPS_TIME_STAMP
:
2710 time_t time
= entry
->d_un
.d_val
;
2711 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
2712 printf ("Time Stamp: %s\n", timebuf
);
2716 case DT_MIPS_RLD_VERSION
:
2717 case DT_MIPS_LOCAL_GOTNO
:
2718 case DT_MIPS_CONFLICTNO
:
2719 case DT_MIPS_LIBLISTNO
:
2720 case DT_MIPS_SYMTABNO
:
2721 case DT_MIPS_UNREFEXTNO
:
2722 case DT_MIPS_HIPAGENO
:
2723 case DT_MIPS_DELTA_CLASS_NO
:
2724 case DT_MIPS_DELTA_INSTANCE_NO
:
2725 case DT_MIPS_DELTA_RELOC_NO
:
2726 case DT_MIPS_DELTA_SYM_NO
:
2727 case DT_MIPS_DELTA_CLASSSYM_NO
:
2728 case DT_MIPS_COMPACT_SIZE
:
2729 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2733 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2739 dynamic_segment_parisc_val (entry
)
2740 Elf_Internal_Dyn
* entry
;
2742 switch (entry
->d_tag
)
2744 case DT_HP_DLD_FLAGS
:
2753 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
2754 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
2755 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
2756 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
2757 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
2758 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
2759 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
2760 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
2761 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
2762 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
2763 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
2767 bfd_vma val
= entry
->d_un
.d_val
;
2769 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
2770 if (val
& flags
[cnt
].bit
)
2774 fputs (flags
[cnt
].str
, stdout
);
2776 val
^= flags
[cnt
].bit
;
2779 if (val
!= 0 || first
)
2783 print_vma (val
, HEX
);
2789 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
2795 get_32bit_dynamic_segment (file
)
2798 Elf32_External_Dyn
* edyn
;
2799 Elf_Internal_Dyn
* entry
;
2802 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
2803 edyn
, Elf32_External_Dyn
*, "dynamic segment");
2805 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2806 how large this .dynamic is now. We can do this even before the byte
2807 swapping since the DT_NULL tag is recognizable. */
2809 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
2812 dynamic_segment
= (Elf_Internal_Dyn
*)
2813 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
2815 if (dynamic_segment
== NULL
)
2817 error (_("Out of memory\n"));
2822 for (i
= 0, entry
= dynamic_segment
;
2826 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
2827 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
2836 get_64bit_dynamic_segment (file
)
2839 Elf64_External_Dyn
* edyn
;
2840 Elf_Internal_Dyn
* entry
;
2843 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
2844 edyn
, Elf64_External_Dyn
*, "dynamic segment");
2846 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2847 how large this .dynamic is now. We can do this even before the byte
2848 swapping since the DT_NULL tag is recognizable. */
2850 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
2853 dynamic_segment
= (Elf_Internal_Dyn
*)
2854 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
2856 if (dynamic_segment
== NULL
)
2858 error (_("Out of memory\n"));
2863 for (i
= 0, entry
= dynamic_segment
;
2867 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
2868 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
2876 /* Parse and display the contents of the dynamic segment. */
2878 process_dynamic_segment (file
)
2881 Elf_Internal_Dyn
* entry
;
2884 if (dynamic_size
== 0)
2887 printf (_("\nThere is no dynamic segment in this file.\n"));
2894 if (! get_32bit_dynamic_segment (file
))
2897 else if (! get_64bit_dynamic_segment (file
))
2900 /* Find the appropriate symbol table. */
2901 if (dynamic_symbols
== NULL
)
2903 for (i
= 0, entry
= dynamic_segment
;
2907 unsigned long offset
;
2909 if (entry
->d_tag
!= DT_SYMTAB
)
2912 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
2914 /* Since we do not know how big the symbol table is,
2915 we default to reading in the entire file (!) and
2916 processing that. This is overkill, I know, but it
2918 offset
= entry
->d_un
.d_val
- loadaddr
;
2920 if (fseek (file
, 0, SEEK_END
))
2921 error (_("Unable to seek to end of file!"));
2924 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
2926 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
2928 if (num_dynamic_syms
< 1)
2930 error (_("Unable to determine the number of symbols to load\n"));
2934 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
2938 /* Similarly find a string table. */
2939 if (dynamic_strings
== NULL
)
2941 for (i
= 0, entry
= dynamic_segment
;
2945 unsigned long offset
;
2948 if (entry
->d_tag
!= DT_STRTAB
)
2951 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
2953 /* Since we do not know how big the string table is,
2954 we default to reading in the entire file (!) and
2955 processing that. This is overkill, I know, but it
2958 offset
= entry
->d_un
.d_val
- loadaddr
;
2959 if (fseek (file
, 0, SEEK_END
))
2960 error (_("Unable to seek to end of file\n"));
2961 str_tab_len
= ftell (file
) - offset
;
2963 if (str_tab_len
< 1)
2966 (_("Unable to determine the length of the dynamic string table\n"));
2970 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
2971 "dynamic string table");
2977 /* And find the syminfo section if available. */
2978 if (dynamic_syminfo
== NULL
)
2980 unsigned int syminsz
= 0;
2982 for (i
= 0, entry
= dynamic_segment
;
2986 if (entry
->d_tag
== DT_SYMINENT
)
2988 /* Note: these braces are necessary to avoid a syntax
2989 error from the SunOS4 C compiler. */
2990 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
2992 else if (entry
->d_tag
== DT_SYMINSZ
)
2993 syminsz
= entry
->d_un
.d_val
;
2994 else if (entry
->d_tag
== DT_SYMINFO
)
2995 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
2998 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3000 Elf_External_Syminfo
* extsyminfo
;
3001 Elf_Internal_Syminfo
* syminfo
;
3003 /* There is a syminfo section. Read the data. */
3004 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3005 Elf_External_Syminfo
*, "symbol information");
3007 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3008 if (dynamic_syminfo
== NULL
)
3010 error (_("Out of memory\n"));
3014 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3015 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3018 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3019 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3026 if (do_dynamic
&& dynamic_addr
)
3027 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3028 dynamic_addr
, (long) dynamic_size
);
3030 printf (_(" Tag Type Name/Value\n"));
3032 for (i
= 0, entry
= dynamic_segment
;
3039 print_vma (entry
->d_tag
, FULL_HEX
);
3041 get_dynamic_type (entry
->d_tag
),
3042 (is_32bit_elf
? 27 : 19) - strlen (get_dynamic_type (entry
->d_tag
)),
3046 switch (entry
->d_tag
)
3052 if (entry
->d_tag
== DT_AUXILIARY
)
3053 printf (_("Auxiliary library"));
3055 printf (_("Filter library"));
3057 if (dynamic_strings
)
3058 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3062 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3071 printf (_("Flags:"));
3072 if (entry
->d_un
.d_val
== 0)
3073 printf (_(" None\n"));
3076 unsigned long int val
= entry
->d_un
.d_val
;
3077 if (val
& DTF_1_PARINIT
)
3079 printf (" PARINIT");
3080 val
^= DTF_1_PARINIT
;
3083 printf (" %lx", val
);
3092 printf (_("Flags:"));
3093 if (entry
->d_un
.d_val
== 0)
3094 printf (_(" None\n"));
3097 unsigned long int val
= entry
->d_un
.d_val
;
3098 if (val
& DF_P1_LAZYLOAD
)
3100 printf (" LAZYLOAD");
3101 val
^= DF_P1_LAZYLOAD
;
3103 if (val
& DF_P1_GROUPPERM
)
3105 printf (" GROUPPERM");
3106 val
^= DF_P1_GROUPPERM
;
3109 printf (" %lx", val
);
3118 printf (_("Flags:"));
3119 if (entry
->d_un
.d_val
== 0)
3120 printf (_(" None\n"));
3123 unsigned long int val
= entry
->d_un
.d_val
;
3129 if (val
& DF_1_GLOBAL
)
3134 if (val
& DF_1_GROUP
)
3139 if (val
& DF_1_NODELETE
)
3141 printf (" NODELETE");
3142 val
^= DF_1_NODELETE
;
3144 if (val
& DF_1_LOADFLTR
)
3146 printf (" LOADFLTR");
3147 val
^= DF_1_LOADFLTR
;
3149 if (val
& DF_1_INITFIRST
)
3151 printf (" INITFIRST");
3152 val
^= DF_1_INITFIRST
;
3154 if (val
& DF_1_NOOPEN
)
3159 if (val
& DF_1_ORIGIN
)
3164 if (val
& DF_1_DIRECT
)
3169 if (val
& DF_1_TRANS
)
3174 if (val
& DF_1_INTERPOSE
)
3176 printf (" INTERPOSE");
3177 val
^= DF_1_INTERPOSE
;
3180 printf (" %lx", val
);
3188 puts (get_dynamic_type (entry
->d_un
.d_val
));
3207 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
3213 if (dynamic_strings
== NULL
)
3216 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3220 switch (entry
->d_tag
)
3223 printf (_("Shared library: [%s]"), name
);
3225 if (strcmp (name
, program_interpreter
) == 0)
3226 printf (_(" program interpreter"));
3230 printf (_("Library soname: [%s]"), name
);
3234 printf (_("Library rpath: [%s]"), name
);
3238 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3243 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3259 case DT_INIT_ARRAYSZ
:
3260 case DT_FINI_ARRAYSZ
:
3263 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3264 printf (" (bytes)\n");
3274 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3287 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
3291 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3295 printf (_("Not needed object: [%s]\n"), name
);
3300 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3306 /* The value of this entry is ignored. */
3310 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
3311 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
3316 switch (elf_header
.e_machine
)
3319 case EM_MIPS_RS4_BE
:
3320 dynamic_segment_mips_val (entry
);
3323 dynamic_segment_parisc_val (entry
);
3326 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3338 get_ver_flags (flags
)
3341 static char buff
[32];
3348 if (flags
& VER_FLG_BASE
)
3349 strcat (buff
, "BASE ");
3351 if (flags
& VER_FLG_WEAK
)
3353 if (flags
& VER_FLG_BASE
)
3354 strcat (buff
, "| ");
3356 strcat (buff
, "WEAK ");
3359 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
3360 strcat (buff
, "| <unknown>");
3365 /* Display the contents of the version sections. */
3367 process_version_sections (file
)
3370 Elf32_Internal_Shdr
* section
;
3377 for (i
= 0, section
= section_headers
;
3378 i
< elf_header
.e_shnum
;
3381 switch (section
->sh_type
)
3383 case SHT_GNU_verdef
:
3385 Elf_External_Verdef
* edefs
;
3392 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3393 SECTION_NAME (section
), section
->sh_info
);
3395 printf (_(" Addr: 0x"));
3396 printf_vma (section
->sh_addr
);
3397 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3398 (unsigned long) section
->sh_offset
, section
->sh_link
,
3399 SECTION_NAME (section_headers
+ section
->sh_link
));
3401 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3402 edefs
, Elf_External_Verdef
*,
3403 "version definition section");
3405 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
3408 Elf_External_Verdef
* edef
;
3409 Elf_Internal_Verdef ent
;
3410 Elf_External_Verdaux
* eaux
;
3411 Elf_Internal_Verdaux aux
;
3415 vstart
= ((char *) edefs
) + idx
;
3417 edef
= (Elf_External_Verdef
*) vstart
;
3419 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
3420 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
3421 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
3422 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
3423 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
3424 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
3425 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
3427 printf (_(" %#06x: Rev: %d Flags: %s"),
3428 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
3430 printf (_(" Index: %d Cnt: %d "),
3431 ent
.vd_ndx
, ent
.vd_cnt
);
3433 vstart
+= ent
.vd_aux
;
3435 eaux
= (Elf_External_Verdaux
*) vstart
;
3437 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3438 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3440 if (dynamic_strings
)
3441 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
3443 printf (_("Name index: %ld\n"), aux
.vda_name
);
3445 isum
= idx
+ ent
.vd_aux
;
3447 for (j
= 1; j
< ent
.vd_cnt
; j
++)
3449 isum
+= aux
.vda_next
;
3450 vstart
+= aux
.vda_next
;
3452 eaux
= (Elf_External_Verdaux
*) vstart
;
3454 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3455 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3457 if (dynamic_strings
)
3458 printf (_(" %#06x: Parent %d: %s\n"),
3459 isum
, j
, dynamic_strings
+ aux
.vda_name
);
3461 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3462 isum
, j
, aux
.vda_name
);
3472 case SHT_GNU_verneed
:
3474 Elf_External_Verneed
* eneed
;
3480 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3481 SECTION_NAME (section
), section
->sh_info
);
3483 printf (_(" Addr: 0x"));
3484 printf_vma (section
->sh_addr
);
3485 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3486 (unsigned long) section
->sh_offset
, section
->sh_link
,
3487 SECTION_NAME (section_headers
+ section
->sh_link
));
3489 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3490 eneed
, Elf_External_Verneed
*,
3491 "version need section");
3493 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
3495 Elf_External_Verneed
* entry
;
3496 Elf_Internal_Verneed ent
;
3501 vstart
= ((char *) eneed
) + idx
;
3503 entry
= (Elf_External_Verneed
*) vstart
;
3505 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
3506 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
3507 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
3508 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
3509 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
3511 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
3513 if (dynamic_strings
)
3514 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
3516 printf (_(" File: %lx"), ent
.vn_file
);
3518 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
3520 vstart
+= ent
.vn_aux
;
3522 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
3524 Elf_External_Vernaux
* eaux
;
3525 Elf_Internal_Vernaux aux
;
3527 eaux
= (Elf_External_Vernaux
*) vstart
;
3529 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
3530 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
3531 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
3532 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
3533 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
3535 if (dynamic_strings
)
3536 printf (_(" %#06x: Name: %s"),
3537 isum
, dynamic_strings
+ aux
.vna_name
);
3539 printf (_(" %#06x: Name index: %lx"),
3540 isum
, aux
.vna_name
);
3542 printf (_(" Flags: %s Version: %d\n"),
3543 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
3545 isum
+= aux
.vna_next
;
3546 vstart
+= aux
.vna_next
;
3556 case SHT_GNU_versym
:
3558 Elf32_Internal_Shdr
* link_section
;
3561 unsigned char * edata
;
3562 unsigned short * data
;
3564 Elf_Internal_Sym
* symbols
;
3565 Elf32_Internal_Shdr
* string_sec
;
3567 link_section
= section_headers
+ section
->sh_link
;
3568 total
= section
->sh_size
/ section
->sh_entsize
;
3572 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
3573 link_section
->sh_size
/ link_section
->sh_entsize
);
3575 string_sec
= section_headers
+ link_section
->sh_link
;
3577 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3578 strtab
, char *, "version string table");
3580 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3581 SECTION_NAME (section
), total
);
3583 printf (_(" Addr: "));
3584 printf_vma (section
->sh_addr
);
3585 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3586 (unsigned long) section
->sh_offset
, section
->sh_link
,
3587 SECTION_NAME (link_section
));
3589 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3591 total
* sizeof (short), edata
,
3592 unsigned char *, "version symbol data");
3594 data
= (unsigned short *) malloc (total
* sizeof (short));
3596 for (cnt
= total
; cnt
--;)
3597 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
3602 for (cnt
= 0; cnt
< total
; cnt
+= 4)
3606 printf (" %03x:", cnt
);
3608 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
3609 switch (data
[cnt
+ j
])
3612 fputs (_(" 0 (*local*) "), stdout
);
3616 fputs (_(" 1 (*global*) "), stdout
);
3620 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
3621 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
3623 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
3624 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
3627 /* We must test both. */
3628 Elf_Internal_Verneed ivn
;
3629 unsigned long offset
;
3631 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3636 Elf_External_Verneed evn
;
3637 Elf_External_Vernaux evna
;
3638 Elf_Internal_Vernaux ivna
;
3639 unsigned long vna_off
;
3641 GET_DATA (offset
, evn
, "version need");
3643 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3644 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3646 vna_off
= offset
+ ivn
.vn_aux
;
3650 GET_DATA (vna_off
, evna
,
3651 "version need aux (1)");
3653 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3654 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3656 vna_off
+= ivna
.vna_next
;
3658 while (ivna
.vna_other
!= data
[cnt
+ j
]
3659 && ivna
.vna_next
!= 0);
3661 if (ivna
.vna_other
== data
[cnt
+ j
])
3663 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3665 nn
+= printf ("(%s%-*s",
3666 strtab
+ ivna
.vna_name
,
3672 else if (ivn
.vn_next
== 0)
3674 if (data
[cnt
+ j
] != 0x8001)
3676 Elf_Internal_Verdef ivd
;
3677 Elf_External_Verdef evd
;
3679 offset
= version_info
3680 [DT_VERSIONTAGIDX (DT_VERDEF
)]
3685 GET_DATA (offset
, evd
,
3686 "version definition");
3688 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3689 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3691 offset
+= ivd
.vd_next
;
3694 != (data
[cnt
+ j
] & 0x7fff)
3695 && ivd
.vd_next
!= 0);
3698 == (data
[cnt
+ j
] & 0x7fff))
3700 Elf_External_Verdaux evda
;
3701 Elf_Internal_Verdaux ivda
;
3703 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3705 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
3706 "version definition aux");
3709 BYTE_GET (evda
.vda_name
);
3713 strtab
+ ivda
.vda_name
,
3724 offset
+= ivn
.vn_next
;
3726 while (ivn
.vn_next
);
3728 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
3730 Elf_Internal_Verneed ivn
;
3731 unsigned long offset
;
3733 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3738 Elf_Internal_Vernaux ivna
;
3739 Elf_External_Verneed evn
;
3740 Elf_External_Vernaux evna
;
3741 unsigned long a_off
;
3743 GET_DATA (offset
, evn
, "version need");
3745 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3746 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3748 a_off
= offset
+ ivn
.vn_aux
;
3752 GET_DATA (a_off
, evna
,
3753 "version need aux (2)");
3755 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3756 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3758 a_off
+= ivna
.vna_next
;
3760 while (ivna
.vna_other
!= data
[cnt
+ j
]
3761 && ivna
.vna_next
!= 0);
3763 if (ivna
.vna_other
== data
[cnt
+ j
])
3765 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3767 nn
+= printf ("(%s%-*s",
3768 strtab
+ ivna
.vna_name
,
3775 offset
+= ivn
.vn_next
;
3777 while (ivn
.vn_next
);
3779 else if (data
[cnt
+ j
] != 0x8001)
3781 Elf_Internal_Verdef ivd
;
3782 Elf_External_Verdef evd
;
3783 unsigned long offset
;
3785 offset
= version_info
3786 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
3790 GET_DATA (offset
, evd
, "version def");
3792 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3793 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3795 offset
+= ivd
.vd_next
;
3797 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
3798 && ivd
.vd_next
!= 0);
3800 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
3802 Elf_External_Verdaux evda
;
3803 Elf_Internal_Verdaux ivda
;
3805 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3807 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
3808 evda
, "version def aux");
3810 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
3812 nn
+= printf ("(%s%-*s",
3813 strtab
+ ivda
.vda_name
,
3821 printf ("%*c", 18 - nn
, ' ');
3839 printf (_("\nNo version information found in this file.\n"));
3845 get_symbol_binding (binding
)
3846 unsigned int binding
;
3848 static char buff
[32];
3852 case STB_LOCAL
: return "LOCAL";
3853 case STB_GLOBAL
: return "GLOBAL";
3854 case STB_WEAK
: return "WEAK";
3856 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
3857 sprintf (buff
, _("<processor specific>: %d"), binding
);
3858 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
3859 sprintf (buff
, _("<OS specific>: %d"), binding
);
3861 sprintf (buff
, _("<unknown>: %d"), binding
);
3867 get_symbol_type (type
)
3870 static char buff
[32];
3874 case STT_NOTYPE
: return "NOTYPE";
3875 case STT_OBJECT
: return "OBJECT";
3876 case STT_FUNC
: return "FUNC";
3877 case STT_SECTION
: return "SECTION";
3878 case STT_FILE
: return "FILE";
3880 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
3882 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
3883 return "THUMB_FUNC";
3885 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
3888 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
3889 return "PARISC_MILLI";
3891 sprintf (buff
, _("<processor specific>: %d"), type
);
3893 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
3895 if (elf_header
.e_machine
== EM_PARISC
)
3897 if (type
== STT_HP_OPAQUE
)
3899 if (type
== STT_HP_STUB
)
3903 sprintf (buff
, _("<OS specific>: %d"), type
);
3906 sprintf (buff
, _("<unknown>: %d"), type
);
3912 get_symbol_index_type (type
)
3917 case SHN_UNDEF
: return "UND";
3918 case SHN_ABS
: return "ABS";
3919 case SHN_COMMON
: return "COM";
3921 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
3923 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
3925 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
3929 static char buff
[32];
3931 sprintf (buff
, "%3d", type
);
3939 get_dynamic_data (file
, number
)
3941 unsigned int number
;
3946 e_data
= (char *) malloc (number
* 4);
3950 error (_("Out of memory\n"));
3954 if (fread (e_data
, 4, number
, file
) != number
)
3956 error (_("Unable to read in dynamic data\n"));
3960 i_data
= (int *) malloc (number
* sizeof (* i_data
));
3964 error (_("Out of memory\n"));
3970 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
3977 /* Dump the symbol table */
3979 process_symbol_table (file
)
3982 Elf32_Internal_Shdr
* section
;
3987 int * buckets
= NULL
;
3988 int * chains
= NULL
;
3990 if (! do_syms
&& !do_histogram
)
3993 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
3996 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
3998 error (_("Unable to seek to start of dynamic information"));
4002 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4004 error (_("Failed to read in number of buckets\n"));
4008 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4010 error (_("Failed to read in number of chains\n"));
4014 nbuckets
= byte_get (nb
, 4);
4015 nchains
= byte_get (nc
, 4);
4017 buckets
= get_dynamic_data (file
, nbuckets
);
4018 chains
= get_dynamic_data (file
, nchains
);
4020 if (buckets
== NULL
|| chains
== NULL
)
4025 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4030 printf (_("\nSymbol table for image:\n"));
4032 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
4034 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
4036 for (hn
= 0; hn
< nbuckets
; hn
++)
4041 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4043 Elf_Internal_Sym
* psym
;
4045 psym
= dynamic_symbols
+ si
;
4047 printf (" %3d %3d: ", si
, hn
);
4048 print_vma (psym
->st_value
, LONG_HEX
);
4050 print_vma (psym
->st_size
, DEC_5
);
4052 printf (" %6s %6s %2d ",
4053 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
4054 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
4057 printf ("%3.3s", get_symbol_index_type (psym
->st_shndx
));
4059 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4063 else if (do_syms
&& !do_using_dynamic
)
4067 for (i
= 0, section
= section_headers
;
4068 i
< elf_header
.e_shnum
;
4073 Elf_Internal_Sym
* symtab
;
4074 Elf_Internal_Sym
* psym
;
4077 if ( section
->sh_type
!= SHT_SYMTAB
4078 && section
->sh_type
!= SHT_DYNSYM
)
4081 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4082 SECTION_NAME (section
),
4083 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4085 printf (_(" Num: Value Size Type Bind Ot Ndx Name\n"));
4087 printf (_(" Num: Value Size Type Bind Ot Ndx Name\n"));
4089 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4090 section
->sh_size
/ section
->sh_entsize
);
4094 if (section
->sh_link
== elf_header
.e_shstrndx
)
4095 strtab
= string_table
;
4098 Elf32_Internal_Shdr
* string_sec
;
4100 string_sec
= section_headers
+ section
->sh_link
;
4102 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4103 strtab
, char *, "string table");
4106 for (si
= 0, psym
= symtab
;
4107 si
< section
->sh_size
/ section
->sh_entsize
;
4110 printf ("%6d: ", si
);
4111 print_vma (psym
->st_value
, LONG_HEX
);
4113 print_vma (psym
->st_size
, DEC_5
);
4114 printf (" %-7s %-6s %2d ",
4115 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
4116 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
4119 printf ("%4s", get_symbol_index_type (psym
->st_shndx
));
4121 printf (" %s", strtab
+ psym
->st_name
);
4123 if (section
->sh_type
== SHT_DYNSYM
&&
4124 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
4126 unsigned char data
[2];
4127 unsigned short vers_data
;
4128 unsigned long offset
;
4132 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4135 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
4138 vers_data
= byte_get (data
, 2);
4140 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
4141 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
4144 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
4146 if ((vers_data
& 0x8000) || vers_data
> 1)
4148 if (is_nobits
|| ! check_def
)
4150 Elf_External_Verneed evn
;
4151 Elf_Internal_Verneed ivn
;
4152 Elf_Internal_Vernaux ivna
;
4154 /* We must test both. */
4155 offset
= version_info
4156 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
4158 GET_DATA (offset
, evn
, "version need");
4160 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4161 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4165 unsigned long vna_off
;
4167 vna_off
= offset
+ ivn
.vn_aux
;
4171 Elf_External_Vernaux evna
;
4173 GET_DATA (vna_off
, evna
,
4174 "version need aux (3)");
4176 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4177 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4178 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4180 vna_off
+= ivna
.vna_next
;
4182 while (ivna
.vna_other
!= vers_data
4183 && ivna
.vna_next
!= 0);
4185 if (ivna
.vna_other
== vers_data
)
4188 offset
+= ivn
.vn_next
;
4190 while (ivn
.vn_next
!= 0);
4192 if (ivna
.vna_other
== vers_data
)
4195 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
4198 else if (! is_nobits
)
4199 error (_("bad dynamic symbol"));
4206 if (vers_data
!= 0x8001)
4208 Elf_Internal_Verdef ivd
;
4209 Elf_Internal_Verdaux ivda
;
4210 Elf_External_Verdaux evda
;
4211 unsigned long offset
;
4214 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
4219 Elf_External_Verdef evd
;
4221 GET_DATA (offset
, evd
, "version def");
4223 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4224 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4225 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4227 offset
+= ivd
.vd_next
;
4229 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
4230 && ivd
.vd_next
!= 0);
4232 offset
-= ivd
.vd_next
;
4233 offset
+= ivd
.vd_aux
;
4235 GET_DATA (offset
, evda
, "version def aux");
4237 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4239 if (psym
->st_name
!= ivda
.vda_name
)
4240 printf ((vers_data
& 0x8000)
4242 strtab
+ ivda
.vda_name
);
4252 if (strtab
!= string_table
)
4258 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4260 if (do_histogram
&& buckets
!= NULL
)
4267 int nzero_counts
= 0;
4270 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4272 printf (_(" Length Number %% of total Coverage\n"));
4274 lengths
= (int *) calloc (nbuckets
, sizeof (int));
4275 if (lengths
== NULL
)
4277 error (_("Out of memory"));
4280 for (hn
= 0; hn
< nbuckets
; ++hn
)
4285 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
4288 if (maxlength
< ++lengths
[hn
])
4293 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
4296 error (_("Out of memory"));
4300 for (hn
= 0; hn
< nbuckets
; ++hn
)
4301 ++ counts
[lengths
[hn
]];
4305 printf (" 0 %-10d (%5.1f%%)\n",
4306 counts
[0], (counts
[0] * 100.0) / nbuckets
);
4307 for (si
= 1; si
<= maxlength
; ++si
)
4309 nzero_counts
+= counts
[si
] * si
;
4310 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4311 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
4312 (nzero_counts
* 100.0) / nsyms
);
4320 if (buckets
!= NULL
)
4330 process_syminfo (file
)
4331 FILE * file ATTRIBUTE_UNUSED
;
4335 if (dynamic_syminfo
== NULL
4337 /* No syminfo, this is ok. */
4340 /* There better should be a dynamic symbol section. */
4341 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
4345 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4346 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
4348 printf (_(" Num: Name BoundTo Flags\n"));
4349 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
4351 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
4353 printf ("%4d: %-30s ", i
,
4354 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
4356 switch (dynamic_syminfo
[i
].si_boundto
)
4358 case SYMINFO_BT_SELF
:
4359 fputs ("SELF ", stdout
);
4361 case SYMINFO_BT_PARENT
:
4362 fputs ("PARENT ", stdout
);
4365 if (dynamic_syminfo
[i
].si_boundto
> 0
4366 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
4369 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
4371 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
4375 if (flags
& SYMINFO_FLG_DIRECT
)
4377 if (flags
& SYMINFO_FLG_PASSTHRU
)
4378 printf (" PASSTHRU");
4379 if (flags
& SYMINFO_FLG_COPY
)
4381 if (flags
& SYMINFO_FLG_LAZYLOAD
)
4382 printf (" LAZYLOAD");
4390 #ifdef SUPPORT_DISASSEMBLY
4392 disassemble_section (section
, file
)
4393 Elf32_Internal_Shdr
* section
;
4396 printf (_("\nAssembly dump of section %s\n"),
4397 SECTION_NAME (section
));
4399 /* XXX -- to be done --- XXX */
4406 dump_section (section
, file
)
4407 Elf32_Internal_Shdr
* section
;
4410 bfd_size_type bytes
;
4412 unsigned char * data
;
4413 unsigned char * start
;
4415 bytes
= section
->sh_size
;
4419 printf (_("\nSection '%s' has no data to dump.\n"),
4420 SECTION_NAME (section
));
4424 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
4426 addr
= section
->sh_addr
;
4428 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
4439 lbytes
= (bytes
> 16 ? 16 : bytes
);
4441 printf (" 0x%8.8lx ", (unsigned long) addr
);
4443 switch (elf_header
.e_ident
[EI_DATA
])
4447 for (j
= 15; j
>= 0; j
--)
4450 printf ("%2.2x", data
[j
]);
4460 for (j
= 0; j
< 16; j
++)
4463 printf ("%2.2x", data
[j
]);
4473 for (j
= 0; j
< lbytes
; j
++)
4476 if (k
>= ' ' && k
< 0x80)
4495 static unsigned long int
4496 read_leb128 (data
, length_return
, sign
)
4497 unsigned char * data
;
4498 int * length_return
;
4501 unsigned long int result
= 0;
4502 unsigned int num_read
= 0;
4511 result
|= (byte
& 0x7f) << shift
;
4516 while (byte
& 0x80);
4518 if (length_return
!= NULL
)
4519 * length_return
= num_read
;
4521 if (sign
&& (shift
< 32) && (byte
& 0x40))
4522 result
|= -1 << shift
;
4527 typedef struct State_Machine_Registers
4529 unsigned long address
;
4532 unsigned int column
;
4536 /* This variable hold the number of the last entry seen
4537 in the File Table. */
4538 unsigned int last_file_entry
;
4541 static SMR state_machine_regs
;
4544 reset_state_machine (is_stmt
)
4547 state_machine_regs
.address
= 0;
4548 state_machine_regs
.file
= 1;
4549 state_machine_regs
.line
= 1;
4550 state_machine_regs
.column
= 0;
4551 state_machine_regs
.is_stmt
= is_stmt
;
4552 state_machine_regs
.basic_block
= 0;
4553 state_machine_regs
.end_sequence
= 0;
4554 state_machine_regs
.last_file_entry
= 0;
4557 /* Handled an extend line op. Returns true if this is the end
4560 process_extended_line_op (data
, is_stmt
, pointer_size
)
4561 unsigned char * data
;
4565 unsigned char op_code
;
4568 unsigned char * name
;
4571 len
= read_leb128 (data
, & bytes_read
, 0);
4576 warn (_("badly formed extended line op encountered!"));
4581 op_code
= * data
++;
4583 printf (_(" Extended opcode %d: "), op_code
);
4587 case DW_LNE_end_sequence
:
4588 printf (_("End of Sequence\n\n"));
4589 reset_state_machine (is_stmt
);
4592 case DW_LNE_set_address
:
4593 adr
= byte_get (data
, pointer_size
);
4594 printf (_("set Address to 0x%lx\n"), adr
);
4595 state_machine_regs
.address
= adr
;
4598 case DW_LNE_define_file
:
4599 printf (_(" define new File Table entry\n"));
4600 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4602 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4604 data
+= strlen (data
) + 1;
4605 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4607 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4609 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4610 printf (_("%s\n\n"), name
);
4614 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
4621 /* Size of pointers in the .debug_line section. This information is not
4622 really present in that section. It's obtained before dumping the debug
4623 sections by doing some pre-scan of the .debug_info section. */
4624 static int debug_line_pointer_size
= 4;
4627 display_debug_lines (section
, start
, file
)
4628 Elf32_Internal_Shdr
* section
;
4629 unsigned char * start
;
4630 FILE * file ATTRIBUTE_UNUSED
;
4632 DWARF2_External_LineInfo
* external
;
4633 DWARF2_Internal_LineInfo info
;
4634 unsigned char * standard_opcodes
;
4635 unsigned char * data
= start
;
4636 unsigned char * end
= start
+ section
->sh_size
;
4637 unsigned char * end_of_sequence
;
4640 printf (_("\nDump of debug contents of section %s:\n\n"),
4641 SECTION_NAME (section
));
4645 external
= (DWARF2_External_LineInfo
*) data
;
4647 /* Check the length of the block. */
4648 info
.li_length
= BYTE_GET (external
->li_length
);
4649 if (info
.li_length
> section
->sh_size
)
4652 (_("The line info appears to be corrupt - the section is too small\n"));
4656 /* Check its version number. */
4657 info
.li_version
= BYTE_GET (external
->li_version
);
4658 if (info
.li_version
!= 2)
4660 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4664 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
4665 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
4666 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
4667 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
4668 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
4669 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
4671 /* Sign extend the line base field. */
4672 info
.li_line_base
<<= 24;
4673 info
.li_line_base
>>= 24;
4675 printf (_(" Length: %ld\n"), info
.li_length
);
4676 printf (_(" DWARF Version: %d\n"), info
.li_version
);
4677 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
4678 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
4679 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
4680 printf (_(" Line Base: %d\n"), info
.li_line_base
);
4681 printf (_(" Line Range: %d\n"), info
.li_line_range
);
4682 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
4684 end_of_sequence
= data
+ info
.li_length
+ sizeof (info
.li_length
);
4686 reset_state_machine (info
.li_default_is_stmt
);
4688 /* Display the contents of the Opcodes table. */
4689 standard_opcodes
= data
+ sizeof (* external
);
4691 printf (_("\n Opcodes:\n"));
4693 for (i
= 1; i
< info
.li_opcode_base
; i
++)
4694 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
4696 /* Display the contents of the Directory table. */
4697 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
4700 printf (_("\n The Directory Table is empty.\n"));
4703 printf (_("\n The Directory Table:\n"));
4707 printf (_(" %s\n"), data
);
4709 data
+= strlen (data
) + 1;
4713 /* Skip the NUL at the end of the table. */
4716 /* Display the contents of the File Name table. */
4718 printf (_("\n The File Name Table is empty.\n"));
4721 printf (_("\n The File Name Table:\n"));
4722 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4729 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4732 data
+= strlen (data
) + 1;
4734 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4736 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4738 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4740 printf (_("%s\n"), name
);
4744 /* Skip the NUL at the end of the table. */
4747 /* Now display the statements. */
4748 printf (_("\n Line Number Statements:\n"));
4751 while (data
< end_of_sequence
)
4753 unsigned char op_code
;
4757 op_code
= * data
++;
4761 case DW_LNS_extended_op
:
4762 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
4763 debug_line_pointer_size
);
4767 printf (_(" Copy\n"));
4770 case DW_LNS_advance_pc
:
4771 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
4773 state_machine_regs
.address
+= adv
;
4774 printf (_(" Advance PC by %d to %lx\n"), adv
,
4775 state_machine_regs
.address
);
4778 case DW_LNS_advance_line
:
4779 adv
= read_leb128 (data
, & bytes_read
, 1);
4781 state_machine_regs
.line
+= adv
;
4782 printf (_(" Advance Line by %d to %d\n"), adv
,
4783 state_machine_regs
.line
);
4786 case DW_LNS_set_file
:
4787 adv
= read_leb128 (data
, & bytes_read
, 0);
4789 printf (_(" Set File Name to entry %d in the File Name Table\n"),
4791 state_machine_regs
.file
= adv
;
4794 case DW_LNS_set_column
:
4795 adv
= read_leb128 (data
, & bytes_read
, 0);
4797 printf (_(" Set column to %d\n"), adv
);
4798 state_machine_regs
.column
= adv
;
4801 case DW_LNS_negate_stmt
:
4802 adv
= state_machine_regs
.is_stmt
;
4804 printf (_(" Set is_stmt to %d\n"), adv
);
4805 state_machine_regs
.is_stmt
= adv
;
4808 case DW_LNS_set_basic_block
:
4809 printf (_(" Set basic block\n"));
4810 state_machine_regs
.basic_block
= 1;
4813 case DW_LNS_const_add_pc
:
4814 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
4815 * info
.li_min_insn_length
);
4816 state_machine_regs
.address
+= adv
;
4817 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
4818 state_machine_regs
.address
);
4821 case DW_LNS_fixed_advance_pc
:
4822 adv
= byte_get (data
, 2);
4824 state_machine_regs
.address
+= adv
;
4825 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
4826 adv
, state_machine_regs
.address
);
4830 op_code
-= info
.li_opcode_base
;
4831 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
4832 state_machine_regs
.address
+= adv
;
4833 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
4834 op_code
, adv
, state_machine_regs
.address
);
4835 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
4836 state_machine_regs
.line
+= adv
;
4837 printf (_(" and Line by %d to %d\n"),
4838 adv
, state_machine_regs
.line
);
4849 display_debug_pubnames (section
, start
, file
)
4850 Elf32_Internal_Shdr
* section
;
4851 unsigned char * start
;
4852 FILE * file ATTRIBUTE_UNUSED
;
4854 DWARF2_External_PubNames
* external
;
4855 DWARF2_Internal_PubNames pubnames
;
4856 unsigned char * end
;
4858 end
= start
+ section
->sh_size
;
4860 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
4864 unsigned char * data
;
4865 unsigned long offset
;
4867 external
= (DWARF2_External_PubNames
*) start
;
4869 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
4870 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
4871 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
4872 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
4874 data
= start
+ sizeof (* external
);
4875 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
4877 if (pubnames
.pn_version
!= 2)
4879 warn (_("Only DWARF 2 pubnames are currently supported"));
4883 printf (_(" Length: %ld\n"),
4884 pubnames
.pn_length
);
4885 printf (_(" Version: %d\n"),
4886 pubnames
.pn_version
);
4887 printf (_(" Offset into .debug_info section: %ld\n"),
4888 pubnames
.pn_offset
);
4889 printf (_(" Size of area in .debug_info section: %ld\n"),
4892 printf (_("\n Offset\tName\n"));
4896 offset
= byte_get (data
, 4);
4901 printf (" %ld\t\t%s\n", offset
, data
);
4902 data
+= strlen (data
) + 1;
4905 while (offset
!= 0);
4918 case DW_TAG_padding
: return "DW_TAG_padding";
4919 case DW_TAG_array_type
: return "DW_TAG_array_type";
4920 case DW_TAG_class_type
: return "DW_TAG_class_type";
4921 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
4922 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
4923 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
4924 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
4925 case DW_TAG_label
: return "DW_TAG_label";
4926 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
4927 case DW_TAG_member
: return "DW_TAG_member";
4928 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
4929 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
4930 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
4931 case DW_TAG_string_type
: return "DW_TAG_string_type";
4932 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
4933 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
4934 case DW_TAG_typedef
: return "DW_TAG_typedef";
4935 case DW_TAG_union_type
: return "DW_TAG_union_type";
4936 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
4937 case DW_TAG_variant
: return "DW_TAG_variant";
4938 case DW_TAG_common_block
: return "DW_TAG_common_block";
4939 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
4940 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
4941 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
4942 case DW_TAG_module
: return "DW_TAG_module";
4943 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
4944 case DW_TAG_set_type
: return "DW_TAG_set_type";
4945 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
4946 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
4947 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
4948 case DW_TAG_base_type
: return "DW_TAG_base_type";
4949 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
4950 case DW_TAG_const_type
: return "DW_TAG_const_type";
4951 case DW_TAG_constant
: return "DW_TAG_constant";
4952 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
4953 case DW_TAG_file_type
: return "DW_TAG_file_type";
4954 case DW_TAG_friend
: return "DW_TAG_friend";
4955 case DW_TAG_namelist
: return "DW_TAG_namelist";
4956 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
4957 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
4958 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
4959 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
4960 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
4961 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
4962 case DW_TAG_try_block
: return "DW_TAG_try_block";
4963 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
4964 case DW_TAG_variable
: return "DW_TAG_variable";
4965 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
4966 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
4967 case DW_TAG_format_label
: return "DW_TAG_format_label";
4968 case DW_TAG_function_template
: return "DW_TAG_function_template";
4969 case DW_TAG_class_template
: return "DW_TAG_class_template";
4972 static char buffer
[100];
4974 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
4981 get_AT_name (attribute
)
4982 unsigned long attribute
;
4986 case DW_AT_sibling
: return "DW_AT_sibling";
4987 case DW_AT_location
: return "DW_AT_location";
4988 case DW_AT_name
: return "DW_AT_name";
4989 case DW_AT_ordering
: return "DW_AT_ordering";
4990 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
4991 case DW_AT_byte_size
: return "DW_AT_byte_size";
4992 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
4993 case DW_AT_bit_size
: return "DW_AT_bit_size";
4994 case DW_AT_element_list
: return "DW_AT_element_list";
4995 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
4996 case DW_AT_low_pc
: return "DW_AT_low_pc";
4997 case DW_AT_high_pc
: return "DW_AT_high_pc";
4998 case DW_AT_language
: return "DW_AT_language";
4999 case DW_AT_member
: return "DW_AT_member";
5000 case DW_AT_discr
: return "DW_AT_discr";
5001 case DW_AT_discr_value
: return "DW_AT_discr_value";
5002 case DW_AT_visibility
: return "DW_AT_visibility";
5003 case DW_AT_import
: return "DW_AT_import";
5004 case DW_AT_string_length
: return "DW_AT_string_length";
5005 case DW_AT_common_reference
: return "DW_AT_common_reference";
5006 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5007 case DW_AT_const_value
: return "DW_AT_const_value";
5008 case DW_AT_containing_type
: return "DW_AT_containing_type";
5009 case DW_AT_default_value
: return "DW_AT_default_value";
5010 case DW_AT_inline
: return "DW_AT_inline";
5011 case DW_AT_is_optional
: return "DW_AT_is_optional";
5012 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5013 case DW_AT_producer
: return "DW_AT_producer";
5014 case DW_AT_prototyped
: return "DW_AT_prototyped";
5015 case DW_AT_return_addr
: return "DW_AT_return_addr";
5016 case DW_AT_start_scope
: return "DW_AT_start_scope";
5017 case DW_AT_stride_size
: return "DW_AT_stride_size";
5018 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5019 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5020 case DW_AT_accessibility
: return "DW_AT_accessibility";
5021 case DW_AT_address_class
: return "DW_AT_address_class";
5022 case DW_AT_artificial
: return "DW_AT_artificial";
5023 case DW_AT_base_types
: return "DW_AT_base_types";
5024 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5025 case DW_AT_count
: return "DW_AT_count";
5026 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5027 case DW_AT_decl_column
: return "DW_AT_decl_column";
5028 case DW_AT_decl_file
: return "DW_AT_decl_file";
5029 case DW_AT_decl_line
: return "DW_AT_decl_line";
5030 case DW_AT_declaration
: return "DW_AT_declaration";
5031 case DW_AT_discr_list
: return "DW_AT_discr_list";
5032 case DW_AT_encoding
: return "DW_AT_encoding";
5033 case DW_AT_external
: return "DW_AT_external";
5034 case DW_AT_frame_base
: return "DW_AT_frame_base";
5035 case DW_AT_friend
: return "DW_AT_friend";
5036 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5037 case DW_AT_macro_info
: return "DW_AT_macro_info";
5038 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5039 case DW_AT_priority
: return "DW_AT_priority";
5040 case DW_AT_segment
: return "DW_AT_segment";
5041 case DW_AT_specification
: return "DW_AT_specification";
5042 case DW_AT_static_link
: return "DW_AT_static_link";
5043 case DW_AT_type
: return "DW_AT_type";
5044 case DW_AT_use_location
: return "DW_AT_use_location";
5045 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5046 case DW_AT_virtuality
: return "DW_AT_virtuality";
5047 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5048 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5049 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5050 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5051 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5052 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5053 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5054 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5055 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5056 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5057 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5058 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5059 case DW_AT_sf_names
: return "DW_AT_sf_names";
5060 case DW_AT_src_info
: return "DW_AT_src_info";
5061 case DW_AT_mac_info
: return "DW_AT_mac_info";
5062 case DW_AT_src_coords
: return "DW_AT_src_coords";
5063 case DW_AT_body_begin
: return "DW_AT_body_begin";
5064 case DW_AT_body_end
: return "DW_AT_body_end";
5067 static char buffer
[100];
5069 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5076 get_FORM_name (form
)
5081 case DW_FORM_addr
: return "DW_FORM_addr";
5082 case DW_FORM_block2
: return "DW_FORM_block2";
5083 case DW_FORM_block4
: return "DW_FORM_block4";
5084 case DW_FORM_data2
: return "DW_FORM_data2";
5085 case DW_FORM_data4
: return "DW_FORM_data4";
5086 case DW_FORM_data8
: return "DW_FORM_data8";
5087 case DW_FORM_string
: return "DW_FORM_string";
5088 case DW_FORM_block
: return "DW_FORM_block";
5089 case DW_FORM_block1
: return "DW_FORM_block1";
5090 case DW_FORM_data1
: return "DW_FORM_data1";
5091 case DW_FORM_flag
: return "DW_FORM_flag";
5092 case DW_FORM_sdata
: return "DW_FORM_sdata";
5093 case DW_FORM_strp
: return "DW_FORM_strp";
5094 case DW_FORM_udata
: return "DW_FORM_udata";
5095 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5096 case DW_FORM_ref1
: return "DW_FORM_ref1";
5097 case DW_FORM_ref2
: return "DW_FORM_ref2";
5098 case DW_FORM_ref4
: return "DW_FORM_ref4";
5099 case DW_FORM_ref8
: return "DW_FORM_ref8";
5100 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5101 case DW_FORM_indirect
: return "DW_FORM_indirect";
5104 static char buffer
[100];
5106 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5112 /* FIXME: There are better and more effiecint ways to handle
5113 these structures. For now though, I just want something that
5114 is simple to implement. */
5115 typedef struct abbrev_attr
5117 unsigned long attribute
;
5119 struct abbrev_attr
* next
;
5123 typedef struct abbrev_entry
5125 unsigned long entry
;
5128 struct abbrev_attr
* first_attr
;
5129 struct abbrev_attr
* last_attr
;
5130 struct abbrev_entry
* next
;
5134 static abbrev_entry
* first_abbrev
= NULL
;
5135 static abbrev_entry
* last_abbrev
= NULL
;
5138 free_abbrevs
PARAMS ((void))
5140 abbrev_entry
* abbrev
;
5142 for (abbrev
= first_abbrev
; abbrev
;)
5144 abbrev_entry
* next
= abbrev
->next
;
5147 for (attr
= abbrev
->first_attr
; attr
;)
5149 abbrev_attr
* next
= attr
->next
;
5159 last_abbrev
= first_abbrev
= NULL
;
5163 add_abbrev (number
, tag
, children
)
5164 unsigned long number
;
5168 abbrev_entry
* entry
;
5170 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
5176 entry
->entry
= number
;
5178 entry
->children
= children
;
5179 entry
->first_attr
= NULL
;
5180 entry
->last_attr
= NULL
;
5183 if (first_abbrev
== NULL
)
5184 first_abbrev
= entry
;
5186 last_abbrev
->next
= entry
;
5188 last_abbrev
= entry
;
5192 add_abbrev_attr (attribute
, form
)
5193 unsigned long attribute
;
5198 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
5204 attr
->attribute
= attribute
;
5208 if (last_abbrev
->first_attr
== NULL
)
5209 last_abbrev
->first_attr
= attr
;
5211 last_abbrev
->last_attr
->next
= attr
;
5213 last_abbrev
->last_attr
= attr
;
5216 /* Processes the (partial) contents of a .debug_abbrev section.
5217 Returns NULL if the end of the section was encountered.
5218 Returns the address after the last byte read if the end of
5219 an abbreviation set was found. */
5221 static unsigned char *
5222 process_abbrev_section (start
, end
)
5223 unsigned char * start
;
5224 unsigned char * end
;
5226 if (first_abbrev
!= NULL
)
5232 unsigned long entry
;
5234 unsigned long attribute
;
5237 entry
= read_leb128 (start
, & bytes_read
, 0);
5238 start
+= bytes_read
;
5240 /* A single zero is supposed to end the section according
5241 to the standard. If there's more, then signal that to
5244 return start
== end
? NULL
: start
;
5246 tag
= read_leb128 (start
, & bytes_read
, 0);
5247 start
+= bytes_read
;
5249 children
= * start
++;
5251 add_abbrev (entry
, tag
, children
);
5257 attribute
= read_leb128 (start
, & bytes_read
, 0);
5258 start
+= bytes_read
;
5260 form
= read_leb128 (start
, & bytes_read
, 0);
5261 start
+= bytes_read
;
5264 add_abbrev_attr (attribute
, form
);
5266 while (attribute
!= 0);
5274 display_debug_abbrev (section
, start
, file
)
5275 Elf32_Internal_Shdr
* section
;
5276 unsigned char * start
;
5277 FILE * file ATTRIBUTE_UNUSED
;
5279 abbrev_entry
* entry
;
5280 unsigned char * end
= start
+ section
->sh_size
;
5282 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5286 start
= process_abbrev_section (start
, end
);
5288 printf (_(" Number TAG\n"));
5290 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5294 printf (_(" %ld %s [%s]\n"),
5296 get_TAG_name (entry
->tag
),
5297 entry
->children
? _("has children") : _("no children"));
5299 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5301 printf (_(" %-18s %s\n"),
5302 get_AT_name (attr
->attribute
),
5303 get_FORM_name (attr
->form
));
5315 static unsigned char *
5316 display_block (data
, length
)
5317 unsigned char * data
;
5318 unsigned long length
;
5320 printf (_(" %lu byte block: "), length
);
5323 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
5329 decode_location_expression (data
, pointer_size
)
5330 unsigned char * data
;
5331 unsigned int pointer_size
;
5335 unsigned long uvalue
;
5342 printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data
, pointer_size
));
5345 printf ("DW_OP_deref");
5348 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
, 1));
5351 printf ("DW_OP_const1s: %ld", (long) byte_get (data
, 1));
5354 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
5357 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
5360 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
5363 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
5366 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
5367 (unsigned long) byte_get (data
+ 4, 4));
5370 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
5371 (long) byte_get (data
+ 4, 4));
5374 printf ("DW_OP_constu: %lu", read_leb128 (data
, NULL
, 0));
5377 printf ("DW_OP_consts: %ld", read_leb128 (data
, NULL
, 1));
5380 printf ("DW_OP_dup");
5383 printf ("DW_OP_drop");
5386 printf ("DW_OP_over");
5389 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
, 1));
5392 printf ("DW_OP_swap");
5395 printf ("DW_OP_rot");
5398 printf ("DW_OP_xderef");
5401 printf ("DW_OP_abs");
5404 printf ("DW_OP_and");
5407 printf ("DW_OP_div");
5410 printf ("DW_OP_minus");
5413 printf ("DW_OP_mod");
5416 printf ("DW_OP_mul");
5419 printf ("DW_OP_neg");
5422 printf ("DW_OP_not");
5425 printf ("DW_OP_or");
5428 printf ("DW_OP_plus");
5430 case DW_OP_plus_uconst
:
5431 printf ("DW_OP_plus_uconst: %lu", read_leb128 (data
, NULL
, 0));
5434 printf ("DW_OP_shl");
5437 printf ("DW_OP_shr");
5440 printf ("DW_OP_shra");
5443 printf ("DW_OP_xor");
5446 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
5449 printf ("DW_OP_eq");
5452 printf ("DW_OP_ge");
5455 printf ("DW_OP_gt");
5458 printf ("DW_OP_le");
5461 printf ("DW_OP_lt");
5464 printf ("DW_OP_ne");
5467 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
5470 printf ("DW_OP_lit0");
5473 printf ("DW_OP_lit1");
5476 printf ("DW_OP_lit2");
5479 printf ("DW_OP_lit3");
5482 printf ("DW_OP_lit4");
5485 printf ("DW_OP_lit5");
5488 printf ("DW_OP_lit6");
5491 printf ("DW_OP_lit7");
5494 printf ("DW_OP_lit8");
5497 printf ("DW_OP_lit9");
5500 printf ("DW_OP_lit10");
5503 printf ("DW_OP_lit11");
5506 printf ("DW_OP_lit12");
5509 printf ("DW_OP_lit13");
5512 printf ("DW_OP_lit14");
5515 printf ("DW_OP_lit15");
5518 printf ("DW_OP_lit16");
5521 printf ("DW_OP_lit17");
5524 printf ("DW_OP_lit18");
5527 printf ("DW_OP_lit19");
5530 printf ("DW_OP_lit20");
5533 printf ("DW_OP_lit21");
5536 printf ("DW_OP_lit22");
5539 printf ("DW_OP_lit23");
5542 printf ("DW_OP_lit24");
5545 printf ("DW_OP_lit25");
5548 printf ("DW_OP_lit26");
5551 printf ("DW_OP_lit27");
5554 printf ("DW_OP_lit28");
5557 printf ("DW_OP_lit29");
5560 printf ("DW_OP_lit30");
5563 printf ("DW_OP_lit31");
5566 printf ("DW_OP_reg0");
5569 printf ("DW_OP_reg1");
5572 printf ("DW_OP_reg2");
5575 printf ("DW_OP_reg3");
5578 printf ("DW_OP_reg4");
5581 printf ("DW_OP_reg5");
5584 printf ("DW_OP_reg6");
5587 printf ("DW_OP_reg7");
5590 printf ("DW_OP_reg8");
5593 printf ("DW_OP_reg9");
5596 printf ("DW_OP_reg10");
5599 printf ("DW_OP_reg11");
5602 printf ("DW_OP_reg12");
5605 printf ("DW_OP_reg13");
5608 printf ("DW_OP_reg14");
5611 printf ("DW_OP_reg15");
5614 printf ("DW_OP_reg16");
5617 printf ("DW_OP_reg17");
5620 printf ("DW_OP_reg18");
5623 printf ("DW_OP_reg19");
5626 printf ("DW_OP_reg20");
5629 printf ("DW_OP_reg21");
5632 printf ("DW_OP_reg22");
5635 printf ("DW_OP_reg23");
5638 printf ("DW_OP_reg24");
5641 printf ("DW_OP_reg25");
5644 printf ("DW_OP_reg26");
5647 printf ("DW_OP_reg27");
5650 printf ("DW_OP_reg28");
5653 printf ("DW_OP_reg29");
5656 printf ("DW_OP_reg30");
5659 printf ("DW_OP_reg31");
5662 printf ("DW_OP_breg0: %ld", read_leb128 (data
, NULL
, 1));
5665 printf ("DW_OP_breg1: %ld", read_leb128 (data
, NULL
, 1));
5668 printf ("DW_OP_breg2: %ld", read_leb128 (data
, NULL
, 1));
5671 printf ("DW_OP_breg3: %ld", read_leb128 (data
, NULL
, 1));
5674 printf ("DW_OP_breg4: %ld", read_leb128 (data
, NULL
, 1));
5677 printf ("DW_OP_breg5: %ld", read_leb128 (data
, NULL
, 1));
5680 printf ("DW_OP_breg6: %ld", read_leb128 (data
, NULL
, 1));
5683 printf ("DW_OP_breg7: %ld", read_leb128 (data
, NULL
, 1));
5686 printf ("DW_OP_breg8: %ld", read_leb128 (data
, NULL
, 1));
5689 printf ("DW_OP_breg9: %ld", read_leb128 (data
, NULL
, 1));
5692 printf ("DW_OP_breg10: %ld", read_leb128 (data
, NULL
, 1));
5695 printf ("DW_OP_breg11: %ld", read_leb128 (data
, NULL
, 1));
5698 printf ("DW_OP_breg12: %ld", read_leb128 (data
, NULL
, 1));
5701 printf ("DW_OP_breg13: %ld", read_leb128 (data
, NULL
, 1));
5704 printf ("DW_OP_breg14: %ld", read_leb128 (data
, NULL
, 1));
5707 printf ("DW_OP_breg15: %ld", read_leb128 (data
, NULL
, 1));
5710 printf ("DW_OP_breg16: %ld", read_leb128 (data
, NULL
, 1));
5713 printf ("DW_OP_breg17: %ld", read_leb128 (data
, NULL
, 1));
5716 printf ("DW_OP_breg18: %ld", read_leb128 (data
, NULL
, 1));
5719 printf ("DW_OP_breg19: %ld", read_leb128 (data
, NULL
, 1));
5722 printf ("DW_OP_breg20: %ld", read_leb128 (data
, NULL
, 1));
5725 printf ("DW_OP_breg21: %ld", read_leb128 (data
, NULL
, 1));
5728 printf ("DW_OP_breg22: %ld", read_leb128 (data
, NULL
, 1));
5731 printf ("DW_OP_breg23: %ld", read_leb128 (data
, NULL
, 1));
5734 printf ("DW_OP_breg24: %ld", read_leb128 (data
, NULL
, 1));
5737 printf ("DW_OP_breg25: %ld", read_leb128 (data
, NULL
, 1));
5740 printf ("DW_OP_breg26: %ld", read_leb128 (data
, NULL
, 1));
5743 printf ("DW_OP_breg27: %ld", read_leb128 (data
, NULL
, 1));
5746 printf ("DW_OP_breg28: %ld", read_leb128 (data
, NULL
, 1));
5749 printf ("DW_OP_breg29: %ld", read_leb128 (data
, NULL
, 1));
5752 printf ("DW_OP_breg30: %ld", read_leb128 (data
, NULL
, 1));
5755 printf ("DW_OP_breg31: %ld", read_leb128 (data
, NULL
, 1));
5758 printf ("DW_OP_regx: %lu", read_leb128 (data
, NULL
, 0));
5761 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, NULL
, 1));
5764 uvalue
= read_leb128 (data
, &bytes_read
, 0);
5765 printf ("DW_OP_bregx: %lu %ld", uvalue
,
5766 read_leb128 (data
+ bytes_read
, NULL
, 1));
5769 printf ("DW_OP_piece: %lu", read_leb128 (data
, NULL
, 0));
5771 case DW_OP_deref_size
:
5772 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
, 1));
5774 case DW_OP_xderef_size
:
5775 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
, 1));
5778 printf ("DW_OP_nop");
5782 if (op
>= DW_OP_lo_user
5783 && op
<= DW_OP_hi_user
)
5784 printf (_("(User defined location op)"));
5786 printf (_("(Unknown location op)"));
5792 static unsigned char *
5793 read_and_display_attr (attribute
, form
, data
, pointer_size
)
5794 unsigned long attribute
;
5796 unsigned char * data
;
5797 unsigned long pointer_size
;
5799 unsigned long uvalue
= 0;
5800 unsigned char * block_start
= NULL
;
5804 printf (" %-18s:", get_AT_name (attribute
));
5808 case DW_FORM_ref_addr
:
5813 case DW_FORM_ref_udata
:
5819 case DW_FORM_ref_addr
:
5821 uvalue
= byte_get (data
, pointer_size
);
5822 printf (is_ref
? " <%x>" : " %#x", uvalue
);
5823 data
+= pointer_size
;
5829 uvalue
= byte_get (data
++, 1);
5830 printf (is_ref
? " <%x>" : " %d", uvalue
);
5835 uvalue
= byte_get (data
, 2);
5837 printf (is_ref
? " <%x>" : " %d", uvalue
);
5842 uvalue
= byte_get (data
, 4);
5844 printf (is_ref
? " <%x>" : " %d", uvalue
);
5849 uvalue
= byte_get (data
, 4);
5850 printf (" %lx", uvalue
);
5851 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
5855 case DW_FORM_string
:
5856 printf (" %s", data
);
5857 data
+= strlen (data
) + 1;
5861 uvalue
= read_leb128 (data
, & bytes_read
, 1);
5863 printf (" %ld", (long) uvalue
);
5866 case DW_FORM_ref_udata
:
5868 uvalue
= read_leb128 (data
, & bytes_read
, 0);
5870 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
5874 uvalue
= read_leb128 (data
, & bytes_read
, 0);
5875 block_start
= data
+ bytes_read
;
5876 data
= display_block (block_start
, uvalue
);
5877 uvalue
= * block_start
;
5880 case DW_FORM_block1
:
5881 uvalue
= byte_get (data
, 1);
5882 block_start
= data
+ 1;
5883 data
= display_block (block_start
, uvalue
);
5884 uvalue
= * block_start
;
5887 case DW_FORM_block2
:
5888 uvalue
= byte_get (data
, 2);
5889 block_start
= data
+ 2;
5890 data
= display_block (block_start
, uvalue
);
5891 uvalue
= * block_start
;
5894 case DW_FORM_block4
:
5895 uvalue
= byte_get (data
, 4);
5896 block_start
= data
+ 4;
5897 data
= display_block (block_start
, uvalue
);
5898 uvalue
= * block_start
;
5902 case DW_FORM_indirect
:
5903 warn (_("Unable to handle FORM: %d"), form
);
5907 warn (_("Unrecognised form: %d"), form
);
5911 /* For some attributes we can display futher information. */
5920 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
5921 case DW_INL_inlined
: printf (_("(inlined)")); break;
5922 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
5923 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
5924 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
5928 case DW_AT_frame_base
:
5929 if (uvalue
>= DW_OP_reg0
&& uvalue
<= DW_OP_reg31
)
5930 printf ("(reg %ld)", uvalue
- DW_OP_reg0
);
5933 case DW_AT_language
:
5936 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
5937 case DW_LANG_C89
: printf ("(ANSI C)"); break;
5938 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
5939 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
5940 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
5941 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
5942 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
5943 case DW_LANG_Ada83
: printf ("(Ada)"); break;
5944 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
5945 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
5946 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
5947 default: printf ("(Unknown: %lx)", uvalue
); break;
5951 case DW_AT_encoding
:
5954 case DW_ATE_void
: printf ("(void)"); break;
5955 case DW_ATE_address
: printf ("(machine address)"); break;
5956 case DW_ATE_boolean
: printf ("(boolean)"); break;
5957 case DW_ATE_complex_float
: printf ("(complex float)"); break;
5958 case DW_ATE_float
: printf ("(float)"); break;
5959 case DW_ATE_signed
: printf ("(signed)"); break;
5960 case DW_ATE_signed_char
: printf ("(signed char)"); break;
5961 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
5962 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
5964 if (uvalue
>= DW_ATE_lo_user
5965 && uvalue
<= DW_ATE_hi_user
)
5966 printf ("(user defined type)");
5968 printf ("(unknown type)");
5973 case DW_AT_accessibility
:
5976 case DW_ACCESS_public
: printf ("(public)"); break;
5977 case DW_ACCESS_protected
: printf ("(protected)"); break;
5978 case DW_ACCESS_private
: printf ("(private)"); break;
5979 default: printf ("(unknown accessibility)"); break;
5983 case DW_AT_visibility
:
5986 case DW_VIS_local
: printf ("(local)"); break;
5987 case DW_VIS_exported
: printf ("(exported)"); break;
5988 case DW_VIS_qualified
: printf ("(qualified)"); break;
5989 default: printf ("(unknown visibility)"); break;
5993 case DW_AT_virtuality
:
5996 case DW_VIRTUALITY_none
: printf ("(none)"); break;
5997 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
5998 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
5999 default: printf ("(unknown virtuality)"); break;
6003 case DW_AT_identifier_case
:
6006 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6007 case DW_ID_up_case
: printf ("(up_case)"); break;
6008 case DW_ID_down_case
: printf ("(down_case)"); break;
6009 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6010 default: printf ("(unknown case)"); break;
6014 case DW_AT_calling_convention
:
6017 case DW_CC_normal
: printf ("(normal)"); break;
6018 case DW_CC_program
: printf ("(program)"); break;
6019 case DW_CC_nocall
: printf ("(nocall)"); break;
6021 if (uvalue
>= DW_CC_lo_user
6022 && uvalue
<= DW_CC_hi_user
)
6023 printf ("(user defined)");
6025 printf ("(unknown convention)");
6029 case DW_AT_location
:
6030 case DW_AT_data_member_location
:
6031 case DW_AT_vtable_elem_location
:
6033 decode_location_expression (block_start
, pointer_size
);
6046 display_debug_info (section
, start
, file
)
6047 Elf32_Internal_Shdr
* section
;
6048 unsigned char * start
;
6051 unsigned char * end
= start
+ section
->sh_size
;
6052 unsigned char * section_begin
= start
;
6054 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6058 DWARF2_External_CompUnit
* external
;
6059 DWARF2_Internal_CompUnit compunit
;
6060 unsigned char * tags
;
6064 external
= (DWARF2_External_CompUnit
*) start
;
6066 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6067 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6068 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6069 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6071 tags
= start
+ sizeof (* external
);
6072 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6074 if (compunit
.cu_version
!= 2)
6076 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6080 printf (_(" Compilation Unit:\n"));
6081 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6082 printf (_(" Version: %d\n"), compunit
.cu_version
);
6083 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6084 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6086 if (first_abbrev
!= NULL
)
6089 /* Read in the abbrevs used by this compilation unit. */
6092 Elf32_Internal_Shdr
* sec
;
6093 unsigned char * begin
;
6095 /* Locate the .debug_abbrev section and process it. */
6096 for (i
= 0, sec
= section_headers
;
6097 i
< elf_header
.e_shnum
;
6099 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6102 if (i
== -1 || sec
->sh_size
== 0)
6104 warn (_("Unable to locate .debug_abbrev section!\n"));
6108 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6109 "debug_abbrev section data");
6111 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6112 begin
+ sec
->sh_size
);
6118 while (tags
< start
)
6121 unsigned long abbrev_number
;
6122 abbrev_entry
* entry
;
6125 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6128 /* A null DIE marks the end of a list of children. */
6129 if (abbrev_number
== 0)
6135 /* Scan through the abbreviation list until we reach the
6137 for (entry
= first_abbrev
;
6138 entry
&& entry
->entry
!= abbrev_number
;
6139 entry
= entry
->next
)
6144 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6149 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6150 level
, tags
- section_begin
- bytes_read
,
6152 get_TAG_name (entry
->tag
));
6154 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6155 tags
= read_and_display_attr (attr
->attribute
,
6158 compunit
.cu_pointer_size
);
6160 if (entry
->children
)
6171 display_debug_aranges (section
, start
, file
)
6172 Elf32_Internal_Shdr
* section
;
6173 unsigned char * start
;
6174 FILE * file ATTRIBUTE_UNUSED
;
6176 unsigned char * end
= start
+ section
->sh_size
;
6178 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6182 DWARF2_External_ARange
* external
;
6183 DWARF2_Internal_ARange arange
;
6184 unsigned char * ranges
;
6185 unsigned long length
;
6186 unsigned long address
;
6189 external
= (DWARF2_External_ARange
*) start
;
6191 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6192 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6193 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6194 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6195 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6197 printf (_(" Length: %ld\n"), arange
.ar_length
);
6198 printf (_(" Version: %d\n"), arange
.ar_version
);
6199 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6200 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6201 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6203 printf (_("\n Address Length\n"));
6205 ranges
= start
+ sizeof (* external
);
6207 /* Must pad to an alignment boundary that is twice the pointer size. */
6208 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
6210 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6214 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6216 ranges
+= arange
.ar_pointer_size
;
6218 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6220 ranges
+= arange
.ar_pointer_size
;
6222 /* A pair of zeros marks the end of the list. */
6223 if (address
== 0 && length
== 0)
6226 printf (" %8.8lx %lu\n", address
, length
);
6229 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6239 display_debug_not_supported (section
, start
, file
)
6240 Elf32_Internal_Shdr
* section
;
6241 unsigned char * start ATTRIBUTE_UNUSED
;
6242 FILE * file ATTRIBUTE_UNUSED
;
6244 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6245 SECTION_NAME (section
));
6250 /* Pre-scan the .debug_info section to record the size of address.
6251 When dumping the .debug_line, we use that size information, assuming
6252 that all compilation units have the same address size. */
6254 prescan_debug_info (section
, start
, file
)
6255 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
6256 unsigned char * start
;
6257 FILE * file ATTRIBUTE_UNUSED
;
6259 DWARF2_External_CompUnit
* external
;
6261 external
= (DWARF2_External_CompUnit
*) start
;
6263 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6267 /* A structure containing the name of a debug section and a pointer
6268 to a function that can decode it. The third field is a prescan
6269 function to be run over the section before displaying any of the
6274 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6275 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6279 { ".debug_info", display_debug_info
, prescan_debug_info
},
6280 { ".debug_abbrev", display_debug_abbrev
, NULL
},
6281 { ".debug_line", display_debug_lines
, NULL
},
6282 { ".debug_aranges", display_debug_aranges
, NULL
},
6283 { ".debug_pubnames", display_debug_pubnames
, NULL
},
6284 { ".debug_macinfo", display_debug_not_supported
, NULL
},
6285 { ".debug_frame", display_debug_not_supported
, NULL
},
6286 { ".debug_str", display_debug_not_supported
, NULL
},
6287 { ".debug_static_func", display_debug_not_supported
, NULL
},
6288 { ".debug_static_vars", display_debug_not_supported
, NULL
},
6289 { ".debug_types", display_debug_not_supported
, NULL
},
6290 { ".debug_weaknames", display_debug_not_supported
, NULL
}
6294 display_debug_section (section
, file
)
6295 Elf32_Internal_Shdr
* section
;
6298 char * name
= SECTION_NAME (section
);
6299 bfd_size_type length
;
6300 unsigned char * start
;
6303 length
= section
->sh_size
;
6306 printf (_("\nSection '%s' has no debugging data.\n"), name
);
6310 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6311 "debug section data");
6313 /* See if we know how to display the contents of this section. */
6314 for (i
= NUM_ELEM (debug_displays
); i
--;)
6315 if (strcmp (debug_displays
[i
].name
, name
) == 0)
6317 debug_displays
[i
].display (section
, start
, file
);
6322 printf (_("Unrecognised debug section: %s\n"), name
);
6326 /* If we loaded in the abbrev section at some point,
6327 we must release it here. */
6328 if (first_abbrev
!= NULL
)
6335 process_section_contents (file
)
6338 Elf32_Internal_Shdr
* section
;
6344 /* Pre-scan the debug sections to find some debug information not
6345 present in some of them. For the .debug_line, we must find out the
6346 size of address (specified in .debug_info and .debug_aranges). */
6347 for (i
= 0, section
= section_headers
;
6348 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6351 char * name
= SECTION_NAME (section
);
6354 if (section
->sh_size
== 0)
6357 /* See if there is some pre-scan operation for this section. */
6358 for (j
= NUM_ELEM (debug_displays
); j
--;)
6359 if (strcmp (debug_displays
[j
].name
, name
) == 0)
6361 if (debug_displays
[j
].prescan
!= NULL
)
6363 bfd_size_type length
;
6364 unsigned char * start
;
6366 length
= section
->sh_size
;
6367 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6368 "debug section data");
6370 debug_displays
[j
].prescan (section
, start
, file
);
6378 for (i
= 0, section
= section_headers
;
6379 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6382 #ifdef SUPPORT_DISASSEMBLY
6383 if (dump_sects
[i
] & DISASS_DUMP
)
6384 disassemble_section (section
, file
);
6386 if (dump_sects
[i
] & HEX_DUMP
)
6387 dump_section (section
, file
);
6389 if (dump_sects
[i
] & DEBUG_DUMP
)
6390 display_debug_section (section
, file
);
6393 if (i
< num_dump_sects
)
6394 warn (_("Some sections were not dumped because they do not exist!\n"));
6400 process_mips_fpe_exception (mask
)
6406 if (mask
& OEX_FPU_INEX
)
6407 fputs ("INEX", stdout
), first
= 0;
6408 if (mask
& OEX_FPU_UFLO
)
6409 printf ("%sUFLO", first
? "" : "|"), first
= 0;
6410 if (mask
& OEX_FPU_OFLO
)
6411 printf ("%sOFLO", first
? "" : "|"), first
= 0;
6412 if (mask
& OEX_FPU_DIV0
)
6413 printf ("%sDIV0", first
? "" : "|"), first
= 0;
6414 if (mask
& OEX_FPU_INVAL
)
6415 printf ("%sINVAL", first
? "" : "|");
6418 fputs ("0", stdout
);
6422 process_mips_specific (file
)
6425 Elf_Internal_Dyn
* entry
;
6426 size_t liblist_offset
= 0;
6427 size_t liblistno
= 0;
6428 size_t conflictsno
= 0;
6429 size_t options_offset
= 0;
6430 size_t conflicts_offset
= 0;
6432 /* We have a lot of special sections. Thanks SGI! */
6433 if (dynamic_segment
== NULL
)
6434 /* No information available. */
6437 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
6438 switch (entry
->d_tag
)
6440 case DT_MIPS_LIBLIST
:
6441 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
6443 case DT_MIPS_LIBLISTNO
:
6444 liblistno
= entry
->d_un
.d_val
;
6446 case DT_MIPS_OPTIONS
:
6447 options_offset
= entry
->d_un
.d_val
- loadaddr
;
6449 case DT_MIPS_CONFLICT
:
6450 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
6452 case DT_MIPS_CONFLICTNO
:
6453 conflictsno
= entry
->d_un
.d_val
;
6459 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
6461 Elf32_External_Lib
* elib
;
6464 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
6465 elib
, Elf32_External_Lib
*, "liblist");
6467 printf ("\nSection '.liblist' contains %d entries:\n", liblistno
);
6468 fputs (" Library Time Stamp Checksum Version Flags\n",
6471 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
6477 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
6478 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
6479 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
6480 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
6481 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
6483 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
6485 printf ("%3d: %-20s %s %#10lx %-7ld", cnt
,
6486 dynamic_strings
+ liblist
.l_name
, timebuf
,
6487 liblist
.l_checksum
, liblist
.l_version
);
6489 if (liblist
.l_flags
== 0)
6500 { " EXACT_MATCH", LL_EXACT_MATCH
},
6501 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
6502 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
6503 { " EXPORTS", LL_EXPORTS
},
6504 { " DELAY_LOAD", LL_DELAY_LOAD
},
6505 { " DELTA", LL_DELTA
}
6507 int flags
= liblist
.l_flags
;
6511 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
6513 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
6515 fputs (l_flags_vals
[fcnt
].name
, stdout
);
6516 flags
^= l_flags_vals
[fcnt
].bit
;
6519 printf (" %#x", (unsigned int) flags
);
6528 if (options_offset
!= 0)
6530 Elf_External_Options
* eopt
;
6531 Elf_Internal_Shdr
* sect
= section_headers
;
6532 Elf_Internal_Options
* iopt
;
6533 Elf_Internal_Options
* option
;
6537 /* Find the section header so that we get the size. */
6538 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
6541 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
6542 Elf_External_Options
*, "options");
6544 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
6548 error (_("Out of memory"));
6554 while (offset
< sect
->sh_size
)
6556 Elf_External_Options
* eoption
;
6558 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
6560 option
->kind
= BYTE_GET (eoption
->kind
);
6561 option
->size
= BYTE_GET (eoption
->size
);
6562 option
->section
= BYTE_GET (eoption
->section
);
6563 option
->info
= BYTE_GET (eoption
->info
);
6565 offset
+= option
->size
;
6570 printf (_("\nSection '%s' contains %d entries:\n"),
6571 string_table
+ sect
->sh_name
, cnt
);
6578 switch (option
->kind
)
6581 /* This shouldn't happen. */
6582 printf (" NULL %d %lx", option
->section
, option
->info
);
6585 printf (" REGINFO ");
6586 if (elf_header
.e_machine
== EM_MIPS
)
6589 Elf32_External_RegInfo
*ereg
;
6590 Elf32_RegInfo reginfo
;
6592 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
6593 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6594 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6595 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6596 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6597 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6598 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
6600 printf ("GPR %08lx GP 0x%lx\n",
6602 (unsigned long) reginfo
.ri_gp_value
);
6603 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6604 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6605 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6610 Elf64_External_RegInfo
* ereg
;
6611 Elf64_Internal_RegInfo reginfo
;
6613 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
6614 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6615 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6616 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6617 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6618 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6619 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
6621 printf ("GPR %08lx GP 0x",
6622 reginfo
.ri_gprmask
);
6623 printf_vma (reginfo
.ri_gp_value
);
6626 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6627 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6628 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6632 case ODK_EXCEPTIONS
:
6633 fputs (" EXCEPTIONS fpe_min(", stdout
);
6634 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
6635 fputs (") fpe_max(", stdout
);
6636 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
6637 fputs (")", stdout
);
6639 if (option
->info
& OEX_PAGE0
)
6640 fputs (" PAGE0", stdout
);
6641 if (option
->info
& OEX_SMM
)
6642 fputs (" SMM", stdout
);
6643 if (option
->info
& OEX_FPDBUG
)
6644 fputs (" FPDBUG", stdout
);
6645 if (option
->info
& OEX_DISMISS
)
6646 fputs (" DISMISS", stdout
);
6649 fputs (" PAD ", stdout
);
6650 if (option
->info
& OPAD_PREFIX
)
6651 fputs (" PREFIX", stdout
);
6652 if (option
->info
& OPAD_POSTFIX
)
6653 fputs (" POSTFIX", stdout
);
6654 if (option
->info
& OPAD_SYMBOL
)
6655 fputs (" SYMBOL", stdout
);
6658 fputs (" HWPATCH ", stdout
);
6659 if (option
->info
& OHW_R4KEOP
)
6660 fputs (" R4KEOP", stdout
);
6661 if (option
->info
& OHW_R8KPFETCH
)
6662 fputs (" R8KPFETCH", stdout
);
6663 if (option
->info
& OHW_R5KEOP
)
6664 fputs (" R5KEOP", stdout
);
6665 if (option
->info
& OHW_R5KCVTL
)
6666 fputs (" R5KCVTL", stdout
);
6669 fputs (" FILL ", stdout
);
6670 /* XXX Print content of info word? */
6673 fputs (" TAGS ", stdout
);
6674 /* XXX Print content of info word? */
6677 fputs (" HWAND ", stdout
);
6678 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6679 fputs (" R4KEOP_CHECKED", stdout
);
6680 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6681 fputs (" R4KEOP_CLEAN", stdout
);
6684 fputs (" HWOR ", stdout
);
6685 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6686 fputs (" R4KEOP_CHECKED", stdout
);
6687 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6688 fputs (" R4KEOP_CLEAN", stdout
);
6691 printf (" GP_GROUP %#06lx self-contained %#06lx",
6692 option
->info
& OGP_GROUP
,
6693 (option
->info
& OGP_SELF
) >> 16);
6696 printf (" IDENT %#06lx self-contained %#06lx",
6697 option
->info
& OGP_GROUP
,
6698 (option
->info
& OGP_SELF
) >> 16);
6701 /* This shouldn't happen. */
6702 printf (" %3d ??? %d %lx",
6703 option
->kind
, option
->section
, option
->info
);
6707 len
= sizeof (*eopt
);
6708 while (len
< option
->size
)
6709 if (((char *) option
)[len
] >= ' '
6710 && ((char *) option
)[len
] < 0x7f)
6711 printf ("%c", ((char *) option
)[len
++]);
6713 printf ("\\%03o", ((char *) option
)[len
++]);
6715 fputs ("\n", stdout
);
6722 if (conflicts_offset
!= 0 && conflictsno
!= 0)
6724 Elf32_External_Conflict
* econf32
;
6725 Elf64_External_Conflict
* econf64
;
6726 Elf32_Conflict
* iconf
;
6729 if (dynamic_symbols
== NULL
)
6731 error (_("conflict list with without table"));
6735 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
6738 error (_("Out of memory"));
6744 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
6745 econf32
, Elf32_External_Conflict
*, "conflict");
6747 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6748 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
6752 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
6753 econf64
, Elf64_External_Conflict
*, "conflict");
6755 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6756 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
6759 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
6760 puts (_(" Num: Index Value Name"));
6762 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6764 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
6766 printf ("%5u: %8lu ", cnt
, iconf
[cnt
]);
6767 print_vma (psym
->st_value
, FULL_HEX
);
6768 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
6778 get_note_type (e_type
)
6781 static char buff
[64];
6785 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
6786 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
6787 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
6788 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
6789 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
6790 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
6791 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
6792 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6793 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
6795 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
6800 /* Note that by the ELF standard, the name field is already null byte
6801 terminated, and namesz includes the terminating null byte.
6802 I.E. the value of namesz for the name "FSF" is 4.
6804 If the value of namesz is zero, there is no name present. */
6806 process_note (pnote
)
6807 Elf32_Internal_Note
* pnote
;
6809 printf (" %s\t\t0x%08lx\t%s\n",
6810 pnote
->namesz
? pnote
->namedata
: "(NONE)",
6811 pnote
->descsz
, get_note_type (pnote
->type
));
6817 process_corefile_note_segment (file
, offset
, length
)
6822 Elf_External_Note
* pnotes
;
6823 Elf_External_Note
* external
;
6829 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
6833 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"), offset
, length
);
6834 printf (_(" Owner\t\tData size\tDescription\n"));
6836 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
6838 Elf32_Internal_Note inote
;
6841 inote
.type
= BYTE_GET (external
->type
);
6842 inote
.namesz
= BYTE_GET (external
->namesz
);
6843 inote
.namedata
= external
->name
;
6844 inote
.descsz
= BYTE_GET (external
->descsz
);
6845 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
6846 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
6848 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
6850 /* Verify that name is null terminated. It appears that at least
6851 one version of Linux (RedHat 6.0) generates corefiles that don't
6852 comply with the ELF spec by failing to include the null byte in
6854 if (inote
.namedata
[inote
.namesz
] != '\0')
6856 temp
= malloc (inote
.namesz
+ 1);
6860 error (_("Out of memory\n"));
6865 strncpy (temp
, inote
.namedata
, inote
.namesz
);
6866 temp
[inote
.namesz
] = 0;
6868 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
6869 inote
.namedata
= temp
;
6872 res
&= process_note (& inote
);
6887 process_corefile_note_segments (file
)
6890 Elf_Internal_Phdr
* program_headers
;
6891 Elf_Internal_Phdr
* segment
;
6895 program_headers
= (Elf_Internal_Phdr
*) malloc
6896 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
6898 if (program_headers
== NULL
)
6900 error (_("Out of memory\n"));
6905 i
= get_32bit_program_headers (file
, program_headers
);
6907 i
= get_64bit_program_headers (file
, program_headers
);
6911 free (program_headers
);
6915 for (i
= 0, segment
= program_headers
;
6916 i
< elf_header
.e_phnum
;
6919 if (segment
->p_type
== PT_NOTE
)
6920 res
&= process_corefile_note_segment (file
,
6921 (bfd_vma
) segment
->p_offset
,
6922 (bfd_vma
) segment
->p_filesz
);
6925 free (program_headers
);
6931 process_corefile_contents (file
)
6934 /* If we have not been asked to display the notes then do nothing. */
6938 /* If file is not a core file then exit. */
6939 if (elf_header
.e_type
!= ET_CORE
)
6942 /* No program headers means no NOTE segment. */
6943 if (elf_header
.e_phnum
== 0)
6945 printf (_("No note segments present in the core file.\n"));
6949 return process_corefile_note_segments (file
);
6953 process_arch_specific (file
)
6959 switch (elf_header
.e_machine
)
6962 case EM_MIPS_RS4_BE
:
6963 return process_mips_specific (file
);
6972 get_file_header (file
)
6975 /* Read in the identity array. */
6976 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
6979 /* Determine how to read the rest of the header. */
6980 switch (elf_header
.e_ident
[EI_DATA
])
6982 default: /* fall through */
6983 case ELFDATANONE
: /* fall through */
6984 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
6985 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
6988 /* For now we only support 32 bit and 64 bit ELF files. */
6989 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
6991 /* Read in the rest of the header. */
6994 Elf32_External_Ehdr ehdr32
;
6996 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
6999 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
7000 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
7001 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
7002 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
7003 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
7004 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
7005 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
7006 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
7007 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
7008 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
7009 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
7010 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
7011 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
7015 Elf64_External_Ehdr ehdr64
;
7017 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7018 we will not be able to cope with the 64bit data found in
7019 64 ELF files. Detect this now and abort before we start
7020 overwritting things. */
7021 if (sizeof (bfd_vma
) < 8)
7023 error (_("This instance of readelf has been built without support for a\n"));
7024 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7028 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
7031 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
7032 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
7033 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
7034 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
7035 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
7036 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
7037 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
7038 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
7039 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
7040 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
7041 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
7042 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
7043 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
7050 process_file (file_name
)
7054 struct stat statbuf
;
7057 if (stat (file_name
, & statbuf
) < 0)
7059 error (_("Cannot stat input file %s.\n"), file_name
);
7063 file
= fopen (file_name
, "rb");
7066 error (_("Input file %s not found.\n"), file_name
);
7070 if (! get_file_header (file
))
7072 error (_("%s: Failed to read file header\n"), file_name
);
7077 /* Initialise per file variables. */
7078 for (i
= NUM_ELEM (version_info
); i
--;)
7079 version_info
[i
] = 0;
7081 for (i
= NUM_ELEM (dynamic_info
); i
--;)
7082 dynamic_info
[i
] = 0;
7084 /* Process the file. */
7086 printf (_("\nFile: %s\n"), file_name
);
7088 if (! process_file_header ())
7094 process_section_headers (file
);
7096 process_program_headers (file
);
7098 process_dynamic_segment (file
);
7100 process_relocs (file
);
7102 process_symbol_table (file
);
7104 process_syminfo (file
);
7106 process_version_sections (file
);
7108 process_section_contents (file
);
7110 process_corefile_contents (file
);
7112 process_arch_specific (file
);
7116 if (section_headers
)
7118 free (section_headers
);
7119 section_headers
= NULL
;
7124 free (string_table
);
7125 string_table
= NULL
;
7128 if (dynamic_strings
)
7130 free (dynamic_strings
);
7131 dynamic_strings
= NULL
;
7134 if (dynamic_symbols
)
7136 free (dynamic_symbols
);
7137 dynamic_symbols
= NULL
;
7138 num_dynamic_syms
= 0;
7141 if (dynamic_syminfo
)
7143 free (dynamic_syminfo
);
7144 dynamic_syminfo
= NULL
;
7148 #ifdef SUPPORT_DISASSEMBLY
7149 /* Needed by the i386 disassembler. For extra credit, someone could
7150 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7154 print_address (unsigned int addr
, FILE * outfile
)
7156 fprintf (outfile
,"0x%8.8x", addr
);
7159 /* Needed by the i386 disassembler. */
7161 db_task_printsym (unsigned int addr
)
7163 print_address (addr
, stderr
);
7172 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7173 setlocale (LC_MESSAGES
, "");
7175 bindtextdomain (PACKAGE
, LOCALEDIR
);
7176 textdomain (PACKAGE
);
7178 parse_args (argc
, argv
);
7180 if (optind
< (argc
- 1))
7183 while (optind
< argc
)
7184 process_file (argv
[optind
++]);
7186 if (dump_sects
!= NULL
)