1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 99, 2000, 2001 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we belive that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
56 #include "elf/alpha.h"
59 #include "elf/sparc.h"
64 #include "elf/mn10200.h"
65 #include "elf/mn10300.h"
69 #include "elf/mcore.h"
76 #include "elf/x86-64.h"
82 char * program_name = "readelf";
83 unsigned int dynamic_addr;
84 bfd_size_type dynamic_size;
85 unsigned int rela_addr;
86 unsigned int rela_size;
87 char * dynamic_strings;
89 unsigned long string_table_length;
90 unsigned long num_dynamic_syms;
91 Elf_Internal_Sym * dynamic_symbols;
92 Elf_Internal_Syminfo * dynamic_syminfo;
93 unsigned long dynamic_syminfo_offset;
94 unsigned int dynamic_syminfo_nent;
95 char program_interpreter [64];
96 int dynamic_info[DT_JMPREL + 1];
99 Elf_Internal_Ehdr elf_header;
100 Elf_Internal_Shdr * section_headers;
101 Elf_Internal_Dyn * dynamic_segment;
109 int do_using_dynamic;
116 int do_debug_abbrevs;
118 int do_debug_pubnames;
119 int do_debug_aranges;
125 /* A dynamic array of flags indicating which sections require dumping. */
126 char * dump_sects = NULL;
127 unsigned int num_dump_sects = 0;
129 #define HEX_DUMP (1 << 0)
130 #define DISASS_DUMP (1 << 1)
131 #define DEBUG_DUMP (1 << 2)
133 /* How to rpint a vma value. */
134 typedef enum print_mode
146 /* Forward declarations for dumb compilers. */
147 static void print_vma PARAMS ((bfd_vma, print_mode));
148 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
149 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
150 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
151 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
152 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
153 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
154 static const char * get_dynamic_type PARAMS ((unsigned long));
155 static int slurp_rela_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **, unsigned long *));
156 static int slurp_rel_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel **, unsigned long *));
157 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
158 static char * get_file_type PARAMS ((unsigned));
159 static char * get_machine_name PARAMS ((unsigned));
160 static void decode_ARM_machine_flags PARAMS ((unsigned, char []));
161 static char * get_machine_flags PARAMS ((unsigned, unsigned));
162 static const char * get_mips_segment_type PARAMS ((unsigned long));
163 static const char * get_parisc_segment_type PARAMS ((unsigned long));
164 static const char * get_ia64_segment_type PARAMS ((unsigned long));
165 static const char * get_segment_type PARAMS ((unsigned long));
166 static const char * get_mips_section_type_name PARAMS ((unsigned int));
167 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
168 static const char * get_ia64_section_type_name PARAMS ((unsigned int));
169 static const char * get_section_type_name PARAMS ((unsigned int));
170 static const char * get_symbol_binding PARAMS ((unsigned int));
171 static const char * get_symbol_type PARAMS ((unsigned int));
172 static const char * get_symbol_visibility PARAMS ((unsigned int));
173 static const char * get_symbol_index_type PARAMS ((unsigned int));
174 static const char * get_dynamic_flags PARAMS ((bfd_vma));
175 static void usage PARAMS ((void));
176 static void parse_args PARAMS ((int, char **));
177 static int process_file_header PARAMS ((void));
178 static int process_program_headers PARAMS ((FILE *));
179 static int process_section_headers PARAMS ((FILE *));
180 static int process_unwind PARAMS ((FILE *));
181 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
182 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
183 static int process_dynamic_segment PARAMS ((FILE *));
184 static int process_symbol_table PARAMS ((FILE *));
185 static int process_section_contents PARAMS ((FILE *));
186 static void process_file PARAMS ((char *));
187 static int process_relocs PARAMS ((FILE *));
188 static int process_version_sections PARAMS ((FILE *));
189 static char * get_ver_flags PARAMS ((unsigned int));
190 static int get_32bit_section_headers PARAMS ((FILE *));
191 static int get_64bit_section_headers PARAMS ((FILE *));
192 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
193 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
194 static int get_file_header PARAMS ((FILE *));
195 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
196 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
197 static const char * get_elf_section_flags PARAMS ((bfd_vma));
198 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
199 static int get_32bit_dynamic_segment PARAMS ((FILE *));
200 static int get_64bit_dynamic_segment PARAMS ((FILE *));
201 #ifdef SUPPORT_DISASSEMBLY
202 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
204 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
205 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
206 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
207 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
208 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
209 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
210 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
211 static int display_debug_frames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
212 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
213 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
214 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
215 static void reset_state_machine PARAMS ((int));
216 static char * get_TAG_name PARAMS ((unsigned long));
217 static char * get_AT_name PARAMS ((unsigned long));
218 static char * get_FORM_name PARAMS ((unsigned long));
219 static void free_abbrevs PARAMS ((void));
220 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
221 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
222 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
223 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
224 static void decode_location_expression PARAMS ((unsigned char *, unsigned int, unsigned long));
225 static void request_dump PARAMS ((unsigned int, char));
226 static const char * get_elf_class PARAMS ((unsigned char));
227 static const char * get_data_encoding PARAMS ((unsigned char));
228 static const char * get_osabi_name PARAMS ((unsigned char));
229 static int guess_is_rela PARAMS ((unsigned long));
230 static char * get_note_type PARAMS ((unsigned int));
231 static int process_note PARAMS ((Elf32_Internal_Note *));
232 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
233 static int process_corefile_note_segments PARAMS ((FILE *));
234 static int process_corefile_contents PARAMS ((FILE *));
236 typedef int Elf32_Word;
244 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
245 ((X)->sh_name >= string_table_length \
246 ? "<corrupt>" : string_table + (X)->sh_name))
248 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
250 #define BYTE_GET(field) byte_get (field, sizeof (field))
252 /* If we can support a 64 bit data type then BFD64 should be defined
253 and sizeof (bfd_vma) == 8. In this case when translating from an
254 external 8 byte field to an internal field, we can assume that the
255 internal field is also 8 bytes wide and so we can extract all the data.
256 If, however, BFD64 is not defined, then we must assume that the
257 internal data structure only has 4 byte wide fields that are the
258 equivalent of the 8 byte wide external counterparts, and so we must
259 truncate the data. */
261 #define BYTE_GET8(field) byte_get (field, -8)
263 #define BYTE_GET8(field) byte_get (field, 8)
266 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
268 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
269 if (fseek (file, offset, SEEK_SET)) \
271 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
275 var = (type) malloc (size); \
279 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
283 if (fread (var, size, 1, file) != 1) \
285 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
292 #define GET_DATA(offset, var, reason) \
293 if (fseek (file, offset, SEEK_SET)) \
295 error (_("Unable to seek to %x for %s\n"), offset, reason); \
298 else if (fread (& var, sizeof (var), 1, file) != 1) \
300 error (_("Unable to read data at %x for %s\n"), offset, reason); \
304 #define GET_ELF_SYMBOLS(file, offset, size) \
305 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
306 : get_64bit_elf_symbols (file, offset, size))
309 #ifdef ANSI_PROTOTYPES
311 error (const char * message, ...)
315 fprintf (stderr, _("%s: Error: "), program_name);
316 va_start (args, message);
317 vfprintf (stderr, message, args);
323 warn (const char * message, ...)
327 fprintf (stderr, _("%s: Warning: "), program_name);
328 va_start (args, message);
329 vfprintf (stderr, message, args);
341 fprintf (stderr, _("%s: Error: "), program_name);
343 message = va_arg (args, char *);
344 vfprintf (stderr, message, args);
356 fprintf (stderr, _("%s: Warning: "), program_name);
358 message = va_arg (args, char *);
359 vfprintf (stderr, message, args);
366 byte_get_little_endian (field, size)
367 unsigned char * field;
376 return ((unsigned int) (field [0]))
377 | (((unsigned int) (field [1])) << 8);
380 /* We want to extract data from an 8 byte wide field and
381 place it into a 4 byte wide field. Since this is a little
382 endian source we can juts use the 4 byte extraction code. */
385 return ((unsigned long) (field [0]))
386 | (((unsigned long) (field [1])) << 8)
387 | (((unsigned long) (field [2])) << 16)
388 | (((unsigned long) (field [3])) << 24);
392 /* This is a special case, generated by the BYTE_GET8 macro.
393 It means that we are loading an 8 byte value from a field
394 in an external structure into an 8 byte value in a field
395 in an internal strcuture. */
396 return ((bfd_vma) (field [0]))
397 | (((bfd_vma) (field [1])) << 8)
398 | (((bfd_vma) (field [2])) << 16)
399 | (((bfd_vma) (field [3])) << 24)
400 | (((bfd_vma) (field [4])) << 32)
401 | (((bfd_vma) (field [5])) << 40)
402 | (((bfd_vma) (field [6])) << 48)
403 | (((bfd_vma) (field [7])) << 56);
406 error (_("Unhandled data length: %d\n"), size);
411 /* Print a VMA value. */
413 print_vma (vma, mode)
423 case FULL_HEX: printf ("0x"); /* drop through */
424 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
425 case PREFIX_HEX: printf ("0x"); /* drop through */
426 case HEX: printf ("%lx", (unsigned long) vma); break;
427 case DEC: printf ("%ld", (unsigned long) vma); break;
428 case DEC_5: printf ("%5ld", (long) vma); break;
429 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
450 #if BFD_HOST_64BIT_LONG
453 if (_bfd_int64_high (vma))
454 printf ("%lx%lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
456 printf ("%lx", _bfd_int64_low (vma));
461 #if BFD_HOST_64BIT_LONG
464 if (_bfd_int64_high (vma))
466 printf ("++%ld", _bfd_int64_low (vma));
468 printf ("%ld", _bfd_int64_low (vma));
473 #if BFD_HOST_64BIT_LONG
474 printf ("%5ld", vma);
476 if (_bfd_int64_high (vma))
478 printf ("++%ld", _bfd_int64_low (vma));
480 printf ("%5ld", _bfd_int64_low (vma));
485 #if BFD_HOST_64BIT_LONG
488 if (_bfd_int64_high (vma))
490 printf ("++%lu", _bfd_int64_low (vma));
492 printf ("%lu", _bfd_int64_low (vma));
501 byte_get_big_endian (field, size)
502 unsigned char * field;
511 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
514 return ((unsigned long) (field [3]))
515 | (((unsigned long) (field [2])) << 8)
516 | (((unsigned long) (field [1])) << 16)
517 | (((unsigned long) (field [0])) << 24);
520 /* Although we are extracing data from an 8 byte wide field, we
521 are returning only 4 bytes of data. */
522 return ((unsigned long) (field [7]))
523 | (((unsigned long) (field [6])) << 8)
524 | (((unsigned long) (field [5])) << 16)
525 | (((unsigned long) (field [4])) << 24);
529 /* This is a special case, generated by the BYTE_GET8 macro.
530 It means that we are loading an 8 byte value from a field
531 in an external structure into an 8 byte value in a field
532 in an internal strcuture. */
533 return ((bfd_vma) (field [7]))
534 | (((bfd_vma) (field [6])) << 8)
535 | (((bfd_vma) (field [5])) << 16)
536 | (((bfd_vma) (field [4])) << 24)
537 | (((bfd_vma) (field [3])) << 32)
538 | (((bfd_vma) (field [2])) << 40)
539 | (((bfd_vma) (field [1])) << 48)
540 | (((bfd_vma) (field [0])) << 56);
544 error (_("Unhandled data length: %d\n"), size);
549 /* Guess the relocation size commonly used by the specific machines. */
552 guess_is_rela (e_machine)
553 unsigned long e_machine;
557 /* Targets that use REL relocations. */
568 /* Targets that use RELA relocations. */
576 case EM_CYGNUS_MN10200:
577 case EM_CYGNUS_MN10300:
609 warn (_("Don't know about relocations on this machine architecture\n"));
615 slurp_rela_relocs (file, rel_offset, rel_size, relasp, nrelasp)
617 unsigned long rel_offset;
618 unsigned long rel_size;
619 Elf_Internal_Rela **relasp;
620 unsigned long *nrelasp;
622 Elf_Internal_Rela *relas;
623 unsigned long nrelas;
628 Elf32_External_Rela * erelas;
630 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
631 Elf32_External_Rela *, "relocs");
633 nrelas = rel_size / sizeof (Elf32_External_Rela);
635 relas = (Elf_Internal_Rela *)
636 malloc (nrelas * sizeof (Elf_Internal_Rela));
640 error(_("out of memory parsing relocs"));
644 for (i = 0; i < nrelas; i++)
646 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
647 relas[i].r_info = BYTE_GET (erelas[i].r_info);
648 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
655 Elf64_External_Rela * erelas;
657 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
658 Elf64_External_Rela *, "relocs");
660 nrelas = rel_size / sizeof (Elf64_External_Rela);
662 relas = (Elf_Internal_Rela *)
663 malloc (nrelas * sizeof (Elf_Internal_Rela));
667 error(_("out of memory parsing relocs"));
671 for (i = 0; i < nrelas; i++)
673 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
674 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
675 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
686 slurp_rel_relocs (file, rel_offset, rel_size, relsp, nrelsp)
688 unsigned long rel_offset;
689 unsigned long rel_size;
690 Elf_Internal_Rel **relsp;
691 unsigned long *nrelsp;
693 Elf_Internal_Rel *rels;
699 Elf32_External_Rel * erels;
701 GET_DATA_ALLOC (rel_offset, rel_size, erels,
702 Elf32_External_Rel *, "relocs");
704 nrels = rel_size / sizeof (Elf32_External_Rel);
706 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
710 error(_("out of memory parsing relocs"));
714 for (i = 0; i < nrels; i++)
716 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
717 rels[i].r_info = BYTE_GET (erels[i].r_info);
724 Elf64_External_Rel * erels;
726 GET_DATA_ALLOC (rel_offset, rel_size, erels,
727 Elf64_External_Rel *, "relocs");
729 nrels = rel_size / sizeof (Elf64_External_Rel);
731 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
735 error(_("out of memory parsing relocs"));
739 for (i = 0; i < nrels; i++)
741 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
742 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
752 /* Display the contents of the relocation data found at the specified offset. */
754 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
756 unsigned long rel_offset;
757 unsigned long rel_size;
758 Elf_Internal_Sym * symtab;
764 Elf_Internal_Rel * rels;
765 Elf_Internal_Rela * relas;
768 if (is_rela == UNKNOWN)
769 is_rela = guess_is_rela (elf_header.e_machine);
773 if (!slurp_rela_relocs (file, rel_offset, rel_size, &relas, &rel_size))
778 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
784 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
787 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
789 for (i = 0; i < rel_size; i++)
794 bfd_vma symtab_index;
799 offset = relas [i].r_offset;
800 info = relas [i].r_info;
804 offset = rels [i].r_offset;
805 info = rels [i].r_info;
810 type = ELF32_R_TYPE (info);
811 symtab_index = ELF32_R_SYM (info);
815 if (elf_header.e_machine == EM_SPARCV9)
816 type = ELF64_R_TYPE_ID (info);
818 type = ELF64_R_TYPE (info);
819 /* The #ifdef BFD64 below is to prevent a compile time warning.
820 We know that if we do not have a 64 bit data type that we
821 will never execute this code anyway. */
823 symtab_index = ELF64_R_SYM (info);
827 #ifdef _bfd_int64_low
828 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
830 printf (" %8.8lx %5.5lx ", offset, info);
833 switch (elf_header.e_machine)
840 rtype = elf_m32r_reloc_type (type);
845 rtype = elf_i386_reloc_type (type);
849 rtype = elf_m68k_reloc_type (type);
853 rtype = elf_i960_reloc_type (type);
857 rtype = elf_avr_reloc_type (type);
864 rtype = elf_sparc_reloc_type (type);
868 rtype = v850_reloc_type (type);
872 rtype = elf_d10v_reloc_type (type);
876 rtype = elf_d30v_reloc_type (type);
880 rtype = elf_sh_reloc_type (type);
883 case EM_CYGNUS_MN10300:
884 rtype = elf_mn10300_reloc_type (type);
887 case EM_CYGNUS_MN10200:
888 rtype = elf_mn10200_reloc_type (type);
892 rtype = elf_fr30_reloc_type (type);
896 rtype = elf_mcore_reloc_type (type);
900 rtype = elf_ppc_reloc_type (type);
905 rtype = elf_mips_reloc_type (type);
909 rtype = elf_alpha_reloc_type (type);
913 rtype = elf_arm_reloc_type (type);
918 rtype = elf_arc_reloc_type (type);
922 rtype = elf_hppa_reloc_type (type);
926 rtype = elf_pj_reloc_type (type);
929 rtype = elf_ia64_reloc_type (type);
933 rtype = elf_cris_reloc_type (type);
937 rtype = elf_i860_reloc_type (type);
941 rtype = elf_x86_64_reloc_type (type);
945 rtype = elf_s390_reloc_type (type);
950 #ifdef _bfd_int64_low
951 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
953 printf (_("unrecognised: %-7lx"), type);
956 printf ("%-21.21s", rtype);
962 if (symtab_index >= nsyms)
963 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
966 Elf_Internal_Sym * psym;
968 psym = symtab + symtab_index;
971 print_vma (psym->st_value, LONG_HEX);
974 if (psym->st_name == 0)
976 SECTION_NAME (section_headers + psym->st_shndx));
977 else if (strtab == NULL)
978 printf (_("<string table index %3ld>"), psym->st_name);
980 printf ("%-25.25s", strtab + psym->st_name);
983 printf (" + %lx", (unsigned long) relas [i].r_addend);
989 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
990 print_vma (relas[i].r_addend, LONG_HEX);
993 if (elf_header.e_machine == EM_SPARCV9
994 && !strcmp (rtype, "R_SPARC_OLO10"))
995 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1009 get_mips_dynamic_type (type)
1014 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1015 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1016 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1017 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1018 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1019 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1020 case DT_MIPS_MSYM: return "MIPS_MSYM";
1021 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1022 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1023 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1024 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1025 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1026 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1027 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1028 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1029 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1030 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1031 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1032 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1033 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1034 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1035 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1036 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1037 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1038 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1039 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1040 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1041 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1042 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1043 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1044 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1045 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1046 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1047 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1048 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1049 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1050 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1051 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1052 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1053 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1054 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1055 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1056 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1063 get_sparc64_dynamic_type (type)
1068 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1075 get_parisc_dynamic_type (type)
1080 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1081 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1082 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1083 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1084 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1085 case DT_HP_PREINIT: return "HP_PREINIT";
1086 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1087 case DT_HP_NEEDED: return "HP_NEEDED";
1088 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1089 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1090 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1091 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1092 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1099 get_dynamic_type (type)
1102 static char buff [32];
1106 case DT_NULL: return "NULL";
1107 case DT_NEEDED: return "NEEDED";
1108 case DT_PLTRELSZ: return "PLTRELSZ";
1109 case DT_PLTGOT: return "PLTGOT";
1110 case DT_HASH: return "HASH";
1111 case DT_STRTAB: return "STRTAB";
1112 case DT_SYMTAB: return "SYMTAB";
1113 case DT_RELA: return "RELA";
1114 case DT_RELASZ: return "RELASZ";
1115 case DT_RELAENT: return "RELAENT";
1116 case DT_STRSZ: return "STRSZ";
1117 case DT_SYMENT: return "SYMENT";
1118 case DT_INIT: return "INIT";
1119 case DT_FINI: return "FINI";
1120 case DT_SONAME: return "SONAME";
1121 case DT_RPATH: return "RPATH";
1122 case DT_SYMBOLIC: return "SYMBOLIC";
1123 case DT_REL: return "REL";
1124 case DT_RELSZ: return "RELSZ";
1125 case DT_RELENT: return "RELENT";
1126 case DT_PLTREL: return "PLTREL";
1127 case DT_DEBUG: return "DEBUG";
1128 case DT_TEXTREL: return "TEXTREL";
1129 case DT_JMPREL: return "JMPREL";
1130 case DT_BIND_NOW: return "BIND_NOW";
1131 case DT_INIT_ARRAY: return "INIT_ARRAY";
1132 case DT_FINI_ARRAY: return "FINI_ARRAY";
1133 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1134 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1135 case DT_RUNPATH: return "RUNPATH";
1136 case DT_FLAGS: return "FLAGS";
1138 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1139 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1141 case DT_CHECKSUM: return "CHECKSUM";
1142 case DT_PLTPADSZ: return "PLTPADSZ";
1143 case DT_MOVEENT: return "MOVEENT";
1144 case DT_MOVESZ: return "MOVESZ";
1145 case DT_FEATURE: return "FEATURE";
1146 case DT_POSFLAG_1: return "POSFLAG_1";
1147 case DT_SYMINSZ: return "SYMINSZ";
1148 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1150 case DT_ADDRRNGLO: return "ADDRRNGLO";
1151 case DT_CONFIG: return "CONFIG";
1152 case DT_DEPAUDIT: return "DEPAUDIT";
1153 case DT_AUDIT: return "AUDIT";
1154 case DT_PLTPAD: return "PLTPAD";
1155 case DT_MOVETAB: return "MOVETAB";
1156 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1158 case DT_VERSYM: return "VERSYM";
1160 case DT_RELACOUNT: return "RELACOUNT";
1161 case DT_RELCOUNT: return "RELCOUNT";
1162 case DT_FLAGS_1: return "FLAGS_1";
1163 case DT_VERDEF: return "VERDEF";
1164 case DT_VERDEFNUM: return "VERDEFNUM";
1165 case DT_VERNEED: return "VERNEED";
1166 case DT_VERNEEDNUM: return "VERNEEDNUM";
1168 case DT_AUXILIARY: return "AUXILIARY";
1169 case DT_USED: return "USED";
1170 case DT_FILTER: return "FILTER";
1173 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1175 const char * result;
1177 switch (elf_header.e_machine)
1180 case EM_MIPS_RS4_BE:
1181 result = get_mips_dynamic_type (type);
1184 result = get_sparc64_dynamic_type (type);
1194 sprintf (buff, _("Processor Specific: %lx"), type);
1196 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1198 const char * result;
1200 switch (elf_header.e_machine)
1203 result = get_parisc_dynamic_type (type);
1213 sprintf (buff, _("Operating System specific: %lx"), type);
1216 sprintf (buff, _("<unknown>: %lx"), type);
1223 get_file_type (e_type)
1226 static char buff [32];
1230 case ET_NONE: return _("NONE (None)");
1231 case ET_REL: return _("REL (Relocatable file)");
1232 case ET_EXEC: return _("EXEC (Executable file)");
1233 case ET_DYN: return _("DYN (Shared object file)");
1234 case ET_CORE: return _("CORE (Core file)");
1237 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1238 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1239 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1240 sprintf (buff, _("OS Specific: (%x)"), e_type);
1242 sprintf (buff, _("<unknown>: %x"), e_type);
1248 get_machine_name (e_machine)
1251 static char buff [64]; /* XXX */
1255 case EM_NONE: return _("None");
1256 case EM_M32: return "WE32100";
1257 case EM_SPARC: return "Sparc";
1258 case EM_386: return "Intel 80386";
1259 case EM_68K: return "MC68000";
1260 case EM_88K: return "MC88000";
1261 case EM_486: return "Intel 80486";
1262 case EM_860: return "Intel 80860";
1263 case EM_MIPS: return "MIPS R3000";
1264 case EM_S370: return "IBM System/370";
1265 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1266 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1267 case EM_PARISC: return "HPPA";
1268 case EM_PPC_OLD: return "Power PC (old)";
1269 case EM_SPARC32PLUS: return "Sparc v8+" ;
1270 case EM_960: return "Intel 90860";
1271 case EM_PPC: return "PowerPC";
1272 case EM_V800: return "NEC V800";
1273 case EM_FR20: return "Fujitsu FR20";
1274 case EM_RH32: return "TRW RH32";
1275 case EM_MCORE: return "MCORE";
1276 case EM_ARM: return "ARM";
1277 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1278 case EM_SH: return "Hitachi SH";
1279 case EM_SPARCV9: return "Sparc v9";
1280 case EM_TRICORE: return "Siemens Tricore";
1281 case EM_ARC: return "ARC";
1282 case EM_H8_300: return "Hitachi H8/300";
1283 case EM_H8_300H: return "Hitachi H8/300H";
1284 case EM_H8S: return "Hitachi H8S";
1285 case EM_H8_500: return "Hitachi H8/500";
1286 case EM_IA_64: return "Intel IA-64";
1287 case EM_MIPS_X: return "Stanford MIPS-X";
1288 case EM_COLDFIRE: return "Motorola Coldfire";
1289 case EM_68HC12: return "Motorola M68HC12";
1290 case EM_ALPHA: return "Alpha";
1291 case EM_CYGNUS_D10V: return "d10v";
1292 case EM_CYGNUS_D30V: return "d30v";
1293 case EM_CYGNUS_ARC: return "ARC";
1294 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1295 case EM_CYGNUS_V850: return "NEC v850";
1296 case EM_CYGNUS_MN10300: return "mn10300";
1297 case EM_CYGNUS_MN10200: return "mn10200";
1298 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1299 case EM_PJ: return "picoJava";
1300 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1301 case EM_PCP: return "Siemens PCP";
1302 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1303 case EM_NDR1: return "Denso NDR1 microprocesspr";
1304 case EM_STARCORE: return "Motorola Star*Core processor";
1305 case EM_ME16: return "Toyota ME16 processor";
1306 case EM_ST100: return "STMicroelectronics ST100 processor";
1307 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1308 case EM_FX66: return "Siemens FX66 microcontroller";
1309 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1310 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1311 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1312 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1313 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1314 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1315 case EM_SVX: return "Silicon Graphics SVx";
1316 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1317 case EM_VAX: return "Digital VAX";
1318 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1319 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1320 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1321 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1322 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1323 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1324 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1325 case EM_PRISM: return "SiTera Prism";
1326 case EM_X86_64: return "Advanced Micro Devices X86-64";
1327 case EM_S390: return "IBM S/390";
1329 sprintf (buff, _("<unknown>: %x"), e_machine);
1335 decode_ARM_machine_flags (e_flags, buf)
1342 eabi = EF_ARM_EABI_VERSION (e_flags);
1343 e_flags &= ~ EF_ARM_EABIMASK;
1345 /* Handle "generic" ARM flags. */
1346 if (e_flags & EF_ARM_RELEXEC)
1348 strcat (buf, ", relocatable executable");
1349 e_flags &= ~ EF_ARM_RELEXEC;
1352 if (e_flags & EF_ARM_HASENTRY)
1354 strcat (buf, ", has entry point");
1355 e_flags &= ~ EF_ARM_HASENTRY;
1358 /* Now handle EABI specific flags. */
1362 strcat (buf, ", <unrecognised EABI>");
1367 case EF_ARM_EABI_VER1:
1368 strcat (buf, ", Version1 EABI");
1373 /* Process flags one bit at a time. */
1374 flag = e_flags & - e_flags;
1379 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1380 strcat (buf, ", sorted symbol tables");
1390 case EF_ARM_EABI_VER2:
1391 strcat (buf, ", Version2 EABI");
1396 /* Process flags one bit at a time. */
1397 flag = e_flags & - e_flags;
1402 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1403 strcat (buf, ", sorted symbol tables");
1406 case EF_ARM_DYNSYMSUSESEGIDX:
1407 strcat (buf, ", dynamic symbols use segment index");
1410 case EF_ARM_MAPSYMSFIRST:
1411 strcat (buf, ", mapping symbols precede others");
1421 case EF_ARM_EABI_UNKNOWN:
1422 strcat (buf, ", GNU EABI");
1427 /* Process flags one bit at a time. */
1428 flag = e_flags & - e_flags;
1433 case EF_ARM_INTERWORK:
1434 strcat (buf, ", interworking enabled");
1437 case EF_ARM_APCS_26:
1438 strcat (buf, ", uses APCS/26");
1441 case EF_ARM_APCS_FLOAT:
1442 strcat (buf, ", uses APCS/float");
1446 strcat (buf, ", position independent");
1450 strcat (buf, ", 8 bit structure alignment");
1453 case EF_ARM_NEW_ABI:
1454 strcat (buf, ", uses new ABI");
1457 case EF_ARM_OLD_ABI:
1458 strcat (buf, ", uses old ABI");
1461 case EF_ARM_SOFT_FLOAT:
1462 strcat (buf, ", software FP");
1473 strcat (buf,", <unknown>");
1477 get_machine_flags (e_flags, e_machine)
1481 static char buf [1024];
1493 decode_ARM_machine_flags (e_flags, buf);
1497 if (e_flags & EF_CPU32)
1498 strcat (buf, ", cpu32");
1502 if (e_flags & EF_PPC_EMB)
1503 strcat (buf, ", emb");
1505 if (e_flags & EF_PPC_RELOCATABLE)
1506 strcat (buf, ", relocatable");
1508 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1509 strcat (buf, ", relocatable-lib");
1512 case EM_CYGNUS_V850:
1513 switch (e_flags & EF_V850_ARCH)
1516 strcat (buf, ", v850e");
1519 strcat (buf, ", v850ea");
1522 strcat (buf, ", v850");
1525 strcat (buf, ", unknown v850 architecture variant");
1530 case EM_CYGNUS_M32R:
1531 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1532 strcat (buf, ", m32r");
1537 case EM_MIPS_RS4_BE:
1538 if (e_flags & EF_MIPS_NOREORDER)
1539 strcat (buf, ", noreorder");
1541 if (e_flags & EF_MIPS_PIC)
1542 strcat (buf, ", pic");
1544 if (e_flags & EF_MIPS_CPIC)
1545 strcat (buf, ", cpic");
1547 if (e_flags & EF_MIPS_ABI2)
1548 strcat (buf, ", abi2");
1550 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1551 strcat (buf, ", mips1");
1553 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1554 strcat (buf, ", mips2");
1556 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1557 strcat (buf, ", mips3");
1559 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1560 strcat (buf, ", mips4");
1562 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
1563 strcat (buf, ", mips5");
1565 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
1566 strcat (buf, ", mips32");
1568 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
1569 strcat (buf, ", mips64");
1571 switch ((e_flags & EF_MIPS_MACH))
1573 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1574 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1575 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1576 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1577 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1578 case E_MIPS_MACH_MIPS32_4K: strcat (buf, ", mips32-4k"); break;
1579 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1580 default: strcat (buf, " UNKNOWN"); break;
1585 if (e_flags & EF_SPARC_32PLUS)
1586 strcat (buf, ", v8+");
1588 if (e_flags & EF_SPARC_SUN_US1)
1589 strcat (buf, ", ultrasparcI");
1591 if (e_flags & EF_SPARC_SUN_US3)
1592 strcat (buf, ", ultrasparcIII");
1594 if (e_flags & EF_SPARC_HAL_R1)
1595 strcat (buf, ", halr1");
1597 if (e_flags & EF_SPARC_LEDATA)
1598 strcat (buf, ", ledata");
1600 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1601 strcat (buf, ", tso");
1603 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1604 strcat (buf, ", pso");
1606 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1607 strcat (buf, ", rmo");
1611 switch (e_flags & EF_PARISC_ARCH)
1613 case EFA_PARISC_1_0:
1614 strcpy (buf, ", PA-RISC 1.0");
1616 case EFA_PARISC_1_1:
1617 strcpy (buf, ", PA-RISC 1.1");
1619 case EFA_PARISC_2_0:
1620 strcpy (buf, ", PA-RISC 2.0");
1625 if (e_flags & EF_PARISC_TRAPNIL)
1626 strcat (buf, ", trapnil");
1627 if (e_flags & EF_PARISC_EXT)
1628 strcat (buf, ", ext");
1629 if (e_flags & EF_PARISC_LSB)
1630 strcat (buf, ", lsb");
1631 if (e_flags & EF_PARISC_WIDE)
1632 strcat (buf, ", wide");
1633 if (e_flags & EF_PARISC_NO_KABP)
1634 strcat (buf, ", no kabp");
1635 if (e_flags & EF_PARISC_LAZYSWAP)
1636 strcat (buf, ", lazyswap");
1640 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1641 strcat (buf, ", new calling convention");
1643 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1644 strcat (buf, ", gnu calling convention");
1648 if ((e_flags & EF_IA_64_ABI64))
1649 strcat (buf, ", 64-bit");
1651 strcat (buf, ", 32-bit");
1652 if ((e_flags & EF_IA_64_REDUCEDFP))
1653 strcat (buf, ", reduced fp model");
1654 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
1655 strcat (buf, ", no function descriptors, constant gp");
1656 else if ((e_flags & EF_IA_64_CONS_GP))
1657 strcat (buf, ", constant gp");
1658 if ((e_flags & EF_IA_64_ABSOLUTE))
1659 strcat (buf, ", absolute");
1668 get_mips_segment_type (type)
1673 case PT_MIPS_REGINFO:
1675 case PT_MIPS_RTPROC:
1677 case PT_MIPS_OPTIONS:
1687 get_parisc_segment_type (type)
1692 case PT_HP_TLS: return "HP_TLS";
1693 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1694 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1695 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1696 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1697 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1698 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1699 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1700 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1701 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1702 case PT_HP_PARALLEL: return "HP_PARALLEL";
1703 case PT_HP_FASTBIND: return "HP_FASTBIND";
1704 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1705 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1714 get_ia64_segment_type (type)
1719 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
1720 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
1729 get_segment_type (p_type)
1730 unsigned long p_type;
1732 static char buff [32];
1736 case PT_NULL: return "NULL";
1737 case PT_LOAD: return "LOAD";
1738 case PT_DYNAMIC: return "DYNAMIC";
1739 case PT_INTERP: return "INTERP";
1740 case PT_NOTE: return "NOTE";
1741 case PT_SHLIB: return "SHLIB";
1742 case PT_PHDR: return "PHDR";
1745 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1747 const char * result;
1749 switch (elf_header.e_machine)
1752 case EM_MIPS_RS4_BE:
1753 result = get_mips_segment_type (p_type);
1756 result = get_parisc_segment_type (p_type);
1759 result = get_ia64_segment_type (p_type);
1769 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1771 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1773 const char * result;
1775 switch (elf_header.e_machine)
1778 result = get_parisc_segment_type (p_type);
1788 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1791 sprintf (buff, _("<unknown>: %lx"), p_type);
1798 get_mips_section_type_name (sh_type)
1799 unsigned int sh_type;
1803 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1804 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1805 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1806 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1807 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1808 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1809 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1810 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1811 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1812 case SHT_MIPS_RELD: return "MIPS_RELD";
1813 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1814 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1815 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1816 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1817 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1818 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1819 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1820 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1821 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1822 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1823 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1824 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1825 case SHT_MIPS_LINE: return "MIPS_LINE";
1826 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1827 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1828 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1829 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1830 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1831 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1832 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1833 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1834 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1835 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1836 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1837 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1838 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1839 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1840 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1841 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1849 get_parisc_section_type_name (sh_type)
1850 unsigned int sh_type;
1854 case SHT_PARISC_EXT: return "PARISC_EXT";
1855 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1856 case SHT_PARISC_DOC: return "PARISC_DOC";
1864 get_ia64_section_type_name (sh_type)
1865 unsigned int sh_type;
1869 case SHT_IA_64_EXT: return "IA_64_EXT";
1870 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
1878 get_section_type_name (sh_type)
1879 unsigned int sh_type;
1881 static char buff [32];
1885 case SHT_NULL: return "NULL";
1886 case SHT_PROGBITS: return "PROGBITS";
1887 case SHT_SYMTAB: return "SYMTAB";
1888 case SHT_STRTAB: return "STRTAB";
1889 case SHT_RELA: return "RELA";
1890 case SHT_HASH: return "HASH";
1891 case SHT_DYNAMIC: return "DYNAMIC";
1892 case SHT_NOTE: return "NOTE";
1893 case SHT_NOBITS: return "NOBITS";
1894 case SHT_REL: return "REL";
1895 case SHT_SHLIB: return "SHLIB";
1896 case SHT_DYNSYM: return "DYNSYM";
1897 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1898 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1899 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1900 case SHT_GROUP: return "GROUP";
1901 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
1902 case SHT_GNU_verdef: return "VERDEF";
1903 case SHT_GNU_verneed: return "VERNEED";
1904 case SHT_GNU_versym: return "VERSYM";
1905 case 0x6ffffff0: return "VERSYM";
1906 case 0x6ffffffc: return "VERDEF";
1907 case 0x7ffffffd: return "AUXILIARY";
1908 case 0x7fffffff: return "FILTER";
1911 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1913 const char * result;
1915 switch (elf_header.e_machine)
1918 case EM_MIPS_RS4_BE:
1919 result = get_mips_section_type_name (sh_type);
1922 result = get_parisc_section_type_name (sh_type);
1925 result = get_ia64_section_type_name (sh_type);
1935 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1937 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1938 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1939 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1940 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1942 sprintf (buff, _("<unknown>: %x"), sh_type);
1948 struct option options [] =
1950 {"all", no_argument, 0, 'a'},
1951 {"file-header", no_argument, 0, 'h'},
1952 {"program-headers", no_argument, 0, 'l'},
1953 {"headers", no_argument, 0, 'e'},
1954 {"histogram", no_argument, 0, 'I'},
1955 {"segments", no_argument, 0, 'l'},
1956 {"sections", no_argument, 0, 'S'},
1957 {"section-headers", no_argument, 0, 'S'},
1958 {"symbols", no_argument, 0, 's'},
1959 {"syms", no_argument, 0, 's'},
1960 {"relocs", no_argument, 0, 'r'},
1961 {"notes", no_argument, 0, 'n'},
1962 {"dynamic", no_argument, 0, 'd'},
1963 {"arch-specific", no_argument, 0, 'A'},
1964 {"version-info", no_argument, 0, 'V'},
1965 {"use-dynamic", no_argument, 0, 'D'},
1966 {"hex-dump", required_argument, 0, 'x'},
1967 {"debug-dump", optional_argument, 0, 'w'},
1968 {"unwind", no_argument, 0, 'u'},
1969 #ifdef SUPPORT_DISASSEMBLY
1970 {"instruction-dump", required_argument, 0, 'i'},
1973 {"version", no_argument, 0, 'v'},
1974 {"help", no_argument, 0, 'H'},
1975 {0, no_argument, 0, 0}
1981 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1982 fprintf (stdout, _(" Options are:\n"));
1983 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1984 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1985 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1986 fprintf (stdout, _(" Display the program headers\n"));
1987 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1988 fprintf (stdout, _(" Display the sections' header\n"));
1989 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1990 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1991 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1992 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1993 fprintf (stdout, _(" -u or --unwind Display the unwind info (if present)\n"));
1994 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1995 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1996 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1997 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1998 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1999 fprintf (stdout, _(" Dump the contents of section <number>\n"));
2000 fprintf (stdout, _(" -w[liaprf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=frames]\n"));
2001 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
2002 #ifdef SUPPORT_DISASSEMBLY
2003 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
2004 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
2006 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
2007 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
2008 fprintf (stdout, _(" -H or --help Display this information\n"));
2009 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2015 request_dump (section, type)
2016 unsigned int section;
2019 if (section >= num_dump_sects)
2021 char * new_dump_sects;
2023 new_dump_sects = (char *) calloc (section + 1, 1);
2025 if (new_dump_sects == NULL)
2026 error (_("Out of memory allocating dump request table."));
2029 /* Copy current flag settings. */
2030 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2034 dump_sects = new_dump_sects;
2035 num_dump_sects = section + 1;
2040 dump_sects [section] |= type;
2046 parse_args (argc, argv)
2055 while ((c = getopt_long
2056 (argc, argv, "ersuahnldSDAIw::x:i:vV", options, NULL)) != EOF)
2092 do_using_dynamic ++;
2123 section = strtoul (optarg, & cp, 0);
2124 if (! * cp && section >= 0)
2126 request_dump (section, HEX_DUMP);
2146 do_debug_abbrevs = 1;
2156 do_debug_pubnames = 1;
2161 do_debug_aranges = 1;
2166 do_debug_frames = 1;
2170 warn (_("Unrecognised debug option '%s'\n"), optarg);
2175 #ifdef SUPPORT_DISASSEMBLY
2178 section = strtoul (optarg, & cp, 0);
2179 if (! * cp && section >= 0)
2181 request_dump (section, DISASS_DUMP);
2187 print_version (program_name);
2194 /* xgettext:c-format */
2195 error (_("Invalid option '-%c'\n"), c);
2202 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2203 && !do_segments && !do_header && !do_dump && !do_version
2204 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2208 warn (_("Nothing to do.\n"));
2214 get_elf_class (elf_class)
2215 unsigned char elf_class;
2217 static char buff [32];
2221 case ELFCLASSNONE: return _("none");
2222 case ELFCLASS32: return _("ELF32");
2223 case ELFCLASS64: return _("ELF64");
2225 sprintf (buff, _("<unknown: %x>"), elf_class);
2231 get_data_encoding (encoding)
2232 unsigned char encoding;
2234 static char buff [32];
2238 case ELFDATANONE: return _("none");
2239 case ELFDATA2LSB: return _("2's complement, little endian");
2240 case ELFDATA2MSB: return _("2's complement, big endian");
2242 sprintf (buff, _("<unknown: %x>"), encoding);
2248 get_osabi_name (osabi)
2249 unsigned char osabi;
2251 static char buff [32];
2255 case ELFOSABI_NONE: return _("UNIX - System V");
2256 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2257 case ELFOSABI_NETBSD: return _("UNIX - NetBSD");
2258 case ELFOSABI_LINUX: return _("UNIX - Linux");
2259 case ELFOSABI_HURD: return _("GNU/Hurd");
2260 case ELFOSABI_SOLARIS: return _("UNIX - Solaris");
2261 case ELFOSABI_AIX: return _("UNIX - AIX");
2262 case ELFOSABI_IRIX: return _("UNIX - IRIX");
2263 case ELFOSABI_FREEBSD: return _("UNIX - FreeBSD");
2264 case ELFOSABI_TRU64: return _("UNIX - TRU64");
2265 case ELFOSABI_MODESTO: return _("Novell - Modesto");
2266 case ELFOSABI_OPENBSD: return _("UNIX - OpenBSD");
2267 case ELFOSABI_STANDALONE: return _("Standalone App");
2268 case ELFOSABI_ARM: return _("ARM");
2270 sprintf (buff, _("<unknown: %x>"), osabi);
2275 /* Decode the data held in 'elf_header'. */
2277 process_file_header ()
2279 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2280 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2281 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2282 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2285 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2293 printf (_("ELF Header:\n"));
2294 printf (_(" Magic: "));
2295 for (i = 0; i < EI_NIDENT; i ++)
2296 printf ("%2.2x ", elf_header.e_ident [i]);
2298 printf (_(" Class: %s\n"),
2299 get_elf_class (elf_header.e_ident [EI_CLASS]));
2300 printf (_(" Data: %s\n"),
2301 get_data_encoding (elf_header.e_ident [EI_DATA]));
2302 printf (_(" Version: %d %s\n"),
2303 elf_header.e_ident [EI_VERSION],
2304 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2306 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2309 printf (_(" OS/ABI: %s\n"),
2310 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2311 printf (_(" ABI Version: %d\n"),
2312 elf_header.e_ident [EI_ABIVERSION]);
2313 printf (_(" Type: %s\n"),
2314 get_file_type (elf_header.e_type));
2315 printf (_(" Machine: %s\n"),
2316 get_machine_name (elf_header.e_machine));
2317 printf (_(" Version: 0x%lx\n"),
2318 (unsigned long) elf_header.e_version);
2320 printf (_(" Entry point address: "));
2321 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2322 printf (_("\n Start of program headers: "));
2323 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2324 printf (_(" (bytes into file)\n Start of section headers: "));
2325 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2326 printf (_(" (bytes into file)\n"));
2328 printf (_(" Flags: 0x%lx%s\n"),
2329 (unsigned long) elf_header.e_flags,
2330 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2331 printf (_(" Size of this header: %ld (bytes)\n"),
2332 (long) elf_header.e_ehsize);
2333 printf (_(" Size of program headers: %ld (bytes)\n"),
2334 (long) elf_header.e_phentsize);
2335 printf (_(" Number of program headers: %ld\n"),
2336 (long) elf_header.e_phnum);
2337 printf (_(" Size of section headers: %ld (bytes)\n"),
2338 (long) elf_header.e_shentsize);
2339 printf (_(" Number of section headers: %ld\n"),
2340 (long) elf_header.e_shnum);
2341 printf (_(" Section header string table index: %ld\n"),
2342 (long) elf_header.e_shstrndx);
2350 get_32bit_program_headers (file, program_headers)
2352 Elf_Internal_Phdr * program_headers;
2354 Elf32_External_Phdr * phdrs;
2355 Elf32_External_Phdr * external;
2356 Elf32_Internal_Phdr * internal;
2359 GET_DATA_ALLOC (elf_header.e_phoff,
2360 elf_header.e_phentsize * elf_header.e_phnum,
2361 phdrs, Elf32_External_Phdr *, "program headers");
2363 for (i = 0, internal = program_headers, external = phdrs;
2364 i < elf_header.e_phnum;
2365 i ++, internal ++, external ++)
2367 internal->p_type = BYTE_GET (external->p_type);
2368 internal->p_offset = BYTE_GET (external->p_offset);
2369 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2370 internal->p_paddr = BYTE_GET (external->p_paddr);
2371 internal->p_filesz = BYTE_GET (external->p_filesz);
2372 internal->p_memsz = BYTE_GET (external->p_memsz);
2373 internal->p_flags = BYTE_GET (external->p_flags);
2374 internal->p_align = BYTE_GET (external->p_align);
2383 get_64bit_program_headers (file, program_headers)
2385 Elf_Internal_Phdr * program_headers;
2387 Elf64_External_Phdr * phdrs;
2388 Elf64_External_Phdr * external;
2389 Elf64_Internal_Phdr * internal;
2392 GET_DATA_ALLOC (elf_header.e_phoff,
2393 elf_header.e_phentsize * elf_header.e_phnum,
2394 phdrs, Elf64_External_Phdr *, "program headers");
2396 for (i = 0, internal = program_headers, external = phdrs;
2397 i < elf_header.e_phnum;
2398 i ++, internal ++, external ++)
2400 internal->p_type = BYTE_GET (external->p_type);
2401 internal->p_flags = BYTE_GET (external->p_flags);
2402 internal->p_offset = BYTE_GET8 (external->p_offset);
2403 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2404 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2405 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2406 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2407 internal->p_align = BYTE_GET8 (external->p_align);
2416 process_program_headers (file)
2419 Elf_Internal_Phdr * program_headers;
2420 Elf_Internal_Phdr * segment;
2423 if (elf_header.e_phnum == 0)
2426 printf (_("\nThere are no program headers in this file.\n"));
2430 if (do_segments && !do_header)
2432 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2433 printf (_("Entry point "));
2434 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2435 printf (_("\nThere are %d program headers, starting at offset "),
2436 elf_header.e_phnum);
2437 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2441 program_headers = (Elf_Internal_Phdr *) malloc
2442 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2444 if (program_headers == NULL)
2446 error (_("Out of memory\n"));
2451 i = get_32bit_program_headers (file, program_headers);
2453 i = get_64bit_program_headers (file, program_headers);
2457 free (program_headers);
2464 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2468 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2472 (_(" Type Offset VirtAddr PhysAddr\n"));
2474 (_(" FileSiz MemSiz Flags Align\n"));
2482 for (i = 0, segment = program_headers;
2483 i < elf_header.e_phnum;
2488 printf (" %-14.14s ", get_segment_type (segment->p_type));
2492 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2493 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2494 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2495 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2496 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2498 (segment->p_flags & PF_R ? 'R' : ' '),
2499 (segment->p_flags & PF_W ? 'W' : ' '),
2500 (segment->p_flags & PF_X ? 'E' : ' '));
2501 printf ("%#lx", (unsigned long) segment->p_align);
2505 print_vma (segment->p_offset, FULL_HEX);
2507 print_vma (segment->p_vaddr, FULL_HEX);
2509 print_vma (segment->p_paddr, FULL_HEX);
2511 print_vma (segment->p_filesz, FULL_HEX);
2513 print_vma (segment->p_memsz, FULL_HEX);
2515 (segment->p_flags & PF_R ? 'R' : ' '),
2516 (segment->p_flags & PF_W ? 'W' : ' '),
2517 (segment->p_flags & PF_X ? 'E' : ' '));
2518 print_vma (segment->p_align, HEX);
2522 switch (segment->p_type)
2526 loadaddr = (segment->p_vaddr & 0xfffff000)
2527 - (segment->p_offset & 0xfffff000);
2532 error (_("more than one dynamic segment\n"));
2534 dynamic_addr = segment->p_offset;
2535 dynamic_size = segment->p_filesz;
2539 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2540 error (_("Unable to find program interpreter name\n"));
2543 program_interpreter[0] = 0;
2544 fscanf (file, "%63s", program_interpreter);
2547 printf (_("\n [Requesting program interpreter: %s]"),
2548 program_interpreter);
2554 putc ('\n', stdout);
2563 if (do_segments && section_headers != NULL)
2565 printf (_("\n Section to Segment mapping:\n"));
2566 printf (_(" Segment Sections...\n"));
2568 assert (string_table != NULL);
2570 for (i = 0; i < elf_header.e_phnum; i++)
2573 Elf_Internal_Shdr * section;
2575 segment = program_headers + i;
2576 section = section_headers;
2578 printf (" %2.2d ", i);
2580 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2582 if (section->sh_size > 0
2583 /* Compare allocated sections by VMA, unallocated
2584 sections by file offset. */
2585 && (section->sh_flags & SHF_ALLOC
2586 ? (section->sh_addr >= segment->p_vaddr
2587 && section->sh_addr + section->sh_size
2588 <= segment->p_vaddr + segment->p_memsz)
2589 : ((bfd_vma) section->sh_offset >= segment->p_offset
2590 && (section->sh_offset + section->sh_size
2591 <= segment->p_offset + segment->p_filesz))))
2592 printf ("%s ", SECTION_NAME (section));
2599 free (program_headers);
2606 get_32bit_section_headers (file)
2609 Elf32_External_Shdr * shdrs;
2610 Elf32_Internal_Shdr * internal;
2613 GET_DATA_ALLOC (elf_header.e_shoff,
2614 elf_header.e_shentsize * elf_header.e_shnum,
2615 shdrs, Elf32_External_Shdr *, "section headers");
2617 section_headers = (Elf_Internal_Shdr *) malloc
2618 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2620 if (section_headers == NULL)
2622 error (_("Out of memory\n"));
2626 for (i = 0, internal = section_headers;
2627 i < elf_header.e_shnum;
2630 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2631 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2632 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2633 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2634 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2635 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2636 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2637 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2638 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2639 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2648 get_64bit_section_headers (file)
2651 Elf64_External_Shdr * shdrs;
2652 Elf64_Internal_Shdr * internal;
2655 GET_DATA_ALLOC (elf_header.e_shoff,
2656 elf_header.e_shentsize * elf_header.e_shnum,
2657 shdrs, Elf64_External_Shdr *, "section headers");
2659 section_headers = (Elf_Internal_Shdr *) malloc
2660 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2662 if (section_headers == NULL)
2664 error (_("Out of memory\n"));
2668 for (i = 0, internal = section_headers;
2669 i < elf_header.e_shnum;
2672 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2673 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2674 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2675 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2676 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2677 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2678 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2679 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2680 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2681 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2689 static Elf_Internal_Sym *
2690 get_32bit_elf_symbols (file, offset, number)
2692 unsigned long offset;
2693 unsigned long number;
2695 Elf32_External_Sym * esyms;
2696 Elf_Internal_Sym * isyms;
2697 Elf_Internal_Sym * psym;
2700 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2701 esyms, Elf32_External_Sym *, "symbols");
2703 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2707 error (_("Out of memory\n"));
2713 for (j = 0, psym = isyms;
2717 psym->st_name = BYTE_GET (esyms[j].st_name);
2718 psym->st_value = BYTE_GET (esyms[j].st_value);
2719 psym->st_size = BYTE_GET (esyms[j].st_size);
2720 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2721 psym->st_info = BYTE_GET (esyms[j].st_info);
2722 psym->st_other = BYTE_GET (esyms[j].st_other);
2730 static Elf_Internal_Sym *
2731 get_64bit_elf_symbols (file, offset, number)
2733 unsigned long offset;
2734 unsigned long number;
2736 Elf64_External_Sym * esyms;
2737 Elf_Internal_Sym * isyms;
2738 Elf_Internal_Sym * psym;
2741 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2742 esyms, Elf64_External_Sym *, "symbols");
2744 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2748 error (_("Out of memory\n"));
2754 for (j = 0, psym = isyms;
2758 psym->st_name = BYTE_GET (esyms[j].st_name);
2759 psym->st_info = BYTE_GET (esyms[j].st_info);
2760 psym->st_other = BYTE_GET (esyms[j].st_other);
2761 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2762 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2763 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2772 get_elf_section_flags (sh_flags)
2775 static char buff [32];
2783 flag = sh_flags & - sh_flags;
2788 case SHF_WRITE: strcat (buff, "W"); break;
2789 case SHF_ALLOC: strcat (buff, "A"); break;
2790 case SHF_EXECINSTR: strcat (buff, "X"); break;
2791 case SHF_MERGE: strcat (buff, "M"); break;
2792 case SHF_STRINGS: strcat (buff, "S"); break;
2793 case SHF_INFO_LINK: strcat (buff, "I"); break;
2794 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2795 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2796 case SHF_GROUP: strcat (buff, "G"); break;
2799 if (flag & SHF_MASKOS)
2802 sh_flags &= ~ SHF_MASKOS;
2804 else if (flag & SHF_MASKPROC)
2807 sh_flags &= ~ SHF_MASKPROC;
2819 process_section_headers (file)
2822 Elf_Internal_Shdr * section;
2825 section_headers = NULL;
2827 if (elf_header.e_shnum == 0)
2830 printf (_("\nThere are no sections in this file.\n"));
2835 if (do_sections && !do_header)
2836 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2837 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2841 if (! get_32bit_section_headers (file))
2844 else if (! get_64bit_section_headers (file))
2847 /* Read in the string table, so that we have names to display. */
2848 section = section_headers + elf_header.e_shstrndx;
2850 if (section->sh_size != 0)
2852 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2853 string_table, char *, "string table");
2855 string_table_length = section->sh_size;
2858 /* Scan the sections for the dynamic symbol table
2859 and dynamic string table and debug sections. */
2860 dynamic_symbols = NULL;
2861 dynamic_strings = NULL;
2862 dynamic_syminfo = NULL;
2864 for (i = 0, section = section_headers;
2865 i < elf_header.e_shnum;
2868 char * name = SECTION_NAME (section);
2870 if (section->sh_type == SHT_DYNSYM)
2872 if (dynamic_symbols != NULL)
2874 error (_("File contains multiple dynamic symbol tables\n"));
2878 num_dynamic_syms = section->sh_size / section->sh_entsize;
2880 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2882 else if (section->sh_type == SHT_STRTAB
2883 && strcmp (name, ".dynstr") == 0)
2885 if (dynamic_strings != NULL)
2887 error (_("File contains multiple dynamic string tables\n"));
2891 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2892 dynamic_strings, char *, "dynamic strings");
2894 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2895 || do_debug_lines || do_debug_pubnames || do_debug_aranges || do_debug_frames)
2896 && strncmp (name, ".debug_", 7) == 0)
2901 || (do_debug_info && (strcmp (name, "info") == 0))
2902 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2903 || (do_debug_lines && (strcmp (name, "line") == 0))
2904 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2905 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2906 || (do_debug_frames && (strcmp (name, "frame") == 0))
2908 request_dump (i, DEBUG_DUMP);
2910 /* linkonce section to be combined with .debug_info at link time. */
2911 else if ((do_debugging || do_debug_info)
2912 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
2913 request_dump (i, DEBUG_DUMP);
2914 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
2915 request_dump (i, DEBUG_DUMP);
2921 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2925 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2928 printf (_(" [Nr] Name Type Address Offset\n"));
2929 printf (_(" Size EntSize Flags Link Info Align\n"));
2932 for (i = 0, section = section_headers;
2933 i < elf_header.e_shnum;
2936 printf (" [%2d] %-17.17s %-15.15s ",
2938 SECTION_NAME (section),
2939 get_section_type_name (section->sh_type));
2943 print_vma (section->sh_addr, LONG_HEX);
2945 printf ( " %6.6lx %6.6lx %2.2lx",
2946 (unsigned long) section->sh_offset,
2947 (unsigned long) section->sh_size,
2948 (unsigned long) section->sh_entsize);
2950 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2952 printf ("%2ld %3lx %2ld\n",
2953 (unsigned long) section->sh_link,
2954 (unsigned long) section->sh_info,
2955 (unsigned long) section->sh_addralign);
2960 print_vma (section->sh_addr, LONG_HEX);
2961 printf (" %8.8lx", section->sh_offset);
2963 print_vma (section->sh_size, LONG_HEX);
2965 print_vma (section->sh_entsize, LONG_HEX);
2967 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2969 printf (" %2ld %3lx %ld\n",
2970 (unsigned long) section->sh_link,
2971 (unsigned long) section->sh_info,
2972 (unsigned long) section->sh_addralign);
2976 printf (_("Key to Flags:\n"));
2977 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2978 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
2979 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
2984 /* Process the reloc section. */
2986 process_relocs (file)
2989 unsigned long rel_size;
2990 unsigned long rel_offset;
2996 if (do_using_dynamic)
2998 int is_rela = FALSE;
3003 if (dynamic_info[DT_REL])
3005 rel_offset = dynamic_info[DT_REL];
3006 rel_size = dynamic_info[DT_RELSZ];
3009 else if (dynamic_info [DT_RELA])
3011 rel_offset = dynamic_info[DT_RELA];
3012 rel_size = dynamic_info[DT_RELASZ];
3015 else if (dynamic_info[DT_JMPREL])
3017 rel_offset = dynamic_info[DT_JMPREL];
3018 rel_size = dynamic_info[DT_PLTRELSZ];
3020 switch (dynamic_info[DT_PLTREL])
3037 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3038 rel_offset, rel_size);
3040 dump_relocations (file, rel_offset - loadaddr, rel_size,
3041 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3044 printf (_("\nThere are no dynamic relocations in this file.\n"));
3048 Elf32_Internal_Shdr * section;
3052 for (i = 0, section = section_headers;
3053 i < elf_header.e_shnum;
3056 if ( section->sh_type != SHT_RELA
3057 && section->sh_type != SHT_REL)
3060 rel_offset = section->sh_offset;
3061 rel_size = section->sh_size;
3065 Elf32_Internal_Shdr * strsec;
3066 Elf32_Internal_Shdr * symsec;
3067 Elf_Internal_Sym * symtab;
3070 unsigned long nsyms;
3072 printf (_("\nRelocation section "));
3074 if (string_table == NULL)
3075 printf ("%d", section->sh_name);
3077 printf ("'%s'", SECTION_NAME (section));
3079 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3080 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3082 symsec = section_headers + section->sh_link;
3084 nsyms = symsec->sh_size / symsec->sh_entsize;
3085 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
3090 strsec = section_headers + symsec->sh_link;
3092 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
3093 char *, "string table");
3095 is_rela = section->sh_type == SHT_RELA;
3097 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
3107 printf (_("\nThere are no relocations in this file.\n"));
3113 #include "unwind-ia64.h"
3115 /* An absolute address consists of a section and an offset. If the
3116 section is NULL, the offset itself is the address, otherwise, the
3117 address equals to LOAD_ADDRESS(section) + offset. */
3121 unsigned short section;
3127 struct unw_table_entry
3129 struct absaddr start;
3131 struct absaddr info;
3133 *table; /* Unwind table. */
3134 unsigned long table_len; /* Length of unwind table. */
3135 unsigned char * info; /* Unwind info. */
3136 unsigned long info_size; /* Size of unwind info. */
3137 bfd_vma info_addr; /* starting address of unwind info. */
3138 bfd_vma seg_base; /* Starting address of segment. */
3139 Elf_Internal_Sym * symtab; /* The symbol table. */
3140 unsigned long nsyms; /* Number of symbols. */
3141 char * strtab; /* The string table. */
3142 unsigned long strtab_size; /* Size of string table. */
3145 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3146 struct absaddr, const char **,
3148 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3149 static int slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3150 Elf32_Internal_Shdr *));
3153 find_symbol_for_address (aux, addr, symname, offset)
3154 struct unw_aux_info *aux;
3155 struct absaddr addr;
3156 const char **symname;
3159 bfd_vma dist = (bfd_vma) 0x100000;
3160 Elf_Internal_Sym *sym, *best = NULL;
3163 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3165 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3166 && sym->st_name != 0
3167 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3168 && addr.offset >= sym->st_value
3169 && addr.offset - sym->st_value < dist)
3172 dist = addr.offset - sym->st_value;
3179 *symname = (best->st_name >= aux->strtab_size
3180 ? "<corrupt>" : aux->strtab + best->st_name);
3185 *offset = addr.offset;
3189 dump_ia64_unwind (aux)
3190 struct unw_aux_info *aux;
3193 struct unw_table_entry * tp;
3196 addr_size = is_32bit_elf ? 4 : 8;
3198 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3202 const unsigned char * dp;
3203 const unsigned char * head;
3204 const char * procname;
3206 find_symbol_for_address (aux, tp->start, &procname, &offset);
3208 fputs ("\n<", stdout);
3212 fputs (procname, stdout);
3215 printf ("+%lx", (unsigned long) offset);
3218 fputs (">: [", stdout);
3219 print_vma (tp->start.offset, PREFIX_HEX);
3220 fputc ('-', stdout);
3221 print_vma (tp->end.offset, PREFIX_HEX);
3222 printf ("), info at +0x%lx\n",
3223 (unsigned long) (tp->info.offset - aux->seg_base));
3225 head = aux->info + (tp->info.offset - aux->info_addr);
3226 stamp = BYTE_GET8 ((unsigned char *) head);
3228 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3229 (unsigned) UNW_VER (stamp),
3230 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3231 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3232 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3233 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3235 if (UNW_VER (stamp) != 1)
3237 printf ("\tUnknown version.\n");
3242 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3243 dp = unw_decode (dp, in_body, & in_body);
3248 slurp_ia64_unwind_table (file, aux, sec)
3250 struct unw_aux_info *aux;
3251 Elf32_Internal_Shdr *sec;
3253 unsigned long size, addr_size, nrelas, i;
3254 Elf_Internal_Phdr *prog_hdrs, *seg;
3255 struct unw_table_entry *tep;
3256 Elf32_Internal_Shdr *relsec;
3257 Elf_Internal_Rela *rela, *rp;
3258 unsigned char *table, *tp;
3259 Elf_Internal_Sym *sym;
3260 const char *relname;
3263 addr_size = is_32bit_elf ? 4 : 8;
3265 /* First, find the starting address of the segment that includes
3268 if (elf_header.e_phnum)
3270 prog_hdrs = (Elf_Internal_Phdr *)
3271 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3274 result = get_32bit_program_headers (file, prog_hdrs);
3276 result = get_64bit_program_headers (file, prog_hdrs);
3284 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3286 if (seg->p_type != PT_LOAD)
3289 if (sec->sh_addr >= seg->p_vaddr
3290 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3292 aux->seg_base = seg->p_vaddr;
3300 /* Second, build the unwind table from the contents of the unwind section: */
3301 size = sec->sh_size;
3302 GET_DATA_ALLOC (sec->sh_offset, size, table, char *, "unwind table");
3304 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3305 for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3307 tep->start.section = SHN_UNDEF;
3308 tep->end.section = SHN_UNDEF;
3309 tep->info.section = SHN_UNDEF;
3312 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3313 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
3314 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
3318 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
3319 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
3320 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
3322 tep->start.offset += aux->seg_base;
3323 tep->end.offset += aux->seg_base;
3324 tep->info.offset += aux->seg_base;
3328 /* Third, apply any relocations to the unwind table: */
3330 for (relsec = section_headers;
3331 relsec < section_headers + elf_header.e_shnum;
3334 if (relsec->sh_type != SHT_RELA
3335 || section_headers + relsec->sh_info != sec)
3338 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3342 for (rp = rela; rp < rela + nrelas; ++rp)
3346 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3347 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3349 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3351 warn (_("Skipping unexpected symbol type %u"),
3352 ELF32_ST_TYPE (sym->st_info));
3358 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3359 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3361 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3363 warn (_("Skipping unexpected symbol type %u"),
3364 ELF64_ST_TYPE (sym->st_info));
3369 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
3371 warn (_("Skipping unexpected relocation type %s"), relname);
3375 i = rp->r_offset / (3 * addr_size);
3377 switch (rp->r_offset/addr_size % 3)
3380 aux->table[i].start.section = sym->st_shndx;
3381 aux->table[i].start.offset += rp->r_addend;
3384 aux->table[i].end.section = sym->st_shndx;
3385 aux->table[i].end.offset += rp->r_addend;
3388 aux->table[i].info.section = sym->st_shndx;
3389 aux->table[i].info.offset += rp->r_addend;
3399 aux->table_len = size / (3 * addr_size);
3404 process_unwind (file)
3407 Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
3408 unsigned long i, addr_size;
3409 struct unw_aux_info aux;
3411 memset (& aux, 0, sizeof (aux));
3413 addr_size = is_32bit_elf ? 4 : 8;
3418 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
3420 if (sec->sh_type == SHT_SYMTAB)
3422 aux.nsyms = sec->sh_size / sec->sh_entsize;
3423 aux.symtab = GET_ELF_SYMBOLS (file, sec->sh_offset, aux.nsyms);
3425 strsec = section_headers + sec->sh_link;
3426 aux.strtab_size = strsec->sh_size;
3427 GET_DATA_ALLOC (strsec->sh_offset, aux.strtab_size,
3428 aux.strtab, const char *, "string table");
3430 else if (sec->sh_type == SHT_IA_64_UNWIND)
3432 else if (strcmp (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info) == 0)
3434 aux.info_size = sec->sh_size;
3435 aux.info_addr = sec->sh_addr;
3436 GET_DATA_ALLOC (sec->sh_offset, aux.info_size, aux.info,
3437 char *, "unwind info");
3443 printf (_("\nUnwind section "));
3445 if (string_table == NULL)
3446 printf ("%d", unwsec->sh_name);
3448 printf ("'%s'", SECTION_NAME (unwsec));
3450 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3451 unwsec->sh_offset, (unsigned long) (unwsec->sh_size / (3 * addr_size)));
3453 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
3455 if (aux.table_len > 0)
3456 dump_ia64_unwind (& aux);
3459 printf (_("\nThere are no unwind sections in this file.\n"));
3462 free ((char *) aux.table);
3464 free ((char *) aux.info);
3468 free ((char *) aux.strtab);
3474 dynamic_segment_mips_val (entry)
3475 Elf_Internal_Dyn * entry;
3477 switch (entry->d_tag)
3480 if (entry->d_un.d_val == 0)
3484 static const char * opts[] =
3486 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3487 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3488 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3489 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3494 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
3495 if (entry->d_un.d_val & (1 << cnt))
3497 printf ("%s%s", first ? "" : " ", opts[cnt]);
3504 case DT_MIPS_IVERSION:
3505 if (dynamic_strings != NULL)
3506 printf ("Interface Version: %s\n",
3507 dynamic_strings + entry->d_un.d_val);
3509 printf ("%ld\n", (long) entry->d_un.d_ptr);
3512 case DT_MIPS_TIME_STAMP:
3517 time_t time = entry->d_un.d_val;
3518 tmp = gmtime (&time);
3519 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3520 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3521 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3522 printf ("Time Stamp: %s\n", timebuf);
3526 case DT_MIPS_RLD_VERSION:
3527 case DT_MIPS_LOCAL_GOTNO:
3528 case DT_MIPS_CONFLICTNO:
3529 case DT_MIPS_LIBLISTNO:
3530 case DT_MIPS_SYMTABNO:
3531 case DT_MIPS_UNREFEXTNO:
3532 case DT_MIPS_HIPAGENO:
3533 case DT_MIPS_DELTA_CLASS_NO:
3534 case DT_MIPS_DELTA_INSTANCE_NO:
3535 case DT_MIPS_DELTA_RELOC_NO:
3536 case DT_MIPS_DELTA_SYM_NO:
3537 case DT_MIPS_DELTA_CLASSSYM_NO:
3538 case DT_MIPS_COMPACT_SIZE:
3539 printf ("%ld\n", (long) entry->d_un.d_ptr);
3543 printf ("%#lx\n", (long) entry->d_un.d_ptr);
3549 dynamic_segment_parisc_val (entry)
3550 Elf_Internal_Dyn * entry;
3552 switch (entry->d_tag)
3554 case DT_HP_DLD_FLAGS:
3563 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3564 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3565 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3566 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3567 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3568 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3569 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3570 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3571 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3572 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3573 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3577 bfd_vma val = entry->d_un.d_val;
3579 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3580 if (val & flags[cnt].bit)
3584 fputs (flags[cnt].str, stdout);
3586 val ^= flags[cnt].bit;
3589 if (val != 0 || first)
3593 print_vma (val, HEX);
3599 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3605 get_32bit_dynamic_segment (file)
3608 Elf32_External_Dyn * edyn;
3609 Elf_Internal_Dyn * entry;
3612 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3613 edyn, Elf32_External_Dyn *, "dynamic segment");
3615 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3616 how large this .dynamic is now. We can do this even before the byte
3617 swapping since the DT_NULL tag is recognizable. */
3619 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3622 dynamic_segment = (Elf_Internal_Dyn *)
3623 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3625 if (dynamic_segment == NULL)
3627 error (_("Out of memory\n"));
3632 for (i = 0, entry = dynamic_segment;
3636 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3637 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3646 get_64bit_dynamic_segment (file)
3649 Elf64_External_Dyn * edyn;
3650 Elf_Internal_Dyn * entry;
3653 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3654 edyn, Elf64_External_Dyn *, "dynamic segment");
3656 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3657 how large this .dynamic is now. We can do this even before the byte
3658 swapping since the DT_NULL tag is recognizable. */
3660 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3663 dynamic_segment = (Elf_Internal_Dyn *)
3664 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3666 if (dynamic_segment == NULL)
3668 error (_("Out of memory\n"));
3673 for (i = 0, entry = dynamic_segment;
3677 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3678 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3687 get_dynamic_flags (flags)
3690 static char buff [64];
3695 flag = flags & - flags;
3700 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3701 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3702 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3703 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3704 default: strcat (buff, "unknown "); break;
3710 /* Parse and display the contents of the dynamic segment. */
3712 process_dynamic_segment (file)
3715 Elf_Internal_Dyn * entry;
3718 if (dynamic_size == 0)
3721 printf (_("\nThere is no dynamic segment in this file.\n"));
3728 if (! get_32bit_dynamic_segment (file))
3731 else if (! get_64bit_dynamic_segment (file))
3734 /* Find the appropriate symbol table. */
3735 if (dynamic_symbols == NULL)
3737 for (i = 0, entry = dynamic_segment;
3741 unsigned long offset;
3743 if (entry->d_tag != DT_SYMTAB)
3746 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3748 /* Since we do not know how big the symbol table is,
3749 we default to reading in the entire file (!) and
3750 processing that. This is overkill, I know, but it
3752 offset = entry->d_un.d_val - loadaddr;
3754 if (fseek (file, 0, SEEK_END))
3755 error (_("Unable to seek to end of file!"));
3758 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3760 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3762 if (num_dynamic_syms < 1)
3764 error (_("Unable to determine the number of symbols to load\n"));
3768 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3772 /* Similarly find a string table. */
3773 if (dynamic_strings == NULL)
3775 for (i = 0, entry = dynamic_segment;
3779 unsigned long offset;
3782 if (entry->d_tag != DT_STRTAB)
3785 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3787 /* Since we do not know how big the string table is,
3788 we default to reading in the entire file (!) and
3789 processing that. This is overkill, I know, but it
3792 offset = entry->d_un.d_val - loadaddr;
3793 if (fseek (file, 0, SEEK_END))
3794 error (_("Unable to seek to end of file\n"));
3795 str_tab_len = ftell (file) - offset;
3797 if (str_tab_len < 1)
3800 (_("Unable to determine the length of the dynamic string table\n"));
3804 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3805 "dynamic string table");
3811 /* And find the syminfo section if available. */
3812 if (dynamic_syminfo == NULL)
3814 unsigned int syminsz = 0;
3816 for (i = 0, entry = dynamic_segment;
3820 if (entry->d_tag == DT_SYMINENT)
3822 /* Note: these braces are necessary to avoid a syntax
3823 error from the SunOS4 C compiler. */
3824 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3826 else if (entry->d_tag == DT_SYMINSZ)
3827 syminsz = entry->d_un.d_val;
3828 else if (entry->d_tag == DT_SYMINFO)
3829 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3832 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3834 Elf_External_Syminfo * extsyminfo;
3835 Elf_Internal_Syminfo * syminfo;
3837 /* There is a syminfo section. Read the data. */
3838 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3839 Elf_External_Syminfo *, "symbol information");
3841 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3842 if (dynamic_syminfo == NULL)
3844 error (_("Out of memory\n"));
3848 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3849 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3852 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3853 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3860 if (do_dynamic && dynamic_addr)
3861 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3862 dynamic_addr, (long) dynamic_size);
3864 printf (_(" Tag Type Name/Value\n"));
3866 for (i = 0, entry = dynamic_segment;
3875 print_vma (entry->d_tag, FULL_HEX);
3876 dtype = get_dynamic_type (entry->d_tag);
3877 printf (" (%s)%*s", dtype,
3878 ((is_32bit_elf ? 27 : 19)
3879 - (int) strlen (dtype)),
3883 switch (entry->d_tag)
3887 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3897 switch (entry->d_tag)
3900 printf (_("Auxiliary library"));
3904 printf (_("Filter library"));
3908 printf (_("Configuration file"));
3912 printf (_("Dependency audit library"));
3916 printf (_("Audit library"));
3920 if (dynamic_strings)
3921 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3925 print_vma (entry->d_un.d_val, PREFIX_HEX);
3934 printf (_("Flags:"));
3935 if (entry->d_un.d_val == 0)
3936 printf (_(" None\n"));
3939 unsigned long int val = entry->d_un.d_val;
3940 if (val & DTF_1_PARINIT)
3942 printf (" PARINIT");
3943 val ^= DTF_1_PARINIT;
3945 if (val & DTF_1_CONFEXP)
3947 printf (" CONFEXP");
3948 val ^= DTF_1_CONFEXP;
3951 printf (" %lx", val);
3960 printf (_("Flags:"));
3961 if (entry->d_un.d_val == 0)
3962 printf (_(" None\n"));
3965 unsigned long int val = entry->d_un.d_val;
3966 if (val & DF_P1_LAZYLOAD)
3968 printf (" LAZYLOAD");
3969 val ^= DF_P1_LAZYLOAD;
3971 if (val & DF_P1_GROUPPERM)
3973 printf (" GROUPPERM");
3974 val ^= DF_P1_GROUPPERM;
3977 printf (" %lx", val);
3986 printf (_("Flags:"));
3987 if (entry->d_un.d_val == 0)
3988 printf (_(" None\n"));
3991 unsigned long int val = entry->d_un.d_val;
3997 if (val & DF_1_GLOBAL)
4002 if (val & DF_1_GROUP)
4007 if (val & DF_1_NODELETE)
4009 printf (" NODELETE");
4010 val ^= DF_1_NODELETE;
4012 if (val & DF_1_LOADFLTR)
4014 printf (" LOADFLTR");
4015 val ^= DF_1_LOADFLTR;
4017 if (val & DF_1_INITFIRST)
4019 printf (" INITFIRST");
4020 val ^= DF_1_INITFIRST;
4022 if (val & DF_1_NOOPEN)
4027 if (val & DF_1_ORIGIN)
4032 if (val & DF_1_DIRECT)
4037 if (val & DF_1_TRANS)
4042 if (val & DF_1_INTERPOSE)
4044 printf (" INTERPOSE");
4045 val ^= DF_1_INTERPOSE;
4047 if (val & DF_1_NODEFLIB)
4049 printf (" NODEFLIB");
4050 val ^= DF_1_NODEFLIB;
4052 if (val & DF_1_NODUMP)
4057 if (val & DF_1_CONLFAT)
4059 printf (" CONLFAT");
4060 val ^= DF_1_CONLFAT;
4063 printf (" %lx", val);
4071 puts (get_dynamic_type (entry->d_un.d_val));
4091 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4097 if (dynamic_strings == NULL)
4100 name = dynamic_strings + entry->d_un.d_val;
4104 switch (entry->d_tag)
4107 printf (_("Shared library: [%s]"), name);
4109 if (strcmp (name, program_interpreter) == 0)
4110 printf (_(" program interpreter"));
4114 printf (_("Library soname: [%s]"), name);
4118 printf (_("Library rpath: [%s]"), name);
4122 printf (_("Library runpath: [%s]"), name);
4126 print_vma (entry->d_un.d_val, PREFIX_HEX);
4131 print_vma (entry->d_un.d_val, PREFIX_HEX);
4147 case DT_INIT_ARRAYSZ:
4148 case DT_FINI_ARRAYSZ:
4151 print_vma (entry->d_un.d_val, UNSIGNED);
4152 printf (" (bytes)\n");
4162 print_vma (entry->d_un.d_val, UNSIGNED);
4175 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4179 name = dynamic_strings + entry->d_un.d_val;
4183 printf (_("Not needed object: [%s]\n"), name);
4188 print_vma (entry->d_un.d_val, PREFIX_HEX);
4194 /* The value of this entry is ignored. */
4198 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4199 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4204 switch (elf_header.e_machine)
4207 case EM_MIPS_RS4_BE:
4208 dynamic_segment_mips_val (entry);
4211 dynamic_segment_parisc_val (entry);
4214 print_vma (entry->d_un.d_val, PREFIX_HEX);
4226 get_ver_flags (flags)
4229 static char buff [32];
4236 if (flags & VER_FLG_BASE)
4237 strcat (buff, "BASE ");
4239 if (flags & VER_FLG_WEAK)
4241 if (flags & VER_FLG_BASE)
4242 strcat (buff, "| ");
4244 strcat (buff, "WEAK ");
4247 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4248 strcat (buff, "| <unknown>");
4253 /* Display the contents of the version sections. */
4255 process_version_sections (file)
4258 Elf32_Internal_Shdr * section;
4265 for (i = 0, section = section_headers;
4266 i < elf_header.e_shnum;
4269 switch (section->sh_type)
4271 case SHT_GNU_verdef:
4273 Elf_External_Verdef * edefs;
4280 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4281 SECTION_NAME (section), section->sh_info);
4283 printf (_(" Addr: 0x"));
4284 printf_vma (section->sh_addr);
4285 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4286 (unsigned long) section->sh_offset, section->sh_link,
4287 SECTION_NAME (section_headers + section->sh_link));
4289 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
4290 edefs, Elf_External_Verdef *,
4291 "version definition section");
4293 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
4296 Elf_External_Verdef * edef;
4297 Elf_Internal_Verdef ent;
4298 Elf_External_Verdaux * eaux;
4299 Elf_Internal_Verdaux aux;
4303 vstart = ((char *) edefs) + idx;
4305 edef = (Elf_External_Verdef *) vstart;
4307 ent.vd_version = BYTE_GET (edef->vd_version);
4308 ent.vd_flags = BYTE_GET (edef->vd_flags);
4309 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
4310 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
4311 ent.vd_hash = BYTE_GET (edef->vd_hash);
4312 ent.vd_aux = BYTE_GET (edef->vd_aux);
4313 ent.vd_next = BYTE_GET (edef->vd_next);
4315 printf (_(" %#06x: Rev: %d Flags: %s"),
4316 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
4318 printf (_(" Index: %d Cnt: %d "),
4319 ent.vd_ndx, ent.vd_cnt);
4321 vstart += ent.vd_aux;
4323 eaux = (Elf_External_Verdaux *) vstart;
4325 aux.vda_name = BYTE_GET (eaux->vda_name);
4326 aux.vda_next = BYTE_GET (eaux->vda_next);
4328 if (dynamic_strings)
4329 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
4331 printf (_("Name index: %ld\n"), aux.vda_name);
4333 isum = idx + ent.vd_aux;
4335 for (j = 1; j < ent.vd_cnt; j ++)
4337 isum += aux.vda_next;
4338 vstart += aux.vda_next;
4340 eaux = (Elf_External_Verdaux *) vstart;
4342 aux.vda_name = BYTE_GET (eaux->vda_name);
4343 aux.vda_next = BYTE_GET (eaux->vda_next);
4345 if (dynamic_strings)
4346 printf (_(" %#06x: Parent %d: %s\n"),
4347 isum, j, dynamic_strings + aux.vda_name);
4349 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4350 isum, j, aux.vda_name);
4360 case SHT_GNU_verneed:
4362 Elf_External_Verneed * eneed;
4368 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4369 SECTION_NAME (section), section->sh_info);
4371 printf (_(" Addr: 0x"));
4372 printf_vma (section->sh_addr);
4373 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4374 (unsigned long) section->sh_offset, section->sh_link,
4375 SECTION_NAME (section_headers + section->sh_link));
4377 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
4378 eneed, Elf_External_Verneed *,
4379 "version need section");
4381 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
4383 Elf_External_Verneed * entry;
4384 Elf_Internal_Verneed ent;
4389 vstart = ((char *) eneed) + idx;
4391 entry = (Elf_External_Verneed *) vstart;
4393 ent.vn_version = BYTE_GET (entry->vn_version);
4394 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
4395 ent.vn_file = BYTE_GET (entry->vn_file);
4396 ent.vn_aux = BYTE_GET (entry->vn_aux);
4397 ent.vn_next = BYTE_GET (entry->vn_next);
4399 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
4401 if (dynamic_strings)
4402 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
4404 printf (_(" File: %lx"), ent.vn_file);
4406 printf (_(" Cnt: %d\n"), ent.vn_cnt);
4408 vstart += ent.vn_aux;
4410 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
4412 Elf_External_Vernaux * eaux;
4413 Elf_Internal_Vernaux aux;
4415 eaux = (Elf_External_Vernaux *) vstart;
4417 aux.vna_hash = BYTE_GET (eaux->vna_hash);
4418 aux.vna_flags = BYTE_GET (eaux->vna_flags);
4419 aux.vna_other = BYTE_GET (eaux->vna_other);
4420 aux.vna_name = BYTE_GET (eaux->vna_name);
4421 aux.vna_next = BYTE_GET (eaux->vna_next);
4423 if (dynamic_strings)
4424 printf (_(" %#06x: Name: %s"),
4425 isum, dynamic_strings + aux.vna_name);
4427 printf (_(" %#06x: Name index: %lx"),
4428 isum, aux.vna_name);
4430 printf (_(" Flags: %s Version: %d\n"),
4431 get_ver_flags (aux.vna_flags), aux.vna_other);
4433 isum += aux.vna_next;
4434 vstart += aux.vna_next;
4444 case SHT_GNU_versym:
4446 Elf32_Internal_Shdr * link_section;
4449 unsigned char * edata;
4450 unsigned short * data;
4452 Elf_Internal_Sym * symbols;
4453 Elf32_Internal_Shdr * string_sec;
4455 link_section = section_headers + section->sh_link;
4456 total = section->sh_size / section->sh_entsize;
4460 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
4461 link_section->sh_size / link_section->sh_entsize);
4463 string_sec = section_headers + link_section->sh_link;
4465 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4466 strtab, char *, "version string table");
4468 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4469 SECTION_NAME (section), total);
4471 printf (_(" Addr: "));
4472 printf_vma (section->sh_addr);
4473 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4474 (unsigned long) section->sh_offset, section->sh_link,
4475 SECTION_NAME (link_section));
4477 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4479 total * sizeof (short), edata,
4480 unsigned char *, "version symbol data");
4482 data = (unsigned short *) malloc (total * sizeof (short));
4484 for (cnt = total; cnt --;)
4485 data [cnt] = byte_get (edata + cnt * sizeof (short),
4490 for (cnt = 0; cnt < total; cnt += 4)
4493 int check_def, check_need;
4496 printf (" %03x:", cnt);
4498 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
4499 switch (data [cnt + j])
4502 fputs (_(" 0 (*local*) "), stdout);
4506 fputs (_(" 1 (*global*) "), stdout);
4510 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4511 data [cnt + j] & 0x8000 ? 'h' : ' ');
4515 if (symbols [cnt + j].st_shndx >= SHN_LORESERVE
4516 || section_headers[symbols [cnt + j].st_shndx].sh_type
4519 if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4526 && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
4528 Elf_Internal_Verneed ivn;
4529 unsigned long offset;
4531 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4536 Elf_Internal_Vernaux ivna;
4537 Elf_External_Verneed evn;
4538 Elf_External_Vernaux evna;
4539 unsigned long a_off;
4541 GET_DATA (offset, evn, "version need");
4543 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4544 ivn.vn_next = BYTE_GET (evn.vn_next);
4546 a_off = offset + ivn.vn_aux;
4550 GET_DATA (a_off, evna,
4551 "version need aux (2)");
4553 ivna.vna_next = BYTE_GET (evna.vna_next);
4554 ivna.vna_other = BYTE_GET (evna.vna_other);
4556 a_off += ivna.vna_next;
4558 while (ivna.vna_other != data [cnt + j]
4559 && ivna.vna_next != 0);
4561 if (ivna.vna_other == data [cnt + j])
4563 ivna.vna_name = BYTE_GET (evna.vna_name);
4565 name = strtab + ivna.vna_name;
4566 nn += printf ("(%s%-*s",
4568 12 - (int) strlen (name),
4574 offset += ivn.vn_next;
4576 while (ivn.vn_next);
4579 if (check_def && data [cnt + j] != 0x8001
4580 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
4582 Elf_Internal_Verdef ivd;
4583 Elf_External_Verdef evd;
4584 unsigned long offset;
4586 offset = version_info
4587 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4591 GET_DATA (offset, evd, "version def");
4593 ivd.vd_next = BYTE_GET (evd.vd_next);
4594 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4596 offset += ivd.vd_next;
4598 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4599 && ivd.vd_next != 0);
4601 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4603 Elf_External_Verdaux evda;
4604 Elf_Internal_Verdaux ivda;
4606 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4608 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4609 evda, "version def aux");
4611 ivda.vda_name = BYTE_GET (evda.vda_name);
4613 name = strtab + ivda.vda_name;
4614 nn += printf ("(%s%-*s",
4616 12 - (int) strlen (name),
4622 printf ("%*c", 18 - nn, ' ');
4640 printf (_("\nNo version information found in this file.\n"));
4646 get_symbol_binding (binding)
4647 unsigned int binding;
4649 static char buff [32];
4653 case STB_LOCAL: return "LOCAL";
4654 case STB_GLOBAL: return "GLOBAL";
4655 case STB_WEAK: return "WEAK";
4657 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4658 sprintf (buff, _("<processor specific>: %d"), binding);
4659 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4660 sprintf (buff, _("<OS specific>: %d"), binding);
4662 sprintf (buff, _("<unknown>: %d"), binding);
4668 get_symbol_type (type)
4671 static char buff [32];
4675 case STT_NOTYPE: return "NOTYPE";
4676 case STT_OBJECT: return "OBJECT";
4677 case STT_FUNC: return "FUNC";
4678 case STT_SECTION: return "SECTION";
4679 case STT_FILE: return "FILE";
4680 case STT_COMMON: return "COMMON";
4682 if (type >= STT_LOPROC && type <= STT_HIPROC)
4684 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4685 return "THUMB_FUNC";
4687 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4690 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4691 return "PARISC_MILLI";
4693 sprintf (buff, _("<processor specific>: %d"), type);
4695 else if (type >= STT_LOOS && type <= STT_HIOS)
4697 if (elf_header.e_machine == EM_PARISC)
4699 if (type == STT_HP_OPAQUE)
4701 if (type == STT_HP_STUB)
4705 sprintf (buff, _("<OS specific>: %d"), type);
4708 sprintf (buff, _("<unknown>: %d"), type);
4714 get_symbol_visibility (visibility)
4715 unsigned int visibility;
4719 case STV_DEFAULT: return "DEFAULT";
4720 case STV_INTERNAL: return "INTERNAL";
4721 case STV_HIDDEN: return "HIDDEN";
4722 case STV_PROTECTED: return "PROTECTED";
4728 get_symbol_index_type (type)
4733 case SHN_UNDEF: return "UND";
4734 case SHN_ABS: return "ABS";
4735 case SHN_COMMON: return "COM";
4737 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4739 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4741 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4745 static char buff [32];
4747 sprintf (buff, "%3d", type);
4754 get_dynamic_data (file, number)
4756 unsigned int number;
4758 unsigned char * e_data;
4761 e_data = (unsigned char *) malloc (number * 4);
4765 error (_("Out of memory\n"));
4769 if (fread (e_data, 4, number, file) != number)
4771 error (_("Unable to read in dynamic data\n"));
4775 i_data = (int *) malloc (number * sizeof (* i_data));
4779 error (_("Out of memory\n"));
4785 i_data [number] = byte_get (e_data + number * 4, 4);
4792 /* Dump the symbol table */
4794 process_symbol_table (file)
4797 Elf32_Internal_Shdr * section;
4798 unsigned char nb [4];
4799 unsigned char nc [4];
4802 int * buckets = NULL;
4803 int * chains = NULL;
4805 if (! do_syms && !do_histogram)
4808 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4811 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4813 error (_("Unable to seek to start of dynamic information"));
4817 if (fread (nb, sizeof (nb), 1, file) != 1)
4819 error (_("Failed to read in number of buckets\n"));
4823 if (fread (nc, sizeof (nc), 1, file) != 1)
4825 error (_("Failed to read in number of chains\n"));
4829 nbuckets = byte_get (nb, 4);
4830 nchains = byte_get (nc, 4);
4832 buckets = get_dynamic_data (file, nbuckets);
4833 chains = get_dynamic_data (file, nchains);
4835 if (buckets == NULL || chains == NULL)
4840 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4845 printf (_("\nSymbol table for image:\n"));
4847 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4849 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4851 for (hn = 0; hn < nbuckets; hn++)
4856 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4858 Elf_Internal_Sym * psym;
4860 psym = dynamic_symbols + si;
4862 printf (" %3d %3d: ", si, hn);
4863 print_vma (psym->st_value, LONG_HEX);
4865 print_vma (psym->st_size, DEC_5);
4867 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4868 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4869 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4870 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4871 printf (" %s\n", dynamic_strings + psym->st_name);
4875 else if (do_syms && !do_using_dynamic)
4879 for (i = 0, section = section_headers;
4880 i < elf_header.e_shnum;
4885 Elf_Internal_Sym * symtab;
4886 Elf_Internal_Sym * psym;
4889 if ( section->sh_type != SHT_SYMTAB
4890 && section->sh_type != SHT_DYNSYM)
4893 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4894 SECTION_NAME (section),
4895 (unsigned long) (section->sh_size / section->sh_entsize));
4897 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4899 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4901 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4902 section->sh_size / section->sh_entsize);
4906 if (section->sh_link == elf_header.e_shstrndx)
4907 strtab = string_table;
4910 Elf32_Internal_Shdr * string_sec;
4912 string_sec = section_headers + section->sh_link;
4914 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4915 strtab, char *, "string table");
4918 for (si = 0, psym = symtab;
4919 si < section->sh_size / section->sh_entsize;
4922 printf ("%6d: ", si);
4923 print_vma (psym->st_value, LONG_HEX);
4925 print_vma (psym->st_size, DEC_5);
4926 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4927 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4928 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4929 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4930 printf (" %s", strtab + psym->st_name);
4932 if (section->sh_type == SHT_DYNSYM &&
4933 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4935 unsigned char data[2];
4936 unsigned short vers_data;
4937 unsigned long offset;
4941 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4944 GET_DATA (offset + si * sizeof (vers_data), data,
4947 vers_data = byte_get (data, 2);
4949 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4950 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4953 check_def = (psym->st_shndx != SHN_UNDEF);
4955 if ((vers_data & 0x8000) || vers_data > 1)
4957 if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4958 && (is_nobits || ! check_def))
4960 Elf_External_Verneed evn;
4961 Elf_Internal_Verneed ivn;
4962 Elf_Internal_Vernaux ivna;
4964 /* We must test both. */
4965 offset = version_info
4966 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4970 unsigned long vna_off;
4972 GET_DATA (offset, evn, "version need");
4974 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4975 ivn.vn_next = BYTE_GET (evn.vn_next);
4977 vna_off = offset + ivn.vn_aux;
4981 Elf_External_Vernaux evna;
4983 GET_DATA (vna_off, evna,
4984 "version need aux (3)");
4986 ivna.vna_other = BYTE_GET (evna.vna_other);
4987 ivna.vna_next = BYTE_GET (evna.vna_next);
4988 ivna.vna_name = BYTE_GET (evna.vna_name);
4990 vna_off += ivna.vna_next;
4992 while (ivna.vna_other != vers_data
4993 && ivna.vna_next != 0);
4995 if (ivna.vna_other == vers_data)
4998 offset += ivn.vn_next;
5000 while (ivn.vn_next != 0);
5002 if (ivna.vna_other == vers_data)
5005 strtab + ivna.vna_name, ivna.vna_other);
5008 else if (! is_nobits)
5009 error (_("bad dynamic symbol"));
5016 if (vers_data != 0x8001
5017 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5019 Elf_Internal_Verdef ivd;
5020 Elf_Internal_Verdaux ivda;
5021 Elf_External_Verdaux evda;
5022 unsigned long offset;
5025 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5030 Elf_External_Verdef evd;
5032 GET_DATA (offset, evd, "version def");
5034 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5035 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5036 ivd.vd_next = BYTE_GET (evd.vd_next);
5038 offset += ivd.vd_next;
5040 while (ivd.vd_ndx != (vers_data & 0x7fff)
5041 && ivd.vd_next != 0);
5043 offset -= ivd.vd_next;
5044 offset += ivd.vd_aux;
5046 GET_DATA (offset, evda, "version def aux");
5048 ivda.vda_name = BYTE_GET (evda.vda_name);
5050 if (psym->st_name != ivda.vda_name)
5051 printf ((vers_data & 0x8000)
5053 strtab + ivda.vda_name);
5063 if (strtab != string_table)
5069 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5071 if (do_histogram && buckets != NULL)
5078 int nzero_counts = 0;
5081 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5083 printf (_(" Length Number %% of total Coverage\n"));
5085 lengths = (int *) calloc (nbuckets, sizeof (int));
5086 if (lengths == NULL)
5088 error (_("Out of memory"));
5091 for (hn = 0; hn < nbuckets; ++hn)
5096 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5099 if (maxlength < ++lengths[hn])
5104 counts = (int *) calloc (maxlength + 1, sizeof (int));
5107 error (_("Out of memory"));
5111 for (hn = 0; hn < nbuckets; ++hn)
5112 ++ counts [lengths [hn]];
5116 printf (" 0 %-10d (%5.1f%%)\n",
5117 counts[0], (counts[0] * 100.0) / nbuckets);
5118 for (si = 1; si <= maxlength; ++si)
5120 nzero_counts += counts[si] * si;
5121 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5122 si, counts[si], (counts[si] * 100.0) / nbuckets,
5123 (nzero_counts * 100.0) / nsyms);
5131 if (buckets != NULL)
5141 process_syminfo (file)
5142 FILE * file ATTRIBUTE_UNUSED;
5146 if (dynamic_syminfo == NULL
5148 /* No syminfo, this is ok. */
5151 /* There better should be a dynamic symbol section. */
5152 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5156 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5157 dynamic_syminfo_offset, dynamic_syminfo_nent);
5159 printf (_(" Num: Name BoundTo Flags\n"));
5160 for (i = 0; i < dynamic_syminfo_nent; ++i)
5162 unsigned short int flags = dynamic_syminfo[i].si_flags;
5164 printf ("%4d: %-30s ", i,
5165 dynamic_strings + dynamic_symbols[i].st_name);
5167 switch (dynamic_syminfo[i].si_boundto)
5169 case SYMINFO_BT_SELF:
5170 fputs ("SELF ", stdout);
5172 case SYMINFO_BT_PARENT:
5173 fputs ("PARENT ", stdout);
5176 if (dynamic_syminfo[i].si_boundto > 0
5177 && dynamic_syminfo[i].si_boundto < dynamic_size)
5180 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
5182 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5186 if (flags & SYMINFO_FLG_DIRECT)
5188 if (flags & SYMINFO_FLG_PASSTHRU)
5189 printf (" PASSTHRU");
5190 if (flags & SYMINFO_FLG_COPY)
5192 if (flags & SYMINFO_FLG_LAZYLOAD)
5193 printf (" LAZYLOAD");
5201 #ifdef SUPPORT_DISASSEMBLY
5203 disassemble_section (section, file)
5204 Elf32_Internal_Shdr * section;
5207 printf (_("\nAssembly dump of section %s\n"),
5208 SECTION_NAME (section));
5210 /* XXX -- to be done --- XXX */
5217 dump_section (section, file)
5218 Elf32_Internal_Shdr * section;
5221 bfd_size_type bytes;
5223 unsigned char * data;
5224 unsigned char * start;
5226 bytes = section->sh_size;
5230 printf (_("\nSection '%s' has no data to dump.\n"),
5231 SECTION_NAME (section));
5235 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5237 addr = section->sh_addr;
5239 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
5250 lbytes = (bytes > 16 ? 16 : bytes);
5252 printf (" 0x%8.8lx ", (unsigned long) addr);
5254 switch (elf_header.e_ident [EI_DATA])
5258 for (j = 15; j >= 0; j --)
5261 printf ("%2.2x", data [j]);
5271 for (j = 0; j < 16; j++)
5274 printf ("%2.2x", data [j]);
5284 for (j = 0; j < lbytes; j++)
5287 if (k >= ' ' && k < 0x80)
5306 static unsigned long int
5307 read_leb128 (data, length_return, sign)
5308 unsigned char * data;
5309 int * length_return;
5312 unsigned long int result = 0;
5313 unsigned int num_read = 0;
5322 result |= (byte & 0x7f) << shift;
5327 while (byte & 0x80);
5329 if (length_return != NULL)
5330 * length_return = num_read;
5332 if (sign && (shift < 32) && (byte & 0x40))
5333 result |= -1 << shift;
5338 typedef struct State_Machine_Registers
5340 unsigned long address;
5343 unsigned int column;
5347 /* This variable hold the number of the last entry seen
5348 in the File Table. */
5349 unsigned int last_file_entry;
5352 static SMR state_machine_regs;
5355 reset_state_machine (is_stmt)
5358 state_machine_regs.address = 0;
5359 state_machine_regs.file = 1;
5360 state_machine_regs.line = 1;
5361 state_machine_regs.column = 0;
5362 state_machine_regs.is_stmt = is_stmt;
5363 state_machine_regs.basic_block = 0;
5364 state_machine_regs.end_sequence = 0;
5365 state_machine_regs.last_file_entry = 0;
5368 /* Handled an extend line op. Returns true if this is the end
5371 process_extended_line_op (data, is_stmt, pointer_size)
5372 unsigned char * data;
5376 unsigned char op_code;
5379 unsigned char * name;
5382 len = read_leb128 (data, & bytes_read, 0);
5387 warn (_("badly formed extended line op encountered!"));
5392 op_code = * data ++;
5394 printf (_(" Extended opcode %d: "), op_code);
5398 case DW_LNE_end_sequence:
5399 printf (_("End of Sequence\n\n"));
5400 reset_state_machine (is_stmt);
5403 case DW_LNE_set_address:
5404 adr = byte_get (data, pointer_size);
5405 printf (_("set Address to 0x%lx\n"), adr);
5406 state_machine_regs.address = adr;
5409 case DW_LNE_define_file:
5410 printf (_(" define new File Table entry\n"));
5411 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5413 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5415 data += strlen ((char *) data) + 1;
5416 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5418 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5420 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5421 printf (_("%s\n\n"), name);
5425 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5432 /* Size of pointers in the .debug_line section. This information is not
5433 really present in that section. It's obtained before dumping the debug
5434 sections by doing some pre-scan of the .debug_info section. */
5435 static int debug_line_pointer_size = 4;
5438 display_debug_lines (section, start, file)
5439 Elf32_Internal_Shdr * section;
5440 unsigned char * start;
5441 FILE * file ATTRIBUTE_UNUSED;
5443 DWARF2_External_LineInfo * external;
5444 DWARF2_Internal_LineInfo info;
5445 unsigned char * standard_opcodes;
5446 unsigned char * data = start;
5447 unsigned char * end = start + section->sh_size;
5448 unsigned char * end_of_sequence;
5451 printf (_("\nDump of debug contents of section %s:\n\n"),
5452 SECTION_NAME (section));
5456 external = (DWARF2_External_LineInfo *) data;
5458 /* Check the length of the block. */
5459 info.li_length = BYTE_GET (external->li_length);
5460 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5463 (_("The line info appears to be corrupt - the section is too small\n"));
5467 /* Check its version number. */
5468 info.li_version = BYTE_GET (external->li_version);
5469 if (info.li_version != 2)
5471 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5475 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5476 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5477 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5478 info.li_line_base = BYTE_GET (external->li_line_base);
5479 info.li_line_range = BYTE_GET (external->li_line_range);
5480 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5482 /* Sign extend the line base field. */
5483 info.li_line_base <<= 24;
5484 info.li_line_base >>= 24;
5486 printf (_(" Length: %ld\n"), info.li_length);
5487 printf (_(" DWARF Version: %d\n"), info.li_version);
5488 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
5489 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5490 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5491 printf (_(" Line Base: %d\n"), info.li_line_base);
5492 printf (_(" Line Range: %d\n"), info.li_line_range);
5493 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5495 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5497 reset_state_machine (info.li_default_is_stmt);
5499 /* Display the contents of the Opcodes table. */
5500 standard_opcodes = data + sizeof (* external);
5502 printf (_("\n Opcodes:\n"));
5504 for (i = 1; i < info.li_opcode_base; i++)
5505 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5507 /* Display the contents of the Directory table. */
5508 data = standard_opcodes + info.li_opcode_base - 1;
5511 printf (_("\n The Directory Table is empty.\n"));
5514 printf (_("\n The Directory Table:\n"));
5518 printf (_(" %s\n"), data);
5520 data += strlen ((char *) data) + 1;
5524 /* Skip the NUL at the end of the table. */
5527 /* Display the contents of the File Name table. */
5529 printf (_("\n The File Name Table is empty.\n"));
5532 printf (_("\n The File Name Table:\n"));
5533 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5537 unsigned char * name;
5540 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5543 data += strlen ((char *) data) + 1;
5545 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5547 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5549 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5551 printf (_("%s\n"), name);
5555 /* Skip the NUL at the end of the table. */
5558 /* Now display the statements. */
5559 printf (_("\n Line Number Statements:\n"));
5562 while (data < end_of_sequence)
5564 unsigned char op_code;
5568 op_code = * data ++;
5572 case DW_LNS_extended_op:
5573 data += process_extended_line_op (data, info.li_default_is_stmt,
5574 debug_line_pointer_size);
5578 printf (_(" Copy\n"));
5581 case DW_LNS_advance_pc:
5582 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5584 state_machine_regs.address += adv;
5585 printf (_(" Advance PC by %d to %lx\n"), adv,
5586 state_machine_regs.address);
5589 case DW_LNS_advance_line:
5590 adv = read_leb128 (data, & bytes_read, 1);
5592 state_machine_regs.line += adv;
5593 printf (_(" Advance Line by %d to %d\n"), adv,
5594 state_machine_regs.line);
5597 case DW_LNS_set_file:
5598 adv = read_leb128 (data, & bytes_read, 0);
5600 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5602 state_machine_regs.file = adv;
5605 case DW_LNS_set_column:
5606 adv = read_leb128 (data, & bytes_read, 0);
5608 printf (_(" Set column to %d\n"), adv);
5609 state_machine_regs.column = adv;
5612 case DW_LNS_negate_stmt:
5613 adv = state_machine_regs.is_stmt;
5615 printf (_(" Set is_stmt to %d\n"), adv);
5616 state_machine_regs.is_stmt = adv;
5619 case DW_LNS_set_basic_block:
5620 printf (_(" Set basic block\n"));
5621 state_machine_regs.basic_block = 1;
5624 case DW_LNS_const_add_pc:
5625 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5626 * info.li_min_insn_length);
5627 state_machine_regs.address += adv;
5628 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5629 state_machine_regs.address);
5632 case DW_LNS_fixed_advance_pc:
5633 adv = byte_get (data, 2);
5635 state_machine_regs.address += adv;
5636 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5637 adv, state_machine_regs.address);
5641 op_code -= info.li_opcode_base;
5642 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5643 state_machine_regs.address += adv;
5644 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5645 op_code, adv, state_machine_regs.address);
5646 adv = (op_code % info.li_line_range) + info.li_line_base;
5647 state_machine_regs.line += adv;
5648 printf (_(" and Line by %d to %d\n"),
5649 adv, state_machine_regs.line);
5660 display_debug_pubnames (section, start, file)
5661 Elf32_Internal_Shdr * section;
5662 unsigned char * start;
5663 FILE * file ATTRIBUTE_UNUSED;
5665 DWARF2_External_PubNames * external;
5666 DWARF2_Internal_PubNames pubnames;
5667 unsigned char * end;
5669 end = start + section->sh_size;
5671 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5675 unsigned char * data;
5676 unsigned long offset;
5678 external = (DWARF2_External_PubNames *) start;
5680 pubnames.pn_length = BYTE_GET (external->pn_length);
5681 pubnames.pn_version = BYTE_GET (external->pn_version);
5682 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5683 pubnames.pn_size = BYTE_GET (external->pn_size);
5685 data = start + sizeof (* external);
5686 start += pubnames.pn_length + sizeof (external->pn_length);
5688 if (pubnames.pn_version != 2)
5690 static int warned = 0;
5694 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5701 printf (_(" Length: %ld\n"),
5702 pubnames.pn_length);
5703 printf (_(" Version: %d\n"),
5704 pubnames.pn_version);
5705 printf (_(" Offset into .debug_info section: %ld\n"),
5706 pubnames.pn_offset);
5707 printf (_(" Size of area in .debug_info section: %ld\n"),
5710 printf (_("\n Offset\tName\n"));
5714 offset = byte_get (data, 4);
5719 printf (" %ld\t\t%s\n", offset, data);
5720 data += strlen ((char *) data) + 1;
5723 while (offset != 0);
5736 case DW_TAG_padding: return "DW_TAG_padding";
5737 case DW_TAG_array_type: return "DW_TAG_array_type";
5738 case DW_TAG_class_type: return "DW_TAG_class_type";
5739 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5740 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5741 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5742 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5743 case DW_TAG_label: return "DW_TAG_label";
5744 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5745 case DW_TAG_member: return "DW_TAG_member";
5746 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5747 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5748 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5749 case DW_TAG_string_type: return "DW_TAG_string_type";
5750 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5751 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5752 case DW_TAG_typedef: return "DW_TAG_typedef";
5753 case DW_TAG_union_type: return "DW_TAG_union_type";
5754 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5755 case DW_TAG_variant: return "DW_TAG_variant";
5756 case DW_TAG_common_block: return "DW_TAG_common_block";
5757 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5758 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5759 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5760 case DW_TAG_module: return "DW_TAG_module";
5761 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5762 case DW_TAG_set_type: return "DW_TAG_set_type";
5763 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5764 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5765 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5766 case DW_TAG_base_type: return "DW_TAG_base_type";
5767 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5768 case DW_TAG_const_type: return "DW_TAG_const_type";
5769 case DW_TAG_constant: return "DW_TAG_constant";
5770 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5771 case DW_TAG_file_type: return "DW_TAG_file_type";
5772 case DW_TAG_friend: return "DW_TAG_friend";
5773 case DW_TAG_namelist: return "DW_TAG_namelist";
5774 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5775 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5776 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5777 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5778 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5779 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5780 case DW_TAG_try_block: return "DW_TAG_try_block";
5781 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5782 case DW_TAG_variable: return "DW_TAG_variable";
5783 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5784 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5785 case DW_TAG_format_label: return "DW_TAG_format_label";
5786 case DW_TAG_function_template: return "DW_TAG_function_template";
5787 case DW_TAG_class_template: return "DW_TAG_class_template";
5790 static char buffer [100];
5792 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5799 get_AT_name (attribute)
5800 unsigned long attribute;
5804 case DW_AT_sibling: return "DW_AT_sibling";
5805 case DW_AT_location: return "DW_AT_location";
5806 case DW_AT_name: return "DW_AT_name";
5807 case DW_AT_ordering: return "DW_AT_ordering";
5808 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5809 case DW_AT_byte_size: return "DW_AT_byte_size";
5810 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5811 case DW_AT_bit_size: return "DW_AT_bit_size";
5812 case DW_AT_element_list: return "DW_AT_element_list";
5813 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5814 case DW_AT_low_pc: return "DW_AT_low_pc";
5815 case DW_AT_high_pc: return "DW_AT_high_pc";
5816 case DW_AT_language: return "DW_AT_language";
5817 case DW_AT_member: return "DW_AT_member";
5818 case DW_AT_discr: return "DW_AT_discr";
5819 case DW_AT_discr_value: return "DW_AT_discr_value";
5820 case DW_AT_visibility: return "DW_AT_visibility";
5821 case DW_AT_import: return "DW_AT_import";
5822 case DW_AT_string_length: return "DW_AT_string_length";
5823 case DW_AT_common_reference: return "DW_AT_common_reference";
5824 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5825 case DW_AT_const_value: return "DW_AT_const_value";
5826 case DW_AT_containing_type: return "DW_AT_containing_type";
5827 case DW_AT_default_value: return "DW_AT_default_value";
5828 case DW_AT_inline: return "DW_AT_inline";
5829 case DW_AT_is_optional: return "DW_AT_is_optional";
5830 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5831 case DW_AT_producer: return "DW_AT_producer";
5832 case DW_AT_prototyped: return "DW_AT_prototyped";
5833 case DW_AT_return_addr: return "DW_AT_return_addr";
5834 case DW_AT_start_scope: return "DW_AT_start_scope";
5835 case DW_AT_stride_size: return "DW_AT_stride_size";
5836 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5837 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5838 case DW_AT_accessibility: return "DW_AT_accessibility";
5839 case DW_AT_address_class: return "DW_AT_address_class";
5840 case DW_AT_artificial: return "DW_AT_artificial";
5841 case DW_AT_base_types: return "DW_AT_base_types";
5842 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5843 case DW_AT_count: return "DW_AT_count";
5844 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5845 case DW_AT_decl_column: return "DW_AT_decl_column";
5846 case DW_AT_decl_file: return "DW_AT_decl_file";
5847 case DW_AT_decl_line: return "DW_AT_decl_line";
5848 case DW_AT_declaration: return "DW_AT_declaration";
5849 case DW_AT_discr_list: return "DW_AT_discr_list";
5850 case DW_AT_encoding: return "DW_AT_encoding";
5851 case DW_AT_external: return "DW_AT_external";
5852 case DW_AT_frame_base: return "DW_AT_frame_base";
5853 case DW_AT_friend: return "DW_AT_friend";
5854 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5855 case DW_AT_macro_info: return "DW_AT_macro_info";
5856 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5857 case DW_AT_priority: return "DW_AT_priority";
5858 case DW_AT_segment: return "DW_AT_segment";
5859 case DW_AT_specification: return "DW_AT_specification";
5860 case DW_AT_static_link: return "DW_AT_static_link";
5861 case DW_AT_type: return "DW_AT_type";
5862 case DW_AT_use_location: return "DW_AT_use_location";
5863 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5864 case DW_AT_virtuality: return "DW_AT_virtuality";
5865 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5866 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5867 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5868 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5869 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5870 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5871 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5872 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5873 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5874 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5875 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5876 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5877 case DW_AT_sf_names: return "DW_AT_sf_names";
5878 case DW_AT_src_info: return "DW_AT_src_info";
5879 case DW_AT_mac_info: return "DW_AT_mac_info";
5880 case DW_AT_src_coords: return "DW_AT_src_coords";
5881 case DW_AT_body_begin: return "DW_AT_body_begin";
5882 case DW_AT_body_end: return "DW_AT_body_end";
5885 static char buffer [100];
5887 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5894 get_FORM_name (form)
5899 case DW_FORM_addr: return "DW_FORM_addr";
5900 case DW_FORM_block2: return "DW_FORM_block2";
5901 case DW_FORM_block4: return "DW_FORM_block4";
5902 case DW_FORM_data2: return "DW_FORM_data2";
5903 case DW_FORM_data4: return "DW_FORM_data4";
5904 case DW_FORM_data8: return "DW_FORM_data8";
5905 case DW_FORM_string: return "DW_FORM_string";
5906 case DW_FORM_block: return "DW_FORM_block";
5907 case DW_FORM_block1: return "DW_FORM_block1";
5908 case DW_FORM_data1: return "DW_FORM_data1";
5909 case DW_FORM_flag: return "DW_FORM_flag";
5910 case DW_FORM_sdata: return "DW_FORM_sdata";
5911 case DW_FORM_strp: return "DW_FORM_strp";
5912 case DW_FORM_udata: return "DW_FORM_udata";
5913 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5914 case DW_FORM_ref1: return "DW_FORM_ref1";
5915 case DW_FORM_ref2: return "DW_FORM_ref2";
5916 case DW_FORM_ref4: return "DW_FORM_ref4";
5917 case DW_FORM_ref8: return "DW_FORM_ref8";
5918 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5919 case DW_FORM_indirect: return "DW_FORM_indirect";
5922 static char buffer [100];
5924 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5930 /* FIXME: There are better and more effiecint ways to handle
5931 these structures. For now though, I just want something that
5932 is simple to implement. */
5933 typedef struct abbrev_attr
5935 unsigned long attribute;
5937 struct abbrev_attr * next;
5941 typedef struct abbrev_entry
5943 unsigned long entry;
5946 struct abbrev_attr * first_attr;
5947 struct abbrev_attr * last_attr;
5948 struct abbrev_entry * next;
5952 static abbrev_entry * first_abbrev = NULL;
5953 static abbrev_entry * last_abbrev = NULL;
5956 free_abbrevs PARAMS ((void))
5958 abbrev_entry * abbrev;
5960 for (abbrev = first_abbrev; abbrev;)
5962 abbrev_entry * next = abbrev->next;
5965 for (attr = abbrev->first_attr; attr;)
5967 abbrev_attr * next = attr->next;
5977 last_abbrev = first_abbrev = NULL;
5981 add_abbrev (number, tag, children)
5982 unsigned long number;
5986 abbrev_entry * entry;
5988 entry = (abbrev_entry *) malloc (sizeof (* entry));
5994 entry->entry = number;
5996 entry->children = children;
5997 entry->first_attr = NULL;
5998 entry->last_attr = NULL;
6001 if (first_abbrev == NULL)
6002 first_abbrev = entry;
6004 last_abbrev->next = entry;
6006 last_abbrev = entry;
6010 add_abbrev_attr (attribute, form)
6011 unsigned long attribute;
6016 attr = (abbrev_attr *) malloc (sizeof (* attr));
6022 attr->attribute = attribute;
6026 if (last_abbrev->first_attr == NULL)
6027 last_abbrev->first_attr = attr;
6029 last_abbrev->last_attr->next = attr;
6031 last_abbrev->last_attr = attr;
6034 /* Processes the (partial) contents of a .debug_abbrev section.
6035 Returns NULL if the end of the section was encountered.
6036 Returns the address after the last byte read if the end of
6037 an abbreviation set was found. */
6039 static unsigned char *
6040 process_abbrev_section (start, end)
6041 unsigned char * start;
6042 unsigned char * end;
6044 if (first_abbrev != NULL)
6050 unsigned long entry;
6052 unsigned long attribute;
6055 entry = read_leb128 (start, & bytes_read, 0);
6056 start += bytes_read;
6058 /* A single zero is supposed to end the section according
6059 to the standard. If there's more, then signal that to
6062 return start == end ? NULL : start;
6064 tag = read_leb128 (start, & bytes_read, 0);
6065 start += bytes_read;
6067 children = * start ++;
6069 add_abbrev (entry, tag, children);
6075 attribute = read_leb128 (start, & bytes_read, 0);
6076 start += bytes_read;
6078 form = read_leb128 (start, & bytes_read, 0);
6079 start += bytes_read;
6082 add_abbrev_attr (attribute, form);
6084 while (attribute != 0);
6092 display_debug_abbrev (section, start, file)
6093 Elf32_Internal_Shdr * section;
6094 unsigned char * start;
6095 FILE * file ATTRIBUTE_UNUSED;
6097 abbrev_entry * entry;
6098 unsigned char * end = start + section->sh_size;
6100 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6104 start = process_abbrev_section (start, end);
6106 printf (_(" Number TAG\n"));
6108 for (entry = first_abbrev; entry; entry = entry->next)
6112 printf (_(" %ld %s [%s]\n"),
6114 get_TAG_name (entry->tag),
6115 entry->children ? _("has children") : _("no children"));
6117 for (attr = entry->first_attr; attr; attr = attr->next)
6119 printf (_(" %-18s %s\n"),
6120 get_AT_name (attr->attribute),
6121 get_FORM_name (attr->form));
6133 static unsigned char *
6134 display_block (data, length)
6135 unsigned char * data;
6136 unsigned long length;
6138 printf (_(" %lu byte block: "), length);
6141 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6147 decode_location_expression (data, pointer_size, length)
6148 unsigned char * data;
6149 unsigned int pointer_size;
6150 unsigned long length;
6154 unsigned long uvalue;
6155 unsigned char * end = data + length;
6164 printf ("DW_OP_addr: %lx",
6165 (unsigned long) byte_get (data, pointer_size));
6166 data += pointer_size;
6169 printf ("DW_OP_deref");
6172 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6175 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6178 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6182 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6186 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6190 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6194 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6195 (unsigned long) byte_get (data + 4, 4));
6199 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6200 (long) byte_get (data + 4, 4));
6204 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6208 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6212 printf ("DW_OP_dup");
6215 printf ("DW_OP_drop");
6218 printf ("DW_OP_over");
6221 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6224 printf ("DW_OP_swap");
6227 printf ("DW_OP_rot");
6230 printf ("DW_OP_xderef");
6233 printf ("DW_OP_abs");
6236 printf ("DW_OP_and");
6239 printf ("DW_OP_div");
6242 printf ("DW_OP_minus");
6245 printf ("DW_OP_mod");
6248 printf ("DW_OP_mul");
6251 printf ("DW_OP_neg");
6254 printf ("DW_OP_not");
6257 printf ("DW_OP_or");
6260 printf ("DW_OP_plus");
6262 case DW_OP_plus_uconst:
6263 printf ("DW_OP_plus_uconst: %lu",
6264 read_leb128 (data, &bytes_read, 0));
6268 printf ("DW_OP_shl");
6271 printf ("DW_OP_shr");
6274 printf ("DW_OP_shra");
6277 printf ("DW_OP_xor");
6280 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
6284 printf ("DW_OP_eq");
6287 printf ("DW_OP_ge");
6290 printf ("DW_OP_gt");
6293 printf ("DW_OP_le");
6296 printf ("DW_OP_lt");
6299 printf ("DW_OP_ne");
6302 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
6338 printf ("DW_OP_lit%d", op - DW_OP_lit0);
6373 printf ("DW_OP_reg%d", op - DW_OP_reg0);
6408 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
6409 read_leb128 (data, &bytes_read, 1));
6414 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6418 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6422 uvalue = read_leb128 (data, &bytes_read, 0);
6424 printf ("DW_OP_bregx: %lu %ld", uvalue,
6425 read_leb128 (data, &bytes_read, 1));
6429 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6432 case DW_OP_deref_size:
6433 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6435 case DW_OP_xderef_size:
6436 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6439 printf ("DW_OP_nop");
6443 if (op >= DW_OP_lo_user
6444 && op <= DW_OP_hi_user)
6445 printf (_("(User defined location op)"));
6447 printf (_("(Unknown location op)"));
6448 /* No way to tell where the next op is, so just bail. */
6455 static unsigned char *
6456 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6457 unsigned long attribute;
6459 unsigned char * data;
6460 unsigned long cu_offset;
6461 unsigned long pointer_size;
6463 unsigned long uvalue = 0;
6464 unsigned char * block_start = NULL;
6467 printf (" %-18s:", get_AT_name (attribute));
6474 case DW_FORM_ref_addr:
6476 uvalue = byte_get (data, pointer_size);
6477 data += pointer_size;
6483 uvalue = byte_get (data ++, 1);
6488 uvalue = byte_get (data, 2);
6494 uvalue = byte_get (data, 4);
6499 uvalue = read_leb128 (data, & bytes_read, 1);
6503 case DW_FORM_ref_udata:
6505 uvalue = read_leb128 (data, & bytes_read, 0);
6512 case DW_FORM_ref_addr:
6513 printf (" <#%lx>", uvalue);
6519 case DW_FORM_ref_udata:
6520 printf (" <%lx>", uvalue + cu_offset);
6524 printf (" %#lx", uvalue);
6532 printf (" %ld", uvalue);
6537 uvalue = byte_get (data, 4);
6538 printf (" %lx", uvalue);
6539 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6543 case DW_FORM_string:
6544 printf (" %s", data);
6545 data += strlen ((char *) data) + 1;
6549 uvalue = read_leb128 (data, & bytes_read, 0);
6550 block_start = data + bytes_read;
6551 data = display_block (block_start, uvalue);
6554 case DW_FORM_block1:
6555 uvalue = byte_get (data, 1);
6556 block_start = data + 1;
6557 data = display_block (block_start, uvalue);
6560 case DW_FORM_block2:
6561 uvalue = byte_get (data, 2);
6562 block_start = data + 2;
6563 data = display_block (block_start, uvalue);
6566 case DW_FORM_block4:
6567 uvalue = byte_get (data, 4);
6568 block_start = data + 4;
6569 data = display_block (block_start, uvalue);
6573 case DW_FORM_indirect:
6574 warn (_("Unable to handle FORM: %d"), form);
6578 warn (_("Unrecognised form: %d"), form);
6582 /* For some attributes we can display futher information. */
6591 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6592 case DW_INL_inlined: printf (_("(inlined)")); break;
6593 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6594 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6595 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6599 case DW_AT_language:
6602 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6603 case DW_LANG_C89: printf ("(ANSI C)"); break;
6604 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6605 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6606 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6607 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6608 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6609 case DW_LANG_Ada83: printf ("(Ada)"); break;
6610 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6611 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6612 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6613 default: printf ("(Unknown: %lx)", uvalue); break;
6617 case DW_AT_encoding:
6620 case DW_ATE_void: printf ("(void)"); break;
6621 case DW_ATE_address: printf ("(machine address)"); break;
6622 case DW_ATE_boolean: printf ("(boolean)"); break;
6623 case DW_ATE_complex_float: printf ("(complex float)"); break;
6624 case DW_ATE_float: printf ("(float)"); break;
6625 case DW_ATE_signed: printf ("(signed)"); break;
6626 case DW_ATE_signed_char: printf ("(signed char)"); break;
6627 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6628 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6630 if (uvalue >= DW_ATE_lo_user
6631 && uvalue <= DW_ATE_hi_user)
6632 printf ("(user defined type)");
6634 printf ("(unknown type)");
6639 case DW_AT_accessibility:
6642 case DW_ACCESS_public: printf ("(public)"); break;
6643 case DW_ACCESS_protected: printf ("(protected)"); break;
6644 case DW_ACCESS_private: printf ("(private)"); break;
6645 default: printf ("(unknown accessibility)"); break;
6649 case DW_AT_visibility:
6652 case DW_VIS_local: printf ("(local)"); break;
6653 case DW_VIS_exported: printf ("(exported)"); break;
6654 case DW_VIS_qualified: printf ("(qualified)"); break;
6655 default: printf ("(unknown visibility)"); break;
6659 case DW_AT_virtuality:
6662 case DW_VIRTUALITY_none: printf ("(none)"); break;
6663 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6664 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6665 default: printf ("(unknown virtuality)"); break;
6669 case DW_AT_identifier_case:
6672 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6673 case DW_ID_up_case: printf ("(up_case)"); break;
6674 case DW_ID_down_case: printf ("(down_case)"); break;
6675 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6676 default: printf ("(unknown case)"); break;
6680 case DW_AT_calling_convention:
6683 case DW_CC_normal: printf ("(normal)"); break;
6684 case DW_CC_program: printf ("(program)"); break;
6685 case DW_CC_nocall: printf ("(nocall)"); break;
6687 if (uvalue >= DW_CC_lo_user
6688 && uvalue <= DW_CC_hi_user)
6689 printf ("(user defined)");
6691 printf ("(unknown convention)");
6695 case DW_AT_frame_base:
6696 case DW_AT_location:
6697 case DW_AT_data_member_location:
6698 case DW_AT_vtable_elem_location:
6702 decode_location_expression (block_start, pointer_size, uvalue);
6716 display_debug_info (section, start, file)
6717 Elf32_Internal_Shdr * section;
6718 unsigned char * start;
6721 unsigned char * end = start + section->sh_size;
6722 unsigned char * section_begin = start;
6724 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6728 DWARF2_External_CompUnit * external;
6729 DWARF2_Internal_CompUnit compunit;
6730 unsigned char * tags;
6733 unsigned long cu_offset;
6735 external = (DWARF2_External_CompUnit *) start;
6737 compunit.cu_length = BYTE_GET (external->cu_length);
6738 compunit.cu_version = BYTE_GET (external->cu_version);
6739 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6740 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6742 tags = start + sizeof (* external);
6743 cu_offset = start - section_begin;
6744 start += compunit.cu_length + sizeof (external->cu_length);
6746 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
6747 printf (_(" Length: %ld\n"), compunit.cu_length);
6748 printf (_(" Version: %d\n"), compunit.cu_version);
6749 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6750 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6752 if (compunit.cu_version != 2)
6754 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6758 if (first_abbrev != NULL)
6761 /* Read in the abbrevs used by this compilation unit. */
6764 Elf32_Internal_Shdr * sec;
6765 unsigned char * begin;
6767 /* Locate the .debug_abbrev section and process it. */
6768 for (i = 0, sec = section_headers;
6769 i < elf_header.e_shnum;
6771 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6774 if (i == -1 || sec->sh_size == 0)
6776 warn (_("Unable to locate .debug_abbrev section!\n"));
6780 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6781 "debug_abbrev section data");
6783 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6784 begin + sec->sh_size);
6790 while (tags < start)
6793 unsigned long abbrev_number;
6794 abbrev_entry * entry;
6797 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6800 /* A null DIE marks the end of a list of children. */
6801 if (abbrev_number == 0)
6807 /* Scan through the abbreviation list until we reach the
6809 for (entry = first_abbrev;
6810 entry && entry->entry != abbrev_number;
6811 entry = entry->next)
6816 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6821 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6822 level, tags - section_begin - bytes_read,
6824 get_TAG_name (entry->tag));
6826 for (attr = entry->first_attr; attr; attr = attr->next)
6827 tags = read_and_display_attr (attr->attribute,
6830 compunit.cu_pointer_size);
6832 if (entry->children)
6843 display_debug_aranges (section, start, file)
6844 Elf32_Internal_Shdr * section;
6845 unsigned char * start;
6846 FILE * file ATTRIBUTE_UNUSED;
6848 unsigned char * end = start + section->sh_size;
6850 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6854 DWARF2_External_ARange * external;
6855 DWARF2_Internal_ARange arange;
6856 unsigned char * ranges;
6857 unsigned long length;
6858 unsigned long address;
6861 external = (DWARF2_External_ARange *) start;
6863 arange.ar_length = BYTE_GET (external->ar_length);
6864 arange.ar_version = BYTE_GET (external->ar_version);
6865 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6866 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6867 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6869 if (arange.ar_version != 2)
6871 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6875 printf (_(" Length: %ld\n"), arange.ar_length);
6876 printf (_(" Version: %d\n"), arange.ar_version);
6877 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6878 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6879 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6881 printf (_("\n Address Length\n"));
6883 ranges = start + sizeof (* external);
6885 /* Must pad to an alignment boundary that is twice the pointer size. */
6886 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
6888 ranges += (2 * arange.ar_pointer_size) - excess;
6892 address = byte_get (ranges, arange.ar_pointer_size);
6894 ranges += arange.ar_pointer_size;
6896 length = byte_get (ranges, arange.ar_pointer_size);
6898 ranges += arange.ar_pointer_size;
6900 /* A pair of zeros marks the end of the list. */
6901 if (address == 0 && length == 0)
6904 printf (" %8.8lx %lu\n", address, length);
6907 start += arange.ar_length + sizeof (external->ar_length);
6915 typedef struct Frame_Chunk
6917 struct Frame_Chunk * next;
6918 unsigned char * chunk_start;
6920 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6921 short int * col_type;
6923 char * augmentation;
6924 unsigned int code_factor;
6925 unsigned int data_factor;
6926 unsigned long pc_begin;
6927 unsigned long pc_range;
6934 /* A marker for a col_type that means this column was never referenced
6935 in the frame info. */
6936 #define DW_CFA_unreferenced (-1)
6939 frame_need_space (fc, reg)
6943 int prev = fc->ncols;
6945 if (reg < fc->ncols)
6948 fc->ncols = reg + 1;
6949 fc->col_type = (short int *) xrealloc (fc->col_type,
6950 fc->ncols * sizeof (short int));
6951 fc->col_offset = (int *) xrealloc (fc->col_offset,
6952 fc->ncols * sizeof (int));
6954 while (prev < fc->ncols)
6956 fc->col_type[prev] = DW_CFA_unreferenced;
6957 fc->col_offset[prev] = 0;
6963 frame_display_row (fc, need_col_headers, max_regs)
6965 int * need_col_headers;
6971 if (* max_regs < fc->ncols)
6972 * max_regs = fc->ncols;
6974 if (* need_col_headers)
6976 * need_col_headers = 0;
6978 printf (" LOC CFA ");
6980 for (r = 0; r < * max_regs; r++)
6981 if (fc->col_type[r] != DW_CFA_unreferenced)
6986 printf ("r%-4d", r);
6992 printf ("%08x ", (unsigned int) fc->pc_begin);
6993 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
6994 printf ("%-8s ", tmp);
6996 for (r = 0; r < fc->ncols; r++)
6998 if (fc->col_type[r] != DW_CFA_unreferenced)
7000 switch (fc->col_type[r])
7002 case DW_CFA_undefined:
7005 case DW_CFA_same_value:
7009 sprintf (tmp, "c%+d", fc->col_offset[r]);
7011 case DW_CFA_register:
7012 sprintf (tmp, "r%d", fc->col_offset[r]);
7015 strcpy (tmp, "n/a");
7018 printf ("%-5s", tmp);
7024 #define GET(N) byte_get (start, N); start += N
7025 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
7026 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
7029 display_debug_frames (section, start, file)
7030 Elf32_Internal_Shdr * section;
7031 unsigned char * start;
7032 FILE * file ATTRIBUTE_UNUSED;
7034 unsigned char * end = start + section->sh_size;
7035 unsigned char * section_start = start;
7036 Frame_Chunk * chunks = 0;
7037 Frame_Chunk * remembered_state = 0;
7039 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
7043 printf (_("The section %s contains:\n"), SECTION_NAME (section));
7047 unsigned char * saved_start;
7048 unsigned char * block_end;
7049 unsigned long length;
7050 unsigned long cie_id;
7053 int need_col_headers = 1;
7055 saved_start = start;
7056 length = byte_get (start, 4); start += 4;
7061 block_end = saved_start + length + 4;
7062 cie_id = byte_get (start, 4); start += 4;
7064 printf ("\n%08x %08lx %08lx ", saved_start - section_start, length, cie_id);
7066 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
7068 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7069 memset (fc, 0, sizeof (Frame_Chunk));
7073 fc->chunk_start = saved_start;
7075 fc->col_type = (short int *) xmalloc (sizeof (short int));
7076 fc->col_offset = (int *) xmalloc (sizeof (int));
7077 frame_need_space (fc, max_regs-1);
7079 start ++; /* version */
7080 fc->augmentation = start;
7085 start++; /* skip past NUL */
7087 if (fc->augmentation[0] == 'z')
7090 fc->code_factor = LEB ();
7091 fc->data_factor = SLEB ();
7092 fc->ra = byte_get (start, 1); start += 1;
7094 printf ("skipping %d extra bytes\n", xtra);
7097 else if (strcmp (fc->augmentation, "eh") == 0)
7100 fc->code_factor = LEB ();
7101 fc->data_factor = SLEB ();
7102 fc->ra = byte_get (start, 1); start += 1;
7106 fc->code_factor = LEB ();
7107 fc->data_factor = SLEB ();
7108 fc->ra = byte_get (start, 1); start += 1;
7111 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n",
7112 fc->augmentation, fc->code_factor, fc->data_factor, fc->ra);
7114 frame_need_space (fc, fc->ra);
7118 unsigned char * look_for;
7119 static Frame_Chunk fde_fc;
7122 memset (fc, 0, sizeof (Frame_Chunk));
7124 look_for = is_eh ? start-4-cie_id : (unsigned char *) cie_id;
7126 fc->pc_begin = byte_get (start, 4); start += 4;
7127 fc->pc_range = byte_get (start, 4); start += 4;
7129 for (cie=chunks; cie && (cie->chunk_start != look_for); cie = cie->next);
7132 warn ("Invalid CIE pointer %08x in FDE at %08x\n", cie_id, saved_start);
7135 fc->col_type = (short int *) xmalloc (sizeof (short int));
7136 fc->col_offset = (int *) xmalloc (sizeof (int));
7137 frame_need_space (fc, max_regs - 1);
7139 fc->augmentation = "";
7143 fc->ncols = cie->ncols;
7144 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
7145 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
7146 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7147 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7148 fc->augmentation = cie->augmentation;
7149 fc->code_factor = cie->code_factor;
7150 fc->data_factor = cie->data_factor;
7151 fc->cfa_reg = cie->cfa_reg;
7152 fc->cfa_offset = cie->cfa_offset;
7154 frame_need_space (fc, max_regs-1);
7157 if (cie->augmentation[0] == 'z')
7159 unsigned long l = LEB ();
7163 printf ("FDE cie=%08x pc=%08lx..%08lx\n",
7164 cie->chunk_start-section_start, fc->pc_begin,
7165 fc->pc_begin + fc->pc_range);
7168 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7169 about to interpret instructions for the chunk. */
7171 /* This exists for readelf maintainers. */
7175 /* Start by making a pass over the chunk, allocating storage
7176 and taking note of what registers are used. */
7177 unsigned char * tmp = start;
7179 while (start < block_end)
7190 /* Warning: if you add any more cases to this switch, be
7191 sure to add them to the corresponding switch below. */
7194 case DW_CFA_advance_loc:
7198 frame_need_space (fc, opa);
7199 fc->col_type[opa] = DW_CFA_undefined;
7201 case DW_CFA_restore:
7202 frame_need_space (fc, opa);
7203 fc->col_type[opa] = DW_CFA_undefined;
7205 case DW_CFA_set_loc:
7206 start += sizeof (vma);
7208 case DW_CFA_advance_loc1:
7211 case DW_CFA_advance_loc2:
7214 case DW_CFA_advance_loc4:
7217 case DW_CFA_offset_extended:
7218 reg = LEB (); LEB ();
7219 frame_need_space (fc, reg);
7220 fc->col_type[reg] = DW_CFA_undefined;
7222 case DW_CFA_restore_extended:
7224 frame_need_space (fc, reg);
7225 fc->col_type[reg] = DW_CFA_undefined;
7227 case DW_CFA_undefined:
7229 frame_need_space (fc, reg);
7230 fc->col_type[reg] = DW_CFA_undefined;
7232 case DW_CFA_same_value:
7234 frame_need_space (fc, reg);
7235 fc->col_type[reg] = DW_CFA_undefined;
7237 case DW_CFA_register:
7238 reg = LEB (); LEB ();
7239 frame_need_space (fc, reg);
7240 fc->col_type[reg] = DW_CFA_undefined;
7242 case DW_CFA_def_cfa:
7245 case DW_CFA_def_cfa_register:
7248 case DW_CFA_def_cfa_offset:
7251 #ifndef DW_CFA_GNU_args_size
7252 #define DW_CFA_GNU_args_size 0x2e
7254 case DW_CFA_GNU_args_size:
7257 #ifndef DW_CFA_GNU_negative_offset_extended
7258 #define DW_CFA_GNU_negative_offset_extended 0x2f
7260 case DW_CFA_GNU_negative_offset_extended:
7261 reg = LEB (); LEB ();
7262 frame_need_space (fc, reg);
7263 fc->col_type[reg] = DW_CFA_undefined;
7272 /* Now we know what registers are used, make a second pass over
7273 the chunk, this time actually printing out the info. */
7275 while (start < block_end)
7278 unsigned long ul, reg, roffs;
7287 /* Warning: if you add any more cases to this switch, be
7288 sure to add them to the corresponding switch above. */
7291 case DW_CFA_advance_loc:
7292 frame_display_row (fc, &need_col_headers, &max_regs);
7294 printf (" DW_CFA_advance_loc: %08x = %08x + %d*%d\n",
7295 fc->pc_begin + opa * fc->code_factor, fc->pc_begin, opa, fc->code_factor);
7297 fc->pc_begin += opa * fc->code_factor;
7303 printf (" DW_CFA_offset: r%d = cfa[%d*%d]\n", opa, roffs, fc->data_factor);
7305 fc->col_type[opa] = DW_CFA_offset;
7306 fc->col_offset[opa] = roffs * fc->data_factor;
7309 case DW_CFA_restore:
7311 printf (" DW_CFA_restore: r%d\n", opa);
7313 fc->col_type[opa] = cie->col_type[opa];
7314 fc->col_offset[opa] = cie->col_offset[opa];
7317 case DW_CFA_set_loc:
7318 frame_display_row (fc, &need_col_headers, &max_regs);
7319 vma = byte_get (start, sizeof (vma)); start += sizeof (vma);
7321 printf (" DW_CFA_set_loc: %08x\n", vma);
7326 case DW_CFA_advance_loc1:
7327 frame_display_row (fc, &need_col_headers, &max_regs);
7328 ofs = byte_get (start, 1); start += 1;
7330 printf (" DW_CFA_advance_loc1: %08x = %08x + %d*%d\n",
7331 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7333 fc->pc_begin += ofs * fc->code_factor;
7336 case DW_CFA_advance_loc2:
7337 frame_display_row (fc, &need_col_headers, &max_regs);
7338 ofs = byte_get (start, 2); start += 2;
7340 printf (" DW_CFA_advance_loc2: %08x = %08x + %d*%d\n",
7341 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7343 fc->pc_begin += ofs * fc->code_factor;
7346 case DW_CFA_advance_loc4:
7347 frame_display_row (fc, &need_col_headers, &max_regs);
7348 ofs = byte_get (start, 4); start += 4;
7350 printf (" DW_CFA_advance_loc4: %08x = %08x + %d*%d\n",
7351 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7353 fc->pc_begin += ofs * fc->code_factor;
7356 case DW_CFA_offset_extended:
7360 printf (" DW_CFA_offset_extended: r%d = cfa[%d*%d]\n", reg, roffs, fc->data_factor);
7362 fc->col_type[reg] = DW_CFA_offset;
7363 fc->col_offset[reg] = roffs * fc->data_factor;
7366 case DW_CFA_restore_extended:
7369 printf (" DW_CFA_restore_extended: r%d\n", reg);
7371 fc->col_type[reg] = cie->col_type[reg];
7372 fc->col_offset[reg] = cie->col_offset[reg];
7375 case DW_CFA_undefined:
7378 printf (" DW_CFA_undefined: r%d\n", reg);
7380 fc->col_type[reg] = DW_CFA_undefined;
7381 fc->col_offset[reg] = 0;
7384 case DW_CFA_same_value:
7387 printf (" DW_CFA_same_value: r%d\n", reg);
7389 fc->col_type[reg] = DW_CFA_same_value;
7390 fc->col_offset[reg] = 0;
7393 case DW_CFA_register:
7397 printf (" DW_CFA_register: r%d\n", reg);
7399 fc->col_type[reg] = DW_CFA_register;
7400 fc->col_offset[reg] = roffs;
7403 case DW_CFA_remember_state:
7405 printf (" DW_CFA_remember_state\n");
7407 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7408 rs->ncols = fc->ncols;
7409 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
7410 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
7411 memcpy (rs->col_type, fc->col_type, rs->ncols);
7412 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
7413 rs->next = remembered_state;
7414 remembered_state = rs;
7417 case DW_CFA_restore_state:
7419 printf (" DW_CFA_restore_state\n");
7421 rs = remembered_state;
7422 remembered_state = rs->next;
7423 frame_need_space (fc, rs->ncols-1);
7424 memcpy (fc->col_type, rs->col_type, rs->ncols);
7425 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
7426 free (rs->col_type);
7427 free (rs->col_offset);
7431 case DW_CFA_def_cfa:
7432 fc->cfa_reg = LEB ();
7433 fc->cfa_offset = LEB ();
7435 printf (" DW_CFA_def_cfa: reg %d ofs %d\n", fc->cfa_reg, fc->cfa_offset);
7439 case DW_CFA_def_cfa_register:
7440 fc->cfa_reg = LEB ();
7442 printf (" DW_CFA_def_cfa_reg: %d\n", fc->cfa_reg);
7446 case DW_CFA_def_cfa_offset:
7447 fc->cfa_offset = LEB ();
7449 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
7455 printf (" DW_CFA_nop\n");
7459 #ifndef DW_CFA_GNU_window_save
7460 #define DW_CFA_GNU_window_save 0x2d
7462 case DW_CFA_GNU_window_save:
7464 printf (" DW_CFA_GNU_window_save\n");
7468 #ifndef DW_CFA_GNU_args_size
7469 #define DW_CFA_GNU_args_size 0x2e
7471 case DW_CFA_GNU_args_size:
7474 printf (" DW_CFA_GNU_args_size: %d\n", ul);
7478 #ifndef DW_CFA_GNU_negative_offset_extended
7479 #define DW_CFA_GNU_negative_offset_extended 0x2f
7481 case DW_CFA_GNU_negative_offset_extended:
7484 frame_need_space (fc, reg);
7486 printf (" DW_CFA_GNU_negative_offset_extended: r%d = cfa[%d*%d]\n", reg, l, fc->data_factor);
7488 fc->col_type[reg] = DW_CFA_offset;
7489 fc->col_offset[reg] = l * fc->data_factor;
7493 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
7498 frame_display_row (fc, &need_col_headers, &max_regs);
7513 display_debug_not_supported (section, start, file)
7514 Elf32_Internal_Shdr * section;
7515 unsigned char * start ATTRIBUTE_UNUSED;
7516 FILE * file ATTRIBUTE_UNUSED;
7518 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7519 SECTION_NAME (section));
7524 /* Pre-scan the .debug_info section to record the size of address.
7525 When dumping the .debug_line, we use that size information, assuming
7526 that all compilation units have the same address size. */
7528 prescan_debug_info (section, start, file)
7529 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
7530 unsigned char * start;
7531 FILE * file ATTRIBUTE_UNUSED;
7533 DWARF2_External_CompUnit * external;
7535 external = (DWARF2_External_CompUnit *) start;
7537 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
7541 /* A structure containing the name of a debug section and a pointer
7542 to a function that can decode it. The third field is a prescan
7543 function to be run over the section before displaying any of the
7548 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7549 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7553 { ".debug_info", display_debug_info, prescan_debug_info },
7554 { ".debug_abbrev", display_debug_abbrev, NULL },
7555 { ".debug_line", display_debug_lines, NULL },
7556 { ".debug_aranges", display_debug_aranges, NULL },
7557 { ".debug_pubnames", display_debug_pubnames, NULL },
7558 { ".debug_frame", display_debug_frames, NULL },
7559 { ".eh_frame", display_debug_frames, NULL },
7560 { ".debug_macinfo", display_debug_not_supported, NULL },
7561 { ".debug_frame", display_debug_not_supported, NULL },
7562 { ".debug_str", display_debug_not_supported, NULL },
7563 { ".debug_static_func", display_debug_not_supported, NULL },
7564 { ".debug_static_vars", display_debug_not_supported, NULL },
7565 { ".debug_types", display_debug_not_supported, NULL },
7566 { ".debug_weaknames", display_debug_not_supported, NULL }
7570 display_debug_section (section, file)
7571 Elf32_Internal_Shdr * section;
7574 char * name = SECTION_NAME (section);
7575 bfd_size_type length;
7576 unsigned char * start;
7579 length = section->sh_size;
7582 printf (_("\nSection '%s' has no debugging data.\n"), name);
7586 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7587 "debug section data");
7589 /* See if we know how to display the contents of this section. */
7590 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
7591 name = ".debug_info";
7593 for (i = NUM_ELEM (debug_displays); i--;)
7594 if (strcmp (debug_displays[i].name, name) == 0)
7596 debug_displays[i].display (section, start, file);
7601 printf (_("Unrecognised debug section: %s\n"), name);
7605 /* If we loaded in the abbrev section at some point,
7606 we must release it here. */
7607 if (first_abbrev != NULL)
7614 process_section_contents (file)
7617 Elf32_Internal_Shdr * section;
7623 /* Pre-scan the debug sections to find some debug information not
7624 present in some of them. For the .debug_line, we must find out the
7625 size of address (specified in .debug_info and .debug_aranges). */
7626 for (i = 0, section = section_headers;
7627 i < elf_header.e_shnum && i < num_dump_sects;
7630 char * name = SECTION_NAME (section);
7633 if (section->sh_size == 0)
7636 /* See if there is some pre-scan operation for this section. */
7637 for (j = NUM_ELEM (debug_displays); j--;)
7638 if (strcmp (debug_displays[j].name, name) == 0)
7640 if (debug_displays[j].prescan != NULL)
7642 bfd_size_type length;
7643 unsigned char * start;
7645 length = section->sh_size;
7646 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7647 "debug section data");
7649 debug_displays[j].prescan (section, start, file);
7657 for (i = 0, section = section_headers;
7658 i < elf_header.e_shnum && i < num_dump_sects;
7661 #ifdef SUPPORT_DISASSEMBLY
7662 if (dump_sects[i] & DISASS_DUMP)
7663 disassemble_section (section, file);
7665 if (dump_sects[i] & HEX_DUMP)
7666 dump_section (section, file);
7668 if (dump_sects[i] & DEBUG_DUMP)
7669 display_debug_section (section, file);
7672 if (i < num_dump_sects)
7673 warn (_("Some sections were not dumped because they do not exist!\n"));
7679 process_mips_fpe_exception (mask)
7685 if (mask & OEX_FPU_INEX)
7686 fputs ("INEX", stdout), first = 0;
7687 if (mask & OEX_FPU_UFLO)
7688 printf ("%sUFLO", first ? "" : "|"), first = 0;
7689 if (mask & OEX_FPU_OFLO)
7690 printf ("%sOFLO", first ? "" : "|"), first = 0;
7691 if (mask & OEX_FPU_DIV0)
7692 printf ("%sDIV0", first ? "" : "|"), first = 0;
7693 if (mask & OEX_FPU_INVAL)
7694 printf ("%sINVAL", first ? "" : "|");
7697 fputs ("0", stdout);
7701 process_mips_specific (file)
7704 Elf_Internal_Dyn * entry;
7705 size_t liblist_offset = 0;
7706 size_t liblistno = 0;
7707 size_t conflictsno = 0;
7708 size_t options_offset = 0;
7709 size_t conflicts_offset = 0;
7711 /* We have a lot of special sections. Thanks SGI! */
7712 if (dynamic_segment == NULL)
7713 /* No information available. */
7716 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
7717 switch (entry->d_tag)
7719 case DT_MIPS_LIBLIST:
7720 liblist_offset = entry->d_un.d_val - loadaddr;
7722 case DT_MIPS_LIBLISTNO:
7723 liblistno = entry->d_un.d_val;
7725 case DT_MIPS_OPTIONS:
7726 options_offset = entry->d_un.d_val - loadaddr;
7728 case DT_MIPS_CONFLICT:
7729 conflicts_offset = entry->d_un.d_val - loadaddr;
7731 case DT_MIPS_CONFLICTNO:
7732 conflictsno = entry->d_un.d_val;
7738 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
7740 Elf32_External_Lib * elib;
7743 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
7744 elib, Elf32_External_Lib *, "liblist");
7746 printf ("\nSection '.liblist' contains %lu entries:\n",
7747 (unsigned long) liblistno);
7748 fputs (" Library Time Stamp Checksum Version Flags\n",
7751 for (cnt = 0; cnt < liblistno; ++cnt)
7758 liblist.l_name = BYTE_GET (elib[cnt].l_name);
7759 time = BYTE_GET (elib[cnt].l_time_stamp);
7760 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
7761 liblist.l_version = BYTE_GET (elib[cnt].l_version);
7762 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
7764 tmp = gmtime (&time);
7765 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
7766 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7767 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7769 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
7770 dynamic_strings + liblist.l_name, timebuf,
7771 liblist.l_checksum, liblist.l_version);
7773 if (liblist.l_flags == 0)
7784 { " EXACT_MATCH", LL_EXACT_MATCH },
7785 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
7786 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
7787 { " EXPORTS", LL_EXPORTS },
7788 { " DELAY_LOAD", LL_DELAY_LOAD },
7789 { " DELTA", LL_DELTA }
7791 int flags = liblist.l_flags;
7795 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
7797 if ((flags & l_flags_vals[fcnt].bit) != 0)
7799 fputs (l_flags_vals[fcnt].name, stdout);
7800 flags ^= l_flags_vals[fcnt].bit;
7803 printf (" %#x", (unsigned int) flags);
7812 if (options_offset != 0)
7814 Elf_External_Options * eopt;
7815 Elf_Internal_Shdr * sect = section_headers;
7816 Elf_Internal_Options * iopt;
7817 Elf_Internal_Options * option;
7821 /* Find the section header so that we get the size. */
7822 while (sect->sh_type != SHT_MIPS_OPTIONS)
7825 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
7826 Elf_External_Options *, "options");
7828 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
7832 error (_("Out of memory"));
7839 while (offset < sect->sh_size)
7841 Elf_External_Options * eoption;
7843 eoption = (Elf_External_Options *) ((char *) eopt + offset);
7845 option->kind = BYTE_GET (eoption->kind);
7846 option->size = BYTE_GET (eoption->size);
7847 option->section = BYTE_GET (eoption->section);
7848 option->info = BYTE_GET (eoption->info);
7850 offset += option->size;
7856 printf (_("\nSection '%s' contains %d entries:\n"),
7857 SECTION_NAME (sect), cnt);
7865 switch (option->kind)
7868 /* This shouldn't happen. */
7869 printf (" NULL %d %lx", option->section, option->info);
7872 printf (" REGINFO ");
7873 if (elf_header.e_machine == EM_MIPS)
7876 Elf32_External_RegInfo * ereg;
7877 Elf32_RegInfo reginfo;
7879 ereg = (Elf32_External_RegInfo *) (option + 1);
7880 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7881 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7882 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7883 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7884 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7885 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
7887 printf ("GPR %08lx GP 0x%lx\n",
7889 (unsigned long) reginfo.ri_gp_value);
7890 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7891 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7892 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7897 Elf64_External_RegInfo * ereg;
7898 Elf64_Internal_RegInfo reginfo;
7900 ereg = (Elf64_External_RegInfo *) (option + 1);
7901 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7902 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7903 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7904 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7905 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7906 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
7908 printf ("GPR %08lx GP 0x",
7909 reginfo.ri_gprmask);
7910 printf_vma (reginfo.ri_gp_value);
7913 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7914 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7915 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7919 case ODK_EXCEPTIONS:
7920 fputs (" EXCEPTIONS fpe_min(", stdout);
7921 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
7922 fputs (") fpe_max(", stdout);
7923 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
7924 fputs (")", stdout);
7926 if (option->info & OEX_PAGE0)
7927 fputs (" PAGE0", stdout);
7928 if (option->info & OEX_SMM)
7929 fputs (" SMM", stdout);
7930 if (option->info & OEX_FPDBUG)
7931 fputs (" FPDBUG", stdout);
7932 if (option->info & OEX_DISMISS)
7933 fputs (" DISMISS", stdout);
7936 fputs (" PAD ", stdout);
7937 if (option->info & OPAD_PREFIX)
7938 fputs (" PREFIX", stdout);
7939 if (option->info & OPAD_POSTFIX)
7940 fputs (" POSTFIX", stdout);
7941 if (option->info & OPAD_SYMBOL)
7942 fputs (" SYMBOL", stdout);
7945 fputs (" HWPATCH ", stdout);
7946 if (option->info & OHW_R4KEOP)
7947 fputs (" R4KEOP", stdout);
7948 if (option->info & OHW_R8KPFETCH)
7949 fputs (" R8KPFETCH", stdout);
7950 if (option->info & OHW_R5KEOP)
7951 fputs (" R5KEOP", stdout);
7952 if (option->info & OHW_R5KCVTL)
7953 fputs (" R5KCVTL", stdout);
7956 fputs (" FILL ", stdout);
7957 /* XXX Print content of info word? */
7960 fputs (" TAGS ", stdout);
7961 /* XXX Print content of info word? */
7964 fputs (" HWAND ", stdout);
7965 if (option->info & OHWA0_R4KEOP_CHECKED)
7966 fputs (" R4KEOP_CHECKED", stdout);
7967 if (option->info & OHWA0_R4KEOP_CLEAN)
7968 fputs (" R4KEOP_CLEAN", stdout);
7971 fputs (" HWOR ", stdout);
7972 if (option->info & OHWA0_R4KEOP_CHECKED)
7973 fputs (" R4KEOP_CHECKED", stdout);
7974 if (option->info & OHWA0_R4KEOP_CLEAN)
7975 fputs (" R4KEOP_CLEAN", stdout);
7978 printf (" GP_GROUP %#06lx self-contained %#06lx",
7979 option->info & OGP_GROUP,
7980 (option->info & OGP_SELF) >> 16);
7983 printf (" IDENT %#06lx self-contained %#06lx",
7984 option->info & OGP_GROUP,
7985 (option->info & OGP_SELF) >> 16);
7988 /* This shouldn't happen. */
7989 printf (" %3d ??? %d %lx",
7990 option->kind, option->section, option->info);
7994 len = sizeof (* eopt);
7995 while (len < option->size)
7996 if (((char *) option)[len] >= ' '
7997 && ((char *) option)[len] < 0x7f)
7998 printf ("%c", ((char *) option)[len++]);
8000 printf ("\\%03o", ((char *) option)[len++]);
8002 fputs ("\n", stdout);
8009 if (conflicts_offset != 0 && conflictsno != 0)
8011 Elf32_External_Conflict * econf32;
8012 Elf64_External_Conflict * econf64;
8013 Elf32_Conflict * iconf;
8016 if (dynamic_symbols == NULL)
8018 error (_("conflict list with without table"));
8022 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
8025 error (_("Out of memory"));
8031 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf32),
8032 econf32, Elf32_External_Conflict *, "conflict");
8034 for (cnt = 0; cnt < conflictsno; ++cnt)
8035 iconf[cnt] = BYTE_GET (econf32[cnt]);
8039 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf64),
8040 econf64, Elf64_External_Conflict *, "conflict");
8042 for (cnt = 0; cnt < conflictsno; ++cnt)
8043 iconf[cnt] = BYTE_GET (econf64[cnt]);
8046 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
8047 puts (_(" Num: Index Value Name"));
8049 for (cnt = 0; cnt < conflictsno; ++cnt)
8051 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
8053 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
8054 print_vma (psym->st_value, FULL_HEX);
8055 printf (" %s\n", dynamic_strings + psym->st_name);
8065 get_note_type (e_type)
8068 static char buff[64];
8072 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
8073 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
8074 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
8075 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
8076 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
8077 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
8078 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
8079 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
8080 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8081 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8082 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8084 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
8089 /* Note that by the ELF standard, the name field is already null byte
8090 terminated, and namesz includes the terminating null byte.
8091 I.E. the value of namesz for the name "FSF" is 4.
8093 If the value of namesz is zero, there is no name present. */
8095 process_note (pnote)
8096 Elf32_Internal_Note * pnote;
8098 printf (" %s\t\t0x%08lx\t%s\n",
8099 pnote->namesz ? pnote->namedata : "(NONE)",
8100 pnote->descsz, get_note_type (pnote->type));
8106 process_corefile_note_segment (file, offset, length)
8111 Elf_External_Note * pnotes;
8112 Elf_External_Note * external;
8118 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
8122 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8123 (unsigned long) offset, (unsigned long) length);
8124 printf (_(" Owner\t\tData size\tDescription\n"));
8126 while (external < (Elf_External_Note *)((char *) pnotes + length))
8128 Elf32_Internal_Note inote;
8131 inote.type = BYTE_GET (external->type);
8132 inote.namesz = BYTE_GET (external->namesz);
8133 inote.namedata = external->name;
8134 inote.descsz = BYTE_GET (external->descsz);
8135 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8136 inote.descpos = offset + (inote.descdata - (char *) pnotes);
8138 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8140 /* Verify that name is null terminated. It appears that at least
8141 one version of Linux (RedHat 6.0) generates corefiles that don't
8142 comply with the ELF spec by failing to include the null byte in
8144 if (inote.namedata[inote.namesz] != '\0')
8146 temp = malloc (inote.namesz + 1);
8150 error (_("Out of memory\n"));
8155 strncpy (temp, inote.namedata, inote.namesz);
8156 temp[inote.namesz] = 0;
8158 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8159 inote.namedata = temp;
8162 res &= process_note (& inote);
8177 process_corefile_note_segments (file)
8180 Elf_Internal_Phdr * program_headers;
8181 Elf_Internal_Phdr * segment;
8185 program_headers = (Elf_Internal_Phdr *) malloc
8186 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
8188 if (program_headers == NULL)
8190 error (_("Out of memory\n"));
8195 i = get_32bit_program_headers (file, program_headers);
8197 i = get_64bit_program_headers (file, program_headers);
8201 free (program_headers);
8205 for (i = 0, segment = program_headers;
8206 i < elf_header.e_phnum;
8209 if (segment->p_type == PT_NOTE)
8210 res &= process_corefile_note_segment (file,
8211 (bfd_vma) segment->p_offset,
8212 (bfd_vma) segment->p_filesz);
8215 free (program_headers);
8221 process_corefile_contents (file)
8224 /* If we have not been asked to display the notes then do nothing. */
8228 /* If file is not a core file then exit. */
8229 if (elf_header.e_type != ET_CORE)
8232 /* No program headers means no NOTE segment. */
8233 if (elf_header.e_phnum == 0)
8235 printf (_("No note segments present in the core file.\n"));
8239 return process_corefile_note_segments (file);
8243 process_arch_specific (file)
8249 switch (elf_header.e_machine)
8252 case EM_MIPS_RS4_BE:
8253 return process_mips_specific (file);
8262 get_file_header (file)
8265 /* Read in the identity array. */
8266 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8269 /* Determine how to read the rest of the header. */
8270 switch (elf_header.e_ident [EI_DATA])
8272 default: /* fall through */
8273 case ELFDATANONE: /* fall through */
8274 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
8275 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
8278 /* For now we only support 32 bit and 64 bit ELF files. */
8279 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
8281 /* Read in the rest of the header. */
8284 Elf32_External_Ehdr ehdr32;
8286 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8289 elf_header.e_type = BYTE_GET (ehdr32.e_type);
8290 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
8291 elf_header.e_version = BYTE_GET (ehdr32.e_version);
8292 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
8293 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
8294 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
8295 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
8296 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
8297 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8298 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
8299 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8300 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
8301 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
8305 Elf64_External_Ehdr ehdr64;
8307 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8308 we will not be able to cope with the 64bit data found in
8309 64 ELF files. Detect this now and abort before we start
8310 overwritting things. */
8311 if (sizeof (bfd_vma) < 8)
8313 error (_("This instance of readelf has been built without support for a\n"));
8314 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
8318 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
8321 elf_header.e_type = BYTE_GET (ehdr64.e_type);
8322 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
8323 elf_header.e_version = BYTE_GET (ehdr64.e_version);
8324 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
8325 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
8326 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
8327 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
8328 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
8329 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
8330 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
8331 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
8332 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
8333 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
8340 process_file (file_name)
8344 struct stat statbuf;
8347 if (stat (file_name, & statbuf) < 0)
8349 error (_("Cannot stat input file %s.\n"), file_name);
8353 file = fopen (file_name, "rb");
8356 error (_("Input file %s not found.\n"), file_name);
8360 if (! get_file_header (file))
8362 error (_("%s: Failed to read file header\n"), file_name);
8367 /* Initialise per file variables. */
8368 for (i = NUM_ELEM (version_info); i--;)
8369 version_info[i] = 0;
8371 for (i = NUM_ELEM (dynamic_info); i--;)
8372 dynamic_info[i] = 0;
8374 /* Process the file. */
8376 printf (_("\nFile: %s\n"), file_name);
8378 if (! process_file_header ())
8384 process_section_headers (file);
8386 process_program_headers (file);
8388 process_dynamic_segment (file);
8390 process_relocs (file);
8392 process_unwind (file);
8394 process_symbol_table (file);
8396 process_syminfo (file);
8398 process_version_sections (file);
8400 process_section_contents (file);
8402 process_corefile_contents (file);
8404 process_arch_specific (file);
8408 if (section_headers)
8410 free (section_headers);
8411 section_headers = NULL;
8416 free (string_table);
8417 string_table = NULL;
8418 string_table_length = 0;
8421 if (dynamic_strings)
8423 free (dynamic_strings);
8424 dynamic_strings = NULL;
8427 if (dynamic_symbols)
8429 free (dynamic_symbols);
8430 dynamic_symbols = NULL;
8431 num_dynamic_syms = 0;
8434 if (dynamic_syminfo)
8436 free (dynamic_syminfo);
8437 dynamic_syminfo = NULL;
8441 #ifdef SUPPORT_DISASSEMBLY
8442 /* Needed by the i386 disassembler. For extra credit, someone could
8443 fix this so that we insert symbolic addresses here, esp for GOT/PLT
8447 print_address (unsigned int addr, FILE * outfile)
8449 fprintf (outfile,"0x%8.8x", addr);
8452 /* Needed by the i386 disassembler. */
8454 db_task_printsym (unsigned int addr)
8456 print_address (addr, stderr);
8465 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
8466 setlocale (LC_MESSAGES, "");
8468 bindtextdomain (PACKAGE, LOCALEDIR);
8469 textdomain (PACKAGE);
8471 parse_args (argc, argv);
8473 if (optind < (argc - 1))
8476 while (optind < argc)
8477 process_file (argv [optind ++]);
8479 if (dump_sects != NULL)