1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.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"
70 #include "elf/mcore.h"
77 #include "elf/x86-64.h"
83 char * program_name = "readelf";
84 unsigned int dynamic_addr;
85 bfd_size_type dynamic_size;
86 unsigned int rela_addr;
87 unsigned int rela_size;
88 char * dynamic_strings;
90 unsigned long string_table_length;
91 unsigned long num_dynamic_syms;
92 Elf_Internal_Sym * dynamic_symbols;
93 Elf_Internal_Syminfo * dynamic_syminfo;
94 unsigned long dynamic_syminfo_offset;
95 unsigned int dynamic_syminfo_nent;
96 char program_interpreter [64];
97 int dynamic_info[DT_JMPREL + 1];
100 Elf_Internal_Ehdr elf_header;
101 Elf_Internal_Shdr * section_headers;
102 Elf_Internal_Dyn * dynamic_segment;
110 int do_using_dynamic;
118 int do_debug_abbrevs;
120 int do_debug_pubnames;
121 int do_debug_aranges;
123 int do_debug_frames_interp;
124 int do_debug_macinfo;
129 /* A dynamic array of flags indicating which sections require dumping. */
130 char * dump_sects = NULL;
131 unsigned int num_dump_sects = 0;
133 #define HEX_DUMP (1 << 0)
134 #define DISASS_DUMP (1 << 1)
135 #define DEBUG_DUMP (1 << 2)
137 /* How to rpint a vma value. */
138 typedef enum print_mode
150 /* Forward declarations for dumb compilers. */
151 static void print_vma PARAMS ((bfd_vma, print_mode));
152 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
153 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
154 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
155 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
156 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
157 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
158 static const char * get_dynamic_type PARAMS ((unsigned long));
159 static int slurp_rela_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **, unsigned long *));
160 static int slurp_rel_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel **, unsigned long *));
161 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
162 static char * get_file_type PARAMS ((unsigned));
163 static char * get_machine_name PARAMS ((unsigned));
164 static void decode_ARM_machine_flags PARAMS ((unsigned, char []));
165 static char * get_machine_flags PARAMS ((unsigned, unsigned));
166 static const char * get_mips_segment_type PARAMS ((unsigned long));
167 static const char * get_parisc_segment_type PARAMS ((unsigned long));
168 static const char * get_ia64_segment_type PARAMS ((unsigned long));
169 static const char * get_segment_type PARAMS ((unsigned long));
170 static const char * get_mips_section_type_name PARAMS ((unsigned int));
171 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
172 static const char * get_ia64_section_type_name PARAMS ((unsigned int));
173 static const char * get_section_type_name PARAMS ((unsigned int));
174 static const char * get_symbol_binding PARAMS ((unsigned int));
175 static const char * get_symbol_type PARAMS ((unsigned int));
176 static const char * get_symbol_visibility PARAMS ((unsigned int));
177 static const char * get_symbol_index_type PARAMS ((unsigned int));
178 static const char * get_dynamic_flags PARAMS ((bfd_vma));
179 static void usage PARAMS ((void));
180 static void parse_args PARAMS ((int, char **));
181 static int process_file_header PARAMS ((void));
182 static int process_program_headers PARAMS ((FILE *));
183 static int process_section_headers PARAMS ((FILE *));
184 static int process_unwind PARAMS ((FILE *));
185 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
186 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
187 static int process_dynamic_segment PARAMS ((FILE *));
188 static int process_symbol_table PARAMS ((FILE *));
189 static int process_syminfo PARAMS ((FILE *));
190 static int process_section_contents PARAMS ((FILE *));
191 static void process_mips_fpe_exception PARAMS ((int));
192 static int process_mips_specific PARAMS ((FILE *));
193 static int process_file PARAMS ((char *));
194 static int process_relocs PARAMS ((FILE *));
195 static int process_version_sections PARAMS ((FILE *));
196 static char * get_ver_flags PARAMS ((unsigned int));
197 static int get_32bit_section_headers PARAMS ((FILE *));
198 static int get_64bit_section_headers PARAMS ((FILE *));
199 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
200 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
201 static int get_file_header PARAMS ((FILE *));
202 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
203 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
204 static const char * get_elf_section_flags PARAMS ((bfd_vma));
205 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
206 static int get_32bit_dynamic_segment PARAMS ((FILE *));
207 static int get_64bit_dynamic_segment PARAMS ((FILE *));
208 #ifdef SUPPORT_DISASSEMBLY
209 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
211 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
212 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
213 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
214 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
215 static int prescan_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
216 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
217 static int display_debug_pubnames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
218 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
219 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
220 static int display_debug_frames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
221 static int display_debug_macinfo PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
222 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
223 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
224 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
225 static void reset_state_machine PARAMS ((int));
226 static char * get_TAG_name PARAMS ((unsigned long));
227 static char * get_AT_name PARAMS ((unsigned long));
228 static char * get_FORM_name PARAMS ((unsigned long));
229 static void free_abbrevs PARAMS ((void));
230 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
231 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
232 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
233 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
234 static void decode_location_expression PARAMS ((unsigned char *, unsigned int, unsigned long));
235 static void request_dump PARAMS ((unsigned int, char));
236 static const char * get_elf_class PARAMS ((unsigned char));
237 static const char * get_data_encoding PARAMS ((unsigned char));
238 static const char * get_osabi_name PARAMS ((unsigned char));
239 static int guess_is_rela PARAMS ((unsigned long));
240 static char * get_note_type PARAMS ((unsigned int));
241 static int process_note PARAMS ((Elf32_Internal_Note *));
242 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
243 static int process_corefile_note_segments PARAMS ((FILE *));
244 static int process_corefile_contents PARAMS ((FILE *));
245 static int process_arch_specific PARAMS ((FILE *));
247 typedef int Elf32_Word;
255 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
256 ((X)->sh_name >= string_table_length \
257 ? "<corrupt>" : string_table + (X)->sh_name))
259 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
261 #define BYTE_GET(field) byte_get (field, sizeof (field))
263 /* If we can support a 64 bit data type then BFD64 should be defined
264 and sizeof (bfd_vma) == 8. In this case when translating from an
265 external 8 byte field to an internal field, we can assume that the
266 internal field is also 8 bytes wide and so we can extract all the data.
267 If, however, BFD64 is not defined, then we must assume that the
268 internal data structure only has 4 byte wide fields that are the
269 equivalent of the 8 byte wide external counterparts, and so we must
270 truncate the data. */
272 #define BYTE_GET8(field) byte_get (field, -8)
274 #define BYTE_GET8(field) byte_get (field, 8)
277 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
279 #define GET_ELF_SYMBOLS(file, offset, size) \
280 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
281 : get_64bit_elf_symbols (file, offset, size))
285 error VPARAMS ((const char *message, ...))
287 VA_OPEN (args, message);
288 VA_FIXEDARG (args, const char *, message);
290 fprintf (stderr, _("%s: Error: "), program_name);
291 vfprintf (stderr, message, args);
296 warn VPARAMS ((const char *message, ...))
298 VA_OPEN (args, message);
299 VA_FIXEDARG (args, const char *, message);
301 fprintf (stderr, _("%s: Warning: "), program_name);
302 vfprintf (stderr, message, args);
306 static PTR get_data PARAMS ((PTR, FILE *, long, size_t, const char *));
309 get_data (var, file, offset, size, reason)
321 if (fseek (file, offset, SEEK_SET))
323 error (_("Unable to seek to %x for %s\n"), offset, reason);
330 mvar = (PTR) malloc (size);
334 error (_("Out of memory allocating %d bytes for %s\n"),
340 if (fread (mvar, size, 1, file) != 1)
342 error (_("Unable to read in %d bytes of %s\n"), size, reason);
352 byte_get_little_endian (field, size)
353 unsigned char * field;
362 return ((unsigned int) (field [0]))
363 | (((unsigned int) (field [1])) << 8);
367 /* We want to extract data from an 8 byte wide field and
368 place it into a 4 byte wide field. Since this is a little
369 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);
381 /* This is a special case, generated by the BYTE_GET8 macro.
382 It means that we are loading an 8 byte value from a field
383 in an external structure into an 8 byte value in a field
384 in an internal strcuture. */
385 return ((bfd_vma) (field [0]))
386 | (((bfd_vma) (field [1])) << 8)
387 | (((bfd_vma) (field [2])) << 16)
388 | (((bfd_vma) (field [3])) << 24)
389 | (((bfd_vma) (field [4])) << 32)
390 | (((bfd_vma) (field [5])) << 40)
391 | (((bfd_vma) (field [6])) << 48)
392 | (((bfd_vma) (field [7])) << 56);
395 error (_("Unhandled data length: %d\n"), size);
400 /* Print a VMA value. */
402 print_vma (vma, mode)
412 case FULL_HEX: printf ("0x"); /* drop through */
413 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
414 case PREFIX_HEX: printf ("0x"); /* drop through */
415 case HEX: printf ("%lx", (unsigned long) vma); break;
416 case DEC: printf ("%ld", (unsigned long) vma); break;
417 case DEC_5: printf ("%5ld", (long) vma); break;
418 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
439 #if BFD_HOST_64BIT_LONG
442 if (_bfd_int64_high (vma))
443 printf ("%lx%8.8lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
445 printf ("%lx", _bfd_int64_low (vma));
450 #if BFD_HOST_64BIT_LONG
453 if (_bfd_int64_high (vma))
455 printf ("++%ld", _bfd_int64_low (vma));
457 printf ("%ld", _bfd_int64_low (vma));
462 #if BFD_HOST_64BIT_LONG
463 printf ("%5ld", vma);
465 if (_bfd_int64_high (vma))
467 printf ("++%ld", _bfd_int64_low (vma));
469 printf ("%5ld", _bfd_int64_low (vma));
474 #if BFD_HOST_64BIT_LONG
477 if (_bfd_int64_high (vma))
479 printf ("++%lu", _bfd_int64_low (vma));
481 printf ("%lu", _bfd_int64_low (vma));
490 byte_get_big_endian (field, size)
491 unsigned char * field;
500 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
503 return ((unsigned long) (field [3]))
504 | (((unsigned long) (field [2])) << 8)
505 | (((unsigned long) (field [1])) << 16)
506 | (((unsigned long) (field [0])) << 24);
510 /* Although we are extracing data from an 8 byte wide field, we
511 are returning only 4 bytes of data. */
512 return ((unsigned long) (field [7]))
513 | (((unsigned long) (field [6])) << 8)
514 | (((unsigned long) (field [5])) << 16)
515 | (((unsigned long) (field [4])) << 24);
519 /* This is a special case, generated by the BYTE_GET8 macro.
520 It means that we are loading an 8 byte value from a field
521 in an external structure into an 8 byte value in a field
522 in an internal strcuture. */
523 return ((bfd_vma) (field [7]))
524 | (((bfd_vma) (field [6])) << 8)
525 | (((bfd_vma) (field [5])) << 16)
526 | (((bfd_vma) (field [4])) << 24)
527 | (((bfd_vma) (field [3])) << 32)
528 | (((bfd_vma) (field [2])) << 40)
529 | (((bfd_vma) (field [1])) << 48)
530 | (((bfd_vma) (field [0])) << 56);
534 error (_("Unhandled data length: %d\n"), size);
539 /* Guess the relocation size commonly used by the specific machines. */
542 guess_is_rela (e_machine)
543 unsigned long e_machine;
547 /* Targets that use REL relocations. */
560 /* Targets that use RELA relocations. */
574 case EM_CYGNUS_MN10200:
576 case EM_CYGNUS_MN10300:
611 warn (_("Don't know about relocations on this machine architecture\n"));
617 slurp_rela_relocs (file, rel_offset, rel_size, relasp, nrelasp)
619 unsigned long rel_offset;
620 unsigned long rel_size;
621 Elf_Internal_Rela **relasp;
622 unsigned long *nrelasp;
624 Elf_Internal_Rela *relas;
625 unsigned long nrelas;
630 Elf32_External_Rela * erelas;
632 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset,
633 rel_size, _("relocs"));
637 nrelas = rel_size / sizeof (Elf32_External_Rela);
639 relas = (Elf_Internal_Rela *)
640 malloc (nrelas * sizeof (Elf_Internal_Rela));
644 error(_("out of memory parsing relocs"));
648 for (i = 0; i < nrelas; i++)
650 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
651 relas[i].r_info = BYTE_GET (erelas[i].r_info);
652 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
659 Elf64_External_Rela * erelas;
661 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset,
662 rel_size, _("relocs"));
666 nrelas = rel_size / sizeof (Elf64_External_Rela);
668 relas = (Elf_Internal_Rela *)
669 malloc (nrelas * sizeof (Elf_Internal_Rela));
673 error(_("out of memory parsing relocs"));
677 for (i = 0; i < nrelas; i++)
679 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
680 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
681 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
692 slurp_rel_relocs (file, rel_offset, rel_size, relsp, nrelsp)
694 unsigned long rel_offset;
695 unsigned long rel_size;
696 Elf_Internal_Rel **relsp;
697 unsigned long *nrelsp;
699 Elf_Internal_Rel *rels;
705 Elf32_External_Rel * erels;
707 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset,
708 rel_size, _("relocs"));
712 nrels = rel_size / sizeof (Elf32_External_Rel);
714 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
718 error(_("out of memory parsing relocs"));
722 for (i = 0; i < nrels; i++)
724 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
725 rels[i].r_info = BYTE_GET (erels[i].r_info);
732 Elf64_External_Rel * erels;
734 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset,
735 rel_size, _("relocs"));
739 nrels = rel_size / sizeof (Elf64_External_Rel);
741 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
745 error(_("out of memory parsing relocs"));
749 for (i = 0; i < nrels; i++)
751 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
752 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
762 /* Display the contents of the relocation data found at the specified offset. */
764 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
766 unsigned long rel_offset;
767 unsigned long rel_size;
768 Elf_Internal_Sym * symtab;
774 Elf_Internal_Rel * rels;
775 Elf_Internal_Rela * relas;
778 if (is_rela == UNKNOWN)
779 is_rela = guess_is_rela (elf_header.e_machine);
783 if (!slurp_rela_relocs (file, rel_offset, rel_size, &relas, &rel_size))
788 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
796 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
799 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
805 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
808 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
811 for (i = 0; i < rel_size; i++)
816 bfd_vma symtab_index;
821 offset = relas [i].r_offset;
822 info = relas [i].r_info;
826 offset = rels [i].r_offset;
827 info = rels [i].r_info;
832 type = ELF32_R_TYPE (info);
833 symtab_index = ELF32_R_SYM (info);
837 if (elf_header.e_machine == EM_SPARCV9)
838 type = ELF64_R_TYPE_ID (info);
840 type = ELF64_R_TYPE (info);
841 /* The #ifdef BFD64 below is to prevent a compile time warning.
842 We know that if we do not have a 64 bit data type that we
843 will never execute this code anyway. */
845 symtab_index = ELF64_R_SYM (info);
851 #ifdef _bfd_int64_low
852 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
854 printf ("%8.8lx %8.8lx ", offset, info);
859 #ifdef _bfd_int64_low
860 printf ("%8.8lx%8.8lx %8.8lx%8.8lx ",
861 _bfd_int64_high (offset),
862 _bfd_int64_low (offset),
863 _bfd_int64_high (info),
864 _bfd_int64_low (info));
866 printf ("%16.16lx %16.16lx ", offset, info);
870 switch (elf_header.e_machine)
878 rtype = elf_m32r_reloc_type (type);
883 rtype = elf_i386_reloc_type (type);
887 rtype = elf_m68k_reloc_type (type);
891 rtype = elf_i960_reloc_type (type);
896 rtype = elf_avr_reloc_type (type);
903 rtype = elf_sparc_reloc_type (type);
908 rtype = v850_reloc_type (type);
913 rtype = elf_d10v_reloc_type (type);
918 rtype = elf_d30v_reloc_type (type);
922 rtype = elf_sh_reloc_type (type);
926 case EM_CYGNUS_MN10300:
927 rtype = elf_mn10300_reloc_type (type);
931 case EM_CYGNUS_MN10200:
932 rtype = elf_mn10200_reloc_type (type);
937 rtype = elf_fr30_reloc_type (type);
941 rtype = elf_mcore_reloc_type (type);
946 rtype = elf_ppc_reloc_type (type);
951 rtype = elf_mips_reloc_type (type);
955 rtype = elf_alpha_reloc_type (type);
959 rtype = elf_arm_reloc_type (type);
963 rtype = elf_arc_reloc_type (type);
967 rtype = elf_hppa_reloc_type (type);
973 rtype = elf_h8_reloc_type (type);
978 rtype = elf_pj_reloc_type (type);
981 rtype = elf_ia64_reloc_type (type);
985 rtype = elf_cris_reloc_type (type);
989 rtype = elf_i860_reloc_type (type);
993 rtype = elf_x86_64_reloc_type (type);
998 rtype = elf_s390_reloc_type (type);
1003 #ifdef _bfd_int64_low
1004 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
1006 printf (_("unrecognised: %-7lx"), type);
1009 printf ("%-21.21s", rtype);
1013 if (symtab == NULL || symtab_index >= nsyms)
1014 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1017 Elf_Internal_Sym * psym;
1019 psym = symtab + symtab_index;
1022 print_vma (psym->st_value, LONG_HEX);
1025 if (psym->st_name == 0)
1027 SECTION_NAME (section_headers + psym->st_shndx));
1028 else if (strtab == NULL)
1029 printf (_("<string table index %3ld>"), psym->st_name);
1031 printf ("%-25.25s", strtab + psym->st_name);
1034 printf (" + %lx", (unsigned long) relas [i].r_addend);
1039 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
1040 print_vma (relas[i].r_addend, LONG_HEX);
1043 if (elf_header.e_machine == EM_SPARCV9
1044 && !strcmp (rtype, "R_SPARC_OLO10"))
1045 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1059 get_mips_dynamic_type (type)
1064 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1065 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1066 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1067 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1068 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1069 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1070 case DT_MIPS_MSYM: return "MIPS_MSYM";
1071 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1072 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1073 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1074 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1075 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1076 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1077 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1078 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1079 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1080 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1081 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1082 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1083 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1084 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1085 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1086 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1087 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1088 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1089 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1090 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1091 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1092 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1093 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1094 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1095 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1096 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1097 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1098 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1099 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1100 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1101 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1102 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1103 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1104 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1105 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1106 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1113 get_sparc64_dynamic_type (type)
1118 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1125 get_parisc_dynamic_type (type)
1130 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1131 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1132 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1133 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1134 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1135 case DT_HP_PREINIT: return "HP_PREINIT";
1136 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1137 case DT_HP_NEEDED: return "HP_NEEDED";
1138 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1139 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1140 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1141 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1142 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1149 get_dynamic_type (type)
1152 static char buff [32];
1156 case DT_NULL: return "NULL";
1157 case DT_NEEDED: return "NEEDED";
1158 case DT_PLTRELSZ: return "PLTRELSZ";
1159 case DT_PLTGOT: return "PLTGOT";
1160 case DT_HASH: return "HASH";
1161 case DT_STRTAB: return "STRTAB";
1162 case DT_SYMTAB: return "SYMTAB";
1163 case DT_RELA: return "RELA";
1164 case DT_RELASZ: return "RELASZ";
1165 case DT_RELAENT: return "RELAENT";
1166 case DT_STRSZ: return "STRSZ";
1167 case DT_SYMENT: return "SYMENT";
1168 case DT_INIT: return "INIT";
1169 case DT_FINI: return "FINI";
1170 case DT_SONAME: return "SONAME";
1171 case DT_RPATH: return "RPATH";
1172 case DT_SYMBOLIC: return "SYMBOLIC";
1173 case DT_REL: return "REL";
1174 case DT_RELSZ: return "RELSZ";
1175 case DT_RELENT: return "RELENT";
1176 case DT_PLTREL: return "PLTREL";
1177 case DT_DEBUG: return "DEBUG";
1178 case DT_TEXTREL: return "TEXTREL";
1179 case DT_JMPREL: return "JMPREL";
1180 case DT_BIND_NOW: return "BIND_NOW";
1181 case DT_INIT_ARRAY: return "INIT_ARRAY";
1182 case DT_FINI_ARRAY: return "FINI_ARRAY";
1183 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1184 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1185 case DT_RUNPATH: return "RUNPATH";
1186 case DT_FLAGS: return "FLAGS";
1188 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1189 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1191 case DT_CHECKSUM: return "CHECKSUM";
1192 case DT_PLTPADSZ: return "PLTPADSZ";
1193 case DT_MOVEENT: return "MOVEENT";
1194 case DT_MOVESZ: return "MOVESZ";
1195 case DT_FEATURE: return "FEATURE";
1196 case DT_POSFLAG_1: return "POSFLAG_1";
1197 case DT_SYMINSZ: return "SYMINSZ";
1198 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1200 case DT_ADDRRNGLO: return "ADDRRNGLO";
1201 case DT_CONFIG: return "CONFIG";
1202 case DT_DEPAUDIT: return "DEPAUDIT";
1203 case DT_AUDIT: return "AUDIT";
1204 case DT_PLTPAD: return "PLTPAD";
1205 case DT_MOVETAB: return "MOVETAB";
1206 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1208 case DT_VERSYM: return "VERSYM";
1210 case DT_RELACOUNT: return "RELACOUNT";
1211 case DT_RELCOUNT: return "RELCOUNT";
1212 case DT_FLAGS_1: return "FLAGS_1";
1213 case DT_VERDEF: return "VERDEF";
1214 case DT_VERDEFNUM: return "VERDEFNUM";
1215 case DT_VERNEED: return "VERNEED";
1216 case DT_VERNEEDNUM: return "VERNEEDNUM";
1218 case DT_AUXILIARY: return "AUXILIARY";
1219 case DT_USED: return "USED";
1220 case DT_FILTER: return "FILTER";
1223 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1225 const char * result;
1227 switch (elf_header.e_machine)
1230 case EM_MIPS_RS3_LE:
1231 result = get_mips_dynamic_type (type);
1234 result = get_sparc64_dynamic_type (type);
1244 sprintf (buff, _("Processor Specific: %lx"), type);
1246 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1248 const char * result;
1250 switch (elf_header.e_machine)
1253 result = get_parisc_dynamic_type (type);
1263 sprintf (buff, _("Operating System specific: %lx"), type);
1266 sprintf (buff, _("<unknown>: %lx"), type);
1273 get_file_type (e_type)
1276 static char buff [32];
1280 case ET_NONE: return _("NONE (None)");
1281 case ET_REL: return _("REL (Relocatable file)");
1282 case ET_EXEC: return _("EXEC (Executable file)");
1283 case ET_DYN: return _("DYN (Shared object file)");
1284 case ET_CORE: return _("CORE (Core file)");
1287 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1288 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1289 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1290 sprintf (buff, _("OS Specific: (%x)"), e_type);
1292 sprintf (buff, _("<unknown>: %x"), e_type);
1298 get_machine_name (e_machine)
1301 static char buff [64]; /* XXX */
1305 case EM_NONE: return _("None");
1306 case EM_M32: return "WE32100";
1307 case EM_SPARC: return "Sparc";
1308 case EM_386: return "Intel 80386";
1309 case EM_68K: return "MC68000";
1310 case EM_88K: return "MC88000";
1311 case EM_486: return "Intel 80486";
1312 case EM_860: return "Intel 80860";
1313 case EM_MIPS: return "MIPS R3000";
1314 case EM_S370: return "IBM System/370";
1315 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1316 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1317 case EM_PARISC: return "HPPA";
1318 case EM_PPC_OLD: return "Power PC (old)";
1319 case EM_SPARC32PLUS: return "Sparc v8+" ;
1320 case EM_960: return "Intel 90860";
1321 case EM_PPC: return "PowerPC";
1322 case EM_V800: return "NEC V800";
1323 case EM_FR20: return "Fujitsu FR20";
1324 case EM_RH32: return "TRW RH32";
1325 case EM_MCORE: return "MCORE";
1326 case EM_ARM: return "ARM";
1327 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1328 case EM_SH: return "Hitachi SH";
1329 case EM_SPARCV9: return "Sparc v9";
1330 case EM_TRICORE: return "Siemens Tricore";
1331 case EM_ARC: return "ARC";
1332 case EM_H8_300: return "Hitachi H8/300";
1333 case EM_H8_300H: return "Hitachi H8/300H";
1334 case EM_H8S: return "Hitachi H8S";
1335 case EM_H8_500: return "Hitachi H8/500";
1336 case EM_IA_64: return "Intel IA-64";
1337 case EM_MIPS_X: return "Stanford MIPS-X";
1338 case EM_COLDFIRE: return "Motorola Coldfire";
1339 case EM_68HC12: return "Motorola M68HC12";
1340 case EM_ALPHA: return "Alpha";
1341 case EM_CYGNUS_D10V:
1342 case EM_D10V: return "d10v";
1343 case EM_CYGNUS_D30V:
1344 case EM_D30V: return "d30v";
1345 case EM_CYGNUS_M32R:
1346 case EM_M32R: return "Mitsubishi M32r";
1347 case EM_CYGNUS_V850:
1348 case EM_V850: return "NEC v850";
1349 case EM_CYGNUS_MN10300:
1350 case EM_MN10300: return "mn10300";
1351 case EM_CYGNUS_MN10200:
1352 case EM_MN10200: return "mn10200";
1353 case EM_CYGNUS_FR30:
1354 case EM_FR30: return "Fujitsu FR30";
1356 case EM_PJ: return "picoJava";
1357 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1358 case EM_PCP: return "Siemens PCP";
1359 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1360 case EM_NDR1: return "Denso NDR1 microprocesspr";
1361 case EM_STARCORE: return "Motorola Star*Core processor";
1362 case EM_ME16: return "Toyota ME16 processor";
1363 case EM_ST100: return "STMicroelectronics ST100 processor";
1364 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1365 case EM_FX66: return "Siemens FX66 microcontroller";
1366 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1367 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1368 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1369 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1370 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1371 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1372 case EM_SVX: return "Silicon Graphics SVx";
1373 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1374 case EM_VAX: return "Digital VAX";
1376 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1377 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1378 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1379 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1380 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1381 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1382 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1383 case EM_PRISM: return "SiTera Prism";
1384 case EM_X86_64: return "Advanced Micro Devices X86-64";
1386 case EM_S390: return "IBM S/390";
1388 sprintf (buff, _("<unknown>: %x"), e_machine);
1394 decode_ARM_machine_flags (e_flags, buf)
1401 eabi = EF_ARM_EABI_VERSION (e_flags);
1402 e_flags &= ~ EF_ARM_EABIMASK;
1404 /* Handle "generic" ARM flags. */
1405 if (e_flags & EF_ARM_RELEXEC)
1407 strcat (buf, ", relocatable executable");
1408 e_flags &= ~ EF_ARM_RELEXEC;
1411 if (e_flags & EF_ARM_HASENTRY)
1413 strcat (buf, ", has entry point");
1414 e_flags &= ~ EF_ARM_HASENTRY;
1417 /* Now handle EABI specific flags. */
1421 strcat (buf, ", <unrecognised EABI>");
1426 case EF_ARM_EABI_VER1:
1427 strcat (buf, ", Version1 EABI");
1432 /* Process flags one bit at a time. */
1433 flag = e_flags & - e_flags;
1438 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1439 strcat (buf, ", sorted symbol tables");
1449 case EF_ARM_EABI_VER2:
1450 strcat (buf, ", Version2 EABI");
1455 /* Process flags one bit at a time. */
1456 flag = e_flags & - e_flags;
1461 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1462 strcat (buf, ", sorted symbol tables");
1465 case EF_ARM_DYNSYMSUSESEGIDX:
1466 strcat (buf, ", dynamic symbols use segment index");
1469 case EF_ARM_MAPSYMSFIRST:
1470 strcat (buf, ", mapping symbols precede others");
1480 case EF_ARM_EABI_UNKNOWN:
1481 strcat (buf, ", GNU EABI");
1486 /* Process flags one bit at a time. */
1487 flag = e_flags & - e_flags;
1492 case EF_ARM_INTERWORK:
1493 strcat (buf, ", interworking enabled");
1496 case EF_ARM_APCS_26:
1497 strcat (buf, ", uses APCS/26");
1500 case EF_ARM_APCS_FLOAT:
1501 strcat (buf, ", uses APCS/float");
1505 strcat (buf, ", position independent");
1509 strcat (buf, ", 8 bit structure alignment");
1512 case EF_ARM_NEW_ABI:
1513 strcat (buf, ", uses new ABI");
1516 case EF_ARM_OLD_ABI:
1517 strcat (buf, ", uses old ABI");
1520 case EF_ARM_SOFT_FLOAT:
1521 strcat (buf, ", software FP");
1532 strcat (buf,", <unknown>");
1536 get_machine_flags (e_flags, e_machine)
1540 static char buf [1024];
1552 decode_ARM_machine_flags (e_flags, buf);
1556 if (e_flags & EF_CPU32)
1557 strcat (buf, ", cpu32");
1561 if (e_flags & EF_PPC_EMB)
1562 strcat (buf, ", emb");
1564 if (e_flags & EF_PPC_RELOCATABLE)
1565 strcat (buf, ", relocatable");
1567 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1568 strcat (buf, ", relocatable-lib");
1572 case EM_CYGNUS_V850:
1573 switch (e_flags & EF_V850_ARCH)
1576 strcat (buf, ", v850e");
1579 strcat (buf, ", v850ea");
1582 strcat (buf, ", v850");
1585 strcat (buf, ", unknown v850 architecture variant");
1591 case EM_CYGNUS_M32R:
1592 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1593 strcat (buf, ", m32r");
1598 case EM_MIPS_RS3_LE:
1599 if (e_flags & EF_MIPS_NOREORDER)
1600 strcat (buf, ", noreorder");
1602 if (e_flags & EF_MIPS_PIC)
1603 strcat (buf, ", pic");
1605 if (e_flags & EF_MIPS_CPIC)
1606 strcat (buf, ", cpic");
1608 if (e_flags & EF_MIPS_UCODE)
1609 strcat (buf, ", ugen_reserved");
1611 if (e_flags & EF_MIPS_ABI2)
1612 strcat (buf, ", abi2");
1614 if (e_flags & EF_MIPS_32BITMODE)
1615 strcat (buf, ", 32bitmode");
1617 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1618 strcat (buf, ", mips1");
1620 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1621 strcat (buf, ", mips2");
1623 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1624 strcat (buf, ", mips3");
1626 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1627 strcat (buf, ", mips4");
1629 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
1630 strcat (buf, ", mips5");
1632 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
1633 strcat (buf, ", mips32");
1635 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
1636 strcat (buf, ", mips64");
1638 switch ((e_flags & EF_MIPS_MACH))
1640 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1641 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1642 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1643 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1644 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1645 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1646 default: strcat (buf, " UNKNOWN"); break;
1651 if (e_flags & EF_SPARC_32PLUS)
1652 strcat (buf, ", v8+");
1654 if (e_flags & EF_SPARC_SUN_US1)
1655 strcat (buf, ", ultrasparcI");
1657 if (e_flags & EF_SPARC_SUN_US3)
1658 strcat (buf, ", ultrasparcIII");
1660 if (e_flags & EF_SPARC_HAL_R1)
1661 strcat (buf, ", halr1");
1663 if (e_flags & EF_SPARC_LEDATA)
1664 strcat (buf, ", ledata");
1666 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1667 strcat (buf, ", tso");
1669 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1670 strcat (buf, ", pso");
1672 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1673 strcat (buf, ", rmo");
1677 switch (e_flags & EF_PARISC_ARCH)
1679 case EFA_PARISC_1_0:
1680 strcpy (buf, ", PA-RISC 1.0");
1682 case EFA_PARISC_1_1:
1683 strcpy (buf, ", PA-RISC 1.1");
1685 case EFA_PARISC_2_0:
1686 strcpy (buf, ", PA-RISC 2.0");
1691 if (e_flags & EF_PARISC_TRAPNIL)
1692 strcat (buf, ", trapnil");
1693 if (e_flags & EF_PARISC_EXT)
1694 strcat (buf, ", ext");
1695 if (e_flags & EF_PARISC_LSB)
1696 strcat (buf, ", lsb");
1697 if (e_flags & EF_PARISC_WIDE)
1698 strcat (buf, ", wide");
1699 if (e_flags & EF_PARISC_NO_KABP)
1700 strcat (buf, ", no kabp");
1701 if (e_flags & EF_PARISC_LAZYSWAP)
1702 strcat (buf, ", lazyswap");
1707 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1708 strcat (buf, ", new calling convention");
1710 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1711 strcat (buf, ", gnu calling convention");
1715 if ((e_flags & EF_IA_64_ABI64))
1716 strcat (buf, ", 64-bit");
1718 strcat (buf, ", 32-bit");
1719 if ((e_flags & EF_IA_64_REDUCEDFP))
1720 strcat (buf, ", reduced fp model");
1721 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
1722 strcat (buf, ", no function descriptors, constant gp");
1723 else if ((e_flags & EF_IA_64_CONS_GP))
1724 strcat (buf, ", constant gp");
1725 if ((e_flags & EF_IA_64_ABSOLUTE))
1726 strcat (buf, ", absolute");
1735 get_mips_segment_type (type)
1740 case PT_MIPS_REGINFO:
1742 case PT_MIPS_RTPROC:
1744 case PT_MIPS_OPTIONS:
1754 get_parisc_segment_type (type)
1759 case PT_HP_TLS: return "HP_TLS";
1760 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1761 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1762 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1763 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1764 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1765 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1766 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1767 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1768 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1769 case PT_HP_PARALLEL: return "HP_PARALLEL";
1770 case PT_HP_FASTBIND: return "HP_FASTBIND";
1771 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1772 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1781 get_ia64_segment_type (type)
1786 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
1787 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
1796 get_segment_type (p_type)
1797 unsigned long p_type;
1799 static char buff [32];
1803 case PT_NULL: return "NULL";
1804 case PT_LOAD: return "LOAD";
1805 case PT_DYNAMIC: return "DYNAMIC";
1806 case PT_INTERP: return "INTERP";
1807 case PT_NOTE: return "NOTE";
1808 case PT_SHLIB: return "SHLIB";
1809 case PT_PHDR: return "PHDR";
1812 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1814 const char * result;
1816 switch (elf_header.e_machine)
1819 case EM_MIPS_RS3_LE:
1820 result = get_mips_segment_type (p_type);
1823 result = get_parisc_segment_type (p_type);
1826 result = get_ia64_segment_type (p_type);
1836 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1838 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1840 const char * result;
1842 switch (elf_header.e_machine)
1845 result = get_parisc_segment_type (p_type);
1855 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1858 sprintf (buff, _("<unknown>: %lx"), p_type);
1865 get_mips_section_type_name (sh_type)
1866 unsigned int sh_type;
1870 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1871 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1872 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1873 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1874 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1875 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1876 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1877 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1878 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1879 case SHT_MIPS_RELD: return "MIPS_RELD";
1880 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1881 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1882 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1883 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1884 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1885 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1886 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1887 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1888 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1889 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1890 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1891 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1892 case SHT_MIPS_LINE: return "MIPS_LINE";
1893 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1894 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1895 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1896 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1897 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1898 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1899 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1900 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1901 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1902 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1903 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1904 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1905 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1906 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1907 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1908 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1916 get_parisc_section_type_name (sh_type)
1917 unsigned int sh_type;
1921 case SHT_PARISC_EXT: return "PARISC_EXT";
1922 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1923 case SHT_PARISC_DOC: return "PARISC_DOC";
1931 get_ia64_section_type_name (sh_type)
1932 unsigned int sh_type;
1936 case SHT_IA_64_EXT: return "IA_64_EXT";
1937 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
1945 get_section_type_name (sh_type)
1946 unsigned int sh_type;
1948 static char buff [32];
1952 case SHT_NULL: return "NULL";
1953 case SHT_PROGBITS: return "PROGBITS";
1954 case SHT_SYMTAB: return "SYMTAB";
1955 case SHT_STRTAB: return "STRTAB";
1956 case SHT_RELA: return "RELA";
1957 case SHT_HASH: return "HASH";
1958 case SHT_DYNAMIC: return "DYNAMIC";
1959 case SHT_NOTE: return "NOTE";
1960 case SHT_NOBITS: return "NOBITS";
1961 case SHT_REL: return "REL";
1962 case SHT_SHLIB: return "SHLIB";
1963 case SHT_DYNSYM: return "DYNSYM";
1964 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1965 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1966 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1967 case SHT_GROUP: return "GROUP";
1968 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
1969 case SHT_GNU_verdef: return "VERDEF";
1970 case SHT_GNU_verneed: return "VERNEED";
1971 case SHT_GNU_versym: return "VERSYM";
1972 case 0x6ffffff0: return "VERSYM";
1973 case 0x6ffffffc: return "VERDEF";
1974 case 0x7ffffffd: return "AUXILIARY";
1975 case 0x7fffffff: return "FILTER";
1978 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1980 const char * result;
1982 switch (elf_header.e_machine)
1985 case EM_MIPS_RS3_LE:
1986 result = get_mips_section_type_name (sh_type);
1989 result = get_parisc_section_type_name (sh_type);
1992 result = get_ia64_section_type_name (sh_type);
2002 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
2004 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2005 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
2006 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2007 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
2009 sprintf (buff, _("<unknown>: %x"), sh_type);
2015 struct option options [] =
2017 {"all", no_argument, 0, 'a'},
2018 {"file-header", no_argument, 0, 'h'},
2019 {"program-headers", no_argument, 0, 'l'},
2020 {"headers", no_argument, 0, 'e'},
2021 {"histogram", no_argument, 0, 'I'},
2022 {"segments", no_argument, 0, 'l'},
2023 {"sections", no_argument, 0, 'S'},
2024 {"section-headers", no_argument, 0, 'S'},
2025 {"symbols", no_argument, 0, 's'},
2026 {"syms", no_argument, 0, 's'},
2027 {"relocs", no_argument, 0, 'r'},
2028 {"notes", no_argument, 0, 'n'},
2029 {"dynamic", no_argument, 0, 'd'},
2030 {"arch-specific", no_argument, 0, 'A'},
2031 {"version-info", no_argument, 0, 'V'},
2032 {"use-dynamic", no_argument, 0, 'D'},
2033 {"hex-dump", required_argument, 0, 'x'},
2034 {"debug-dump", optional_argument, 0, 'w'},
2035 {"unwind", no_argument, 0, 'u'},
2036 #ifdef SUPPORT_DISASSEMBLY
2037 {"instruction-dump", required_argument, 0, 'i'},
2040 {"version", no_argument, 0, 'v'},
2041 {"wide", no_argument, 0, 'W'},
2042 {"help", no_argument, 0, 'H'},
2043 {0, no_argument, 0, 0}
2049 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
2050 fprintf (stdout, _(" Options are:\n"));
2051 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
2052 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
2053 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
2054 fprintf (stdout, _(" Display the program headers\n"));
2055 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
2056 fprintf (stdout, _(" Display the sections' header\n"));
2057 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
2058 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
2059 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
2060 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
2061 fprintf (stdout, _(" -u or --unwind Display the unwind info (if present)\n"));
2062 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
2063 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
2064 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
2065 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
2066 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
2067 fprintf (stdout, _(" Dump the contents of section <number>\n"));
2068 fprintf (stdout, _(" -w[liaprmf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames]\n"));
2069 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
2070 #ifdef SUPPORT_DISASSEMBLY
2071 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
2072 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
2074 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
2075 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
2076 fprintf (stdout, _(" -W or --wide Don't split lines to fit into 80 columns\n"));
2077 fprintf (stdout, _(" -H or --help Display this information\n"));
2078 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2084 request_dump (section, type)
2085 unsigned int section;
2088 if (section >= num_dump_sects)
2090 char * new_dump_sects;
2092 new_dump_sects = (char *) calloc (section + 1, 1);
2094 if (new_dump_sects == NULL)
2095 error (_("Out of memory allocating dump request table."));
2098 /* Copy current flag settings. */
2099 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2103 dump_sects = new_dump_sects;
2104 num_dump_sects = section + 1;
2109 dump_sects [section] |= type;
2115 parse_args (argc, argv)
2124 while ((c = getopt_long
2125 (argc, argv, "ersuahnldSDAIw::x:i:vVW", options, NULL)) != EOF)
2161 do_using_dynamic ++;
2192 section = strtoul (optarg, & cp, 0);
2193 if (! * cp && section >= 0)
2195 request_dump (section, HEX_DUMP);
2215 do_debug_abbrevs = 1;
2225 do_debug_pubnames = 1;
2230 do_debug_aranges = 1;
2234 do_debug_frames_interp = 1;
2236 do_debug_frames = 1;
2241 do_debug_macinfo = 1;
2245 warn (_("Unrecognised debug option '%s'\n"), optarg);
2250 #ifdef SUPPORT_DISASSEMBLY
2253 section = strtoul (optarg, & cp, 0);
2254 if (! * cp && section >= 0)
2256 request_dump (section, DISASS_DUMP);
2262 print_version (program_name);
2272 /* xgettext:c-format */
2273 error (_("Invalid option '-%c'\n"), c);
2280 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2281 && !do_segments && !do_header && !do_dump && !do_version
2282 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2286 warn (_("Nothing to do.\n"));
2292 get_elf_class (elf_class)
2293 unsigned char elf_class;
2295 static char buff [32];
2299 case ELFCLASSNONE: return _("none");
2300 case ELFCLASS32: return _("ELF32");
2301 case ELFCLASS64: return _("ELF64");
2303 sprintf (buff, _("<unknown: %x>"), elf_class);
2309 get_data_encoding (encoding)
2310 unsigned char encoding;
2312 static char buff [32];
2316 case ELFDATANONE: return _("none");
2317 case ELFDATA2LSB: return _("2's complement, little endian");
2318 case ELFDATA2MSB: return _("2's complement, big endian");
2320 sprintf (buff, _("<unknown: %x>"), encoding);
2326 get_osabi_name (osabi)
2327 unsigned char osabi;
2329 static char buff [32];
2333 case ELFOSABI_NONE: return _("UNIX - System V");
2334 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2335 case ELFOSABI_NETBSD: return _("UNIX - NetBSD");
2336 case ELFOSABI_LINUX: return _("UNIX - Linux");
2337 case ELFOSABI_HURD: return _("GNU/Hurd");
2338 case ELFOSABI_SOLARIS: return _("UNIX - Solaris");
2339 case ELFOSABI_AIX: return _("UNIX - AIX");
2340 case ELFOSABI_IRIX: return _("UNIX - IRIX");
2341 case ELFOSABI_FREEBSD: return _("UNIX - FreeBSD");
2342 case ELFOSABI_TRU64: return _("UNIX - TRU64");
2343 case ELFOSABI_MODESTO: return _("Novell - Modesto");
2344 case ELFOSABI_OPENBSD: return _("UNIX - OpenBSD");
2345 case ELFOSABI_STANDALONE: return _("Standalone App");
2346 case ELFOSABI_ARM: return _("ARM");
2348 sprintf (buff, _("<unknown: %x>"), osabi);
2353 /* Decode the data held in 'elf_header'. */
2355 process_file_header ()
2357 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2358 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2359 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2360 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2363 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2371 printf (_("ELF Header:\n"));
2372 printf (_(" Magic: "));
2373 for (i = 0; i < EI_NIDENT; i ++)
2374 printf ("%2.2x ", elf_header.e_ident [i]);
2376 printf (_(" Class: %s\n"),
2377 get_elf_class (elf_header.e_ident [EI_CLASS]));
2378 printf (_(" Data: %s\n"),
2379 get_data_encoding (elf_header.e_ident [EI_DATA]));
2380 printf (_(" Version: %d %s\n"),
2381 elf_header.e_ident [EI_VERSION],
2382 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2384 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2387 printf (_(" OS/ABI: %s\n"),
2388 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2389 printf (_(" ABI Version: %d\n"),
2390 elf_header.e_ident [EI_ABIVERSION]);
2391 printf (_(" Type: %s\n"),
2392 get_file_type (elf_header.e_type));
2393 printf (_(" Machine: %s\n"),
2394 get_machine_name (elf_header.e_machine));
2395 printf (_(" Version: 0x%lx\n"),
2396 (unsigned long) elf_header.e_version);
2398 printf (_(" Entry point address: "));
2399 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2400 printf (_("\n Start of program headers: "));
2401 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2402 printf (_(" (bytes into file)\n Start of section headers: "));
2403 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2404 printf (_(" (bytes into file)\n"));
2406 printf (_(" Flags: 0x%lx%s\n"),
2407 (unsigned long) elf_header.e_flags,
2408 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2409 printf (_(" Size of this header: %ld (bytes)\n"),
2410 (long) elf_header.e_ehsize);
2411 printf (_(" Size of program headers: %ld (bytes)\n"),
2412 (long) elf_header.e_phentsize);
2413 printf (_(" Number of program headers: %ld\n"),
2414 (long) elf_header.e_phnum);
2415 printf (_(" Size of section headers: %ld (bytes)\n"),
2416 (long) elf_header.e_shentsize);
2417 printf (_(" Number of section headers: %ld\n"),
2418 (long) elf_header.e_shnum);
2419 printf (_(" Section header string table index: %ld\n"),
2420 (long) elf_header.e_shstrndx);
2428 get_32bit_program_headers (file, program_headers)
2430 Elf_Internal_Phdr * program_headers;
2432 Elf32_External_Phdr * phdrs;
2433 Elf32_External_Phdr * external;
2434 Elf32_Internal_Phdr * internal;
2437 phdrs = ((Elf32_External_Phdr *)
2438 get_data (NULL, file, elf_header.e_phoff,
2439 elf_header.e_phentsize * elf_header.e_phnum,
2440 _("program headers")));
2444 for (i = 0, internal = program_headers, external = phdrs;
2445 i < elf_header.e_phnum;
2446 i ++, internal ++, external ++)
2448 internal->p_type = BYTE_GET (external->p_type);
2449 internal->p_offset = BYTE_GET (external->p_offset);
2450 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2451 internal->p_paddr = BYTE_GET (external->p_paddr);
2452 internal->p_filesz = BYTE_GET (external->p_filesz);
2453 internal->p_memsz = BYTE_GET (external->p_memsz);
2454 internal->p_flags = BYTE_GET (external->p_flags);
2455 internal->p_align = BYTE_GET (external->p_align);
2464 get_64bit_program_headers (file, program_headers)
2466 Elf_Internal_Phdr * program_headers;
2468 Elf64_External_Phdr * phdrs;
2469 Elf64_External_Phdr * external;
2470 Elf64_Internal_Phdr * internal;
2473 phdrs = ((Elf64_External_Phdr *)
2474 get_data (NULL, file, elf_header.e_phoff,
2475 elf_header.e_phentsize * elf_header.e_phnum,
2476 _("program headers")));
2480 for (i = 0, internal = program_headers, external = phdrs;
2481 i < elf_header.e_phnum;
2482 i ++, internal ++, external ++)
2484 internal->p_type = BYTE_GET (external->p_type);
2485 internal->p_flags = BYTE_GET (external->p_flags);
2486 internal->p_offset = BYTE_GET8 (external->p_offset);
2487 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2488 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2489 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2490 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2491 internal->p_align = BYTE_GET8 (external->p_align);
2500 process_program_headers (file)
2503 Elf_Internal_Phdr * program_headers;
2504 Elf_Internal_Phdr * segment;
2507 if (elf_header.e_phnum == 0)
2510 printf (_("\nThere are no program headers in this file.\n"));
2514 if (do_segments && !do_header)
2516 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2517 printf (_("Entry point "));
2518 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2519 printf (_("\nThere are %d program headers, starting at offset "),
2520 elf_header.e_phnum);
2521 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2525 program_headers = (Elf_Internal_Phdr *) malloc
2526 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2528 if (program_headers == NULL)
2530 error (_("Out of memory\n"));
2535 i = get_32bit_program_headers (file, program_headers);
2537 i = get_64bit_program_headers (file, program_headers);
2541 free (program_headers);
2548 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2552 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2555 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2559 (_(" Type Offset VirtAddr PhysAddr\n"));
2561 (_(" FileSiz MemSiz Flags Align\n"));
2569 for (i = 0, segment = program_headers;
2570 i < elf_header.e_phnum;
2575 printf (" %-14.14s ", get_segment_type (segment->p_type));
2579 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2580 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2581 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2582 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2583 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2585 (segment->p_flags & PF_R ? 'R' : ' '),
2586 (segment->p_flags & PF_W ? 'W' : ' '),
2587 (segment->p_flags & PF_X ? 'E' : ' '));
2588 printf ("%#lx", (unsigned long) segment->p_align);
2592 if ((unsigned long) segment->p_offset == segment->p_offset)
2593 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2596 print_vma (segment->p_offset, FULL_HEX);
2600 print_vma (segment->p_vaddr, FULL_HEX);
2602 print_vma (segment->p_paddr, FULL_HEX);
2605 if ((unsigned long) segment->p_filesz == segment->p_filesz)
2606 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
2609 print_vma (segment->p_filesz, FULL_HEX);
2613 if ((unsigned long) segment->p_memsz == segment->p_memsz)
2614 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
2617 print_vma (segment->p_offset, FULL_HEX);
2621 (segment->p_flags & PF_R ? 'R' : ' '),
2622 (segment->p_flags & PF_W ? 'W' : ' '),
2623 (segment->p_flags & PF_X ? 'E' : ' '));
2625 if ((unsigned long) segment->p_align == segment->p_align)
2626 printf ("%#lx", (unsigned long) segment->p_align);
2629 print_vma (segment->p_align, PREFIX_HEX);
2634 print_vma (segment->p_offset, FULL_HEX);
2636 print_vma (segment->p_vaddr, FULL_HEX);
2638 print_vma (segment->p_paddr, FULL_HEX);
2640 print_vma (segment->p_filesz, FULL_HEX);
2642 print_vma (segment->p_memsz, FULL_HEX);
2644 (segment->p_flags & PF_R ? 'R' : ' '),
2645 (segment->p_flags & PF_W ? 'W' : ' '),
2646 (segment->p_flags & PF_X ? 'E' : ' '));
2647 print_vma (segment->p_align, HEX);
2651 switch (segment->p_type)
2655 loadaddr = (segment->p_vaddr & 0xfffff000)
2656 - (segment->p_offset & 0xfffff000);
2661 error (_("more than one dynamic segment\n"));
2663 dynamic_addr = segment->p_offset;
2664 dynamic_size = segment->p_filesz;
2668 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2669 error (_("Unable to find program interpreter name\n"));
2672 program_interpreter[0] = 0;
2673 fscanf (file, "%63s", program_interpreter);
2676 printf (_("\n [Requesting program interpreter: %s]"),
2677 program_interpreter);
2683 putc ('\n', stdout);
2692 if (do_segments && section_headers != NULL)
2694 printf (_("\n Section to Segment mapping:\n"));
2695 printf (_(" Segment Sections...\n"));
2697 assert (string_table != NULL);
2699 for (i = 0; i < elf_header.e_phnum; i++)
2702 Elf_Internal_Shdr * section;
2704 segment = program_headers + i;
2705 section = section_headers;
2707 printf (" %2.2d ", i);
2709 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2711 if (section->sh_size > 0
2712 /* Compare allocated sections by VMA, unallocated
2713 sections by file offset. */
2714 && (section->sh_flags & SHF_ALLOC
2715 ? (section->sh_addr >= segment->p_vaddr
2716 && section->sh_addr + section->sh_size
2717 <= segment->p_vaddr + segment->p_memsz)
2718 : ((bfd_vma) section->sh_offset >= segment->p_offset
2719 && (section->sh_offset + section->sh_size
2720 <= segment->p_offset + segment->p_filesz))))
2721 printf ("%s ", SECTION_NAME (section));
2728 free (program_headers);
2735 get_32bit_section_headers (file)
2738 Elf32_External_Shdr * shdrs;
2739 Elf32_Internal_Shdr * internal;
2742 shdrs = ((Elf32_External_Shdr *)
2743 get_data (NULL, file, elf_header.e_shoff,
2744 elf_header.e_shentsize * elf_header.e_shnum,
2745 _("section headers")));
2749 section_headers = (Elf_Internal_Shdr *) malloc
2750 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2752 if (section_headers == NULL)
2754 error (_("Out of memory\n"));
2758 for (i = 0, internal = section_headers;
2759 i < elf_header.e_shnum;
2762 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2763 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2764 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2765 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2766 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2767 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2768 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2769 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2770 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2771 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2780 get_64bit_section_headers (file)
2783 Elf64_External_Shdr * shdrs;
2784 Elf64_Internal_Shdr * internal;
2787 shdrs = ((Elf64_External_Shdr *)
2788 get_data (NULL, file, elf_header.e_shoff,
2789 elf_header.e_shentsize * elf_header.e_shnum,
2790 _("section headers")));
2794 section_headers = (Elf_Internal_Shdr *) malloc
2795 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2797 if (section_headers == NULL)
2799 error (_("Out of memory\n"));
2803 for (i = 0, internal = section_headers;
2804 i < elf_header.e_shnum;
2807 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2808 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2809 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2810 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2811 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2812 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2813 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2814 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2815 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2816 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2824 static Elf_Internal_Sym *
2825 get_32bit_elf_symbols (file, offset, number)
2827 unsigned long offset;
2828 unsigned long number;
2830 Elf32_External_Sym * esyms;
2831 Elf_Internal_Sym * isyms;
2832 Elf_Internal_Sym * psym;
2835 esyms = ((Elf32_External_Sym *)
2836 get_data (NULL, file, offset,
2837 number * sizeof (Elf32_External_Sym), _("symbols")));
2841 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2845 error (_("Out of memory\n"));
2851 for (j = 0, psym = isyms;
2855 psym->st_name = BYTE_GET (esyms[j].st_name);
2856 psym->st_value = BYTE_GET (esyms[j].st_value);
2857 psym->st_size = BYTE_GET (esyms[j].st_size);
2858 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2859 psym->st_info = BYTE_GET (esyms[j].st_info);
2860 psym->st_other = BYTE_GET (esyms[j].st_other);
2868 static Elf_Internal_Sym *
2869 get_64bit_elf_symbols (file, offset, number)
2871 unsigned long offset;
2872 unsigned long number;
2874 Elf64_External_Sym * esyms;
2875 Elf_Internal_Sym * isyms;
2876 Elf_Internal_Sym * psym;
2879 esyms = ((Elf64_External_Sym *)
2880 get_data (NULL, file, offset,
2881 number * sizeof (Elf64_External_Sym), _("symbols")));
2885 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2889 error (_("Out of memory\n"));
2895 for (j = 0, psym = isyms;
2899 psym->st_name = BYTE_GET (esyms[j].st_name);
2900 psym->st_info = BYTE_GET (esyms[j].st_info);
2901 psym->st_other = BYTE_GET (esyms[j].st_other);
2902 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2903 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2904 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2913 get_elf_section_flags (sh_flags)
2916 static char buff [32];
2924 flag = sh_flags & - sh_flags;
2929 case SHF_WRITE: strcat (buff, "W"); break;
2930 case SHF_ALLOC: strcat (buff, "A"); break;
2931 case SHF_EXECINSTR: strcat (buff, "X"); break;
2932 case SHF_MERGE: strcat (buff, "M"); break;
2933 case SHF_STRINGS: strcat (buff, "S"); break;
2934 case SHF_INFO_LINK: strcat (buff, "I"); break;
2935 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2936 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2937 case SHF_GROUP: strcat (buff, "G"); break;
2940 if (flag & SHF_MASKOS)
2943 sh_flags &= ~ SHF_MASKOS;
2945 else if (flag & SHF_MASKPROC)
2948 sh_flags &= ~ SHF_MASKPROC;
2960 process_section_headers (file)
2963 Elf_Internal_Shdr * section;
2966 section_headers = NULL;
2968 if (elf_header.e_shnum == 0)
2971 printf (_("\nThere are no sections in this file.\n"));
2976 if (do_sections && !do_header)
2977 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2978 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2982 if (! get_32bit_section_headers (file))
2985 else if (! get_64bit_section_headers (file))
2988 /* Read in the string table, so that we have names to display. */
2989 section = section_headers + elf_header.e_shstrndx;
2991 if (section->sh_size != 0)
2993 string_table = (char *) get_data (NULL, file, section->sh_offset,
2994 section->sh_size, _("string table"));
2996 string_table_length = section->sh_size;
2999 /* Scan the sections for the dynamic symbol table
3000 and dynamic string table and debug sections. */
3001 dynamic_symbols = NULL;
3002 dynamic_strings = NULL;
3003 dynamic_syminfo = NULL;
3005 for (i = 0, section = section_headers;
3006 i < elf_header.e_shnum;
3009 char * name = SECTION_NAME (section);
3011 if (section->sh_type == SHT_DYNSYM)
3013 if (dynamic_symbols != NULL)
3015 error (_("File contains multiple dynamic symbol tables\n"));
3019 num_dynamic_syms = section->sh_size / section->sh_entsize;
3021 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
3023 else if (section->sh_type == SHT_STRTAB
3024 && strcmp (name, ".dynstr") == 0)
3026 if (dynamic_strings != NULL)
3028 error (_("File contains multiple dynamic string tables\n"));
3032 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
3034 _("dynamic strings"));
3036 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3037 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3038 || do_debug_frames || do_debug_macinfo)
3039 && strncmp (name, ".debug_", 7) == 0)
3044 || (do_debug_info && (strcmp (name, "info") == 0))
3045 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3046 || (do_debug_lines && (strcmp (name, "line") == 0))
3047 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3048 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3049 || (do_debug_frames && (strcmp (name, "frame") == 0))
3050 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3052 request_dump (i, DEBUG_DUMP);
3054 /* linkonce section to be combined with .debug_info at link time. */
3055 else if ((do_debugging || do_debug_info)
3056 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3057 request_dump (i, DEBUG_DUMP);
3058 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3059 request_dump (i, DEBUG_DUMP);
3065 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
3069 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3072 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3075 printf (_(" [Nr] Name Type Address Offset\n"));
3076 printf (_(" Size EntSize Flags Link Info Align\n"));
3079 for (i = 0, section = section_headers;
3080 i < elf_header.e_shnum;
3083 printf (" [%2d] %-17.17s %-15.15s ",
3085 SECTION_NAME (section),
3086 get_section_type_name (section->sh_type));
3090 print_vma (section->sh_addr, LONG_HEX);
3092 printf ( " %6.6lx %6.6lx %2.2lx",
3093 (unsigned long) section->sh_offset,
3094 (unsigned long) section->sh_size,
3095 (unsigned long) section->sh_entsize);
3097 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3099 printf ("%2ld %3lx %2ld\n",
3100 (unsigned long) section->sh_link,
3101 (unsigned long) section->sh_info,
3102 (unsigned long) section->sh_addralign);
3106 print_vma (section->sh_addr, LONG_HEX);
3108 if ((long) section->sh_offset == section->sh_offset)
3109 printf (" %6.6lx", (unsigned long) section->sh_offset);
3113 print_vma (section->sh_offset, LONG_HEX);
3116 if ((unsigned long) section->sh_size == section->sh_size)
3117 printf (" %6.6lx", (unsigned long) section->sh_size);
3121 print_vma (section->sh_size, LONG_HEX);
3124 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3125 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3129 print_vma (section->sh_entsize, LONG_HEX);
3132 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3134 printf ("%2ld %3lx ",
3135 (unsigned long) section->sh_link,
3136 (unsigned long) section->sh_info);
3138 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3139 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3142 print_vma (section->sh_addralign, DEC);
3149 print_vma (section->sh_addr, LONG_HEX);
3150 if ((long) section->sh_offset == section->sh_offset)
3151 printf (" %8.8lx", (unsigned long) section->sh_offset);
3155 print_vma (section->sh_offset, LONG_HEX);
3158 print_vma (section->sh_size, LONG_HEX);
3160 print_vma (section->sh_entsize, LONG_HEX);
3162 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3164 printf (" %2ld %3lx %ld\n",
3165 (unsigned long) section->sh_link,
3166 (unsigned long) section->sh_info,
3167 (unsigned long) section->sh_addralign);
3171 printf (_("Key to Flags:\n"));
3172 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
3173 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
3174 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3179 /* Process the reloc section. */
3181 process_relocs (file)
3184 unsigned long rel_size;
3185 unsigned long rel_offset;
3191 if (do_using_dynamic)
3193 int is_rela = FALSE;
3198 if (dynamic_info[DT_REL])
3200 rel_offset = dynamic_info[DT_REL];
3201 rel_size = dynamic_info[DT_RELSZ];
3204 else if (dynamic_info [DT_RELA])
3206 rel_offset = dynamic_info[DT_RELA];
3207 rel_size = dynamic_info[DT_RELASZ];
3210 else if (dynamic_info[DT_JMPREL])
3212 rel_offset = dynamic_info[DT_JMPREL];
3213 rel_size = dynamic_info[DT_PLTRELSZ];
3215 switch (dynamic_info[DT_PLTREL])
3232 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3233 rel_offset, rel_size);
3235 dump_relocations (file, rel_offset - loadaddr, rel_size,
3236 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3239 printf (_("\nThere are no dynamic relocations in this file.\n"));
3243 Elf32_Internal_Shdr * section;
3247 for (i = 0, section = section_headers;
3248 i < elf_header.e_shnum;
3251 if ( section->sh_type != SHT_RELA
3252 && section->sh_type != SHT_REL)
3255 rel_offset = section->sh_offset;
3256 rel_size = section->sh_size;
3260 Elf32_Internal_Shdr * strsec;
3261 Elf_Internal_Sym * symtab;
3264 unsigned long nsyms;
3266 printf (_("\nRelocation section "));
3268 if (string_table == NULL)
3269 printf ("%d", section->sh_name);
3271 printf ("'%s'", SECTION_NAME (section));
3273 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3274 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3279 if (section->sh_link)
3281 Elf32_Internal_Shdr * symsec;
3283 symsec = section_headers + section->sh_link;
3284 nsyms = symsec->sh_size / symsec->sh_entsize;
3285 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
3290 strsec = section_headers + symsec->sh_link;
3292 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3296 is_rela = section->sh_type == SHT_RELA;
3298 dump_relocations (file, rel_offset, rel_size,
3299 symtab, nsyms, strtab, is_rela);
3311 printf (_("\nThere are no relocations in this file.\n"));
3317 #include "unwind-ia64.h"
3319 /* An absolute address consists of a section and an offset. If the
3320 section is NULL, the offset itself is the address, otherwise, the
3321 address equals to LOAD_ADDRESS(section) + offset. */
3325 unsigned short section;
3331 struct unw_table_entry
3333 struct absaddr start;
3335 struct absaddr info;
3337 *table; /* Unwind table. */
3338 unsigned long table_len; /* Length of unwind table. */
3339 unsigned char * info; /* Unwind info. */
3340 unsigned long info_size; /* Size of unwind info. */
3341 bfd_vma info_addr; /* starting address of unwind info. */
3342 bfd_vma seg_base; /* Starting address of segment. */
3343 Elf_Internal_Sym * symtab; /* The symbol table. */
3344 unsigned long nsyms; /* Number of symbols. */
3345 char * strtab; /* The string table. */
3346 unsigned long strtab_size; /* Size of string table. */
3349 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3350 struct absaddr, const char **,
3352 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3353 static int slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3354 Elf32_Internal_Shdr *));
3357 find_symbol_for_address (aux, addr, symname, offset)
3358 struct unw_aux_info *aux;
3359 struct absaddr addr;
3360 const char **symname;
3363 bfd_vma dist = (bfd_vma) 0x100000;
3364 Elf_Internal_Sym *sym, *best = NULL;
3367 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3369 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3370 && sym->st_name != 0
3371 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3372 && addr.offset >= sym->st_value
3373 && addr.offset - sym->st_value < dist)
3376 dist = addr.offset - sym->st_value;
3383 *symname = (best->st_name >= aux->strtab_size
3384 ? "<corrupt>" : aux->strtab + best->st_name);
3389 *offset = addr.offset;
3393 dump_ia64_unwind (aux)
3394 struct unw_aux_info *aux;
3397 struct unw_table_entry * tp;
3400 addr_size = is_32bit_elf ? 4 : 8;
3402 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3406 const unsigned char * dp;
3407 const unsigned char * head;
3408 const char * procname;
3410 find_symbol_for_address (aux, tp->start, &procname, &offset);
3412 fputs ("\n<", stdout);
3416 fputs (procname, stdout);
3419 printf ("+%lx", (unsigned long) offset);
3422 fputs (">: [", stdout);
3423 print_vma (tp->start.offset, PREFIX_HEX);
3424 fputc ('-', stdout);
3425 print_vma (tp->end.offset, PREFIX_HEX);
3426 printf ("), info at +0x%lx\n",
3427 (unsigned long) (tp->info.offset - aux->seg_base));
3429 head = aux->info + (tp->info.offset - aux->info_addr);
3430 stamp = BYTE_GET8 ((unsigned char *) head);
3432 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3433 (unsigned) UNW_VER (stamp),
3434 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3435 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3436 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3437 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3439 if (UNW_VER (stamp) != 1)
3441 printf ("\tUnknown version.\n");
3446 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3447 dp = unw_decode (dp, in_body, & in_body);
3452 slurp_ia64_unwind_table (file, aux, sec)
3454 struct unw_aux_info *aux;
3455 Elf32_Internal_Shdr *sec;
3457 unsigned long size, addr_size, nrelas, i;
3458 Elf_Internal_Phdr *prog_hdrs, *seg;
3459 struct unw_table_entry *tep;
3460 Elf32_Internal_Shdr *relsec;
3461 Elf_Internal_Rela *rela, *rp;
3462 unsigned char *table, *tp;
3463 Elf_Internal_Sym *sym;
3464 const char *relname;
3467 addr_size = is_32bit_elf ? 4 : 8;
3469 /* First, find the starting address of the segment that includes
3472 if (elf_header.e_phnum)
3474 prog_hdrs = (Elf_Internal_Phdr *)
3475 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3478 result = get_32bit_program_headers (file, prog_hdrs);
3480 result = get_64bit_program_headers (file, prog_hdrs);
3488 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3490 if (seg->p_type != PT_LOAD)
3493 if (sec->sh_addr >= seg->p_vaddr
3494 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3496 aux->seg_base = seg->p_vaddr;
3504 /* Second, build the unwind table from the contents of the unwind section: */
3505 size = sec->sh_size;
3506 table = (char *) get_data (NULL, file, sec->sh_offset,
3507 size, _("unwind table"));
3511 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3512 for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3514 tep->start.section = SHN_UNDEF;
3515 tep->end.section = SHN_UNDEF;
3516 tep->info.section = SHN_UNDEF;
3519 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3520 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
3521 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
3525 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
3526 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
3527 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
3529 tep->start.offset += aux->seg_base;
3530 tep->end.offset += aux->seg_base;
3531 tep->info.offset += aux->seg_base;
3535 /* Third, apply any relocations to the unwind table: */
3537 for (relsec = section_headers;
3538 relsec < section_headers + elf_header.e_shnum;
3541 if (relsec->sh_type != SHT_RELA
3542 || section_headers + relsec->sh_info != sec)
3545 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3549 for (rp = rela; rp < rela + nrelas; ++rp)
3553 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3554 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3556 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3558 warn (_("Skipping unexpected symbol type %u"),
3559 ELF32_ST_TYPE (sym->st_info));
3565 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3566 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3568 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3570 warn (_("Skipping unexpected symbol type %u"),
3571 ELF64_ST_TYPE (sym->st_info));
3576 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
3578 warn (_("Skipping unexpected relocation type %s"), relname);
3582 i = rp->r_offset / (3 * addr_size);
3584 switch (rp->r_offset/addr_size % 3)
3587 aux->table[i].start.section = sym->st_shndx;
3588 aux->table[i].start.offset += rp->r_addend;
3591 aux->table[i].end.section = sym->st_shndx;
3592 aux->table[i].end.offset += rp->r_addend;
3595 aux->table[i].info.section = sym->st_shndx;
3596 aux->table[i].info.offset += rp->r_addend;
3606 aux->table_len = size / (3 * addr_size);
3611 process_unwind (file)
3614 Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
3615 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
3616 struct unw_aux_info aux;
3621 if (elf_header.e_machine != EM_IA_64)
3623 printf (_("\nThere are no unwind sections in this file.\n"));
3627 memset (& aux, 0, sizeof (aux));
3629 addr_size = is_32bit_elf ? 4 : 8;
3631 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
3633 if (sec->sh_type == SHT_SYMTAB)
3635 aux.nsyms = sec->sh_size / sec->sh_entsize;
3636 aux.symtab = GET_ELF_SYMBOLS (file, sec->sh_offset, aux.nsyms);
3638 strsec = section_headers + sec->sh_link;
3639 aux.strtab_size = strsec->sh_size;
3640 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3641 aux.strtab_size, _("string table"));
3643 else if (sec->sh_type == SHT_IA_64_UNWIND)
3648 printf (_("\nThere are no unwind sections in this file.\n"));
3650 while (unwcount-- > 0)
3655 for (i = unwstart, sec = section_headers + unwstart;
3656 i < elf_header.e_shnum; ++i, ++sec)
3657 if (sec->sh_type == SHT_IA_64_UNWIND)
3664 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
3666 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
3669 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3670 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
3671 suffix = SECTION_NAME (unwsec) + len;
3672 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3674 if (strncmp (SECTION_NAME (sec),
3675 ELF_STRING_ia64_unwind_info_once, len2) == 0
3676 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3681 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3682 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3683 len = sizeof (ELF_STRING_ia64_unwind) - 1;
3684 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
3686 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
3688 suffix = SECTION_NAME (unwsec) + len;
3689 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3691 if (strncmp (SECTION_NAME (sec),
3692 ELF_STRING_ia64_unwind_info, len2) == 0
3693 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3697 if (i == elf_header.e_shnum)
3699 printf (_("\nCould not find unwind info section for "));
3701 if (string_table == NULL)
3702 printf ("%d", unwsec->sh_name);
3704 printf ("'%s'", SECTION_NAME (unwsec));
3708 aux.info_size = sec->sh_size;
3709 aux.info_addr = sec->sh_addr;
3710 aux.info = (char *) get_data (NULL, file, sec->sh_offset,
3711 aux.info_size, _("unwind info"));
3713 printf (_("\nUnwind section "));
3715 if (string_table == NULL)
3716 printf ("%d", unwsec->sh_name);
3718 printf ("'%s'", SECTION_NAME (unwsec));
3720 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3721 (unsigned long) unwsec->sh_offset,
3722 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
3724 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
3726 if (aux.table_len > 0)
3727 dump_ia64_unwind (& aux);
3730 free ((char *) aux.table);
3732 free ((char *) aux.info);
3741 free ((char *) aux.strtab);
3747 dynamic_segment_mips_val (entry)
3748 Elf_Internal_Dyn * entry;
3750 switch (entry->d_tag)
3753 if (entry->d_un.d_val == 0)
3757 static const char * opts[] =
3759 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3760 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3761 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3762 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3767 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
3768 if (entry->d_un.d_val & (1 << cnt))
3770 printf ("%s%s", first ? "" : " ", opts[cnt]);
3777 case DT_MIPS_IVERSION:
3778 if (dynamic_strings != NULL)
3779 printf ("Interface Version: %s\n",
3780 dynamic_strings + entry->d_un.d_val);
3782 printf ("%ld\n", (long) entry->d_un.d_ptr);
3785 case DT_MIPS_TIME_STAMP:
3790 time_t time = entry->d_un.d_val;
3791 tmp = gmtime (&time);
3792 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3793 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3794 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3795 printf ("Time Stamp: %s\n", timebuf);
3799 case DT_MIPS_RLD_VERSION:
3800 case DT_MIPS_LOCAL_GOTNO:
3801 case DT_MIPS_CONFLICTNO:
3802 case DT_MIPS_LIBLISTNO:
3803 case DT_MIPS_SYMTABNO:
3804 case DT_MIPS_UNREFEXTNO:
3805 case DT_MIPS_HIPAGENO:
3806 case DT_MIPS_DELTA_CLASS_NO:
3807 case DT_MIPS_DELTA_INSTANCE_NO:
3808 case DT_MIPS_DELTA_RELOC_NO:
3809 case DT_MIPS_DELTA_SYM_NO:
3810 case DT_MIPS_DELTA_CLASSSYM_NO:
3811 case DT_MIPS_COMPACT_SIZE:
3812 printf ("%ld\n", (long) entry->d_un.d_ptr);
3816 printf ("%#lx\n", (long) entry->d_un.d_ptr);
3822 dynamic_segment_parisc_val (entry)
3823 Elf_Internal_Dyn * entry;
3825 switch (entry->d_tag)
3827 case DT_HP_DLD_FLAGS:
3836 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3837 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3838 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3839 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3840 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3841 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3842 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3843 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3844 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3845 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3846 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3850 bfd_vma val = entry->d_un.d_val;
3852 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3853 if (val & flags[cnt].bit)
3857 fputs (flags[cnt].str, stdout);
3859 val ^= flags[cnt].bit;
3862 if (val != 0 || first)
3866 print_vma (val, HEX);
3872 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3878 get_32bit_dynamic_segment (file)
3881 Elf32_External_Dyn * edyn;
3882 Elf_Internal_Dyn * entry;
3885 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr,
3886 dynamic_size, _("dynamic segment"));
3890 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3891 how large this .dynamic is now. We can do this even before the byte
3892 swapping since the DT_NULL tag is recognizable. */
3894 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3897 dynamic_segment = (Elf_Internal_Dyn *)
3898 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3900 if (dynamic_segment == NULL)
3902 error (_("Out of memory\n"));
3907 for (i = 0, entry = dynamic_segment;
3911 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3912 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3921 get_64bit_dynamic_segment (file)
3924 Elf64_External_Dyn * edyn;
3925 Elf_Internal_Dyn * entry;
3928 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr,
3929 dynamic_size, _("dynamic segment"));
3933 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3934 how large this .dynamic is now. We can do this even before the byte
3935 swapping since the DT_NULL tag is recognizable. */
3937 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3940 dynamic_segment = (Elf_Internal_Dyn *)
3941 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3943 if (dynamic_segment == NULL)
3945 error (_("Out of memory\n"));
3950 for (i = 0, entry = dynamic_segment;
3954 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3955 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3964 get_dynamic_flags (flags)
3967 static char buff [64];
3972 flag = flags & - flags;
3977 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3978 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3979 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3980 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3981 default: strcat (buff, "unknown "); break;
3987 /* Parse and display the contents of the dynamic segment. */
3989 process_dynamic_segment (file)
3992 Elf_Internal_Dyn * entry;
3995 if (dynamic_size == 0)
3998 printf (_("\nThere is no dynamic segment in this file.\n"));
4005 if (! get_32bit_dynamic_segment (file))
4008 else if (! get_64bit_dynamic_segment (file))
4011 /* Find the appropriate symbol table. */
4012 if (dynamic_symbols == NULL)
4014 for (i = 0, entry = dynamic_segment;
4018 unsigned long offset;
4020 if (entry->d_tag != DT_SYMTAB)
4023 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4025 /* Since we do not know how big the symbol table is,
4026 we default to reading in the entire file (!) and
4027 processing that. This is overkill, I know, but it
4029 offset = entry->d_un.d_val - loadaddr;
4031 if (fseek (file, 0, SEEK_END))
4032 error (_("Unable to seek to end of file!"));
4035 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
4037 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
4039 if (num_dynamic_syms < 1)
4041 error (_("Unable to determine the number of symbols to load\n"));
4045 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
4049 /* Similarly find a string table. */
4050 if (dynamic_strings == NULL)
4052 for (i = 0, entry = dynamic_segment;
4056 unsigned long offset;
4059 if (entry->d_tag != DT_STRTAB)
4062 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4064 /* Since we do not know how big the string table is,
4065 we default to reading in the entire file (!) and
4066 processing that. This is overkill, I know, but it
4069 offset = entry->d_un.d_val - loadaddr;
4070 if (fseek (file, 0, SEEK_END))
4071 error (_("Unable to seek to end of file\n"));
4072 str_tab_len = ftell (file) - offset;
4074 if (str_tab_len < 1)
4077 (_("Unable to determine the length of the dynamic string table\n"));
4081 dynamic_strings = (char *) get_data (NULL, file, offset, str_tab_len,
4082 _("dynamic string table"));
4088 /* And find the syminfo section if available. */
4089 if (dynamic_syminfo == NULL)
4091 unsigned int syminsz = 0;
4093 for (i = 0, entry = dynamic_segment;
4097 if (entry->d_tag == DT_SYMINENT)
4099 /* Note: these braces are necessary to avoid a syntax
4100 error from the SunOS4 C compiler. */
4101 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4103 else if (entry->d_tag == DT_SYMINSZ)
4104 syminsz = entry->d_un.d_val;
4105 else if (entry->d_tag == DT_SYMINFO)
4106 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
4109 if (dynamic_syminfo_offset != 0 && syminsz != 0)
4111 Elf_External_Syminfo * extsyminfo;
4112 Elf_Internal_Syminfo * syminfo;
4114 /* There is a syminfo section. Read the data. */
4115 extsyminfo = ((Elf_External_Syminfo *)
4116 get_data (NULL, file, dynamic_syminfo_offset,
4117 syminsz, _("symbol information")));
4121 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
4122 if (dynamic_syminfo == NULL)
4124 error (_("Out of memory\n"));
4128 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4129 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4132 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4133 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4140 if (do_dynamic && dynamic_addr)
4141 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4142 dynamic_addr, (long) dynamic_size);
4144 printf (_(" Tag Type Name/Value\n"));
4146 for (i = 0, entry = dynamic_segment;
4155 print_vma (entry->d_tag, FULL_HEX);
4156 dtype = get_dynamic_type (entry->d_tag);
4157 printf (" (%s)%*s", dtype,
4158 ((is_32bit_elf ? 27 : 19)
4159 - (int) strlen (dtype)),
4163 switch (entry->d_tag)
4167 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
4177 switch (entry->d_tag)
4180 printf (_("Auxiliary library"));
4184 printf (_("Filter library"));
4188 printf (_("Configuration file"));
4192 printf (_("Dependency audit library"));
4196 printf (_("Audit library"));
4200 if (dynamic_strings)
4201 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4205 print_vma (entry->d_un.d_val, PREFIX_HEX);
4214 printf (_("Flags:"));
4215 if (entry->d_un.d_val == 0)
4216 printf (_(" None\n"));
4219 unsigned long int val = entry->d_un.d_val;
4220 if (val & DTF_1_PARINIT)
4222 printf (" PARINIT");
4223 val ^= DTF_1_PARINIT;
4225 if (val & DTF_1_CONFEXP)
4227 printf (" CONFEXP");
4228 val ^= DTF_1_CONFEXP;
4231 printf (" %lx", val);
4240 printf (_("Flags:"));
4241 if (entry->d_un.d_val == 0)
4242 printf (_(" None\n"));
4245 unsigned long int val = entry->d_un.d_val;
4246 if (val & DF_P1_LAZYLOAD)
4248 printf (" LAZYLOAD");
4249 val ^= DF_P1_LAZYLOAD;
4251 if (val & DF_P1_GROUPPERM)
4253 printf (" GROUPPERM");
4254 val ^= DF_P1_GROUPPERM;
4257 printf (" %lx", val);
4266 printf (_("Flags:"));
4267 if (entry->d_un.d_val == 0)
4268 printf (_(" None\n"));
4271 unsigned long int val = entry->d_un.d_val;
4277 if (val & DF_1_GLOBAL)
4282 if (val & DF_1_GROUP)
4287 if (val & DF_1_NODELETE)
4289 printf (" NODELETE");
4290 val ^= DF_1_NODELETE;
4292 if (val & DF_1_LOADFLTR)
4294 printf (" LOADFLTR");
4295 val ^= DF_1_LOADFLTR;
4297 if (val & DF_1_INITFIRST)
4299 printf (" INITFIRST");
4300 val ^= DF_1_INITFIRST;
4302 if (val & DF_1_NOOPEN)
4307 if (val & DF_1_ORIGIN)
4312 if (val & DF_1_DIRECT)
4317 if (val & DF_1_TRANS)
4322 if (val & DF_1_INTERPOSE)
4324 printf (" INTERPOSE");
4325 val ^= DF_1_INTERPOSE;
4327 if (val & DF_1_NODEFLIB)
4329 printf (" NODEFLIB");
4330 val ^= DF_1_NODEFLIB;
4332 if (val & DF_1_NODUMP)
4337 if (val & DF_1_CONLFAT)
4339 printf (" CONLFAT");
4340 val ^= DF_1_CONLFAT;
4343 printf (" %lx", val);
4351 puts (get_dynamic_type (entry->d_un.d_val));
4371 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4377 if (dynamic_strings == NULL)
4380 name = dynamic_strings + entry->d_un.d_val;
4384 switch (entry->d_tag)
4387 printf (_("Shared library: [%s]"), name);
4389 if (strcmp (name, program_interpreter) == 0)
4390 printf (_(" program interpreter"));
4394 printf (_("Library soname: [%s]"), name);
4398 printf (_("Library rpath: [%s]"), name);
4402 printf (_("Library runpath: [%s]"), name);
4406 print_vma (entry->d_un.d_val, PREFIX_HEX);
4411 print_vma (entry->d_un.d_val, PREFIX_HEX);
4427 case DT_INIT_ARRAYSZ:
4428 case DT_FINI_ARRAYSZ:
4431 print_vma (entry->d_un.d_val, UNSIGNED);
4432 printf (" (bytes)\n");
4442 print_vma (entry->d_un.d_val, UNSIGNED);
4455 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4459 name = dynamic_strings + entry->d_un.d_val;
4463 printf (_("Not needed object: [%s]\n"), name);
4468 print_vma (entry->d_un.d_val, PREFIX_HEX);
4474 /* The value of this entry is ignored. */
4478 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4479 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4484 switch (elf_header.e_machine)
4487 case EM_MIPS_RS3_LE:
4488 dynamic_segment_mips_val (entry);
4491 dynamic_segment_parisc_val (entry);
4494 print_vma (entry->d_un.d_val, PREFIX_HEX);
4506 get_ver_flags (flags)
4509 static char buff [32];
4516 if (flags & VER_FLG_BASE)
4517 strcat (buff, "BASE ");
4519 if (flags & VER_FLG_WEAK)
4521 if (flags & VER_FLG_BASE)
4522 strcat (buff, "| ");
4524 strcat (buff, "WEAK ");
4527 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4528 strcat (buff, "| <unknown>");
4533 /* Display the contents of the version sections. */
4535 process_version_sections (file)
4538 Elf32_Internal_Shdr * section;
4545 for (i = 0, section = section_headers;
4546 i < elf_header.e_shnum;
4549 switch (section->sh_type)
4551 case SHT_GNU_verdef:
4553 Elf_External_Verdef * edefs;
4560 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4561 SECTION_NAME (section), section->sh_info);
4563 printf (_(" Addr: 0x"));
4564 printf_vma (section->sh_addr);
4565 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4566 (unsigned long) section->sh_offset, section->sh_link,
4567 SECTION_NAME (section_headers + section->sh_link));
4569 edefs = ((Elf_External_Verdef *)
4570 get_data (NULL, file, section->sh_offset,
4572 _("version definition section")));
4576 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
4579 Elf_External_Verdef * edef;
4580 Elf_Internal_Verdef ent;
4581 Elf_External_Verdaux * eaux;
4582 Elf_Internal_Verdaux aux;
4586 vstart = ((char *) edefs) + idx;
4588 edef = (Elf_External_Verdef *) vstart;
4590 ent.vd_version = BYTE_GET (edef->vd_version);
4591 ent.vd_flags = BYTE_GET (edef->vd_flags);
4592 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
4593 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
4594 ent.vd_hash = BYTE_GET (edef->vd_hash);
4595 ent.vd_aux = BYTE_GET (edef->vd_aux);
4596 ent.vd_next = BYTE_GET (edef->vd_next);
4598 printf (_(" %#06x: Rev: %d Flags: %s"),
4599 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
4601 printf (_(" Index: %d Cnt: %d "),
4602 ent.vd_ndx, ent.vd_cnt);
4604 vstart += ent.vd_aux;
4606 eaux = (Elf_External_Verdaux *) vstart;
4608 aux.vda_name = BYTE_GET (eaux->vda_name);
4609 aux.vda_next = BYTE_GET (eaux->vda_next);
4611 if (dynamic_strings)
4612 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
4614 printf (_("Name index: %ld\n"), aux.vda_name);
4616 isum = idx + ent.vd_aux;
4618 for (j = 1; j < ent.vd_cnt; j ++)
4620 isum += aux.vda_next;
4621 vstart += aux.vda_next;
4623 eaux = (Elf_External_Verdaux *) vstart;
4625 aux.vda_name = BYTE_GET (eaux->vda_name);
4626 aux.vda_next = BYTE_GET (eaux->vda_next);
4628 if (dynamic_strings)
4629 printf (_(" %#06x: Parent %d: %s\n"),
4630 isum, j, dynamic_strings + aux.vda_name);
4632 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4633 isum, j, aux.vda_name);
4643 case SHT_GNU_verneed:
4645 Elf_External_Verneed * eneed;
4651 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4652 SECTION_NAME (section), section->sh_info);
4654 printf (_(" Addr: 0x"));
4655 printf_vma (section->sh_addr);
4656 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4657 (unsigned long) section->sh_offset, section->sh_link,
4658 SECTION_NAME (section_headers + section->sh_link));
4660 eneed = ((Elf_External_Verneed *)
4661 get_data (NULL, file, section->sh_offset,
4662 section->sh_size, _("version need section")));
4666 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
4668 Elf_External_Verneed * entry;
4669 Elf_Internal_Verneed ent;
4674 vstart = ((char *) eneed) + idx;
4676 entry = (Elf_External_Verneed *) vstart;
4678 ent.vn_version = BYTE_GET (entry->vn_version);
4679 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
4680 ent.vn_file = BYTE_GET (entry->vn_file);
4681 ent.vn_aux = BYTE_GET (entry->vn_aux);
4682 ent.vn_next = BYTE_GET (entry->vn_next);
4684 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
4686 if (dynamic_strings)
4687 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
4689 printf (_(" File: %lx"), ent.vn_file);
4691 printf (_(" Cnt: %d\n"), ent.vn_cnt);
4693 vstart += ent.vn_aux;
4695 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
4697 Elf_External_Vernaux * eaux;
4698 Elf_Internal_Vernaux aux;
4700 eaux = (Elf_External_Vernaux *) vstart;
4702 aux.vna_hash = BYTE_GET (eaux->vna_hash);
4703 aux.vna_flags = BYTE_GET (eaux->vna_flags);
4704 aux.vna_other = BYTE_GET (eaux->vna_other);
4705 aux.vna_name = BYTE_GET (eaux->vna_name);
4706 aux.vna_next = BYTE_GET (eaux->vna_next);
4708 if (dynamic_strings)
4709 printf (_(" %#06x: Name: %s"),
4710 isum, dynamic_strings + aux.vna_name);
4712 printf (_(" %#06x: Name index: %lx"),
4713 isum, aux.vna_name);
4715 printf (_(" Flags: %s Version: %d\n"),
4716 get_ver_flags (aux.vna_flags), aux.vna_other);
4718 isum += aux.vna_next;
4719 vstart += aux.vna_next;
4729 case SHT_GNU_versym:
4731 Elf32_Internal_Shdr * link_section;
4734 unsigned char * edata;
4735 unsigned short * data;
4737 Elf_Internal_Sym * symbols;
4738 Elf32_Internal_Shdr * string_sec;
4740 link_section = section_headers + section->sh_link;
4741 total = section->sh_size / section->sh_entsize;
4745 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
4746 link_section->sh_size / link_section->sh_entsize);
4748 string_sec = section_headers + link_section->sh_link;
4750 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
4751 string_sec->sh_size,
4752 _("version string table"));
4756 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4757 SECTION_NAME (section), total);
4759 printf (_(" Addr: "));
4760 printf_vma (section->sh_addr);
4761 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4762 (unsigned long) section->sh_offset, section->sh_link,
4763 SECTION_NAME (link_section));
4767 get_data (NULL, file,
4768 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] - loadaddr,
4769 total * sizeof (short), _("version symbol data")));
4776 data = (unsigned short *) malloc (total * sizeof (short));
4778 for (cnt = total; cnt --;)
4779 data [cnt] = byte_get (edata + cnt * sizeof (short),
4784 for (cnt = 0; cnt < total; cnt += 4)
4787 int check_def, check_need;
4790 printf (" %03x:", cnt);
4792 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
4793 switch (data [cnt + j])
4796 fputs (_(" 0 (*local*) "), stdout);
4800 fputs (_(" 1 (*global*) "), stdout);
4804 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4805 data [cnt + j] & 0x8000 ? 'h' : ' ');
4809 if (symbols [cnt + j].st_shndx >= SHN_LORESERVE
4810 || section_headers[symbols [cnt + j].st_shndx].sh_type
4813 if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4820 && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
4822 Elf_Internal_Verneed ivn;
4823 unsigned long offset;
4825 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4830 Elf_Internal_Vernaux ivna;
4831 Elf_External_Verneed evn;
4832 Elf_External_Vernaux evna;
4833 unsigned long a_off;
4835 get_data (&evn, file, offset, sizeof (evn),
4838 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4839 ivn.vn_next = BYTE_GET (evn.vn_next);
4841 a_off = offset + ivn.vn_aux;
4845 get_data (&evna, file, a_off, sizeof (evna),
4846 _("version need aux (2)"));
4848 ivna.vna_next = BYTE_GET (evna.vna_next);
4849 ivna.vna_other = BYTE_GET (evna.vna_other);
4851 a_off += ivna.vna_next;
4853 while (ivna.vna_other != data [cnt + j]
4854 && ivna.vna_next != 0);
4856 if (ivna.vna_other == data [cnt + j])
4858 ivna.vna_name = BYTE_GET (evna.vna_name);
4860 name = strtab + ivna.vna_name;
4861 nn += printf ("(%s%-*s",
4863 12 - (int) strlen (name),
4869 offset += ivn.vn_next;
4871 while (ivn.vn_next);
4874 if (check_def && data [cnt + j] != 0x8001
4875 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
4877 Elf_Internal_Verdef ivd;
4878 Elf_External_Verdef evd;
4879 unsigned long offset;
4881 offset = version_info
4882 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4886 get_data (&evd, file, offset, sizeof (evd),
4889 ivd.vd_next = BYTE_GET (evd.vd_next);
4890 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4892 offset += ivd.vd_next;
4894 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4895 && ivd.vd_next != 0);
4897 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4899 Elf_External_Verdaux evda;
4900 Elf_Internal_Verdaux ivda;
4902 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4904 get_data (&evda, file,
4905 offset - ivd.vd_next + ivd.vd_aux,
4906 sizeof (evda), _("version def aux"));
4908 ivda.vda_name = BYTE_GET (evda.vda_name);
4910 name = strtab + ivda.vda_name;
4911 nn += printf ("(%s%-*s",
4913 12 - (int) strlen (name),
4919 printf ("%*c", 18 - nn, ' ');
4937 printf (_("\nNo version information found in this file.\n"));
4943 get_symbol_binding (binding)
4944 unsigned int binding;
4946 static char buff [32];
4950 case STB_LOCAL: return "LOCAL";
4951 case STB_GLOBAL: return "GLOBAL";
4952 case STB_WEAK: return "WEAK";
4954 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4955 sprintf (buff, _("<processor specific>: %d"), binding);
4956 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4957 sprintf (buff, _("<OS specific>: %d"), binding);
4959 sprintf (buff, _("<unknown>: %d"), binding);
4965 get_symbol_type (type)
4968 static char buff [32];
4972 case STT_NOTYPE: return "NOTYPE";
4973 case STT_OBJECT: return "OBJECT";
4974 case STT_FUNC: return "FUNC";
4975 case STT_SECTION: return "SECTION";
4976 case STT_FILE: return "FILE";
4977 case STT_COMMON: return "COMMON";
4979 if (type >= STT_LOPROC && type <= STT_HIPROC)
4981 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4982 return "THUMB_FUNC";
4984 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4987 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4988 return "PARISC_MILLI";
4990 sprintf (buff, _("<processor specific>: %d"), type);
4992 else if (type >= STT_LOOS && type <= STT_HIOS)
4994 if (elf_header.e_machine == EM_PARISC)
4996 if (type == STT_HP_OPAQUE)
4998 if (type == STT_HP_STUB)
5002 sprintf (buff, _("<OS specific>: %d"), type);
5005 sprintf (buff, _("<unknown>: %d"), type);
5011 get_symbol_visibility (visibility)
5012 unsigned int visibility;
5016 case STV_DEFAULT: return "DEFAULT";
5017 case STV_INTERNAL: return "INTERNAL";
5018 case STV_HIDDEN: return "HIDDEN";
5019 case STV_PROTECTED: return "PROTECTED";
5025 get_symbol_index_type (type)
5030 case SHN_UNDEF: return "UND";
5031 case SHN_ABS: return "ABS";
5032 case SHN_COMMON: return "COM";
5034 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5036 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5038 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5042 static char buff [32];
5044 sprintf (buff, "%3d", type);
5051 get_dynamic_data (file, number)
5053 unsigned int number;
5055 unsigned char * e_data;
5058 e_data = (unsigned char *) malloc (number * 4);
5062 error (_("Out of memory\n"));
5066 if (fread (e_data, 4, number, file) != number)
5068 error (_("Unable to read in dynamic data\n"));
5072 i_data = (int *) malloc (number * sizeof (* i_data));
5076 error (_("Out of memory\n"));
5082 i_data [number] = byte_get (e_data + number * 4, 4);
5089 /* Dump the symbol table */
5091 process_symbol_table (file)
5094 Elf32_Internal_Shdr * section;
5095 unsigned char nb [4];
5096 unsigned char nc [4];
5099 int * buckets = NULL;
5100 int * chains = NULL;
5102 if (! do_syms && !do_histogram)
5105 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5108 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
5110 error (_("Unable to seek to start of dynamic information"));
5114 if (fread (nb, sizeof (nb), 1, file) != 1)
5116 error (_("Failed to read in number of buckets\n"));
5120 if (fread (nc, sizeof (nc), 1, file) != 1)
5122 error (_("Failed to read in number of chains\n"));
5126 nbuckets = byte_get (nb, 4);
5127 nchains = byte_get (nc, 4);
5129 buckets = get_dynamic_data (file, nbuckets);
5130 chains = get_dynamic_data (file, nchains);
5132 if (buckets == NULL || chains == NULL)
5137 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5142 printf (_("\nSymbol table for image:\n"));
5144 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5146 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5148 for (hn = 0; hn < nbuckets; hn++)
5153 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
5155 Elf_Internal_Sym * psym;
5157 psym = dynamic_symbols + si;
5159 printf (" %3d %3d: ", si, hn);
5160 print_vma (psym->st_value, LONG_HEX);
5162 print_vma (psym->st_size, DEC_5);
5164 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5165 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5166 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5167 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
5168 printf (" %s\n", dynamic_strings + psym->st_name);
5172 else if (do_syms && !do_using_dynamic)
5176 for (i = 0, section = section_headers;
5177 i < elf_header.e_shnum;
5182 Elf_Internal_Sym * symtab;
5183 Elf_Internal_Sym * psym;
5186 if ( section->sh_type != SHT_SYMTAB
5187 && section->sh_type != SHT_DYNSYM)
5190 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5191 SECTION_NAME (section),
5192 (unsigned long) (section->sh_size / section->sh_entsize));
5194 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5196 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5198 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
5199 section->sh_size / section->sh_entsize);
5203 if (section->sh_link == elf_header.e_shstrndx)
5204 strtab = string_table;
5207 Elf32_Internal_Shdr * string_sec;
5209 string_sec = section_headers + section->sh_link;
5211 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5212 string_sec->sh_size,
5216 for (si = 0, psym = symtab;
5217 si < section->sh_size / section->sh_entsize;
5220 printf ("%6d: ", si);
5221 print_vma (psym->st_value, LONG_HEX);
5223 print_vma (psym->st_size, DEC_5);
5224 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5225 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5226 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5227 printf (" %4s", get_symbol_index_type (psym->st_shndx));
5228 printf (" %s", strtab + psym->st_name);
5230 if (section->sh_type == SHT_DYNSYM &&
5231 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5233 unsigned char data[2];
5234 unsigned short vers_data;
5235 unsigned long offset;
5239 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
5242 get_data (&data, file, offset + si * sizeof (vers_data),
5243 sizeof (data), _("version data"));
5245 vers_data = byte_get (data, 2);
5247 is_nobits = psym->st_shndx < SHN_LORESERVE ?
5248 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
5251 check_def = (psym->st_shndx != SHN_UNDEF);
5253 if ((vers_data & 0x8000) || vers_data > 1)
5255 if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5256 && (is_nobits || ! check_def))
5258 Elf_External_Verneed evn;
5259 Elf_Internal_Verneed ivn;
5260 Elf_Internal_Vernaux ivna;
5262 /* We must test both. */
5263 offset = version_info
5264 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
5268 unsigned long vna_off;
5270 get_data (&evn, file, offset, sizeof (evn),
5273 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5274 ivn.vn_next = BYTE_GET (evn.vn_next);
5276 vna_off = offset + ivn.vn_aux;
5280 Elf_External_Vernaux evna;
5282 get_data (&evna, file, vna_off,
5284 _("version need aux (3)"));
5286 ivna.vna_other = BYTE_GET (evna.vna_other);
5287 ivna.vna_next = BYTE_GET (evna.vna_next);
5288 ivna.vna_name = BYTE_GET (evna.vna_name);
5290 vna_off += ivna.vna_next;
5292 while (ivna.vna_other != vers_data
5293 && ivna.vna_next != 0);
5295 if (ivna.vna_other == vers_data)
5298 offset += ivn.vn_next;
5300 while (ivn.vn_next != 0);
5302 if (ivna.vna_other == vers_data)
5305 strtab + ivna.vna_name, ivna.vna_other);
5308 else if (! is_nobits)
5309 error (_("bad dynamic symbol"));
5316 if (vers_data != 0x8001
5317 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5319 Elf_Internal_Verdef ivd;
5320 Elf_Internal_Verdaux ivda;
5321 Elf_External_Verdaux evda;
5322 unsigned long offset;
5325 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5330 Elf_External_Verdef evd;
5332 get_data (&evd, file, offset, sizeof (evd),
5335 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5336 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5337 ivd.vd_next = BYTE_GET (evd.vd_next);
5339 offset += ivd.vd_next;
5341 while (ivd.vd_ndx != (vers_data & 0x7fff)
5342 && ivd.vd_next != 0);
5344 offset -= ivd.vd_next;
5345 offset += ivd.vd_aux;
5347 get_data (&evda, file, offset, sizeof (evda),
5348 _("version def aux"));
5350 ivda.vda_name = BYTE_GET (evda.vda_name);
5352 if (psym->st_name != ivda.vda_name)
5353 printf ((vers_data & 0x8000)
5355 strtab + ivda.vda_name);
5365 if (strtab != string_table)
5371 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5373 if (do_histogram && buckets != NULL)
5380 int nzero_counts = 0;
5383 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5385 printf (_(" Length Number %% of total Coverage\n"));
5387 lengths = (int *) calloc (nbuckets, sizeof (int));
5388 if (lengths == NULL)
5390 error (_("Out of memory"));
5393 for (hn = 0; hn < nbuckets; ++hn)
5398 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5401 if (maxlength < ++lengths[hn])
5406 counts = (int *) calloc (maxlength + 1, sizeof (int));
5409 error (_("Out of memory"));
5413 for (hn = 0; hn < nbuckets; ++hn)
5414 ++ counts [lengths [hn]];
5418 printf (" 0 %-10d (%5.1f%%)\n",
5419 counts[0], (counts[0] * 100.0) / nbuckets);
5420 for (si = 1; si <= maxlength; ++si)
5422 nzero_counts += counts[si] * si;
5423 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5424 si, counts[si], (counts[si] * 100.0) / nbuckets,
5425 (nzero_counts * 100.0) / nsyms);
5433 if (buckets != NULL)
5443 process_syminfo (file)
5444 FILE * file ATTRIBUTE_UNUSED;
5448 if (dynamic_syminfo == NULL
5450 /* No syminfo, this is ok. */
5453 /* There better should be a dynamic symbol section. */
5454 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5458 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5459 dynamic_syminfo_offset, dynamic_syminfo_nent);
5461 printf (_(" Num: Name BoundTo Flags\n"));
5462 for (i = 0; i < dynamic_syminfo_nent; ++i)
5464 unsigned short int flags = dynamic_syminfo[i].si_flags;
5466 printf ("%4d: %-30s ", i,
5467 dynamic_strings + dynamic_symbols[i].st_name);
5469 switch (dynamic_syminfo[i].si_boundto)
5471 case SYMINFO_BT_SELF:
5472 fputs ("SELF ", stdout);
5474 case SYMINFO_BT_PARENT:
5475 fputs ("PARENT ", stdout);
5478 if (dynamic_syminfo[i].si_boundto > 0
5479 && dynamic_syminfo[i].si_boundto < dynamic_size)
5482 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
5484 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5488 if (flags & SYMINFO_FLG_DIRECT)
5490 if (flags & SYMINFO_FLG_PASSTHRU)
5491 printf (" PASSTHRU");
5492 if (flags & SYMINFO_FLG_COPY)
5494 if (flags & SYMINFO_FLG_LAZYLOAD)
5495 printf (" LAZYLOAD");
5503 #ifdef SUPPORT_DISASSEMBLY
5505 disassemble_section (section, file)
5506 Elf32_Internal_Shdr * section;
5509 printf (_("\nAssembly dump of section %s\n"),
5510 SECTION_NAME (section));
5512 /* XXX -- to be done --- XXX */
5519 dump_section (section, file)
5520 Elf32_Internal_Shdr * section;
5523 bfd_size_type bytes;
5525 unsigned char * data;
5526 unsigned char * start;
5528 bytes = section->sh_size;
5532 printf (_("\nSection '%s' has no data to dump.\n"),
5533 SECTION_NAME (section));
5537 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5539 addr = section->sh_addr;
5541 start = (unsigned char *) get_data (NULL, file, section->sh_offset, bytes,
5554 lbytes = (bytes > 16 ? 16 : bytes);
5556 printf (" 0x%8.8lx ", (unsigned long) addr);
5558 switch (elf_header.e_ident [EI_DATA])
5562 for (j = 15; j >= 0; j --)
5565 printf ("%2.2x", data [j]);
5575 for (j = 0; j < 16; j++)
5578 printf ("%2.2x", data [j]);
5588 for (j = 0; j < lbytes; j++)
5591 if (k >= ' ' && k < 0x80)
5610 static unsigned long int
5611 read_leb128 (data, length_return, sign)
5612 unsigned char * data;
5613 int * length_return;
5616 unsigned long int result = 0;
5617 unsigned int num_read = 0;
5626 result |= (byte & 0x7f) << shift;
5631 while (byte & 0x80);
5633 if (length_return != NULL)
5634 * length_return = num_read;
5636 if (sign && (shift < 32) && (byte & 0x40))
5637 result |= -1 << shift;
5642 typedef struct State_Machine_Registers
5644 unsigned long address;
5647 unsigned int column;
5651 /* This variable hold the number of the last entry seen
5652 in the File Table. */
5653 unsigned int last_file_entry;
5656 static SMR state_machine_regs;
5659 reset_state_machine (is_stmt)
5662 state_machine_regs.address = 0;
5663 state_machine_regs.file = 1;
5664 state_machine_regs.line = 1;
5665 state_machine_regs.column = 0;
5666 state_machine_regs.is_stmt = is_stmt;
5667 state_machine_regs.basic_block = 0;
5668 state_machine_regs.end_sequence = 0;
5669 state_machine_regs.last_file_entry = 0;
5672 /* Handled an extend line op. Returns true if this is the end
5675 process_extended_line_op (data, is_stmt, pointer_size)
5676 unsigned char * data;
5680 unsigned char op_code;
5683 unsigned char * name;
5686 len = read_leb128 (data, & bytes_read, 0);
5691 warn (_("badly formed extended line op encountered!"));
5696 op_code = * data ++;
5698 printf (_(" Extended opcode %d: "), op_code);
5702 case DW_LNE_end_sequence:
5703 printf (_("End of Sequence\n\n"));
5704 reset_state_machine (is_stmt);
5707 case DW_LNE_set_address:
5708 adr = byte_get (data, pointer_size);
5709 printf (_("set Address to 0x%lx\n"), adr);
5710 state_machine_regs.address = adr;
5713 case DW_LNE_define_file:
5714 printf (_(" define new File Table entry\n"));
5715 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5717 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5719 data += strlen ((char *) data) + 1;
5720 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5722 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5724 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5725 printf (_("%s\n\n"), name);
5729 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5736 /* Size of pointers in the .debug_line section. This information is not
5737 really present in that section. It's obtained before dumping the debug
5738 sections by doing some pre-scan of the .debug_info section. */
5739 static int debug_line_pointer_size = 4;
5742 display_debug_lines (section, start, file)
5743 Elf32_Internal_Shdr * section;
5744 unsigned char * start;
5745 FILE * file ATTRIBUTE_UNUSED;
5747 DWARF2_External_LineInfo * external;
5748 DWARF2_Internal_LineInfo info;
5749 unsigned char * standard_opcodes;
5750 unsigned char * data = start;
5751 unsigned char * end = start + section->sh_size;
5752 unsigned char * end_of_sequence;
5755 printf (_("\nDump of debug contents of section %s:\n\n"),
5756 SECTION_NAME (section));
5760 external = (DWARF2_External_LineInfo *) data;
5762 /* Check the length of the block. */
5763 info.li_length = BYTE_GET (external->li_length);
5765 if (info.li_length == 0xffffffff)
5767 warn (_("64-bit DWARF line info is not supported yet.\n"));
5771 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5774 (_("The line info appears to be corrupt - the section is too small\n"));
5778 /* Check its version number. */
5779 info.li_version = BYTE_GET (external->li_version);
5780 if (info.li_version != 2)
5782 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5786 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5787 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5788 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5789 info.li_line_base = BYTE_GET (external->li_line_base);
5790 info.li_line_range = BYTE_GET (external->li_line_range);
5791 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5793 /* Sign extend the line base field. */
5794 info.li_line_base <<= 24;
5795 info.li_line_base >>= 24;
5797 printf (_(" Length: %ld\n"), info.li_length);
5798 printf (_(" DWARF Version: %d\n"), info.li_version);
5799 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
5800 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5801 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5802 printf (_(" Line Base: %d\n"), info.li_line_base);
5803 printf (_(" Line Range: %d\n"), info.li_line_range);
5804 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5806 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5808 reset_state_machine (info.li_default_is_stmt);
5810 /* Display the contents of the Opcodes table. */
5811 standard_opcodes = data + sizeof (* external);
5813 printf (_("\n Opcodes:\n"));
5815 for (i = 1; i < info.li_opcode_base; i++)
5816 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5818 /* Display the contents of the Directory table. */
5819 data = standard_opcodes + info.li_opcode_base - 1;
5822 printf (_("\n The Directory Table is empty.\n"));
5825 printf (_("\n The Directory Table:\n"));
5829 printf (_(" %s\n"), data);
5831 data += strlen ((char *) data) + 1;
5835 /* Skip the NUL at the end of the table. */
5838 /* Display the contents of the File Name table. */
5840 printf (_("\n The File Name Table is empty.\n"));
5843 printf (_("\n The File Name Table:\n"));
5844 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5848 unsigned char * name;
5851 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5854 data += strlen ((char *) data) + 1;
5856 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5858 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5860 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5862 printf (_("%s\n"), name);
5866 /* Skip the NUL at the end of the table. */
5869 /* Now display the statements. */
5870 printf (_("\n Line Number Statements:\n"));
5873 while (data < end_of_sequence)
5875 unsigned char op_code;
5879 op_code = * data ++;
5883 case DW_LNS_extended_op:
5884 data += process_extended_line_op (data, info.li_default_is_stmt,
5885 debug_line_pointer_size);
5889 printf (_(" Copy\n"));
5892 case DW_LNS_advance_pc:
5893 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5895 state_machine_regs.address += adv;
5896 printf (_(" Advance PC by %d to %lx\n"), adv,
5897 state_machine_regs.address);
5900 case DW_LNS_advance_line:
5901 adv = read_leb128 (data, & bytes_read, 1);
5903 state_machine_regs.line += adv;
5904 printf (_(" Advance Line by %d to %d\n"), adv,
5905 state_machine_regs.line);
5908 case DW_LNS_set_file:
5909 adv = read_leb128 (data, & bytes_read, 0);
5911 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5913 state_machine_regs.file = adv;
5916 case DW_LNS_set_column:
5917 adv = read_leb128 (data, & bytes_read, 0);
5919 printf (_(" Set column to %d\n"), adv);
5920 state_machine_regs.column = adv;
5923 case DW_LNS_negate_stmt:
5924 adv = state_machine_regs.is_stmt;
5926 printf (_(" Set is_stmt to %d\n"), adv);
5927 state_machine_regs.is_stmt = adv;
5930 case DW_LNS_set_basic_block:
5931 printf (_(" Set basic block\n"));
5932 state_machine_regs.basic_block = 1;
5935 case DW_LNS_const_add_pc:
5936 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5937 * info.li_min_insn_length);
5938 state_machine_regs.address += adv;
5939 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5940 state_machine_regs.address);
5943 case DW_LNS_fixed_advance_pc:
5944 adv = byte_get (data, 2);
5946 state_machine_regs.address += adv;
5947 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5948 adv, state_machine_regs.address);
5952 op_code -= info.li_opcode_base;
5953 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5954 state_machine_regs.address += adv;
5955 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5956 op_code, adv, state_machine_regs.address);
5957 adv = (op_code % info.li_line_range) + info.li_line_base;
5958 state_machine_regs.line += adv;
5959 printf (_(" and Line by %d to %d\n"),
5960 adv, state_machine_regs.line);
5971 display_debug_pubnames (section, start, file)
5972 Elf32_Internal_Shdr * section;
5973 unsigned char * start;
5974 FILE * file ATTRIBUTE_UNUSED;
5976 DWARF2_External_PubNames * external;
5977 DWARF2_Internal_PubNames pubnames;
5978 unsigned char * end;
5980 end = start + section->sh_size;
5982 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5986 unsigned char * data;
5987 unsigned long offset;
5989 external = (DWARF2_External_PubNames *) start;
5991 pubnames.pn_length = BYTE_GET (external->pn_length);
5992 pubnames.pn_version = BYTE_GET (external->pn_version);
5993 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5994 pubnames.pn_size = BYTE_GET (external->pn_size);
5996 data = start + sizeof (* external);
5997 start += pubnames.pn_length + sizeof (external->pn_length);
5999 if (pubnames.pn_length == 0xffffffff)
6001 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6005 if (pubnames.pn_version != 2)
6007 static int warned = 0;
6011 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6018 printf (_(" Length: %ld\n"),
6019 pubnames.pn_length);
6020 printf (_(" Version: %d\n"),
6021 pubnames.pn_version);
6022 printf (_(" Offset into .debug_info section: %ld\n"),
6023 pubnames.pn_offset);
6024 printf (_(" Size of area in .debug_info section: %ld\n"),
6027 printf (_("\n Offset\tName\n"));
6031 offset = byte_get (data, 4);
6036 printf (" %ld\t\t%s\n", offset, data);
6037 data += strlen ((char *) data) + 1;
6040 while (offset != 0);
6053 case DW_TAG_padding: return "DW_TAG_padding";
6054 case DW_TAG_array_type: return "DW_TAG_array_type";
6055 case DW_TAG_class_type: return "DW_TAG_class_type";
6056 case DW_TAG_entry_point: return "DW_TAG_entry_point";
6057 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
6058 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
6059 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
6060 case DW_TAG_label: return "DW_TAG_label";
6061 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
6062 case DW_TAG_member: return "DW_TAG_member";
6063 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
6064 case DW_TAG_reference_type: return "DW_TAG_reference_type";
6065 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
6066 case DW_TAG_string_type: return "DW_TAG_string_type";
6067 case DW_TAG_structure_type: return "DW_TAG_structure_type";
6068 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
6069 case DW_TAG_typedef: return "DW_TAG_typedef";
6070 case DW_TAG_union_type: return "DW_TAG_union_type";
6071 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6072 case DW_TAG_variant: return "DW_TAG_variant";
6073 case DW_TAG_common_block: return "DW_TAG_common_block";
6074 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
6075 case DW_TAG_inheritance: return "DW_TAG_inheritance";
6076 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
6077 case DW_TAG_module: return "DW_TAG_module";
6078 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
6079 case DW_TAG_set_type: return "DW_TAG_set_type";
6080 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
6081 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
6082 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
6083 case DW_TAG_base_type: return "DW_TAG_base_type";
6084 case DW_TAG_catch_block: return "DW_TAG_catch_block";
6085 case DW_TAG_const_type: return "DW_TAG_const_type";
6086 case DW_TAG_constant: return "DW_TAG_constant";
6087 case DW_TAG_enumerator: return "DW_TAG_enumerator";
6088 case DW_TAG_file_type: return "DW_TAG_file_type";
6089 case DW_TAG_friend: return "DW_TAG_friend";
6090 case DW_TAG_namelist: return "DW_TAG_namelist";
6091 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
6092 case DW_TAG_packed_type: return "DW_TAG_packed_type";
6093 case DW_TAG_subprogram: return "DW_TAG_subprogram";
6094 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
6095 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
6096 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
6097 case DW_TAG_try_block: return "DW_TAG_try_block";
6098 case DW_TAG_variant_part: return "DW_TAG_variant_part";
6099 case DW_TAG_variable: return "DW_TAG_variable";
6100 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
6101 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
6102 case DW_TAG_format_label: return "DW_TAG_format_label";
6103 case DW_TAG_function_template: return "DW_TAG_function_template";
6104 case DW_TAG_class_template: return "DW_TAG_class_template";
6105 /* DWARF 2.1 values. */
6106 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
6107 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
6108 case DW_TAG_interface_type: return "DW_TAG_interface_type";
6109 case DW_TAG_namespace: return "DW_TAG_namespace";
6110 case DW_TAG_imported_module: return "DW_TAG_imported_module";
6111 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
6112 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
6113 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
6116 static char buffer [100];
6118 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6125 get_AT_name (attribute)
6126 unsigned long attribute;
6130 case DW_AT_sibling: return "DW_AT_sibling";
6131 case DW_AT_location: return "DW_AT_location";
6132 case DW_AT_name: return "DW_AT_name";
6133 case DW_AT_ordering: return "DW_AT_ordering";
6134 case DW_AT_subscr_data: return "DW_AT_subscr_data";
6135 case DW_AT_byte_size: return "DW_AT_byte_size";
6136 case DW_AT_bit_offset: return "DW_AT_bit_offset";
6137 case DW_AT_bit_size: return "DW_AT_bit_size";
6138 case DW_AT_element_list: return "DW_AT_element_list";
6139 case DW_AT_stmt_list: return "DW_AT_stmt_list";
6140 case DW_AT_low_pc: return "DW_AT_low_pc";
6141 case DW_AT_high_pc: return "DW_AT_high_pc";
6142 case DW_AT_language: return "DW_AT_language";
6143 case DW_AT_member: return "DW_AT_member";
6144 case DW_AT_discr: return "DW_AT_discr";
6145 case DW_AT_discr_value: return "DW_AT_discr_value";
6146 case DW_AT_visibility: return "DW_AT_visibility";
6147 case DW_AT_import: return "DW_AT_import";
6148 case DW_AT_string_length: return "DW_AT_string_length";
6149 case DW_AT_common_reference: return "DW_AT_common_reference";
6150 case DW_AT_comp_dir: return "DW_AT_comp_dir";
6151 case DW_AT_const_value: return "DW_AT_const_value";
6152 case DW_AT_containing_type: return "DW_AT_containing_type";
6153 case DW_AT_default_value: return "DW_AT_default_value";
6154 case DW_AT_inline: return "DW_AT_inline";
6155 case DW_AT_is_optional: return "DW_AT_is_optional";
6156 case DW_AT_lower_bound: return "DW_AT_lower_bound";
6157 case DW_AT_producer: return "DW_AT_producer";
6158 case DW_AT_prototyped: return "DW_AT_prototyped";
6159 case DW_AT_return_addr: return "DW_AT_return_addr";
6160 case DW_AT_start_scope: return "DW_AT_start_scope";
6161 case DW_AT_stride_size: return "DW_AT_stride_size";
6162 case DW_AT_upper_bound: return "DW_AT_upper_bound";
6163 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
6164 case DW_AT_accessibility: return "DW_AT_accessibility";
6165 case DW_AT_address_class: return "DW_AT_address_class";
6166 case DW_AT_artificial: return "DW_AT_artificial";
6167 case DW_AT_base_types: return "DW_AT_base_types";
6168 case DW_AT_calling_convention: return "DW_AT_calling_convention";
6169 case DW_AT_count: return "DW_AT_count";
6170 case DW_AT_data_member_location: return "DW_AT_data_member_location";
6171 case DW_AT_decl_column: return "DW_AT_decl_column";
6172 case DW_AT_decl_file: return "DW_AT_decl_file";
6173 case DW_AT_decl_line: return "DW_AT_decl_line";
6174 case DW_AT_declaration: return "DW_AT_declaration";
6175 case DW_AT_discr_list: return "DW_AT_discr_list";
6176 case DW_AT_encoding: return "DW_AT_encoding";
6177 case DW_AT_external: return "DW_AT_external";
6178 case DW_AT_frame_base: return "DW_AT_frame_base";
6179 case DW_AT_friend: return "DW_AT_friend";
6180 case DW_AT_identifier_case: return "DW_AT_identifier_case";
6181 case DW_AT_macro_info: return "DW_AT_macro_info";
6182 case DW_AT_namelist_items: return "DW_AT_namelist_items";
6183 case DW_AT_priority: return "DW_AT_priority";
6184 case DW_AT_segment: return "DW_AT_segment";
6185 case DW_AT_specification: return "DW_AT_specification";
6186 case DW_AT_static_link: return "DW_AT_static_link";
6187 case DW_AT_type: return "DW_AT_type";
6188 case DW_AT_use_location: return "DW_AT_use_location";
6189 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
6190 case DW_AT_virtuality: return "DW_AT_virtuality";
6191 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6192 /* DWARF 2.1 values. */
6193 case DW_AT_allocated: return "DW_AT_allocated";
6194 case DW_AT_associated: return "DW_AT_associated";
6195 case DW_AT_data_location: return "DW_AT_data_location";
6196 case DW_AT_stride: return "DW_AT_stride";
6197 case DW_AT_entry_pc: return "DW_AT_entry_pc";
6198 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
6199 case DW_AT_extension: return "DW_AT_extension";
6200 case DW_AT_ranges: return "DW_AT_ranges";
6201 case DW_AT_trampoline: return "DW_AT_trampoline";
6202 case DW_AT_call_column: return "DW_AT_call_column";
6203 case DW_AT_call_file: return "DW_AT_call_file";
6204 case DW_AT_call_line: return "DW_AT_call_line";
6205 /* SGI/MIPS extensions. */
6206 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
6207 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
6208 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6209 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
6210 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6211 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
6212 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
6213 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
6214 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
6215 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
6216 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
6217 /* GNU extensions. */
6218 case DW_AT_sf_names: return "DW_AT_sf_names";
6219 case DW_AT_src_info: return "DW_AT_src_info";
6220 case DW_AT_mac_info: return "DW_AT_mac_info";
6221 case DW_AT_src_coords: return "DW_AT_src_coords";
6222 case DW_AT_body_begin: return "DW_AT_body_begin";
6223 case DW_AT_body_end: return "DW_AT_body_end";
6226 static char buffer [100];
6228 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6235 get_FORM_name (form)
6240 case DW_FORM_addr: return "DW_FORM_addr";
6241 case DW_FORM_block2: return "DW_FORM_block2";
6242 case DW_FORM_block4: return "DW_FORM_block4";
6243 case DW_FORM_data2: return "DW_FORM_data2";
6244 case DW_FORM_data4: return "DW_FORM_data4";
6245 case DW_FORM_data8: return "DW_FORM_data8";
6246 case DW_FORM_string: return "DW_FORM_string";
6247 case DW_FORM_block: return "DW_FORM_block";
6248 case DW_FORM_block1: return "DW_FORM_block1";
6249 case DW_FORM_data1: return "DW_FORM_data1";
6250 case DW_FORM_flag: return "DW_FORM_flag";
6251 case DW_FORM_sdata: return "DW_FORM_sdata";
6252 case DW_FORM_strp: return "DW_FORM_strp";
6253 case DW_FORM_udata: return "DW_FORM_udata";
6254 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
6255 case DW_FORM_ref1: return "DW_FORM_ref1";
6256 case DW_FORM_ref2: return "DW_FORM_ref2";
6257 case DW_FORM_ref4: return "DW_FORM_ref4";
6258 case DW_FORM_ref8: return "DW_FORM_ref8";
6259 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6260 case DW_FORM_indirect: return "DW_FORM_indirect";
6263 static char buffer [100];
6265 sprintf (buffer, _("Unknown FORM value: %lx"), form);
6271 /* FIXME: There are better and more effiecint ways to handle
6272 these structures. For now though, I just want something that
6273 is simple to implement. */
6274 typedef struct abbrev_attr
6276 unsigned long attribute;
6278 struct abbrev_attr * next;
6282 typedef struct abbrev_entry
6284 unsigned long entry;
6287 struct abbrev_attr * first_attr;
6288 struct abbrev_attr * last_attr;
6289 struct abbrev_entry * next;
6293 static abbrev_entry * first_abbrev = NULL;
6294 static abbrev_entry * last_abbrev = NULL;
6297 free_abbrevs PARAMS ((void))
6299 abbrev_entry * abbrev;
6301 for (abbrev = first_abbrev; abbrev;)
6303 abbrev_entry * next = abbrev->next;
6306 for (attr = abbrev->first_attr; attr;)
6308 abbrev_attr * next = attr->next;
6318 last_abbrev = first_abbrev = NULL;
6322 add_abbrev (number, tag, children)
6323 unsigned long number;
6327 abbrev_entry * entry;
6329 entry = (abbrev_entry *) malloc (sizeof (* entry));
6335 entry->entry = number;
6337 entry->children = children;
6338 entry->first_attr = NULL;
6339 entry->last_attr = NULL;
6342 if (first_abbrev == NULL)
6343 first_abbrev = entry;
6345 last_abbrev->next = entry;
6347 last_abbrev = entry;
6351 add_abbrev_attr (attribute, form)
6352 unsigned long attribute;
6357 attr = (abbrev_attr *) malloc (sizeof (* attr));
6363 attr->attribute = attribute;
6367 if (last_abbrev->first_attr == NULL)
6368 last_abbrev->first_attr = attr;
6370 last_abbrev->last_attr->next = attr;
6372 last_abbrev->last_attr = attr;
6375 /* Processes the (partial) contents of a .debug_abbrev section.
6376 Returns NULL if the end of the section was encountered.
6377 Returns the address after the last byte read if the end of
6378 an abbreviation set was found. */
6380 static unsigned char *
6381 process_abbrev_section (start, end)
6382 unsigned char * start;
6383 unsigned char * end;
6385 if (first_abbrev != NULL)
6391 unsigned long entry;
6393 unsigned long attribute;
6396 entry = read_leb128 (start, & bytes_read, 0);
6397 start += bytes_read;
6399 /* A single zero is supposed to end the section according
6400 to the standard. If there's more, then signal that to
6403 return start == end ? NULL : start;
6405 tag = read_leb128 (start, & bytes_read, 0);
6406 start += bytes_read;
6408 children = * start ++;
6410 add_abbrev (entry, tag, children);
6416 attribute = read_leb128 (start, & bytes_read, 0);
6417 start += bytes_read;
6419 form = read_leb128 (start, & bytes_read, 0);
6420 start += bytes_read;
6423 add_abbrev_attr (attribute, form);
6425 while (attribute != 0);
6433 display_debug_macinfo (section, start, file)
6434 Elf32_Internal_Shdr * section;
6435 unsigned char * start;
6436 FILE * file ATTRIBUTE_UNUSED;
6438 unsigned char * end = start + section->sh_size;
6439 unsigned char * curr = start;
6440 unsigned int bytes_read;
6441 enum dwarf_macinfo_record_type op;
6443 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6447 unsigned int lineno;
6448 const char * string;
6455 case DW_MACINFO_start_file:
6457 unsigned int filenum;
6459 lineno = read_leb128 (curr, & bytes_read, 0);
6461 filenum = read_leb128 (curr, & bytes_read, 0);
6464 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
6468 case DW_MACINFO_end_file:
6469 printf (_(" DW_MACINFO_end_file\n"));
6472 case DW_MACINFO_define:
6473 lineno = read_leb128 (curr, & bytes_read, 0);
6476 curr += strlen (string) + 1;
6477 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
6480 case DW_MACINFO_undef:
6481 lineno = read_leb128 (curr, & bytes_read, 0);
6484 curr += strlen (string) + 1;
6485 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
6488 case DW_MACINFO_vendor_ext:
6490 unsigned int constant;
6492 constant = read_leb128 (curr, & bytes_read, 0);
6495 curr += strlen (string) + 1;
6496 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
6507 display_debug_abbrev (section, start, file)
6508 Elf32_Internal_Shdr * section;
6509 unsigned char * start;
6510 FILE * file ATTRIBUTE_UNUSED;
6512 abbrev_entry * entry;
6513 unsigned char * end = start + section->sh_size;
6515 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6519 start = process_abbrev_section (start, end);
6521 printf (_(" Number TAG\n"));
6523 for (entry = first_abbrev; entry; entry = entry->next)
6527 printf (_(" %ld %s [%s]\n"),
6529 get_TAG_name (entry->tag),
6530 entry->children ? _("has children") : _("no children"));
6532 for (attr = entry->first_attr; attr; attr = attr->next)
6534 printf (_(" %-18s %s\n"),
6535 get_AT_name (attr->attribute),
6536 get_FORM_name (attr->form));
6548 static unsigned char *
6549 display_block (data, length)
6550 unsigned char * data;
6551 unsigned long length;
6553 printf (_(" %lu byte block: "), length);
6556 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6562 decode_location_expression (data, pointer_size, length)
6563 unsigned char * data;
6564 unsigned int pointer_size;
6565 unsigned long length;
6569 unsigned long uvalue;
6570 unsigned char * end = data + length;
6579 printf ("DW_OP_addr: %lx",
6580 (unsigned long) byte_get (data, pointer_size));
6581 data += pointer_size;
6584 printf ("DW_OP_deref");
6587 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6590 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6593 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6597 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6601 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6605 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6609 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6610 (unsigned long) byte_get (data + 4, 4));
6614 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6615 (long) byte_get (data + 4, 4));
6619 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6623 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6627 printf ("DW_OP_dup");
6630 printf ("DW_OP_drop");
6633 printf ("DW_OP_over");
6636 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6639 printf ("DW_OP_swap");
6642 printf ("DW_OP_rot");
6645 printf ("DW_OP_xderef");
6648 printf ("DW_OP_abs");
6651 printf ("DW_OP_and");
6654 printf ("DW_OP_div");
6657 printf ("DW_OP_minus");
6660 printf ("DW_OP_mod");
6663 printf ("DW_OP_mul");
6666 printf ("DW_OP_neg");
6669 printf ("DW_OP_not");
6672 printf ("DW_OP_or");
6675 printf ("DW_OP_plus");
6677 case DW_OP_plus_uconst:
6678 printf ("DW_OP_plus_uconst: %lu",
6679 read_leb128 (data, &bytes_read, 0));
6683 printf ("DW_OP_shl");
6686 printf ("DW_OP_shr");
6689 printf ("DW_OP_shra");
6692 printf ("DW_OP_xor");
6695 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
6699 printf ("DW_OP_eq");
6702 printf ("DW_OP_ge");
6705 printf ("DW_OP_gt");
6708 printf ("DW_OP_le");
6711 printf ("DW_OP_lt");
6714 printf ("DW_OP_ne");
6717 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
6753 printf ("DW_OP_lit%d", op - DW_OP_lit0);
6788 printf ("DW_OP_reg%d", op - DW_OP_reg0);
6823 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
6824 read_leb128 (data, &bytes_read, 1));
6829 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6833 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6837 uvalue = read_leb128 (data, &bytes_read, 0);
6839 printf ("DW_OP_bregx: %lu %ld", uvalue,
6840 read_leb128 (data, &bytes_read, 1));
6844 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6847 case DW_OP_deref_size:
6848 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6850 case DW_OP_xderef_size:
6851 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6854 printf ("DW_OP_nop");
6857 /* DWARF 2.1 extensions. */
6858 case DW_OP_push_object_address:
6859 printf ("DW_OP_push_object_address");
6862 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
6866 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
6870 printf ("DW_OP_calli");
6874 if (op >= DW_OP_lo_user
6875 && op <= DW_OP_hi_user)
6876 printf (_("(User defined location op)"));
6878 printf (_("(Unknown location op)"));
6879 /* No way to tell where the next op is, so just bail. */
6883 /* Separate the ops. */
6889 static unsigned char *
6890 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6891 unsigned long attribute;
6893 unsigned char * data;
6894 unsigned long cu_offset;
6895 unsigned long pointer_size;
6897 unsigned long uvalue = 0;
6898 unsigned char * block_start = NULL;
6901 printf (" %-18s:", get_AT_name (attribute));
6908 case DW_FORM_ref_addr:
6910 uvalue = byte_get (data, pointer_size);
6911 data += pointer_size;
6917 uvalue = byte_get (data ++, 1);
6922 uvalue = byte_get (data, 2);
6928 uvalue = byte_get (data, 4);
6933 uvalue = read_leb128 (data, & bytes_read, 1);
6937 case DW_FORM_ref_udata:
6939 uvalue = read_leb128 (data, & bytes_read, 0);
6946 case DW_FORM_ref_addr:
6947 printf (" <#%lx>", uvalue);
6953 case DW_FORM_ref_udata:
6954 printf (" <%lx>", uvalue + cu_offset);
6958 printf (" %#lx", uvalue);
6966 printf (" %ld", uvalue);
6971 uvalue = byte_get (data, 4);
6972 printf (" %lx", uvalue);
6973 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6977 case DW_FORM_string:
6978 printf (" %s", data);
6979 data += strlen ((char *) data) + 1;
6983 uvalue = read_leb128 (data, & bytes_read, 0);
6984 block_start = data + bytes_read;
6985 data = display_block (block_start, uvalue);
6988 case DW_FORM_block1:
6989 uvalue = byte_get (data, 1);
6990 block_start = data + 1;
6991 data = display_block (block_start, uvalue);
6994 case DW_FORM_block2:
6995 uvalue = byte_get (data, 2);
6996 block_start = data + 2;
6997 data = display_block (block_start, uvalue);
7000 case DW_FORM_block4:
7001 uvalue = byte_get (data, 4);
7002 block_start = data + 4;
7003 data = display_block (block_start, uvalue);
7007 case DW_FORM_indirect:
7008 warn (_("Unable to handle FORM: %d"), form);
7012 warn (_("Unrecognised form: %d"), form);
7016 /* For some attributes we can display futher information. */
7025 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
7026 case DW_INL_inlined: printf (_("(inlined)")); break;
7027 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
7028 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
7029 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
7033 case DW_AT_language:
7036 case DW_LANG_C: printf ("(non-ANSI C)"); break;
7037 case DW_LANG_C89: printf ("(ANSI C)"); break;
7038 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
7039 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
7040 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
7041 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
7042 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
7043 case DW_LANG_Ada83: printf ("(Ada)"); break;
7044 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
7045 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
7046 /* DWARF 2.1 values. */
7047 case DW_LANG_C99: printf ("(ANSI C99)"); break;
7048 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
7049 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
7050 /* MIPS extension. */
7051 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7052 default: printf ("(Unknown: %lx)", uvalue); break;
7056 case DW_AT_encoding:
7059 case DW_ATE_void: printf ("(void)"); break;
7060 case DW_ATE_address: printf ("(machine address)"); break;
7061 case DW_ATE_boolean: printf ("(boolean)"); break;
7062 case DW_ATE_complex_float: printf ("(complex float)"); break;
7063 case DW_ATE_float: printf ("(float)"); break;
7064 case DW_ATE_signed: printf ("(signed)"); break;
7065 case DW_ATE_signed_char: printf ("(signed char)"); break;
7066 case DW_ATE_unsigned: printf ("(unsigned)"); break;
7067 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
7068 /* DWARF 2.1 value. */
7069 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7071 if (uvalue >= DW_ATE_lo_user
7072 && uvalue <= DW_ATE_hi_user)
7073 printf ("(user defined type)");
7075 printf ("(unknown type)");
7080 case DW_AT_accessibility:
7083 case DW_ACCESS_public: printf ("(public)"); break;
7084 case DW_ACCESS_protected: printf ("(protected)"); break;
7085 case DW_ACCESS_private: printf ("(private)"); break;
7086 default: printf ("(unknown accessibility)"); break;
7090 case DW_AT_visibility:
7093 case DW_VIS_local: printf ("(local)"); break;
7094 case DW_VIS_exported: printf ("(exported)"); break;
7095 case DW_VIS_qualified: printf ("(qualified)"); break;
7096 default: printf ("(unknown visibility)"); break;
7100 case DW_AT_virtuality:
7103 case DW_VIRTUALITY_none: printf ("(none)"); break;
7104 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
7105 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
7106 default: printf ("(unknown virtuality)"); break;
7110 case DW_AT_identifier_case:
7113 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
7114 case DW_ID_up_case: printf ("(up_case)"); break;
7115 case DW_ID_down_case: printf ("(down_case)"); break;
7116 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
7117 default: printf ("(unknown case)"); break;
7121 case DW_AT_calling_convention:
7124 case DW_CC_normal: printf ("(normal)"); break;
7125 case DW_CC_program: printf ("(program)"); break;
7126 case DW_CC_nocall: printf ("(nocall)"); break;
7128 if (uvalue >= DW_CC_lo_user
7129 && uvalue <= DW_CC_hi_user)
7130 printf ("(user defined)");
7132 printf ("(unknown convention)");
7136 case DW_AT_ordering:
7139 case -1: printf ("(undefined)"); break;
7140 case 0: printf ("(row major)"); break;
7141 case 1: printf ("(column major)"); break;
7145 case DW_AT_frame_base:
7146 case DW_AT_location:
7147 case DW_AT_data_member_location:
7148 case DW_AT_vtable_elem_location:
7149 case DW_AT_allocated:
7150 case DW_AT_associated:
7151 case DW_AT_data_location:
7153 case DW_AT_upper_bound:
7154 case DW_AT_lower_bound:
7158 decode_location_expression (block_start, pointer_size, uvalue);
7172 display_debug_info (section, start, file)
7173 Elf32_Internal_Shdr * section;
7174 unsigned char * start;
7177 unsigned char * end = start + section->sh_size;
7178 unsigned char * section_begin = start;
7180 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7184 DWARF2_External_CompUnit * external;
7185 DWARF2_Internal_CompUnit compunit;
7186 Elf32_Internal_Shdr * relsec;
7187 unsigned char * tags;
7190 unsigned long cu_offset;
7192 external = (DWARF2_External_CompUnit *) start;
7194 compunit.cu_length = BYTE_GET (external->cu_length);
7195 compunit.cu_version = BYTE_GET (external->cu_version);
7196 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
7197 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
7199 if (compunit.cu_length == 0xffffffff)
7201 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7205 /* Check for RELA relocations in the abbrev_offset address, and
7207 for (relsec = section_headers;
7208 relsec < section_headers + elf_header.e_shnum;
7211 unsigned long nrelas, nsyms;
7212 Elf_Internal_Rela *rela, *rp;
7213 Elf32_Internal_Shdr *symsec;
7214 Elf_Internal_Sym *symtab;
7215 Elf_Internal_Sym *sym;
7217 if (relsec->sh_type != SHT_RELA
7218 || section_headers + relsec->sh_info != section)
7221 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7225 symsec = section_headers + relsec->sh_link;
7226 nsyms = symsec->sh_size / symsec->sh_entsize;
7227 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
7229 for (rp = rela; rp < rela + nrelas; ++rp)
7232 != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
7238 sym = symtab + ELF32_R_SYM (rp->r_info);
7240 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
7242 warn (_("Skipping unexpected symbol type %u"),
7243 ELF32_ST_TYPE (sym->st_info));
7249 sym = symtab + ELF64_R_SYM (rp->r_info);
7251 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
7253 warn (_("Skipping unexpected symbol type %u"),
7254 ELF64_ST_TYPE (sym->st_info));
7259 compunit.cu_abbrev_offset += rp->r_addend;
7267 tags = start + sizeof (* external);
7268 cu_offset = start - section_begin;
7269 start += compunit.cu_length + sizeof (external->cu_length);
7271 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
7272 printf (_(" Length: %ld\n"), compunit.cu_length);
7273 printf (_(" Version: %d\n"), compunit.cu_version);
7274 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
7275 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
7277 if (compunit.cu_version != 2)
7279 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7283 if (first_abbrev != NULL)
7286 /* Read in the abbrevs used by this compilation unit. */
7289 Elf32_Internal_Shdr * sec;
7290 unsigned char * begin;
7292 /* Locate the .debug_abbrev section and process it. */
7293 for (i = 0, sec = section_headers;
7294 i < elf_header.e_shnum;
7296 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
7299 if (i == -1 || sec->sh_size == 0)
7301 warn (_("Unable to locate .debug_abbrev section!\n"));
7305 begin = ((unsigned char *)
7306 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7307 _("debug_abbrev section data")));
7311 process_abbrev_section (begin + compunit.cu_abbrev_offset,
7312 begin + sec->sh_size);
7318 while (tags < start)
7321 unsigned long abbrev_number;
7322 abbrev_entry * entry;
7325 abbrev_number = read_leb128 (tags, & bytes_read, 0);
7328 /* A null DIE marks the end of a list of children. */
7329 if (abbrev_number == 0)
7335 /* Scan through the abbreviation list until we reach the
7337 for (entry = first_abbrev;
7338 entry && entry->entry != abbrev_number;
7339 entry = entry->next)
7344 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7349 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7351 (unsigned long) (tags - section_begin - bytes_read),
7353 get_TAG_name (entry->tag));
7355 for (attr = entry->first_attr; attr; attr = attr->next)
7356 tags = read_and_display_attr (attr->attribute,
7359 compunit.cu_pointer_size);
7361 if (entry->children)
7372 display_debug_aranges (section, start, file)
7373 Elf32_Internal_Shdr * section;
7374 unsigned char * start;
7375 FILE * file ATTRIBUTE_UNUSED;
7377 unsigned char * end = start + section->sh_size;
7379 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7383 DWARF2_External_ARange * external;
7384 DWARF2_Internal_ARange arange;
7385 unsigned char * ranges;
7386 unsigned long length;
7387 unsigned long address;
7390 external = (DWARF2_External_ARange *) start;
7392 arange.ar_length = BYTE_GET (external->ar_length);
7393 arange.ar_version = BYTE_GET (external->ar_version);
7394 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
7395 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
7396 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
7398 if (arange.ar_length == 0xffffffff)
7400 warn (_("64-bit DWARF aranges are not supported yet.\n"));
7404 if (arange.ar_version != 2)
7406 warn (_("Only DWARF 2 aranges are currently supported.\n"));
7410 printf (_(" Length: %ld\n"), arange.ar_length);
7411 printf (_(" Version: %d\n"), arange.ar_version);
7412 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
7413 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
7414 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
7416 printf (_("\n Address Length\n"));
7418 ranges = start + sizeof (* external);
7420 /* Must pad to an alignment boundary that is twice the pointer size. */
7421 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
7423 ranges += (2 * arange.ar_pointer_size) - excess;
7427 address = byte_get (ranges, arange.ar_pointer_size);
7429 ranges += arange.ar_pointer_size;
7431 length = byte_get (ranges, arange.ar_pointer_size);
7433 ranges += arange.ar_pointer_size;
7435 /* A pair of zeros marks the end of the list. */
7436 if (address == 0 && length == 0)
7439 printf (" %8.8lx %lu\n", address, length);
7442 start += arange.ar_length + sizeof (external->ar_length);
7450 typedef struct Frame_Chunk
7452 struct Frame_Chunk * next;
7453 unsigned char * chunk_start;
7455 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7456 short int * col_type;
7458 char * augmentation;
7459 unsigned int code_factor;
7461 unsigned long pc_begin;
7462 unsigned long pc_range;
7466 unsigned char fde_encoding;
7470 /* A marker for a col_type that means this column was never referenced
7471 in the frame info. */
7472 #define DW_CFA_unreferenced (-1)
7474 static void frame_need_space PARAMS ((Frame_Chunk *, int));
7475 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
7476 static int size_of_encoded_value PARAMS ((int));
7479 frame_need_space (fc, reg)
7483 int prev = fc->ncols;
7485 if (reg < fc->ncols)
7488 fc->ncols = reg + 1;
7489 fc->col_type = (short int *) xrealloc (fc->col_type,
7490 fc->ncols * sizeof (short int));
7491 fc->col_offset = (int *) xrealloc (fc->col_offset,
7492 fc->ncols * sizeof (int));
7494 while (prev < fc->ncols)
7496 fc->col_type[prev] = DW_CFA_unreferenced;
7497 fc->col_offset[prev] = 0;
7503 frame_display_row (fc, need_col_headers, max_regs)
7505 int * need_col_headers;
7511 if (* max_regs < fc->ncols)
7512 * max_regs = fc->ncols;
7514 if (* need_col_headers)
7516 * need_col_headers = 0;
7518 printf (" LOC CFA ");
7520 for (r = 0; r < * max_regs; r++)
7521 if (fc->col_type[r] != DW_CFA_unreferenced)
7526 printf ("r%-4d", r);
7532 printf ("%08lx ", fc->pc_begin);
7533 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
7534 printf ("%-8s ", tmp);
7536 for (r = 0; r < fc->ncols; r++)
7538 if (fc->col_type[r] != DW_CFA_unreferenced)
7540 switch (fc->col_type[r])
7542 case DW_CFA_undefined:
7545 case DW_CFA_same_value:
7549 sprintf (tmp, "c%+d", fc->col_offset[r]);
7551 case DW_CFA_register:
7552 sprintf (tmp, "r%d", fc->col_offset[r]);
7555 strcpy (tmp, "n/a");
7558 printf ("%-5s", tmp);
7565 size_of_encoded_value (encoding)
7568 switch (encoding & 0x7)
7571 case 0: return is_32bit_elf ? 4 : 8;
7578 #define GET(N) byte_get (start, N); start += N
7579 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
7580 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
7583 display_debug_frames (section, start, file)
7584 Elf32_Internal_Shdr * section;
7585 unsigned char * start;
7586 FILE * file ATTRIBUTE_UNUSED;
7588 unsigned char * end = start + section->sh_size;
7589 unsigned char * section_start = start;
7590 Frame_Chunk * chunks = 0;
7591 Frame_Chunk * remembered_state = 0;
7593 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
7596 int addr_size = is_32bit_elf ? 4 : 8;
7598 printf (_("The section %s contains:\n"), SECTION_NAME (section));
7602 unsigned char * saved_start;
7603 unsigned char * block_end;
7604 unsigned long length;
7605 unsigned long cie_id;
7608 int need_col_headers = 1;
7609 unsigned char * augmentation_data = NULL;
7610 unsigned long augmentation_data_len = 0;
7611 int encoded_ptr_size = addr_size;
7613 saved_start = start;
7614 length = byte_get (start, 4); start += 4;
7619 if (length == 0xffffffff)
7621 warn (_("64-bit DWARF format frames are not supported yet.\n"));
7625 block_end = saved_start + length + 4;
7626 cie_id = byte_get (start, 4); start += 4;
7628 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
7632 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7633 memset (fc, 0, sizeof (Frame_Chunk));
7637 fc->chunk_start = saved_start;
7639 fc->col_type = (short int *) xmalloc (sizeof (short int));
7640 fc->col_offset = (int *) xmalloc (sizeof (int));
7641 frame_need_space (fc, max_regs-1);
7645 fc->augmentation = start;
7646 start = strchr (start, '\0') + 1;
7648 if (fc->augmentation[0] == 'z')
7650 fc->code_factor = LEB ();
7651 fc->data_factor = SLEB ();
7652 fc->ra = byte_get (start, 1); start += 1;
7653 augmentation_data_len = LEB ();
7654 augmentation_data = start;
7655 start += augmentation_data_len;
7657 else if (strcmp (fc->augmentation, "eh") == 0)
7660 fc->code_factor = LEB ();
7661 fc->data_factor = SLEB ();
7662 fc->ra = byte_get (start, 1); start += 1;
7666 fc->code_factor = LEB ();
7667 fc->data_factor = SLEB ();
7668 fc->ra = byte_get (start, 1); start += 1;
7672 if (do_debug_frames_interp)
7673 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
7674 (unsigned long)(saved_start - section_start), length, cie_id,
7675 fc->augmentation, fc->code_factor, fc->data_factor,
7679 printf ("\n%08lx %08lx %08lx CIE\n",
7680 (unsigned long)(saved_start - section_start), length, cie_id);
7681 printf (" Version: %d\n", version);
7682 printf (" Augmentation: \"%s\"\n", fc->augmentation);
7683 printf (" Code alignment factor: %u\n", fc->code_factor);
7684 printf (" Data alignment factor: %d\n", fc->data_factor);
7685 printf (" Return address column: %d\n", fc->ra);
7687 if (augmentation_data_len)
7690 printf (" Augmentation data: ");
7691 for (i = 0; i < augmentation_data_len; ++i)
7692 printf (" %02x", augmentation_data[i]);
7698 if (augmentation_data_len)
7700 unsigned char *p, *q;
7701 p = fc->augmentation + 1;
7702 q = augmentation_data;
7709 q += 1 + size_of_encoded_value (*q);
7711 fc->fde_encoding = *q++;
7717 if (fc->fde_encoding)
7718 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7721 frame_need_space (fc, fc->ra);
7725 unsigned char * look_for;
7726 static Frame_Chunk fde_fc;
7729 memset (fc, 0, sizeof (Frame_Chunk));
7731 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
7733 for (cie = chunks; cie ; cie = cie->next)
7734 if (cie->chunk_start == look_for)
7739 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
7740 cie_id, saved_start);
7743 fc->col_type = (short int *) xmalloc (sizeof (short int));
7744 fc->col_offset = (int *) xmalloc (sizeof (int));
7745 frame_need_space (fc, max_regs - 1);
7747 fc->augmentation = "";
7748 fc->fde_encoding = 0;
7752 fc->ncols = cie->ncols;
7753 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
7754 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
7755 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7756 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7757 fc->augmentation = cie->augmentation;
7758 fc->code_factor = cie->code_factor;
7759 fc->data_factor = cie->data_factor;
7760 fc->cfa_reg = cie->cfa_reg;
7761 fc->cfa_offset = cie->cfa_offset;
7763 frame_need_space (fc, max_regs-1);
7764 fc->fde_encoding = cie->fde_encoding;
7767 if (fc->fde_encoding)
7768 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7770 fc->pc_begin = byte_get (start, encoded_ptr_size);
7771 start += encoded_ptr_size;
7772 fc->pc_range = byte_get (start, encoded_ptr_size);
7773 start += encoded_ptr_size;
7775 if (cie->augmentation[0] == 'z')
7777 augmentation_data_len = LEB ();
7778 augmentation_data = start;
7779 start += augmentation_data_len;
7782 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
7783 (unsigned long)(saved_start - section_start), length, cie_id,
7784 (unsigned long)(cie->chunk_start - section_start),
7785 fc->pc_begin, fc->pc_begin + fc->pc_range);
7786 if (! do_debug_frames_interp && augmentation_data_len)
7789 printf (" Augmentation data: ");
7790 for (i = 0; i < augmentation_data_len; ++i)
7791 printf (" %02x", augmentation_data[i]);
7797 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7798 about to interpret instructions for the chunk. */
7800 if (do_debug_frames_interp)
7802 /* Start by making a pass over the chunk, allocating storage
7803 and taking note of what registers are used. */
7804 unsigned char * tmp = start;
7806 while (start < block_end)
7816 /* Warning: if you add any more cases to this switch, be
7817 sure to add them to the corresponding switch below. */
7820 case DW_CFA_advance_loc:
7824 frame_need_space (fc, opa);
7825 fc->col_type[opa] = DW_CFA_undefined;
7827 case DW_CFA_restore:
7828 frame_need_space (fc, opa);
7829 fc->col_type[opa] = DW_CFA_undefined;
7831 case DW_CFA_set_loc:
7832 start += encoded_ptr_size;
7834 case DW_CFA_advance_loc1:
7837 case DW_CFA_advance_loc2:
7840 case DW_CFA_advance_loc4:
7843 case DW_CFA_offset_extended:
7844 reg = LEB (); LEB ();
7845 frame_need_space (fc, reg);
7846 fc->col_type[reg] = DW_CFA_undefined;
7848 case DW_CFA_restore_extended:
7850 frame_need_space (fc, reg);
7851 fc->col_type[reg] = DW_CFA_undefined;
7853 case DW_CFA_undefined:
7855 frame_need_space (fc, reg);
7856 fc->col_type[reg] = DW_CFA_undefined;
7858 case DW_CFA_same_value:
7860 frame_need_space (fc, reg);
7861 fc->col_type[reg] = DW_CFA_undefined;
7863 case DW_CFA_register:
7864 reg = LEB (); LEB ();
7865 frame_need_space (fc, reg);
7866 fc->col_type[reg] = DW_CFA_undefined;
7868 case DW_CFA_def_cfa:
7871 case DW_CFA_def_cfa_register:
7874 case DW_CFA_def_cfa_offset:
7877 #ifndef DW_CFA_GNU_args_size
7878 #define DW_CFA_GNU_args_size 0x2e
7880 case DW_CFA_GNU_args_size:
7883 #ifndef DW_CFA_GNU_negative_offset_extended
7884 #define DW_CFA_GNU_negative_offset_extended 0x2f
7886 case DW_CFA_GNU_negative_offset_extended:
7887 reg = LEB (); LEB ();
7888 frame_need_space (fc, reg);
7889 fc->col_type[reg] = DW_CFA_undefined;
7898 /* Now we know what registers are used, make a second pass over
7899 the chunk, this time actually printing out the info. */
7901 while (start < block_end)
7904 unsigned long ul, reg, roffs;
7913 /* Warning: if you add any more cases to this switch, be
7914 sure to add them to the corresponding switch above. */
7917 case DW_CFA_advance_loc:
7918 if (do_debug_frames_interp)
7919 frame_display_row (fc, &need_col_headers, &max_regs);
7921 printf (" DW_CFA_advance_loc: %d to %08lx\n",
7922 opa * fc->code_factor,
7923 fc->pc_begin + opa * fc->code_factor);
7924 fc->pc_begin += opa * fc->code_factor;
7929 if (! do_debug_frames_interp)
7930 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
7931 opa, roffs * fc->data_factor);
7932 fc->col_type[opa] = DW_CFA_offset;
7933 fc->col_offset[opa] = roffs * fc->data_factor;
7936 case DW_CFA_restore:
7937 if (! do_debug_frames_interp)
7938 printf (" DW_CFA_restore: r%d\n", opa);
7939 fc->col_type[opa] = cie->col_type[opa];
7940 fc->col_offset[opa] = cie->col_offset[opa];
7943 case DW_CFA_set_loc:
7944 vma = byte_get (start, encoded_ptr_size);
7945 start += encoded_ptr_size;
7946 if (do_debug_frames_interp)
7947 frame_display_row (fc, &need_col_headers, &max_regs);
7949 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
7953 case DW_CFA_advance_loc1:
7954 ofs = byte_get (start, 1); start += 1;
7955 if (do_debug_frames_interp)
7956 frame_display_row (fc, &need_col_headers, &max_regs);
7958 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
7959 ofs * fc->code_factor,
7960 fc->pc_begin + ofs * fc->code_factor);
7961 fc->pc_begin += ofs * fc->code_factor;
7964 case DW_CFA_advance_loc2:
7965 ofs = byte_get (start, 2); start += 2;
7966 if (do_debug_frames_interp)
7967 frame_display_row (fc, &need_col_headers, &max_regs);
7969 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
7970 ofs * fc->code_factor,
7971 fc->pc_begin + ofs * fc->code_factor);
7972 fc->pc_begin += ofs * fc->code_factor;
7975 case DW_CFA_advance_loc4:
7976 ofs = byte_get (start, 4); start += 4;
7977 if (do_debug_frames_interp)
7978 frame_display_row (fc, &need_col_headers, &max_regs);
7980 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
7981 ofs * fc->code_factor,
7982 fc->pc_begin + ofs * fc->code_factor);
7983 fc->pc_begin += ofs * fc->code_factor;
7986 case DW_CFA_offset_extended:
7989 if (! do_debug_frames_interp)
7990 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
7991 reg, roffs * fc->data_factor);
7992 fc->col_type[reg] = DW_CFA_offset;
7993 fc->col_offset[reg] = roffs * fc->data_factor;
7996 case DW_CFA_restore_extended:
7998 if (! do_debug_frames_interp)
7999 printf (" DW_CFA_restore_extended: r%ld\n", reg);
8000 fc->col_type[reg] = cie->col_type[reg];
8001 fc->col_offset[reg] = cie->col_offset[reg];
8004 case DW_CFA_undefined:
8006 if (! do_debug_frames_interp)
8007 printf (" DW_CFA_undefined: r%ld\n", reg);
8008 fc->col_type[reg] = DW_CFA_undefined;
8009 fc->col_offset[reg] = 0;
8012 case DW_CFA_same_value:
8014 if (! do_debug_frames_interp)
8015 printf (" DW_CFA_same_value: r%ld\n", reg);
8016 fc->col_type[reg] = DW_CFA_same_value;
8017 fc->col_offset[reg] = 0;
8020 case DW_CFA_register:
8023 if (! do_debug_frames_interp)
8024 printf (" DW_CFA_register: r%ld\n", reg);
8025 fc->col_type[reg] = DW_CFA_register;
8026 fc->col_offset[reg] = roffs;
8029 case DW_CFA_remember_state:
8030 if (! do_debug_frames_interp)
8031 printf (" DW_CFA_remember_state\n");
8032 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8033 rs->ncols = fc->ncols;
8034 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8035 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8036 memcpy (rs->col_type, fc->col_type, rs->ncols);
8037 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8038 rs->next = remembered_state;
8039 remembered_state = rs;
8042 case DW_CFA_restore_state:
8043 if (! do_debug_frames_interp)
8044 printf (" DW_CFA_restore_state\n");
8045 rs = remembered_state;
8046 remembered_state = rs->next;
8047 frame_need_space (fc, rs->ncols-1);
8048 memcpy (fc->col_type, rs->col_type, rs->ncols);
8049 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8050 free (rs->col_type);
8051 free (rs->col_offset);
8055 case DW_CFA_def_cfa:
8056 fc->cfa_reg = LEB ();
8057 fc->cfa_offset = LEB ();
8058 if (! do_debug_frames_interp)
8059 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8060 fc->cfa_reg, fc->cfa_offset);
8063 case DW_CFA_def_cfa_register:
8064 fc->cfa_reg = LEB ();
8065 if (! do_debug_frames_interp)
8066 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
8069 case DW_CFA_def_cfa_offset:
8070 fc->cfa_offset = LEB ();
8071 if (! do_debug_frames_interp)
8072 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
8076 if (! do_debug_frames_interp)
8077 printf (" DW_CFA_nop\n");
8080 #ifndef DW_CFA_GNU_window_save
8081 #define DW_CFA_GNU_window_save 0x2d
8083 case DW_CFA_GNU_window_save:
8084 if (! do_debug_frames_interp)
8085 printf (" DW_CFA_GNU_window_save\n");
8088 case DW_CFA_GNU_args_size:
8090 if (! do_debug_frames_interp)
8091 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
8094 case DW_CFA_GNU_negative_offset_extended:
8097 frame_need_space (fc, reg);
8098 if (! do_debug_frames_interp)
8099 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8100 reg, l * fc->data_factor);
8101 fc->col_type[reg] = DW_CFA_offset;
8102 fc->col_offset[reg] = l * fc->data_factor;
8106 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
8111 if (do_debug_frames_interp)
8112 frame_display_row (fc, &need_col_headers, &max_regs);
8127 display_debug_not_supported (section, start, file)
8128 Elf32_Internal_Shdr * section;
8129 unsigned char * start ATTRIBUTE_UNUSED;
8130 FILE * file ATTRIBUTE_UNUSED;
8132 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8133 SECTION_NAME (section));
8138 /* Pre-scan the .debug_info section to record the size of address.
8139 When dumping the .debug_line, we use that size information, assuming
8140 that all compilation units have the same address size. */
8142 prescan_debug_info (section, start, file)
8143 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
8144 unsigned char * start;
8145 FILE * file ATTRIBUTE_UNUSED;
8147 DWARF2_External_CompUnit * external;
8149 external = (DWARF2_External_CompUnit *) start;
8151 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
8155 /* A structure containing the name of a debug section and a pointer
8156 to a function that can decode it. The third field is a prescan
8157 function to be run over the section before displaying any of the
8162 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8163 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8167 { ".debug_info", display_debug_info, prescan_debug_info },
8168 { ".debug_abbrev", display_debug_abbrev, NULL },
8169 { ".debug_line", display_debug_lines, NULL },
8170 { ".debug_aranges", display_debug_aranges, NULL },
8171 { ".debug_pubnames", display_debug_pubnames, NULL },
8172 { ".debug_frame", display_debug_frames, NULL },
8173 { ".eh_frame", display_debug_frames, NULL },
8174 { ".debug_macinfo", display_debug_macinfo, NULL },
8175 { ".debug_pubtypes", display_debug_not_supported, NULL },
8176 { ".debug_str", display_debug_not_supported, NULL },
8177 { ".debug_static_func", display_debug_not_supported, NULL },
8178 { ".debug_static_vars", display_debug_not_supported, NULL },
8179 { ".debug_types", display_debug_not_supported, NULL },
8180 { ".debug_weaknames", display_debug_not_supported, NULL }
8184 display_debug_section (section, file)
8185 Elf32_Internal_Shdr * section;
8188 char * name = SECTION_NAME (section);
8189 bfd_size_type length;
8190 unsigned char * start;
8193 length = section->sh_size;
8196 printf (_("\nSection '%s' has no debugging data.\n"), name);
8200 start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
8201 _("debug section data"));
8205 /* See if we know how to display the contents of this section. */
8206 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
8207 name = ".debug_info";
8209 for (i = NUM_ELEM (debug_displays); i--;)
8210 if (strcmp (debug_displays[i].name, name) == 0)
8212 debug_displays[i].display (section, start, file);
8217 printf (_("Unrecognised debug section: %s\n"), name);
8221 /* If we loaded in the abbrev section at some point,
8222 we must release it here. */
8223 if (first_abbrev != NULL)
8230 process_section_contents (file)
8233 Elf32_Internal_Shdr * section;
8239 /* Pre-scan the debug sections to find some debug information not
8240 present in some of them. For the .debug_line, we must find out the
8241 size of address (specified in .debug_info and .debug_aranges). */
8242 for (i = 0, section = section_headers;
8243 i < elf_header.e_shnum && i < num_dump_sects;
8246 char * name = SECTION_NAME (section);
8249 if (section->sh_size == 0)
8252 /* See if there is some pre-scan operation for this section. */
8253 for (j = NUM_ELEM (debug_displays); j--;)
8254 if (strcmp (debug_displays[j].name, name) == 0)
8256 if (debug_displays[j].prescan != NULL)
8258 bfd_size_type length;
8259 unsigned char * start;
8261 length = section->sh_size;
8262 start = ((unsigned char *)
8263 get_data (NULL, file, section->sh_offset, length,
8264 _("debug section data")));
8268 debug_displays[j].prescan (section, start, file);
8276 for (i = 0, section = section_headers;
8277 i < elf_header.e_shnum && i < num_dump_sects;
8280 #ifdef SUPPORT_DISASSEMBLY
8281 if (dump_sects[i] & DISASS_DUMP)
8282 disassemble_section (section, file);
8284 if (dump_sects[i] & HEX_DUMP)
8285 dump_section (section, file);
8287 if (dump_sects[i] & DEBUG_DUMP)
8288 display_debug_section (section, file);
8291 if (i < num_dump_sects)
8292 warn (_("Some sections were not dumped because they do not exist!\n"));
8298 process_mips_fpe_exception (mask)
8304 if (mask & OEX_FPU_INEX)
8305 fputs ("INEX", stdout), first = 0;
8306 if (mask & OEX_FPU_UFLO)
8307 printf ("%sUFLO", first ? "" : "|"), first = 0;
8308 if (mask & OEX_FPU_OFLO)
8309 printf ("%sOFLO", first ? "" : "|"), first = 0;
8310 if (mask & OEX_FPU_DIV0)
8311 printf ("%sDIV0", first ? "" : "|"), first = 0;
8312 if (mask & OEX_FPU_INVAL)
8313 printf ("%sINVAL", first ? "" : "|");
8316 fputs ("0", stdout);
8320 process_mips_specific (file)
8323 Elf_Internal_Dyn * entry;
8324 size_t liblist_offset = 0;
8325 size_t liblistno = 0;
8326 size_t conflictsno = 0;
8327 size_t options_offset = 0;
8328 size_t conflicts_offset = 0;
8330 /* We have a lot of special sections. Thanks SGI! */
8331 if (dynamic_segment == NULL)
8332 /* No information available. */
8335 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
8336 switch (entry->d_tag)
8338 case DT_MIPS_LIBLIST:
8339 liblist_offset = entry->d_un.d_val - loadaddr;
8341 case DT_MIPS_LIBLISTNO:
8342 liblistno = entry->d_un.d_val;
8344 case DT_MIPS_OPTIONS:
8345 options_offset = entry->d_un.d_val - loadaddr;
8347 case DT_MIPS_CONFLICT:
8348 conflicts_offset = entry->d_un.d_val - loadaddr;
8350 case DT_MIPS_CONFLICTNO:
8351 conflictsno = entry->d_un.d_val;
8357 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8359 Elf32_External_Lib * elib;
8362 elib = ((Elf32_External_Lib *)
8363 get_data (NULL, file, liblist_offset,
8364 liblistno * sizeof (Elf32_External_Lib),
8368 printf ("\nSection '.liblist' contains %lu entries:\n",
8369 (unsigned long) liblistno);
8370 fputs (" Library Time Stamp Checksum Version Flags\n",
8373 for (cnt = 0; cnt < liblistno; ++cnt)
8380 liblist.l_name = BYTE_GET (elib[cnt].l_name);
8381 time = BYTE_GET (elib[cnt].l_time_stamp);
8382 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8383 liblist.l_version = BYTE_GET (elib[cnt].l_version);
8384 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8386 tmp = gmtime (&time);
8387 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
8388 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8389 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8391 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
8392 dynamic_strings + liblist.l_name, timebuf,
8393 liblist.l_checksum, liblist.l_version);
8395 if (liblist.l_flags == 0)
8406 { " EXACT_MATCH", LL_EXACT_MATCH },
8407 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8408 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8409 { " EXPORTS", LL_EXPORTS },
8410 { " DELAY_LOAD", LL_DELAY_LOAD },
8411 { " DELTA", LL_DELTA }
8413 int flags = liblist.l_flags;
8417 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
8419 if ((flags & l_flags_vals[fcnt].bit) != 0)
8421 fputs (l_flags_vals[fcnt].name, stdout);
8422 flags ^= l_flags_vals[fcnt].bit;
8425 printf (" %#x", (unsigned int) flags);
8435 if (options_offset != 0)
8437 Elf_External_Options * eopt;
8438 Elf_Internal_Shdr * sect = section_headers;
8439 Elf_Internal_Options * iopt;
8440 Elf_Internal_Options * option;
8444 /* Find the section header so that we get the size. */
8445 while (sect->sh_type != SHT_MIPS_OPTIONS)
8448 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
8449 sect->sh_size, _("options"));
8452 iopt = ((Elf_Internal_Options *)
8453 malloc ((sect->sh_size / sizeof (eopt)) * sizeof (* iopt)));
8456 error (_("Out of memory"));
8463 while (offset < sect->sh_size)
8465 Elf_External_Options * eoption;
8467 eoption = (Elf_External_Options *) ((char *) eopt + offset);
8469 option->kind = BYTE_GET (eoption->kind);
8470 option->size = BYTE_GET (eoption->size);
8471 option->section = BYTE_GET (eoption->section);
8472 option->info = BYTE_GET (eoption->info);
8474 offset += option->size;
8480 printf (_("\nSection '%s' contains %d entries:\n"),
8481 SECTION_NAME (sect), cnt);
8489 switch (option->kind)
8492 /* This shouldn't happen. */
8493 printf (" NULL %d %lx", option->section, option->info);
8496 printf (" REGINFO ");
8497 if (elf_header.e_machine == EM_MIPS)
8500 Elf32_External_RegInfo * ereg;
8501 Elf32_RegInfo reginfo;
8503 ereg = (Elf32_External_RegInfo *) (option + 1);
8504 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8505 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8506 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8507 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8508 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8509 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
8511 printf ("GPR %08lx GP 0x%lx\n",
8513 (unsigned long) reginfo.ri_gp_value);
8514 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8515 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8516 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8521 Elf64_External_RegInfo * ereg;
8522 Elf64_Internal_RegInfo reginfo;
8524 ereg = (Elf64_External_RegInfo *) (option + 1);
8525 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8526 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8527 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8528 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8529 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8530 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
8532 printf ("GPR %08lx GP 0x",
8533 reginfo.ri_gprmask);
8534 printf_vma (reginfo.ri_gp_value);
8537 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8538 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8539 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8543 case ODK_EXCEPTIONS:
8544 fputs (" EXCEPTIONS fpe_min(", stdout);
8545 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
8546 fputs (") fpe_max(", stdout);
8547 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
8548 fputs (")", stdout);
8550 if (option->info & OEX_PAGE0)
8551 fputs (" PAGE0", stdout);
8552 if (option->info & OEX_SMM)
8553 fputs (" SMM", stdout);
8554 if (option->info & OEX_FPDBUG)
8555 fputs (" FPDBUG", stdout);
8556 if (option->info & OEX_DISMISS)
8557 fputs (" DISMISS", stdout);
8560 fputs (" PAD ", stdout);
8561 if (option->info & OPAD_PREFIX)
8562 fputs (" PREFIX", stdout);
8563 if (option->info & OPAD_POSTFIX)
8564 fputs (" POSTFIX", stdout);
8565 if (option->info & OPAD_SYMBOL)
8566 fputs (" SYMBOL", stdout);
8569 fputs (" HWPATCH ", stdout);
8570 if (option->info & OHW_R4KEOP)
8571 fputs (" R4KEOP", stdout);
8572 if (option->info & OHW_R8KPFETCH)
8573 fputs (" R8KPFETCH", stdout);
8574 if (option->info & OHW_R5KEOP)
8575 fputs (" R5KEOP", stdout);
8576 if (option->info & OHW_R5KCVTL)
8577 fputs (" R5KCVTL", stdout);
8580 fputs (" FILL ", stdout);
8581 /* XXX Print content of info word? */
8584 fputs (" TAGS ", stdout);
8585 /* XXX Print content of info word? */
8588 fputs (" HWAND ", stdout);
8589 if (option->info & OHWA0_R4KEOP_CHECKED)
8590 fputs (" R4KEOP_CHECKED", stdout);
8591 if (option->info & OHWA0_R4KEOP_CLEAN)
8592 fputs (" R4KEOP_CLEAN", stdout);
8595 fputs (" HWOR ", stdout);
8596 if (option->info & OHWA0_R4KEOP_CHECKED)
8597 fputs (" R4KEOP_CHECKED", stdout);
8598 if (option->info & OHWA0_R4KEOP_CLEAN)
8599 fputs (" R4KEOP_CLEAN", stdout);
8602 printf (" GP_GROUP %#06lx self-contained %#06lx",
8603 option->info & OGP_GROUP,
8604 (option->info & OGP_SELF) >> 16);
8607 printf (" IDENT %#06lx self-contained %#06lx",
8608 option->info & OGP_GROUP,
8609 (option->info & OGP_SELF) >> 16);
8612 /* This shouldn't happen. */
8613 printf (" %3d ??? %d %lx",
8614 option->kind, option->section, option->info);
8618 len = sizeof (* eopt);
8619 while (len < option->size)
8620 if (((char *) option)[len] >= ' '
8621 && ((char *) option)[len] < 0x7f)
8622 printf ("%c", ((char *) option)[len++]);
8624 printf ("\\%03o", ((char *) option)[len++]);
8626 fputs ("\n", stdout);
8634 if (conflicts_offset != 0 && conflictsno != 0)
8636 Elf32_Conflict * iconf;
8639 if (dynamic_symbols == NULL)
8641 error (_("conflict list with without table"));
8645 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
8648 error (_("Out of memory"));
8654 Elf32_External_Conflict * econf32;
8656 econf32 = ((Elf32_External_Conflict *)
8657 get_data (NULL, file, conflicts_offset,
8658 conflictsno * sizeof (* econf32),
8663 for (cnt = 0; cnt < conflictsno; ++cnt)
8664 iconf[cnt] = BYTE_GET (econf32[cnt]);
8670 Elf64_External_Conflict * econf64;
8672 econf64 = ((Elf64_External_Conflict *)
8673 get_data (NULL, file, conflicts_offset,
8674 conflictsno * sizeof (* econf64),
8679 for (cnt = 0; cnt < conflictsno; ++cnt)
8680 iconf[cnt] = BYTE_GET (econf64[cnt]);
8685 printf (_("\nSection '.conflict' contains %ld entries:\n"),
8686 (long) conflictsno);
8687 puts (_(" Num: Index Value Name"));
8689 for (cnt = 0; cnt < conflictsno; ++cnt)
8691 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
8693 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
8694 print_vma (psym->st_value, FULL_HEX);
8695 printf (" %s\n", dynamic_strings + psym->st_name);
8705 get_note_type (e_type)
8708 static char buff[64];
8712 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
8713 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
8714 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
8715 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
8716 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
8717 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
8718 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
8719 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
8720 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8721 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8722 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8724 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
8729 /* Note that by the ELF standard, the name field is already null byte
8730 terminated, and namesz includes the terminating null byte.
8731 I.E. the value of namesz for the name "FSF" is 4.
8733 If the value of namesz is zero, there is no name present. */
8735 process_note (pnote)
8736 Elf32_Internal_Note * pnote;
8738 printf (" %s\t\t0x%08lx\t%s\n",
8739 pnote->namesz ? pnote->namedata : "(NONE)",
8740 pnote->descsz, get_note_type (pnote->type));
8746 process_corefile_note_segment (file, offset, length)
8751 Elf_External_Note * pnotes;
8752 Elf_External_Note * external;
8758 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
8765 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8766 (unsigned long) offset, (unsigned long) length);
8767 printf (_(" Owner\t\tData size\tDescription\n"));
8769 while (external < (Elf_External_Note *)((char *) pnotes + length))
8771 Elf32_Internal_Note inote;
8774 inote.type = BYTE_GET (external->type);
8775 inote.namesz = BYTE_GET (external->namesz);
8776 inote.namedata = external->name;
8777 inote.descsz = BYTE_GET (external->descsz);
8778 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8779 inote.descpos = offset + (inote.descdata - (char *) pnotes);
8781 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8783 /* Verify that name is null terminated. It appears that at least
8784 one version of Linux (RedHat 6.0) generates corefiles that don't
8785 comply with the ELF spec by failing to include the null byte in
8787 if (inote.namedata[inote.namesz] != '\0')
8789 temp = malloc (inote.namesz + 1);
8793 error (_("Out of memory\n"));
8798 strncpy (temp, inote.namedata, inote.namesz);
8799 temp[inote.namesz] = 0;
8801 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8802 inote.namedata = temp;
8805 res &= process_note (& inote);
8820 process_corefile_note_segments (file)
8823 Elf_Internal_Phdr * program_headers;
8824 Elf_Internal_Phdr * segment;
8828 program_headers = (Elf_Internal_Phdr *) malloc
8829 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
8831 if (program_headers == NULL)
8833 error (_("Out of memory\n"));
8838 i = get_32bit_program_headers (file, program_headers);
8840 i = get_64bit_program_headers (file, program_headers);
8844 free (program_headers);
8848 for (i = 0, segment = program_headers;
8849 i < elf_header.e_phnum;
8852 if (segment->p_type == PT_NOTE)
8853 res &= process_corefile_note_segment (file,
8854 (bfd_vma) segment->p_offset,
8855 (bfd_vma) segment->p_filesz);
8858 free (program_headers);
8864 process_corefile_contents (file)
8867 /* If we have not been asked to display the notes then do nothing. */
8871 /* If file is not a core file then exit. */
8872 if (elf_header.e_type != ET_CORE)
8875 /* No program headers means no NOTE segment. */
8876 if (elf_header.e_phnum == 0)
8878 printf (_("No note segments present in the core file.\n"));
8882 return process_corefile_note_segments (file);
8886 process_arch_specific (file)
8892 switch (elf_header.e_machine)
8895 case EM_MIPS_RS3_LE:
8896 return process_mips_specific (file);
8905 get_file_header (file)
8908 /* Read in the identity array. */
8909 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8912 /* Determine how to read the rest of the header. */
8913 switch (elf_header.e_ident [EI_DATA])
8915 default: /* fall through */
8916 case ELFDATANONE: /* fall through */
8917 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
8918 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
8921 /* For now we only support 32 bit and 64 bit ELF files. */
8922 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
8924 /* Read in the rest of the header. */
8927 Elf32_External_Ehdr ehdr32;
8929 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8932 elf_header.e_type = BYTE_GET (ehdr32.e_type);
8933 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
8934 elf_header.e_version = BYTE_GET (ehdr32.e_version);
8935 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
8936 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
8937 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
8938 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
8939 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
8940 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8941 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
8942 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8943 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
8944 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
8948 Elf64_External_Ehdr ehdr64;
8950 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8951 we will not be able to cope with the 64bit data found in
8952 64 ELF files. Detect this now and abort before we start
8953 overwritting things. */
8954 if (sizeof (bfd_vma) < 8)
8956 error (_("This instance of readelf has been built without support for a\n"));
8957 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
8961 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
8964 elf_header.e_type = BYTE_GET (ehdr64.e_type);
8965 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
8966 elf_header.e_version = BYTE_GET (ehdr64.e_version);
8967 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
8968 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
8969 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
8970 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
8971 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
8972 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
8973 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
8974 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
8975 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
8976 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
8983 process_file (file_name)
8987 struct stat statbuf;
8990 if (stat (file_name, & statbuf) < 0)
8992 error (_("Cannot stat input file %s.\n"), file_name);
8996 file = fopen (file_name, "rb");
8999 error (_("Input file %s not found.\n"), file_name);
9003 if (! get_file_header (file))
9005 error (_("%s: Failed to read file header\n"), file_name);
9010 /* Initialise per file variables. */
9011 for (i = NUM_ELEM (version_info); i--;)
9012 version_info[i] = 0;
9014 for (i = NUM_ELEM (dynamic_info); i--;)
9015 dynamic_info[i] = 0;
9017 /* Process the file. */
9019 printf (_("\nFile: %s\n"), file_name);
9021 if (! process_file_header ())
9027 process_section_headers (file);
9029 process_program_headers (file);
9031 process_dynamic_segment (file);
9033 process_relocs (file);
9035 process_unwind (file);
9037 process_symbol_table (file);
9039 process_syminfo (file);
9041 process_version_sections (file);
9043 process_section_contents (file);
9045 process_corefile_contents (file);
9047 process_arch_specific (file);
9051 if (section_headers)
9053 free (section_headers);
9054 section_headers = NULL;
9059 free (string_table);
9060 string_table = NULL;
9061 string_table_length = 0;
9064 if (dynamic_strings)
9066 free (dynamic_strings);
9067 dynamic_strings = NULL;
9070 if (dynamic_symbols)
9072 free (dynamic_symbols);
9073 dynamic_symbols = NULL;
9074 num_dynamic_syms = 0;
9077 if (dynamic_syminfo)
9079 free (dynamic_syminfo);
9080 dynamic_syminfo = NULL;
9086 #ifdef SUPPORT_DISASSEMBLY
9087 /* Needed by the i386 disassembler. For extra credit, someone could
9088 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9092 print_address (unsigned int addr, FILE * outfile)
9094 fprintf (outfile,"0x%8.8x", addr);
9097 /* Needed by the i386 disassembler. */
9099 db_task_printsym (unsigned int addr)
9101 print_address (addr, stderr);
9105 int main PARAMS ((int, char **));
9114 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9115 setlocale (LC_MESSAGES, "");
9117 #if defined (HAVE_SETLOCALE)
9118 setlocale (LC_CTYPE, "");
9120 bindtextdomain (PACKAGE, LOCALEDIR);
9121 textdomain (PACKAGE);
9123 parse_args (argc, argv);
9125 if (optind < (argc - 1))
9129 while (optind < argc)
9130 err |= process_file (argv [optind ++]);
9132 if (dump_sects != NULL)