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"
78 #include "elf/x86-64.h"
84 char * program_name = "readelf";
85 unsigned int dynamic_addr;
86 bfd_size_type dynamic_size;
87 unsigned int rela_addr;
88 unsigned int rela_size;
89 char * dynamic_strings;
91 unsigned long string_table_length;
92 unsigned long num_dynamic_syms;
93 Elf_Internal_Sym * dynamic_symbols;
94 Elf_Internal_Syminfo * dynamic_syminfo;
95 unsigned long dynamic_syminfo_offset;
96 unsigned int dynamic_syminfo_nent;
97 char program_interpreter [64];
98 int dynamic_info[DT_JMPREL + 1];
101 Elf_Internal_Ehdr elf_header;
102 Elf_Internal_Shdr * section_headers;
103 Elf_Internal_Dyn * dynamic_segment;
111 int do_using_dynamic;
119 int do_debug_abbrevs;
121 int do_debug_pubnames;
122 int do_debug_aranges;
124 int do_debug_frames_interp;
125 int do_debug_macinfo;
130 /* A dynamic array of flags indicating which sections require dumping. */
131 char * dump_sects = NULL;
132 unsigned int num_dump_sects = 0;
134 #define HEX_DUMP (1 << 0)
135 #define DISASS_DUMP (1 << 1)
136 #define DEBUG_DUMP (1 << 2)
138 /* How to rpint a vma value. */
139 typedef enum print_mode
151 /* Forward declarations for dumb compilers. */
152 static void print_vma PARAMS ((bfd_vma, print_mode));
153 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
154 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
155 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
156 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
157 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
158 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
159 static const char * get_dynamic_type PARAMS ((unsigned long));
160 static int slurp_rela_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **, unsigned long *));
161 static int slurp_rel_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel **, unsigned long *));
162 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
163 static char * get_file_type PARAMS ((unsigned));
164 static char * get_machine_name PARAMS ((unsigned));
165 static void decode_ARM_machine_flags PARAMS ((unsigned, char []));
166 static char * get_machine_flags PARAMS ((unsigned, unsigned));
167 static const char * get_mips_segment_type PARAMS ((unsigned long));
168 static const char * get_parisc_segment_type PARAMS ((unsigned long));
169 static const char * get_ia64_segment_type PARAMS ((unsigned long));
170 static const char * get_segment_type PARAMS ((unsigned long));
171 static const char * get_mips_section_type_name PARAMS ((unsigned int));
172 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
173 static const char * get_ia64_section_type_name PARAMS ((unsigned int));
174 static const char * get_section_type_name PARAMS ((unsigned int));
175 static const char * get_symbol_binding PARAMS ((unsigned int));
176 static const char * get_symbol_type PARAMS ((unsigned int));
177 static const char * get_symbol_visibility PARAMS ((unsigned int));
178 static const char * get_symbol_index_type PARAMS ((unsigned int));
179 static const char * get_dynamic_flags PARAMS ((bfd_vma));
180 static void usage PARAMS ((void));
181 static void parse_args PARAMS ((int, char **));
182 static int process_file_header PARAMS ((void));
183 static int process_program_headers PARAMS ((FILE *));
184 static int process_section_headers PARAMS ((FILE *));
185 static int process_unwind PARAMS ((FILE *));
186 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
187 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
188 static int process_dynamic_segment PARAMS ((FILE *));
189 static int process_symbol_table PARAMS ((FILE *));
190 static int process_syminfo PARAMS ((FILE *));
191 static int process_section_contents PARAMS ((FILE *));
192 static void process_mips_fpe_exception PARAMS ((int));
193 static int process_mips_specific PARAMS ((FILE *));
194 static int process_file PARAMS ((char *));
195 static int process_relocs PARAMS ((FILE *));
196 static int process_version_sections PARAMS ((FILE *));
197 static char * get_ver_flags PARAMS ((unsigned int));
198 static int get_32bit_section_headers PARAMS ((FILE *));
199 static int get_64bit_section_headers PARAMS ((FILE *));
200 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
201 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
202 static int get_file_header PARAMS ((FILE *));
203 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
204 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
205 static const char * get_elf_section_flags PARAMS ((bfd_vma));
206 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
207 static int get_32bit_dynamic_segment PARAMS ((FILE *));
208 static int get_64bit_dynamic_segment PARAMS ((FILE *));
209 #ifdef SUPPORT_DISASSEMBLY
210 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
212 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
213 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
214 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
215 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
216 static int prescan_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
217 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
218 static int display_debug_pubnames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
219 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
220 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
221 static int display_debug_frames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
222 static int display_debug_macinfo PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
223 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
224 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
225 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
226 static void reset_state_machine PARAMS ((int));
227 static char * get_TAG_name PARAMS ((unsigned long));
228 static char * get_AT_name PARAMS ((unsigned long));
229 static char * get_FORM_name PARAMS ((unsigned long));
230 static void free_abbrevs PARAMS ((void));
231 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
232 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
233 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
234 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
235 static void decode_location_expression PARAMS ((unsigned char *, unsigned int, unsigned long));
236 static void request_dump PARAMS ((unsigned int, char));
237 static const char * get_elf_class PARAMS ((unsigned char));
238 static const char * get_data_encoding PARAMS ((unsigned char));
239 static const char * get_osabi_name PARAMS ((unsigned char));
240 static int guess_is_rela PARAMS ((unsigned long));
241 static char * get_note_type PARAMS ((unsigned int));
242 static int process_note PARAMS ((Elf32_Internal_Note *));
243 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
244 static int process_corefile_note_segments PARAMS ((FILE *));
245 static int process_corefile_contents PARAMS ((FILE *));
246 static int process_arch_specific PARAMS ((FILE *));
248 typedef int Elf32_Word;
256 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
257 ((X)->sh_name >= string_table_length \
258 ? "<corrupt>" : string_table + (X)->sh_name))
260 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
262 #define BYTE_GET(field) byte_get (field, sizeof (field))
264 /* If we can support a 64 bit data type then BFD64 should be defined
265 and sizeof (bfd_vma) == 8. In this case when translating from an
266 external 8 byte field to an internal field, we can assume that the
267 internal field is also 8 bytes wide and so we can extract all the data.
268 If, however, BFD64 is not defined, then we must assume that the
269 internal data structure only has 4 byte wide fields that are the
270 equivalent of the 8 byte wide external counterparts, and so we must
271 truncate the data. */
273 #define BYTE_GET8(field) byte_get (field, -8)
275 #define BYTE_GET8(field) byte_get (field, 8)
278 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
280 #define GET_ELF_SYMBOLS(file, offset, size) \
281 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
282 : get_64bit_elf_symbols (file, offset, size))
286 error VPARAMS ((const char *message, ...))
288 VA_OPEN (args, message);
289 VA_FIXEDARG (args, const char *, message);
291 fprintf (stderr, _("%s: Error: "), program_name);
292 vfprintf (stderr, message, args);
297 warn VPARAMS ((const char *message, ...))
299 VA_OPEN (args, message);
300 VA_FIXEDARG (args, const char *, message);
302 fprintf (stderr, _("%s: Warning: "), program_name);
303 vfprintf (stderr, message, args);
307 static PTR get_data PARAMS ((PTR, FILE *, long, size_t, const char *));
310 get_data (var, file, offset, size, reason)
322 if (fseek (file, offset, SEEK_SET))
324 error (_("Unable to seek to %x for %s\n"), offset, reason);
331 mvar = (PTR) malloc (size);
335 error (_("Out of memory allocating %d bytes for %s\n"),
341 if (fread (mvar, size, 1, file) != 1)
343 error (_("Unable to read in %d bytes of %s\n"), size, reason);
353 byte_get_little_endian (field, size)
354 unsigned char * field;
363 return ((unsigned int) (field [0]))
364 | (((unsigned int) (field [1])) << 8);
368 /* We want to extract data from an 8 byte wide field and
369 place it into a 4 byte wide field. Since this is a little
370 endian source we can juts use the 4 byte extraction code. */
374 return ((unsigned long) (field [0]))
375 | (((unsigned long) (field [1])) << 8)
376 | (((unsigned long) (field [2])) << 16)
377 | (((unsigned long) (field [3])) << 24);
382 /* This is a special case, generated by the BYTE_GET8 macro.
383 It means that we are loading an 8 byte value from a field
384 in an external structure into an 8 byte value in a field
385 in an internal strcuture. */
386 return ((bfd_vma) (field [0]))
387 | (((bfd_vma) (field [1])) << 8)
388 | (((bfd_vma) (field [2])) << 16)
389 | (((bfd_vma) (field [3])) << 24)
390 | (((bfd_vma) (field [4])) << 32)
391 | (((bfd_vma) (field [5])) << 40)
392 | (((bfd_vma) (field [6])) << 48)
393 | (((bfd_vma) (field [7])) << 56);
396 error (_("Unhandled data length: %d\n"), size);
401 /* Print a VMA value. */
403 print_vma (vma, mode)
413 case FULL_HEX: printf ("0x"); /* drop through */
414 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
415 case PREFIX_HEX: printf ("0x"); /* drop through */
416 case HEX: printf ("%lx", (unsigned long) vma); break;
417 case DEC: printf ("%ld", (unsigned long) vma); break;
418 case DEC_5: printf ("%5ld", (long) vma); break;
419 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
440 #if BFD_HOST_64BIT_LONG
443 if (_bfd_int64_high (vma))
444 printf ("%lx%8.8lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
446 printf ("%lx", _bfd_int64_low (vma));
451 #if BFD_HOST_64BIT_LONG
454 if (_bfd_int64_high (vma))
456 printf ("++%ld", _bfd_int64_low (vma));
458 printf ("%ld", _bfd_int64_low (vma));
463 #if BFD_HOST_64BIT_LONG
464 printf ("%5ld", vma);
466 if (_bfd_int64_high (vma))
468 printf ("++%ld", _bfd_int64_low (vma));
470 printf ("%5ld", _bfd_int64_low (vma));
475 #if BFD_HOST_64BIT_LONG
478 if (_bfd_int64_high (vma))
480 printf ("++%lu", _bfd_int64_low (vma));
482 printf ("%lu", _bfd_int64_low (vma));
491 byte_get_big_endian (field, size)
492 unsigned char * field;
501 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
504 return ((unsigned long) (field [3]))
505 | (((unsigned long) (field [2])) << 8)
506 | (((unsigned long) (field [1])) << 16)
507 | (((unsigned long) (field [0])) << 24);
511 /* Although we are extracing data from an 8 byte wide field, we
512 are returning only 4 bytes of data. */
513 return ((unsigned long) (field [7]))
514 | (((unsigned long) (field [6])) << 8)
515 | (((unsigned long) (field [5])) << 16)
516 | (((unsigned long) (field [4])) << 24);
520 /* This is a special case, generated by the BYTE_GET8 macro.
521 It means that we are loading an 8 byte value from a field
522 in an external structure into an 8 byte value in a field
523 in an internal strcuture. */
524 return ((bfd_vma) (field [7]))
525 | (((bfd_vma) (field [6])) << 8)
526 | (((bfd_vma) (field [5])) << 16)
527 | (((bfd_vma) (field [4])) << 24)
528 | (((bfd_vma) (field [3])) << 32)
529 | (((bfd_vma) (field [2])) << 40)
530 | (((bfd_vma) (field [1])) << 48)
531 | (((bfd_vma) (field [0])) << 56);
535 error (_("Unhandled data length: %d\n"), size);
540 /* Guess the relocation size commonly used by the specific machines. */
543 guess_is_rela (e_machine)
544 unsigned long e_machine;
548 /* Targets that use REL relocations. */
561 /* Targets that use RELA relocations. */
575 case EM_CYGNUS_MN10200:
577 case EM_CYGNUS_MN10300:
613 warn (_("Don't know about relocations on this machine architecture\n"));
619 slurp_rela_relocs (file, rel_offset, rel_size, relasp, nrelasp)
621 unsigned long rel_offset;
622 unsigned long rel_size;
623 Elf_Internal_Rela **relasp;
624 unsigned long *nrelasp;
626 Elf_Internal_Rela *relas;
627 unsigned long nrelas;
632 Elf32_External_Rela * erelas;
634 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset,
635 rel_size, _("relocs"));
639 nrelas = rel_size / sizeof (Elf32_External_Rela);
641 relas = (Elf_Internal_Rela *)
642 malloc (nrelas * sizeof (Elf_Internal_Rela));
646 error(_("out of memory parsing relocs"));
650 for (i = 0; i < nrelas; i++)
652 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
653 relas[i].r_info = BYTE_GET (erelas[i].r_info);
654 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
661 Elf64_External_Rela * erelas;
663 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset,
664 rel_size, _("relocs"));
668 nrelas = rel_size / sizeof (Elf64_External_Rela);
670 relas = (Elf_Internal_Rela *)
671 malloc (nrelas * sizeof (Elf_Internal_Rela));
675 error(_("out of memory parsing relocs"));
679 for (i = 0; i < nrelas; i++)
681 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
682 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
683 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
694 slurp_rel_relocs (file, rel_offset, rel_size, relsp, nrelsp)
696 unsigned long rel_offset;
697 unsigned long rel_size;
698 Elf_Internal_Rel **relsp;
699 unsigned long *nrelsp;
701 Elf_Internal_Rel *rels;
707 Elf32_External_Rel * erels;
709 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset,
710 rel_size, _("relocs"));
714 nrels = rel_size / sizeof (Elf32_External_Rel);
716 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
720 error(_("out of memory parsing relocs"));
724 for (i = 0; i < nrels; i++)
726 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
727 rels[i].r_info = BYTE_GET (erels[i].r_info);
734 Elf64_External_Rel * erels;
736 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset,
737 rel_size, _("relocs"));
741 nrels = rel_size / sizeof (Elf64_External_Rel);
743 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
747 error(_("out of memory parsing relocs"));
751 for (i = 0; i < nrels; i++)
753 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
754 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
764 /* Display the contents of the relocation data found at the specified offset. */
766 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
768 unsigned long rel_offset;
769 unsigned long rel_size;
770 Elf_Internal_Sym * symtab;
776 Elf_Internal_Rel * rels;
777 Elf_Internal_Rela * relas;
780 if (is_rela == UNKNOWN)
781 is_rela = guess_is_rela (elf_header.e_machine);
785 if (!slurp_rela_relocs (file, rel_offset, rel_size, &relas, &rel_size))
790 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
798 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
801 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
807 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
810 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
813 for (i = 0; i < rel_size; i++)
818 bfd_vma symtab_index;
823 offset = relas [i].r_offset;
824 info = relas [i].r_info;
828 offset = rels [i].r_offset;
829 info = rels [i].r_info;
834 type = ELF32_R_TYPE (info);
835 symtab_index = ELF32_R_SYM (info);
839 if (elf_header.e_machine == EM_SPARCV9)
840 type = ELF64_R_TYPE_ID (info);
842 type = ELF64_R_TYPE (info);
843 /* The #ifdef BFD64 below is to prevent a compile time warning.
844 We know that if we do not have a 64 bit data type that we
845 will never execute this code anyway. */
847 symtab_index = ELF64_R_SYM (info);
853 #ifdef _bfd_int64_low
854 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
856 printf ("%8.8lx %8.8lx ", offset, info);
861 #ifdef _bfd_int64_low
862 printf ("%8.8lx%8.8lx %8.8lx%8.8lx ",
863 _bfd_int64_high (offset),
864 _bfd_int64_low (offset),
865 _bfd_int64_high (info),
866 _bfd_int64_low (info));
868 printf ("%16.16lx %16.16lx ", offset, info);
872 switch (elf_header.e_machine)
880 rtype = elf_m32r_reloc_type (type);
885 rtype = elf_i386_reloc_type (type);
889 rtype = elf_m68k_reloc_type (type);
893 rtype = elf_i960_reloc_type (type);
898 rtype = elf_avr_reloc_type (type);
905 rtype = elf_sparc_reloc_type (type);
910 rtype = v850_reloc_type (type);
915 rtype = elf_d10v_reloc_type (type);
920 rtype = elf_d30v_reloc_type (type);
924 rtype = elf_sh_reloc_type (type);
928 case EM_CYGNUS_MN10300:
929 rtype = elf_mn10300_reloc_type (type);
933 case EM_CYGNUS_MN10200:
934 rtype = elf_mn10200_reloc_type (type);
939 rtype = elf_fr30_reloc_type (type);
943 rtype = elf_mcore_reloc_type (type);
947 rtype = elf_mmix_reloc_type (type);
952 rtype = elf_ppc_reloc_type (type);
957 rtype = elf_mips_reloc_type (type);
961 rtype = elf_alpha_reloc_type (type);
965 rtype = elf_arm_reloc_type (type);
969 rtype = elf_arc_reloc_type (type);
973 rtype = elf_hppa_reloc_type (type);
979 rtype = elf_h8_reloc_type (type);
984 rtype = elf_pj_reloc_type (type);
987 rtype = elf_ia64_reloc_type (type);
991 rtype = elf_cris_reloc_type (type);
995 rtype = elf_i860_reloc_type (type);
999 rtype = elf_x86_64_reloc_type (type);
1004 rtype = elf_s390_reloc_type (type);
1009 #ifdef _bfd_int64_low
1010 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
1012 printf (_("unrecognised: %-7lx"), type);
1015 printf ("%-21.21s", rtype);
1019 if (symtab == NULL || symtab_index >= nsyms)
1020 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1023 Elf_Internal_Sym * psym;
1025 psym = symtab + symtab_index;
1028 print_vma (psym->st_value, LONG_HEX);
1031 if (psym->st_name == 0)
1033 SECTION_NAME (section_headers + psym->st_shndx));
1034 else if (strtab == NULL)
1035 printf (_("<string table index %3ld>"), psym->st_name);
1037 printf ("%-25.25s", strtab + psym->st_name);
1040 printf (" + %lx", (unsigned long) relas [i].r_addend);
1045 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
1046 print_vma (relas[i].r_addend, LONG_HEX);
1049 if (elf_header.e_machine == EM_SPARCV9
1050 && !strcmp (rtype, "R_SPARC_OLO10"))
1051 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1065 get_mips_dynamic_type (type)
1070 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1071 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1072 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1073 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1074 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1075 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1076 case DT_MIPS_MSYM: return "MIPS_MSYM";
1077 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1078 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1079 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1080 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1081 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1082 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1083 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1084 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1085 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1086 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1087 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1088 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1089 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1090 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1091 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1092 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1093 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1094 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1095 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1096 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1097 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1098 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1099 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1100 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1101 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1102 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1103 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1104 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1105 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1106 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1107 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1108 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1109 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1110 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1111 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1112 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1119 get_sparc64_dynamic_type (type)
1124 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1131 get_parisc_dynamic_type (type)
1136 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1137 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1138 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1139 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1140 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1141 case DT_HP_PREINIT: return "HP_PREINIT";
1142 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1143 case DT_HP_NEEDED: return "HP_NEEDED";
1144 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1145 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1146 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1147 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1148 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1155 get_dynamic_type (type)
1158 static char buff [32];
1162 case DT_NULL: return "NULL";
1163 case DT_NEEDED: return "NEEDED";
1164 case DT_PLTRELSZ: return "PLTRELSZ";
1165 case DT_PLTGOT: return "PLTGOT";
1166 case DT_HASH: return "HASH";
1167 case DT_STRTAB: return "STRTAB";
1168 case DT_SYMTAB: return "SYMTAB";
1169 case DT_RELA: return "RELA";
1170 case DT_RELASZ: return "RELASZ";
1171 case DT_RELAENT: return "RELAENT";
1172 case DT_STRSZ: return "STRSZ";
1173 case DT_SYMENT: return "SYMENT";
1174 case DT_INIT: return "INIT";
1175 case DT_FINI: return "FINI";
1176 case DT_SONAME: return "SONAME";
1177 case DT_RPATH: return "RPATH";
1178 case DT_SYMBOLIC: return "SYMBOLIC";
1179 case DT_REL: return "REL";
1180 case DT_RELSZ: return "RELSZ";
1181 case DT_RELENT: return "RELENT";
1182 case DT_PLTREL: return "PLTREL";
1183 case DT_DEBUG: return "DEBUG";
1184 case DT_TEXTREL: return "TEXTREL";
1185 case DT_JMPREL: return "JMPREL";
1186 case DT_BIND_NOW: return "BIND_NOW";
1187 case DT_INIT_ARRAY: return "INIT_ARRAY";
1188 case DT_FINI_ARRAY: return "FINI_ARRAY";
1189 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1190 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1191 case DT_RUNPATH: return "RUNPATH";
1192 case DT_FLAGS: return "FLAGS";
1194 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1195 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1197 case DT_CHECKSUM: return "CHECKSUM";
1198 case DT_PLTPADSZ: return "PLTPADSZ";
1199 case DT_MOVEENT: return "MOVEENT";
1200 case DT_MOVESZ: return "MOVESZ";
1201 case DT_FEATURE: return "FEATURE";
1202 case DT_POSFLAG_1: return "POSFLAG_1";
1203 case DT_SYMINSZ: return "SYMINSZ";
1204 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1206 case DT_ADDRRNGLO: return "ADDRRNGLO";
1207 case DT_CONFIG: return "CONFIG";
1208 case DT_DEPAUDIT: return "DEPAUDIT";
1209 case DT_AUDIT: return "AUDIT";
1210 case DT_PLTPAD: return "PLTPAD";
1211 case DT_MOVETAB: return "MOVETAB";
1212 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1214 case DT_VERSYM: return "VERSYM";
1216 case DT_RELACOUNT: return "RELACOUNT";
1217 case DT_RELCOUNT: return "RELCOUNT";
1218 case DT_FLAGS_1: return "FLAGS_1";
1219 case DT_VERDEF: return "VERDEF";
1220 case DT_VERDEFNUM: return "VERDEFNUM";
1221 case DT_VERNEED: return "VERNEED";
1222 case DT_VERNEEDNUM: return "VERNEEDNUM";
1224 case DT_AUXILIARY: return "AUXILIARY";
1225 case DT_USED: return "USED";
1226 case DT_FILTER: return "FILTER";
1229 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1231 const char * result;
1233 switch (elf_header.e_machine)
1236 case EM_MIPS_RS3_LE:
1237 result = get_mips_dynamic_type (type);
1240 result = get_sparc64_dynamic_type (type);
1250 sprintf (buff, _("Processor Specific: %lx"), type);
1252 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1254 const char * result;
1256 switch (elf_header.e_machine)
1259 result = get_parisc_dynamic_type (type);
1269 sprintf (buff, _("Operating System specific: %lx"), type);
1272 sprintf (buff, _("<unknown>: %lx"), type);
1279 get_file_type (e_type)
1282 static char buff [32];
1286 case ET_NONE: return _("NONE (None)");
1287 case ET_REL: return _("REL (Relocatable file)");
1288 case ET_EXEC: return _("EXEC (Executable file)");
1289 case ET_DYN: return _("DYN (Shared object file)");
1290 case ET_CORE: return _("CORE (Core file)");
1293 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1294 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1295 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1296 sprintf (buff, _("OS Specific: (%x)"), e_type);
1298 sprintf (buff, _("<unknown>: %x"), e_type);
1304 get_machine_name (e_machine)
1307 static char buff [64]; /* XXX */
1311 case EM_NONE: return _("None");
1312 case EM_M32: return "WE32100";
1313 case EM_SPARC: return "Sparc";
1314 case EM_386: return "Intel 80386";
1315 case EM_68K: return "MC68000";
1316 case EM_88K: return "MC88000";
1317 case EM_486: return "Intel 80486";
1318 case EM_860: return "Intel 80860";
1319 case EM_MIPS: return "MIPS R3000";
1320 case EM_S370: return "IBM System/370";
1321 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1322 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1323 case EM_PARISC: return "HPPA";
1324 case EM_PPC_OLD: return "Power PC (old)";
1325 case EM_SPARC32PLUS: return "Sparc v8+" ;
1326 case EM_960: return "Intel 90860";
1327 case EM_PPC: return "PowerPC";
1328 case EM_V800: return "NEC V800";
1329 case EM_FR20: return "Fujitsu FR20";
1330 case EM_RH32: return "TRW RH32";
1331 case EM_MCORE: return "MCORE";
1332 case EM_ARM: return "ARM";
1333 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1334 case EM_SH: return "Hitachi SH";
1335 case EM_SPARCV9: return "Sparc v9";
1336 case EM_TRICORE: return "Siemens Tricore";
1337 case EM_ARC: return "ARC";
1338 case EM_H8_300: return "Hitachi H8/300";
1339 case EM_H8_300H: return "Hitachi H8/300H";
1340 case EM_H8S: return "Hitachi H8S";
1341 case EM_H8_500: return "Hitachi H8/500";
1342 case EM_IA_64: return "Intel IA-64";
1343 case EM_MIPS_X: return "Stanford MIPS-X";
1344 case EM_COLDFIRE: return "Motorola Coldfire";
1345 case EM_68HC12: return "Motorola M68HC12";
1346 case EM_ALPHA: return "Alpha";
1347 case EM_CYGNUS_D10V:
1348 case EM_D10V: return "d10v";
1349 case EM_CYGNUS_D30V:
1350 case EM_D30V: return "d30v";
1351 case EM_CYGNUS_M32R:
1352 case EM_M32R: return "Mitsubishi M32r";
1353 case EM_CYGNUS_V850:
1354 case EM_V850: return "NEC v850";
1355 case EM_CYGNUS_MN10300:
1356 case EM_MN10300: return "mn10300";
1357 case EM_CYGNUS_MN10200:
1358 case EM_MN10200: return "mn10200";
1359 case EM_CYGNUS_FR30:
1360 case EM_FR30: return "Fujitsu FR30";
1362 case EM_PJ: return "picoJava";
1363 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1364 case EM_PCP: return "Siemens PCP";
1365 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1366 case EM_NDR1: return "Denso NDR1 microprocesspr";
1367 case EM_STARCORE: return "Motorola Star*Core processor";
1368 case EM_ME16: return "Toyota ME16 processor";
1369 case EM_ST100: return "STMicroelectronics ST100 processor";
1370 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1371 case EM_FX66: return "Siemens FX66 microcontroller";
1372 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1373 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1374 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1375 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1376 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1377 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1378 case EM_SVX: return "Silicon Graphics SVx";
1379 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1380 case EM_VAX: return "Digital VAX";
1382 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1383 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1384 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1385 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1386 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1387 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1388 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1389 case EM_PRISM: return "SiTera Prism";
1390 case EM_X86_64: return "Advanced Micro Devices X86-64";
1392 case EM_S390: return "IBM S/390";
1394 sprintf (buff, _("<unknown>: %x"), e_machine);
1400 decode_ARM_machine_flags (e_flags, buf)
1407 eabi = EF_ARM_EABI_VERSION (e_flags);
1408 e_flags &= ~ EF_ARM_EABIMASK;
1410 /* Handle "generic" ARM flags. */
1411 if (e_flags & EF_ARM_RELEXEC)
1413 strcat (buf, ", relocatable executable");
1414 e_flags &= ~ EF_ARM_RELEXEC;
1417 if (e_flags & EF_ARM_HASENTRY)
1419 strcat (buf, ", has entry point");
1420 e_flags &= ~ EF_ARM_HASENTRY;
1423 /* Now handle EABI specific flags. */
1427 strcat (buf, ", <unrecognised EABI>");
1432 case EF_ARM_EABI_VER1:
1433 strcat (buf, ", Version1 EABI");
1438 /* Process flags one bit at a time. */
1439 flag = e_flags & - e_flags;
1444 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1445 strcat (buf, ", sorted symbol tables");
1455 case EF_ARM_EABI_VER2:
1456 strcat (buf, ", Version2 EABI");
1461 /* Process flags one bit at a time. */
1462 flag = e_flags & - e_flags;
1467 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1468 strcat (buf, ", sorted symbol tables");
1471 case EF_ARM_DYNSYMSUSESEGIDX:
1472 strcat (buf, ", dynamic symbols use segment index");
1475 case EF_ARM_MAPSYMSFIRST:
1476 strcat (buf, ", mapping symbols precede others");
1486 case EF_ARM_EABI_UNKNOWN:
1487 strcat (buf, ", GNU EABI");
1492 /* Process flags one bit at a time. */
1493 flag = e_flags & - e_flags;
1498 case EF_ARM_INTERWORK:
1499 strcat (buf, ", interworking enabled");
1502 case EF_ARM_APCS_26:
1503 strcat (buf, ", uses APCS/26");
1506 case EF_ARM_APCS_FLOAT:
1507 strcat (buf, ", uses APCS/float");
1511 strcat (buf, ", position independent");
1515 strcat (buf, ", 8 bit structure alignment");
1518 case EF_ARM_NEW_ABI:
1519 strcat (buf, ", uses new ABI");
1522 case EF_ARM_OLD_ABI:
1523 strcat (buf, ", uses old ABI");
1526 case EF_ARM_SOFT_FLOAT:
1527 strcat (buf, ", software FP");
1538 strcat (buf,", <unknown>");
1542 get_machine_flags (e_flags, e_machine)
1546 static char buf [1024];
1558 decode_ARM_machine_flags (e_flags, buf);
1562 if (e_flags & EF_CPU32)
1563 strcat (buf, ", cpu32");
1567 if (e_flags & EF_PPC_EMB)
1568 strcat (buf, ", emb");
1570 if (e_flags & EF_PPC_RELOCATABLE)
1571 strcat (buf, ", relocatable");
1573 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1574 strcat (buf, ", relocatable-lib");
1578 case EM_CYGNUS_V850:
1579 switch (e_flags & EF_V850_ARCH)
1582 strcat (buf, ", v850e");
1585 strcat (buf, ", v850ea");
1588 strcat (buf, ", v850");
1591 strcat (buf, ", unknown v850 architecture variant");
1597 case EM_CYGNUS_M32R:
1598 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1599 strcat (buf, ", m32r");
1604 case EM_MIPS_RS3_LE:
1605 if (e_flags & EF_MIPS_NOREORDER)
1606 strcat (buf, ", noreorder");
1608 if (e_flags & EF_MIPS_PIC)
1609 strcat (buf, ", pic");
1611 if (e_flags & EF_MIPS_CPIC)
1612 strcat (buf, ", cpic");
1614 if (e_flags & EF_MIPS_UCODE)
1615 strcat (buf, ", ugen_reserved");
1617 if (e_flags & EF_MIPS_ABI2)
1618 strcat (buf, ", abi2");
1620 if (e_flags & EF_MIPS_32BITMODE)
1621 strcat (buf, ", 32bitmode");
1623 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1624 strcat (buf, ", mips1");
1626 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1627 strcat (buf, ", mips2");
1629 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1630 strcat (buf, ", mips3");
1632 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1633 strcat (buf, ", mips4");
1635 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
1636 strcat (buf, ", mips5");
1638 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
1639 strcat (buf, ", mips32");
1641 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
1642 strcat (buf, ", mips64");
1644 switch ((e_flags & EF_MIPS_MACH))
1646 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1647 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1648 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1649 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1650 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1651 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1652 default: strcat (buf, " UNKNOWN"); break;
1657 if (e_flags & EF_SPARC_32PLUS)
1658 strcat (buf, ", v8+");
1660 if (e_flags & EF_SPARC_SUN_US1)
1661 strcat (buf, ", ultrasparcI");
1663 if (e_flags & EF_SPARC_SUN_US3)
1664 strcat (buf, ", ultrasparcIII");
1666 if (e_flags & EF_SPARC_HAL_R1)
1667 strcat (buf, ", halr1");
1669 if (e_flags & EF_SPARC_LEDATA)
1670 strcat (buf, ", ledata");
1672 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1673 strcat (buf, ", tso");
1675 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1676 strcat (buf, ", pso");
1678 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1679 strcat (buf, ", rmo");
1683 switch (e_flags & EF_PARISC_ARCH)
1685 case EFA_PARISC_1_0:
1686 strcpy (buf, ", PA-RISC 1.0");
1688 case EFA_PARISC_1_1:
1689 strcpy (buf, ", PA-RISC 1.1");
1691 case EFA_PARISC_2_0:
1692 strcpy (buf, ", PA-RISC 2.0");
1697 if (e_flags & EF_PARISC_TRAPNIL)
1698 strcat (buf, ", trapnil");
1699 if (e_flags & EF_PARISC_EXT)
1700 strcat (buf, ", ext");
1701 if (e_flags & EF_PARISC_LSB)
1702 strcat (buf, ", lsb");
1703 if (e_flags & EF_PARISC_WIDE)
1704 strcat (buf, ", wide");
1705 if (e_flags & EF_PARISC_NO_KABP)
1706 strcat (buf, ", no kabp");
1707 if (e_flags & EF_PARISC_LAZYSWAP)
1708 strcat (buf, ", lazyswap");
1713 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1714 strcat (buf, ", new calling convention");
1716 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1717 strcat (buf, ", gnu calling convention");
1721 if ((e_flags & EF_IA_64_ABI64))
1722 strcat (buf, ", 64-bit");
1724 strcat (buf, ", 32-bit");
1725 if ((e_flags & EF_IA_64_REDUCEDFP))
1726 strcat (buf, ", reduced fp model");
1727 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
1728 strcat (buf, ", no function descriptors, constant gp");
1729 else if ((e_flags & EF_IA_64_CONS_GP))
1730 strcat (buf, ", constant gp");
1731 if ((e_flags & EF_IA_64_ABSOLUTE))
1732 strcat (buf, ", absolute");
1741 get_mips_segment_type (type)
1746 case PT_MIPS_REGINFO:
1748 case PT_MIPS_RTPROC:
1750 case PT_MIPS_OPTIONS:
1760 get_parisc_segment_type (type)
1765 case PT_HP_TLS: return "HP_TLS";
1766 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1767 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1768 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1769 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1770 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1771 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1772 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1773 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1774 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1775 case PT_HP_PARALLEL: return "HP_PARALLEL";
1776 case PT_HP_FASTBIND: return "HP_FASTBIND";
1777 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1778 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1787 get_ia64_segment_type (type)
1792 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
1793 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
1802 get_segment_type (p_type)
1803 unsigned long p_type;
1805 static char buff [32];
1809 case PT_NULL: return "NULL";
1810 case PT_LOAD: return "LOAD";
1811 case PT_DYNAMIC: return "DYNAMIC";
1812 case PT_INTERP: return "INTERP";
1813 case PT_NOTE: return "NOTE";
1814 case PT_SHLIB: return "SHLIB";
1815 case PT_PHDR: return "PHDR";
1818 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1820 const char * result;
1822 switch (elf_header.e_machine)
1825 case EM_MIPS_RS3_LE:
1826 result = get_mips_segment_type (p_type);
1829 result = get_parisc_segment_type (p_type);
1832 result = get_ia64_segment_type (p_type);
1842 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1844 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1846 const char * result;
1848 switch (elf_header.e_machine)
1851 result = get_parisc_segment_type (p_type);
1861 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1864 sprintf (buff, _("<unknown>: %lx"), p_type);
1871 get_mips_section_type_name (sh_type)
1872 unsigned int sh_type;
1876 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1877 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1878 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1879 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1880 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1881 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1882 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1883 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1884 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1885 case SHT_MIPS_RELD: return "MIPS_RELD";
1886 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1887 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1888 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1889 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1890 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1891 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1892 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1893 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1894 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1895 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1896 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1897 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1898 case SHT_MIPS_LINE: return "MIPS_LINE";
1899 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1900 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1901 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1902 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1903 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1904 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1905 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1906 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1907 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1908 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1909 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1910 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1911 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1912 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1913 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1914 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1922 get_parisc_section_type_name (sh_type)
1923 unsigned int sh_type;
1927 case SHT_PARISC_EXT: return "PARISC_EXT";
1928 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1929 case SHT_PARISC_DOC: return "PARISC_DOC";
1937 get_ia64_section_type_name (sh_type)
1938 unsigned int sh_type;
1942 case SHT_IA_64_EXT: return "IA_64_EXT";
1943 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
1951 get_section_type_name (sh_type)
1952 unsigned int sh_type;
1954 static char buff [32];
1958 case SHT_NULL: return "NULL";
1959 case SHT_PROGBITS: return "PROGBITS";
1960 case SHT_SYMTAB: return "SYMTAB";
1961 case SHT_STRTAB: return "STRTAB";
1962 case SHT_RELA: return "RELA";
1963 case SHT_HASH: return "HASH";
1964 case SHT_DYNAMIC: return "DYNAMIC";
1965 case SHT_NOTE: return "NOTE";
1966 case SHT_NOBITS: return "NOBITS";
1967 case SHT_REL: return "REL";
1968 case SHT_SHLIB: return "SHLIB";
1969 case SHT_DYNSYM: return "DYNSYM";
1970 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1971 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1972 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1973 case SHT_GROUP: return "GROUP";
1974 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
1975 case SHT_GNU_verdef: return "VERDEF";
1976 case SHT_GNU_verneed: return "VERNEED";
1977 case SHT_GNU_versym: return "VERSYM";
1978 case 0x6ffffff0: return "VERSYM";
1979 case 0x6ffffffc: return "VERDEF";
1980 case 0x7ffffffd: return "AUXILIARY";
1981 case 0x7fffffff: return "FILTER";
1984 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1986 const char * result;
1988 switch (elf_header.e_machine)
1991 case EM_MIPS_RS3_LE:
1992 result = get_mips_section_type_name (sh_type);
1995 result = get_parisc_section_type_name (sh_type);
1998 result = get_ia64_section_type_name (sh_type);
2008 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2010 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2011 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2012 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2013 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2015 sprintf (buff, _("<unknown>: %x"), sh_type);
2021 struct option options [] =
2023 {"all", no_argument, 0, 'a'},
2024 {"file-header", no_argument, 0, 'h'},
2025 {"program-headers", no_argument, 0, 'l'},
2026 {"headers", no_argument, 0, 'e'},
2027 {"histogram", no_argument, 0, 'I'},
2028 {"segments", no_argument, 0, 'l'},
2029 {"sections", no_argument, 0, 'S'},
2030 {"section-headers", no_argument, 0, 'S'},
2031 {"symbols", no_argument, 0, 's'},
2032 {"syms", no_argument, 0, 's'},
2033 {"relocs", no_argument, 0, 'r'},
2034 {"notes", no_argument, 0, 'n'},
2035 {"dynamic", no_argument, 0, 'd'},
2036 {"arch-specific", no_argument, 0, 'A'},
2037 {"version-info", no_argument, 0, 'V'},
2038 {"use-dynamic", no_argument, 0, 'D'},
2039 {"hex-dump", required_argument, 0, 'x'},
2040 {"debug-dump", optional_argument, 0, 'w'},
2041 {"unwind", no_argument, 0, 'u'},
2042 #ifdef SUPPORT_DISASSEMBLY
2043 {"instruction-dump", required_argument, 0, 'i'},
2046 {"version", no_argument, 0, 'v'},
2047 {"wide", no_argument, 0, 'W'},
2048 {"help", no_argument, 0, 'H'},
2049 {0, no_argument, 0, 0}
2055 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
2056 fprintf (stdout, _(" Options are:\n"));
2057 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
2058 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
2059 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
2060 fprintf (stdout, _(" Display the program headers\n"));
2061 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
2062 fprintf (stdout, _(" Display the sections' header\n"));
2063 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
2064 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
2065 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
2066 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
2067 fprintf (stdout, _(" -u or --unwind Display the unwind info (if present)\n"));
2068 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
2069 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
2070 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
2071 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
2072 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
2073 fprintf (stdout, _(" Dump the contents of section <number>\n"));
2074 fprintf (stdout, _(" -w[liaprmf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames]\n"));
2075 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
2076 #ifdef SUPPORT_DISASSEMBLY
2077 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
2078 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
2080 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
2081 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
2082 fprintf (stdout, _(" -W or --wide Don't split lines to fit into 80 columns\n"));
2083 fprintf (stdout, _(" -H or --help Display this information\n"));
2084 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2090 request_dump (section, type)
2091 unsigned int section;
2094 if (section >= num_dump_sects)
2096 char * new_dump_sects;
2098 new_dump_sects = (char *) calloc (section + 1, 1);
2100 if (new_dump_sects == NULL)
2101 error (_("Out of memory allocating dump request table."));
2104 /* Copy current flag settings. */
2105 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2109 dump_sects = new_dump_sects;
2110 num_dump_sects = section + 1;
2115 dump_sects [section] |= type;
2121 parse_args (argc, argv)
2130 while ((c = getopt_long
2131 (argc, argv, "ersuahnldSDAIw::x:i:vVW", options, NULL)) != EOF)
2167 do_using_dynamic ++;
2198 section = strtoul (optarg, & cp, 0);
2199 if (! * cp && section >= 0)
2201 request_dump (section, HEX_DUMP);
2211 unsigned int index = 0;
2215 while (optarg[index])
2216 switch (optarg[index++])
2225 do_debug_abbrevs = 1;
2235 do_debug_pubnames = 1;
2240 do_debug_aranges = 1;
2244 do_debug_frames_interp = 1;
2246 do_debug_frames = 1;
2251 do_debug_macinfo = 1;
2255 warn (_("Unrecognised debug option '%s'\n"), optarg);
2260 #ifdef SUPPORT_DISASSEMBLY
2263 section = strtoul (optarg, & cp, 0);
2264 if (! * cp && section >= 0)
2266 request_dump (section, DISASS_DUMP);
2272 print_version (program_name);
2282 /* xgettext:c-format */
2283 error (_("Invalid option '-%c'\n"), c);
2290 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2291 && !do_segments && !do_header && !do_dump && !do_version
2292 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2296 warn (_("Nothing to do.\n"));
2302 get_elf_class (elf_class)
2303 unsigned char elf_class;
2305 static char buff [32];
2309 case ELFCLASSNONE: return _("none");
2310 case ELFCLASS32: return _("ELF32");
2311 case ELFCLASS64: return _("ELF64");
2313 sprintf (buff, _("<unknown: %x>"), elf_class);
2319 get_data_encoding (encoding)
2320 unsigned char encoding;
2322 static char buff [32];
2326 case ELFDATANONE: return _("none");
2327 case ELFDATA2LSB: return _("2's complement, little endian");
2328 case ELFDATA2MSB: return _("2's complement, big endian");
2330 sprintf (buff, _("<unknown: %x>"), encoding);
2336 get_osabi_name (osabi)
2337 unsigned char osabi;
2339 static char buff [32];
2343 case ELFOSABI_NONE: return _("UNIX - System V");
2344 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2345 case ELFOSABI_NETBSD: return _("UNIX - NetBSD");
2346 case ELFOSABI_LINUX: return _("UNIX - Linux");
2347 case ELFOSABI_HURD: return _("GNU/Hurd");
2348 case ELFOSABI_SOLARIS: return _("UNIX - Solaris");
2349 case ELFOSABI_AIX: return _("UNIX - AIX");
2350 case ELFOSABI_IRIX: return _("UNIX - IRIX");
2351 case ELFOSABI_FREEBSD: return _("UNIX - FreeBSD");
2352 case ELFOSABI_TRU64: return _("UNIX - TRU64");
2353 case ELFOSABI_MODESTO: return _("Novell - Modesto");
2354 case ELFOSABI_OPENBSD: return _("UNIX - OpenBSD");
2355 case ELFOSABI_STANDALONE: return _("Standalone App");
2356 case ELFOSABI_ARM: return _("ARM");
2358 sprintf (buff, _("<unknown: %x>"), osabi);
2363 /* Decode the data held in 'elf_header'. */
2365 process_file_header ()
2367 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2368 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2369 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2370 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2373 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2381 printf (_("ELF Header:\n"));
2382 printf (_(" Magic: "));
2383 for (i = 0; i < EI_NIDENT; i ++)
2384 printf ("%2.2x ", elf_header.e_ident [i]);
2386 printf (_(" Class: %s\n"),
2387 get_elf_class (elf_header.e_ident [EI_CLASS]));
2388 printf (_(" Data: %s\n"),
2389 get_data_encoding (elf_header.e_ident [EI_DATA]));
2390 printf (_(" Version: %d %s\n"),
2391 elf_header.e_ident [EI_VERSION],
2392 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2394 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2397 printf (_(" OS/ABI: %s\n"),
2398 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2399 printf (_(" ABI Version: %d\n"),
2400 elf_header.e_ident [EI_ABIVERSION]);
2401 printf (_(" Type: %s\n"),
2402 get_file_type (elf_header.e_type));
2403 printf (_(" Machine: %s\n"),
2404 get_machine_name (elf_header.e_machine));
2405 printf (_(" Version: 0x%lx\n"),
2406 (unsigned long) elf_header.e_version);
2408 printf (_(" Entry point address: "));
2409 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2410 printf (_("\n Start of program headers: "));
2411 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2412 printf (_(" (bytes into file)\n Start of section headers: "));
2413 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2414 printf (_(" (bytes into file)\n"));
2416 printf (_(" Flags: 0x%lx%s\n"),
2417 (unsigned long) elf_header.e_flags,
2418 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2419 printf (_(" Size of this header: %ld (bytes)\n"),
2420 (long) elf_header.e_ehsize);
2421 printf (_(" Size of program headers: %ld (bytes)\n"),
2422 (long) elf_header.e_phentsize);
2423 printf (_(" Number of program headers: %ld\n"),
2424 (long) elf_header.e_phnum);
2425 printf (_(" Size of section headers: %ld (bytes)\n"),
2426 (long) elf_header.e_shentsize);
2427 printf (_(" Number of section headers: %ld\n"),
2428 (long) elf_header.e_shnum);
2429 printf (_(" Section header string table index: %ld\n"),
2430 (long) elf_header.e_shstrndx);
2438 get_32bit_program_headers (file, program_headers)
2440 Elf_Internal_Phdr * program_headers;
2442 Elf32_External_Phdr * phdrs;
2443 Elf32_External_Phdr * external;
2444 Elf32_Internal_Phdr * internal;
2447 phdrs = ((Elf32_External_Phdr *)
2448 get_data (NULL, file, elf_header.e_phoff,
2449 elf_header.e_phentsize * elf_header.e_phnum,
2450 _("program headers")));
2454 for (i = 0, internal = program_headers, external = phdrs;
2455 i < elf_header.e_phnum;
2456 i ++, internal ++, external ++)
2458 internal->p_type = BYTE_GET (external->p_type);
2459 internal->p_offset = BYTE_GET (external->p_offset);
2460 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2461 internal->p_paddr = BYTE_GET (external->p_paddr);
2462 internal->p_filesz = BYTE_GET (external->p_filesz);
2463 internal->p_memsz = BYTE_GET (external->p_memsz);
2464 internal->p_flags = BYTE_GET (external->p_flags);
2465 internal->p_align = BYTE_GET (external->p_align);
2474 get_64bit_program_headers (file, program_headers)
2476 Elf_Internal_Phdr * program_headers;
2478 Elf64_External_Phdr * phdrs;
2479 Elf64_External_Phdr * external;
2480 Elf64_Internal_Phdr * internal;
2483 phdrs = ((Elf64_External_Phdr *)
2484 get_data (NULL, file, elf_header.e_phoff,
2485 elf_header.e_phentsize * elf_header.e_phnum,
2486 _("program headers")));
2490 for (i = 0, internal = program_headers, external = phdrs;
2491 i < elf_header.e_phnum;
2492 i ++, internal ++, external ++)
2494 internal->p_type = BYTE_GET (external->p_type);
2495 internal->p_flags = BYTE_GET (external->p_flags);
2496 internal->p_offset = BYTE_GET8 (external->p_offset);
2497 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2498 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2499 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2500 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2501 internal->p_align = BYTE_GET8 (external->p_align);
2510 process_program_headers (file)
2513 Elf_Internal_Phdr * program_headers;
2514 Elf_Internal_Phdr * segment;
2517 if (elf_header.e_phnum == 0)
2520 printf (_("\nThere are no program headers in this file.\n"));
2524 if (do_segments && !do_header)
2526 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2527 printf (_("Entry point "));
2528 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2529 printf (_("\nThere are %d program headers, starting at offset "),
2530 elf_header.e_phnum);
2531 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2535 program_headers = (Elf_Internal_Phdr *) malloc
2536 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2538 if (program_headers == NULL)
2540 error (_("Out of memory\n"));
2545 i = get_32bit_program_headers (file, program_headers);
2547 i = get_64bit_program_headers (file, program_headers);
2551 free (program_headers);
2558 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2562 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2565 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2569 (_(" Type Offset VirtAddr PhysAddr\n"));
2571 (_(" FileSiz MemSiz Flags Align\n"));
2579 for (i = 0, segment = program_headers;
2580 i < elf_header.e_phnum;
2585 printf (" %-14.14s ", get_segment_type (segment->p_type));
2589 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2590 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2591 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2592 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2593 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2595 (segment->p_flags & PF_R ? 'R' : ' '),
2596 (segment->p_flags & PF_W ? 'W' : ' '),
2597 (segment->p_flags & PF_X ? 'E' : ' '));
2598 printf ("%#lx", (unsigned long) segment->p_align);
2602 if ((unsigned long) segment->p_offset == segment->p_offset)
2603 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2606 print_vma (segment->p_offset, FULL_HEX);
2610 print_vma (segment->p_vaddr, FULL_HEX);
2612 print_vma (segment->p_paddr, FULL_HEX);
2615 if ((unsigned long) segment->p_filesz == segment->p_filesz)
2616 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
2619 print_vma (segment->p_filesz, FULL_HEX);
2623 if ((unsigned long) segment->p_memsz == segment->p_memsz)
2624 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
2627 print_vma (segment->p_offset, FULL_HEX);
2631 (segment->p_flags & PF_R ? 'R' : ' '),
2632 (segment->p_flags & PF_W ? 'W' : ' '),
2633 (segment->p_flags & PF_X ? 'E' : ' '));
2635 if ((unsigned long) segment->p_align == segment->p_align)
2636 printf ("%#lx", (unsigned long) segment->p_align);
2639 print_vma (segment->p_align, PREFIX_HEX);
2644 print_vma (segment->p_offset, FULL_HEX);
2646 print_vma (segment->p_vaddr, FULL_HEX);
2648 print_vma (segment->p_paddr, FULL_HEX);
2650 print_vma (segment->p_filesz, FULL_HEX);
2652 print_vma (segment->p_memsz, FULL_HEX);
2654 (segment->p_flags & PF_R ? 'R' : ' '),
2655 (segment->p_flags & PF_W ? 'W' : ' '),
2656 (segment->p_flags & PF_X ? 'E' : ' '));
2657 print_vma (segment->p_align, HEX);
2661 switch (segment->p_type)
2665 loadaddr = (segment->p_vaddr & 0xfffff000)
2666 - (segment->p_offset & 0xfffff000);
2671 error (_("more than one dynamic segment\n"));
2673 dynamic_addr = segment->p_offset;
2674 dynamic_size = segment->p_filesz;
2678 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2679 error (_("Unable to find program interpreter name\n"));
2682 program_interpreter[0] = 0;
2683 fscanf (file, "%63s", program_interpreter);
2686 printf (_("\n [Requesting program interpreter: %s]"),
2687 program_interpreter);
2693 putc ('\n', stdout);
2702 if (do_segments && section_headers != NULL)
2704 printf (_("\n Section to Segment mapping:\n"));
2705 printf (_(" Segment Sections...\n"));
2707 assert (string_table != NULL);
2709 for (i = 0; i < elf_header.e_phnum; i++)
2712 Elf_Internal_Shdr * section;
2714 segment = program_headers + i;
2715 section = section_headers;
2717 printf (" %2.2d ", i);
2719 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2721 if (section->sh_size > 0
2722 /* Compare allocated sections by VMA, unallocated
2723 sections by file offset. */
2724 && (section->sh_flags & SHF_ALLOC
2725 ? (section->sh_addr >= segment->p_vaddr
2726 && section->sh_addr + section->sh_size
2727 <= segment->p_vaddr + segment->p_memsz)
2728 : ((bfd_vma) section->sh_offset >= segment->p_offset
2729 && (section->sh_offset + section->sh_size
2730 <= segment->p_offset + segment->p_filesz))))
2731 printf ("%s ", SECTION_NAME (section));
2738 free (program_headers);
2745 get_32bit_section_headers (file)
2748 Elf32_External_Shdr * shdrs;
2749 Elf32_Internal_Shdr * internal;
2752 shdrs = ((Elf32_External_Shdr *)
2753 get_data (NULL, file, elf_header.e_shoff,
2754 elf_header.e_shentsize * elf_header.e_shnum,
2755 _("section headers")));
2759 section_headers = (Elf_Internal_Shdr *) malloc
2760 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2762 if (section_headers == NULL)
2764 error (_("Out of memory\n"));
2768 for (i = 0, internal = section_headers;
2769 i < elf_header.e_shnum;
2772 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2773 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2774 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2775 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2776 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2777 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2778 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2779 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2780 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2781 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2790 get_64bit_section_headers (file)
2793 Elf64_External_Shdr * shdrs;
2794 Elf64_Internal_Shdr * internal;
2797 shdrs = ((Elf64_External_Shdr *)
2798 get_data (NULL, file, elf_header.e_shoff,
2799 elf_header.e_shentsize * elf_header.e_shnum,
2800 _("section headers")));
2804 section_headers = (Elf_Internal_Shdr *) malloc
2805 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2807 if (section_headers == NULL)
2809 error (_("Out of memory\n"));
2813 for (i = 0, internal = section_headers;
2814 i < elf_header.e_shnum;
2817 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2818 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2819 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2820 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2821 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2822 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2823 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2824 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2825 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2826 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2834 static Elf_Internal_Sym *
2835 get_32bit_elf_symbols (file, offset, number)
2837 unsigned long offset;
2838 unsigned long number;
2840 Elf32_External_Sym * esyms;
2841 Elf_Internal_Sym * isyms;
2842 Elf_Internal_Sym * psym;
2845 esyms = ((Elf32_External_Sym *)
2846 get_data (NULL, file, offset,
2847 number * sizeof (Elf32_External_Sym), _("symbols")));
2851 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2855 error (_("Out of memory\n"));
2861 for (j = 0, psym = isyms;
2865 psym->st_name = BYTE_GET (esyms[j].st_name);
2866 psym->st_value = BYTE_GET (esyms[j].st_value);
2867 psym->st_size = BYTE_GET (esyms[j].st_size);
2868 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2869 psym->st_info = BYTE_GET (esyms[j].st_info);
2870 psym->st_other = BYTE_GET (esyms[j].st_other);
2878 static Elf_Internal_Sym *
2879 get_64bit_elf_symbols (file, offset, number)
2881 unsigned long offset;
2882 unsigned long number;
2884 Elf64_External_Sym * esyms;
2885 Elf_Internal_Sym * isyms;
2886 Elf_Internal_Sym * psym;
2889 esyms = ((Elf64_External_Sym *)
2890 get_data (NULL, file, offset,
2891 number * sizeof (Elf64_External_Sym), _("symbols")));
2895 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2899 error (_("Out of memory\n"));
2905 for (j = 0, psym = isyms;
2909 psym->st_name = BYTE_GET (esyms[j].st_name);
2910 psym->st_info = BYTE_GET (esyms[j].st_info);
2911 psym->st_other = BYTE_GET (esyms[j].st_other);
2912 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2913 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2914 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2923 get_elf_section_flags (sh_flags)
2926 static char buff [32];
2934 flag = sh_flags & - sh_flags;
2939 case SHF_WRITE: strcat (buff, "W"); break;
2940 case SHF_ALLOC: strcat (buff, "A"); break;
2941 case SHF_EXECINSTR: strcat (buff, "X"); break;
2942 case SHF_MERGE: strcat (buff, "M"); break;
2943 case SHF_STRINGS: strcat (buff, "S"); break;
2944 case SHF_INFO_LINK: strcat (buff, "I"); break;
2945 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2946 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2947 case SHF_GROUP: strcat (buff, "G"); break;
2950 if (flag & SHF_MASKOS)
2953 sh_flags &= ~ SHF_MASKOS;
2955 else if (flag & SHF_MASKPROC)
2958 sh_flags &= ~ SHF_MASKPROC;
2970 process_section_headers (file)
2973 Elf_Internal_Shdr * section;
2976 section_headers = NULL;
2978 if (elf_header.e_shnum == 0)
2981 printf (_("\nThere are no sections in this file.\n"));
2986 if (do_sections && !do_header)
2987 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2988 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2992 if (! get_32bit_section_headers (file))
2995 else if (! get_64bit_section_headers (file))
2998 /* Read in the string table, so that we have names to display. */
2999 section = section_headers + elf_header.e_shstrndx;
3001 if (section->sh_size != 0)
3003 string_table = (char *) get_data (NULL, file, section->sh_offset,
3004 section->sh_size, _("string table"));
3006 string_table_length = section->sh_size;
3009 /* Scan the sections for the dynamic symbol table
3010 and dynamic string table and debug sections. */
3011 dynamic_symbols = NULL;
3012 dynamic_strings = NULL;
3013 dynamic_syminfo = NULL;
3015 for (i = 0, section = section_headers;
3016 i < elf_header.e_shnum;
3019 char * name = SECTION_NAME (section);
3021 if (section->sh_type == SHT_DYNSYM)
3023 if (dynamic_symbols != NULL)
3025 error (_("File contains multiple dynamic symbol tables\n"));
3029 num_dynamic_syms = section->sh_size / section->sh_entsize;
3031 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
3033 else if (section->sh_type == SHT_STRTAB
3034 && strcmp (name, ".dynstr") == 0)
3036 if (dynamic_strings != NULL)
3038 error (_("File contains multiple dynamic string tables\n"));
3042 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
3044 _("dynamic strings"));
3046 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3047 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3048 || do_debug_frames || do_debug_macinfo)
3049 && strncmp (name, ".debug_", 7) == 0)
3054 || (do_debug_info && (strcmp (name, "info") == 0))
3055 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3056 || (do_debug_lines && (strcmp (name, "line") == 0))
3057 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3058 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3059 || (do_debug_frames && (strcmp (name, "frame") == 0))
3060 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3062 request_dump (i, DEBUG_DUMP);
3064 /* linkonce section to be combined with .debug_info at link time. */
3065 else if ((do_debugging || do_debug_info)
3066 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3067 request_dump (i, DEBUG_DUMP);
3068 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3069 request_dump (i, DEBUG_DUMP);
3075 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
3079 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3082 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3085 printf (_(" [Nr] Name Type Address Offset\n"));
3086 printf (_(" Size EntSize Flags Link Info Align\n"));
3089 for (i = 0, section = section_headers;
3090 i < elf_header.e_shnum;
3093 printf (" [%2d] %-17.17s %-15.15s ",
3095 SECTION_NAME (section),
3096 get_section_type_name (section->sh_type));
3100 print_vma (section->sh_addr, LONG_HEX);
3102 printf ( " %6.6lx %6.6lx %2.2lx",
3103 (unsigned long) section->sh_offset,
3104 (unsigned long) section->sh_size,
3105 (unsigned long) section->sh_entsize);
3107 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3109 printf ("%2ld %3lx %2ld\n",
3110 (unsigned long) section->sh_link,
3111 (unsigned long) section->sh_info,
3112 (unsigned long) section->sh_addralign);
3116 print_vma (section->sh_addr, LONG_HEX);
3118 if ((long) section->sh_offset == section->sh_offset)
3119 printf (" %6.6lx", (unsigned long) section->sh_offset);
3123 print_vma (section->sh_offset, LONG_HEX);
3126 if ((unsigned long) section->sh_size == section->sh_size)
3127 printf (" %6.6lx", (unsigned long) section->sh_size);
3131 print_vma (section->sh_size, LONG_HEX);
3134 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3135 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3139 print_vma (section->sh_entsize, LONG_HEX);
3142 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3144 printf ("%2ld %3lx ",
3145 (unsigned long) section->sh_link,
3146 (unsigned long) section->sh_info);
3148 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3149 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3152 print_vma (section->sh_addralign, DEC);
3159 print_vma (section->sh_addr, LONG_HEX);
3160 if ((long) section->sh_offset == section->sh_offset)
3161 printf (" %8.8lx", (unsigned long) section->sh_offset);
3165 print_vma (section->sh_offset, LONG_HEX);
3168 print_vma (section->sh_size, LONG_HEX);
3170 print_vma (section->sh_entsize, LONG_HEX);
3172 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3174 printf (" %2ld %3lx %ld\n",
3175 (unsigned long) section->sh_link,
3176 (unsigned long) section->sh_info,
3177 (unsigned long) section->sh_addralign);
3181 printf (_("Key to Flags:\n"));
3182 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
3183 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
3184 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3189 /* Process the reloc section. */
3191 process_relocs (file)
3194 unsigned long rel_size;
3195 unsigned long rel_offset;
3201 if (do_using_dynamic)
3203 int is_rela = FALSE;
3208 if (dynamic_info[DT_REL])
3210 rel_offset = dynamic_info[DT_REL];
3211 rel_size = dynamic_info[DT_RELSZ];
3214 else if (dynamic_info [DT_RELA])
3216 rel_offset = dynamic_info[DT_RELA];
3217 rel_size = dynamic_info[DT_RELASZ];
3220 else if (dynamic_info[DT_JMPREL])
3222 rel_offset = dynamic_info[DT_JMPREL];
3223 rel_size = dynamic_info[DT_PLTRELSZ];
3225 switch (dynamic_info[DT_PLTREL])
3242 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3243 rel_offset, rel_size);
3245 dump_relocations (file, rel_offset - loadaddr, rel_size,
3246 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3249 printf (_("\nThere are no dynamic relocations in this file.\n"));
3253 Elf32_Internal_Shdr * section;
3257 for (i = 0, section = section_headers;
3258 i < elf_header.e_shnum;
3261 if ( section->sh_type != SHT_RELA
3262 && section->sh_type != SHT_REL)
3265 rel_offset = section->sh_offset;
3266 rel_size = section->sh_size;
3270 Elf32_Internal_Shdr * strsec;
3271 Elf_Internal_Sym * symtab;
3274 unsigned long nsyms;
3276 printf (_("\nRelocation section "));
3278 if (string_table == NULL)
3279 printf ("%d", section->sh_name);
3281 printf ("'%s'", SECTION_NAME (section));
3283 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3284 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3289 if (section->sh_link)
3291 Elf32_Internal_Shdr * symsec;
3293 symsec = section_headers + section->sh_link;
3294 nsyms = symsec->sh_size / symsec->sh_entsize;
3295 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
3300 strsec = section_headers + symsec->sh_link;
3302 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3306 is_rela = section->sh_type == SHT_RELA;
3308 dump_relocations (file, rel_offset, rel_size,
3309 symtab, nsyms, strtab, is_rela);
3321 printf (_("\nThere are no relocations in this file.\n"));
3327 #include "unwind-ia64.h"
3329 /* An absolute address consists of a section and an offset. If the
3330 section is NULL, the offset itself is the address, otherwise, the
3331 address equals to LOAD_ADDRESS(section) + offset. */
3335 unsigned short section;
3341 struct unw_table_entry
3343 struct absaddr start;
3345 struct absaddr info;
3347 *table; /* Unwind table. */
3348 unsigned long table_len; /* Length of unwind table. */
3349 unsigned char * info; /* Unwind info. */
3350 unsigned long info_size; /* Size of unwind info. */
3351 bfd_vma info_addr; /* starting address of unwind info. */
3352 bfd_vma seg_base; /* Starting address of segment. */
3353 Elf_Internal_Sym * symtab; /* The symbol table. */
3354 unsigned long nsyms; /* Number of symbols. */
3355 char * strtab; /* The string table. */
3356 unsigned long strtab_size; /* Size of string table. */
3359 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3360 struct absaddr, const char **,
3362 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3363 static int slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3364 Elf32_Internal_Shdr *));
3367 find_symbol_for_address (aux, addr, symname, offset)
3368 struct unw_aux_info *aux;
3369 struct absaddr addr;
3370 const char **symname;
3373 bfd_vma dist = (bfd_vma) 0x100000;
3374 Elf_Internal_Sym *sym, *best = NULL;
3377 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3379 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3380 && sym->st_name != 0
3381 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3382 && addr.offset >= sym->st_value
3383 && addr.offset - sym->st_value < dist)
3386 dist = addr.offset - sym->st_value;
3393 *symname = (best->st_name >= aux->strtab_size
3394 ? "<corrupt>" : aux->strtab + best->st_name);
3399 *offset = addr.offset;
3403 dump_ia64_unwind (aux)
3404 struct unw_aux_info *aux;
3407 struct unw_table_entry * tp;
3410 addr_size = is_32bit_elf ? 4 : 8;
3412 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3416 const unsigned char * dp;
3417 const unsigned char * head;
3418 const char * procname;
3420 find_symbol_for_address (aux, tp->start, &procname, &offset);
3422 fputs ("\n<", stdout);
3426 fputs (procname, stdout);
3429 printf ("+%lx", (unsigned long) offset);
3432 fputs (">: [", stdout);
3433 print_vma (tp->start.offset, PREFIX_HEX);
3434 fputc ('-', stdout);
3435 print_vma (tp->end.offset, PREFIX_HEX);
3436 printf ("), info at +0x%lx\n",
3437 (unsigned long) (tp->info.offset - aux->seg_base));
3439 head = aux->info + (tp->info.offset - aux->info_addr);
3440 stamp = BYTE_GET8 ((unsigned char *) head);
3442 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3443 (unsigned) UNW_VER (stamp),
3444 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3445 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3446 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3447 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3449 if (UNW_VER (stamp) != 1)
3451 printf ("\tUnknown version.\n");
3456 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3457 dp = unw_decode (dp, in_body, & in_body);
3462 slurp_ia64_unwind_table (file, aux, sec)
3464 struct unw_aux_info *aux;
3465 Elf32_Internal_Shdr *sec;
3467 unsigned long size, addr_size, nrelas, i;
3468 Elf_Internal_Phdr *prog_hdrs, *seg;
3469 struct unw_table_entry *tep;
3470 Elf32_Internal_Shdr *relsec;
3471 Elf_Internal_Rela *rela, *rp;
3472 unsigned char *table, *tp;
3473 Elf_Internal_Sym *sym;
3474 const char *relname;
3477 addr_size = is_32bit_elf ? 4 : 8;
3479 /* First, find the starting address of the segment that includes
3482 if (elf_header.e_phnum)
3484 prog_hdrs = (Elf_Internal_Phdr *)
3485 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3488 result = get_32bit_program_headers (file, prog_hdrs);
3490 result = get_64bit_program_headers (file, prog_hdrs);
3498 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3500 if (seg->p_type != PT_LOAD)
3503 if (sec->sh_addr >= seg->p_vaddr
3504 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3506 aux->seg_base = seg->p_vaddr;
3514 /* Second, build the unwind table from the contents of the unwind section: */
3515 size = sec->sh_size;
3516 table = (char *) get_data (NULL, file, sec->sh_offset,
3517 size, _("unwind table"));
3521 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3522 for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3524 tep->start.section = SHN_UNDEF;
3525 tep->end.section = SHN_UNDEF;
3526 tep->info.section = SHN_UNDEF;
3529 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3530 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
3531 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
3535 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
3536 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
3537 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
3539 tep->start.offset += aux->seg_base;
3540 tep->end.offset += aux->seg_base;
3541 tep->info.offset += aux->seg_base;
3545 /* Third, apply any relocations to the unwind table: */
3547 for (relsec = section_headers;
3548 relsec < section_headers + elf_header.e_shnum;
3551 if (relsec->sh_type != SHT_RELA
3552 || section_headers + relsec->sh_info != sec)
3555 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3559 for (rp = rela; rp < rela + nrelas; ++rp)
3563 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3564 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3566 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3568 warn (_("Skipping unexpected symbol type %u"),
3569 ELF32_ST_TYPE (sym->st_info));
3575 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3576 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3578 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3580 warn (_("Skipping unexpected symbol type %u"),
3581 ELF64_ST_TYPE (sym->st_info));
3586 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
3588 warn (_("Skipping unexpected relocation type %s"), relname);
3592 i = rp->r_offset / (3 * addr_size);
3594 switch (rp->r_offset/addr_size % 3)
3597 aux->table[i].start.section = sym->st_shndx;
3598 aux->table[i].start.offset += rp->r_addend;
3601 aux->table[i].end.section = sym->st_shndx;
3602 aux->table[i].end.offset += rp->r_addend;
3605 aux->table[i].info.section = sym->st_shndx;
3606 aux->table[i].info.offset += rp->r_addend;
3616 aux->table_len = size / (3 * addr_size);
3621 process_unwind (file)
3624 Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
3625 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
3626 struct unw_aux_info aux;
3631 if (elf_header.e_machine != EM_IA_64)
3633 printf (_("\nThere are no unwind sections in this file.\n"));
3637 memset (& aux, 0, sizeof (aux));
3639 addr_size = is_32bit_elf ? 4 : 8;
3641 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
3643 if (sec->sh_type == SHT_SYMTAB)
3645 aux.nsyms = sec->sh_size / sec->sh_entsize;
3646 aux.symtab = GET_ELF_SYMBOLS (file, sec->sh_offset, aux.nsyms);
3648 strsec = section_headers + sec->sh_link;
3649 aux.strtab_size = strsec->sh_size;
3650 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3651 aux.strtab_size, _("string table"));
3653 else if (sec->sh_type == SHT_IA_64_UNWIND)
3658 printf (_("\nThere are no unwind sections in this file.\n"));
3660 while (unwcount-- > 0)
3665 for (i = unwstart, sec = section_headers + unwstart;
3666 i < elf_header.e_shnum; ++i, ++sec)
3667 if (sec->sh_type == SHT_IA_64_UNWIND)
3674 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
3676 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
3679 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3680 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
3681 suffix = SECTION_NAME (unwsec) + len;
3682 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3684 if (strncmp (SECTION_NAME (sec),
3685 ELF_STRING_ia64_unwind_info_once, len2) == 0
3686 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3691 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3692 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3693 len = sizeof (ELF_STRING_ia64_unwind) - 1;
3694 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
3696 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
3698 suffix = SECTION_NAME (unwsec) + len;
3699 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
3701 if (strncmp (SECTION_NAME (sec),
3702 ELF_STRING_ia64_unwind_info, len2) == 0
3703 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
3707 if (i == elf_header.e_shnum)
3709 printf (_("\nCould not find unwind info section for "));
3711 if (string_table == NULL)
3712 printf ("%d", unwsec->sh_name);
3714 printf ("'%s'", SECTION_NAME (unwsec));
3718 aux.info_size = sec->sh_size;
3719 aux.info_addr = sec->sh_addr;
3720 aux.info = (char *) get_data (NULL, file, sec->sh_offset,
3721 aux.info_size, _("unwind info"));
3723 printf (_("\nUnwind section "));
3725 if (string_table == NULL)
3726 printf ("%d", unwsec->sh_name);
3728 printf ("'%s'", SECTION_NAME (unwsec));
3730 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3731 (unsigned long) unwsec->sh_offset,
3732 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
3734 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
3736 if (aux.table_len > 0)
3737 dump_ia64_unwind (& aux);
3740 free ((char *) aux.table);
3742 free ((char *) aux.info);
3751 free ((char *) aux.strtab);
3757 dynamic_segment_mips_val (entry)
3758 Elf_Internal_Dyn * entry;
3760 switch (entry->d_tag)
3763 if (entry->d_un.d_val == 0)
3767 static const char * opts[] =
3769 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3770 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3771 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3772 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3777 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
3778 if (entry->d_un.d_val & (1 << cnt))
3780 printf ("%s%s", first ? "" : " ", opts[cnt]);
3787 case DT_MIPS_IVERSION:
3788 if (dynamic_strings != NULL)
3789 printf ("Interface Version: %s\n",
3790 dynamic_strings + entry->d_un.d_val);
3792 printf ("%ld\n", (long) entry->d_un.d_ptr);
3795 case DT_MIPS_TIME_STAMP:
3800 time_t time = entry->d_un.d_val;
3801 tmp = gmtime (&time);
3802 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3803 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3804 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3805 printf ("Time Stamp: %s\n", timebuf);
3809 case DT_MIPS_RLD_VERSION:
3810 case DT_MIPS_LOCAL_GOTNO:
3811 case DT_MIPS_CONFLICTNO:
3812 case DT_MIPS_LIBLISTNO:
3813 case DT_MIPS_SYMTABNO:
3814 case DT_MIPS_UNREFEXTNO:
3815 case DT_MIPS_HIPAGENO:
3816 case DT_MIPS_DELTA_CLASS_NO:
3817 case DT_MIPS_DELTA_INSTANCE_NO:
3818 case DT_MIPS_DELTA_RELOC_NO:
3819 case DT_MIPS_DELTA_SYM_NO:
3820 case DT_MIPS_DELTA_CLASSSYM_NO:
3821 case DT_MIPS_COMPACT_SIZE:
3822 printf ("%ld\n", (long) entry->d_un.d_ptr);
3826 printf ("%#lx\n", (long) entry->d_un.d_ptr);
3832 dynamic_segment_parisc_val (entry)
3833 Elf_Internal_Dyn * entry;
3835 switch (entry->d_tag)
3837 case DT_HP_DLD_FLAGS:
3846 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3847 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3848 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3849 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3850 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3851 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3852 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3853 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3854 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3855 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3856 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3860 bfd_vma val = entry->d_un.d_val;
3862 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3863 if (val & flags[cnt].bit)
3867 fputs (flags[cnt].str, stdout);
3869 val ^= flags[cnt].bit;
3872 if (val != 0 || first)
3876 print_vma (val, HEX);
3882 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3888 get_32bit_dynamic_segment (file)
3891 Elf32_External_Dyn * edyn;
3892 Elf_Internal_Dyn * entry;
3895 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr,
3896 dynamic_size, _("dynamic segment"));
3900 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3901 how large this .dynamic is now. We can do this even before the byte
3902 swapping since the DT_NULL tag is recognizable. */
3904 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3907 dynamic_segment = (Elf_Internal_Dyn *)
3908 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3910 if (dynamic_segment == NULL)
3912 error (_("Out of memory\n"));
3917 for (i = 0, entry = dynamic_segment;
3921 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3922 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3931 get_64bit_dynamic_segment (file)
3934 Elf64_External_Dyn * edyn;
3935 Elf_Internal_Dyn * entry;
3938 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr,
3939 dynamic_size, _("dynamic segment"));
3943 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3944 how large this .dynamic is now. We can do this even before the byte
3945 swapping since the DT_NULL tag is recognizable. */
3947 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3950 dynamic_segment = (Elf_Internal_Dyn *)
3951 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3953 if (dynamic_segment == NULL)
3955 error (_("Out of memory\n"));
3960 for (i = 0, entry = dynamic_segment;
3964 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3965 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3974 get_dynamic_flags (flags)
3977 static char buff [64];
3982 flag = flags & - flags;
3987 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3988 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3989 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3990 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3991 default: strcat (buff, "unknown "); break;
3997 /* Parse and display the contents of the dynamic segment. */
3999 process_dynamic_segment (file)
4002 Elf_Internal_Dyn * entry;
4005 if (dynamic_size == 0)
4008 printf (_("\nThere is no dynamic segment in this file.\n"));
4015 if (! get_32bit_dynamic_segment (file))
4018 else if (! get_64bit_dynamic_segment (file))
4021 /* Find the appropriate symbol table. */
4022 if (dynamic_symbols == NULL)
4024 for (i = 0, entry = dynamic_segment;
4028 unsigned long offset;
4030 if (entry->d_tag != DT_SYMTAB)
4033 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4035 /* Since we do not know how big the symbol table is,
4036 we default to reading in the entire file (!) and
4037 processing that. This is overkill, I know, but it
4039 offset = entry->d_un.d_val - loadaddr;
4041 if (fseek (file, 0, SEEK_END))
4042 error (_("Unable to seek to end of file!"));
4045 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
4047 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
4049 if (num_dynamic_syms < 1)
4051 error (_("Unable to determine the number of symbols to load\n"));
4055 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
4059 /* Similarly find a string table. */
4060 if (dynamic_strings == NULL)
4062 for (i = 0, entry = dynamic_segment;
4066 unsigned long offset;
4069 if (entry->d_tag != DT_STRTAB)
4072 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4074 /* Since we do not know how big the string table is,
4075 we default to reading in the entire file (!) and
4076 processing that. This is overkill, I know, but it
4079 offset = entry->d_un.d_val - loadaddr;
4080 if (fseek (file, 0, SEEK_END))
4081 error (_("Unable to seek to end of file\n"));
4082 str_tab_len = ftell (file) - offset;
4084 if (str_tab_len < 1)
4087 (_("Unable to determine the length of the dynamic string table\n"));
4091 dynamic_strings = (char *) get_data (NULL, file, offset, str_tab_len,
4092 _("dynamic string table"));
4098 /* And find the syminfo section if available. */
4099 if (dynamic_syminfo == NULL)
4101 unsigned int syminsz = 0;
4103 for (i = 0, entry = dynamic_segment;
4107 if (entry->d_tag == DT_SYMINENT)
4109 /* Note: these braces are necessary to avoid a syntax
4110 error from the SunOS4 C compiler. */
4111 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4113 else if (entry->d_tag == DT_SYMINSZ)
4114 syminsz = entry->d_un.d_val;
4115 else if (entry->d_tag == DT_SYMINFO)
4116 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
4119 if (dynamic_syminfo_offset != 0 && syminsz != 0)
4121 Elf_External_Syminfo * extsyminfo;
4122 Elf_Internal_Syminfo * syminfo;
4124 /* There is a syminfo section. Read the data. */
4125 extsyminfo = ((Elf_External_Syminfo *)
4126 get_data (NULL, file, dynamic_syminfo_offset,
4127 syminsz, _("symbol information")));
4131 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
4132 if (dynamic_syminfo == NULL)
4134 error (_("Out of memory\n"));
4138 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4139 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4142 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4143 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4150 if (do_dynamic && dynamic_addr)
4151 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4152 dynamic_addr, (long) dynamic_size);
4154 printf (_(" Tag Type Name/Value\n"));
4156 for (i = 0, entry = dynamic_segment;
4165 print_vma (entry->d_tag, FULL_HEX);
4166 dtype = get_dynamic_type (entry->d_tag);
4167 printf (" (%s)%*s", dtype,
4168 ((is_32bit_elf ? 27 : 19)
4169 - (int) strlen (dtype)),
4173 switch (entry->d_tag)
4177 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
4187 switch (entry->d_tag)
4190 printf (_("Auxiliary library"));
4194 printf (_("Filter library"));
4198 printf (_("Configuration file"));
4202 printf (_("Dependency audit library"));
4206 printf (_("Audit library"));
4210 if (dynamic_strings)
4211 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4215 print_vma (entry->d_un.d_val, PREFIX_HEX);
4224 printf (_("Flags:"));
4225 if (entry->d_un.d_val == 0)
4226 printf (_(" None\n"));
4229 unsigned long int val = entry->d_un.d_val;
4230 if (val & DTF_1_PARINIT)
4232 printf (" PARINIT");
4233 val ^= DTF_1_PARINIT;
4235 if (val & DTF_1_CONFEXP)
4237 printf (" CONFEXP");
4238 val ^= DTF_1_CONFEXP;
4241 printf (" %lx", val);
4250 printf (_("Flags:"));
4251 if (entry->d_un.d_val == 0)
4252 printf (_(" None\n"));
4255 unsigned long int val = entry->d_un.d_val;
4256 if (val & DF_P1_LAZYLOAD)
4258 printf (" LAZYLOAD");
4259 val ^= DF_P1_LAZYLOAD;
4261 if (val & DF_P1_GROUPPERM)
4263 printf (" GROUPPERM");
4264 val ^= DF_P1_GROUPPERM;
4267 printf (" %lx", val);
4276 printf (_("Flags:"));
4277 if (entry->d_un.d_val == 0)
4278 printf (_(" None\n"));
4281 unsigned long int val = entry->d_un.d_val;
4287 if (val & DF_1_GLOBAL)
4292 if (val & DF_1_GROUP)
4297 if (val & DF_1_NODELETE)
4299 printf (" NODELETE");
4300 val ^= DF_1_NODELETE;
4302 if (val & DF_1_LOADFLTR)
4304 printf (" LOADFLTR");
4305 val ^= DF_1_LOADFLTR;
4307 if (val & DF_1_INITFIRST)
4309 printf (" INITFIRST");
4310 val ^= DF_1_INITFIRST;
4312 if (val & DF_1_NOOPEN)
4317 if (val & DF_1_ORIGIN)
4322 if (val & DF_1_DIRECT)
4327 if (val & DF_1_TRANS)
4332 if (val & DF_1_INTERPOSE)
4334 printf (" INTERPOSE");
4335 val ^= DF_1_INTERPOSE;
4337 if (val & DF_1_NODEFLIB)
4339 printf (" NODEFLIB");
4340 val ^= DF_1_NODEFLIB;
4342 if (val & DF_1_NODUMP)
4347 if (val & DF_1_CONLFAT)
4349 printf (" CONLFAT");
4350 val ^= DF_1_CONLFAT;
4353 printf (" %lx", val);
4361 puts (get_dynamic_type (entry->d_un.d_val));
4381 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4387 if (dynamic_strings == NULL)
4390 name = dynamic_strings + entry->d_un.d_val;
4394 switch (entry->d_tag)
4397 printf (_("Shared library: [%s]"), name);
4399 if (strcmp (name, program_interpreter) == 0)
4400 printf (_(" program interpreter"));
4404 printf (_("Library soname: [%s]"), name);
4408 printf (_("Library rpath: [%s]"), name);
4412 printf (_("Library runpath: [%s]"), name);
4416 print_vma (entry->d_un.d_val, PREFIX_HEX);
4421 print_vma (entry->d_un.d_val, PREFIX_HEX);
4437 case DT_INIT_ARRAYSZ:
4438 case DT_FINI_ARRAYSZ:
4441 print_vma (entry->d_un.d_val, UNSIGNED);
4442 printf (" (bytes)\n");
4452 print_vma (entry->d_un.d_val, UNSIGNED);
4465 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4469 name = dynamic_strings + entry->d_un.d_val;
4473 printf (_("Not needed object: [%s]\n"), name);
4478 print_vma (entry->d_un.d_val, PREFIX_HEX);
4484 /* The value of this entry is ignored. */
4488 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4489 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4494 switch (elf_header.e_machine)
4497 case EM_MIPS_RS3_LE:
4498 dynamic_segment_mips_val (entry);
4501 dynamic_segment_parisc_val (entry);
4504 print_vma (entry->d_un.d_val, PREFIX_HEX);
4516 get_ver_flags (flags)
4519 static char buff [32];
4526 if (flags & VER_FLG_BASE)
4527 strcat (buff, "BASE ");
4529 if (flags & VER_FLG_WEAK)
4531 if (flags & VER_FLG_BASE)
4532 strcat (buff, "| ");
4534 strcat (buff, "WEAK ");
4537 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4538 strcat (buff, "| <unknown>");
4543 /* Display the contents of the version sections. */
4545 process_version_sections (file)
4548 Elf32_Internal_Shdr * section;
4555 for (i = 0, section = section_headers;
4556 i < elf_header.e_shnum;
4559 switch (section->sh_type)
4561 case SHT_GNU_verdef:
4563 Elf_External_Verdef * edefs;
4570 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4571 SECTION_NAME (section), section->sh_info);
4573 printf (_(" Addr: 0x"));
4574 printf_vma (section->sh_addr);
4575 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4576 (unsigned long) section->sh_offset, section->sh_link,
4577 SECTION_NAME (section_headers + section->sh_link));
4579 edefs = ((Elf_External_Verdef *)
4580 get_data (NULL, file, section->sh_offset,
4582 _("version definition section")));
4586 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
4589 Elf_External_Verdef * edef;
4590 Elf_Internal_Verdef ent;
4591 Elf_External_Verdaux * eaux;
4592 Elf_Internal_Verdaux aux;
4596 vstart = ((char *) edefs) + idx;
4598 edef = (Elf_External_Verdef *) vstart;
4600 ent.vd_version = BYTE_GET (edef->vd_version);
4601 ent.vd_flags = BYTE_GET (edef->vd_flags);
4602 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
4603 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
4604 ent.vd_hash = BYTE_GET (edef->vd_hash);
4605 ent.vd_aux = BYTE_GET (edef->vd_aux);
4606 ent.vd_next = BYTE_GET (edef->vd_next);
4608 printf (_(" %#06x: Rev: %d Flags: %s"),
4609 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
4611 printf (_(" Index: %d Cnt: %d "),
4612 ent.vd_ndx, ent.vd_cnt);
4614 vstart += ent.vd_aux;
4616 eaux = (Elf_External_Verdaux *) vstart;
4618 aux.vda_name = BYTE_GET (eaux->vda_name);
4619 aux.vda_next = BYTE_GET (eaux->vda_next);
4621 if (dynamic_strings)
4622 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
4624 printf (_("Name index: %ld\n"), aux.vda_name);
4626 isum = idx + ent.vd_aux;
4628 for (j = 1; j < ent.vd_cnt; j ++)
4630 isum += aux.vda_next;
4631 vstart += aux.vda_next;
4633 eaux = (Elf_External_Verdaux *) vstart;
4635 aux.vda_name = BYTE_GET (eaux->vda_name);
4636 aux.vda_next = BYTE_GET (eaux->vda_next);
4638 if (dynamic_strings)
4639 printf (_(" %#06x: Parent %d: %s\n"),
4640 isum, j, dynamic_strings + aux.vda_name);
4642 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4643 isum, j, aux.vda_name);
4653 case SHT_GNU_verneed:
4655 Elf_External_Verneed * eneed;
4661 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4662 SECTION_NAME (section), section->sh_info);
4664 printf (_(" Addr: 0x"));
4665 printf_vma (section->sh_addr);
4666 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4667 (unsigned long) section->sh_offset, section->sh_link,
4668 SECTION_NAME (section_headers + section->sh_link));
4670 eneed = ((Elf_External_Verneed *)
4671 get_data (NULL, file, section->sh_offset,
4672 section->sh_size, _("version need section")));
4676 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
4678 Elf_External_Verneed * entry;
4679 Elf_Internal_Verneed ent;
4684 vstart = ((char *) eneed) + idx;
4686 entry = (Elf_External_Verneed *) vstart;
4688 ent.vn_version = BYTE_GET (entry->vn_version);
4689 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
4690 ent.vn_file = BYTE_GET (entry->vn_file);
4691 ent.vn_aux = BYTE_GET (entry->vn_aux);
4692 ent.vn_next = BYTE_GET (entry->vn_next);
4694 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
4696 if (dynamic_strings)
4697 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
4699 printf (_(" File: %lx"), ent.vn_file);
4701 printf (_(" Cnt: %d\n"), ent.vn_cnt);
4703 vstart += ent.vn_aux;
4705 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
4707 Elf_External_Vernaux * eaux;
4708 Elf_Internal_Vernaux aux;
4710 eaux = (Elf_External_Vernaux *) vstart;
4712 aux.vna_hash = BYTE_GET (eaux->vna_hash);
4713 aux.vna_flags = BYTE_GET (eaux->vna_flags);
4714 aux.vna_other = BYTE_GET (eaux->vna_other);
4715 aux.vna_name = BYTE_GET (eaux->vna_name);
4716 aux.vna_next = BYTE_GET (eaux->vna_next);
4718 if (dynamic_strings)
4719 printf (_(" %#06x: Name: %s"),
4720 isum, dynamic_strings + aux.vna_name);
4722 printf (_(" %#06x: Name index: %lx"),
4723 isum, aux.vna_name);
4725 printf (_(" Flags: %s Version: %d\n"),
4726 get_ver_flags (aux.vna_flags), aux.vna_other);
4728 isum += aux.vna_next;
4729 vstart += aux.vna_next;
4739 case SHT_GNU_versym:
4741 Elf32_Internal_Shdr * link_section;
4744 unsigned char * edata;
4745 unsigned short * data;
4747 Elf_Internal_Sym * symbols;
4748 Elf32_Internal_Shdr * string_sec;
4750 link_section = section_headers + section->sh_link;
4751 total = section->sh_size / section->sh_entsize;
4755 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
4756 link_section->sh_size / link_section->sh_entsize);
4758 string_sec = section_headers + link_section->sh_link;
4760 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
4761 string_sec->sh_size,
4762 _("version string table"));
4766 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4767 SECTION_NAME (section), total);
4769 printf (_(" Addr: "));
4770 printf_vma (section->sh_addr);
4771 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4772 (unsigned long) section->sh_offset, section->sh_link,
4773 SECTION_NAME (link_section));
4777 get_data (NULL, file,
4778 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] - loadaddr,
4779 total * sizeof (short), _("version symbol data")));
4786 data = (unsigned short *) malloc (total * sizeof (short));
4788 for (cnt = total; cnt --;)
4789 data [cnt] = byte_get (edata + cnt * sizeof (short),
4794 for (cnt = 0; cnt < total; cnt += 4)
4797 int check_def, check_need;
4800 printf (" %03x:", cnt);
4802 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
4803 switch (data [cnt + j])
4806 fputs (_(" 0 (*local*) "), stdout);
4810 fputs (_(" 1 (*global*) "), stdout);
4814 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4815 data [cnt + j] & 0x8000 ? 'h' : ' ');
4819 if (symbols [cnt + j].st_shndx >= SHN_LORESERVE
4820 || section_headers[symbols [cnt + j].st_shndx].sh_type
4823 if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4830 && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
4832 Elf_Internal_Verneed ivn;
4833 unsigned long offset;
4835 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4840 Elf_Internal_Vernaux ivna;
4841 Elf_External_Verneed evn;
4842 Elf_External_Vernaux evna;
4843 unsigned long a_off;
4845 get_data (&evn, file, offset, sizeof (evn),
4848 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4849 ivn.vn_next = BYTE_GET (evn.vn_next);
4851 a_off = offset + ivn.vn_aux;
4855 get_data (&evna, file, a_off, sizeof (evna),
4856 _("version need aux (2)"));
4858 ivna.vna_next = BYTE_GET (evna.vna_next);
4859 ivna.vna_other = BYTE_GET (evna.vna_other);
4861 a_off += ivna.vna_next;
4863 while (ivna.vna_other != data [cnt + j]
4864 && ivna.vna_next != 0);
4866 if (ivna.vna_other == data [cnt + j])
4868 ivna.vna_name = BYTE_GET (evna.vna_name);
4870 name = strtab + ivna.vna_name;
4871 nn += printf ("(%s%-*s",
4873 12 - (int) strlen (name),
4879 offset += ivn.vn_next;
4881 while (ivn.vn_next);
4884 if (check_def && data [cnt + j] != 0x8001
4885 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
4887 Elf_Internal_Verdef ivd;
4888 Elf_External_Verdef evd;
4889 unsigned long offset;
4891 offset = version_info
4892 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4896 get_data (&evd, file, offset, sizeof (evd),
4899 ivd.vd_next = BYTE_GET (evd.vd_next);
4900 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4902 offset += ivd.vd_next;
4904 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4905 && ivd.vd_next != 0);
4907 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4909 Elf_External_Verdaux evda;
4910 Elf_Internal_Verdaux ivda;
4912 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4914 get_data (&evda, file,
4915 offset - ivd.vd_next + ivd.vd_aux,
4916 sizeof (evda), _("version def aux"));
4918 ivda.vda_name = BYTE_GET (evda.vda_name);
4920 name = strtab + ivda.vda_name;
4921 nn += printf ("(%s%-*s",
4923 12 - (int) strlen (name),
4929 printf ("%*c", 18 - nn, ' ');
4947 printf (_("\nNo version information found in this file.\n"));
4953 get_symbol_binding (binding)
4954 unsigned int binding;
4956 static char buff [32];
4960 case STB_LOCAL: return "LOCAL";
4961 case STB_GLOBAL: return "GLOBAL";
4962 case STB_WEAK: return "WEAK";
4964 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4965 sprintf (buff, _("<processor specific>: %d"), binding);
4966 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4967 sprintf (buff, _("<OS specific>: %d"), binding);
4969 sprintf (buff, _("<unknown>: %d"), binding);
4975 get_symbol_type (type)
4978 static char buff [32];
4982 case STT_NOTYPE: return "NOTYPE";
4983 case STT_OBJECT: return "OBJECT";
4984 case STT_FUNC: return "FUNC";
4985 case STT_SECTION: return "SECTION";
4986 case STT_FILE: return "FILE";
4987 case STT_COMMON: return "COMMON";
4989 if (type >= STT_LOPROC && type <= STT_HIPROC)
4991 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4992 return "THUMB_FUNC";
4994 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4997 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4998 return "PARISC_MILLI";
5000 sprintf (buff, _("<processor specific>: %d"), type);
5002 else if (type >= STT_LOOS && type <= STT_HIOS)
5004 if (elf_header.e_machine == EM_PARISC)
5006 if (type == STT_HP_OPAQUE)
5008 if (type == STT_HP_STUB)
5012 sprintf (buff, _("<OS specific>: %d"), type);
5015 sprintf (buff, _("<unknown>: %d"), type);
5021 get_symbol_visibility (visibility)
5022 unsigned int visibility;
5026 case STV_DEFAULT: return "DEFAULT";
5027 case STV_INTERNAL: return "INTERNAL";
5028 case STV_HIDDEN: return "HIDDEN";
5029 case STV_PROTECTED: return "PROTECTED";
5035 get_symbol_index_type (type)
5040 case SHN_UNDEF: return "UND";
5041 case SHN_ABS: return "ABS";
5042 case SHN_COMMON: return "COM";
5044 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5046 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5048 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5052 static char buff [32];
5054 sprintf (buff, "%3d", type);
5061 get_dynamic_data (file, number)
5063 unsigned int number;
5065 unsigned char * e_data;
5068 e_data = (unsigned char *) malloc (number * 4);
5072 error (_("Out of memory\n"));
5076 if (fread (e_data, 4, number, file) != number)
5078 error (_("Unable to read in dynamic data\n"));
5082 i_data = (int *) malloc (number * sizeof (* i_data));
5086 error (_("Out of memory\n"));
5092 i_data [number] = byte_get (e_data + number * 4, 4);
5099 /* Dump the symbol table */
5101 process_symbol_table (file)
5104 Elf32_Internal_Shdr * section;
5105 unsigned char nb [4];
5106 unsigned char nc [4];
5109 int * buckets = NULL;
5110 int * chains = NULL;
5112 if (! do_syms && !do_histogram)
5115 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5118 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
5120 error (_("Unable to seek to start of dynamic information"));
5124 if (fread (nb, sizeof (nb), 1, file) != 1)
5126 error (_("Failed to read in number of buckets\n"));
5130 if (fread (nc, sizeof (nc), 1, file) != 1)
5132 error (_("Failed to read in number of chains\n"));
5136 nbuckets = byte_get (nb, 4);
5137 nchains = byte_get (nc, 4);
5139 buckets = get_dynamic_data (file, nbuckets);
5140 chains = get_dynamic_data (file, nchains);
5142 if (buckets == NULL || chains == NULL)
5147 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5152 printf (_("\nSymbol table for image:\n"));
5154 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5156 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5158 for (hn = 0; hn < nbuckets; hn++)
5163 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
5165 Elf_Internal_Sym * psym;
5167 psym = dynamic_symbols + si;
5169 printf (" %3d %3d: ", si, hn);
5170 print_vma (psym->st_value, LONG_HEX);
5172 print_vma (psym->st_size, DEC_5);
5174 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5175 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5176 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5177 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
5178 printf (" %s\n", dynamic_strings + psym->st_name);
5182 else if (do_syms && !do_using_dynamic)
5186 for (i = 0, section = section_headers;
5187 i < elf_header.e_shnum;
5192 Elf_Internal_Sym * symtab;
5193 Elf_Internal_Sym * psym;
5196 if ( section->sh_type != SHT_SYMTAB
5197 && section->sh_type != SHT_DYNSYM)
5200 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5201 SECTION_NAME (section),
5202 (unsigned long) (section->sh_size / section->sh_entsize));
5204 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5206 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5208 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
5209 section->sh_size / section->sh_entsize);
5213 if (section->sh_link == elf_header.e_shstrndx)
5214 strtab = string_table;
5217 Elf32_Internal_Shdr * string_sec;
5219 string_sec = section_headers + section->sh_link;
5221 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5222 string_sec->sh_size,
5226 for (si = 0, psym = symtab;
5227 si < section->sh_size / section->sh_entsize;
5230 printf ("%6d: ", si);
5231 print_vma (psym->st_value, LONG_HEX);
5233 print_vma (psym->st_size, DEC_5);
5234 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5235 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5236 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5237 printf (" %4s", get_symbol_index_type (psym->st_shndx));
5238 printf (" %s", strtab + psym->st_name);
5240 if (section->sh_type == SHT_DYNSYM &&
5241 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5243 unsigned char data[2];
5244 unsigned short vers_data;
5245 unsigned long offset;
5249 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
5252 get_data (&data, file, offset + si * sizeof (vers_data),
5253 sizeof (data), _("version data"));
5255 vers_data = byte_get (data, 2);
5257 is_nobits = psym->st_shndx < SHN_LORESERVE ?
5258 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
5261 check_def = (psym->st_shndx != SHN_UNDEF);
5263 if ((vers_data & 0x8000) || vers_data > 1)
5265 if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5266 && (is_nobits || ! check_def))
5268 Elf_External_Verneed evn;
5269 Elf_Internal_Verneed ivn;
5270 Elf_Internal_Vernaux ivna;
5272 /* We must test both. */
5273 offset = version_info
5274 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
5278 unsigned long vna_off;
5280 get_data (&evn, file, offset, sizeof (evn),
5283 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5284 ivn.vn_next = BYTE_GET (evn.vn_next);
5286 vna_off = offset + ivn.vn_aux;
5290 Elf_External_Vernaux evna;
5292 get_data (&evna, file, vna_off,
5294 _("version need aux (3)"));
5296 ivna.vna_other = BYTE_GET (evna.vna_other);
5297 ivna.vna_next = BYTE_GET (evna.vna_next);
5298 ivna.vna_name = BYTE_GET (evna.vna_name);
5300 vna_off += ivna.vna_next;
5302 while (ivna.vna_other != vers_data
5303 && ivna.vna_next != 0);
5305 if (ivna.vna_other == vers_data)
5308 offset += ivn.vn_next;
5310 while (ivn.vn_next != 0);
5312 if (ivna.vna_other == vers_data)
5315 strtab + ivna.vna_name, ivna.vna_other);
5318 else if (! is_nobits)
5319 error (_("bad dynamic symbol"));
5326 if (vers_data != 0x8001
5327 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5329 Elf_Internal_Verdef ivd;
5330 Elf_Internal_Verdaux ivda;
5331 Elf_External_Verdaux evda;
5332 unsigned long offset;
5335 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5340 Elf_External_Verdef evd;
5342 get_data (&evd, file, offset, sizeof (evd),
5345 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5346 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5347 ivd.vd_next = BYTE_GET (evd.vd_next);
5349 offset += ivd.vd_next;
5351 while (ivd.vd_ndx != (vers_data & 0x7fff)
5352 && ivd.vd_next != 0);
5354 offset -= ivd.vd_next;
5355 offset += ivd.vd_aux;
5357 get_data (&evda, file, offset, sizeof (evda),
5358 _("version def aux"));
5360 ivda.vda_name = BYTE_GET (evda.vda_name);
5362 if (psym->st_name != ivda.vda_name)
5363 printf ((vers_data & 0x8000)
5365 strtab + ivda.vda_name);
5375 if (strtab != string_table)
5381 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5383 if (do_histogram && buckets != NULL)
5390 int nzero_counts = 0;
5393 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5395 printf (_(" Length Number %% of total Coverage\n"));
5397 lengths = (int *) calloc (nbuckets, sizeof (int));
5398 if (lengths == NULL)
5400 error (_("Out of memory"));
5403 for (hn = 0; hn < nbuckets; ++hn)
5408 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5411 if (maxlength < ++lengths[hn])
5416 counts = (int *) calloc (maxlength + 1, sizeof (int));
5419 error (_("Out of memory"));
5423 for (hn = 0; hn < nbuckets; ++hn)
5424 ++ counts [lengths [hn]];
5428 printf (" 0 %-10d (%5.1f%%)\n",
5429 counts[0], (counts[0] * 100.0) / nbuckets);
5430 for (si = 1; si <= maxlength; ++si)
5432 nzero_counts += counts[si] * si;
5433 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5434 si, counts[si], (counts[si] * 100.0) / nbuckets,
5435 (nzero_counts * 100.0) / nsyms);
5443 if (buckets != NULL)
5453 process_syminfo (file)
5454 FILE * file ATTRIBUTE_UNUSED;
5458 if (dynamic_syminfo == NULL
5460 /* No syminfo, this is ok. */
5463 /* There better should be a dynamic symbol section. */
5464 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5468 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5469 dynamic_syminfo_offset, dynamic_syminfo_nent);
5471 printf (_(" Num: Name BoundTo Flags\n"));
5472 for (i = 0; i < dynamic_syminfo_nent; ++i)
5474 unsigned short int flags = dynamic_syminfo[i].si_flags;
5476 printf ("%4d: %-30s ", i,
5477 dynamic_strings + dynamic_symbols[i].st_name);
5479 switch (dynamic_syminfo[i].si_boundto)
5481 case SYMINFO_BT_SELF:
5482 fputs ("SELF ", stdout);
5484 case SYMINFO_BT_PARENT:
5485 fputs ("PARENT ", stdout);
5488 if (dynamic_syminfo[i].si_boundto > 0
5489 && dynamic_syminfo[i].si_boundto < dynamic_size)
5492 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
5494 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5498 if (flags & SYMINFO_FLG_DIRECT)
5500 if (flags & SYMINFO_FLG_PASSTHRU)
5501 printf (" PASSTHRU");
5502 if (flags & SYMINFO_FLG_COPY)
5504 if (flags & SYMINFO_FLG_LAZYLOAD)
5505 printf (" LAZYLOAD");
5513 #ifdef SUPPORT_DISASSEMBLY
5515 disassemble_section (section, file)
5516 Elf32_Internal_Shdr * section;
5519 printf (_("\nAssembly dump of section %s\n"),
5520 SECTION_NAME (section));
5522 /* XXX -- to be done --- XXX */
5529 dump_section (section, file)
5530 Elf32_Internal_Shdr * section;
5533 bfd_size_type bytes;
5535 unsigned char * data;
5536 unsigned char * start;
5538 bytes = section->sh_size;
5542 printf (_("\nSection '%s' has no data to dump.\n"),
5543 SECTION_NAME (section));
5547 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5549 addr = section->sh_addr;
5551 start = (unsigned char *) get_data (NULL, file, section->sh_offset, bytes,
5564 lbytes = (bytes > 16 ? 16 : bytes);
5566 printf (" 0x%8.8lx ", (unsigned long) addr);
5568 switch (elf_header.e_ident [EI_DATA])
5572 for (j = 15; j >= 0; j --)
5575 printf ("%2.2x", data [j]);
5585 for (j = 0; j < 16; j++)
5588 printf ("%2.2x", data [j]);
5598 for (j = 0; j < lbytes; j++)
5601 if (k >= ' ' && k < 0x80)
5620 static unsigned long int
5621 read_leb128 (data, length_return, sign)
5622 unsigned char * data;
5623 int * length_return;
5626 unsigned long int result = 0;
5627 unsigned int num_read = 0;
5636 result |= (byte & 0x7f) << shift;
5641 while (byte & 0x80);
5643 if (length_return != NULL)
5644 * length_return = num_read;
5646 if (sign && (shift < 32) && (byte & 0x40))
5647 result |= -1 << shift;
5652 typedef struct State_Machine_Registers
5654 unsigned long address;
5657 unsigned int column;
5661 /* This variable hold the number of the last entry seen
5662 in the File Table. */
5663 unsigned int last_file_entry;
5666 static SMR state_machine_regs;
5669 reset_state_machine (is_stmt)
5672 state_machine_regs.address = 0;
5673 state_machine_regs.file = 1;
5674 state_machine_regs.line = 1;
5675 state_machine_regs.column = 0;
5676 state_machine_regs.is_stmt = is_stmt;
5677 state_machine_regs.basic_block = 0;
5678 state_machine_regs.end_sequence = 0;
5679 state_machine_regs.last_file_entry = 0;
5682 /* Handled an extend line op. Returns true if this is the end
5685 process_extended_line_op (data, is_stmt, pointer_size)
5686 unsigned char * data;
5690 unsigned char op_code;
5693 unsigned char * name;
5696 len = read_leb128 (data, & bytes_read, 0);
5701 warn (_("badly formed extended line op encountered!"));
5706 op_code = * data ++;
5708 printf (_(" Extended opcode %d: "), op_code);
5712 case DW_LNE_end_sequence:
5713 printf (_("End of Sequence\n\n"));
5714 reset_state_machine (is_stmt);
5717 case DW_LNE_set_address:
5718 adr = byte_get (data, pointer_size);
5719 printf (_("set Address to 0x%lx\n"), adr);
5720 state_machine_regs.address = adr;
5723 case DW_LNE_define_file:
5724 printf (_(" define new File Table entry\n"));
5725 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5727 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5729 data += strlen ((char *) data) + 1;
5730 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5732 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5734 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5735 printf (_("%s\n\n"), name);
5739 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5746 /* Size of pointers in the .debug_line section. This information is not
5747 really present in that section. It's obtained before dumping the debug
5748 sections by doing some pre-scan of the .debug_info section. */
5749 static int debug_line_pointer_size = 4;
5752 display_debug_lines (section, start, file)
5753 Elf32_Internal_Shdr * section;
5754 unsigned char * start;
5755 FILE * file ATTRIBUTE_UNUSED;
5757 DWARF2_External_LineInfo * external;
5758 DWARF2_Internal_LineInfo info;
5759 unsigned char * standard_opcodes;
5760 unsigned char * data = start;
5761 unsigned char * end = start + section->sh_size;
5762 unsigned char * end_of_sequence;
5765 printf (_("\nDump of debug contents of section %s:\n\n"),
5766 SECTION_NAME (section));
5770 external = (DWARF2_External_LineInfo *) data;
5772 /* Check the length of the block. */
5773 info.li_length = BYTE_GET (external->li_length);
5775 if (info.li_length == 0xffffffff)
5777 warn (_("64-bit DWARF line info is not supported yet.\n"));
5781 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5784 (_("The line info appears to be corrupt - the section is too small\n"));
5788 /* Check its version number. */
5789 info.li_version = BYTE_GET (external->li_version);
5790 if (info.li_version != 2)
5792 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5796 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5797 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5798 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5799 info.li_line_base = BYTE_GET (external->li_line_base);
5800 info.li_line_range = BYTE_GET (external->li_line_range);
5801 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5803 /* Sign extend the line base field. */
5804 info.li_line_base <<= 24;
5805 info.li_line_base >>= 24;
5807 printf (_(" Length: %ld\n"), info.li_length);
5808 printf (_(" DWARF Version: %d\n"), info.li_version);
5809 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
5810 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5811 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5812 printf (_(" Line Base: %d\n"), info.li_line_base);
5813 printf (_(" Line Range: %d\n"), info.li_line_range);
5814 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5816 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5818 reset_state_machine (info.li_default_is_stmt);
5820 /* Display the contents of the Opcodes table. */
5821 standard_opcodes = data + sizeof (* external);
5823 printf (_("\n Opcodes:\n"));
5825 for (i = 1; i < info.li_opcode_base; i++)
5826 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5828 /* Display the contents of the Directory table. */
5829 data = standard_opcodes + info.li_opcode_base - 1;
5832 printf (_("\n The Directory Table is empty.\n"));
5835 printf (_("\n The Directory Table:\n"));
5839 printf (_(" %s\n"), data);
5841 data += strlen ((char *) data) + 1;
5845 /* Skip the NUL at the end of the table. */
5848 /* Display the contents of the File Name table. */
5850 printf (_("\n The File Name Table is empty.\n"));
5853 printf (_("\n The File Name Table:\n"));
5854 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5858 unsigned char * name;
5861 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5864 data += strlen ((char *) data) + 1;
5866 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5868 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5870 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5872 printf (_("%s\n"), name);
5876 /* Skip the NUL at the end of the table. */
5879 /* Now display the statements. */
5880 printf (_("\n Line Number Statements:\n"));
5883 while (data < end_of_sequence)
5885 unsigned char op_code;
5889 op_code = * data ++;
5893 case DW_LNS_extended_op:
5894 data += process_extended_line_op (data, info.li_default_is_stmt,
5895 debug_line_pointer_size);
5899 printf (_(" Copy\n"));
5902 case DW_LNS_advance_pc:
5903 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5905 state_machine_regs.address += adv;
5906 printf (_(" Advance PC by %d to %lx\n"), adv,
5907 state_machine_regs.address);
5910 case DW_LNS_advance_line:
5911 adv = read_leb128 (data, & bytes_read, 1);
5913 state_machine_regs.line += adv;
5914 printf (_(" Advance Line by %d to %d\n"), adv,
5915 state_machine_regs.line);
5918 case DW_LNS_set_file:
5919 adv = read_leb128 (data, & bytes_read, 0);
5921 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5923 state_machine_regs.file = adv;
5926 case DW_LNS_set_column:
5927 adv = read_leb128 (data, & bytes_read, 0);
5929 printf (_(" Set column to %d\n"), adv);
5930 state_machine_regs.column = adv;
5933 case DW_LNS_negate_stmt:
5934 adv = state_machine_regs.is_stmt;
5936 printf (_(" Set is_stmt to %d\n"), adv);
5937 state_machine_regs.is_stmt = adv;
5940 case DW_LNS_set_basic_block:
5941 printf (_(" Set basic block\n"));
5942 state_machine_regs.basic_block = 1;
5945 case DW_LNS_const_add_pc:
5946 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5947 * info.li_min_insn_length);
5948 state_machine_regs.address += adv;
5949 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5950 state_machine_regs.address);
5953 case DW_LNS_fixed_advance_pc:
5954 adv = byte_get (data, 2);
5956 state_machine_regs.address += adv;
5957 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5958 adv, state_machine_regs.address);
5962 op_code -= info.li_opcode_base;
5963 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5964 state_machine_regs.address += adv;
5965 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5966 op_code, adv, state_machine_regs.address);
5967 adv = (op_code % info.li_line_range) + info.li_line_base;
5968 state_machine_regs.line += adv;
5969 printf (_(" and Line by %d to %d\n"),
5970 adv, state_machine_regs.line);
5981 display_debug_pubnames (section, start, file)
5982 Elf32_Internal_Shdr * section;
5983 unsigned char * start;
5984 FILE * file ATTRIBUTE_UNUSED;
5986 DWARF2_External_PubNames * external;
5987 DWARF2_Internal_PubNames pubnames;
5988 unsigned char * end;
5990 end = start + section->sh_size;
5992 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5996 unsigned char * data;
5997 unsigned long offset;
5999 external = (DWARF2_External_PubNames *) start;
6001 pubnames.pn_length = BYTE_GET (external->pn_length);
6002 pubnames.pn_version = BYTE_GET (external->pn_version);
6003 pubnames.pn_offset = BYTE_GET (external->pn_offset);
6004 pubnames.pn_size = BYTE_GET (external->pn_size);
6006 data = start + sizeof (* external);
6007 start += pubnames.pn_length + sizeof (external->pn_length);
6009 if (pubnames.pn_length == 0xffffffff)
6011 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6015 if (pubnames.pn_version != 2)
6017 static int warned = 0;
6021 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6028 printf (_(" Length: %ld\n"),
6029 pubnames.pn_length);
6030 printf (_(" Version: %d\n"),
6031 pubnames.pn_version);
6032 printf (_(" Offset into .debug_info section: %ld\n"),
6033 pubnames.pn_offset);
6034 printf (_(" Size of area in .debug_info section: %ld\n"),
6037 printf (_("\n Offset\tName\n"));
6041 offset = byte_get (data, 4);
6046 printf (" %ld\t\t%s\n", offset, data);
6047 data += strlen ((char *) data) + 1;
6050 while (offset != 0);
6063 case DW_TAG_padding: return "DW_TAG_padding";
6064 case DW_TAG_array_type: return "DW_TAG_array_type";
6065 case DW_TAG_class_type: return "DW_TAG_class_type";
6066 case DW_TAG_entry_point: return "DW_TAG_entry_point";
6067 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
6068 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
6069 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
6070 case DW_TAG_label: return "DW_TAG_label";
6071 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
6072 case DW_TAG_member: return "DW_TAG_member";
6073 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
6074 case DW_TAG_reference_type: return "DW_TAG_reference_type";
6075 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
6076 case DW_TAG_string_type: return "DW_TAG_string_type";
6077 case DW_TAG_structure_type: return "DW_TAG_structure_type";
6078 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
6079 case DW_TAG_typedef: return "DW_TAG_typedef";
6080 case DW_TAG_union_type: return "DW_TAG_union_type";
6081 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6082 case DW_TAG_variant: return "DW_TAG_variant";
6083 case DW_TAG_common_block: return "DW_TAG_common_block";
6084 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
6085 case DW_TAG_inheritance: return "DW_TAG_inheritance";
6086 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
6087 case DW_TAG_module: return "DW_TAG_module";
6088 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
6089 case DW_TAG_set_type: return "DW_TAG_set_type";
6090 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
6091 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
6092 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
6093 case DW_TAG_base_type: return "DW_TAG_base_type";
6094 case DW_TAG_catch_block: return "DW_TAG_catch_block";
6095 case DW_TAG_const_type: return "DW_TAG_const_type";
6096 case DW_TAG_constant: return "DW_TAG_constant";
6097 case DW_TAG_enumerator: return "DW_TAG_enumerator";
6098 case DW_TAG_file_type: return "DW_TAG_file_type";
6099 case DW_TAG_friend: return "DW_TAG_friend";
6100 case DW_TAG_namelist: return "DW_TAG_namelist";
6101 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
6102 case DW_TAG_packed_type: return "DW_TAG_packed_type";
6103 case DW_TAG_subprogram: return "DW_TAG_subprogram";
6104 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
6105 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
6106 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
6107 case DW_TAG_try_block: return "DW_TAG_try_block";
6108 case DW_TAG_variant_part: return "DW_TAG_variant_part";
6109 case DW_TAG_variable: return "DW_TAG_variable";
6110 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
6111 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
6112 case DW_TAG_format_label: return "DW_TAG_format_label";
6113 case DW_TAG_function_template: return "DW_TAG_function_template";
6114 case DW_TAG_class_template: return "DW_TAG_class_template";
6115 /* DWARF 2.1 values. */
6116 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
6117 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
6118 case DW_TAG_interface_type: return "DW_TAG_interface_type";
6119 case DW_TAG_namespace: return "DW_TAG_namespace";
6120 case DW_TAG_imported_module: return "DW_TAG_imported_module";
6121 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
6122 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
6123 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
6126 static char buffer [100];
6128 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6135 get_AT_name (attribute)
6136 unsigned long attribute;
6140 case DW_AT_sibling: return "DW_AT_sibling";
6141 case DW_AT_location: return "DW_AT_location";
6142 case DW_AT_name: return "DW_AT_name";
6143 case DW_AT_ordering: return "DW_AT_ordering";
6144 case DW_AT_subscr_data: return "DW_AT_subscr_data";
6145 case DW_AT_byte_size: return "DW_AT_byte_size";
6146 case DW_AT_bit_offset: return "DW_AT_bit_offset";
6147 case DW_AT_bit_size: return "DW_AT_bit_size";
6148 case DW_AT_element_list: return "DW_AT_element_list";
6149 case DW_AT_stmt_list: return "DW_AT_stmt_list";
6150 case DW_AT_low_pc: return "DW_AT_low_pc";
6151 case DW_AT_high_pc: return "DW_AT_high_pc";
6152 case DW_AT_language: return "DW_AT_language";
6153 case DW_AT_member: return "DW_AT_member";
6154 case DW_AT_discr: return "DW_AT_discr";
6155 case DW_AT_discr_value: return "DW_AT_discr_value";
6156 case DW_AT_visibility: return "DW_AT_visibility";
6157 case DW_AT_import: return "DW_AT_import";
6158 case DW_AT_string_length: return "DW_AT_string_length";
6159 case DW_AT_common_reference: return "DW_AT_common_reference";
6160 case DW_AT_comp_dir: return "DW_AT_comp_dir";
6161 case DW_AT_const_value: return "DW_AT_const_value";
6162 case DW_AT_containing_type: return "DW_AT_containing_type";
6163 case DW_AT_default_value: return "DW_AT_default_value";
6164 case DW_AT_inline: return "DW_AT_inline";
6165 case DW_AT_is_optional: return "DW_AT_is_optional";
6166 case DW_AT_lower_bound: return "DW_AT_lower_bound";
6167 case DW_AT_producer: return "DW_AT_producer";
6168 case DW_AT_prototyped: return "DW_AT_prototyped";
6169 case DW_AT_return_addr: return "DW_AT_return_addr";
6170 case DW_AT_start_scope: return "DW_AT_start_scope";
6171 case DW_AT_stride_size: return "DW_AT_stride_size";
6172 case DW_AT_upper_bound: return "DW_AT_upper_bound";
6173 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
6174 case DW_AT_accessibility: return "DW_AT_accessibility";
6175 case DW_AT_address_class: return "DW_AT_address_class";
6176 case DW_AT_artificial: return "DW_AT_artificial";
6177 case DW_AT_base_types: return "DW_AT_base_types";
6178 case DW_AT_calling_convention: return "DW_AT_calling_convention";
6179 case DW_AT_count: return "DW_AT_count";
6180 case DW_AT_data_member_location: return "DW_AT_data_member_location";
6181 case DW_AT_decl_column: return "DW_AT_decl_column";
6182 case DW_AT_decl_file: return "DW_AT_decl_file";
6183 case DW_AT_decl_line: return "DW_AT_decl_line";
6184 case DW_AT_declaration: return "DW_AT_declaration";
6185 case DW_AT_discr_list: return "DW_AT_discr_list";
6186 case DW_AT_encoding: return "DW_AT_encoding";
6187 case DW_AT_external: return "DW_AT_external";
6188 case DW_AT_frame_base: return "DW_AT_frame_base";
6189 case DW_AT_friend: return "DW_AT_friend";
6190 case DW_AT_identifier_case: return "DW_AT_identifier_case";
6191 case DW_AT_macro_info: return "DW_AT_macro_info";
6192 case DW_AT_namelist_items: return "DW_AT_namelist_items";
6193 case DW_AT_priority: return "DW_AT_priority";
6194 case DW_AT_segment: return "DW_AT_segment";
6195 case DW_AT_specification: return "DW_AT_specification";
6196 case DW_AT_static_link: return "DW_AT_static_link";
6197 case DW_AT_type: return "DW_AT_type";
6198 case DW_AT_use_location: return "DW_AT_use_location";
6199 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
6200 case DW_AT_virtuality: return "DW_AT_virtuality";
6201 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6202 /* DWARF 2.1 values. */
6203 case DW_AT_allocated: return "DW_AT_allocated";
6204 case DW_AT_associated: return "DW_AT_associated";
6205 case DW_AT_data_location: return "DW_AT_data_location";
6206 case DW_AT_stride: return "DW_AT_stride";
6207 case DW_AT_entry_pc: return "DW_AT_entry_pc";
6208 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
6209 case DW_AT_extension: return "DW_AT_extension";
6210 case DW_AT_ranges: return "DW_AT_ranges";
6211 case DW_AT_trampoline: return "DW_AT_trampoline";
6212 case DW_AT_call_column: return "DW_AT_call_column";
6213 case DW_AT_call_file: return "DW_AT_call_file";
6214 case DW_AT_call_line: return "DW_AT_call_line";
6215 /* SGI/MIPS extensions. */
6216 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
6217 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
6218 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6219 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
6220 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6221 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
6222 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
6223 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
6224 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
6225 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
6226 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
6227 /* GNU extensions. */
6228 case DW_AT_sf_names: return "DW_AT_sf_names";
6229 case DW_AT_src_info: return "DW_AT_src_info";
6230 case DW_AT_mac_info: return "DW_AT_mac_info";
6231 case DW_AT_src_coords: return "DW_AT_src_coords";
6232 case DW_AT_body_begin: return "DW_AT_body_begin";
6233 case DW_AT_body_end: return "DW_AT_body_end";
6236 static char buffer [100];
6238 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6245 get_FORM_name (form)
6250 case DW_FORM_addr: return "DW_FORM_addr";
6251 case DW_FORM_block2: return "DW_FORM_block2";
6252 case DW_FORM_block4: return "DW_FORM_block4";
6253 case DW_FORM_data2: return "DW_FORM_data2";
6254 case DW_FORM_data4: return "DW_FORM_data4";
6255 case DW_FORM_data8: return "DW_FORM_data8";
6256 case DW_FORM_string: return "DW_FORM_string";
6257 case DW_FORM_block: return "DW_FORM_block";
6258 case DW_FORM_block1: return "DW_FORM_block1";
6259 case DW_FORM_data1: return "DW_FORM_data1";
6260 case DW_FORM_flag: return "DW_FORM_flag";
6261 case DW_FORM_sdata: return "DW_FORM_sdata";
6262 case DW_FORM_strp: return "DW_FORM_strp";
6263 case DW_FORM_udata: return "DW_FORM_udata";
6264 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
6265 case DW_FORM_ref1: return "DW_FORM_ref1";
6266 case DW_FORM_ref2: return "DW_FORM_ref2";
6267 case DW_FORM_ref4: return "DW_FORM_ref4";
6268 case DW_FORM_ref8: return "DW_FORM_ref8";
6269 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6270 case DW_FORM_indirect: return "DW_FORM_indirect";
6273 static char buffer [100];
6275 sprintf (buffer, _("Unknown FORM value: %lx"), form);
6281 static const char *debug_str;
6282 static bfd_vma debug_str_size;
6284 /* FIXME: There are better and more effiecint ways to handle
6285 these structures. For now though, I just want something that
6286 is simple to implement. */
6287 typedef struct abbrev_attr
6289 unsigned long attribute;
6291 struct abbrev_attr * next;
6295 typedef struct abbrev_entry
6297 unsigned long entry;
6300 struct abbrev_attr * first_attr;
6301 struct abbrev_attr * last_attr;
6302 struct abbrev_entry * next;
6306 static abbrev_entry * first_abbrev = NULL;
6307 static abbrev_entry * last_abbrev = NULL;
6310 free_abbrevs PARAMS ((void))
6312 abbrev_entry * abbrev;
6314 for (abbrev = first_abbrev; abbrev;)
6316 abbrev_entry * next = abbrev->next;
6319 for (attr = abbrev->first_attr; attr;)
6321 abbrev_attr * next = attr->next;
6331 last_abbrev = first_abbrev = NULL;
6335 add_abbrev (number, tag, children)
6336 unsigned long number;
6340 abbrev_entry * entry;
6342 entry = (abbrev_entry *) malloc (sizeof (* entry));
6348 entry->entry = number;
6350 entry->children = children;
6351 entry->first_attr = NULL;
6352 entry->last_attr = NULL;
6355 if (first_abbrev == NULL)
6356 first_abbrev = entry;
6358 last_abbrev->next = entry;
6360 last_abbrev = entry;
6364 add_abbrev_attr (attribute, form)
6365 unsigned long attribute;
6370 attr = (abbrev_attr *) malloc (sizeof (* attr));
6376 attr->attribute = attribute;
6380 if (last_abbrev->first_attr == NULL)
6381 last_abbrev->first_attr = attr;
6383 last_abbrev->last_attr->next = attr;
6385 last_abbrev->last_attr = attr;
6388 /* Processes the (partial) contents of a .debug_abbrev section.
6389 Returns NULL if the end of the section was encountered.
6390 Returns the address after the last byte read if the end of
6391 an abbreviation set was found. */
6393 static unsigned char *
6394 process_abbrev_section (start, end)
6395 unsigned char * start;
6396 unsigned char * end;
6398 if (first_abbrev != NULL)
6404 unsigned long entry;
6406 unsigned long attribute;
6409 entry = read_leb128 (start, & bytes_read, 0);
6410 start += bytes_read;
6412 /* A single zero is supposed to end the section according
6413 to the standard. If there's more, then signal that to
6416 return start == end ? NULL : start;
6418 tag = read_leb128 (start, & bytes_read, 0);
6419 start += bytes_read;
6421 children = * start ++;
6423 add_abbrev (entry, tag, children);
6429 attribute = read_leb128 (start, & bytes_read, 0);
6430 start += bytes_read;
6432 form = read_leb128 (start, & bytes_read, 0);
6433 start += bytes_read;
6436 add_abbrev_attr (attribute, form);
6438 while (attribute != 0);
6446 display_debug_macinfo (section, start, file)
6447 Elf32_Internal_Shdr * section;
6448 unsigned char * start;
6449 FILE * file ATTRIBUTE_UNUSED;
6451 unsigned char * end = start + section->sh_size;
6452 unsigned char * curr = start;
6453 unsigned int bytes_read;
6454 enum dwarf_macinfo_record_type op;
6456 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6460 unsigned int lineno;
6461 const char * string;
6468 case DW_MACINFO_start_file:
6470 unsigned int filenum;
6472 lineno = read_leb128 (curr, & bytes_read, 0);
6474 filenum = read_leb128 (curr, & bytes_read, 0);
6477 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
6481 case DW_MACINFO_end_file:
6482 printf (_(" DW_MACINFO_end_file\n"));
6485 case DW_MACINFO_define:
6486 lineno = read_leb128 (curr, & bytes_read, 0);
6489 curr += strlen (string) + 1;
6490 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
6493 case DW_MACINFO_undef:
6494 lineno = read_leb128 (curr, & bytes_read, 0);
6497 curr += strlen (string) + 1;
6498 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
6501 case DW_MACINFO_vendor_ext:
6503 unsigned int constant;
6505 constant = read_leb128 (curr, & bytes_read, 0);
6508 curr += strlen (string) + 1;
6509 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
6520 display_debug_abbrev (section, start, file)
6521 Elf32_Internal_Shdr * section;
6522 unsigned char * start;
6523 FILE * file ATTRIBUTE_UNUSED;
6525 abbrev_entry * entry;
6526 unsigned char * end = start + section->sh_size;
6528 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6532 start = process_abbrev_section (start, end);
6534 if (first_abbrev == NULL)
6537 printf (_(" Number TAG\n"));
6539 for (entry = first_abbrev; entry; entry = entry->next)
6543 printf (_(" %ld %s [%s]\n"),
6545 get_TAG_name (entry->tag),
6546 entry->children ? _("has children") : _("no children"));
6548 for (attr = entry->first_attr; attr; attr = attr->next)
6550 printf (_(" %-18s %s\n"),
6551 get_AT_name (attr->attribute),
6552 get_FORM_name (attr->form));
6566 static unsigned char *
6567 display_block (data, length)
6568 unsigned char * data;
6569 unsigned long length;
6571 printf (_(" %lu byte block: "), length);
6574 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6580 decode_location_expression (data, pointer_size, length)
6581 unsigned char * data;
6582 unsigned int pointer_size;
6583 unsigned long length;
6587 unsigned long uvalue;
6588 unsigned char * end = data + length;
6597 printf ("DW_OP_addr: %lx",
6598 (unsigned long) byte_get (data, pointer_size));
6599 data += pointer_size;
6602 printf ("DW_OP_deref");
6605 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6608 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6611 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6615 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6619 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6623 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6627 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6628 (unsigned long) byte_get (data + 4, 4));
6632 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6633 (long) byte_get (data + 4, 4));
6637 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6641 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6645 printf ("DW_OP_dup");
6648 printf ("DW_OP_drop");
6651 printf ("DW_OP_over");
6654 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6657 printf ("DW_OP_swap");
6660 printf ("DW_OP_rot");
6663 printf ("DW_OP_xderef");
6666 printf ("DW_OP_abs");
6669 printf ("DW_OP_and");
6672 printf ("DW_OP_div");
6675 printf ("DW_OP_minus");
6678 printf ("DW_OP_mod");
6681 printf ("DW_OP_mul");
6684 printf ("DW_OP_neg");
6687 printf ("DW_OP_not");
6690 printf ("DW_OP_or");
6693 printf ("DW_OP_plus");
6695 case DW_OP_plus_uconst:
6696 printf ("DW_OP_plus_uconst: %lu",
6697 read_leb128 (data, &bytes_read, 0));
6701 printf ("DW_OP_shl");
6704 printf ("DW_OP_shr");
6707 printf ("DW_OP_shra");
6710 printf ("DW_OP_xor");
6713 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
6717 printf ("DW_OP_eq");
6720 printf ("DW_OP_ge");
6723 printf ("DW_OP_gt");
6726 printf ("DW_OP_le");
6729 printf ("DW_OP_lt");
6732 printf ("DW_OP_ne");
6735 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
6771 printf ("DW_OP_lit%d", op - DW_OP_lit0);
6806 printf ("DW_OP_reg%d", op - DW_OP_reg0);
6841 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
6842 read_leb128 (data, &bytes_read, 1));
6847 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6851 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6855 uvalue = read_leb128 (data, &bytes_read, 0);
6857 printf ("DW_OP_bregx: %lu %ld", uvalue,
6858 read_leb128 (data, &bytes_read, 1));
6862 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6865 case DW_OP_deref_size:
6866 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6868 case DW_OP_xderef_size:
6869 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6872 printf ("DW_OP_nop");
6875 /* DWARF 2.1 extensions. */
6876 case DW_OP_push_object_address:
6877 printf ("DW_OP_push_object_address");
6880 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
6884 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
6888 printf ("DW_OP_calli");
6892 if (op >= DW_OP_lo_user
6893 && op <= DW_OP_hi_user)
6894 printf (_("(User defined location op)"));
6896 printf (_("(Unknown location op)"));
6897 /* No way to tell where the next op is, so just bail. */
6901 /* Separate the ops. */
6907 static unsigned char *
6908 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6909 unsigned long attribute;
6911 unsigned char * data;
6912 unsigned long cu_offset;
6913 unsigned long pointer_size;
6915 unsigned long uvalue = 0;
6916 unsigned char * block_start = NULL;
6919 printf (" %-18s:", get_AT_name (attribute));
6926 case DW_FORM_ref_addr:
6928 uvalue = byte_get (data, pointer_size);
6929 data += pointer_size;
6933 uvalue = byte_get (data, /* offset_size */ 4);
6934 data += /* offset_size */ 4;
6940 uvalue = byte_get (data ++, 1);
6945 uvalue = byte_get (data, 2);
6951 uvalue = byte_get (data, 4);
6956 uvalue = read_leb128 (data, & bytes_read, 1);
6960 case DW_FORM_ref_udata:
6962 uvalue = read_leb128 (data, & bytes_read, 0);
6969 case DW_FORM_ref_addr:
6970 printf (" <#%lx>", uvalue);
6976 case DW_FORM_ref_udata:
6977 printf (" <%lx>", uvalue + cu_offset);
6981 printf (" %#lx", uvalue);
6989 printf (" %ld", uvalue);
6994 uvalue = byte_get (data, 4);
6995 printf (" %lx", uvalue);
6996 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
7000 case DW_FORM_string:
7001 printf (" %s", data);
7002 data += strlen ((char *) data) + 1;
7006 uvalue = read_leb128 (data, & bytes_read, 0);
7007 block_start = data + bytes_read;
7008 data = display_block (block_start, uvalue);
7011 case DW_FORM_block1:
7012 uvalue = byte_get (data, 1);
7013 block_start = data + 1;
7014 data = display_block (block_start, uvalue);
7017 case DW_FORM_block2:
7018 uvalue = byte_get (data, 2);
7019 block_start = data + 2;
7020 data = display_block (block_start, uvalue);
7023 case DW_FORM_block4:
7024 uvalue = byte_get (data, 4);
7025 block_start = data + 4;
7026 data = display_block (block_start, uvalue);
7030 if (debug_str == NULL)
7031 warn (_("DW_FORM_strp used but no .debug_str section"));
7032 else if (uvalue >= debug_str_size)
7033 warn (_("DW_FORM_strp %lx points outside of .debug_str section"),
7036 printf (" %s", debug_str + uvalue);
7039 case DW_FORM_indirect:
7040 warn (_("Unable to handle FORM: %d"), form);
7044 warn (_("Unrecognised form: %d"), form);
7048 /* For some attributes we can display futher information. */
7057 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
7058 case DW_INL_inlined: printf (_("(inlined)")); break;
7059 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
7060 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
7061 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
7065 case DW_AT_language:
7068 case DW_LANG_C: printf ("(non-ANSI C)"); break;
7069 case DW_LANG_C89: printf ("(ANSI C)"); break;
7070 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
7071 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
7072 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
7073 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
7074 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
7075 case DW_LANG_Ada83: printf ("(Ada)"); break;
7076 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
7077 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
7078 /* DWARF 2.1 values. */
7079 case DW_LANG_C99: printf ("(ANSI C99)"); break;
7080 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
7081 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
7082 /* MIPS extension. */
7083 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7084 default: printf ("(Unknown: %lx)", uvalue); break;
7088 case DW_AT_encoding:
7091 case DW_ATE_void: printf ("(void)"); break;
7092 case DW_ATE_address: printf ("(machine address)"); break;
7093 case DW_ATE_boolean: printf ("(boolean)"); break;
7094 case DW_ATE_complex_float: printf ("(complex float)"); break;
7095 case DW_ATE_float: printf ("(float)"); break;
7096 case DW_ATE_signed: printf ("(signed)"); break;
7097 case DW_ATE_signed_char: printf ("(signed char)"); break;
7098 case DW_ATE_unsigned: printf ("(unsigned)"); break;
7099 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
7100 /* DWARF 2.1 value. */
7101 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7103 if (uvalue >= DW_ATE_lo_user
7104 && uvalue <= DW_ATE_hi_user)
7105 printf ("(user defined type)");
7107 printf ("(unknown type)");
7112 case DW_AT_accessibility:
7115 case DW_ACCESS_public: printf ("(public)"); break;
7116 case DW_ACCESS_protected: printf ("(protected)"); break;
7117 case DW_ACCESS_private: printf ("(private)"); break;
7118 default: printf ("(unknown accessibility)"); break;
7122 case DW_AT_visibility:
7125 case DW_VIS_local: printf ("(local)"); break;
7126 case DW_VIS_exported: printf ("(exported)"); break;
7127 case DW_VIS_qualified: printf ("(qualified)"); break;
7128 default: printf ("(unknown visibility)"); break;
7132 case DW_AT_virtuality:
7135 case DW_VIRTUALITY_none: printf ("(none)"); break;
7136 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
7137 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
7138 default: printf ("(unknown virtuality)"); break;
7142 case DW_AT_identifier_case:
7145 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
7146 case DW_ID_up_case: printf ("(up_case)"); break;
7147 case DW_ID_down_case: printf ("(down_case)"); break;
7148 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
7149 default: printf ("(unknown case)"); break;
7153 case DW_AT_calling_convention:
7156 case DW_CC_normal: printf ("(normal)"); break;
7157 case DW_CC_program: printf ("(program)"); break;
7158 case DW_CC_nocall: printf ("(nocall)"); break;
7160 if (uvalue >= DW_CC_lo_user
7161 && uvalue <= DW_CC_hi_user)
7162 printf ("(user defined)");
7164 printf ("(unknown convention)");
7168 case DW_AT_ordering:
7171 case -1: printf ("(undefined)"); break;
7172 case 0: printf ("(row major)"); break;
7173 case 1: printf ("(column major)"); break;
7177 case DW_AT_frame_base:
7178 case DW_AT_location:
7179 case DW_AT_data_member_location:
7180 case DW_AT_vtable_elem_location:
7181 case DW_AT_allocated:
7182 case DW_AT_associated:
7183 case DW_AT_data_location:
7185 case DW_AT_upper_bound:
7186 case DW_AT_lower_bound:
7190 decode_location_expression (block_start, pointer_size, uvalue);
7204 display_debug_info (section, start, file)
7205 Elf32_Internal_Shdr * section;
7206 unsigned char * start;
7209 unsigned char * end = start + section->sh_size;
7210 unsigned char * section_begin = start;
7212 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7215 Elf32_Internal_Shdr * sec;
7218 /* Locate the .debug_str section and read it. */
7219 for (i = 0, sec = section_headers;
7220 i < elf_header.e_shnum;
7222 if (strcmp (SECTION_NAME (sec), ".debug_str") == 0 && sec->sh_size != 0)
7224 debug_str = (const char *)
7225 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7226 _("debug_str section data"));
7227 debug_str_size = sec->sh_size;
7234 DWARF2_External_CompUnit * external;
7235 DWARF2_Internal_CompUnit compunit;
7236 Elf32_Internal_Shdr * relsec;
7237 unsigned char * tags;
7240 unsigned long cu_offset;
7242 external = (DWARF2_External_CompUnit *) start;
7244 compunit.cu_length = BYTE_GET (external->cu_length);
7245 compunit.cu_version = BYTE_GET (external->cu_version);
7246 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
7247 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
7249 if (compunit.cu_length == 0xffffffff)
7251 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7255 /* Check for RELA relocations in the abbrev_offset address, and
7257 for (relsec = section_headers;
7258 relsec < section_headers + elf_header.e_shnum;
7261 unsigned long nrelas, nsyms;
7262 Elf_Internal_Rela *rela, *rp;
7263 Elf32_Internal_Shdr *symsec;
7264 Elf_Internal_Sym *symtab;
7265 Elf_Internal_Sym *sym;
7267 if (relsec->sh_type != SHT_RELA
7268 || section_headers + relsec->sh_info != section)
7271 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7275 symsec = section_headers + relsec->sh_link;
7276 nsyms = symsec->sh_size / symsec->sh_entsize;
7277 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
7279 for (rp = rela; rp < rela + nrelas; ++rp)
7282 != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
7288 sym = symtab + ELF32_R_SYM (rp->r_info);
7290 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
7292 warn (_("Skipping unexpected symbol type %u"),
7293 ELF32_ST_TYPE (sym->st_info));
7299 sym = symtab + ELF64_R_SYM (rp->r_info);
7301 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
7303 warn (_("Skipping unexpected symbol type %u"),
7304 ELF64_ST_TYPE (sym->st_info));
7309 compunit.cu_abbrev_offset += rp->r_addend;
7317 tags = start + sizeof (* external);
7318 cu_offset = start - section_begin;
7319 start += compunit.cu_length + sizeof (external->cu_length);
7321 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
7322 printf (_(" Length: %ld\n"), compunit.cu_length);
7323 printf (_(" Version: %d\n"), compunit.cu_version);
7324 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
7325 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
7327 if (compunit.cu_version != 2)
7329 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7333 if (first_abbrev != NULL)
7336 /* Read in the abbrevs used by this compilation unit. */
7339 Elf32_Internal_Shdr * sec;
7340 unsigned char * begin;
7342 /* Locate the .debug_abbrev section and process it. */
7343 for (i = 0, sec = section_headers;
7344 i < elf_header.e_shnum;
7346 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
7349 if (i == elf_header.e_shnum || sec->sh_size == 0)
7351 warn (_("Unable to locate .debug_abbrev section!\n"));
7355 begin = ((unsigned char *)
7356 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7357 _("debug_abbrev section data")));
7361 process_abbrev_section (begin + compunit.cu_abbrev_offset,
7362 begin + sec->sh_size);
7368 while (tags < start)
7371 unsigned long abbrev_number;
7372 abbrev_entry * entry;
7375 abbrev_number = read_leb128 (tags, & bytes_read, 0);
7378 /* A null DIE marks the end of a list of children. */
7379 if (abbrev_number == 0)
7385 /* Scan through the abbreviation list until we reach the
7387 for (entry = first_abbrev;
7388 entry && entry->entry != abbrev_number;
7389 entry = entry->next)
7394 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7399 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7401 (unsigned long) (tags - section_begin - bytes_read),
7403 get_TAG_name (entry->tag));
7405 for (attr = entry->first_attr; attr; attr = attr->next)
7406 tags = read_and_display_attr (attr->attribute,
7409 compunit.cu_pointer_size);
7411 if (entry->children)
7416 if (debug_str != NULL)
7418 free ((char *) debug_str);
7428 display_debug_aranges (section, start, file)
7429 Elf32_Internal_Shdr * section;
7430 unsigned char * start;
7431 FILE * file ATTRIBUTE_UNUSED;
7433 unsigned char * end = start + section->sh_size;
7435 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7439 DWARF2_External_ARange * external;
7440 DWARF2_Internal_ARange arange;
7441 unsigned char * ranges;
7442 unsigned long length;
7443 unsigned long address;
7446 external = (DWARF2_External_ARange *) start;
7448 arange.ar_length = BYTE_GET (external->ar_length);
7449 arange.ar_version = BYTE_GET (external->ar_version);
7450 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
7451 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
7452 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
7454 if (arange.ar_length == 0xffffffff)
7456 warn (_("64-bit DWARF aranges are not supported yet.\n"));
7460 if (arange.ar_version != 2)
7462 warn (_("Only DWARF 2 aranges are currently supported.\n"));
7466 printf (_(" Length: %ld\n"), arange.ar_length);
7467 printf (_(" Version: %d\n"), arange.ar_version);
7468 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
7469 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
7470 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
7472 printf (_("\n Address Length\n"));
7474 ranges = start + sizeof (* external);
7476 /* Must pad to an alignment boundary that is twice the pointer size. */
7477 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
7479 ranges += (2 * arange.ar_pointer_size) - excess;
7483 address = byte_get (ranges, arange.ar_pointer_size);
7485 ranges += arange.ar_pointer_size;
7487 length = byte_get (ranges, arange.ar_pointer_size);
7489 ranges += arange.ar_pointer_size;
7491 /* A pair of zeros marks the end of the list. */
7492 if (address == 0 && length == 0)
7495 printf (" %8.8lx %lu\n", address, length);
7498 start += arange.ar_length + sizeof (external->ar_length);
7506 typedef struct Frame_Chunk
7508 struct Frame_Chunk * next;
7509 unsigned char * chunk_start;
7511 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7512 short int * col_type;
7514 char * augmentation;
7515 unsigned int code_factor;
7517 unsigned long pc_begin;
7518 unsigned long pc_range;
7522 unsigned char fde_encoding;
7526 /* A marker for a col_type that means this column was never referenced
7527 in the frame info. */
7528 #define DW_CFA_unreferenced (-1)
7530 static void frame_need_space PARAMS ((Frame_Chunk *, int));
7531 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
7532 static int size_of_encoded_value PARAMS ((int));
7535 frame_need_space (fc, reg)
7539 int prev = fc->ncols;
7541 if (reg < fc->ncols)
7544 fc->ncols = reg + 1;
7545 fc->col_type = (short int *) xrealloc (fc->col_type,
7546 fc->ncols * sizeof (short int));
7547 fc->col_offset = (int *) xrealloc (fc->col_offset,
7548 fc->ncols * sizeof (int));
7550 while (prev < fc->ncols)
7552 fc->col_type[prev] = DW_CFA_unreferenced;
7553 fc->col_offset[prev] = 0;
7559 frame_display_row (fc, need_col_headers, max_regs)
7561 int * need_col_headers;
7567 if (* max_regs < fc->ncols)
7568 * max_regs = fc->ncols;
7570 if (* need_col_headers)
7572 * need_col_headers = 0;
7574 printf (" LOC CFA ");
7576 for (r = 0; r < * max_regs; r++)
7577 if (fc->col_type[r] != DW_CFA_unreferenced)
7582 printf ("r%-4d", r);
7588 printf ("%08lx ", fc->pc_begin);
7589 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
7590 printf ("%-8s ", tmp);
7592 for (r = 0; r < fc->ncols; r++)
7594 if (fc->col_type[r] != DW_CFA_unreferenced)
7596 switch (fc->col_type[r])
7598 case DW_CFA_undefined:
7601 case DW_CFA_same_value:
7605 sprintf (tmp, "c%+d", fc->col_offset[r]);
7607 case DW_CFA_register:
7608 sprintf (tmp, "r%d", fc->col_offset[r]);
7611 strcpy (tmp, "n/a");
7614 printf ("%-5s", tmp);
7621 size_of_encoded_value (encoding)
7624 switch (encoding & 0x7)
7627 case 0: return is_32bit_elf ? 4 : 8;
7634 #define GET(N) byte_get (start, N); start += N
7635 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
7636 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
7639 display_debug_frames (section, start, file)
7640 Elf32_Internal_Shdr * section;
7641 unsigned char * start;
7642 FILE * file ATTRIBUTE_UNUSED;
7644 unsigned char * end = start + section->sh_size;
7645 unsigned char * section_start = start;
7646 Frame_Chunk * chunks = 0;
7647 Frame_Chunk * remembered_state = 0;
7649 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
7652 int addr_size = is_32bit_elf ? 4 : 8;
7654 printf (_("The section %s contains:\n"), SECTION_NAME (section));
7658 unsigned char * saved_start;
7659 unsigned char * block_end;
7660 unsigned long length;
7661 unsigned long cie_id;
7664 int need_col_headers = 1;
7665 unsigned char * augmentation_data = NULL;
7666 unsigned long augmentation_data_len = 0;
7667 int encoded_ptr_size = addr_size;
7669 saved_start = start;
7670 length = byte_get (start, 4); start += 4;
7675 if (length == 0xffffffff)
7677 warn (_("64-bit DWARF format frames are not supported yet.\n"));
7681 block_end = saved_start + length + 4;
7682 cie_id = byte_get (start, 4); start += 4;
7684 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
7688 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7689 memset (fc, 0, sizeof (Frame_Chunk));
7693 fc->chunk_start = saved_start;
7695 fc->col_type = (short int *) xmalloc (sizeof (short int));
7696 fc->col_offset = (int *) xmalloc (sizeof (int));
7697 frame_need_space (fc, max_regs-1);
7701 fc->augmentation = start;
7702 start = strchr (start, '\0') + 1;
7704 if (fc->augmentation[0] == 'z')
7706 fc->code_factor = LEB ();
7707 fc->data_factor = SLEB ();
7708 fc->ra = byte_get (start, 1); start += 1;
7709 augmentation_data_len = LEB ();
7710 augmentation_data = start;
7711 start += augmentation_data_len;
7713 else if (strcmp (fc->augmentation, "eh") == 0)
7716 fc->code_factor = LEB ();
7717 fc->data_factor = SLEB ();
7718 fc->ra = byte_get (start, 1); start += 1;
7722 fc->code_factor = LEB ();
7723 fc->data_factor = SLEB ();
7724 fc->ra = byte_get (start, 1); start += 1;
7728 if (do_debug_frames_interp)
7729 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
7730 (unsigned long)(saved_start - section_start), length, cie_id,
7731 fc->augmentation, fc->code_factor, fc->data_factor,
7735 printf ("\n%08lx %08lx %08lx CIE\n",
7736 (unsigned long)(saved_start - section_start), length, cie_id);
7737 printf (" Version: %d\n", version);
7738 printf (" Augmentation: \"%s\"\n", fc->augmentation);
7739 printf (" Code alignment factor: %u\n", fc->code_factor);
7740 printf (" Data alignment factor: %d\n", fc->data_factor);
7741 printf (" Return address column: %d\n", fc->ra);
7743 if (augmentation_data_len)
7746 printf (" Augmentation data: ");
7747 for (i = 0; i < augmentation_data_len; ++i)
7748 printf (" %02x", augmentation_data[i]);
7754 if (augmentation_data_len)
7756 unsigned char *p, *q;
7757 p = fc->augmentation + 1;
7758 q = augmentation_data;
7765 q += 1 + size_of_encoded_value (*q);
7767 fc->fde_encoding = *q++;
7773 if (fc->fde_encoding)
7774 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7777 frame_need_space (fc, fc->ra);
7781 unsigned char * look_for;
7782 static Frame_Chunk fde_fc;
7785 memset (fc, 0, sizeof (Frame_Chunk));
7787 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
7789 for (cie = chunks; cie ; cie = cie->next)
7790 if (cie->chunk_start == look_for)
7795 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
7796 cie_id, saved_start);
7799 fc->col_type = (short int *) xmalloc (sizeof (short int));
7800 fc->col_offset = (int *) xmalloc (sizeof (int));
7801 frame_need_space (fc, max_regs - 1);
7803 fc->augmentation = "";
7804 fc->fde_encoding = 0;
7808 fc->ncols = cie->ncols;
7809 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
7810 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
7811 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7812 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7813 fc->augmentation = cie->augmentation;
7814 fc->code_factor = cie->code_factor;
7815 fc->data_factor = cie->data_factor;
7816 fc->cfa_reg = cie->cfa_reg;
7817 fc->cfa_offset = cie->cfa_offset;
7819 frame_need_space (fc, max_regs-1);
7820 fc->fde_encoding = cie->fde_encoding;
7823 if (fc->fde_encoding)
7824 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
7826 fc->pc_begin = byte_get (start, encoded_ptr_size);
7827 start += encoded_ptr_size;
7828 fc->pc_range = byte_get (start, encoded_ptr_size);
7829 start += encoded_ptr_size;
7831 if (cie->augmentation[0] == 'z')
7833 augmentation_data_len = LEB ();
7834 augmentation_data = start;
7835 start += augmentation_data_len;
7838 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
7839 (unsigned long)(saved_start - section_start), length, cie_id,
7840 (unsigned long)(cie->chunk_start - section_start),
7841 fc->pc_begin, fc->pc_begin + fc->pc_range);
7842 if (! do_debug_frames_interp && augmentation_data_len)
7845 printf (" Augmentation data: ");
7846 for (i = 0; i < augmentation_data_len; ++i)
7847 printf (" %02x", augmentation_data[i]);
7853 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7854 about to interpret instructions for the chunk. */
7856 if (do_debug_frames_interp)
7858 /* Start by making a pass over the chunk, allocating storage
7859 and taking note of what registers are used. */
7860 unsigned char * tmp = start;
7862 while (start < block_end)
7872 /* Warning: if you add any more cases to this switch, be
7873 sure to add them to the corresponding switch below. */
7876 case DW_CFA_advance_loc:
7880 frame_need_space (fc, opa);
7881 fc->col_type[opa] = DW_CFA_undefined;
7883 case DW_CFA_restore:
7884 frame_need_space (fc, opa);
7885 fc->col_type[opa] = DW_CFA_undefined;
7887 case DW_CFA_set_loc:
7888 start += encoded_ptr_size;
7890 case DW_CFA_advance_loc1:
7893 case DW_CFA_advance_loc2:
7896 case DW_CFA_advance_loc4:
7899 case DW_CFA_offset_extended:
7900 reg = LEB (); LEB ();
7901 frame_need_space (fc, reg);
7902 fc->col_type[reg] = DW_CFA_undefined;
7904 case DW_CFA_restore_extended:
7906 frame_need_space (fc, reg);
7907 fc->col_type[reg] = DW_CFA_undefined;
7909 case DW_CFA_undefined:
7911 frame_need_space (fc, reg);
7912 fc->col_type[reg] = DW_CFA_undefined;
7914 case DW_CFA_same_value:
7916 frame_need_space (fc, reg);
7917 fc->col_type[reg] = DW_CFA_undefined;
7919 case DW_CFA_register:
7920 reg = LEB (); LEB ();
7921 frame_need_space (fc, reg);
7922 fc->col_type[reg] = DW_CFA_undefined;
7924 case DW_CFA_def_cfa:
7927 case DW_CFA_def_cfa_register:
7930 case DW_CFA_def_cfa_offset:
7933 #ifndef DW_CFA_GNU_args_size
7934 #define DW_CFA_GNU_args_size 0x2e
7936 case DW_CFA_GNU_args_size:
7939 #ifndef DW_CFA_GNU_negative_offset_extended
7940 #define DW_CFA_GNU_negative_offset_extended 0x2f
7942 case DW_CFA_GNU_negative_offset_extended:
7943 reg = LEB (); LEB ();
7944 frame_need_space (fc, reg);
7945 fc->col_type[reg] = DW_CFA_undefined;
7954 /* Now we know what registers are used, make a second pass over
7955 the chunk, this time actually printing out the info. */
7957 while (start < block_end)
7960 unsigned long ul, reg, roffs;
7969 /* Warning: if you add any more cases to this switch, be
7970 sure to add them to the corresponding switch above. */
7973 case DW_CFA_advance_loc:
7974 if (do_debug_frames_interp)
7975 frame_display_row (fc, &need_col_headers, &max_regs);
7977 printf (" DW_CFA_advance_loc: %d to %08lx\n",
7978 opa * fc->code_factor,
7979 fc->pc_begin + opa * fc->code_factor);
7980 fc->pc_begin += opa * fc->code_factor;
7985 if (! do_debug_frames_interp)
7986 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
7987 opa, roffs * fc->data_factor);
7988 fc->col_type[opa] = DW_CFA_offset;
7989 fc->col_offset[opa] = roffs * fc->data_factor;
7992 case DW_CFA_restore:
7993 if (! do_debug_frames_interp)
7994 printf (" DW_CFA_restore: r%d\n", opa);
7995 fc->col_type[opa] = cie->col_type[opa];
7996 fc->col_offset[opa] = cie->col_offset[opa];
7999 case DW_CFA_set_loc:
8000 vma = byte_get (start, encoded_ptr_size);
8001 start += encoded_ptr_size;
8002 if (do_debug_frames_interp)
8003 frame_display_row (fc, &need_col_headers, &max_regs);
8005 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
8009 case DW_CFA_advance_loc1:
8010 ofs = byte_get (start, 1); start += 1;
8011 if (do_debug_frames_interp)
8012 frame_display_row (fc, &need_col_headers, &max_regs);
8014 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8015 ofs * fc->code_factor,
8016 fc->pc_begin + ofs * fc->code_factor);
8017 fc->pc_begin += ofs * fc->code_factor;
8020 case DW_CFA_advance_loc2:
8021 ofs = byte_get (start, 2); start += 2;
8022 if (do_debug_frames_interp)
8023 frame_display_row (fc, &need_col_headers, &max_regs);
8025 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8026 ofs * fc->code_factor,
8027 fc->pc_begin + ofs * fc->code_factor);
8028 fc->pc_begin += ofs * fc->code_factor;
8031 case DW_CFA_advance_loc4:
8032 ofs = byte_get (start, 4); start += 4;
8033 if (do_debug_frames_interp)
8034 frame_display_row (fc, &need_col_headers, &max_regs);
8036 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8037 ofs * fc->code_factor,
8038 fc->pc_begin + ofs * fc->code_factor);
8039 fc->pc_begin += ofs * fc->code_factor;
8042 case DW_CFA_offset_extended:
8045 if (! do_debug_frames_interp)
8046 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8047 reg, roffs * fc->data_factor);
8048 fc->col_type[reg] = DW_CFA_offset;
8049 fc->col_offset[reg] = roffs * fc->data_factor;
8052 case DW_CFA_restore_extended:
8054 if (! do_debug_frames_interp)
8055 printf (" DW_CFA_restore_extended: r%ld\n", reg);
8056 fc->col_type[reg] = cie->col_type[reg];
8057 fc->col_offset[reg] = cie->col_offset[reg];
8060 case DW_CFA_undefined:
8062 if (! do_debug_frames_interp)
8063 printf (" DW_CFA_undefined: r%ld\n", reg);
8064 fc->col_type[reg] = DW_CFA_undefined;
8065 fc->col_offset[reg] = 0;
8068 case DW_CFA_same_value:
8070 if (! do_debug_frames_interp)
8071 printf (" DW_CFA_same_value: r%ld\n", reg);
8072 fc->col_type[reg] = DW_CFA_same_value;
8073 fc->col_offset[reg] = 0;
8076 case DW_CFA_register:
8079 if (! do_debug_frames_interp)
8080 printf (" DW_CFA_register: r%ld\n", reg);
8081 fc->col_type[reg] = DW_CFA_register;
8082 fc->col_offset[reg] = roffs;
8085 case DW_CFA_remember_state:
8086 if (! do_debug_frames_interp)
8087 printf (" DW_CFA_remember_state\n");
8088 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8089 rs->ncols = fc->ncols;
8090 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8091 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8092 memcpy (rs->col_type, fc->col_type, rs->ncols);
8093 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8094 rs->next = remembered_state;
8095 remembered_state = rs;
8098 case DW_CFA_restore_state:
8099 if (! do_debug_frames_interp)
8100 printf (" DW_CFA_restore_state\n");
8101 rs = remembered_state;
8102 remembered_state = rs->next;
8103 frame_need_space (fc, rs->ncols-1);
8104 memcpy (fc->col_type, rs->col_type, rs->ncols);
8105 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8106 free (rs->col_type);
8107 free (rs->col_offset);
8111 case DW_CFA_def_cfa:
8112 fc->cfa_reg = LEB ();
8113 fc->cfa_offset = LEB ();
8114 if (! do_debug_frames_interp)
8115 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8116 fc->cfa_reg, fc->cfa_offset);
8119 case DW_CFA_def_cfa_register:
8120 fc->cfa_reg = LEB ();
8121 if (! do_debug_frames_interp)
8122 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
8125 case DW_CFA_def_cfa_offset:
8126 fc->cfa_offset = LEB ();
8127 if (! do_debug_frames_interp)
8128 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
8132 if (! do_debug_frames_interp)
8133 printf (" DW_CFA_nop\n");
8136 #ifndef DW_CFA_GNU_window_save
8137 #define DW_CFA_GNU_window_save 0x2d
8139 case DW_CFA_GNU_window_save:
8140 if (! do_debug_frames_interp)
8141 printf (" DW_CFA_GNU_window_save\n");
8144 case DW_CFA_GNU_args_size:
8146 if (! do_debug_frames_interp)
8147 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
8150 case DW_CFA_GNU_negative_offset_extended:
8153 frame_need_space (fc, reg);
8154 if (! do_debug_frames_interp)
8155 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8156 reg, l * fc->data_factor);
8157 fc->col_type[reg] = DW_CFA_offset;
8158 fc->col_offset[reg] = l * fc->data_factor;
8162 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
8167 if (do_debug_frames_interp)
8168 frame_display_row (fc, &need_col_headers, &max_regs);
8183 display_debug_not_supported (section, start, file)
8184 Elf32_Internal_Shdr * section;
8185 unsigned char * start ATTRIBUTE_UNUSED;
8186 FILE * file ATTRIBUTE_UNUSED;
8188 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8189 SECTION_NAME (section));
8194 /* Pre-scan the .debug_info section to record the size of address.
8195 When dumping the .debug_line, we use that size information, assuming
8196 that all compilation units have the same address size. */
8198 prescan_debug_info (section, start, file)
8199 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
8200 unsigned char * start;
8201 FILE * file ATTRIBUTE_UNUSED;
8203 DWARF2_External_CompUnit * external;
8205 external = (DWARF2_External_CompUnit *) start;
8207 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
8211 /* A structure containing the name of a debug section and a pointer
8212 to a function that can decode it. The third field is a prescan
8213 function to be run over the section before displaying any of the
8218 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8219 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8223 { ".debug_info", display_debug_info, prescan_debug_info },
8224 { ".debug_abbrev", display_debug_abbrev, NULL },
8225 { ".debug_line", display_debug_lines, NULL },
8226 { ".debug_aranges", display_debug_aranges, NULL },
8227 { ".debug_pubnames", display_debug_pubnames, NULL },
8228 { ".debug_frame", display_debug_frames, NULL },
8229 { ".eh_frame", display_debug_frames, NULL },
8230 { ".debug_macinfo", display_debug_macinfo, NULL },
8231 { ".debug_pubtypes", display_debug_not_supported, NULL },
8232 { ".debug_str", display_debug_not_supported, NULL },
8233 { ".debug_static_func", display_debug_not_supported, NULL },
8234 { ".debug_static_vars", display_debug_not_supported, NULL },
8235 { ".debug_types", display_debug_not_supported, NULL },
8236 { ".debug_weaknames", display_debug_not_supported, NULL }
8240 display_debug_section (section, file)
8241 Elf32_Internal_Shdr * section;
8244 char * name = SECTION_NAME (section);
8245 bfd_size_type length;
8246 unsigned char * start;
8249 length = section->sh_size;
8252 printf (_("\nSection '%s' has no debugging data.\n"), name);
8256 start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
8257 _("debug section data"));
8261 /* See if we know how to display the contents of this section. */
8262 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
8263 name = ".debug_info";
8265 for (i = NUM_ELEM (debug_displays); i--;)
8266 if (strcmp (debug_displays[i].name, name) == 0)
8268 debug_displays[i].display (section, start, file);
8273 printf (_("Unrecognised debug section: %s\n"), name);
8277 /* If we loaded in the abbrev section at some point,
8278 we must release it here. */
8279 if (first_abbrev != NULL)
8286 process_section_contents (file)
8289 Elf32_Internal_Shdr * section;
8295 /* Pre-scan the debug sections to find some debug information not
8296 present in some of them. For the .debug_line, we must find out the
8297 size of address (specified in .debug_info and .debug_aranges). */
8298 for (i = 0, section = section_headers;
8299 i < elf_header.e_shnum && i < num_dump_sects;
8302 char * name = SECTION_NAME (section);
8305 if (section->sh_size == 0)
8308 /* See if there is some pre-scan operation for this section. */
8309 for (j = NUM_ELEM (debug_displays); j--;)
8310 if (strcmp (debug_displays[j].name, name) == 0)
8312 if (debug_displays[j].prescan != NULL)
8314 bfd_size_type length;
8315 unsigned char * start;
8317 length = section->sh_size;
8318 start = ((unsigned char *)
8319 get_data (NULL, file, section->sh_offset, length,
8320 _("debug section data")));
8324 debug_displays[j].prescan (section, start, file);
8332 for (i = 0, section = section_headers;
8333 i < elf_header.e_shnum && i < num_dump_sects;
8336 #ifdef SUPPORT_DISASSEMBLY
8337 if (dump_sects[i] & DISASS_DUMP)
8338 disassemble_section (section, file);
8340 if (dump_sects[i] & HEX_DUMP)
8341 dump_section (section, file);
8343 if (dump_sects[i] & DEBUG_DUMP)
8344 display_debug_section (section, file);
8347 if (i < num_dump_sects)
8348 warn (_("Some sections were not dumped because they do not exist!\n"));
8354 process_mips_fpe_exception (mask)
8360 if (mask & OEX_FPU_INEX)
8361 fputs ("INEX", stdout), first = 0;
8362 if (mask & OEX_FPU_UFLO)
8363 printf ("%sUFLO", first ? "" : "|"), first = 0;
8364 if (mask & OEX_FPU_OFLO)
8365 printf ("%sOFLO", first ? "" : "|"), first = 0;
8366 if (mask & OEX_FPU_DIV0)
8367 printf ("%sDIV0", first ? "" : "|"), first = 0;
8368 if (mask & OEX_FPU_INVAL)
8369 printf ("%sINVAL", first ? "" : "|");
8372 fputs ("0", stdout);
8376 process_mips_specific (file)
8379 Elf_Internal_Dyn * entry;
8380 size_t liblist_offset = 0;
8381 size_t liblistno = 0;
8382 size_t conflictsno = 0;
8383 size_t options_offset = 0;
8384 size_t conflicts_offset = 0;
8386 /* We have a lot of special sections. Thanks SGI! */
8387 if (dynamic_segment == NULL)
8388 /* No information available. */
8391 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
8392 switch (entry->d_tag)
8394 case DT_MIPS_LIBLIST:
8395 liblist_offset = entry->d_un.d_val - loadaddr;
8397 case DT_MIPS_LIBLISTNO:
8398 liblistno = entry->d_un.d_val;
8400 case DT_MIPS_OPTIONS:
8401 options_offset = entry->d_un.d_val - loadaddr;
8403 case DT_MIPS_CONFLICT:
8404 conflicts_offset = entry->d_un.d_val - loadaddr;
8406 case DT_MIPS_CONFLICTNO:
8407 conflictsno = entry->d_un.d_val;
8413 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8415 Elf32_External_Lib * elib;
8418 elib = ((Elf32_External_Lib *)
8419 get_data (NULL, file, liblist_offset,
8420 liblistno * sizeof (Elf32_External_Lib),
8424 printf ("\nSection '.liblist' contains %lu entries:\n",
8425 (unsigned long) liblistno);
8426 fputs (" Library Time Stamp Checksum Version Flags\n",
8429 for (cnt = 0; cnt < liblistno; ++cnt)
8436 liblist.l_name = BYTE_GET (elib[cnt].l_name);
8437 time = BYTE_GET (elib[cnt].l_time_stamp);
8438 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8439 liblist.l_version = BYTE_GET (elib[cnt].l_version);
8440 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8442 tmp = gmtime (&time);
8443 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
8444 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8445 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8447 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
8448 dynamic_strings + liblist.l_name, timebuf,
8449 liblist.l_checksum, liblist.l_version);
8451 if (liblist.l_flags == 0)
8462 { " EXACT_MATCH", LL_EXACT_MATCH },
8463 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8464 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8465 { " EXPORTS", LL_EXPORTS },
8466 { " DELAY_LOAD", LL_DELAY_LOAD },
8467 { " DELTA", LL_DELTA }
8469 int flags = liblist.l_flags;
8473 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
8475 if ((flags & l_flags_vals[fcnt].bit) != 0)
8477 fputs (l_flags_vals[fcnt].name, stdout);
8478 flags ^= l_flags_vals[fcnt].bit;
8481 printf (" %#x", (unsigned int) flags);
8491 if (options_offset != 0)
8493 Elf_External_Options * eopt;
8494 Elf_Internal_Shdr * sect = section_headers;
8495 Elf_Internal_Options * iopt;
8496 Elf_Internal_Options * option;
8500 /* Find the section header so that we get the size. */
8501 while (sect->sh_type != SHT_MIPS_OPTIONS)
8504 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
8505 sect->sh_size, _("options"));
8508 iopt = ((Elf_Internal_Options *)
8509 malloc ((sect->sh_size / sizeof (eopt)) * sizeof (* iopt)));
8512 error (_("Out of memory"));
8519 while (offset < sect->sh_size)
8521 Elf_External_Options * eoption;
8523 eoption = (Elf_External_Options *) ((char *) eopt + offset);
8525 option->kind = BYTE_GET (eoption->kind);
8526 option->size = BYTE_GET (eoption->size);
8527 option->section = BYTE_GET (eoption->section);
8528 option->info = BYTE_GET (eoption->info);
8530 offset += option->size;
8536 printf (_("\nSection '%s' contains %d entries:\n"),
8537 SECTION_NAME (sect), cnt);
8545 switch (option->kind)
8548 /* This shouldn't happen. */
8549 printf (" NULL %d %lx", option->section, option->info);
8552 printf (" REGINFO ");
8553 if (elf_header.e_machine == EM_MIPS)
8556 Elf32_External_RegInfo * ereg;
8557 Elf32_RegInfo reginfo;
8559 ereg = (Elf32_External_RegInfo *) (option + 1);
8560 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8561 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8562 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8563 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8564 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8565 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
8567 printf ("GPR %08lx GP 0x%lx\n",
8569 (unsigned long) reginfo.ri_gp_value);
8570 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8571 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8572 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8577 Elf64_External_RegInfo * ereg;
8578 Elf64_Internal_RegInfo reginfo;
8580 ereg = (Elf64_External_RegInfo *) (option + 1);
8581 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8582 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8583 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8584 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8585 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8586 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
8588 printf ("GPR %08lx GP 0x",
8589 reginfo.ri_gprmask);
8590 printf_vma (reginfo.ri_gp_value);
8593 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8594 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8595 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8599 case ODK_EXCEPTIONS:
8600 fputs (" EXCEPTIONS fpe_min(", stdout);
8601 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
8602 fputs (") fpe_max(", stdout);
8603 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
8604 fputs (")", stdout);
8606 if (option->info & OEX_PAGE0)
8607 fputs (" PAGE0", stdout);
8608 if (option->info & OEX_SMM)
8609 fputs (" SMM", stdout);
8610 if (option->info & OEX_FPDBUG)
8611 fputs (" FPDBUG", stdout);
8612 if (option->info & OEX_DISMISS)
8613 fputs (" DISMISS", stdout);
8616 fputs (" PAD ", stdout);
8617 if (option->info & OPAD_PREFIX)
8618 fputs (" PREFIX", stdout);
8619 if (option->info & OPAD_POSTFIX)
8620 fputs (" POSTFIX", stdout);
8621 if (option->info & OPAD_SYMBOL)
8622 fputs (" SYMBOL", stdout);
8625 fputs (" HWPATCH ", stdout);
8626 if (option->info & OHW_R4KEOP)
8627 fputs (" R4KEOP", stdout);
8628 if (option->info & OHW_R8KPFETCH)
8629 fputs (" R8KPFETCH", stdout);
8630 if (option->info & OHW_R5KEOP)
8631 fputs (" R5KEOP", stdout);
8632 if (option->info & OHW_R5KCVTL)
8633 fputs (" R5KCVTL", stdout);
8636 fputs (" FILL ", stdout);
8637 /* XXX Print content of info word? */
8640 fputs (" TAGS ", stdout);
8641 /* XXX Print content of info word? */
8644 fputs (" HWAND ", stdout);
8645 if (option->info & OHWA0_R4KEOP_CHECKED)
8646 fputs (" R4KEOP_CHECKED", stdout);
8647 if (option->info & OHWA0_R4KEOP_CLEAN)
8648 fputs (" R4KEOP_CLEAN", stdout);
8651 fputs (" HWOR ", stdout);
8652 if (option->info & OHWA0_R4KEOP_CHECKED)
8653 fputs (" R4KEOP_CHECKED", stdout);
8654 if (option->info & OHWA0_R4KEOP_CLEAN)
8655 fputs (" R4KEOP_CLEAN", stdout);
8658 printf (" GP_GROUP %#06lx self-contained %#06lx",
8659 option->info & OGP_GROUP,
8660 (option->info & OGP_SELF) >> 16);
8663 printf (" IDENT %#06lx self-contained %#06lx",
8664 option->info & OGP_GROUP,
8665 (option->info & OGP_SELF) >> 16);
8668 /* This shouldn't happen. */
8669 printf (" %3d ??? %d %lx",
8670 option->kind, option->section, option->info);
8674 len = sizeof (* eopt);
8675 while (len < option->size)
8676 if (((char *) option)[len] >= ' '
8677 && ((char *) option)[len] < 0x7f)
8678 printf ("%c", ((char *) option)[len++]);
8680 printf ("\\%03o", ((char *) option)[len++]);
8682 fputs ("\n", stdout);
8690 if (conflicts_offset != 0 && conflictsno != 0)
8692 Elf32_Conflict * iconf;
8695 if (dynamic_symbols == NULL)
8697 error (_("conflict list with without table"));
8701 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
8704 error (_("Out of memory"));
8710 Elf32_External_Conflict * econf32;
8712 econf32 = ((Elf32_External_Conflict *)
8713 get_data (NULL, file, conflicts_offset,
8714 conflictsno * sizeof (* econf32),
8719 for (cnt = 0; cnt < conflictsno; ++cnt)
8720 iconf[cnt] = BYTE_GET (econf32[cnt]);
8726 Elf64_External_Conflict * econf64;
8728 econf64 = ((Elf64_External_Conflict *)
8729 get_data (NULL, file, conflicts_offset,
8730 conflictsno * sizeof (* econf64),
8735 for (cnt = 0; cnt < conflictsno; ++cnt)
8736 iconf[cnt] = BYTE_GET (econf64[cnt]);
8741 printf (_("\nSection '.conflict' contains %ld entries:\n"),
8742 (long) conflictsno);
8743 puts (_(" Num: Index Value Name"));
8745 for (cnt = 0; cnt < conflictsno; ++cnt)
8747 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
8749 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
8750 print_vma (psym->st_value, FULL_HEX);
8751 printf (" %s\n", dynamic_strings + psym->st_name);
8761 get_note_type (e_type)
8764 static char buff[64];
8768 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
8769 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
8770 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
8771 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
8772 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
8773 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
8774 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
8775 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
8776 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8777 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8778 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8780 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
8785 /* Note that by the ELF standard, the name field is already null byte
8786 terminated, and namesz includes the terminating null byte.
8787 I.E. the value of namesz for the name "FSF" is 4.
8789 If the value of namesz is zero, there is no name present. */
8791 process_note (pnote)
8792 Elf32_Internal_Note * pnote;
8794 printf (" %s\t\t0x%08lx\t%s\n",
8795 pnote->namesz ? pnote->namedata : "(NONE)",
8796 pnote->descsz, get_note_type (pnote->type));
8802 process_corefile_note_segment (file, offset, length)
8807 Elf_External_Note * pnotes;
8808 Elf_External_Note * external;
8814 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
8821 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8822 (unsigned long) offset, (unsigned long) length);
8823 printf (_(" Owner\t\tData size\tDescription\n"));
8825 while (external < (Elf_External_Note *)((char *) pnotes + length))
8827 Elf32_Internal_Note inote;
8830 inote.type = BYTE_GET (external->type);
8831 inote.namesz = BYTE_GET (external->namesz);
8832 inote.namedata = external->name;
8833 inote.descsz = BYTE_GET (external->descsz);
8834 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8835 inote.descpos = offset + (inote.descdata - (char *) pnotes);
8837 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8839 /* Verify that name is null terminated. It appears that at least
8840 one version of Linux (RedHat 6.0) generates corefiles that don't
8841 comply with the ELF spec by failing to include the null byte in
8843 if (inote.namedata[inote.namesz] != '\0')
8845 temp = malloc (inote.namesz + 1);
8849 error (_("Out of memory\n"));
8854 strncpy (temp, inote.namedata, inote.namesz);
8855 temp[inote.namesz] = 0;
8857 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8858 inote.namedata = temp;
8861 res &= process_note (& inote);
8876 process_corefile_note_segments (file)
8879 Elf_Internal_Phdr * program_headers;
8880 Elf_Internal_Phdr * segment;
8884 program_headers = (Elf_Internal_Phdr *) malloc
8885 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
8887 if (program_headers == NULL)
8889 error (_("Out of memory\n"));
8894 i = get_32bit_program_headers (file, program_headers);
8896 i = get_64bit_program_headers (file, program_headers);
8900 free (program_headers);
8904 for (i = 0, segment = program_headers;
8905 i < elf_header.e_phnum;
8908 if (segment->p_type == PT_NOTE)
8909 res &= process_corefile_note_segment (file,
8910 (bfd_vma) segment->p_offset,
8911 (bfd_vma) segment->p_filesz);
8914 free (program_headers);
8920 process_corefile_contents (file)
8923 /* If we have not been asked to display the notes then do nothing. */
8927 /* If file is not a core file then exit. */
8928 if (elf_header.e_type != ET_CORE)
8931 /* No program headers means no NOTE segment. */
8932 if (elf_header.e_phnum == 0)
8934 printf (_("No note segments present in the core file.\n"));
8938 return process_corefile_note_segments (file);
8942 process_arch_specific (file)
8948 switch (elf_header.e_machine)
8951 case EM_MIPS_RS3_LE:
8952 return process_mips_specific (file);
8961 get_file_header (file)
8964 /* Read in the identity array. */
8965 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8968 /* Determine how to read the rest of the header. */
8969 switch (elf_header.e_ident [EI_DATA])
8971 default: /* fall through */
8972 case ELFDATANONE: /* fall through */
8973 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
8974 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
8977 /* For now we only support 32 bit and 64 bit ELF files. */
8978 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
8980 /* Read in the rest of the header. */
8983 Elf32_External_Ehdr ehdr32;
8985 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8988 elf_header.e_type = BYTE_GET (ehdr32.e_type);
8989 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
8990 elf_header.e_version = BYTE_GET (ehdr32.e_version);
8991 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
8992 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
8993 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
8994 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
8995 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
8996 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8997 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
8998 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8999 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
9000 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
9004 Elf64_External_Ehdr ehdr64;
9006 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9007 we will not be able to cope with the 64bit data found in
9008 64 ELF files. Detect this now and abort before we start
9009 overwritting things. */
9010 if (sizeof (bfd_vma) < 8)
9012 error (_("This instance of readelf has been built without support for a\n"));
9013 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
9017 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
9020 elf_header.e_type = BYTE_GET (ehdr64.e_type);
9021 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
9022 elf_header.e_version = BYTE_GET (ehdr64.e_version);
9023 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
9024 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
9025 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
9026 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
9027 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
9028 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
9029 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
9030 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
9031 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
9032 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
9039 process_file (file_name)
9043 struct stat statbuf;
9046 if (stat (file_name, & statbuf) < 0)
9048 error (_("Cannot stat input file %s.\n"), file_name);
9052 file = fopen (file_name, "rb");
9055 error (_("Input file %s not found.\n"), file_name);
9059 if (! get_file_header (file))
9061 error (_("%s: Failed to read file header\n"), file_name);
9066 /* Initialise per file variables. */
9067 for (i = NUM_ELEM (version_info); i--;)
9068 version_info[i] = 0;
9070 for (i = NUM_ELEM (dynamic_info); i--;)
9071 dynamic_info[i] = 0;
9073 /* Process the file. */
9075 printf (_("\nFile: %s\n"), file_name);
9077 if (! process_file_header ())
9083 process_section_headers (file);
9085 process_program_headers (file);
9087 process_dynamic_segment (file);
9089 process_relocs (file);
9091 process_unwind (file);
9093 process_symbol_table (file);
9095 process_syminfo (file);
9097 process_version_sections (file);
9099 process_section_contents (file);
9101 process_corefile_contents (file);
9103 process_arch_specific (file);
9107 if (section_headers)
9109 free (section_headers);
9110 section_headers = NULL;
9115 free (string_table);
9116 string_table = NULL;
9117 string_table_length = 0;
9120 if (dynamic_strings)
9122 free (dynamic_strings);
9123 dynamic_strings = NULL;
9126 if (dynamic_symbols)
9128 free (dynamic_symbols);
9129 dynamic_symbols = NULL;
9130 num_dynamic_syms = 0;
9133 if (dynamic_syminfo)
9135 free (dynamic_syminfo);
9136 dynamic_syminfo = NULL;
9142 #ifdef SUPPORT_DISASSEMBLY
9143 /* Needed by the i386 disassembler. For extra credit, someone could
9144 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9148 print_address (unsigned int addr, FILE * outfile)
9150 fprintf (outfile,"0x%8.8x", addr);
9153 /* Needed by the i386 disassembler. */
9155 db_task_printsym (unsigned int addr)
9157 print_address (addr, stderr);
9161 int main PARAMS ((int, char **));
9170 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9171 setlocale (LC_MESSAGES, "");
9173 #if defined (HAVE_SETLOCALE)
9174 setlocale (LC_CTYPE, "");
9176 bindtextdomain (PACKAGE, LOCALEDIR);
9177 textdomain (PACKAGE);
9179 parse_args (argc, argv);
9181 if (optind < (argc - 1))
9185 while (optind < argc)
9186 err |= process_file (argv [optind ++]);
9188 if (dump_sects != NULL)