1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 99, 2000 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we belive that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
56 #include "elf/alpha.h"
59 #include "elf/sparc.h"
64 #include "elf/mn10200.h"
65 #include "elf/mn10300.h"
69 #include "elf/mcore.h"
80 char * program_name
= "readelf";
81 unsigned int dynamic_addr
;
82 bfd_size_type dynamic_size
;
83 unsigned int rela_addr
;
84 unsigned int rela_size
;
85 char * dynamic_strings
;
87 unsigned long num_dynamic_syms
;
88 Elf_Internal_Sym
* dynamic_symbols
;
89 Elf_Internal_Syminfo
* dynamic_syminfo
;
90 unsigned long dynamic_syminfo_offset
;
91 unsigned int dynamic_syminfo_nent
;
92 char program_interpreter
[64];
93 int dynamic_info
[DT_JMPREL
+ 1];
96 Elf_Internal_Ehdr elf_header
;
97 Elf_Internal_Shdr
* section_headers
;
98 Elf_Internal_Dyn
* dynamic_segment
;
105 int do_using_dynamic
;
112 int do_debug_abbrevs
;
114 int do_debug_pubnames
;
115 int do_debug_aranges
;
121 /* A dynamic array of flags indicating which sections require dumping. */
122 char * dump_sects
= NULL
;
123 unsigned int num_dump_sects
= 0;
125 #define HEX_DUMP (1 << 0)
126 #define DISASS_DUMP (1 << 1)
127 #define DEBUG_DUMP (1 << 2)
129 /* How to rpint a vma value. */
130 typedef enum print_mode
142 /* Forward declarations for dumb compilers. */
143 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
144 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
145 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
146 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
147 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
148 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
149 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
150 static const char * get_dynamic_type
PARAMS ((unsigned long));
151 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
152 static char * get_file_type
PARAMS ((unsigned));
153 static char * get_machine_name
PARAMS ((unsigned));
154 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
155 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
156 static const char * get_mips_segment_type
PARAMS ((unsigned long));
157 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
158 static const char * get_segment_type
PARAMS ((unsigned long));
159 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
160 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
161 static const char * get_section_type_name
PARAMS ((unsigned int));
162 static const char * get_symbol_binding
PARAMS ((unsigned int));
163 static const char * get_symbol_type
PARAMS ((unsigned int));
164 static const char * get_symbol_visibility
PARAMS ((unsigned int));
165 static const char * get_symbol_index_type
PARAMS ((unsigned int));
166 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
167 static void usage
PARAMS ((void));
168 static void parse_args
PARAMS ((int, char **));
169 static int process_file_header
PARAMS ((void));
170 static int process_program_headers
PARAMS ((FILE *));
171 static int process_section_headers
PARAMS ((FILE *));
172 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
173 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
174 static int process_dynamic_segment
PARAMS ((FILE *));
175 static int process_symbol_table
PARAMS ((FILE *));
176 static int process_section_contents
PARAMS ((FILE *));
177 static void process_file
PARAMS ((char *));
178 static int process_relocs
PARAMS ((FILE *));
179 static int process_version_sections
PARAMS ((FILE *));
180 static char * get_ver_flags
PARAMS ((unsigned int));
181 static int get_32bit_section_headers
PARAMS ((FILE *));
182 static int get_64bit_section_headers
PARAMS ((FILE *));
183 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
184 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
185 static int get_file_header
PARAMS ((FILE *));
186 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
187 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
188 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
189 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
190 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
191 #ifdef SUPPORT_DISASSEMBLY
192 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
194 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
195 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
196 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
197 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
198 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
199 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
200 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
201 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
202 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
203 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
204 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
205 static void reset_state_machine
PARAMS ((int));
206 static char * get_TAG_name
PARAMS ((unsigned long));
207 static char * get_AT_name
PARAMS ((unsigned long));
208 static char * get_FORM_name
PARAMS ((unsigned long));
209 static void free_abbrevs
PARAMS ((void));
210 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
211 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
212 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
213 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
214 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
215 static void request_dump
PARAMS ((unsigned int, char));
216 static const char * get_elf_class
PARAMS ((unsigned char));
217 static const char * get_data_encoding
PARAMS ((unsigned char));
218 static const char * get_osabi_name
PARAMS ((unsigned char));
219 static int guess_is_rela
PARAMS ((unsigned long));
220 static char * get_note_type
PARAMS ((unsigned int));
221 static int process_note
PARAMS ((Elf32_Internal_Note
*));
222 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
223 static int process_corefile_note_segments
PARAMS ((FILE *));
224 static int process_corefile_contents
PARAMS ((FILE *));
226 typedef int Elf32_Word
;
234 #define SECTION_NAME(X) (string_table + (X)->sh_name)
236 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
238 #define BYTE_GET(field) byte_get (field, sizeof (field))
240 /* If we can support a 64 bit data type then BFD64 should be defined
241 and sizeof (bfd_vma) == 8. In this case when translating from an
242 external 8 byte field to an internal field, we can assume that the
243 internal field is also 8 bytes wide and so we can extact all the data.
244 If, however, BFD64 is not defined, then we must assume that the
245 internal data structure only has 4 byte wide fields that are the
246 equivalent of the 8 byte wide external counterparts, and so we must
247 truncate the data. */
249 #define BYTE_GET8(field) byte_get (field, -8)
251 #define BYTE_GET8(field) byte_get (field, 8)
254 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
256 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
257 if (fseek (file, offset, SEEK_SET)) \
259 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
263 var = (type) malloc (size); \
267 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
271 if (fread (var, size, 1, file) != 1) \
273 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
280 #define GET_DATA(offset, var, reason) \
281 if (fseek (file, offset, SEEK_SET)) \
283 error (_("Unable to seek to %x for %s\n"), offset, reason); \
286 else if (fread (& var, sizeof (var), 1, file) != 1) \
288 error (_("Unable to read data at %x for %s\n"), offset, reason); \
292 #define GET_ELF_SYMBOLS(file, offset, size) \
293 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
294 : get_64bit_elf_symbols (file, offset, size))
297 #ifdef ANSI_PROTOTYPES
299 error (const char * message
, ...)
303 fprintf (stderr
, _("%s: Error: "), program_name
);
304 va_start (args
, message
);
305 vfprintf (stderr
, message
, args
);
311 warn (const char * message
, ...)
315 fprintf (stderr
, _("%s: Warning: "), program_name
);
316 va_start (args
, message
);
317 vfprintf (stderr
, message
, args
);
329 fprintf (stderr
, _("%s: Error: "), program_name
);
331 message
= va_arg (args
, char *);
332 vfprintf (stderr
, message
, args
);
344 fprintf (stderr
, _("%s: Warning: "), program_name
);
346 message
= va_arg (args
, char *);
347 vfprintf (stderr
, message
, args
);
354 byte_get_little_endian (field
, size
)
355 unsigned char * field
;
364 return ((unsigned int) (field
[0]))
365 | (((unsigned int) (field
[1])) << 8);
368 /* We want to extract data from an 8 byte wide field and
369 place it into a 4 byte wide field. Since this is a little
370 endian source we can juts use the 4 byte extraction code. */
373 return ((unsigned long) (field
[0]))
374 | (((unsigned long) (field
[1])) << 8)
375 | (((unsigned long) (field
[2])) << 16)
376 | (((unsigned long) (field
[3])) << 24);
380 /* This is a special case, generated by the BYTE_GET8 macro.
381 It means that we are loading an 8 byte value from a field
382 in an external structure into an 8 byte value in a field
383 in an internal strcuture. */
384 return ((bfd_vma
) (field
[0]))
385 | (((bfd_vma
) (field
[1])) << 8)
386 | (((bfd_vma
) (field
[2])) << 16)
387 | (((bfd_vma
) (field
[3])) << 24)
388 | (((bfd_vma
) (field
[4])) << 32)
389 | (((bfd_vma
) (field
[5])) << 40)
390 | (((bfd_vma
) (field
[6])) << 48)
391 | (((bfd_vma
) (field
[7])) << 56);
394 error (_("Unhandled data length: %d\n"), size
);
399 /* Print a VMA value. */
401 print_vma (vma
, mode
)
411 case FULL_HEX
: printf ("0x"); /* drop through */
412 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
413 case PREFIX_HEX
: printf ("0x"); /* drop through */
414 case HEX
: printf ("%lx", (unsigned long) vma
); break;
415 case DEC
: printf ("%ld", (unsigned long) vma
); break;
416 case DEC_5
: printf ("%5ld", (long) vma
); break;
417 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
438 #if BFD_HOST_64BIT_LONG
441 if (_bfd_int64_high (vma
))
442 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
444 printf ("%lx", _bfd_int64_low (vma
));
449 #if BFD_HOST_64BIT_LONG
452 if (_bfd_int64_high (vma
))
454 printf ("++%ld", _bfd_int64_low (vma
));
456 printf ("%ld", _bfd_int64_low (vma
));
461 #if BFD_HOST_64BIT_LONG
462 printf ("%5ld", vma
);
464 if (_bfd_int64_high (vma
))
466 printf ("++%ld", _bfd_int64_low (vma
));
468 printf ("%5ld", _bfd_int64_low (vma
));
473 #if BFD_HOST_64BIT_LONG
476 if (_bfd_int64_high (vma
))
478 printf ("++%lu", _bfd_int64_low (vma
));
480 printf ("%lu", _bfd_int64_low (vma
));
489 byte_get_big_endian (field
, size
)
490 unsigned char * field
;
499 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
502 return ((unsigned long) (field
[3]))
503 | (((unsigned long) (field
[2])) << 8)
504 | (((unsigned long) (field
[1])) << 16)
505 | (((unsigned long) (field
[0])) << 24);
508 /* Although we are extracing data from an 8 byte wide field, we
509 are returning only 4 bytes of data. */
510 return ((unsigned long) (field
[7]))
511 | (((unsigned long) (field
[6])) << 8)
512 | (((unsigned long) (field
[5])) << 16)
513 | (((unsigned long) (field
[4])) << 24);
517 /* This is a special case, generated by the BYTE_GET8 macro.
518 It means that we are loading an 8 byte value from a field
519 in an external structure into an 8 byte value in a field
520 in an internal strcuture. */
521 return ((bfd_vma
) (field
[7]))
522 | (((bfd_vma
) (field
[6])) << 8)
523 | (((bfd_vma
) (field
[5])) << 16)
524 | (((bfd_vma
) (field
[4])) << 24)
525 | (((bfd_vma
) (field
[3])) << 32)
526 | (((bfd_vma
) (field
[2])) << 40)
527 | (((bfd_vma
) (field
[1])) << 48)
528 | (((bfd_vma
) (field
[0])) << 56);
532 error (_("Unhandled data length: %d\n"), size
);
538 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
540 guess_is_rela (e_machine
)
541 unsigned long e_machine
;
545 /* Targets that use REL relocations. */
556 /* Targets that use RELA relocations. */
564 case EM_CYGNUS_MN10200
:
565 case EM_CYGNUS_MN10300
:
595 warn (_("Don't know about relocations on this machine architecture\n"));
600 /* Display the contents of the relocation data found at the specified offset. */
602 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
604 unsigned long rel_offset
;
605 unsigned long rel_size
;
606 Elf_Internal_Sym
* symtab
;
612 Elf_Internal_Rel
* rels
;
613 Elf_Internal_Rela
* relas
;
616 if (is_rela
== UNKNOWN
)
617 is_rela
= guess_is_rela (elf_header
.e_machine
);
623 Elf32_External_Rela
* erelas
;
625 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
626 Elf32_External_Rela
*, "relocs");
628 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
630 relas
= (Elf_Internal_Rela
*)
631 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
635 error(_("out of memory parsing relocs"));
639 for (i
= 0; i
< rel_size
; i
++)
641 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
642 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
643 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
648 rels
= (Elf_Internal_Rel
*) relas
;
652 Elf64_External_Rela
* erelas
;
654 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
655 Elf64_External_Rela
*, "relocs");
657 rel_size
= rel_size
/ sizeof (Elf64_External_Rela
);
659 relas
= (Elf_Internal_Rela
*)
660 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
664 error(_("out of memory parsing relocs"));
668 for (i
= 0; i
< rel_size
; i
++)
670 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
671 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
672 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
677 rels
= (Elf_Internal_Rel
*) relas
;
684 Elf32_External_Rel
* erels
;
686 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
687 Elf32_External_Rel
*, "relocs");
689 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
691 rels
= (Elf_Internal_Rel
*)
692 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
696 error(_("out of memory parsing relocs"));
700 for (i
= 0; i
< rel_size
; i
++)
702 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
703 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
708 relas
= (Elf_Internal_Rela
*) rels
;
712 Elf64_External_Rel
* erels
;
714 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
715 Elf64_External_Rel
*, "relocs");
717 rel_size
= rel_size
/ sizeof (Elf64_External_Rel
);
719 rels
= (Elf_Internal_Rel
*)
720 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
724 error(_("out of memory parsing relocs"));
728 for (i
= 0; i
< rel_size
; i
++)
730 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
731 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
736 relas
= (Elf_Internal_Rela
*) rels
;
742 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
745 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
747 for (i
= 0; i
< rel_size
; i
++)
752 bfd_vma symtab_index
;
757 offset
= relas
[i
].r_offset
;
758 info
= relas
[i
].r_info
;
762 offset
= rels
[i
].r_offset
;
763 info
= rels
[i
].r_info
;
768 type
= ELF32_R_TYPE (info
);
769 symtab_index
= ELF32_R_SYM (info
);
773 if (elf_header
.e_machine
== EM_SPARCV9
)
774 type
= ELF64_R_TYPE_ID (info
);
776 type
= ELF64_R_TYPE (info
);
777 /* The #ifdef BFD64 below is to prevent a compile time warning.
778 We know that if we do not have a 64 bit data type that we
779 will never execute this code anyway. */
781 symtab_index
= ELF64_R_SYM (info
);
785 #ifdef _bfd_int64_low
786 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
788 printf (" %8.8lx %5.5lx ", offset
, info
);
791 switch (elf_header
.e_machine
)
798 rtype
= elf_m32r_reloc_type (type
);
803 rtype
= elf_i386_reloc_type (type
);
807 rtype
= elf_m68k_reloc_type (type
);
811 rtype
= elf_i960_reloc_type (type
);
815 rtype
= elf_avr_reloc_type (type
);
822 rtype
= elf_sparc_reloc_type (type
);
826 rtype
= v850_reloc_type (type
);
830 rtype
= elf_d10v_reloc_type (type
);
834 rtype
= elf_d30v_reloc_type (type
);
838 rtype
= elf_sh_reloc_type (type
);
841 case EM_CYGNUS_MN10300
:
842 rtype
= elf_mn10300_reloc_type (type
);
845 case EM_CYGNUS_MN10200
:
846 rtype
= elf_mn10200_reloc_type (type
);
850 rtype
= elf_fr30_reloc_type (type
);
854 rtype
= elf_mcore_reloc_type (type
);
858 rtype
= elf_ppc_reloc_type (type
);
863 rtype
= elf_mips_reloc_type (type
);
867 rtype
= elf_alpha_reloc_type (type
);
871 rtype
= elf_arm_reloc_type (type
);
875 rtype
= elf_arc_reloc_type (type
);
879 rtype
= elf_hppa_reloc_type (type
);
883 rtype
= elf_pj_reloc_type (type
);
886 rtype
= elf_ia64_reloc_type (type
);
890 rtype
= elf_cris_reloc_type (type
);
894 rtype
= elf_i860_reloc_type (type
);
899 #ifdef _bfd_int64_low
900 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
902 printf (_("unrecognised: %-7lx"), type
);
905 printf ("%-21.21s", rtype
);
911 if (symtab_index
>= nsyms
)
912 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
915 Elf_Internal_Sym
* psym
;
917 psym
= symtab
+ symtab_index
;
920 print_vma (psym
->st_value
, LONG_HEX
);
923 if (psym
->st_name
== 0)
925 SECTION_NAME (section_headers
+ psym
->st_shndx
));
926 else if (strtab
== NULL
)
927 printf (_("<string table index %3ld>"), psym
->st_name
);
929 printf ("%-25.25s", strtab
+ psym
->st_name
);
932 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
938 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
939 print_vma (relas
[i
].r_addend
, LONG_HEX
);
942 if (elf_header
.e_machine
== EM_SPARCV9
943 && !strcmp (rtype
, "R_SPARC_OLO10"))
944 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
955 get_mips_dynamic_type (type
)
960 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
961 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
962 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
963 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
964 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
965 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
966 case DT_MIPS_MSYM
: return "MIPS_MSYM";
967 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
968 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
969 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
970 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
971 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
972 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
973 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
974 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
975 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
976 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
977 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
978 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
979 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
980 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
981 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
982 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
983 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
984 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
985 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
986 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
987 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
988 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
989 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
990 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
991 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
992 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
993 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
994 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
995 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
996 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
997 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
998 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
999 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1000 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1001 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1002 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1009 get_sparc64_dynamic_type (type
)
1014 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1021 get_parisc_dynamic_type (type
)
1026 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1027 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1028 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1029 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1030 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1031 case DT_HP_PREINIT
: return "HP_PREINIT";
1032 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1033 case DT_HP_NEEDED
: return "HP_NEEDED";
1034 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1035 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1036 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1037 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1038 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1045 get_dynamic_type (type
)
1048 static char buff
[32];
1052 case DT_NULL
: return "NULL";
1053 case DT_NEEDED
: return "NEEDED";
1054 case DT_PLTRELSZ
: return "PLTRELSZ";
1055 case DT_PLTGOT
: return "PLTGOT";
1056 case DT_HASH
: return "HASH";
1057 case DT_STRTAB
: return "STRTAB";
1058 case DT_SYMTAB
: return "SYMTAB";
1059 case DT_RELA
: return "RELA";
1060 case DT_RELASZ
: return "RELASZ";
1061 case DT_RELAENT
: return "RELAENT";
1062 case DT_STRSZ
: return "STRSZ";
1063 case DT_SYMENT
: return "SYMENT";
1064 case DT_INIT
: return "INIT";
1065 case DT_FINI
: return "FINI";
1066 case DT_SONAME
: return "SONAME";
1067 case DT_RPATH
: return "RPATH";
1068 case DT_SYMBOLIC
: return "SYMBOLIC";
1069 case DT_REL
: return "REL";
1070 case DT_RELSZ
: return "RELSZ";
1071 case DT_RELENT
: return "RELENT";
1072 case DT_PLTREL
: return "PLTREL";
1073 case DT_DEBUG
: return "DEBUG";
1074 case DT_TEXTREL
: return "TEXTREL";
1075 case DT_JMPREL
: return "JMPREL";
1076 case DT_BIND_NOW
: return "BIND_NOW";
1077 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1078 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1079 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1080 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1081 case DT_RUNPATH
: return "RUNPATH";
1082 case DT_FLAGS
: return "FLAGS";
1084 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1085 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1087 case DT_CHECKSUM
: return "CHECKSUM";
1088 case DT_PLTPADSZ
: return "PLTPADSZ";
1089 case DT_MOVEENT
: return "MOVEENT";
1090 case DT_MOVESZ
: return "MOVESZ";
1091 case DT_FEATURE
: return "FEATURE";
1092 case DT_POSFLAG_1
: return "POSFLAG_1";
1093 case DT_SYMINSZ
: return "SYMINSZ";
1094 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1096 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1097 case DT_CONFIG
: return "CONFIG";
1098 case DT_DEPAUDIT
: return "DEPAUDIT";
1099 case DT_AUDIT
: return "AUDIT";
1100 case DT_PLTPAD
: return "PLTPAD";
1101 case DT_MOVETAB
: return "MOVETAB";
1102 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1104 case DT_VERSYM
: return "VERSYM";
1106 case DT_RELACOUNT
: return "RELACOUNT";
1107 case DT_RELCOUNT
: return "RELCOUNT";
1108 case DT_FLAGS_1
: return "FLAGS_1";
1109 case DT_VERDEF
: return "VERDEF";
1110 case DT_VERDEFNUM
: return "VERDEFNUM";
1111 case DT_VERNEED
: return "VERNEED";
1112 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1114 case DT_AUXILIARY
: return "AUXILIARY";
1115 case DT_USED
: return "USED";
1116 case DT_FILTER
: return "FILTER";
1119 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1121 const char * result
;
1123 switch (elf_header
.e_machine
)
1126 case EM_MIPS_RS4_BE
:
1127 result
= get_mips_dynamic_type (type
);
1130 result
= get_sparc64_dynamic_type (type
);
1140 sprintf (buff
, _("Processor Specific: %lx"), type
);
1142 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1144 const char * result
;
1146 switch (elf_header
.e_machine
)
1149 result
= get_parisc_dynamic_type (type
);
1159 sprintf (buff
, _("Operating System specific: %lx"), type
);
1162 sprintf (buff
, _("<unknown>: %lx"), type
);
1169 get_file_type (e_type
)
1172 static char buff
[32];
1176 case ET_NONE
: return _("NONE (None)");
1177 case ET_REL
: return _("REL (Relocatable file)");
1178 case ET_EXEC
: return _("EXEC (Executable file)");
1179 case ET_DYN
: return _("DYN (Shared object file)");
1180 case ET_CORE
: return _("CORE (Core file)");
1183 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1184 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1185 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1186 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1188 sprintf (buff
, _("<unknown>: %x"), e_type
);
1194 get_machine_name (e_machine
)
1197 static char buff
[64]; /* XXX */
1201 case EM_NONE
: return _("None");
1202 case EM_M32
: return "WE32100";
1203 case EM_SPARC
: return "Sparc";
1204 case EM_386
: return "Intel 80386";
1205 case EM_68K
: return "MC68000";
1206 case EM_88K
: return "MC88000";
1207 case EM_486
: return "Intel 80486";
1208 case EM_860
: return "Intel 80860";
1209 case EM_MIPS
: return "MIPS R3000";
1210 case EM_S370
: return "IBM System/370";
1211 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1212 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1213 case EM_PARISC
: return "HPPA";
1214 case EM_PPC_OLD
: return "Power PC (old)";
1215 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1216 case EM_960
: return "Intel 90860";
1217 case EM_PPC
: return "PowerPC";
1218 case EM_V800
: return "NEC V800";
1219 case EM_FR20
: return "Fujitsu FR20";
1220 case EM_RH32
: return "TRW RH32";
1221 case EM_MCORE
: return "MCORE";
1222 case EM_ARM
: return "ARM";
1223 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1224 case EM_SH
: return "Hitachi SH";
1225 case EM_SPARCV9
: return "Sparc v9";
1226 case EM_TRICORE
: return "Siemens Tricore";
1227 case EM_ARC
: return "Argonaut RISC Core";
1228 case EM_H8_300
: return "Hitachi H8/300";
1229 case EM_H8_300H
: return "Hitachi H8/300H";
1230 case EM_H8S
: return "Hitachi H8S";
1231 case EM_H8_500
: return "Hitachi H8/500";
1232 case EM_IA_64
: return "Intel IA-64";
1233 case EM_MIPS_X
: return "Stanford MIPS-X";
1234 case EM_COLDFIRE
: return "Motorola Coldfire";
1235 case EM_68HC12
: return "Motorola M68HC12";
1236 case EM_ALPHA
: return "Alpha";
1237 case EM_CYGNUS_D10V
: return "d10v";
1238 case EM_CYGNUS_D30V
: return "d30v";
1239 case EM_CYGNUS_ARC
: return "Arc";
1240 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1241 case EM_CYGNUS_V850
: return "NEC v850";
1242 case EM_CYGNUS_MN10300
: return "mn10300";
1243 case EM_CYGNUS_MN10200
: return "mn10200";
1244 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1245 case EM_PJ
: return "picoJava";
1246 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1247 case EM_PCP
: return "Siemens PCP";
1248 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1249 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1250 case EM_STARCORE
: return "Motorola Star*Core processor";
1251 case EM_ME16
: return "Toyota ME16 processor";
1252 case EM_ST100
: return "STMicroelectronics ST100 processor";
1253 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1254 case EM_FX66
: return "Siemens FX66 microcontroller";
1255 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1256 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1257 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1258 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1259 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1260 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1261 case EM_SVX
: return "Silicon Graphics SVx";
1262 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1263 case EM_VAX
: return "Digital VAX";
1264 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1265 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1266 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1267 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1268 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1269 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1270 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1271 case EM_PRISM
: return "SiTera Prism";
1274 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1280 decode_ARM_machine_flags (e_flags
, buf
)
1287 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1288 e_flags
&= ~ EF_ARM_EABIMASK
;
1290 /* Handle "generic" ARM flags. */
1291 if (e_flags
& EF_ARM_RELEXEC
)
1293 strcat (buf
, ", relocatable executable");
1294 e_flags
&= ~ EF_ARM_RELEXEC
;
1297 if (e_flags
& EF_ARM_HASENTRY
)
1299 strcat (buf
, ", has entry point");
1300 e_flags
&= ~ EF_ARM_HASENTRY
;
1303 /* Now handle EABI specific flags. */
1307 strcat (buf
, ", <unknown EABI>");
1312 case EF_ARM_EABI_VER1
:
1317 /* Process flags one bit at a time. */
1318 flag
= e_flags
& - e_flags
;
1323 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_INTERWORK. */
1324 strcat (buf
, ", sorted symbol tables");
1334 case EF_ARM_EABI_UNKNOWN
:
1339 /* Process flags one bit at a time. */
1340 flag
= e_flags
& - e_flags
;
1346 strcat (buf
, ", interworking enabled");
1350 strcat (buf
, ", uses APCS/26");
1354 strcat (buf
, ", uses APCS/float");
1358 strcat (buf
, ", position independent");
1362 strcat (buf
, ", 8 bit structure alignment");
1366 strcat (buf
, ", uses new ABI");
1370 strcat (buf
, ", uses old ABI");
1374 strcat (buf
, ", software FP");
1385 strcat (buf
,", <unknown>");
1389 get_machine_flags (e_flags
, e_machine
)
1393 static char buf
[1024];
1405 decode_ARM_machine_flags (e_flags
, buf
);
1409 if (e_flags
& EF_CPU32
)
1410 strcat (buf
, ", cpu32");
1414 if (e_flags
& EF_PPC_EMB
)
1415 strcat (buf
, ", emb");
1417 if (e_flags
& EF_PPC_RELOCATABLE
)
1418 strcat (buf
, ", relocatable");
1420 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1421 strcat (buf
, ", relocatable-lib");
1424 case EM_CYGNUS_V850
:
1425 switch (e_flags
& EF_V850_ARCH
)
1428 strcat (buf
, ", v850e");
1431 strcat (buf
, ", v850ea");
1434 strcat (buf
, ", v850");
1437 strcat (buf
, ", unknown v850 architecture variant");
1442 case EM_CYGNUS_M32R
:
1443 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1444 strcat (buf
, ", m32r");
1449 case EM_MIPS_RS4_BE
:
1450 if (e_flags
& EF_MIPS_NOREORDER
)
1451 strcat (buf
, ", noreorder");
1453 if (e_flags
& EF_MIPS_PIC
)
1454 strcat (buf
, ", pic");
1456 if (e_flags
& EF_MIPS_CPIC
)
1457 strcat (buf
, ", cpic");
1459 if (e_flags
& EF_MIPS_ABI2
)
1460 strcat (buf
, ", abi2");
1462 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1463 strcat (buf
, ", mips1");
1465 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1466 strcat (buf
, ", mips2");
1468 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1469 strcat (buf
, ", mips3");
1471 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1472 strcat (buf
, ", mips4");
1474 switch ((e_flags
& EF_MIPS_MACH
))
1476 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1477 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1478 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1479 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1480 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1481 case E_MIPS_MACH_MIPS32
: strcat (buf
, ", mips32"); break;
1486 if (e_flags
& EF_SPARC_32PLUS
)
1487 strcat (buf
, ", v8+");
1489 if (e_flags
& EF_SPARC_SUN_US1
)
1490 strcat (buf
, ", ultrasparcI");
1492 if (e_flags
& EF_SPARC_SUN_US3
)
1493 strcat (buf
, ", ultrasparcIII");
1495 if (e_flags
& EF_SPARC_HAL_R1
)
1496 strcat (buf
, ", halr1");
1498 if (e_flags
& EF_SPARC_LEDATA
)
1499 strcat (buf
, ", ledata");
1501 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1502 strcat (buf
, ", tso");
1504 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1505 strcat (buf
, ", pso");
1507 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1508 strcat (buf
, ", rmo");
1512 switch (e_flags
& EF_PARISC_ARCH
)
1514 case EFA_PARISC_1_0
:
1515 strcpy (buf
, ", PA-RISC 1.0");
1517 case EFA_PARISC_1_1
:
1518 strcpy (buf
, ", PA-RISC 1.1");
1520 case EFA_PARISC_2_0
:
1521 strcpy (buf
, ", PA-RISC 2.0");
1526 if (e_flags
& EF_PARISC_TRAPNIL
)
1527 strcat (buf
, ", trapnil");
1528 if (e_flags
& EF_PARISC_EXT
)
1529 strcat (buf
, ", ext");
1530 if (e_flags
& EF_PARISC_LSB
)
1531 strcat (buf
, ", lsb");
1532 if (e_flags
& EF_PARISC_WIDE
)
1533 strcat (buf
, ", wide");
1534 if (e_flags
& EF_PARISC_NO_KABP
)
1535 strcat (buf
, ", no kabp");
1536 if (e_flags
& EF_PARISC_LAZYSWAP
)
1537 strcat (buf
, ", lazyswap");
1541 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1542 strcat (buf
, ", new calling convention");
1544 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1545 strcat (buf
, ", gnu calling convention");
1554 get_mips_segment_type (type
)
1559 case PT_MIPS_REGINFO
:
1561 case PT_MIPS_RTPROC
:
1563 case PT_MIPS_OPTIONS
:
1573 get_parisc_segment_type (type
)
1578 case PT_HP_TLS
: return "HP_TLS";
1579 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1580 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1581 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1582 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1583 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1584 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1585 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1586 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1587 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1588 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1589 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1590 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1591 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1600 get_segment_type (p_type
)
1601 unsigned long p_type
;
1603 static char buff
[32];
1607 case PT_NULL
: return "NULL";
1608 case PT_LOAD
: return "LOAD";
1609 case PT_DYNAMIC
: return "DYNAMIC";
1610 case PT_INTERP
: return "INTERP";
1611 case PT_NOTE
: return "NOTE";
1612 case PT_SHLIB
: return "SHLIB";
1613 case PT_PHDR
: return "PHDR";
1616 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1618 const char * result
;
1620 switch (elf_header
.e_machine
)
1623 case EM_MIPS_RS4_BE
:
1624 result
= get_mips_segment_type (p_type
);
1627 result
= get_parisc_segment_type (p_type
);
1637 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1639 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1641 const char * result
;
1643 switch (elf_header
.e_machine
)
1646 result
= get_parisc_segment_type (p_type
);
1656 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1659 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1666 get_mips_section_type_name (sh_type
)
1667 unsigned int sh_type
;
1671 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1672 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1673 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1674 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1675 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1676 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1677 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1678 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1679 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1680 case SHT_MIPS_RELD
: return "MIPS_RELD";
1681 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1682 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1683 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1684 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1685 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1686 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1687 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1688 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1689 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1690 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1691 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1692 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1693 case SHT_MIPS_LINE
: return "MIPS_LINE";
1694 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1695 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1696 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1697 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1698 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1699 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1700 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1701 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1702 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1703 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1704 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1705 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1706 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1707 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1708 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1709 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1717 get_parisc_section_type_name (sh_type
)
1718 unsigned int sh_type
;
1722 case SHT_PARISC_EXT
: return "PARISC_EXT";
1723 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1724 case SHT_PARISC_DOC
: return "PARISC_DOC";
1732 get_section_type_name (sh_type
)
1733 unsigned int sh_type
;
1735 static char buff
[32];
1739 case SHT_NULL
: return "NULL";
1740 case SHT_PROGBITS
: return "PROGBITS";
1741 case SHT_SYMTAB
: return "SYMTAB";
1742 case SHT_STRTAB
: return "STRTAB";
1743 case SHT_RELA
: return "RELA";
1744 case SHT_HASH
: return "HASH";
1745 case SHT_DYNAMIC
: return "DYNAMIC";
1746 case SHT_NOTE
: return "NOTE";
1747 case SHT_NOBITS
: return "NOBITS";
1748 case SHT_REL
: return "REL";
1749 case SHT_SHLIB
: return "SHLIB";
1750 case SHT_DYNSYM
: return "DYNSYM";
1751 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1752 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1753 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1754 case SHT_GROUP
: return "GROUP";
1755 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
1756 case SHT_GNU_verdef
: return "VERDEF";
1757 case SHT_GNU_verneed
: return "VERNEED";
1758 case SHT_GNU_versym
: return "VERSYM";
1759 case 0x6ffffff0: return "VERSYM";
1760 case 0x6ffffffc: return "VERDEF";
1761 case 0x7ffffffd: return "AUXILIARY";
1762 case 0x7fffffff: return "FILTER";
1765 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1767 const char * result
;
1769 switch (elf_header
.e_machine
)
1772 case EM_MIPS_RS4_BE
:
1773 result
= get_mips_section_type_name (sh_type
);
1776 result
= get_parisc_section_type_name (sh_type
);
1786 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1788 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1789 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1790 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1791 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1793 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1799 struct option options
[] =
1801 {"all", no_argument
, 0, 'a'},
1802 {"file-header", no_argument
, 0, 'h'},
1803 {"program-headers", no_argument
, 0, 'l'},
1804 {"headers", no_argument
, 0, 'e'},
1805 {"histogram", no_argument
, 0, 'I'},
1806 {"segments", no_argument
, 0, 'l'},
1807 {"sections", no_argument
, 0, 'S'},
1808 {"section-headers", no_argument
, 0, 'S'},
1809 {"symbols", no_argument
, 0, 's'},
1810 {"syms", no_argument
, 0, 's'},
1811 {"relocs", no_argument
, 0, 'r'},
1812 {"notes", no_argument
, 0, 'n'},
1813 {"dynamic", no_argument
, 0, 'd'},
1814 {"arch-specific", no_argument
, 0, 'A'},
1815 {"version-info", no_argument
, 0, 'V'},
1816 {"use-dynamic", no_argument
, 0, 'D'},
1817 {"hex-dump", required_argument
, 0, 'x'},
1818 {"debug-dump", optional_argument
, 0, 'w'},
1819 #ifdef SUPPORT_DISASSEMBLY
1820 {"instruction-dump", required_argument
, 0, 'i'},
1823 {"version", no_argument
, 0, 'v'},
1824 {"help", no_argument
, 0, 'H'},
1825 {0, no_argument
, 0, 0}
1831 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1832 fprintf (stdout
, _(" Options are:\n"));
1833 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1834 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1835 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1836 fprintf (stdout
, _(" Display the program headers\n"));
1837 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1838 fprintf (stdout
, _(" Display the sections' header\n"));
1839 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1840 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1841 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1842 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1843 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1844 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1845 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1846 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1847 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1848 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1849 fprintf (stdout
, _(" -w[liaprf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=frames]\n"));
1850 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1851 #ifdef SUPPORT_DISASSEMBLY
1852 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1853 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1855 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1856 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1857 fprintf (stdout
, _(" -H or --help Display this information\n"));
1858 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
1864 request_dump (section
, type
)
1865 unsigned int section
;
1868 if (section
>= num_dump_sects
)
1870 char * new_dump_sects
;
1872 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1874 if (new_dump_sects
== NULL
)
1875 error (_("Out of memory allocating dump request table."));
1878 /* Copy current flag settings. */
1879 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1883 dump_sects
= new_dump_sects
;
1884 num_dump_sects
= section
+ 1;
1889 dump_sects
[section
] |= type
;
1895 parse_args (argc
, argv
)
1904 while ((c
= getopt_long
1905 (argc
, argv
, "ersahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
1940 do_using_dynamic
++;
1968 section
= strtoul (optarg
, & cp
, 0);
1969 if (! * cp
&& section
>= 0)
1971 request_dump (section
, HEX_DUMP
);
1991 do_debug_abbrevs
= 1;
2001 do_debug_pubnames
= 1;
2006 do_debug_aranges
= 1;
2011 do_debug_frames
= 1;
2015 warn (_("Unrecognised debug option '%s'\n"), optarg
);
2020 #ifdef SUPPORT_DISASSEMBLY
2023 section
= strtoul (optarg
, & cp
, 0);
2024 if (! * cp
&& section
>= 0)
2026 request_dump (section
, DISASS_DUMP
);
2032 print_version (program_name
);
2039 /* xgettext:c-format */
2040 error (_("Invalid option '-%c'\n"), c
);
2047 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
2048 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2049 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2053 warn (_("Nothing to do.\n"));
2059 get_elf_class (elf_class
)
2060 unsigned char elf_class
;
2062 static char buff
[32];
2066 case ELFCLASSNONE
: return _("none");
2067 case ELFCLASS32
: return _("ELF32");
2068 case ELFCLASS64
: return _("ELF64");
2070 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2076 get_data_encoding (encoding
)
2077 unsigned char encoding
;
2079 static char buff
[32];
2083 case ELFDATANONE
: return _("none");
2084 case ELFDATA2LSB
: return _("2's complement, little endian");
2085 case ELFDATA2MSB
: return _("2's complement, big endian");
2087 sprintf (buff
, _("<unknown: %x>"), encoding
);
2093 get_osabi_name (osabi
)
2094 unsigned char osabi
;
2096 static char buff
[32];
2100 case ELFOSABI_NONE
: return _("UNIX - System V");
2101 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
2102 case ELFOSABI_NETBSD
: return _("UNIX - NetBSD");
2103 case ELFOSABI_LINUX
: return _("UNIX - Linux");
2104 case ELFOSABI_HURD
: return _("GNU/Hurd");
2105 case ELFOSABI_SOLARIS
: return _("UNIX - Solaris");
2106 case ELFOSABI_AIX
: return _("UNIX - AIX");
2107 case ELFOSABI_IRIX
: return _("UNIX - IRIX");
2108 case ELFOSABI_FREEBSD
: return _("UNIX - FreeBSD");
2109 case ELFOSABI_TRU64
: return _("UNIX - TRU64");
2110 case ELFOSABI_MODESTO
: return _("Novell - Modesto");
2111 case ELFOSABI_OPENBSD
: return _("UNIX - OpenBSD");
2112 case ELFOSABI_STANDALONE
: return _("Standalone App");
2113 case ELFOSABI_ARM
: return _("ARM");
2115 sprintf (buff
, _("<unknown: %x>"), osabi
);
2120 /* Decode the data held in 'elf_header'. */
2122 process_file_header ()
2124 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2125 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2126 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2127 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2130 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2138 printf (_("ELF Header:\n"));
2139 printf (_(" Magic: "));
2140 for (i
= 0; i
< EI_NIDENT
; i
++)
2141 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2143 printf (_(" Class: %s\n"),
2144 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2145 printf (_(" Data: %s\n"),
2146 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2147 printf (_(" Version: %d %s\n"),
2148 elf_header
.e_ident
[EI_VERSION
],
2149 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2151 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2154 printf (_(" OS/ABI: %s\n"),
2155 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2156 printf (_(" ABI Version: %d\n"),
2157 elf_header
.e_ident
[EI_ABIVERSION
]);
2158 printf (_(" Type: %s\n"),
2159 get_file_type (elf_header
.e_type
));
2160 printf (_(" Machine: %s\n"),
2161 get_machine_name (elf_header
.e_machine
));
2162 printf (_(" Version: 0x%lx\n"),
2163 (unsigned long) elf_header
.e_version
);
2165 printf (_(" Entry point address: "));
2166 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2167 printf (_("\n Start of program headers: "));
2168 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2169 printf (_(" (bytes into file)\n Start of section headers: "));
2170 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2171 printf (_(" (bytes into file)\n"));
2173 printf (_(" Flags: 0x%lx%s\n"),
2174 (unsigned long) elf_header
.e_flags
,
2175 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2176 printf (_(" Size of this header: %ld (bytes)\n"),
2177 (long) elf_header
.e_ehsize
);
2178 printf (_(" Size of program headers: %ld (bytes)\n"),
2179 (long) elf_header
.e_phentsize
);
2180 printf (_(" Number of program headers: %ld\n"),
2181 (long) elf_header
.e_phnum
);
2182 printf (_(" Size of section headers: %ld (bytes)\n"),
2183 (long) elf_header
.e_shentsize
);
2184 printf (_(" Number of section headers: %ld\n"),
2185 (long) elf_header
.e_shnum
);
2186 printf (_(" Section header string table index: %ld\n"),
2187 (long) elf_header
.e_shstrndx
);
2195 get_32bit_program_headers (file
, program_headers
)
2197 Elf_Internal_Phdr
* program_headers
;
2199 Elf32_External_Phdr
* phdrs
;
2200 Elf32_External_Phdr
* external
;
2201 Elf32_Internal_Phdr
* internal
;
2204 GET_DATA_ALLOC (elf_header
.e_phoff
,
2205 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2206 phdrs
, Elf32_External_Phdr
*, "program headers");
2208 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2209 i
< elf_header
.e_phnum
;
2210 i
++, internal
++, external
++)
2212 internal
->p_type
= BYTE_GET (external
->p_type
);
2213 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2214 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2215 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2216 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2217 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2218 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2219 internal
->p_align
= BYTE_GET (external
->p_align
);
2228 get_64bit_program_headers (file
, program_headers
)
2230 Elf_Internal_Phdr
* program_headers
;
2232 Elf64_External_Phdr
* phdrs
;
2233 Elf64_External_Phdr
* external
;
2234 Elf64_Internal_Phdr
* internal
;
2237 GET_DATA_ALLOC (elf_header
.e_phoff
,
2238 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2239 phdrs
, Elf64_External_Phdr
*, "program headers");
2241 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2242 i
< elf_header
.e_phnum
;
2243 i
++, internal
++, external
++)
2245 internal
->p_type
= BYTE_GET (external
->p_type
);
2246 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2247 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2248 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2249 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2250 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2251 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2252 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2261 process_program_headers (file
)
2264 Elf_Internal_Phdr
* program_headers
;
2265 Elf_Internal_Phdr
* segment
;
2268 if (elf_header
.e_phnum
== 0)
2271 printf (_("\nThere are no program headers in this file.\n"));
2275 if (do_segments
&& !do_header
)
2277 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2278 printf (_("Entry point "));
2279 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2280 printf (_("\nThere are %d program headers, starting at offset "),
2281 elf_header
.e_phnum
);
2282 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2286 program_headers
= (Elf_Internal_Phdr
*) malloc
2287 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2289 if (program_headers
== NULL
)
2291 error (_("Out of memory\n"));
2296 i
= get_32bit_program_headers (file
, program_headers
);
2298 i
= get_64bit_program_headers (file
, program_headers
);
2302 free (program_headers
);
2309 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2313 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2317 (_(" Type Offset VirtAddr PhysAddr\n"));
2319 (_(" FileSiz MemSiz Flags Align\n"));
2327 for (i
= 0, segment
= program_headers
;
2328 i
< elf_header
.e_phnum
;
2333 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2337 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2338 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2339 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2340 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2341 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2343 (segment
->p_flags
& PF_R
? 'R' : ' '),
2344 (segment
->p_flags
& PF_W
? 'W' : ' '),
2345 (segment
->p_flags
& PF_X
? 'E' : ' '));
2346 printf ("%#lx", (unsigned long) segment
->p_align
);
2350 print_vma (segment
->p_offset
, FULL_HEX
);
2352 print_vma (segment
->p_vaddr
, FULL_HEX
);
2354 print_vma (segment
->p_paddr
, FULL_HEX
);
2356 print_vma (segment
->p_filesz
, FULL_HEX
);
2358 print_vma (segment
->p_memsz
, FULL_HEX
);
2360 (segment
->p_flags
& PF_R
? 'R' : ' '),
2361 (segment
->p_flags
& PF_W
? 'W' : ' '),
2362 (segment
->p_flags
& PF_X
? 'E' : ' '));
2363 print_vma (segment
->p_align
, HEX
);
2367 switch (segment
->p_type
)
2371 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2372 - (segment
->p_offset
& 0xfffff000);
2377 error (_("more than one dynamic segment\n"));
2379 dynamic_addr
= segment
->p_offset
;
2380 dynamic_size
= segment
->p_filesz
;
2384 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2385 error (_("Unable to find program interpreter name\n"));
2388 program_interpreter
[0] = 0;
2389 fscanf (file
, "%63s", program_interpreter
);
2392 printf (_("\n [Requesting program interpreter: %s]"),
2393 program_interpreter
);
2399 putc ('\n', stdout
);
2408 if (do_segments
&& section_headers
!= NULL
)
2410 printf (_("\n Section to Segment mapping:\n"));
2411 printf (_(" Segment Sections...\n"));
2413 assert (string_table
!= NULL
);
2415 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2418 Elf_Internal_Shdr
* section
;
2420 segment
= program_headers
+ i
;
2421 section
= section_headers
;
2423 printf (" %2.2d ", i
);
2425 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2427 if (section
->sh_size
> 0
2428 /* Compare allocated sections by VMA, unallocated
2429 sections by file offset. */
2430 && (section
->sh_flags
& SHF_ALLOC
2431 ? (section
->sh_addr
>= segment
->p_vaddr
2432 && section
->sh_addr
+ section
->sh_size
2433 <= segment
->p_vaddr
+ segment
->p_memsz
)
2434 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2435 && (section
->sh_offset
+ section
->sh_size
2436 <= segment
->p_offset
+ segment
->p_filesz
))))
2437 printf ("%s ", SECTION_NAME (section
));
2444 free (program_headers
);
2451 get_32bit_section_headers (file
)
2454 Elf32_External_Shdr
* shdrs
;
2455 Elf32_Internal_Shdr
* internal
;
2458 GET_DATA_ALLOC (elf_header
.e_shoff
,
2459 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2460 shdrs
, Elf32_External_Shdr
*, "section headers");
2462 section_headers
= (Elf_Internal_Shdr
*) malloc
2463 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2465 if (section_headers
== NULL
)
2467 error (_("Out of memory\n"));
2471 for (i
= 0, internal
= section_headers
;
2472 i
< elf_header
.e_shnum
;
2475 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2476 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2477 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2478 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2479 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2480 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2481 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2482 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2483 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2484 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2493 get_64bit_section_headers (file
)
2496 Elf64_External_Shdr
* shdrs
;
2497 Elf64_Internal_Shdr
* internal
;
2500 GET_DATA_ALLOC (elf_header
.e_shoff
,
2501 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2502 shdrs
, Elf64_External_Shdr
*, "section headers");
2504 section_headers
= (Elf_Internal_Shdr
*) malloc
2505 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2507 if (section_headers
== NULL
)
2509 error (_("Out of memory\n"));
2513 for (i
= 0, internal
= section_headers
;
2514 i
< elf_header
.e_shnum
;
2517 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2518 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2519 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2520 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2521 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2522 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2523 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2524 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2525 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2526 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2534 static Elf_Internal_Sym
*
2535 get_32bit_elf_symbols (file
, offset
, number
)
2537 unsigned long offset
;
2538 unsigned long number
;
2540 Elf32_External_Sym
* esyms
;
2541 Elf_Internal_Sym
* isyms
;
2542 Elf_Internal_Sym
* psym
;
2545 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2546 esyms
, Elf32_External_Sym
*, "symbols");
2548 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2552 error (_("Out of memory\n"));
2558 for (j
= 0, psym
= isyms
;
2562 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2563 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2564 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2565 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2566 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2567 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2575 static Elf_Internal_Sym
*
2576 get_64bit_elf_symbols (file
, offset
, number
)
2578 unsigned long offset
;
2579 unsigned long number
;
2581 Elf64_External_Sym
* esyms
;
2582 Elf_Internal_Sym
* isyms
;
2583 Elf_Internal_Sym
* psym
;
2586 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2587 esyms
, Elf64_External_Sym
*, "symbols");
2589 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2593 error (_("Out of memory\n"));
2599 for (j
= 0, psym
= isyms
;
2603 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2604 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2605 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2606 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2607 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2608 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2617 get_elf_section_flags (sh_flags
)
2620 static char buff
[32];
2628 flag
= sh_flags
& - sh_flags
;
2633 case SHF_WRITE
: strcat (buff
, "W"); break;
2634 case SHF_ALLOC
: strcat (buff
, "A"); break;
2635 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2636 case SHF_MERGE
: strcat (buff
, "M"); break;
2637 case SHF_STRINGS
: strcat (buff
, "S"); break;
2638 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2639 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2640 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2641 case SHF_GROUP
: strcat (buff
, "G"); break;
2644 if (flag
& SHF_MASKOS
)
2647 sh_flags
&= ~ SHF_MASKOS
;
2649 else if (flag
& SHF_MASKPROC
)
2652 sh_flags
&= ~ SHF_MASKPROC
;
2664 process_section_headers (file
)
2667 Elf_Internal_Shdr
* section
;
2670 section_headers
= NULL
;
2672 if (elf_header
.e_shnum
== 0)
2675 printf (_("\nThere are no sections in this file.\n"));
2680 if (do_sections
&& !do_header
)
2681 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2682 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2686 if (! get_32bit_section_headers (file
))
2689 else if (! get_64bit_section_headers (file
))
2692 /* Read in the string table, so that we have names to display. */
2693 section
= section_headers
+ elf_header
.e_shstrndx
;
2695 if (section
->sh_size
!= 0)
2697 unsigned long string_table_offset
;
2699 string_table_offset
= section
->sh_offset
;
2701 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2702 string_table
, char *, "string table");
2705 /* Scan the sections for the dynamic symbol table
2706 and dynamic string table and debug sections. */
2707 dynamic_symbols
= NULL
;
2708 dynamic_strings
= NULL
;
2709 dynamic_syminfo
= NULL
;
2711 for (i
= 0, section
= section_headers
;
2712 i
< elf_header
.e_shnum
;
2715 char * name
= SECTION_NAME (section
);
2717 if (section
->sh_type
== SHT_DYNSYM
)
2719 if (dynamic_symbols
!= NULL
)
2721 error (_("File contains multiple dynamic symbol tables\n"));
2725 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2727 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2729 else if (section
->sh_type
== SHT_STRTAB
2730 && strcmp (name
, ".dynstr") == 0)
2732 if (dynamic_strings
!= NULL
)
2734 error (_("File contains multiple dynamic string tables\n"));
2738 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2739 dynamic_strings
, char *, "dynamic strings");
2741 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2742 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
|| do_debug_frames
)
2743 && strncmp (name
, ".debug_", 7) == 0)
2748 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2749 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2750 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2751 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2752 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2753 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
2755 request_dump (i
, DEBUG_DUMP
);
2757 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
2758 request_dump (i
, DEBUG_DUMP
);
2764 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2768 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2771 printf (_(" [Nr] Name Type Address Offset\n"));
2772 printf (_(" Size EntSize Flags Link Info Align\n"));
2775 for (i
= 0, section
= section_headers
;
2776 i
< elf_header
.e_shnum
;
2779 printf (" [%2d] %-17.17s %-15.15s ",
2781 SECTION_NAME (section
),
2782 get_section_type_name (section
->sh_type
));
2786 print_vma (section
->sh_addr
, LONG_HEX
);
2788 printf ( " %6.6lx %6.6lx %2.2lx",
2789 (unsigned long) section
->sh_offset
,
2790 (unsigned long) section
->sh_size
,
2791 (unsigned long) section
->sh_entsize
);
2793 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2795 printf ("%2ld %3lx %2ld\n",
2796 (unsigned long) section
->sh_link
,
2797 (unsigned long) section
->sh_info
,
2798 (unsigned long) section
->sh_addralign
);
2803 print_vma (section
->sh_addr
, LONG_HEX
);
2804 printf (" %8.8lx", section
->sh_offset
);
2806 print_vma (section
->sh_size
, LONG_HEX
);
2808 print_vma (section
->sh_entsize
, LONG_HEX
);
2810 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2812 printf (" %2ld %3lx %ld\n",
2813 (unsigned long) section
->sh_link
,
2814 (unsigned long) section
->sh_info
,
2815 (unsigned long) section
->sh_addralign
);
2819 printf (_("Key to Flags:\n"));
2820 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2821 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
2822 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
2827 /* Process the reloc section. */
2829 process_relocs (file
)
2832 unsigned long rel_size
;
2833 unsigned long rel_offset
;
2839 if (do_using_dynamic
)
2841 int is_rela
= FALSE
;
2846 if (dynamic_info
[DT_REL
])
2848 rel_offset
= dynamic_info
[DT_REL
];
2849 rel_size
= dynamic_info
[DT_RELSZ
];
2852 else if (dynamic_info
[DT_RELA
])
2854 rel_offset
= dynamic_info
[DT_RELA
];
2855 rel_size
= dynamic_info
[DT_RELASZ
];
2858 else if (dynamic_info
[DT_JMPREL
])
2860 rel_offset
= dynamic_info
[DT_JMPREL
];
2861 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2863 switch (dynamic_info
[DT_PLTREL
])
2880 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2881 rel_offset
, rel_size
);
2883 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2884 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
2887 printf (_("\nThere are no dynamic relocations in this file.\n"));
2891 Elf32_Internal_Shdr
* section
;
2895 for (i
= 0, section
= section_headers
;
2896 i
< elf_header
.e_shnum
;
2899 if ( section
->sh_type
!= SHT_RELA
2900 && section
->sh_type
!= SHT_REL
)
2903 rel_offset
= section
->sh_offset
;
2904 rel_size
= section
->sh_size
;
2908 Elf32_Internal_Shdr
* strsec
;
2909 Elf32_Internal_Shdr
* symsec
;
2910 Elf_Internal_Sym
* symtab
;
2913 unsigned long nsyms
;
2915 printf (_("\nRelocation section "));
2917 if (string_table
== NULL
)
2918 printf ("%d", section
->sh_name
);
2920 printf ("'%s'", SECTION_NAME (section
));
2922 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2923 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
2925 symsec
= section_headers
+ section
->sh_link
;
2927 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
2928 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
2933 strsec
= section_headers
+ symsec
->sh_link
;
2935 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2936 char *, "string table");
2938 is_rela
= section
->sh_type
== SHT_RELA
;
2940 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
2950 printf (_("\nThere are no relocations in this file.\n"));
2958 dynamic_segment_mips_val (entry
)
2959 Elf_Internal_Dyn
* entry
;
2961 switch (entry
->d_tag
)
2964 if (entry
->d_un
.d_val
== 0)
2968 static const char * opts
[] =
2970 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2971 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2972 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2973 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2978 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
2979 if (entry
->d_un
.d_val
& (1 << cnt
))
2981 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2988 case DT_MIPS_IVERSION
:
2989 if (dynamic_strings
!= NULL
)
2990 printf ("Interface Version: %s\n",
2991 dynamic_strings
+ entry
->d_un
.d_val
);
2993 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2996 case DT_MIPS_TIME_STAMP
:
3001 time_t time
= entry
->d_un
.d_val
;
3002 tmp
= gmtime (&time
);
3003 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
3004 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
3005 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
3006 printf ("Time Stamp: %s\n", timebuf
);
3010 case DT_MIPS_RLD_VERSION
:
3011 case DT_MIPS_LOCAL_GOTNO
:
3012 case DT_MIPS_CONFLICTNO
:
3013 case DT_MIPS_LIBLISTNO
:
3014 case DT_MIPS_SYMTABNO
:
3015 case DT_MIPS_UNREFEXTNO
:
3016 case DT_MIPS_HIPAGENO
:
3017 case DT_MIPS_DELTA_CLASS_NO
:
3018 case DT_MIPS_DELTA_INSTANCE_NO
:
3019 case DT_MIPS_DELTA_RELOC_NO
:
3020 case DT_MIPS_DELTA_SYM_NO
:
3021 case DT_MIPS_DELTA_CLASSSYM_NO
:
3022 case DT_MIPS_COMPACT_SIZE
:
3023 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
3027 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
3033 dynamic_segment_parisc_val (entry
)
3034 Elf_Internal_Dyn
* entry
;
3036 switch (entry
->d_tag
)
3038 case DT_HP_DLD_FLAGS
:
3047 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
3048 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
3049 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
3050 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
3051 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
3052 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
3053 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
3054 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
3055 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
3056 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
3057 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
3061 bfd_vma val
= entry
->d_un
.d_val
;
3063 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
3064 if (val
& flags
[cnt
].bit
)
3068 fputs (flags
[cnt
].str
, stdout
);
3070 val
^= flags
[cnt
].bit
;
3073 if (val
!= 0 || first
)
3077 print_vma (val
, HEX
);
3083 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
3089 get_32bit_dynamic_segment (file
)
3092 Elf32_External_Dyn
* edyn
;
3093 Elf_Internal_Dyn
* entry
;
3096 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3097 edyn
, Elf32_External_Dyn
*, "dynamic segment");
3099 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3100 how large this .dynamic is now. We can do this even before the byte
3101 swapping since the DT_NULL tag is recognizable. */
3103 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3106 dynamic_segment
= (Elf_Internal_Dyn
*)
3107 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3109 if (dynamic_segment
== NULL
)
3111 error (_("Out of memory\n"));
3116 for (i
= 0, entry
= dynamic_segment
;
3120 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
3121 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
3130 get_64bit_dynamic_segment (file
)
3133 Elf64_External_Dyn
* edyn
;
3134 Elf_Internal_Dyn
* entry
;
3137 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3138 edyn
, Elf64_External_Dyn
*, "dynamic segment");
3140 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3141 how large this .dynamic is now. We can do this even before the byte
3142 swapping since the DT_NULL tag is recognizable. */
3144 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3147 dynamic_segment
= (Elf_Internal_Dyn
*)
3148 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3150 if (dynamic_segment
== NULL
)
3152 error (_("Out of memory\n"));
3157 for (i
= 0, entry
= dynamic_segment
;
3161 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
3162 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
3171 get_dynamic_flags (flags
)
3174 static char buff
[64];
3179 flag
= flags
& - flags
;
3184 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3185 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3186 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3187 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3188 default: strcat (buff
, "unknown "); break;
3194 /* Parse and display the contents of the dynamic segment. */
3196 process_dynamic_segment (file
)
3199 Elf_Internal_Dyn
* entry
;
3202 if (dynamic_size
== 0)
3205 printf (_("\nThere is no dynamic segment in this file.\n"));
3212 if (! get_32bit_dynamic_segment (file
))
3215 else if (! get_64bit_dynamic_segment (file
))
3218 /* Find the appropriate symbol table. */
3219 if (dynamic_symbols
== NULL
)
3221 for (i
= 0, entry
= dynamic_segment
;
3225 unsigned long offset
;
3227 if (entry
->d_tag
!= DT_SYMTAB
)
3230 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3232 /* Since we do not know how big the symbol table is,
3233 we default to reading in the entire file (!) and
3234 processing that. This is overkill, I know, but it
3236 offset
= entry
->d_un
.d_val
- loadaddr
;
3238 if (fseek (file
, 0, SEEK_END
))
3239 error (_("Unable to seek to end of file!"));
3242 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3244 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3246 if (num_dynamic_syms
< 1)
3248 error (_("Unable to determine the number of symbols to load\n"));
3252 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3256 /* Similarly find a string table. */
3257 if (dynamic_strings
== NULL
)
3259 for (i
= 0, entry
= dynamic_segment
;
3263 unsigned long offset
;
3266 if (entry
->d_tag
!= DT_STRTAB
)
3269 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3271 /* Since we do not know how big the string table is,
3272 we default to reading in the entire file (!) and
3273 processing that. This is overkill, I know, but it
3276 offset
= entry
->d_un
.d_val
- loadaddr
;
3277 if (fseek (file
, 0, SEEK_END
))
3278 error (_("Unable to seek to end of file\n"));
3279 str_tab_len
= ftell (file
) - offset
;
3281 if (str_tab_len
< 1)
3284 (_("Unable to determine the length of the dynamic string table\n"));
3288 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
3289 "dynamic string table");
3295 /* And find the syminfo section if available. */
3296 if (dynamic_syminfo
== NULL
)
3298 unsigned int syminsz
= 0;
3300 for (i
= 0, entry
= dynamic_segment
;
3304 if (entry
->d_tag
== DT_SYMINENT
)
3306 /* Note: these braces are necessary to avoid a syntax
3307 error from the SunOS4 C compiler. */
3308 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3310 else if (entry
->d_tag
== DT_SYMINSZ
)
3311 syminsz
= entry
->d_un
.d_val
;
3312 else if (entry
->d_tag
== DT_SYMINFO
)
3313 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
3316 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3318 Elf_External_Syminfo
* extsyminfo
;
3319 Elf_Internal_Syminfo
* syminfo
;
3321 /* There is a syminfo section. Read the data. */
3322 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3323 Elf_External_Syminfo
*, "symbol information");
3325 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3326 if (dynamic_syminfo
== NULL
)
3328 error (_("Out of memory\n"));
3332 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3333 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3336 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3337 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3344 if (do_dynamic
&& dynamic_addr
)
3345 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3346 dynamic_addr
, (long) dynamic_size
);
3348 printf (_(" Tag Type Name/Value\n"));
3350 for (i
= 0, entry
= dynamic_segment
;
3359 print_vma (entry
->d_tag
, FULL_HEX
);
3360 dtype
= get_dynamic_type (entry
->d_tag
);
3361 printf (" (%s)%*s", dtype
,
3362 ((is_32bit_elf
? 27 : 19)
3363 - (int) strlen (dtype
)),
3367 switch (entry
->d_tag
)
3371 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
3381 switch (entry
->d_tag
)
3384 printf (_("Auxiliary library"));
3388 printf (_("Filter library"));
3392 printf (_("Configuration file"));
3396 printf (_("Dependency audit library"));
3400 printf (_("Audit library"));
3404 if (dynamic_strings
)
3405 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3409 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3418 printf (_("Flags:"));
3419 if (entry
->d_un
.d_val
== 0)
3420 printf (_(" None\n"));
3423 unsigned long int val
= entry
->d_un
.d_val
;
3424 if (val
& DTF_1_PARINIT
)
3426 printf (" PARINIT");
3427 val
^= DTF_1_PARINIT
;
3429 if (val
& DTF_1_CONFEXP
)
3431 printf (" CONFEXP");
3432 val
^= DTF_1_CONFEXP
;
3435 printf (" %lx", val
);
3444 printf (_("Flags:"));
3445 if (entry
->d_un
.d_val
== 0)
3446 printf (_(" None\n"));
3449 unsigned long int val
= entry
->d_un
.d_val
;
3450 if (val
& DF_P1_LAZYLOAD
)
3452 printf (" LAZYLOAD");
3453 val
^= DF_P1_LAZYLOAD
;
3455 if (val
& DF_P1_GROUPPERM
)
3457 printf (" GROUPPERM");
3458 val
^= DF_P1_GROUPPERM
;
3461 printf (" %lx", val
);
3470 printf (_("Flags:"));
3471 if (entry
->d_un
.d_val
== 0)
3472 printf (_(" None\n"));
3475 unsigned long int val
= entry
->d_un
.d_val
;
3481 if (val
& DF_1_GLOBAL
)
3486 if (val
& DF_1_GROUP
)
3491 if (val
& DF_1_NODELETE
)
3493 printf (" NODELETE");
3494 val
^= DF_1_NODELETE
;
3496 if (val
& DF_1_LOADFLTR
)
3498 printf (" LOADFLTR");
3499 val
^= DF_1_LOADFLTR
;
3501 if (val
& DF_1_INITFIRST
)
3503 printf (" INITFIRST");
3504 val
^= DF_1_INITFIRST
;
3506 if (val
& DF_1_NOOPEN
)
3511 if (val
& DF_1_ORIGIN
)
3516 if (val
& DF_1_DIRECT
)
3521 if (val
& DF_1_TRANS
)
3526 if (val
& DF_1_INTERPOSE
)
3528 printf (" INTERPOSE");
3529 val
^= DF_1_INTERPOSE
;
3531 if (val
& DF_1_NODEFLIB
)
3533 printf (" NODEFLIB");
3534 val
^= DF_1_NODEFLIB
;
3536 if (val
& DF_1_NODUMP
)
3541 if (val
& DF_1_CONLFAT
)
3543 printf (" CONLFAT");
3544 val
^= DF_1_CONLFAT
;
3547 printf (" %lx", val
);
3555 puts (get_dynamic_type (entry
->d_un
.d_val
));
3575 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
3581 if (dynamic_strings
== NULL
)
3584 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3588 switch (entry
->d_tag
)
3591 printf (_("Shared library: [%s]"), name
);
3593 if (strcmp (name
, program_interpreter
) == 0)
3594 printf (_(" program interpreter"));
3598 printf (_("Library soname: [%s]"), name
);
3602 printf (_("Library rpath: [%s]"), name
);
3606 printf (_("Library runpath: [%s]"), name
);
3610 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3615 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3631 case DT_INIT_ARRAYSZ
:
3632 case DT_FINI_ARRAYSZ
:
3635 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3636 printf (" (bytes)\n");
3646 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3659 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
3663 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3667 printf (_("Not needed object: [%s]\n"), name
);
3672 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3678 /* The value of this entry is ignored. */
3682 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
3683 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
3688 switch (elf_header
.e_machine
)
3691 case EM_MIPS_RS4_BE
:
3692 dynamic_segment_mips_val (entry
);
3695 dynamic_segment_parisc_val (entry
);
3698 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3710 get_ver_flags (flags
)
3713 static char buff
[32];
3720 if (flags
& VER_FLG_BASE
)
3721 strcat (buff
, "BASE ");
3723 if (flags
& VER_FLG_WEAK
)
3725 if (flags
& VER_FLG_BASE
)
3726 strcat (buff
, "| ");
3728 strcat (buff
, "WEAK ");
3731 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
3732 strcat (buff
, "| <unknown>");
3737 /* Display the contents of the version sections. */
3739 process_version_sections (file
)
3742 Elf32_Internal_Shdr
* section
;
3749 for (i
= 0, section
= section_headers
;
3750 i
< elf_header
.e_shnum
;
3753 switch (section
->sh_type
)
3755 case SHT_GNU_verdef
:
3757 Elf_External_Verdef
* edefs
;
3764 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3765 SECTION_NAME (section
), section
->sh_info
);
3767 printf (_(" Addr: 0x"));
3768 printf_vma (section
->sh_addr
);
3769 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3770 (unsigned long) section
->sh_offset
, section
->sh_link
,
3771 SECTION_NAME (section_headers
+ section
->sh_link
));
3773 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3774 edefs
, Elf_External_Verdef
*,
3775 "version definition section");
3777 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
3780 Elf_External_Verdef
* edef
;
3781 Elf_Internal_Verdef ent
;
3782 Elf_External_Verdaux
* eaux
;
3783 Elf_Internal_Verdaux aux
;
3787 vstart
= ((char *) edefs
) + idx
;
3789 edef
= (Elf_External_Verdef
*) vstart
;
3791 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
3792 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
3793 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
3794 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
3795 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
3796 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
3797 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
3799 printf (_(" %#06x: Rev: %d Flags: %s"),
3800 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
3802 printf (_(" Index: %d Cnt: %d "),
3803 ent
.vd_ndx
, ent
.vd_cnt
);
3805 vstart
+= ent
.vd_aux
;
3807 eaux
= (Elf_External_Verdaux
*) vstart
;
3809 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3810 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3812 if (dynamic_strings
)
3813 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
3815 printf (_("Name index: %ld\n"), aux
.vda_name
);
3817 isum
= idx
+ ent
.vd_aux
;
3819 for (j
= 1; j
< ent
.vd_cnt
; j
++)
3821 isum
+= aux
.vda_next
;
3822 vstart
+= aux
.vda_next
;
3824 eaux
= (Elf_External_Verdaux
*) vstart
;
3826 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3827 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3829 if (dynamic_strings
)
3830 printf (_(" %#06x: Parent %d: %s\n"),
3831 isum
, j
, dynamic_strings
+ aux
.vda_name
);
3833 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3834 isum
, j
, aux
.vda_name
);
3844 case SHT_GNU_verneed
:
3846 Elf_External_Verneed
* eneed
;
3852 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3853 SECTION_NAME (section
), section
->sh_info
);
3855 printf (_(" Addr: 0x"));
3856 printf_vma (section
->sh_addr
);
3857 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3858 (unsigned long) section
->sh_offset
, section
->sh_link
,
3859 SECTION_NAME (section_headers
+ section
->sh_link
));
3861 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3862 eneed
, Elf_External_Verneed
*,
3863 "version need section");
3865 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
3867 Elf_External_Verneed
* entry
;
3868 Elf_Internal_Verneed ent
;
3873 vstart
= ((char *) eneed
) + idx
;
3875 entry
= (Elf_External_Verneed
*) vstart
;
3877 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
3878 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
3879 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
3880 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
3881 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
3883 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
3885 if (dynamic_strings
)
3886 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
3888 printf (_(" File: %lx"), ent
.vn_file
);
3890 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
3892 vstart
+= ent
.vn_aux
;
3894 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
3896 Elf_External_Vernaux
* eaux
;
3897 Elf_Internal_Vernaux aux
;
3899 eaux
= (Elf_External_Vernaux
*) vstart
;
3901 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
3902 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
3903 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
3904 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
3905 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
3907 if (dynamic_strings
)
3908 printf (_(" %#06x: Name: %s"),
3909 isum
, dynamic_strings
+ aux
.vna_name
);
3911 printf (_(" %#06x: Name index: %lx"),
3912 isum
, aux
.vna_name
);
3914 printf (_(" Flags: %s Version: %d\n"),
3915 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
3917 isum
+= aux
.vna_next
;
3918 vstart
+= aux
.vna_next
;
3928 case SHT_GNU_versym
:
3930 Elf32_Internal_Shdr
* link_section
;
3933 unsigned char * edata
;
3934 unsigned short * data
;
3936 Elf_Internal_Sym
* symbols
;
3937 Elf32_Internal_Shdr
* string_sec
;
3939 link_section
= section_headers
+ section
->sh_link
;
3940 total
= section
->sh_size
/ section
->sh_entsize
;
3944 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
3945 link_section
->sh_size
/ link_section
->sh_entsize
);
3947 string_sec
= section_headers
+ link_section
->sh_link
;
3949 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3950 strtab
, char *, "version string table");
3952 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3953 SECTION_NAME (section
), total
);
3955 printf (_(" Addr: "));
3956 printf_vma (section
->sh_addr
);
3957 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3958 (unsigned long) section
->sh_offset
, section
->sh_link
,
3959 SECTION_NAME (link_section
));
3961 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3963 total
* sizeof (short), edata
,
3964 unsigned char *, "version symbol data");
3966 data
= (unsigned short *) malloc (total
* sizeof (short));
3968 for (cnt
= total
; cnt
--;)
3969 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
3974 for (cnt
= 0; cnt
< total
; cnt
+= 4)
3979 printf (" %03x:", cnt
);
3981 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
3982 switch (data
[cnt
+ j
])
3985 fputs (_(" 0 (*local*) "), stdout
);
3989 fputs (_(" 1 (*global*) "), stdout
);
3993 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
3994 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
3996 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
3997 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
4000 /* We must test both. */
4001 Elf_Internal_Verneed ivn
;
4002 unsigned long offset
;
4004 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4009 Elf_External_Verneed evn
;
4010 Elf_External_Vernaux evna
;
4011 Elf_Internal_Vernaux ivna
;
4012 unsigned long vna_off
;
4014 GET_DATA (offset
, evn
, "version need");
4016 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4017 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4019 vna_off
= offset
+ ivn
.vn_aux
;
4023 GET_DATA (vna_off
, evna
,
4024 "version need aux (1)");
4026 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4027 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4029 vna_off
+= ivna
.vna_next
;
4031 while (ivna
.vna_other
!= data
[cnt
+ j
]
4032 && ivna
.vna_next
!= 0);
4034 if (ivna
.vna_other
== data
[cnt
+ j
])
4036 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4038 name
= strtab
+ ivna
.vna_name
;
4039 nn
+= printf ("(%s%-*s",
4041 12 - (int) strlen (name
),
4045 else if (ivn
.vn_next
== 0)
4047 if (data
[cnt
+ j
] != 0x8001)
4049 Elf_Internal_Verdef ivd
;
4050 Elf_External_Verdef evd
;
4052 offset
= version_info
4053 [DT_VERSIONTAGIDX (DT_VERDEF
)]
4058 GET_DATA (offset
, evd
,
4059 "version definition");
4061 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4062 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4064 offset
+= ivd
.vd_next
;
4067 != (data
[cnt
+ j
] & 0x7fff)
4068 && ivd
.vd_next
!= 0);
4071 == (data
[cnt
+ j
] & 0x7fff))
4073 Elf_External_Verdaux evda
;
4074 Elf_Internal_Verdaux ivda
;
4076 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4078 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
4079 "version definition aux");
4082 BYTE_GET (evda
.vda_name
);
4084 name
= strtab
+ ivda
.vda_name
;
4088 12 - (int) strlen (name
),
4096 offset
+= ivn
.vn_next
;
4098 while (ivn
.vn_next
);
4100 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
4102 Elf_Internal_Verneed ivn
;
4103 unsigned long offset
;
4105 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4110 Elf_Internal_Vernaux ivna
;
4111 Elf_External_Verneed evn
;
4112 Elf_External_Vernaux evna
;
4113 unsigned long a_off
;
4115 GET_DATA (offset
, evn
, "version need");
4117 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4118 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4120 a_off
= offset
+ ivn
.vn_aux
;
4124 GET_DATA (a_off
, evna
,
4125 "version need aux (2)");
4127 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4128 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4130 a_off
+= ivna
.vna_next
;
4132 while (ivna
.vna_other
!= data
[cnt
+ j
]
4133 && ivna
.vna_next
!= 0);
4135 if (ivna
.vna_other
== data
[cnt
+ j
])
4137 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4139 name
= strtab
+ ivna
.vna_name
;
4140 nn
+= printf ("(%s%-*s",
4142 12 - (int) strlen (name
),
4147 offset
+= ivn
.vn_next
;
4149 while (ivn
.vn_next
);
4151 else if (data
[cnt
+ j
] != 0x8001)
4153 Elf_Internal_Verdef ivd
;
4154 Elf_External_Verdef evd
;
4155 unsigned long offset
;
4157 offset
= version_info
4158 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
4162 GET_DATA (offset
, evd
, "version def");
4164 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4165 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4167 offset
+= ivd
.vd_next
;
4169 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
4170 && ivd
.vd_next
!= 0);
4172 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
4174 Elf_External_Verdaux evda
;
4175 Elf_Internal_Verdaux ivda
;
4177 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4179 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
4180 evda
, "version def aux");
4182 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4184 name
= strtab
+ ivda
.vda_name
;
4185 nn
+= printf ("(%s%-*s",
4187 12 - (int) strlen (name
),
4193 printf ("%*c", 18 - nn
, ' ');
4211 printf (_("\nNo version information found in this file.\n"));
4217 get_symbol_binding (binding
)
4218 unsigned int binding
;
4220 static char buff
[32];
4224 case STB_LOCAL
: return "LOCAL";
4225 case STB_GLOBAL
: return "GLOBAL";
4226 case STB_WEAK
: return "WEAK";
4228 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4229 sprintf (buff
, _("<processor specific>: %d"), binding
);
4230 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4231 sprintf (buff
, _("<OS specific>: %d"), binding
);
4233 sprintf (buff
, _("<unknown>: %d"), binding
);
4239 get_symbol_type (type
)
4242 static char buff
[32];
4246 case STT_NOTYPE
: return "NOTYPE";
4247 case STT_OBJECT
: return "OBJECT";
4248 case STT_FUNC
: return "FUNC";
4249 case STT_SECTION
: return "SECTION";
4250 case STT_FILE
: return "FILE";
4251 case STT_COMMON
: return "COMMON";
4253 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4255 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4256 return "THUMB_FUNC";
4258 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4261 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4262 return "PARISC_MILLI";
4264 sprintf (buff
, _("<processor specific>: %d"), type
);
4266 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4268 if (elf_header
.e_machine
== EM_PARISC
)
4270 if (type
== STT_HP_OPAQUE
)
4272 if (type
== STT_HP_STUB
)
4276 sprintf (buff
, _("<OS specific>: %d"), type
);
4279 sprintf (buff
, _("<unknown>: %d"), type
);
4285 get_symbol_visibility (visibility
)
4286 unsigned int visibility
;
4290 case STV_DEFAULT
: return "DEFAULT";
4291 case STV_INTERNAL
: return "INTERNAL";
4292 case STV_HIDDEN
: return "HIDDEN";
4293 case STV_PROTECTED
: return "PROTECTED";
4299 get_symbol_index_type (type
)
4304 case SHN_UNDEF
: return "UND";
4305 case SHN_ABS
: return "ABS";
4306 case SHN_COMMON
: return "COM";
4308 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4310 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4312 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4316 static char buff
[32];
4318 sprintf (buff
, "%3d", type
);
4325 get_dynamic_data (file
, number
)
4327 unsigned int number
;
4329 unsigned char * e_data
;
4332 e_data
= (unsigned char *) malloc (number
* 4);
4336 error (_("Out of memory\n"));
4340 if (fread (e_data
, 4, number
, file
) != number
)
4342 error (_("Unable to read in dynamic data\n"));
4346 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4350 error (_("Out of memory\n"));
4356 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4363 /* Dump the symbol table */
4365 process_symbol_table (file
)
4368 Elf32_Internal_Shdr
* section
;
4369 unsigned char nb
[4];
4370 unsigned char nc
[4];
4373 int * buckets
= NULL
;
4374 int * chains
= NULL
;
4376 if (! do_syms
&& !do_histogram
)
4379 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
4382 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
4384 error (_("Unable to seek to start of dynamic information"));
4388 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4390 error (_("Failed to read in number of buckets\n"));
4394 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4396 error (_("Failed to read in number of chains\n"));
4400 nbuckets
= byte_get (nb
, 4);
4401 nchains
= byte_get (nc
, 4);
4403 buckets
= get_dynamic_data (file
, nbuckets
);
4404 chains
= get_dynamic_data (file
, nchains
);
4406 if (buckets
== NULL
|| chains
== NULL
)
4411 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4416 printf (_("\nSymbol table for image:\n"));
4418 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4420 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4422 for (hn
= 0; hn
< nbuckets
; hn
++)
4427 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4429 Elf_Internal_Sym
* psym
;
4431 psym
= dynamic_symbols
+ si
;
4433 printf (" %3d %3d: ", si
, hn
);
4434 print_vma (psym
->st_value
, LONG_HEX
);
4436 print_vma (psym
->st_size
, DEC_5
);
4438 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4439 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4440 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4441 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
4442 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4446 else if (do_syms
&& !do_using_dynamic
)
4450 for (i
= 0, section
= section_headers
;
4451 i
< elf_header
.e_shnum
;
4456 Elf_Internal_Sym
* symtab
;
4457 Elf_Internal_Sym
* psym
;
4460 if ( section
->sh_type
!= SHT_SYMTAB
4461 && section
->sh_type
!= SHT_DYNSYM
)
4464 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4465 SECTION_NAME (section
),
4466 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4468 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4470 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4472 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4473 section
->sh_size
/ section
->sh_entsize
);
4477 if (section
->sh_link
== elf_header
.e_shstrndx
)
4478 strtab
= string_table
;
4481 Elf32_Internal_Shdr
* string_sec
;
4483 string_sec
= section_headers
+ section
->sh_link
;
4485 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4486 strtab
, char *, "string table");
4489 for (si
= 0, psym
= symtab
;
4490 si
< section
->sh_size
/ section
->sh_entsize
;
4493 printf ("%6d: ", si
);
4494 print_vma (psym
->st_value
, LONG_HEX
);
4496 print_vma (psym
->st_size
, DEC_5
);
4497 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4498 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4499 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4500 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
4501 printf (" %s", strtab
+ psym
->st_name
);
4503 if (section
->sh_type
== SHT_DYNSYM
&&
4504 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
4506 unsigned char data
[2];
4507 unsigned short vers_data
;
4508 unsigned long offset
;
4512 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4515 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
4518 vers_data
= byte_get (data
, 2);
4520 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
4521 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
4524 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
4526 if ((vers_data
& 0x8000) || vers_data
> 1)
4528 if (is_nobits
|| ! check_def
)
4530 Elf_External_Verneed evn
;
4531 Elf_Internal_Verneed ivn
;
4532 Elf_Internal_Vernaux ivna
;
4534 /* We must test both. */
4535 offset
= version_info
4536 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
4540 unsigned long vna_off
;
4542 GET_DATA (offset
, evn
, "version need");
4544 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4545 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4547 vna_off
= offset
+ ivn
.vn_aux
;
4551 Elf_External_Vernaux evna
;
4553 GET_DATA (vna_off
, evna
,
4554 "version need aux (3)");
4556 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4557 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4558 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4560 vna_off
+= ivna
.vna_next
;
4562 while (ivna
.vna_other
!= vers_data
4563 && ivna
.vna_next
!= 0);
4565 if (ivna
.vna_other
== vers_data
)
4568 offset
+= ivn
.vn_next
;
4570 while (ivn
.vn_next
!= 0);
4572 if (ivna
.vna_other
== vers_data
)
4575 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
4578 else if (! is_nobits
)
4579 error (_("bad dynamic symbol"));
4586 if (vers_data
!= 0x8001)
4588 Elf_Internal_Verdef ivd
;
4589 Elf_Internal_Verdaux ivda
;
4590 Elf_External_Verdaux evda
;
4591 unsigned long offset
;
4594 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
4599 Elf_External_Verdef evd
;
4601 GET_DATA (offset
, evd
, "version def");
4603 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4604 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4605 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4607 offset
+= ivd
.vd_next
;
4609 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
4610 && ivd
.vd_next
!= 0);
4612 offset
-= ivd
.vd_next
;
4613 offset
+= ivd
.vd_aux
;
4615 GET_DATA (offset
, evda
, "version def aux");
4617 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4619 if (psym
->st_name
!= ivda
.vda_name
)
4620 printf ((vers_data
& 0x8000)
4622 strtab
+ ivda
.vda_name
);
4632 if (strtab
!= string_table
)
4638 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4640 if (do_histogram
&& buckets
!= NULL
)
4647 int nzero_counts
= 0;
4650 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4652 printf (_(" Length Number %% of total Coverage\n"));
4654 lengths
= (int *) calloc (nbuckets
, sizeof (int));
4655 if (lengths
== NULL
)
4657 error (_("Out of memory"));
4660 for (hn
= 0; hn
< nbuckets
; ++hn
)
4665 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
4668 if (maxlength
< ++lengths
[hn
])
4673 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
4676 error (_("Out of memory"));
4680 for (hn
= 0; hn
< nbuckets
; ++hn
)
4681 ++ counts
[lengths
[hn
]];
4685 printf (" 0 %-10d (%5.1f%%)\n",
4686 counts
[0], (counts
[0] * 100.0) / nbuckets
);
4687 for (si
= 1; si
<= maxlength
; ++si
)
4689 nzero_counts
+= counts
[si
] * si
;
4690 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4691 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
4692 (nzero_counts
* 100.0) / nsyms
);
4700 if (buckets
!= NULL
)
4710 process_syminfo (file
)
4711 FILE * file ATTRIBUTE_UNUSED
;
4715 if (dynamic_syminfo
== NULL
4717 /* No syminfo, this is ok. */
4720 /* There better should be a dynamic symbol section. */
4721 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
4725 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4726 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
4728 printf (_(" Num: Name BoundTo Flags\n"));
4729 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
4731 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
4733 printf ("%4d: %-30s ", i
,
4734 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
4736 switch (dynamic_syminfo
[i
].si_boundto
)
4738 case SYMINFO_BT_SELF
:
4739 fputs ("SELF ", stdout
);
4741 case SYMINFO_BT_PARENT
:
4742 fputs ("PARENT ", stdout
);
4745 if (dynamic_syminfo
[i
].si_boundto
> 0
4746 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
4749 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
4751 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
4755 if (flags
& SYMINFO_FLG_DIRECT
)
4757 if (flags
& SYMINFO_FLG_PASSTHRU
)
4758 printf (" PASSTHRU");
4759 if (flags
& SYMINFO_FLG_COPY
)
4761 if (flags
& SYMINFO_FLG_LAZYLOAD
)
4762 printf (" LAZYLOAD");
4770 #ifdef SUPPORT_DISASSEMBLY
4772 disassemble_section (section
, file
)
4773 Elf32_Internal_Shdr
* section
;
4776 printf (_("\nAssembly dump of section %s\n"),
4777 SECTION_NAME (section
));
4779 /* XXX -- to be done --- XXX */
4786 dump_section (section
, file
)
4787 Elf32_Internal_Shdr
* section
;
4790 bfd_size_type bytes
;
4792 unsigned char * data
;
4793 unsigned char * start
;
4795 bytes
= section
->sh_size
;
4799 printf (_("\nSection '%s' has no data to dump.\n"),
4800 SECTION_NAME (section
));
4804 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
4806 addr
= section
->sh_addr
;
4808 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
4819 lbytes
= (bytes
> 16 ? 16 : bytes
);
4821 printf (" 0x%8.8lx ", (unsigned long) addr
);
4823 switch (elf_header
.e_ident
[EI_DATA
])
4827 for (j
= 15; j
>= 0; j
--)
4830 printf ("%2.2x", data
[j
]);
4840 for (j
= 0; j
< 16; j
++)
4843 printf ("%2.2x", data
[j
]);
4853 for (j
= 0; j
< lbytes
; j
++)
4856 if (k
>= ' ' && k
< 0x80)
4875 static unsigned long int
4876 read_leb128 (data
, length_return
, sign
)
4877 unsigned char * data
;
4878 int * length_return
;
4881 unsigned long int result
= 0;
4882 unsigned int num_read
= 0;
4891 result
|= (byte
& 0x7f) << shift
;
4896 while (byte
& 0x80);
4898 if (length_return
!= NULL
)
4899 * length_return
= num_read
;
4901 if (sign
&& (shift
< 32) && (byte
& 0x40))
4902 result
|= -1 << shift
;
4907 typedef struct State_Machine_Registers
4909 unsigned long address
;
4912 unsigned int column
;
4916 /* This variable hold the number of the last entry seen
4917 in the File Table. */
4918 unsigned int last_file_entry
;
4921 static SMR state_machine_regs
;
4924 reset_state_machine (is_stmt
)
4927 state_machine_regs
.address
= 0;
4928 state_machine_regs
.file
= 1;
4929 state_machine_regs
.line
= 1;
4930 state_machine_regs
.column
= 0;
4931 state_machine_regs
.is_stmt
= is_stmt
;
4932 state_machine_regs
.basic_block
= 0;
4933 state_machine_regs
.end_sequence
= 0;
4934 state_machine_regs
.last_file_entry
= 0;
4937 /* Handled an extend line op. Returns true if this is the end
4940 process_extended_line_op (data
, is_stmt
, pointer_size
)
4941 unsigned char * data
;
4945 unsigned char op_code
;
4948 unsigned char * name
;
4951 len
= read_leb128 (data
, & bytes_read
, 0);
4956 warn (_("badly formed extended line op encountered!"));
4961 op_code
= * data
++;
4963 printf (_(" Extended opcode %d: "), op_code
);
4967 case DW_LNE_end_sequence
:
4968 printf (_("End of Sequence\n\n"));
4969 reset_state_machine (is_stmt
);
4972 case DW_LNE_set_address
:
4973 adr
= byte_get (data
, pointer_size
);
4974 printf (_("set Address to 0x%lx\n"), adr
);
4975 state_machine_regs
.address
= adr
;
4978 case DW_LNE_define_file
:
4979 printf (_(" define new File Table entry\n"));
4980 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4982 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4984 data
+= strlen ((char *) data
) + 1;
4985 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4987 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4989 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4990 printf (_("%s\n\n"), name
);
4994 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
5001 /* Size of pointers in the .debug_line section. This information is not
5002 really present in that section. It's obtained before dumping the debug
5003 sections by doing some pre-scan of the .debug_info section. */
5004 static int debug_line_pointer_size
= 4;
5007 display_debug_lines (section
, start
, file
)
5008 Elf32_Internal_Shdr
* section
;
5009 unsigned char * start
;
5010 FILE * file ATTRIBUTE_UNUSED
;
5012 DWARF2_External_LineInfo
* external
;
5013 DWARF2_Internal_LineInfo info
;
5014 unsigned char * standard_opcodes
;
5015 unsigned char * data
= start
;
5016 unsigned char * end
= start
+ section
->sh_size
;
5017 unsigned char * end_of_sequence
;
5020 printf (_("\nDump of debug contents of section %s:\n\n"),
5021 SECTION_NAME (section
));
5025 external
= (DWARF2_External_LineInfo
*) data
;
5027 /* Check the length of the block. */
5028 info
.li_length
= BYTE_GET (external
->li_length
);
5029 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
5032 (_("The line info appears to be corrupt - the section is too small\n"));
5036 /* Check its version number. */
5037 info
.li_version
= BYTE_GET (external
->li_version
);
5038 if (info
.li_version
!= 2)
5040 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5044 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
5045 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
5046 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
5047 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
5048 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
5049 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
5051 /* Sign extend the line base field. */
5052 info
.li_line_base
<<= 24;
5053 info
.li_line_base
>>= 24;
5055 printf (_(" Length: %ld\n"), info
.li_length
);
5056 printf (_(" DWARF Version: %d\n"), info
.li_version
);
5057 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
5058 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
5059 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
5060 printf (_(" Line Base: %d\n"), info
.li_line_base
);
5061 printf (_(" Line Range: %d\n"), info
.li_line_range
);
5062 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
5064 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
5066 reset_state_machine (info
.li_default_is_stmt
);
5068 /* Display the contents of the Opcodes table. */
5069 standard_opcodes
= data
+ sizeof (* external
);
5071 printf (_("\n Opcodes:\n"));
5073 for (i
= 1; i
< info
.li_opcode_base
; i
++)
5074 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
5076 /* Display the contents of the Directory table. */
5077 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
5080 printf (_("\n The Directory Table is empty.\n"));
5083 printf (_("\n The Directory Table:\n"));
5087 printf (_(" %s\n"), data
);
5089 data
+= strlen ((char *) data
) + 1;
5093 /* Skip the NUL at the end of the table. */
5096 /* Display the contents of the File Name table. */
5098 printf (_("\n The File Name Table is empty.\n"));
5101 printf (_("\n The File Name Table:\n"));
5102 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5106 unsigned char * name
;
5109 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5112 data
+= strlen ((char *) data
) + 1;
5114 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5116 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5118 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5120 printf (_("%s\n"), name
);
5124 /* Skip the NUL at the end of the table. */
5127 /* Now display the statements. */
5128 printf (_("\n Line Number Statements:\n"));
5131 while (data
< end_of_sequence
)
5133 unsigned char op_code
;
5137 op_code
= * data
++;
5141 case DW_LNS_extended_op
:
5142 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
5143 debug_line_pointer_size
);
5147 printf (_(" Copy\n"));
5150 case DW_LNS_advance_pc
:
5151 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
5153 state_machine_regs
.address
+= adv
;
5154 printf (_(" Advance PC by %d to %lx\n"), adv
,
5155 state_machine_regs
.address
);
5158 case DW_LNS_advance_line
:
5159 adv
= read_leb128 (data
, & bytes_read
, 1);
5161 state_machine_regs
.line
+= adv
;
5162 printf (_(" Advance Line by %d to %d\n"), adv
,
5163 state_machine_regs
.line
);
5166 case DW_LNS_set_file
:
5167 adv
= read_leb128 (data
, & bytes_read
, 0);
5169 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5171 state_machine_regs
.file
= adv
;
5174 case DW_LNS_set_column
:
5175 adv
= read_leb128 (data
, & bytes_read
, 0);
5177 printf (_(" Set column to %d\n"), adv
);
5178 state_machine_regs
.column
= adv
;
5181 case DW_LNS_negate_stmt
:
5182 adv
= state_machine_regs
.is_stmt
;
5184 printf (_(" Set is_stmt to %d\n"), adv
);
5185 state_machine_regs
.is_stmt
= adv
;
5188 case DW_LNS_set_basic_block
:
5189 printf (_(" Set basic block\n"));
5190 state_machine_regs
.basic_block
= 1;
5193 case DW_LNS_const_add_pc
:
5194 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
5195 * info
.li_min_insn_length
);
5196 state_machine_regs
.address
+= adv
;
5197 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
5198 state_machine_regs
.address
);
5201 case DW_LNS_fixed_advance_pc
:
5202 adv
= byte_get (data
, 2);
5204 state_machine_regs
.address
+= adv
;
5205 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5206 adv
, state_machine_regs
.address
);
5210 op_code
-= info
.li_opcode_base
;
5211 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
5212 state_machine_regs
.address
+= adv
;
5213 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5214 op_code
, adv
, state_machine_regs
.address
);
5215 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
5216 state_machine_regs
.line
+= adv
;
5217 printf (_(" and Line by %d to %d\n"),
5218 adv
, state_machine_regs
.line
);
5229 display_debug_pubnames (section
, start
, file
)
5230 Elf32_Internal_Shdr
* section
;
5231 unsigned char * start
;
5232 FILE * file ATTRIBUTE_UNUSED
;
5234 DWARF2_External_PubNames
* external
;
5235 DWARF2_Internal_PubNames pubnames
;
5236 unsigned char * end
;
5238 end
= start
+ section
->sh_size
;
5240 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5244 unsigned char * data
;
5245 unsigned long offset
;
5247 external
= (DWARF2_External_PubNames
*) start
;
5249 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5250 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5251 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5252 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5254 data
= start
+ sizeof (* external
);
5255 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5257 if (pubnames
.pn_version
!= 2)
5259 static int warned
= 0;
5263 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5270 printf (_(" Length: %ld\n"),
5271 pubnames
.pn_length
);
5272 printf (_(" Version: %d\n"),
5273 pubnames
.pn_version
);
5274 printf (_(" Offset into .debug_info section: %ld\n"),
5275 pubnames
.pn_offset
);
5276 printf (_(" Size of area in .debug_info section: %ld\n"),
5279 printf (_("\n Offset\tName\n"));
5283 offset
= byte_get (data
, 4);
5288 printf (" %ld\t\t%s\n", offset
, data
);
5289 data
+= strlen ((char *) data
) + 1;
5292 while (offset
!= 0);
5305 case DW_TAG_padding
: return "DW_TAG_padding";
5306 case DW_TAG_array_type
: return "DW_TAG_array_type";
5307 case DW_TAG_class_type
: return "DW_TAG_class_type";
5308 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5309 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5310 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5311 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5312 case DW_TAG_label
: return "DW_TAG_label";
5313 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5314 case DW_TAG_member
: return "DW_TAG_member";
5315 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5316 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5317 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5318 case DW_TAG_string_type
: return "DW_TAG_string_type";
5319 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5320 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5321 case DW_TAG_typedef
: return "DW_TAG_typedef";
5322 case DW_TAG_union_type
: return "DW_TAG_union_type";
5323 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5324 case DW_TAG_variant
: return "DW_TAG_variant";
5325 case DW_TAG_common_block
: return "DW_TAG_common_block";
5326 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5327 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5328 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5329 case DW_TAG_module
: return "DW_TAG_module";
5330 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5331 case DW_TAG_set_type
: return "DW_TAG_set_type";
5332 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5333 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5334 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5335 case DW_TAG_base_type
: return "DW_TAG_base_type";
5336 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5337 case DW_TAG_const_type
: return "DW_TAG_const_type";
5338 case DW_TAG_constant
: return "DW_TAG_constant";
5339 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5340 case DW_TAG_file_type
: return "DW_TAG_file_type";
5341 case DW_TAG_friend
: return "DW_TAG_friend";
5342 case DW_TAG_namelist
: return "DW_TAG_namelist";
5343 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5344 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5345 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5346 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5347 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5348 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5349 case DW_TAG_try_block
: return "DW_TAG_try_block";
5350 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5351 case DW_TAG_variable
: return "DW_TAG_variable";
5352 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5353 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5354 case DW_TAG_format_label
: return "DW_TAG_format_label";
5355 case DW_TAG_function_template
: return "DW_TAG_function_template";
5356 case DW_TAG_class_template
: return "DW_TAG_class_template";
5359 static char buffer
[100];
5361 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
5368 get_AT_name (attribute
)
5369 unsigned long attribute
;
5373 case DW_AT_sibling
: return "DW_AT_sibling";
5374 case DW_AT_location
: return "DW_AT_location";
5375 case DW_AT_name
: return "DW_AT_name";
5376 case DW_AT_ordering
: return "DW_AT_ordering";
5377 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
5378 case DW_AT_byte_size
: return "DW_AT_byte_size";
5379 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
5380 case DW_AT_bit_size
: return "DW_AT_bit_size";
5381 case DW_AT_element_list
: return "DW_AT_element_list";
5382 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
5383 case DW_AT_low_pc
: return "DW_AT_low_pc";
5384 case DW_AT_high_pc
: return "DW_AT_high_pc";
5385 case DW_AT_language
: return "DW_AT_language";
5386 case DW_AT_member
: return "DW_AT_member";
5387 case DW_AT_discr
: return "DW_AT_discr";
5388 case DW_AT_discr_value
: return "DW_AT_discr_value";
5389 case DW_AT_visibility
: return "DW_AT_visibility";
5390 case DW_AT_import
: return "DW_AT_import";
5391 case DW_AT_string_length
: return "DW_AT_string_length";
5392 case DW_AT_common_reference
: return "DW_AT_common_reference";
5393 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5394 case DW_AT_const_value
: return "DW_AT_const_value";
5395 case DW_AT_containing_type
: return "DW_AT_containing_type";
5396 case DW_AT_default_value
: return "DW_AT_default_value";
5397 case DW_AT_inline
: return "DW_AT_inline";
5398 case DW_AT_is_optional
: return "DW_AT_is_optional";
5399 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5400 case DW_AT_producer
: return "DW_AT_producer";
5401 case DW_AT_prototyped
: return "DW_AT_prototyped";
5402 case DW_AT_return_addr
: return "DW_AT_return_addr";
5403 case DW_AT_start_scope
: return "DW_AT_start_scope";
5404 case DW_AT_stride_size
: return "DW_AT_stride_size";
5405 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5406 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5407 case DW_AT_accessibility
: return "DW_AT_accessibility";
5408 case DW_AT_address_class
: return "DW_AT_address_class";
5409 case DW_AT_artificial
: return "DW_AT_artificial";
5410 case DW_AT_base_types
: return "DW_AT_base_types";
5411 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5412 case DW_AT_count
: return "DW_AT_count";
5413 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5414 case DW_AT_decl_column
: return "DW_AT_decl_column";
5415 case DW_AT_decl_file
: return "DW_AT_decl_file";
5416 case DW_AT_decl_line
: return "DW_AT_decl_line";
5417 case DW_AT_declaration
: return "DW_AT_declaration";
5418 case DW_AT_discr_list
: return "DW_AT_discr_list";
5419 case DW_AT_encoding
: return "DW_AT_encoding";
5420 case DW_AT_external
: return "DW_AT_external";
5421 case DW_AT_frame_base
: return "DW_AT_frame_base";
5422 case DW_AT_friend
: return "DW_AT_friend";
5423 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5424 case DW_AT_macro_info
: return "DW_AT_macro_info";
5425 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5426 case DW_AT_priority
: return "DW_AT_priority";
5427 case DW_AT_segment
: return "DW_AT_segment";
5428 case DW_AT_specification
: return "DW_AT_specification";
5429 case DW_AT_static_link
: return "DW_AT_static_link";
5430 case DW_AT_type
: return "DW_AT_type";
5431 case DW_AT_use_location
: return "DW_AT_use_location";
5432 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5433 case DW_AT_virtuality
: return "DW_AT_virtuality";
5434 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5435 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5436 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5437 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5438 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5439 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5440 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5441 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5442 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5443 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5444 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5445 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5446 case DW_AT_sf_names
: return "DW_AT_sf_names";
5447 case DW_AT_src_info
: return "DW_AT_src_info";
5448 case DW_AT_mac_info
: return "DW_AT_mac_info";
5449 case DW_AT_src_coords
: return "DW_AT_src_coords";
5450 case DW_AT_body_begin
: return "DW_AT_body_begin";
5451 case DW_AT_body_end
: return "DW_AT_body_end";
5454 static char buffer
[100];
5456 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5463 get_FORM_name (form
)
5468 case DW_FORM_addr
: return "DW_FORM_addr";
5469 case DW_FORM_block2
: return "DW_FORM_block2";
5470 case DW_FORM_block4
: return "DW_FORM_block4";
5471 case DW_FORM_data2
: return "DW_FORM_data2";
5472 case DW_FORM_data4
: return "DW_FORM_data4";
5473 case DW_FORM_data8
: return "DW_FORM_data8";
5474 case DW_FORM_string
: return "DW_FORM_string";
5475 case DW_FORM_block
: return "DW_FORM_block";
5476 case DW_FORM_block1
: return "DW_FORM_block1";
5477 case DW_FORM_data1
: return "DW_FORM_data1";
5478 case DW_FORM_flag
: return "DW_FORM_flag";
5479 case DW_FORM_sdata
: return "DW_FORM_sdata";
5480 case DW_FORM_strp
: return "DW_FORM_strp";
5481 case DW_FORM_udata
: return "DW_FORM_udata";
5482 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5483 case DW_FORM_ref1
: return "DW_FORM_ref1";
5484 case DW_FORM_ref2
: return "DW_FORM_ref2";
5485 case DW_FORM_ref4
: return "DW_FORM_ref4";
5486 case DW_FORM_ref8
: return "DW_FORM_ref8";
5487 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5488 case DW_FORM_indirect
: return "DW_FORM_indirect";
5491 static char buffer
[100];
5493 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5499 /* FIXME: There are better and more effiecint ways to handle
5500 these structures. For now though, I just want something that
5501 is simple to implement. */
5502 typedef struct abbrev_attr
5504 unsigned long attribute
;
5506 struct abbrev_attr
* next
;
5510 typedef struct abbrev_entry
5512 unsigned long entry
;
5515 struct abbrev_attr
* first_attr
;
5516 struct abbrev_attr
* last_attr
;
5517 struct abbrev_entry
* next
;
5521 static abbrev_entry
* first_abbrev
= NULL
;
5522 static abbrev_entry
* last_abbrev
= NULL
;
5525 free_abbrevs
PARAMS ((void))
5527 abbrev_entry
* abbrev
;
5529 for (abbrev
= first_abbrev
; abbrev
;)
5531 abbrev_entry
* next
= abbrev
->next
;
5534 for (attr
= abbrev
->first_attr
; attr
;)
5536 abbrev_attr
* next
= attr
->next
;
5546 last_abbrev
= first_abbrev
= NULL
;
5550 add_abbrev (number
, tag
, children
)
5551 unsigned long number
;
5555 abbrev_entry
* entry
;
5557 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
5563 entry
->entry
= number
;
5565 entry
->children
= children
;
5566 entry
->first_attr
= NULL
;
5567 entry
->last_attr
= NULL
;
5570 if (first_abbrev
== NULL
)
5571 first_abbrev
= entry
;
5573 last_abbrev
->next
= entry
;
5575 last_abbrev
= entry
;
5579 add_abbrev_attr (attribute
, form
)
5580 unsigned long attribute
;
5585 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
5591 attr
->attribute
= attribute
;
5595 if (last_abbrev
->first_attr
== NULL
)
5596 last_abbrev
->first_attr
= attr
;
5598 last_abbrev
->last_attr
->next
= attr
;
5600 last_abbrev
->last_attr
= attr
;
5603 /* Processes the (partial) contents of a .debug_abbrev section.
5604 Returns NULL if the end of the section was encountered.
5605 Returns the address after the last byte read if the end of
5606 an abbreviation set was found. */
5608 static unsigned char *
5609 process_abbrev_section (start
, end
)
5610 unsigned char * start
;
5611 unsigned char * end
;
5613 if (first_abbrev
!= NULL
)
5619 unsigned long entry
;
5621 unsigned long attribute
;
5624 entry
= read_leb128 (start
, & bytes_read
, 0);
5625 start
+= bytes_read
;
5627 /* A single zero is supposed to end the section according
5628 to the standard. If there's more, then signal that to
5631 return start
== end
? NULL
: start
;
5633 tag
= read_leb128 (start
, & bytes_read
, 0);
5634 start
+= bytes_read
;
5636 children
= * start
++;
5638 add_abbrev (entry
, tag
, children
);
5644 attribute
= read_leb128 (start
, & bytes_read
, 0);
5645 start
+= bytes_read
;
5647 form
= read_leb128 (start
, & bytes_read
, 0);
5648 start
+= bytes_read
;
5651 add_abbrev_attr (attribute
, form
);
5653 while (attribute
!= 0);
5661 display_debug_abbrev (section
, start
, file
)
5662 Elf32_Internal_Shdr
* section
;
5663 unsigned char * start
;
5664 FILE * file ATTRIBUTE_UNUSED
;
5666 abbrev_entry
* entry
;
5667 unsigned char * end
= start
+ section
->sh_size
;
5669 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5673 start
= process_abbrev_section (start
, end
);
5675 printf (_(" Number TAG\n"));
5677 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5681 printf (_(" %ld %s [%s]\n"),
5683 get_TAG_name (entry
->tag
),
5684 entry
->children
? _("has children") : _("no children"));
5686 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5688 printf (_(" %-18s %s\n"),
5689 get_AT_name (attr
->attribute
),
5690 get_FORM_name (attr
->form
));
5702 static unsigned char *
5703 display_block (data
, length
)
5704 unsigned char * data
;
5705 unsigned long length
;
5707 printf (_(" %lu byte block: "), length
);
5710 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
5716 decode_location_expression (data
, pointer_size
, length
)
5717 unsigned char * data
;
5718 unsigned int pointer_size
;
5719 unsigned long length
;
5723 unsigned long uvalue
;
5724 unsigned char *end
= data
+ length
;
5733 printf ("DW_OP_addr: %lx",
5734 (unsigned long) byte_get (data
, pointer_size
));
5735 data
+= pointer_size
;
5738 printf ("DW_OP_deref");
5741 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
5744 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
5747 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
5751 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
5755 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
5759 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
5763 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
5764 (unsigned long) byte_get (data
+ 4, 4));
5768 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
5769 (long) byte_get (data
+ 4, 4));
5773 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
5777 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
5781 printf ("DW_OP_dup");
5784 printf ("DW_OP_drop");
5787 printf ("DW_OP_over");
5790 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
5793 printf ("DW_OP_swap");
5796 printf ("DW_OP_rot");
5799 printf ("DW_OP_xderef");
5802 printf ("DW_OP_abs");
5805 printf ("DW_OP_and");
5808 printf ("DW_OP_div");
5811 printf ("DW_OP_minus");
5814 printf ("DW_OP_mod");
5817 printf ("DW_OP_mul");
5820 printf ("DW_OP_neg");
5823 printf ("DW_OP_not");
5826 printf ("DW_OP_or");
5829 printf ("DW_OP_plus");
5831 case DW_OP_plus_uconst
:
5832 printf ("DW_OP_plus_uconst: %lu",
5833 read_leb128 (data
, &bytes_read
, 0));
5837 printf ("DW_OP_shl");
5840 printf ("DW_OP_shr");
5843 printf ("DW_OP_shra");
5846 printf ("DW_OP_xor");
5849 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
5853 printf ("DW_OP_eq");
5856 printf ("DW_OP_ge");
5859 printf ("DW_OP_gt");
5862 printf ("DW_OP_le");
5865 printf ("DW_OP_lt");
5868 printf ("DW_OP_ne");
5871 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
5907 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
5942 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
5977 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
5978 read_leb128 (data
, &bytes_read
, 1));
5983 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
5987 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
5991 uvalue
= read_leb128 (data
, &bytes_read
, 0);
5993 printf ("DW_OP_bregx: %lu %ld", uvalue
,
5994 read_leb128 (data
, &bytes_read
, 1));
5998 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
6001 case DW_OP_deref_size
:
6002 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
6004 case DW_OP_xderef_size
:
6005 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
6008 printf ("DW_OP_nop");
6012 if (op
>= DW_OP_lo_user
6013 && op
<= DW_OP_hi_user
)
6014 printf (_("(User defined location op)"));
6016 printf (_("(Unknown location op)"));
6017 /* No way to tell where the next op is, so just bail. */
6024 static unsigned char *
6025 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
6026 unsigned long attribute
;
6028 unsigned char * data
;
6029 unsigned long cu_offset
;
6030 unsigned long pointer_size
;
6032 unsigned long uvalue
= 0;
6033 unsigned char * block_start
= NULL
;
6036 printf (" %-18s:", get_AT_name (attribute
));
6043 case DW_FORM_ref_addr
:
6045 uvalue
= byte_get (data
, pointer_size
);
6046 data
+= pointer_size
;
6052 uvalue
= byte_get (data
++, 1);
6057 uvalue
= byte_get (data
, 2);
6063 uvalue
= byte_get (data
, 4);
6068 uvalue
= read_leb128 (data
, & bytes_read
, 1);
6072 case DW_FORM_ref_udata
:
6074 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6081 case DW_FORM_ref_addr
:
6082 printf (" <#%lx>", uvalue
);
6088 case DW_FORM_ref_udata
:
6089 printf (" <%lx>", uvalue
+ cu_offset
);
6093 printf (" %#lx", uvalue
);
6101 printf (" %ld", uvalue
);
6106 uvalue
= byte_get (data
, 4);
6107 printf (" %lx", uvalue
);
6108 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
6112 case DW_FORM_string
:
6113 printf (" %s", data
);
6114 data
+= strlen ((char *) data
) + 1;
6118 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6119 block_start
= data
+ bytes_read
;
6120 data
= display_block (block_start
, uvalue
);
6123 case DW_FORM_block1
:
6124 uvalue
= byte_get (data
, 1);
6125 block_start
= data
+ 1;
6126 data
= display_block (block_start
, uvalue
);
6129 case DW_FORM_block2
:
6130 uvalue
= byte_get (data
, 2);
6131 block_start
= data
+ 2;
6132 data
= display_block (block_start
, uvalue
);
6135 case DW_FORM_block4
:
6136 uvalue
= byte_get (data
, 4);
6137 block_start
= data
+ 4;
6138 data
= display_block (block_start
, uvalue
);
6142 case DW_FORM_indirect
:
6143 warn (_("Unable to handle FORM: %d"), form
);
6147 warn (_("Unrecognised form: %d"), form
);
6151 /* For some attributes we can display futher information. */
6160 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6161 case DW_INL_inlined
: printf (_("(inlined)")); break;
6162 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6163 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6164 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6168 case DW_AT_language
:
6171 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6172 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6173 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6174 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6175 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6176 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6177 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6178 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6179 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6180 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6181 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6182 default: printf ("(Unknown: %lx)", uvalue
); break;
6186 case DW_AT_encoding
:
6189 case DW_ATE_void
: printf ("(void)"); break;
6190 case DW_ATE_address
: printf ("(machine address)"); break;
6191 case DW_ATE_boolean
: printf ("(boolean)"); break;
6192 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6193 case DW_ATE_float
: printf ("(float)"); break;
6194 case DW_ATE_signed
: printf ("(signed)"); break;
6195 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6196 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6197 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6199 if (uvalue
>= DW_ATE_lo_user
6200 && uvalue
<= DW_ATE_hi_user
)
6201 printf ("(user defined type)");
6203 printf ("(unknown type)");
6208 case DW_AT_accessibility
:
6211 case DW_ACCESS_public
: printf ("(public)"); break;
6212 case DW_ACCESS_protected
: printf ("(protected)"); break;
6213 case DW_ACCESS_private
: printf ("(private)"); break;
6214 default: printf ("(unknown accessibility)"); break;
6218 case DW_AT_visibility
:
6221 case DW_VIS_local
: printf ("(local)"); break;
6222 case DW_VIS_exported
: printf ("(exported)"); break;
6223 case DW_VIS_qualified
: printf ("(qualified)"); break;
6224 default: printf ("(unknown visibility)"); break;
6228 case DW_AT_virtuality
:
6231 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6232 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6233 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6234 default: printf ("(unknown virtuality)"); break;
6238 case DW_AT_identifier_case
:
6241 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6242 case DW_ID_up_case
: printf ("(up_case)"); break;
6243 case DW_ID_down_case
: printf ("(down_case)"); break;
6244 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6245 default: printf ("(unknown case)"); break;
6249 case DW_AT_calling_convention
:
6252 case DW_CC_normal
: printf ("(normal)"); break;
6253 case DW_CC_program
: printf ("(program)"); break;
6254 case DW_CC_nocall
: printf ("(nocall)"); break;
6256 if (uvalue
>= DW_CC_lo_user
6257 && uvalue
<= DW_CC_hi_user
)
6258 printf ("(user defined)");
6260 printf ("(unknown convention)");
6264 case DW_AT_frame_base
:
6265 case DW_AT_location
:
6266 case DW_AT_data_member_location
:
6267 case DW_AT_vtable_elem_location
:
6271 decode_location_expression (block_start
, pointer_size
, uvalue
);
6285 display_debug_info (section
, start
, file
)
6286 Elf32_Internal_Shdr
* section
;
6287 unsigned char * start
;
6290 unsigned char * end
= start
+ section
->sh_size
;
6291 unsigned char * section_begin
= start
;
6293 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6297 DWARF2_External_CompUnit
* external
;
6298 DWARF2_Internal_CompUnit compunit
;
6299 unsigned char * tags
;
6302 unsigned long cu_offset
;
6304 external
= (DWARF2_External_CompUnit
*) start
;
6306 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6307 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6308 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6309 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6311 tags
= start
+ sizeof (* external
);
6312 cu_offset
= start
- section_begin
;
6313 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6315 if (compunit
.cu_version
!= 2)
6317 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6321 printf (_(" Compilation Unit:\n"));
6322 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6323 printf (_(" Version: %d\n"), compunit
.cu_version
);
6324 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6325 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6327 if (first_abbrev
!= NULL
)
6330 /* Read in the abbrevs used by this compilation unit. */
6333 Elf32_Internal_Shdr
* sec
;
6334 unsigned char * begin
;
6336 /* Locate the .debug_abbrev section and process it. */
6337 for (i
= 0, sec
= section_headers
;
6338 i
< elf_header
.e_shnum
;
6340 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6343 if (i
== -1 || sec
->sh_size
== 0)
6345 warn (_("Unable to locate .debug_abbrev section!\n"));
6349 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6350 "debug_abbrev section data");
6352 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6353 begin
+ sec
->sh_size
);
6359 while (tags
< start
)
6362 unsigned long abbrev_number
;
6363 abbrev_entry
* entry
;
6366 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6369 /* A null DIE marks the end of a list of children. */
6370 if (abbrev_number
== 0)
6376 /* Scan through the abbreviation list until we reach the
6378 for (entry
= first_abbrev
;
6379 entry
&& entry
->entry
!= abbrev_number
;
6380 entry
= entry
->next
)
6385 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6390 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6391 level
, tags
- section_begin
- bytes_read
,
6393 get_TAG_name (entry
->tag
));
6395 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6396 tags
= read_and_display_attr (attr
->attribute
,
6399 compunit
.cu_pointer_size
);
6401 if (entry
->children
)
6412 display_debug_aranges (section
, start
, file
)
6413 Elf32_Internal_Shdr
* section
;
6414 unsigned char * start
;
6415 FILE * file ATTRIBUTE_UNUSED
;
6417 unsigned char * end
= start
+ section
->sh_size
;
6419 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6423 DWARF2_External_ARange
* external
;
6424 DWARF2_Internal_ARange arange
;
6425 unsigned char * ranges
;
6426 unsigned long length
;
6427 unsigned long address
;
6430 external
= (DWARF2_External_ARange
*) start
;
6432 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6433 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6434 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6435 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6436 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6438 if (arange
.ar_version
!= 2)
6440 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6444 printf (_(" Length: %ld\n"), arange
.ar_length
);
6445 printf (_(" Version: %d\n"), arange
.ar_version
);
6446 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6447 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6448 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6450 printf (_("\n Address Length\n"));
6452 ranges
= start
+ sizeof (* external
);
6454 /* Must pad to an alignment boundary that is twice the pointer size. */
6455 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
6457 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6461 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6463 ranges
+= arange
.ar_pointer_size
;
6465 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6467 ranges
+= arange
.ar_pointer_size
;
6469 /* A pair of zeros marks the end of the list. */
6470 if (address
== 0 && length
== 0)
6473 printf (" %8.8lx %lu\n", address
, length
);
6476 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6484 typedef struct Frame_Chunk
6486 struct Frame_Chunk
*next
;
6487 unsigned char *chunk_start
;
6489 /* DW_CFA_{undefined,same_value,offset,register} */
6490 unsigned char *col_type
;
6493 unsigned int code_factor
;
6494 unsigned int data_factor
;
6495 unsigned long pc_begin
;
6496 unsigned long pc_range
;
6504 frame_need_space (fc
, reg
)
6508 int prev
= fc
->ncols
;
6510 if (reg
< fc
->ncols
)
6512 fc
->ncols
= reg
+ 1;
6513 fc
->col_type
= (unsigned char *) xrealloc (fc
->col_type
,
6514 fc
->ncols
* sizeof (unsigned char));
6515 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
6516 fc
->ncols
* sizeof (int));
6518 while (prev
< fc
->ncols
)
6520 fc
->col_type
[prev
] = DW_CFA_undefined
;
6521 fc
->col_offset
[prev
] = 0;
6527 frame_display_row (fc
, need_col_headers
, max_regs
)
6529 int *need_col_headers
;
6535 if (*max_regs
< fc
->ncols
)
6536 *max_regs
= fc
->ncols
;
6537 if (*need_col_headers
)
6539 *need_col_headers
= 0;
6540 printf (" LOC CFA ");
6541 for (r
=0; r
<*max_regs
; r
++)
6545 printf ("r%-4d", r
);
6548 printf ("%08x ", (unsigned int) fc
->pc_begin
);
6549 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
6550 printf ("%-8s ", tmp
);
6551 for (r
=0; r
<fc
->ncols
; r
++)
6553 switch (fc
->col_type
[r
])
6555 case DW_CFA_undefined
:
6558 case DW_CFA_same_value
:
6562 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
6564 case DW_CFA_register
:
6565 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
6568 strcpy (tmp
, "n/a");
6571 printf ("%-5s", tmp
);
6576 #define GET(N) byte_get (start, N); start += N
6577 #define LEB() read_leb128 (start, &length_return, 0); start += length_return
6578 #define SLEB() read_leb128 (start, &length_return, 1); start += length_return
6581 display_debug_frames (section
, start
, file
)
6582 Elf32_Internal_Shdr
* section
;
6583 unsigned char * start
;
6584 FILE * file ATTRIBUTE_UNUSED
;
6586 unsigned char * end
= start
+ section
->sh_size
;
6587 unsigned char *section_start
= start
;
6588 Frame_Chunk
*chunks
= 0;
6589 Frame_Chunk
*remembered_state
= 0, *rs
;
6590 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
6594 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
6598 unsigned char *saved_start
, *block_end
;
6599 unsigned long length
, cie_id
;
6600 Frame_Chunk
*fc
, *cie
;
6601 int need_col_headers
= 1;
6603 saved_start
= start
;
6604 length
= byte_get (start
, 4); start
+= 4;
6609 block_end
= saved_start
+ length
+ 4;
6610 cie_id
= byte_get (start
, 4); start
+= 4;
6612 printf ("\n%08x %08lx %08lx ", saved_start
- section_start
, length
, cie_id
);
6614 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
6616 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6617 memset (fc
, 0, sizeof (Frame_Chunk
));
6621 fc
->chunk_start
= saved_start
;
6623 fc
->col_type
= (unsigned char *) xmalloc (sizeof (unsigned char));
6624 fc
->col_offset
= (int *) xmalloc (sizeof (int));
6625 frame_need_space (fc
, max_regs
-1);
6627 start
++; /* version */
6628 fc
->augmentation
= start
;
6629 while (*start
) start
++; start
++; /* skip past NUL */
6630 if (fc
->augmentation
[0] == 'z')
6633 fc
->code_factor
= LEB ();
6634 fc
->data_factor
= SLEB ();
6635 fc
->ra
= byte_get (start
, 1); start
+= 1;
6637 printf ("skipping %d extra bytes\n", xtra
);
6640 else if (strcmp (fc
->augmentation
, "eh") == 0)
6643 fc
->code_factor
= LEB ();
6644 fc
->data_factor
= SLEB ();
6645 fc
->ra
= byte_get (start
, 1); start
+= 1;
6649 fc
->code_factor
= LEB ();
6650 fc
->data_factor
= SLEB ();
6651 fc
->ra
= byte_get (start
, 1); start
+= 1;
6654 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n",
6655 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
, fc
->ra
);
6657 frame_need_space (fc
, fc
->ra
);
6661 unsigned char *look_for
;
6662 static Frame_Chunk fde_fc
;
6664 memset (fc
, 0, sizeof (Frame_Chunk
));
6666 look_for
= is_eh
? start
-4-cie_id
: (unsigned char *) cie_id
;
6668 fc
->pc_begin
= byte_get (start
, 4); start
+= 4;
6669 fc
->pc_range
= byte_get (start
, 4); start
+= 4;
6671 for (cie
=chunks
; cie
&& (cie
->chunk_start
!= look_for
); cie
= cie
->next
);
6674 warn ("Invalid CIE pointer %08x in FDE at %08x\n", cie_id
, saved_start
);
6677 fc
->col_type
= (unsigned char *) xmalloc (sizeof (unsigned char));
6678 fc
->col_offset
= (int *) xmalloc (sizeof (int));
6679 frame_need_space (fc
, max_regs
-1);
6681 fc
->augmentation
= "";
6685 fc
->ncols
= cie
->ncols
;
6686 fc
->col_type
= (unsigned char *) xmalloc (fc
->ncols
* sizeof (unsigned char));
6687 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
6688 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
);
6689 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
6690 fc
->augmentation
= cie
->augmentation
;
6691 fc
->code_factor
= cie
->code_factor
;
6692 fc
->data_factor
= cie
->data_factor
;
6693 fc
->cfa_reg
= cie
->cfa_reg
;
6694 fc
->cfa_offset
= cie
->cfa_offset
;
6696 frame_need_space (fc
, max_regs
-1);
6699 if (cie
->augmentation
[0] == 'z')
6701 unsigned long l
= LEB ();
6705 printf ("FDE cie=%08x pc=%08lx..%08lx\n",
6706 cie
->chunk_start
-section_start
, fc
->pc_begin
,
6707 fc
->pc_begin
+ fc
->pc_range
);
6710 /* At this point, fc is the current chunk, cie (if any) is set, and we're
6711 about to interpret instructions for the chunk. */
6713 /* This exists for readelf maintainers. */
6716 while (start
< block_end
)
6719 unsigned long ul
, reg
, roffs
;
6730 case DW_CFA_advance_loc
:
6731 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6733 printf (" DW_CFA_advance_loc: %08x = %08x + %d*%d\n",
6734 fc
->pc_begin
+ opa
* fc
->code_factor
, fc
->pc_begin
, opa
, fc
->code_factor
);
6736 fc
->pc_begin
+= opa
* fc
->code_factor
;
6740 frame_need_space (fc
, opa
);
6743 printf (" DW_CFA_offset: r%d = cfa[%d*%d]\n", opa
, roffs
, fc
->data_factor
);
6745 fc
->col_type
[opa
] = DW_CFA_offset
;
6746 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
6749 case DW_CFA_restore
:
6750 frame_need_space (fc
, opa
);
6752 printf (" DW_CFA_restore: r%d\n", opa
);
6754 fc
->col_type
[opa
] = cie
->col_type
[opa
];
6755 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
6758 case DW_CFA_set_loc
:
6759 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6760 vma
= byte_get (start
, sizeof (vma
)); start
+= sizeof (vma
);
6762 printf (" DW_CFA_set_loc: %08x\n", vma
);
6767 case DW_CFA_advance_loc1
:
6768 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6769 ofs
= byte_get (start
, 1); start
+= 1;
6771 printf (" DW_CFA_advance_loc1: %08x = %08x + %d*%d\n",
6772 fc
->pc_begin
+ ofs
* fc
->code_factor
, fc
->pc_begin
, ofs
, fc
->code_factor
);
6774 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6777 case DW_CFA_advance_loc2
:
6778 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6779 ofs
= byte_get (start
, 2); start
+= 2;
6781 printf (" DW_CFA_advance_loc2: %08x = %08x + %d*%d\n",
6782 fc
->pc_begin
+ ofs
* fc
->code_factor
, fc
->pc_begin
, ofs
, fc
->code_factor
);
6784 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6787 case DW_CFA_advance_loc4
:
6788 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6789 ofs
= byte_get (start
, 4); start
+= 4;
6791 printf (" DW_CFA_advance_loc4: %08x = %08x + %d*%d\n",
6792 fc
->pc_begin
+ ofs
* fc
->code_factor
, fc
->pc_begin
, ofs
, fc
->code_factor
);
6794 fc
->pc_begin
+= ofs
* fc
->code_factor
;
6797 case DW_CFA_offset_extended
:
6800 frame_need_space (fc
, reg
);
6802 printf (" DW_CFA_offset_extended: r%d = cfa[%d*%d]\n", reg
, roffs
, fc
->data_factor
);
6804 fc
->col_type
[reg
] = DW_CFA_offset
;
6805 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
6808 case DW_CFA_restore_extended
:
6810 frame_need_space (fc
, reg
);
6812 printf (" DW_CFA_restore_extended: r%d\n", reg
);
6814 fc
->col_type
[reg
] = cie
->col_type
[reg
];
6815 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
6818 case DW_CFA_undefined
:
6820 frame_need_space (fc
, reg
);
6822 printf (" DW_CFA_undefined: r%d\n", reg
);
6824 fc
->col_type
[reg
] = DW_CFA_undefined
;
6825 fc
->col_offset
[reg
] = 0;
6828 case DW_CFA_same_value
:
6830 frame_need_space (fc
, reg
);
6832 printf (" DW_CFA_same_value: r%d\n", reg
);
6834 fc
->col_type
[reg
] = DW_CFA_same_value
;
6835 fc
->col_offset
[reg
] = 0;
6838 case DW_CFA_register
:
6841 frame_need_space (fc
, reg
);
6843 printf (" DW_CFA_ame_value: r%d\n", reg
);
6845 fc
->col_type
[reg
] = DW_CFA_register
;
6846 fc
->col_offset
[reg
] = roffs
;
6849 case DW_CFA_remember_state
:
6851 printf (" DW_CFA_remember_state\n");
6853 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
6854 rs
->ncols
= fc
->ncols
;
6855 rs
->col_type
= (unsigned char *) xmalloc (rs
->ncols
);
6856 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
6857 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
6858 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
6859 rs
->next
= remembered_state
;
6860 remembered_state
= rs
;
6863 case DW_CFA_restore_state
:
6865 printf (" DW_CFA_restore_state\n");
6867 rs
= remembered_state
;
6868 remembered_state
= rs
->next
;
6869 frame_need_space (fc
, rs
->ncols
-1);
6870 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
6871 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
6872 free (rs
->col_type
);
6873 free (rs
->col_offset
);
6877 case DW_CFA_def_cfa
:
6878 fc
->cfa_reg
= LEB ();
6879 fc
->cfa_offset
= LEB ();
6881 printf (" DW_CFA_def_cfa: reg %d ofs %d\n", fc
->cfa_reg
, fc
->cfa_offset
);
6885 case DW_CFA_def_cfa_register
:
6886 fc
->cfa_reg
= LEB ();
6888 printf (" DW_CFA_def_cfa_reg: %d\n", fc
->cfa_reg
);
6892 case DW_CFA_def_cfa_offset
:
6893 fc
->cfa_offset
= LEB ();
6895 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
6901 printf (" DW_CFA_nop\n");
6905 #ifndef DW_CFA_GNU_window_save
6906 #define DW_CFA_GNU_window_save 0x2d
6908 case DW_CFA_GNU_window_save
:
6910 printf (" DW_CFA_GNU_window_save\n");
6914 #ifndef DW_CFA_GNU_args_size
6915 #define DW_CFA_GNU_args_size 0x2e
6917 case DW_CFA_GNU_args_size
:
6920 printf (" DW_CFA_GNU_args_size: %d\n", ul
);
6924 #ifndef DW_CFA_GNU_negative_offset_extended
6925 #define DW_CFA_GNU_negative_offset_extended 0x2f
6927 case DW_CFA_GNU_negative_offset_extended
:
6930 frame_need_space (fc
, reg
);
6932 printf (" DW_CFA_GNU_negative_offset_extended: r%d = cfa[%d*%d]\n", reg
, l
, fc
->data_factor
);
6934 fc
->col_type
[reg
] = DW_CFA_offset
;
6935 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
6939 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
6944 frame_display_row (fc
, &need_col_headers
, &max_regs
);
6959 display_debug_not_supported (section
, start
, file
)
6960 Elf32_Internal_Shdr
* section
;
6961 unsigned char * start ATTRIBUTE_UNUSED
;
6962 FILE * file ATTRIBUTE_UNUSED
;
6964 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6965 SECTION_NAME (section
));
6970 /* Pre-scan the .debug_info section to record the size of address.
6971 When dumping the .debug_line, we use that size information, assuming
6972 that all compilation units have the same address size. */
6974 prescan_debug_info (section
, start
, file
)
6975 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
6976 unsigned char * start
;
6977 FILE * file ATTRIBUTE_UNUSED
;
6979 DWARF2_External_CompUnit
* external
;
6981 external
= (DWARF2_External_CompUnit
*) start
;
6983 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6987 /* A structure containing the name of a debug section and a pointer
6988 to a function that can decode it. The third field is a prescan
6989 function to be run over the section before displaying any of the
6994 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6995 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6999 { ".debug_info", display_debug_info
, prescan_debug_info
},
7000 { ".debug_abbrev", display_debug_abbrev
, NULL
},
7001 { ".debug_line", display_debug_lines
, NULL
},
7002 { ".debug_aranges", display_debug_aranges
, NULL
},
7003 { ".debug_pubnames", display_debug_pubnames
, NULL
},
7004 { ".debug_frame", display_debug_frames
, NULL
},
7005 { ".eh_frame", display_debug_frames
, NULL
},
7006 { ".debug_macinfo", display_debug_not_supported
, NULL
},
7007 { ".debug_frame", display_debug_not_supported
, NULL
},
7008 { ".debug_str", display_debug_not_supported
, NULL
},
7009 { ".debug_static_func", display_debug_not_supported
, NULL
},
7010 { ".debug_static_vars", display_debug_not_supported
, NULL
},
7011 { ".debug_types", display_debug_not_supported
, NULL
},
7012 { ".debug_weaknames", display_debug_not_supported
, NULL
}
7016 display_debug_section (section
, file
)
7017 Elf32_Internal_Shdr
* section
;
7020 char * name
= SECTION_NAME (section
);
7021 bfd_size_type length
;
7022 unsigned char * start
;
7025 length
= section
->sh_size
;
7028 printf (_("\nSection '%s' has no debugging data.\n"), name
);
7032 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
7033 "debug section data");
7035 /* See if we know how to display the contents of this section. */
7036 for (i
= NUM_ELEM (debug_displays
); i
--;)
7037 if (strcmp (debug_displays
[i
].name
, name
) == 0)
7039 debug_displays
[i
].display (section
, start
, file
);
7044 printf (_("Unrecognised debug section: %s\n"), name
);
7048 /* If we loaded in the abbrev section at some point,
7049 we must release it here. */
7050 if (first_abbrev
!= NULL
)
7057 process_section_contents (file
)
7060 Elf32_Internal_Shdr
* section
;
7066 /* Pre-scan the debug sections to find some debug information not
7067 present in some of them. For the .debug_line, we must find out the
7068 size of address (specified in .debug_info and .debug_aranges). */
7069 for (i
= 0, section
= section_headers
;
7070 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7073 char * name
= SECTION_NAME (section
);
7076 if (section
->sh_size
== 0)
7079 /* See if there is some pre-scan operation for this section. */
7080 for (j
= NUM_ELEM (debug_displays
); j
--;)
7081 if (strcmp (debug_displays
[j
].name
, name
) == 0)
7083 if (debug_displays
[j
].prescan
!= NULL
)
7085 bfd_size_type length
;
7086 unsigned char * start
;
7088 length
= section
->sh_size
;
7089 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
7090 "debug section data");
7092 debug_displays
[j
].prescan (section
, start
, file
);
7100 for (i
= 0, section
= section_headers
;
7101 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7104 #ifdef SUPPORT_DISASSEMBLY
7105 if (dump_sects
[i
] & DISASS_DUMP
)
7106 disassemble_section (section
, file
);
7108 if (dump_sects
[i
] & HEX_DUMP
)
7109 dump_section (section
, file
);
7111 if (dump_sects
[i
] & DEBUG_DUMP
)
7112 display_debug_section (section
, file
);
7115 if (i
< num_dump_sects
)
7116 warn (_("Some sections were not dumped because they do not exist!\n"));
7122 process_mips_fpe_exception (mask
)
7128 if (mask
& OEX_FPU_INEX
)
7129 fputs ("INEX", stdout
), first
= 0;
7130 if (mask
& OEX_FPU_UFLO
)
7131 printf ("%sUFLO", first
? "" : "|"), first
= 0;
7132 if (mask
& OEX_FPU_OFLO
)
7133 printf ("%sOFLO", first
? "" : "|"), first
= 0;
7134 if (mask
& OEX_FPU_DIV0
)
7135 printf ("%sDIV0", first
? "" : "|"), first
= 0;
7136 if (mask
& OEX_FPU_INVAL
)
7137 printf ("%sINVAL", first
? "" : "|");
7140 fputs ("0", stdout
);
7144 process_mips_specific (file
)
7147 Elf_Internal_Dyn
* entry
;
7148 size_t liblist_offset
= 0;
7149 size_t liblistno
= 0;
7150 size_t conflictsno
= 0;
7151 size_t options_offset
= 0;
7152 size_t conflicts_offset
= 0;
7154 /* We have a lot of special sections. Thanks SGI! */
7155 if (dynamic_segment
== NULL
)
7156 /* No information available. */
7159 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
7160 switch (entry
->d_tag
)
7162 case DT_MIPS_LIBLIST
:
7163 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
7165 case DT_MIPS_LIBLISTNO
:
7166 liblistno
= entry
->d_un
.d_val
;
7168 case DT_MIPS_OPTIONS
:
7169 options_offset
= entry
->d_un
.d_val
- loadaddr
;
7171 case DT_MIPS_CONFLICT
:
7172 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
7174 case DT_MIPS_CONFLICTNO
:
7175 conflictsno
= entry
->d_un
.d_val
;
7181 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
7183 Elf32_External_Lib
* elib
;
7186 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
7187 elib
, Elf32_External_Lib
*, "liblist");
7189 printf ("\nSection '.liblist' contains %lu entries:\n",
7190 (unsigned long) liblistno
);
7191 fputs (" Library Time Stamp Checksum Version Flags\n",
7194 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
7201 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
7202 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
7203 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
7204 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
7205 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
7207 tmp
= gmtime (&time
);
7208 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
7209 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7210 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7212 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
7213 dynamic_strings
+ liblist
.l_name
, timebuf
,
7214 liblist
.l_checksum
, liblist
.l_version
);
7216 if (liblist
.l_flags
== 0)
7227 { " EXACT_MATCH", LL_EXACT_MATCH
},
7228 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
7229 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
7230 { " EXPORTS", LL_EXPORTS
},
7231 { " DELAY_LOAD", LL_DELAY_LOAD
},
7232 { " DELTA", LL_DELTA
}
7234 int flags
= liblist
.l_flags
;
7238 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
7240 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
7242 fputs (l_flags_vals
[fcnt
].name
, stdout
);
7243 flags
^= l_flags_vals
[fcnt
].bit
;
7246 printf (" %#x", (unsigned int) flags
);
7255 if (options_offset
!= 0)
7257 Elf_External_Options
* eopt
;
7258 Elf_Internal_Shdr
* sect
= section_headers
;
7259 Elf_Internal_Options
* iopt
;
7260 Elf_Internal_Options
* option
;
7264 /* Find the section header so that we get the size. */
7265 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
7268 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
7269 Elf_External_Options
*, "options");
7271 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
7275 error (_("Out of memory"));
7282 while (offset
< sect
->sh_size
)
7284 Elf_External_Options
* eoption
;
7286 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
7288 option
->kind
= BYTE_GET (eoption
->kind
);
7289 option
->size
= BYTE_GET (eoption
->size
);
7290 option
->section
= BYTE_GET (eoption
->section
);
7291 option
->info
= BYTE_GET (eoption
->info
);
7293 offset
+= option
->size
;
7299 printf (_("\nSection '%s' contains %d entries:\n"),
7300 string_table
+ sect
->sh_name
, cnt
);
7308 switch (option
->kind
)
7311 /* This shouldn't happen. */
7312 printf (" NULL %d %lx", option
->section
, option
->info
);
7315 printf (" REGINFO ");
7316 if (elf_header
.e_machine
== EM_MIPS
)
7319 Elf32_External_RegInfo
*ereg
;
7320 Elf32_RegInfo reginfo
;
7322 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
7323 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
7324 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
7325 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
7326 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
7327 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
7328 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
7330 printf ("GPR %08lx GP 0x%lx\n",
7332 (unsigned long) reginfo
.ri_gp_value
);
7333 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7334 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
7335 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
7340 Elf64_External_RegInfo
* ereg
;
7341 Elf64_Internal_RegInfo reginfo
;
7343 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
7344 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
7345 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
7346 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
7347 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
7348 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
7349 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
7351 printf ("GPR %08lx GP 0x",
7352 reginfo
.ri_gprmask
);
7353 printf_vma (reginfo
.ri_gp_value
);
7356 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7357 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
7358 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
7362 case ODK_EXCEPTIONS
:
7363 fputs (" EXCEPTIONS fpe_min(", stdout
);
7364 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
7365 fputs (") fpe_max(", stdout
);
7366 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
7367 fputs (")", stdout
);
7369 if (option
->info
& OEX_PAGE0
)
7370 fputs (" PAGE0", stdout
);
7371 if (option
->info
& OEX_SMM
)
7372 fputs (" SMM", stdout
);
7373 if (option
->info
& OEX_FPDBUG
)
7374 fputs (" FPDBUG", stdout
);
7375 if (option
->info
& OEX_DISMISS
)
7376 fputs (" DISMISS", stdout
);
7379 fputs (" PAD ", stdout
);
7380 if (option
->info
& OPAD_PREFIX
)
7381 fputs (" PREFIX", stdout
);
7382 if (option
->info
& OPAD_POSTFIX
)
7383 fputs (" POSTFIX", stdout
);
7384 if (option
->info
& OPAD_SYMBOL
)
7385 fputs (" SYMBOL", stdout
);
7388 fputs (" HWPATCH ", stdout
);
7389 if (option
->info
& OHW_R4KEOP
)
7390 fputs (" R4KEOP", stdout
);
7391 if (option
->info
& OHW_R8KPFETCH
)
7392 fputs (" R8KPFETCH", stdout
);
7393 if (option
->info
& OHW_R5KEOP
)
7394 fputs (" R5KEOP", stdout
);
7395 if (option
->info
& OHW_R5KCVTL
)
7396 fputs (" R5KCVTL", stdout
);
7399 fputs (" FILL ", stdout
);
7400 /* XXX Print content of info word? */
7403 fputs (" TAGS ", stdout
);
7404 /* XXX Print content of info word? */
7407 fputs (" HWAND ", stdout
);
7408 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
7409 fputs (" R4KEOP_CHECKED", stdout
);
7410 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
7411 fputs (" R4KEOP_CLEAN", stdout
);
7414 fputs (" HWOR ", stdout
);
7415 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
7416 fputs (" R4KEOP_CHECKED", stdout
);
7417 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
7418 fputs (" R4KEOP_CLEAN", stdout
);
7421 printf (" GP_GROUP %#06lx self-contained %#06lx",
7422 option
->info
& OGP_GROUP
,
7423 (option
->info
& OGP_SELF
) >> 16);
7426 printf (" IDENT %#06lx self-contained %#06lx",
7427 option
->info
& OGP_GROUP
,
7428 (option
->info
& OGP_SELF
) >> 16);
7431 /* This shouldn't happen. */
7432 printf (" %3d ??? %d %lx",
7433 option
->kind
, option
->section
, option
->info
);
7437 len
= sizeof (*eopt
);
7438 while (len
< option
->size
)
7439 if (((char *) option
)[len
] >= ' '
7440 && ((char *) option
)[len
] < 0x7f)
7441 printf ("%c", ((char *) option
)[len
++]);
7443 printf ("\\%03o", ((char *) option
)[len
++]);
7445 fputs ("\n", stdout
);
7452 if (conflicts_offset
!= 0 && conflictsno
!= 0)
7454 Elf32_External_Conflict
* econf32
;
7455 Elf64_External_Conflict
* econf64
;
7456 Elf32_Conflict
* iconf
;
7459 if (dynamic_symbols
== NULL
)
7461 error (_("conflict list with without table"));
7465 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
7468 error (_("Out of memory"));
7474 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
7475 econf32
, Elf32_External_Conflict
*, "conflict");
7477 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
7478 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
7482 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
7483 econf64
, Elf64_External_Conflict
*, "conflict");
7485 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
7486 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
7489 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
7490 puts (_(" Num: Index Value Name"));
7492 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
7494 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
7496 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
7497 print_vma (psym
->st_value
, FULL_HEX
);
7498 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
7508 get_note_type (e_type
)
7511 static char buff
[64];
7515 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
7516 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
7517 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
7518 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
7519 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
7520 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
7521 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
7522 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
7523 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
7524 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7525 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7527 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
7532 /* Note that by the ELF standard, the name field is already null byte
7533 terminated, and namesz includes the terminating null byte.
7534 I.E. the value of namesz for the name "FSF" is 4.
7536 If the value of namesz is zero, there is no name present. */
7538 process_note (pnote
)
7539 Elf32_Internal_Note
* pnote
;
7541 printf (" %s\t\t0x%08lx\t%s\n",
7542 pnote
->namesz
? pnote
->namedata
: "(NONE)",
7543 pnote
->descsz
, get_note_type (pnote
->type
));
7549 process_corefile_note_segment (file
, offset
, length
)
7554 Elf_External_Note
* pnotes
;
7555 Elf_External_Note
* external
;
7561 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
7565 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7566 (unsigned long) offset
, (unsigned long) length
);
7567 printf (_(" Owner\t\tData size\tDescription\n"));
7569 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
7571 Elf32_Internal_Note inote
;
7574 inote
.type
= BYTE_GET (external
->type
);
7575 inote
.namesz
= BYTE_GET (external
->namesz
);
7576 inote
.namedata
= external
->name
;
7577 inote
.descsz
= BYTE_GET (external
->descsz
);
7578 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
7579 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
7581 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
7583 /* Verify that name is null terminated. It appears that at least
7584 one version of Linux (RedHat 6.0) generates corefiles that don't
7585 comply with the ELF spec by failing to include the null byte in
7587 if (inote
.namedata
[inote
.namesz
] != '\0')
7589 temp
= malloc (inote
.namesz
+ 1);
7593 error (_("Out of memory\n"));
7598 strncpy (temp
, inote
.namedata
, inote
.namesz
);
7599 temp
[inote
.namesz
] = 0;
7601 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7602 inote
.namedata
= temp
;
7605 res
&= process_note (& inote
);
7620 process_corefile_note_segments (file
)
7623 Elf_Internal_Phdr
* program_headers
;
7624 Elf_Internal_Phdr
* segment
;
7628 program_headers
= (Elf_Internal_Phdr
*) malloc
7629 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
7631 if (program_headers
== NULL
)
7633 error (_("Out of memory\n"));
7638 i
= get_32bit_program_headers (file
, program_headers
);
7640 i
= get_64bit_program_headers (file
, program_headers
);
7644 free (program_headers
);
7648 for (i
= 0, segment
= program_headers
;
7649 i
< elf_header
.e_phnum
;
7652 if (segment
->p_type
== PT_NOTE
)
7653 res
&= process_corefile_note_segment (file
,
7654 (bfd_vma
) segment
->p_offset
,
7655 (bfd_vma
) segment
->p_filesz
);
7658 free (program_headers
);
7664 process_corefile_contents (file
)
7667 /* If we have not been asked to display the notes then do nothing. */
7671 /* If file is not a core file then exit. */
7672 if (elf_header
.e_type
!= ET_CORE
)
7675 /* No program headers means no NOTE segment. */
7676 if (elf_header
.e_phnum
== 0)
7678 printf (_("No note segments present in the core file.\n"));
7682 return process_corefile_note_segments (file
);
7686 process_arch_specific (file
)
7692 switch (elf_header
.e_machine
)
7695 case EM_MIPS_RS4_BE
:
7696 return process_mips_specific (file
);
7705 get_file_header (file
)
7708 /* Read in the identity array. */
7709 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
7712 /* Determine how to read the rest of the header. */
7713 switch (elf_header
.e_ident
[EI_DATA
])
7715 default: /* fall through */
7716 case ELFDATANONE
: /* fall through */
7717 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
7718 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
7721 /* For now we only support 32 bit and 64 bit ELF files. */
7722 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
7724 /* Read in the rest of the header. */
7727 Elf32_External_Ehdr ehdr32
;
7729 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
7732 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
7733 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
7734 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
7735 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
7736 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
7737 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
7738 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
7739 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
7740 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
7741 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
7742 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
7743 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
7744 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
7748 Elf64_External_Ehdr ehdr64
;
7750 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7751 we will not be able to cope with the 64bit data found in
7752 64 ELF files. Detect this now and abort before we start
7753 overwritting things. */
7754 if (sizeof (bfd_vma
) < 8)
7756 error (_("This instance of readelf has been built without support for a\n"));
7757 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7761 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
7764 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
7765 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
7766 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
7767 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
7768 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
7769 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
7770 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
7771 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
7772 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
7773 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
7774 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
7775 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
7776 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
7783 process_file (file_name
)
7787 struct stat statbuf
;
7790 if (stat (file_name
, & statbuf
) < 0)
7792 error (_("Cannot stat input file %s.\n"), file_name
);
7796 file
= fopen (file_name
, "rb");
7799 error (_("Input file %s not found.\n"), file_name
);
7803 if (! get_file_header (file
))
7805 error (_("%s: Failed to read file header\n"), file_name
);
7810 /* Initialise per file variables. */
7811 for (i
= NUM_ELEM (version_info
); i
--;)
7812 version_info
[i
] = 0;
7814 for (i
= NUM_ELEM (dynamic_info
); i
--;)
7815 dynamic_info
[i
] = 0;
7817 /* Process the file. */
7819 printf (_("\nFile: %s\n"), file_name
);
7821 if (! process_file_header ())
7827 process_section_headers (file
);
7829 process_program_headers (file
);
7831 process_dynamic_segment (file
);
7833 process_relocs (file
);
7835 process_symbol_table (file
);
7837 process_syminfo (file
);
7839 process_version_sections (file
);
7841 process_section_contents (file
);
7843 process_corefile_contents (file
);
7845 process_arch_specific (file
);
7849 if (section_headers
)
7851 free (section_headers
);
7852 section_headers
= NULL
;
7857 free (string_table
);
7858 string_table
= NULL
;
7861 if (dynamic_strings
)
7863 free (dynamic_strings
);
7864 dynamic_strings
= NULL
;
7867 if (dynamic_symbols
)
7869 free (dynamic_symbols
);
7870 dynamic_symbols
= NULL
;
7871 num_dynamic_syms
= 0;
7874 if (dynamic_syminfo
)
7876 free (dynamic_syminfo
);
7877 dynamic_syminfo
= NULL
;
7881 #ifdef SUPPORT_DISASSEMBLY
7882 /* Needed by the i386 disassembler. For extra credit, someone could
7883 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7887 print_address (unsigned int addr
, FILE * outfile
)
7889 fprintf (outfile
,"0x%8.8x", addr
);
7892 /* Needed by the i386 disassembler. */
7894 db_task_printsym (unsigned int addr
)
7896 print_address (addr
, stderr
);
7905 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7906 setlocale (LC_MESSAGES
, "");
7908 bindtextdomain (PACKAGE
, LOCALEDIR
);
7909 textdomain (PACKAGE
);
7911 parse_args (argc
, argv
);
7913 if (optind
< (argc
- 1))
7916 while (optind
< argc
)
7917 process_file (argv
[optind
++]);
7919 if (dump_sects
!= NULL
)