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));
1006 get_mips_dynamic_type (type)
1011 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1012 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1013 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1014 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1015 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1016 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1017 case DT_MIPS_MSYM: return "MIPS_MSYM";
1018 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1019 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1020 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1021 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1022 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1023 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1024 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1025 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1026 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1027 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1028 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1029 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1030 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1031 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1032 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1033 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1034 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1035 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1036 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1037 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1038 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1039 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1040 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1041 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1042 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1043 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1044 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1045 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1046 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1047 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1048 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1049 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1050 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1051 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1052 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1053 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1060 get_sparc64_dynamic_type (type)
1065 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1072 get_parisc_dynamic_type (type)
1077 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1078 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1079 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1080 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1081 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1082 case DT_HP_PREINIT: return "HP_PREINIT";
1083 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1084 case DT_HP_NEEDED: return "HP_NEEDED";
1085 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1086 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1087 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1088 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1089 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1096 get_dynamic_type (type)
1099 static char buff [32];
1103 case DT_NULL: return "NULL";
1104 case DT_NEEDED: return "NEEDED";
1105 case DT_PLTRELSZ: return "PLTRELSZ";
1106 case DT_PLTGOT: return "PLTGOT";
1107 case DT_HASH: return "HASH";
1108 case DT_STRTAB: return "STRTAB";
1109 case DT_SYMTAB: return "SYMTAB";
1110 case DT_RELA: return "RELA";
1111 case DT_RELASZ: return "RELASZ";
1112 case DT_RELAENT: return "RELAENT";
1113 case DT_STRSZ: return "STRSZ";
1114 case DT_SYMENT: return "SYMENT";
1115 case DT_INIT: return "INIT";
1116 case DT_FINI: return "FINI";
1117 case DT_SONAME: return "SONAME";
1118 case DT_RPATH: return "RPATH";
1119 case DT_SYMBOLIC: return "SYMBOLIC";
1120 case DT_REL: return "REL";
1121 case DT_RELSZ: return "RELSZ";
1122 case DT_RELENT: return "RELENT";
1123 case DT_PLTREL: return "PLTREL";
1124 case DT_DEBUG: return "DEBUG";
1125 case DT_TEXTREL: return "TEXTREL";
1126 case DT_JMPREL: return "JMPREL";
1127 case DT_BIND_NOW: return "BIND_NOW";
1128 case DT_INIT_ARRAY: return "INIT_ARRAY";
1129 case DT_FINI_ARRAY: return "FINI_ARRAY";
1130 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1131 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1132 case DT_RUNPATH: return "RUNPATH";
1133 case DT_FLAGS: return "FLAGS";
1135 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1136 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1138 case DT_CHECKSUM: return "CHECKSUM";
1139 case DT_PLTPADSZ: return "PLTPADSZ";
1140 case DT_MOVEENT: return "MOVEENT";
1141 case DT_MOVESZ: return "MOVESZ";
1142 case DT_FEATURE: return "FEATURE";
1143 case DT_POSFLAG_1: return "POSFLAG_1";
1144 case DT_SYMINSZ: return "SYMINSZ";
1145 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1147 case DT_ADDRRNGLO: return "ADDRRNGLO";
1148 case DT_CONFIG: return "CONFIG";
1149 case DT_DEPAUDIT: return "DEPAUDIT";
1150 case DT_AUDIT: return "AUDIT";
1151 case DT_PLTPAD: return "PLTPAD";
1152 case DT_MOVETAB: return "MOVETAB";
1153 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1155 case DT_VERSYM: return "VERSYM";
1157 case DT_RELACOUNT: return "RELACOUNT";
1158 case DT_RELCOUNT: return "RELCOUNT";
1159 case DT_FLAGS_1: return "FLAGS_1";
1160 case DT_VERDEF: return "VERDEF";
1161 case DT_VERDEFNUM: return "VERDEFNUM";
1162 case DT_VERNEED: return "VERNEED";
1163 case DT_VERNEEDNUM: return "VERNEEDNUM";
1165 case DT_AUXILIARY: return "AUXILIARY";
1166 case DT_USED: return "USED";
1167 case DT_FILTER: return "FILTER";
1170 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1172 const char * result;
1174 switch (elf_header.e_machine)
1177 case EM_MIPS_RS4_BE:
1178 result = get_mips_dynamic_type (type);
1181 result = get_sparc64_dynamic_type (type);
1191 sprintf (buff, _("Processor Specific: %lx"), type);
1193 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1195 const char * result;
1197 switch (elf_header.e_machine)
1200 result = get_parisc_dynamic_type (type);
1210 sprintf (buff, _("Operating System specific: %lx"), type);
1213 sprintf (buff, _("<unknown>: %lx"), type);
1220 get_file_type (e_type)
1223 static char buff [32];
1227 case ET_NONE: return _("NONE (None)");
1228 case ET_REL: return _("REL (Relocatable file)");
1229 case ET_EXEC: return _("EXEC (Executable file)");
1230 case ET_DYN: return _("DYN (Shared object file)");
1231 case ET_CORE: return _("CORE (Core file)");
1234 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1235 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1236 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1237 sprintf (buff, _("OS Specific: (%x)"), e_type);
1239 sprintf (buff, _("<unknown>: %x"), e_type);
1245 get_machine_name (e_machine)
1248 static char buff [64]; /* XXX */
1252 case EM_NONE: return _("None");
1253 case EM_M32: return "WE32100";
1254 case EM_SPARC: return "Sparc";
1255 case EM_386: return "Intel 80386";
1256 case EM_68K: return "MC68000";
1257 case EM_88K: return "MC88000";
1258 case EM_486: return "Intel 80486";
1259 case EM_860: return "Intel 80860";
1260 case EM_MIPS: return "MIPS R3000";
1261 case EM_S370: return "IBM System/370";
1262 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1263 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1264 case EM_PARISC: return "HPPA";
1265 case EM_PPC_OLD: return "Power PC (old)";
1266 case EM_SPARC32PLUS: return "Sparc v8+" ;
1267 case EM_960: return "Intel 90860";
1268 case EM_PPC: return "PowerPC";
1269 case EM_V800: return "NEC V800";
1270 case EM_FR20: return "Fujitsu FR20";
1271 case EM_RH32: return "TRW RH32";
1272 case EM_MCORE: return "MCORE";
1273 case EM_ARM: return "ARM";
1274 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1275 case EM_SH: return "Hitachi SH";
1276 case EM_SPARCV9: return "Sparc v9";
1277 case EM_TRICORE: return "Siemens Tricore";
1278 case EM_ARC: return "ARC";
1279 case EM_H8_300: return "Hitachi H8/300";
1280 case EM_H8_300H: return "Hitachi H8/300H";
1281 case EM_H8S: return "Hitachi H8S";
1282 case EM_H8_500: return "Hitachi H8/500";
1283 case EM_IA_64: return "Intel IA-64";
1284 case EM_MIPS_X: return "Stanford MIPS-X";
1285 case EM_COLDFIRE: return "Motorola Coldfire";
1286 case EM_68HC12: return "Motorola M68HC12";
1287 case EM_ALPHA: return "Alpha";
1288 case EM_CYGNUS_D10V: return "d10v";
1289 case EM_CYGNUS_D30V: return "d30v";
1290 case EM_CYGNUS_ARC: return "ARC";
1291 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1292 case EM_CYGNUS_V850: return "NEC v850";
1293 case EM_CYGNUS_MN10300: return "mn10300";
1294 case EM_CYGNUS_MN10200: return "mn10200";
1295 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1296 case EM_PJ: return "picoJava";
1297 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1298 case EM_PCP: return "Siemens PCP";
1299 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1300 case EM_NDR1: return "Denso NDR1 microprocesspr";
1301 case EM_STARCORE: return "Motorola Star*Core processor";
1302 case EM_ME16: return "Toyota ME16 processor";
1303 case EM_ST100: return "STMicroelectronics ST100 processor";
1304 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1305 case EM_FX66: return "Siemens FX66 microcontroller";
1306 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1307 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1308 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1309 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1310 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1311 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1312 case EM_SVX: return "Silicon Graphics SVx";
1313 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1314 case EM_VAX: return "Digital VAX";
1315 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1316 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1317 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1318 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1319 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1320 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1321 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1322 case EM_PRISM: return "SiTera Prism";
1323 case EM_X86_64: return "Advanced Micro Devices X86-64";
1324 case EM_S390: return "IBM S/390";
1326 sprintf (buff, _("<unknown>: %x"), e_machine);
1332 decode_ARM_machine_flags (e_flags, buf)
1339 eabi = EF_ARM_EABI_VERSION (e_flags);
1340 e_flags &= ~ EF_ARM_EABIMASK;
1342 /* Handle "generic" ARM flags. */
1343 if (e_flags & EF_ARM_RELEXEC)
1345 strcat (buf, ", relocatable executable");
1346 e_flags &= ~ EF_ARM_RELEXEC;
1349 if (e_flags & EF_ARM_HASENTRY)
1351 strcat (buf, ", has entry point");
1352 e_flags &= ~ EF_ARM_HASENTRY;
1355 /* Now handle EABI specific flags. */
1359 strcat (buf, ", <unknown EABI>");
1364 case EF_ARM_EABI_VER1:
1369 /* Process flags one bit at a time. */
1370 flag = e_flags & - e_flags;
1375 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_INTERWORK. */
1376 strcat (buf, ", sorted symbol tables");
1386 case EF_ARM_EABI_UNKNOWN:
1391 /* Process flags one bit at a time. */
1392 flag = e_flags & - e_flags;
1398 strcat (buf, ", interworking enabled");
1402 strcat (buf, ", uses APCS/26");
1406 strcat (buf, ", uses APCS/float");
1410 strcat (buf, ", position independent");
1414 strcat (buf, ", 8 bit structure alignment");
1418 strcat (buf, ", uses new ABI");
1422 strcat (buf, ", uses old ABI");
1426 strcat (buf, ", software FP");
1437 strcat (buf,", <unknown>");
1441 get_machine_flags (e_flags, e_machine)
1445 static char buf [1024];
1457 decode_ARM_machine_flags (e_flags, buf);
1461 if (e_flags & EF_CPU32)
1462 strcat (buf, ", cpu32");
1466 if (e_flags & EF_PPC_EMB)
1467 strcat (buf, ", emb");
1469 if (e_flags & EF_PPC_RELOCATABLE)
1470 strcat (buf, ", relocatable");
1472 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1473 strcat (buf, ", relocatable-lib");
1476 case EM_CYGNUS_V850:
1477 switch (e_flags & EF_V850_ARCH)
1480 strcat (buf, ", v850e");
1483 strcat (buf, ", v850ea");
1486 strcat (buf, ", v850");
1489 strcat (buf, ", unknown v850 architecture variant");
1494 case EM_CYGNUS_M32R:
1495 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1496 strcat (buf, ", m32r");
1501 case EM_MIPS_RS4_BE:
1502 if (e_flags & EF_MIPS_NOREORDER)
1503 strcat (buf, ", noreorder");
1505 if (e_flags & EF_MIPS_PIC)
1506 strcat (buf, ", pic");
1508 if (e_flags & EF_MIPS_CPIC)
1509 strcat (buf, ", cpic");
1511 if (e_flags & EF_MIPS_ABI2)
1512 strcat (buf, ", abi2");
1514 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1515 strcat (buf, ", mips1");
1517 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1518 strcat (buf, ", mips2");
1520 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1521 strcat (buf, ", mips3");
1523 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1524 strcat (buf, ", mips4");
1526 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
1527 strcat (buf, ", mips5");
1529 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
1530 strcat (buf, ", mips32");
1532 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
1533 strcat (buf, ", mips64");
1535 switch ((e_flags & EF_MIPS_MACH))
1537 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1538 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1539 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1540 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1541 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1542 case E_MIPS_MACH_MIPS32_4K: strcat (buf, ", mips32-4k"); break;
1543 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1544 default: strcat (buf, " UNKNOWN"); break;
1549 if (e_flags & EF_SPARC_32PLUS)
1550 strcat (buf, ", v8+");
1552 if (e_flags & EF_SPARC_SUN_US1)
1553 strcat (buf, ", ultrasparcI");
1555 if (e_flags & EF_SPARC_SUN_US3)
1556 strcat (buf, ", ultrasparcIII");
1558 if (e_flags & EF_SPARC_HAL_R1)
1559 strcat (buf, ", halr1");
1561 if (e_flags & EF_SPARC_LEDATA)
1562 strcat (buf, ", ledata");
1564 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1565 strcat (buf, ", tso");
1567 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1568 strcat (buf, ", pso");
1570 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1571 strcat (buf, ", rmo");
1575 switch (e_flags & EF_PARISC_ARCH)
1577 case EFA_PARISC_1_0:
1578 strcpy (buf, ", PA-RISC 1.0");
1580 case EFA_PARISC_1_1:
1581 strcpy (buf, ", PA-RISC 1.1");
1583 case EFA_PARISC_2_0:
1584 strcpy (buf, ", PA-RISC 2.0");
1589 if (e_flags & EF_PARISC_TRAPNIL)
1590 strcat (buf, ", trapnil");
1591 if (e_flags & EF_PARISC_EXT)
1592 strcat (buf, ", ext");
1593 if (e_flags & EF_PARISC_LSB)
1594 strcat (buf, ", lsb");
1595 if (e_flags & EF_PARISC_WIDE)
1596 strcat (buf, ", wide");
1597 if (e_flags & EF_PARISC_NO_KABP)
1598 strcat (buf, ", no kabp");
1599 if (e_flags & EF_PARISC_LAZYSWAP)
1600 strcat (buf, ", lazyswap");
1604 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1605 strcat (buf, ", new calling convention");
1607 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1608 strcat (buf, ", gnu calling convention");
1612 if ((e_flags & EF_IA_64_ABI64))
1613 strcat (buf, ", 64-bit");
1615 strcat (buf, ", 32-bit");
1616 if ((e_flags & EF_IA_64_REDUCEDFP))
1617 strcat (buf, ", reduced fp model");
1618 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
1619 strcat (buf, ", no function descriptors, constant gp");
1620 else if ((e_flags & EF_IA_64_CONS_GP))
1621 strcat (buf, ", constant gp");
1622 if ((e_flags & EF_IA_64_ABSOLUTE))
1623 strcat (buf, ", absolute");
1632 get_mips_segment_type (type)
1637 case PT_MIPS_REGINFO:
1639 case PT_MIPS_RTPROC:
1641 case PT_MIPS_OPTIONS:
1651 get_parisc_segment_type (type)
1656 case PT_HP_TLS: return "HP_TLS";
1657 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1658 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1659 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1660 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1661 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1662 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1663 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1664 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1665 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1666 case PT_HP_PARALLEL: return "HP_PARALLEL";
1667 case PT_HP_FASTBIND: return "HP_FASTBIND";
1668 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1669 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1678 get_ia64_segment_type (type)
1683 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
1684 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
1693 get_segment_type (p_type)
1694 unsigned long p_type;
1696 static char buff [32];
1700 case PT_NULL: return "NULL";
1701 case PT_LOAD: return "LOAD";
1702 case PT_DYNAMIC: return "DYNAMIC";
1703 case PT_INTERP: return "INTERP";
1704 case PT_NOTE: return "NOTE";
1705 case PT_SHLIB: return "SHLIB";
1706 case PT_PHDR: return "PHDR";
1709 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1711 const char * result;
1713 switch (elf_header.e_machine)
1716 case EM_MIPS_RS4_BE:
1717 result = get_mips_segment_type (p_type);
1720 result = get_parisc_segment_type (p_type);
1723 result = get_ia64_segment_type (p_type);
1733 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1735 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1737 const char * result;
1739 switch (elf_header.e_machine)
1742 result = get_parisc_segment_type (p_type);
1752 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1755 sprintf (buff, _("<unknown>: %lx"), p_type);
1762 get_mips_section_type_name (sh_type)
1763 unsigned int sh_type;
1767 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1768 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1769 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1770 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1771 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1772 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1773 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1774 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1775 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1776 case SHT_MIPS_RELD: return "MIPS_RELD";
1777 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1778 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1779 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1780 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1781 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1782 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1783 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1784 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1785 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1786 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1787 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1788 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1789 case SHT_MIPS_LINE: return "MIPS_LINE";
1790 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1791 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1792 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1793 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1794 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1795 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1796 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1797 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1798 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1799 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1800 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1801 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1802 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1803 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1804 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1805 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1813 get_parisc_section_type_name (sh_type)
1814 unsigned int sh_type;
1818 case SHT_PARISC_EXT: return "PARISC_EXT";
1819 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1820 case SHT_PARISC_DOC: return "PARISC_DOC";
1828 get_ia64_section_type_name (sh_type)
1829 unsigned int sh_type;
1833 case SHT_IA_64_EXT: return "IA_64_EXT";
1834 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
1842 get_section_type_name (sh_type)
1843 unsigned int sh_type;
1845 static char buff [32];
1849 case SHT_NULL: return "NULL";
1850 case SHT_PROGBITS: return "PROGBITS";
1851 case SHT_SYMTAB: return "SYMTAB";
1852 case SHT_STRTAB: return "STRTAB";
1853 case SHT_RELA: return "RELA";
1854 case SHT_HASH: return "HASH";
1855 case SHT_DYNAMIC: return "DYNAMIC";
1856 case SHT_NOTE: return "NOTE";
1857 case SHT_NOBITS: return "NOBITS";
1858 case SHT_REL: return "REL";
1859 case SHT_SHLIB: return "SHLIB";
1860 case SHT_DYNSYM: return "DYNSYM";
1861 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1862 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1863 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1864 case SHT_GROUP: return "GROUP";
1865 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
1866 case SHT_GNU_verdef: return "VERDEF";
1867 case SHT_GNU_verneed: return "VERNEED";
1868 case SHT_GNU_versym: return "VERSYM";
1869 case 0x6ffffff0: return "VERSYM";
1870 case 0x6ffffffc: return "VERDEF";
1871 case 0x7ffffffd: return "AUXILIARY";
1872 case 0x7fffffff: return "FILTER";
1875 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1877 const char * result;
1879 switch (elf_header.e_machine)
1882 case EM_MIPS_RS4_BE:
1883 result = get_mips_section_type_name (sh_type);
1886 result = get_parisc_section_type_name (sh_type);
1889 result = get_ia64_section_type_name (sh_type);
1899 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1901 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1902 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1903 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1904 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1906 sprintf (buff, _("<unknown>: %x"), sh_type);
1912 struct option options [] =
1914 {"all", no_argument, 0, 'a'},
1915 {"file-header", no_argument, 0, 'h'},
1916 {"program-headers", no_argument, 0, 'l'},
1917 {"headers", no_argument, 0, 'e'},
1918 {"histogram", no_argument, 0, 'I'},
1919 {"segments", no_argument, 0, 'l'},
1920 {"sections", no_argument, 0, 'S'},
1921 {"section-headers", no_argument, 0, 'S'},
1922 {"symbols", no_argument, 0, 's'},
1923 {"syms", no_argument, 0, 's'},
1924 {"relocs", no_argument, 0, 'r'},
1925 {"notes", no_argument, 0, 'n'},
1926 {"dynamic", no_argument, 0, 'd'},
1927 {"arch-specific", no_argument, 0, 'A'},
1928 {"version-info", no_argument, 0, 'V'},
1929 {"use-dynamic", no_argument, 0, 'D'},
1930 {"hex-dump", required_argument, 0, 'x'},
1931 {"debug-dump", optional_argument, 0, 'w'},
1932 {"unwind", no_argument, 0, 'u'},
1933 #ifdef SUPPORT_DISASSEMBLY
1934 {"instruction-dump", required_argument, 0, 'i'},
1937 {"version", no_argument, 0, 'v'},
1938 {"help", no_argument, 0, 'H'},
1939 {0, no_argument, 0, 0}
1945 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1946 fprintf (stdout, _(" Options are:\n"));
1947 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1948 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1949 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1950 fprintf (stdout, _(" Display the program headers\n"));
1951 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1952 fprintf (stdout, _(" Display the sections' header\n"));
1953 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1954 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1955 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1956 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1957 fprintf (stdout, _(" -u or --unwind Display the unwind info (if present)\n"));
1958 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1959 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1960 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1961 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1962 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1963 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1964 fprintf (stdout, _(" -w[liaprf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=frames]\n"));
1965 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
1966 #ifdef SUPPORT_DISASSEMBLY
1967 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1968 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1970 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1971 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1972 fprintf (stdout, _(" -H or --help Display this information\n"));
1973 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
1979 request_dump (section, type)
1980 unsigned int section;
1983 if (section >= num_dump_sects)
1985 char * new_dump_sects;
1987 new_dump_sects = (char *) calloc (section + 1, 1);
1989 if (new_dump_sects == NULL)
1990 error (_("Out of memory allocating dump request table."));
1993 /* Copy current flag settings. */
1994 memcpy (new_dump_sects, dump_sects, num_dump_sects);
1998 dump_sects = new_dump_sects;
1999 num_dump_sects = section + 1;
2004 dump_sects [section] |= type;
2010 parse_args (argc, argv)
2019 while ((c = getopt_long
2020 (argc, argv, "ersuahnldSDAIw::x:i:vV", options, NULL)) != EOF)
2056 do_using_dynamic ++;
2087 section = strtoul (optarg, & cp, 0);
2088 if (! * cp && section >= 0)
2090 request_dump (section, HEX_DUMP);
2110 do_debug_abbrevs = 1;
2120 do_debug_pubnames = 1;
2125 do_debug_aranges = 1;
2130 do_debug_frames = 1;
2134 warn (_("Unrecognised debug option '%s'\n"), optarg);
2139 #ifdef SUPPORT_DISASSEMBLY
2142 section = strtoul (optarg, & cp, 0);
2143 if (! * cp && section >= 0)
2145 request_dump (section, DISASS_DUMP);
2151 print_version (program_name);
2158 /* xgettext:c-format */
2159 error (_("Invalid option '-%c'\n"), c);
2166 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2167 && !do_segments && !do_header && !do_dump && !do_version
2168 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2172 warn (_("Nothing to do.\n"));
2178 get_elf_class (elf_class)
2179 unsigned char elf_class;
2181 static char buff [32];
2185 case ELFCLASSNONE: return _("none");
2186 case ELFCLASS32: return _("ELF32");
2187 case ELFCLASS64: return _("ELF64");
2189 sprintf (buff, _("<unknown: %x>"), elf_class);
2195 get_data_encoding (encoding)
2196 unsigned char encoding;
2198 static char buff [32];
2202 case ELFDATANONE: return _("none");
2203 case ELFDATA2LSB: return _("2's complement, little endian");
2204 case ELFDATA2MSB: return _("2's complement, big endian");
2206 sprintf (buff, _("<unknown: %x>"), encoding);
2212 get_osabi_name (osabi)
2213 unsigned char osabi;
2215 static char buff [32];
2219 case ELFOSABI_NONE: return _("UNIX - System V");
2220 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2221 case ELFOSABI_NETBSD: return _("UNIX - NetBSD");
2222 case ELFOSABI_LINUX: return _("UNIX - Linux");
2223 case ELFOSABI_HURD: return _("GNU/Hurd");
2224 case ELFOSABI_SOLARIS: return _("UNIX - Solaris");
2225 case ELFOSABI_AIX: return _("UNIX - AIX");
2226 case ELFOSABI_IRIX: return _("UNIX - IRIX");
2227 case ELFOSABI_FREEBSD: return _("UNIX - FreeBSD");
2228 case ELFOSABI_TRU64: return _("UNIX - TRU64");
2229 case ELFOSABI_MODESTO: return _("Novell - Modesto");
2230 case ELFOSABI_OPENBSD: return _("UNIX - OpenBSD");
2231 case ELFOSABI_STANDALONE: return _("Standalone App");
2232 case ELFOSABI_ARM: return _("ARM");
2234 sprintf (buff, _("<unknown: %x>"), osabi);
2239 /* Decode the data held in 'elf_header'. */
2241 process_file_header ()
2243 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2244 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2245 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2246 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2249 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2257 printf (_("ELF Header:\n"));
2258 printf (_(" Magic: "));
2259 for (i = 0; i < EI_NIDENT; i ++)
2260 printf ("%2.2x ", elf_header.e_ident [i]);
2262 printf (_(" Class: %s\n"),
2263 get_elf_class (elf_header.e_ident [EI_CLASS]));
2264 printf (_(" Data: %s\n"),
2265 get_data_encoding (elf_header.e_ident [EI_DATA]));
2266 printf (_(" Version: %d %s\n"),
2267 elf_header.e_ident [EI_VERSION],
2268 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2270 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2273 printf (_(" OS/ABI: %s\n"),
2274 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2275 printf (_(" ABI Version: %d\n"),
2276 elf_header.e_ident [EI_ABIVERSION]);
2277 printf (_(" Type: %s\n"),
2278 get_file_type (elf_header.e_type));
2279 printf (_(" Machine: %s\n"),
2280 get_machine_name (elf_header.e_machine));
2281 printf (_(" Version: 0x%lx\n"),
2282 (unsigned long) elf_header.e_version);
2284 printf (_(" Entry point address: "));
2285 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2286 printf (_("\n Start of program headers: "));
2287 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2288 printf (_(" (bytes into file)\n Start of section headers: "));
2289 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2290 printf (_(" (bytes into file)\n"));
2292 printf (_(" Flags: 0x%lx%s\n"),
2293 (unsigned long) elf_header.e_flags,
2294 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2295 printf (_(" Size of this header: %ld (bytes)\n"),
2296 (long) elf_header.e_ehsize);
2297 printf (_(" Size of program headers: %ld (bytes)\n"),
2298 (long) elf_header.e_phentsize);
2299 printf (_(" Number of program headers: %ld\n"),
2300 (long) elf_header.e_phnum);
2301 printf (_(" Size of section headers: %ld (bytes)\n"),
2302 (long) elf_header.e_shentsize);
2303 printf (_(" Number of section headers: %ld\n"),
2304 (long) elf_header.e_shnum);
2305 printf (_(" Section header string table index: %ld\n"),
2306 (long) elf_header.e_shstrndx);
2314 get_32bit_program_headers (file, program_headers)
2316 Elf_Internal_Phdr * program_headers;
2318 Elf32_External_Phdr * phdrs;
2319 Elf32_External_Phdr * external;
2320 Elf32_Internal_Phdr * internal;
2323 GET_DATA_ALLOC (elf_header.e_phoff,
2324 elf_header.e_phentsize * elf_header.e_phnum,
2325 phdrs, Elf32_External_Phdr *, "program headers");
2327 for (i = 0, internal = program_headers, external = phdrs;
2328 i < elf_header.e_phnum;
2329 i ++, internal ++, external ++)
2331 internal->p_type = BYTE_GET (external->p_type);
2332 internal->p_offset = BYTE_GET (external->p_offset);
2333 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2334 internal->p_paddr = BYTE_GET (external->p_paddr);
2335 internal->p_filesz = BYTE_GET (external->p_filesz);
2336 internal->p_memsz = BYTE_GET (external->p_memsz);
2337 internal->p_flags = BYTE_GET (external->p_flags);
2338 internal->p_align = BYTE_GET (external->p_align);
2347 get_64bit_program_headers (file, program_headers)
2349 Elf_Internal_Phdr * program_headers;
2351 Elf64_External_Phdr * phdrs;
2352 Elf64_External_Phdr * external;
2353 Elf64_Internal_Phdr * internal;
2356 GET_DATA_ALLOC (elf_header.e_phoff,
2357 elf_header.e_phentsize * elf_header.e_phnum,
2358 phdrs, Elf64_External_Phdr *, "program headers");
2360 for (i = 0, internal = program_headers, external = phdrs;
2361 i < elf_header.e_phnum;
2362 i ++, internal ++, external ++)
2364 internal->p_type = BYTE_GET (external->p_type);
2365 internal->p_flags = BYTE_GET (external->p_flags);
2366 internal->p_offset = BYTE_GET8 (external->p_offset);
2367 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2368 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2369 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2370 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2371 internal->p_align = BYTE_GET8 (external->p_align);
2380 process_program_headers (file)
2383 Elf_Internal_Phdr * program_headers;
2384 Elf_Internal_Phdr * segment;
2387 if (elf_header.e_phnum == 0)
2390 printf (_("\nThere are no program headers in this file.\n"));
2394 if (do_segments && !do_header)
2396 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2397 printf (_("Entry point "));
2398 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2399 printf (_("\nThere are %d program headers, starting at offset "),
2400 elf_header.e_phnum);
2401 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2405 program_headers = (Elf_Internal_Phdr *) malloc
2406 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2408 if (program_headers == NULL)
2410 error (_("Out of memory\n"));
2415 i = get_32bit_program_headers (file, program_headers);
2417 i = get_64bit_program_headers (file, program_headers);
2421 free (program_headers);
2428 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2432 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2436 (_(" Type Offset VirtAddr PhysAddr\n"));
2438 (_(" FileSiz MemSiz Flags Align\n"));
2446 for (i = 0, segment = program_headers;
2447 i < elf_header.e_phnum;
2452 printf (" %-14.14s ", get_segment_type (segment->p_type));
2456 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2457 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2458 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2459 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2460 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2462 (segment->p_flags & PF_R ? 'R' : ' '),
2463 (segment->p_flags & PF_W ? 'W' : ' '),
2464 (segment->p_flags & PF_X ? 'E' : ' '));
2465 printf ("%#lx", (unsigned long) segment->p_align);
2469 print_vma (segment->p_offset, FULL_HEX);
2471 print_vma (segment->p_vaddr, FULL_HEX);
2473 print_vma (segment->p_paddr, FULL_HEX);
2475 print_vma (segment->p_filesz, FULL_HEX);
2477 print_vma (segment->p_memsz, FULL_HEX);
2479 (segment->p_flags & PF_R ? 'R' : ' '),
2480 (segment->p_flags & PF_W ? 'W' : ' '),
2481 (segment->p_flags & PF_X ? 'E' : ' '));
2482 print_vma (segment->p_align, HEX);
2486 switch (segment->p_type)
2490 loadaddr = (segment->p_vaddr & 0xfffff000)
2491 - (segment->p_offset & 0xfffff000);
2496 error (_("more than one dynamic segment\n"));
2498 dynamic_addr = segment->p_offset;
2499 dynamic_size = segment->p_filesz;
2503 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2504 error (_("Unable to find program interpreter name\n"));
2507 program_interpreter[0] = 0;
2508 fscanf (file, "%63s", program_interpreter);
2511 printf (_("\n [Requesting program interpreter: %s]"),
2512 program_interpreter);
2518 putc ('\n', stdout);
2527 if (do_segments && section_headers != NULL)
2529 printf (_("\n Section to Segment mapping:\n"));
2530 printf (_(" Segment Sections...\n"));
2532 assert (string_table != NULL);
2534 for (i = 0; i < elf_header.e_phnum; i++)
2537 Elf_Internal_Shdr * section;
2539 segment = program_headers + i;
2540 section = section_headers;
2542 printf (" %2.2d ", i);
2544 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2546 if (section->sh_size > 0
2547 /* Compare allocated sections by VMA, unallocated
2548 sections by file offset. */
2549 && (section->sh_flags & SHF_ALLOC
2550 ? (section->sh_addr >= segment->p_vaddr
2551 && section->sh_addr + section->sh_size
2552 <= segment->p_vaddr + segment->p_memsz)
2553 : ((bfd_vma) section->sh_offset >= segment->p_offset
2554 && (section->sh_offset + section->sh_size
2555 <= segment->p_offset + segment->p_filesz))))
2556 printf ("%s ", SECTION_NAME (section));
2563 free (program_headers);
2570 get_32bit_section_headers (file)
2573 Elf32_External_Shdr * shdrs;
2574 Elf32_Internal_Shdr * internal;
2577 GET_DATA_ALLOC (elf_header.e_shoff,
2578 elf_header.e_shentsize * elf_header.e_shnum,
2579 shdrs, Elf32_External_Shdr *, "section headers");
2581 section_headers = (Elf_Internal_Shdr *) malloc
2582 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2584 if (section_headers == NULL)
2586 error (_("Out of memory\n"));
2590 for (i = 0, internal = section_headers;
2591 i < elf_header.e_shnum;
2594 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2595 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2596 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2597 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2598 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2599 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2600 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2601 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2602 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2603 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2612 get_64bit_section_headers (file)
2615 Elf64_External_Shdr * shdrs;
2616 Elf64_Internal_Shdr * internal;
2619 GET_DATA_ALLOC (elf_header.e_shoff,
2620 elf_header.e_shentsize * elf_header.e_shnum,
2621 shdrs, Elf64_External_Shdr *, "section headers");
2623 section_headers = (Elf_Internal_Shdr *) malloc
2624 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2626 if (section_headers == NULL)
2628 error (_("Out of memory\n"));
2632 for (i = 0, internal = section_headers;
2633 i < elf_header.e_shnum;
2636 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2637 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2638 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2639 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2640 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2641 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2642 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2643 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2644 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2645 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2653 static Elf_Internal_Sym *
2654 get_32bit_elf_symbols (file, offset, number)
2656 unsigned long offset;
2657 unsigned long number;
2659 Elf32_External_Sym * esyms;
2660 Elf_Internal_Sym * isyms;
2661 Elf_Internal_Sym * psym;
2664 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2665 esyms, Elf32_External_Sym *, "symbols");
2667 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2671 error (_("Out of memory\n"));
2677 for (j = 0, psym = isyms;
2681 psym->st_name = BYTE_GET (esyms[j].st_name);
2682 psym->st_value = BYTE_GET (esyms[j].st_value);
2683 psym->st_size = BYTE_GET (esyms[j].st_size);
2684 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2685 psym->st_info = BYTE_GET (esyms[j].st_info);
2686 psym->st_other = BYTE_GET (esyms[j].st_other);
2694 static Elf_Internal_Sym *
2695 get_64bit_elf_symbols (file, offset, number)
2697 unsigned long offset;
2698 unsigned long number;
2700 Elf64_External_Sym * esyms;
2701 Elf_Internal_Sym * isyms;
2702 Elf_Internal_Sym * psym;
2705 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2706 esyms, Elf64_External_Sym *, "symbols");
2708 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2712 error (_("Out of memory\n"));
2718 for (j = 0, psym = isyms;
2722 psym->st_name = BYTE_GET (esyms[j].st_name);
2723 psym->st_info = BYTE_GET (esyms[j].st_info);
2724 psym->st_other = BYTE_GET (esyms[j].st_other);
2725 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2726 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2727 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2736 get_elf_section_flags (sh_flags)
2739 static char buff [32];
2747 flag = sh_flags & - sh_flags;
2752 case SHF_WRITE: strcat (buff, "W"); break;
2753 case SHF_ALLOC: strcat (buff, "A"); break;
2754 case SHF_EXECINSTR: strcat (buff, "X"); break;
2755 case SHF_MERGE: strcat (buff, "M"); break;
2756 case SHF_STRINGS: strcat (buff, "S"); break;
2757 case SHF_INFO_LINK: strcat (buff, "I"); break;
2758 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2759 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2760 case SHF_GROUP: strcat (buff, "G"); break;
2763 if (flag & SHF_MASKOS)
2766 sh_flags &= ~ SHF_MASKOS;
2768 else if (flag & SHF_MASKPROC)
2771 sh_flags &= ~ SHF_MASKPROC;
2783 process_section_headers (file)
2786 Elf_Internal_Shdr * section;
2789 section_headers = NULL;
2791 if (elf_header.e_shnum == 0)
2794 printf (_("\nThere are no sections in this file.\n"));
2799 if (do_sections && !do_header)
2800 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2801 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2805 if (! get_32bit_section_headers (file))
2808 else if (! get_64bit_section_headers (file))
2811 /* Read in the string table, so that we have names to display. */
2812 section = section_headers + elf_header.e_shstrndx;
2814 if (section->sh_size != 0)
2816 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2817 string_table, char *, "string table");
2819 string_table_length = section->sh_size;
2822 /* Scan the sections for the dynamic symbol table
2823 and dynamic string table and debug sections. */
2824 dynamic_symbols = NULL;
2825 dynamic_strings = NULL;
2826 dynamic_syminfo = NULL;
2828 for (i = 0, section = section_headers;
2829 i < elf_header.e_shnum;
2832 char * name = SECTION_NAME (section);
2834 if (section->sh_type == SHT_DYNSYM)
2836 if (dynamic_symbols != NULL)
2838 error (_("File contains multiple dynamic symbol tables\n"));
2842 num_dynamic_syms = section->sh_size / section->sh_entsize;
2844 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2846 else if (section->sh_type == SHT_STRTAB
2847 && strcmp (name, ".dynstr") == 0)
2849 if (dynamic_strings != NULL)
2851 error (_("File contains multiple dynamic string tables\n"));
2855 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2856 dynamic_strings, char *, "dynamic strings");
2858 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2859 || do_debug_lines || do_debug_pubnames || do_debug_aranges || do_debug_frames)
2860 && strncmp (name, ".debug_", 7) == 0)
2865 || (do_debug_info && (strcmp (name, "info") == 0))
2866 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2867 || (do_debug_lines && (strcmp (name, "line") == 0))
2868 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2869 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2870 || (do_debug_frames && (strcmp (name, "frame") == 0))
2872 request_dump (i, DEBUG_DUMP);
2874 /* linkonce section to be combined with .debug_info at link time. */
2875 else if ((do_debugging || do_debug_info)
2876 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
2877 request_dump (i, DEBUG_DUMP);
2878 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
2879 request_dump (i, DEBUG_DUMP);
2885 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2889 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2892 printf (_(" [Nr] Name Type Address Offset\n"));
2893 printf (_(" Size EntSize Flags Link Info Align\n"));
2896 for (i = 0, section = section_headers;
2897 i < elf_header.e_shnum;
2900 printf (" [%2d] %-17.17s %-15.15s ",
2902 SECTION_NAME (section),
2903 get_section_type_name (section->sh_type));
2907 print_vma (section->sh_addr, LONG_HEX);
2909 printf ( " %6.6lx %6.6lx %2.2lx",
2910 (unsigned long) section->sh_offset,
2911 (unsigned long) section->sh_size,
2912 (unsigned long) section->sh_entsize);
2914 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2916 printf ("%2ld %3lx %2ld\n",
2917 (unsigned long) section->sh_link,
2918 (unsigned long) section->sh_info,
2919 (unsigned long) section->sh_addralign);
2924 print_vma (section->sh_addr, LONG_HEX);
2925 printf (" %8.8lx", section->sh_offset);
2927 print_vma (section->sh_size, LONG_HEX);
2929 print_vma (section->sh_entsize, LONG_HEX);
2931 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2933 printf (" %2ld %3lx %ld\n",
2934 (unsigned long) section->sh_link,
2935 (unsigned long) section->sh_info,
2936 (unsigned long) section->sh_addralign);
2940 printf (_("Key to Flags:\n"));
2941 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2942 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
2943 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
2948 /* Process the reloc section. */
2950 process_relocs (file)
2953 unsigned long rel_size;
2954 unsigned long rel_offset;
2960 if (do_using_dynamic)
2962 int is_rela = FALSE;
2967 if (dynamic_info[DT_REL])
2969 rel_offset = dynamic_info[DT_REL];
2970 rel_size = dynamic_info[DT_RELSZ];
2973 else if (dynamic_info [DT_RELA])
2975 rel_offset = dynamic_info[DT_RELA];
2976 rel_size = dynamic_info[DT_RELASZ];
2979 else if (dynamic_info[DT_JMPREL])
2981 rel_offset = dynamic_info[DT_JMPREL];
2982 rel_size = dynamic_info[DT_PLTRELSZ];
2984 switch (dynamic_info[DT_PLTREL])
3001 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3002 rel_offset, rel_size);
3004 dump_relocations (file, rel_offset - loadaddr, rel_size,
3005 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3008 printf (_("\nThere are no dynamic relocations in this file.\n"));
3012 Elf32_Internal_Shdr * section;
3016 for (i = 0, section = section_headers;
3017 i < elf_header.e_shnum;
3020 if ( section->sh_type != SHT_RELA
3021 && section->sh_type != SHT_REL)
3024 rel_offset = section->sh_offset;
3025 rel_size = section->sh_size;
3029 Elf32_Internal_Shdr * strsec;
3030 Elf32_Internal_Shdr * symsec;
3031 Elf_Internal_Sym * symtab;
3034 unsigned long nsyms;
3036 printf (_("\nRelocation section "));
3038 if (string_table == NULL)
3039 printf ("%d", section->sh_name);
3041 printf ("'%s'", SECTION_NAME (section));
3043 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3044 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3046 symsec = section_headers + section->sh_link;
3048 nsyms = symsec->sh_size / symsec->sh_entsize;
3049 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
3054 strsec = section_headers + symsec->sh_link;
3056 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
3057 char *, "string table");
3059 is_rela = section->sh_type == SHT_RELA;
3061 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
3071 printf (_("\nThere are no relocations in this file.\n"));
3077 #include "unwind-ia64.h"
3079 /* An absolute address consists of a section and an offset. If the
3080 section is NULL, the offset itself is the address, otherwise, the
3081 address equals to LOAD_ADDRESS(section) + offset. */
3085 unsigned short section;
3091 struct unw_table_entry
3093 struct absaddr start;
3095 struct absaddr info;
3097 *table; /* Unwind table. */
3098 unsigned long table_len; /* Length of unwind table. */
3099 const unsigned char * info; /* Unwind info. */
3100 unsigned long info_size; /* Size of unwind info. */
3101 bfd_vma info_addr; /* starting address of unwind info. */
3102 bfd_vma seg_base; /* Starting address of segment. */
3103 Elf_Internal_Sym * symtab; /* The symbol table. */
3104 unsigned long nsyms; /* Number of symbols. */
3105 const char * strtab; /* The string table. */
3106 unsigned long strtab_size; /* Size of string table. */
3109 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3110 struct absaddr, const char **,
3112 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3113 static int slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3114 Elf32_Internal_Shdr *));
3117 find_symbol_for_address (aux, addr, symname, offset)
3118 struct unw_aux_info *aux;
3119 struct absaddr addr;
3120 const char **symname;
3123 bfd_vma dist = (bfd_vma) 0x100000;
3124 Elf_Internal_Sym *sym, *best = NULL;
3127 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3129 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3130 && sym->st_name != 0
3131 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3132 && addr.offset >= sym->st_value
3133 && addr.offset - sym->st_value < dist)
3136 dist = addr.offset - sym->st_value;
3143 *symname = (best->st_name >= aux->strtab_size
3144 ? "<corrupt>" : aux->strtab + best->st_name);
3149 *offset = addr.offset;
3153 dump_ia64_unwind (aux)
3154 struct unw_aux_info *aux;
3157 struct unw_table_entry * tp;
3160 addr_size = is_32bit_elf ? 4 : 8;
3162 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3166 const unsigned char * dp;
3167 const unsigned char * head;
3168 const char * procname;
3170 find_symbol_for_address (aux, tp->start, &procname, &offset);
3172 fputs ("\n<", stdout);
3176 fputs (procname, stdout);
3179 printf ("+%lx", (unsigned long) offset);
3182 fputs (">: [", stdout);
3183 print_vma (tp->start.offset, PREFIX_HEX);
3184 fputc ('-', stdout);
3185 print_vma (tp->end.offset, PREFIX_HEX);
3186 printf ("), info at +0x%lx\n",
3187 (unsigned long) (tp->info.offset - aux->seg_base));
3189 head = aux->info + (tp->info.offset - aux->info_addr);
3190 stamp = BYTE_GET8 ((unsigned char *) head);
3192 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3193 (unsigned) UNW_VER (stamp),
3194 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3195 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3196 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3197 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3199 if (UNW_VER (stamp) != 1)
3201 printf ("\tUnknown version.\n");
3206 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3207 dp = unw_decode (dp, in_body, & in_body);
3212 slurp_ia64_unwind_table (file, aux, sec)
3214 struct unw_aux_info *aux;
3215 Elf32_Internal_Shdr *sec;
3217 unsigned long size, addr_size, nrelas, i;
3218 Elf_Internal_Phdr *prog_hdrs, *seg;
3219 struct unw_table_entry *tep;
3220 Elf32_Internal_Shdr *relsec;
3221 Elf_Internal_Rela *rela, *rp;
3222 unsigned char *table, *tp;
3223 Elf_Internal_Sym *sym;
3224 const char *relname;
3227 addr_size = is_32bit_elf ? 4 : 8;
3229 /* First, find the starting address of the segment that includes
3232 if (elf_header.e_phnum)
3234 prog_hdrs = (Elf_Internal_Phdr *)
3235 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3238 result = get_32bit_program_headers (file, prog_hdrs);
3240 result = get_64bit_program_headers (file, prog_hdrs);
3248 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3250 if (seg->p_type != PT_LOAD)
3253 if (sec->sh_addr >= seg->p_vaddr
3254 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3256 aux->seg_base = seg->p_vaddr;
3264 /* Second, build the unwind table from the contents of the unwind section: */
3265 size = sec->sh_size;
3266 GET_DATA_ALLOC (sec->sh_offset, size, table, char *, "unwind table");
3268 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3269 for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3271 tep->start.section = SHN_UNDEF;
3272 tep->end.section = SHN_UNDEF;
3273 tep->info.section = SHN_UNDEF;
3276 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3277 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
3278 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
3282 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
3283 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
3284 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
3286 tep->start.offset += aux->seg_base;
3287 tep->end.offset += aux->seg_base;
3288 tep->info.offset += aux->seg_base;
3292 /* Third, apply any relocations to the unwind table: */
3294 for (relsec = section_headers;
3295 relsec < section_headers + elf_header.e_shnum;
3298 if (relsec->sh_type != SHT_RELA
3299 || section_headers + relsec->sh_info != sec)
3302 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3306 for (rp = rela; rp < rela + nrelas; ++rp)
3310 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3311 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3313 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3315 warn (_("Skipping unexpected symbol type %u"),
3316 ELF32_ST_TYPE (sym->st_info));
3322 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3323 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3325 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3327 warn (_("Skipping unexpected symbol type %u"),
3328 ELF64_ST_TYPE (sym->st_info));
3333 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
3335 warn (_("Skipping unexpected relocation type %s"), relname);
3339 i = rp->r_offset / (3 * addr_size);
3341 switch (rp->r_offset/addr_size % 3)
3344 aux->table[i].start.section = sym->st_shndx;
3345 aux->table[i].start.offset += rp->r_addend;
3348 aux->table[i].end.section = sym->st_shndx;
3349 aux->table[i].end.offset += rp->r_addend;
3352 aux->table[i].info.section = sym->st_shndx;
3353 aux->table[i].info.offset += rp->r_addend;
3363 aux->table_len = size / (3 * addr_size);
3368 process_unwind (file)
3371 Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
3372 unsigned long i, addr_size;
3373 struct unw_aux_info aux;
3375 memset (& aux, 0, sizeof (aux));
3377 addr_size = is_32bit_elf ? 4 : 8;
3382 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
3384 if (sec->sh_type == SHT_SYMTAB)
3386 aux.nsyms = sec->sh_size / sec->sh_entsize;
3387 aux.symtab = GET_ELF_SYMBOLS (file, sec->sh_offset, aux.nsyms);
3389 strsec = section_headers + sec->sh_link;
3390 aux.strtab_size = strsec->sh_size;
3391 GET_DATA_ALLOC (strsec->sh_offset, aux.strtab_size,
3392 (char *) aux.strtab, char *, "string table");
3394 else if (sec->sh_type == SHT_IA_64_UNWIND)
3396 else if (strcmp (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info) == 0)
3398 aux.info_size = sec->sh_size;
3399 aux.info_addr = sec->sh_addr;
3400 GET_DATA_ALLOC (sec->sh_offset, aux.info_size, (char *) aux.info,
3401 char *, "unwind info");
3407 printf (_("\nUnwind section "));
3409 if (string_table == NULL)
3410 printf ("%d", unwsec->sh_name);
3412 printf ("'%s'", SECTION_NAME (unwsec));
3414 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3415 unwsec->sh_offset, unwsec->sh_size / (3 * addr_size));
3417 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
3419 if (aux.table_len > 0)
3420 dump_ia64_unwind (& aux);
3423 printf (_("\nThere are no unwind sections in this file.\n"));
3426 free ((char *) aux.table);
3428 free ((char *) aux.info);
3432 free ((char *) aux.strtab);
3438 dynamic_segment_mips_val (entry)
3439 Elf_Internal_Dyn * entry;
3441 switch (entry->d_tag)
3444 if (entry->d_un.d_val == 0)
3448 static const char * opts[] =
3450 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3451 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3452 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3453 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3458 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
3459 if (entry->d_un.d_val & (1 << cnt))
3461 printf ("%s%s", first ? "" : " ", opts[cnt]);
3468 case DT_MIPS_IVERSION:
3469 if (dynamic_strings != NULL)
3470 printf ("Interface Version: %s\n",
3471 dynamic_strings + entry->d_un.d_val);
3473 printf ("%ld\n", (long) entry->d_un.d_ptr);
3476 case DT_MIPS_TIME_STAMP:
3481 time_t time = entry->d_un.d_val;
3482 tmp = gmtime (&time);
3483 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3484 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3485 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3486 printf ("Time Stamp: %s\n", timebuf);
3490 case DT_MIPS_RLD_VERSION:
3491 case DT_MIPS_LOCAL_GOTNO:
3492 case DT_MIPS_CONFLICTNO:
3493 case DT_MIPS_LIBLISTNO:
3494 case DT_MIPS_SYMTABNO:
3495 case DT_MIPS_UNREFEXTNO:
3496 case DT_MIPS_HIPAGENO:
3497 case DT_MIPS_DELTA_CLASS_NO:
3498 case DT_MIPS_DELTA_INSTANCE_NO:
3499 case DT_MIPS_DELTA_RELOC_NO:
3500 case DT_MIPS_DELTA_SYM_NO:
3501 case DT_MIPS_DELTA_CLASSSYM_NO:
3502 case DT_MIPS_COMPACT_SIZE:
3503 printf ("%ld\n", (long) entry->d_un.d_ptr);
3507 printf ("%#lx\n", (long) entry->d_un.d_ptr);
3513 dynamic_segment_parisc_val (entry)
3514 Elf_Internal_Dyn * entry;
3516 switch (entry->d_tag)
3518 case DT_HP_DLD_FLAGS:
3527 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3528 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3529 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3530 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3531 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3532 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3533 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3534 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3535 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3536 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3537 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3541 bfd_vma val = entry->d_un.d_val;
3543 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3544 if (val & flags[cnt].bit)
3548 fputs (flags[cnt].str, stdout);
3550 val ^= flags[cnt].bit;
3553 if (val != 0 || first)
3557 print_vma (val, HEX);
3563 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3569 get_32bit_dynamic_segment (file)
3572 Elf32_External_Dyn * edyn;
3573 Elf_Internal_Dyn * entry;
3576 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3577 edyn, Elf32_External_Dyn *, "dynamic segment");
3579 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3580 how large this .dynamic is now. We can do this even before the byte
3581 swapping since the DT_NULL tag is recognizable. */
3583 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3586 dynamic_segment = (Elf_Internal_Dyn *)
3587 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3589 if (dynamic_segment == NULL)
3591 error (_("Out of memory\n"));
3596 for (i = 0, entry = dynamic_segment;
3600 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3601 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3610 get_64bit_dynamic_segment (file)
3613 Elf64_External_Dyn * edyn;
3614 Elf_Internal_Dyn * entry;
3617 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3618 edyn, Elf64_External_Dyn *, "dynamic segment");
3620 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3621 how large this .dynamic is now. We can do this even before the byte
3622 swapping since the DT_NULL tag is recognizable. */
3624 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3627 dynamic_segment = (Elf_Internal_Dyn *)
3628 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3630 if (dynamic_segment == NULL)
3632 error (_("Out of memory\n"));
3637 for (i = 0, entry = dynamic_segment;
3641 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3642 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3651 get_dynamic_flags (flags)
3654 static char buff [64];
3659 flag = flags & - flags;
3664 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3665 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3666 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3667 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3668 default: strcat (buff, "unknown "); break;
3674 /* Parse and display the contents of the dynamic segment. */
3676 process_dynamic_segment (file)
3679 Elf_Internal_Dyn * entry;
3682 if (dynamic_size == 0)
3685 printf (_("\nThere is no dynamic segment in this file.\n"));
3692 if (! get_32bit_dynamic_segment (file))
3695 else if (! get_64bit_dynamic_segment (file))
3698 /* Find the appropriate symbol table. */
3699 if (dynamic_symbols == NULL)
3701 for (i = 0, entry = dynamic_segment;
3705 unsigned long offset;
3707 if (entry->d_tag != DT_SYMTAB)
3710 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3712 /* Since we do not know how big the symbol table is,
3713 we default to reading in the entire file (!) and
3714 processing that. This is overkill, I know, but it
3716 offset = entry->d_un.d_val - loadaddr;
3718 if (fseek (file, 0, SEEK_END))
3719 error (_("Unable to seek to end of file!"));
3722 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3724 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3726 if (num_dynamic_syms < 1)
3728 error (_("Unable to determine the number of symbols to load\n"));
3732 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3736 /* Similarly find a string table. */
3737 if (dynamic_strings == NULL)
3739 for (i = 0, entry = dynamic_segment;
3743 unsigned long offset;
3746 if (entry->d_tag != DT_STRTAB)
3749 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3751 /* Since we do not know how big the string table is,
3752 we default to reading in the entire file (!) and
3753 processing that. This is overkill, I know, but it
3756 offset = entry->d_un.d_val - loadaddr;
3757 if (fseek (file, 0, SEEK_END))
3758 error (_("Unable to seek to end of file\n"));
3759 str_tab_len = ftell (file) - offset;
3761 if (str_tab_len < 1)
3764 (_("Unable to determine the length of the dynamic string table\n"));
3768 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3769 "dynamic string table");
3775 /* And find the syminfo section if available. */
3776 if (dynamic_syminfo == NULL)
3778 unsigned int syminsz = 0;
3780 for (i = 0, entry = dynamic_segment;
3784 if (entry->d_tag == DT_SYMINENT)
3786 /* Note: these braces are necessary to avoid a syntax
3787 error from the SunOS4 C compiler. */
3788 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3790 else if (entry->d_tag == DT_SYMINSZ)
3791 syminsz = entry->d_un.d_val;
3792 else if (entry->d_tag == DT_SYMINFO)
3793 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3796 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3798 Elf_External_Syminfo * extsyminfo;
3799 Elf_Internal_Syminfo * syminfo;
3801 /* There is a syminfo section. Read the data. */
3802 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3803 Elf_External_Syminfo *, "symbol information");
3805 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3806 if (dynamic_syminfo == NULL)
3808 error (_("Out of memory\n"));
3812 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3813 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3816 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3817 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3824 if (do_dynamic && dynamic_addr)
3825 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3826 dynamic_addr, (long) dynamic_size);
3828 printf (_(" Tag Type Name/Value\n"));
3830 for (i = 0, entry = dynamic_segment;
3839 print_vma (entry->d_tag, FULL_HEX);
3840 dtype = get_dynamic_type (entry->d_tag);
3841 printf (" (%s)%*s", dtype,
3842 ((is_32bit_elf ? 27 : 19)
3843 - (int) strlen (dtype)),
3847 switch (entry->d_tag)
3851 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3861 switch (entry->d_tag)
3864 printf (_("Auxiliary library"));
3868 printf (_("Filter library"));
3872 printf (_("Configuration file"));
3876 printf (_("Dependency audit library"));
3880 printf (_("Audit library"));
3884 if (dynamic_strings)
3885 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3889 print_vma (entry->d_un.d_val, PREFIX_HEX);
3898 printf (_("Flags:"));
3899 if (entry->d_un.d_val == 0)
3900 printf (_(" None\n"));
3903 unsigned long int val = entry->d_un.d_val;
3904 if (val & DTF_1_PARINIT)
3906 printf (" PARINIT");
3907 val ^= DTF_1_PARINIT;
3909 if (val & DTF_1_CONFEXP)
3911 printf (" CONFEXP");
3912 val ^= DTF_1_CONFEXP;
3915 printf (" %lx", val);
3924 printf (_("Flags:"));
3925 if (entry->d_un.d_val == 0)
3926 printf (_(" None\n"));
3929 unsigned long int val = entry->d_un.d_val;
3930 if (val & DF_P1_LAZYLOAD)
3932 printf (" LAZYLOAD");
3933 val ^= DF_P1_LAZYLOAD;
3935 if (val & DF_P1_GROUPPERM)
3937 printf (" GROUPPERM");
3938 val ^= DF_P1_GROUPPERM;
3941 printf (" %lx", val);
3950 printf (_("Flags:"));
3951 if (entry->d_un.d_val == 0)
3952 printf (_(" None\n"));
3955 unsigned long int val = entry->d_un.d_val;
3961 if (val & DF_1_GLOBAL)
3966 if (val & DF_1_GROUP)
3971 if (val & DF_1_NODELETE)
3973 printf (" NODELETE");
3974 val ^= DF_1_NODELETE;
3976 if (val & DF_1_LOADFLTR)
3978 printf (" LOADFLTR");
3979 val ^= DF_1_LOADFLTR;
3981 if (val & DF_1_INITFIRST)
3983 printf (" INITFIRST");
3984 val ^= DF_1_INITFIRST;
3986 if (val & DF_1_NOOPEN)
3991 if (val & DF_1_ORIGIN)
3996 if (val & DF_1_DIRECT)
4001 if (val & DF_1_TRANS)
4006 if (val & DF_1_INTERPOSE)
4008 printf (" INTERPOSE");
4009 val ^= DF_1_INTERPOSE;
4011 if (val & DF_1_NODEFLIB)
4013 printf (" NODEFLIB");
4014 val ^= DF_1_NODEFLIB;
4016 if (val & DF_1_NODUMP)
4021 if (val & DF_1_CONLFAT)
4023 printf (" CONLFAT");
4024 val ^= DF_1_CONLFAT;
4027 printf (" %lx", val);
4035 puts (get_dynamic_type (entry->d_un.d_val));
4055 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4061 if (dynamic_strings == NULL)
4064 name = dynamic_strings + entry->d_un.d_val;
4068 switch (entry->d_tag)
4071 printf (_("Shared library: [%s]"), name);
4073 if (strcmp (name, program_interpreter) == 0)
4074 printf (_(" program interpreter"));
4078 printf (_("Library soname: [%s]"), name);
4082 printf (_("Library rpath: [%s]"), name);
4086 printf (_("Library runpath: [%s]"), name);
4090 print_vma (entry->d_un.d_val, PREFIX_HEX);
4095 print_vma (entry->d_un.d_val, PREFIX_HEX);
4111 case DT_INIT_ARRAYSZ:
4112 case DT_FINI_ARRAYSZ:
4115 print_vma (entry->d_un.d_val, UNSIGNED);
4116 printf (" (bytes)\n");
4126 print_vma (entry->d_un.d_val, UNSIGNED);
4139 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4143 name = dynamic_strings + entry->d_un.d_val;
4147 printf (_("Not needed object: [%s]\n"), name);
4152 print_vma (entry->d_un.d_val, PREFIX_HEX);
4158 /* The value of this entry is ignored. */
4162 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4163 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4168 switch (elf_header.e_machine)
4171 case EM_MIPS_RS4_BE:
4172 dynamic_segment_mips_val (entry);
4175 dynamic_segment_parisc_val (entry);
4178 print_vma (entry->d_un.d_val, PREFIX_HEX);
4190 get_ver_flags (flags)
4193 static char buff [32];
4200 if (flags & VER_FLG_BASE)
4201 strcat (buff, "BASE ");
4203 if (flags & VER_FLG_WEAK)
4205 if (flags & VER_FLG_BASE)
4206 strcat (buff, "| ");
4208 strcat (buff, "WEAK ");
4211 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4212 strcat (buff, "| <unknown>");
4217 /* Display the contents of the version sections. */
4219 process_version_sections (file)
4222 Elf32_Internal_Shdr * section;
4229 for (i = 0, section = section_headers;
4230 i < elf_header.e_shnum;
4233 switch (section->sh_type)
4235 case SHT_GNU_verdef:
4237 Elf_External_Verdef * edefs;
4244 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4245 SECTION_NAME (section), section->sh_info);
4247 printf (_(" Addr: 0x"));
4248 printf_vma (section->sh_addr);
4249 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4250 (unsigned long) section->sh_offset, section->sh_link,
4251 SECTION_NAME (section_headers + section->sh_link));
4253 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
4254 edefs, Elf_External_Verdef *,
4255 "version definition section");
4257 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
4260 Elf_External_Verdef * edef;
4261 Elf_Internal_Verdef ent;
4262 Elf_External_Verdaux * eaux;
4263 Elf_Internal_Verdaux aux;
4267 vstart = ((char *) edefs) + idx;
4269 edef = (Elf_External_Verdef *) vstart;
4271 ent.vd_version = BYTE_GET (edef->vd_version);
4272 ent.vd_flags = BYTE_GET (edef->vd_flags);
4273 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
4274 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
4275 ent.vd_hash = BYTE_GET (edef->vd_hash);
4276 ent.vd_aux = BYTE_GET (edef->vd_aux);
4277 ent.vd_next = BYTE_GET (edef->vd_next);
4279 printf (_(" %#06x: Rev: %d Flags: %s"),
4280 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
4282 printf (_(" Index: %d Cnt: %d "),
4283 ent.vd_ndx, ent.vd_cnt);
4285 vstart += ent.vd_aux;
4287 eaux = (Elf_External_Verdaux *) vstart;
4289 aux.vda_name = BYTE_GET (eaux->vda_name);
4290 aux.vda_next = BYTE_GET (eaux->vda_next);
4292 if (dynamic_strings)
4293 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
4295 printf (_("Name index: %ld\n"), aux.vda_name);
4297 isum = idx + ent.vd_aux;
4299 for (j = 1; j < ent.vd_cnt; j ++)
4301 isum += aux.vda_next;
4302 vstart += aux.vda_next;
4304 eaux = (Elf_External_Verdaux *) vstart;
4306 aux.vda_name = BYTE_GET (eaux->vda_name);
4307 aux.vda_next = BYTE_GET (eaux->vda_next);
4309 if (dynamic_strings)
4310 printf (_(" %#06x: Parent %d: %s\n"),
4311 isum, j, dynamic_strings + aux.vda_name);
4313 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4314 isum, j, aux.vda_name);
4324 case SHT_GNU_verneed:
4326 Elf_External_Verneed * eneed;
4332 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4333 SECTION_NAME (section), section->sh_info);
4335 printf (_(" Addr: 0x"));
4336 printf_vma (section->sh_addr);
4337 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4338 (unsigned long) section->sh_offset, section->sh_link,
4339 SECTION_NAME (section_headers + section->sh_link));
4341 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
4342 eneed, Elf_External_Verneed *,
4343 "version need section");
4345 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
4347 Elf_External_Verneed * entry;
4348 Elf_Internal_Verneed ent;
4353 vstart = ((char *) eneed) + idx;
4355 entry = (Elf_External_Verneed *) vstart;
4357 ent.vn_version = BYTE_GET (entry->vn_version);
4358 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
4359 ent.vn_file = BYTE_GET (entry->vn_file);
4360 ent.vn_aux = BYTE_GET (entry->vn_aux);
4361 ent.vn_next = BYTE_GET (entry->vn_next);
4363 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
4365 if (dynamic_strings)
4366 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
4368 printf (_(" File: %lx"), ent.vn_file);
4370 printf (_(" Cnt: %d\n"), ent.vn_cnt);
4372 vstart += ent.vn_aux;
4374 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
4376 Elf_External_Vernaux * eaux;
4377 Elf_Internal_Vernaux aux;
4379 eaux = (Elf_External_Vernaux *) vstart;
4381 aux.vna_hash = BYTE_GET (eaux->vna_hash);
4382 aux.vna_flags = BYTE_GET (eaux->vna_flags);
4383 aux.vna_other = BYTE_GET (eaux->vna_other);
4384 aux.vna_name = BYTE_GET (eaux->vna_name);
4385 aux.vna_next = BYTE_GET (eaux->vna_next);
4387 if (dynamic_strings)
4388 printf (_(" %#06x: Name: %s"),
4389 isum, dynamic_strings + aux.vna_name);
4391 printf (_(" %#06x: Name index: %lx"),
4392 isum, aux.vna_name);
4394 printf (_(" Flags: %s Version: %d\n"),
4395 get_ver_flags (aux.vna_flags), aux.vna_other);
4397 isum += aux.vna_next;
4398 vstart += aux.vna_next;
4408 case SHT_GNU_versym:
4410 Elf32_Internal_Shdr * link_section;
4413 unsigned char * edata;
4414 unsigned short * data;
4416 Elf_Internal_Sym * symbols;
4417 Elf32_Internal_Shdr * string_sec;
4419 link_section = section_headers + section->sh_link;
4420 total = section->sh_size / section->sh_entsize;
4424 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
4425 link_section->sh_size / link_section->sh_entsize);
4427 string_sec = section_headers + link_section->sh_link;
4429 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4430 strtab, char *, "version string table");
4432 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4433 SECTION_NAME (section), total);
4435 printf (_(" Addr: "));
4436 printf_vma (section->sh_addr);
4437 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4438 (unsigned long) section->sh_offset, section->sh_link,
4439 SECTION_NAME (link_section));
4441 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4443 total * sizeof (short), edata,
4444 unsigned char *, "version symbol data");
4446 data = (unsigned short *) malloc (total * sizeof (short));
4448 for (cnt = total; cnt --;)
4449 data [cnt] = byte_get (edata + cnt * sizeof (short),
4454 for (cnt = 0; cnt < total; cnt += 4)
4457 int check_def, check_need;
4460 printf (" %03x:", cnt);
4462 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
4463 switch (data [cnt + j])
4466 fputs (_(" 0 (*local*) "), stdout);
4470 fputs (_(" 1 (*global*) "), stdout);
4474 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4475 data [cnt + j] & 0x8000 ? 'h' : ' ');
4479 if (symbols [cnt + j].st_shndx >= SHN_LORESERVE
4480 || section_headers[symbols [cnt + j].st_shndx].sh_type
4483 if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4490 && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
4492 Elf_Internal_Verneed ivn;
4493 unsigned long offset;
4495 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4500 Elf_Internal_Vernaux ivna;
4501 Elf_External_Verneed evn;
4502 Elf_External_Vernaux evna;
4503 unsigned long a_off;
4505 GET_DATA (offset, evn, "version need");
4507 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4508 ivn.vn_next = BYTE_GET (evn.vn_next);
4510 a_off = offset + ivn.vn_aux;
4514 GET_DATA (a_off, evna,
4515 "version need aux (2)");
4517 ivna.vna_next = BYTE_GET (evna.vna_next);
4518 ivna.vna_other = BYTE_GET (evna.vna_other);
4520 a_off += ivna.vna_next;
4522 while (ivna.vna_other != data [cnt + j]
4523 && ivna.vna_next != 0);
4525 if (ivna.vna_other == data [cnt + j])
4527 ivna.vna_name = BYTE_GET (evna.vna_name);
4529 name = strtab + ivna.vna_name;
4530 nn += printf ("(%s%-*s",
4532 12 - (int) strlen (name),
4538 offset += ivn.vn_next;
4540 while (ivn.vn_next);
4543 if (check_def && data [cnt + j] != 0x8001
4544 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
4546 Elf_Internal_Verdef ivd;
4547 Elf_External_Verdef evd;
4548 unsigned long offset;
4550 offset = version_info
4551 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4555 GET_DATA (offset, evd, "version def");
4557 ivd.vd_next = BYTE_GET (evd.vd_next);
4558 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4560 offset += ivd.vd_next;
4562 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4563 && ivd.vd_next != 0);
4565 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4567 Elf_External_Verdaux evda;
4568 Elf_Internal_Verdaux ivda;
4570 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4572 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4573 evda, "version def aux");
4575 ivda.vda_name = BYTE_GET (evda.vda_name);
4577 name = strtab + ivda.vda_name;
4578 nn += printf ("(%s%-*s",
4580 12 - (int) strlen (name),
4586 printf ("%*c", 18 - nn, ' ');
4604 printf (_("\nNo version information found in this file.\n"));
4610 get_symbol_binding (binding)
4611 unsigned int binding;
4613 static char buff [32];
4617 case STB_LOCAL: return "LOCAL";
4618 case STB_GLOBAL: return "GLOBAL";
4619 case STB_WEAK: return "WEAK";
4621 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4622 sprintf (buff, _("<processor specific>: %d"), binding);
4623 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4624 sprintf (buff, _("<OS specific>: %d"), binding);
4626 sprintf (buff, _("<unknown>: %d"), binding);
4632 get_symbol_type (type)
4635 static char buff [32];
4639 case STT_NOTYPE: return "NOTYPE";
4640 case STT_OBJECT: return "OBJECT";
4641 case STT_FUNC: return "FUNC";
4642 case STT_SECTION: return "SECTION";
4643 case STT_FILE: return "FILE";
4644 case STT_COMMON: return "COMMON";
4646 if (type >= STT_LOPROC && type <= STT_HIPROC)
4648 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4649 return "THUMB_FUNC";
4651 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4654 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4655 return "PARISC_MILLI";
4657 sprintf (buff, _("<processor specific>: %d"), type);
4659 else if (type >= STT_LOOS && type <= STT_HIOS)
4661 if (elf_header.e_machine == EM_PARISC)
4663 if (type == STT_HP_OPAQUE)
4665 if (type == STT_HP_STUB)
4669 sprintf (buff, _("<OS specific>: %d"), type);
4672 sprintf (buff, _("<unknown>: %d"), type);
4678 get_symbol_visibility (visibility)
4679 unsigned int visibility;
4683 case STV_DEFAULT: return "DEFAULT";
4684 case STV_INTERNAL: return "INTERNAL";
4685 case STV_HIDDEN: return "HIDDEN";
4686 case STV_PROTECTED: return "PROTECTED";
4692 get_symbol_index_type (type)
4697 case SHN_UNDEF: return "UND";
4698 case SHN_ABS: return "ABS";
4699 case SHN_COMMON: return "COM";
4701 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4703 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4705 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4709 static char buff [32];
4711 sprintf (buff, "%3d", type);
4718 get_dynamic_data (file, number)
4720 unsigned int number;
4722 unsigned char * e_data;
4725 e_data = (unsigned char *) malloc (number * 4);
4729 error (_("Out of memory\n"));
4733 if (fread (e_data, 4, number, file) != number)
4735 error (_("Unable to read in dynamic data\n"));
4739 i_data = (int *) malloc (number * sizeof (* i_data));
4743 error (_("Out of memory\n"));
4749 i_data [number] = byte_get (e_data + number * 4, 4);
4756 /* Dump the symbol table */
4758 process_symbol_table (file)
4761 Elf32_Internal_Shdr * section;
4762 unsigned char nb [4];
4763 unsigned char nc [4];
4766 int * buckets = NULL;
4767 int * chains = NULL;
4769 if (! do_syms && !do_histogram)
4772 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4775 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4777 error (_("Unable to seek to start of dynamic information"));
4781 if (fread (nb, sizeof (nb), 1, file) != 1)
4783 error (_("Failed to read in number of buckets\n"));
4787 if (fread (nc, sizeof (nc), 1, file) != 1)
4789 error (_("Failed to read in number of chains\n"));
4793 nbuckets = byte_get (nb, 4);
4794 nchains = byte_get (nc, 4);
4796 buckets = get_dynamic_data (file, nbuckets);
4797 chains = get_dynamic_data (file, nchains);
4799 if (buckets == NULL || chains == NULL)
4804 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4809 printf (_("\nSymbol table for image:\n"));
4811 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4813 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4815 for (hn = 0; hn < nbuckets; hn++)
4820 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4822 Elf_Internal_Sym * psym;
4824 psym = dynamic_symbols + si;
4826 printf (" %3d %3d: ", si, hn);
4827 print_vma (psym->st_value, LONG_HEX);
4829 print_vma (psym->st_size, DEC_5);
4831 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4832 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4833 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4834 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4835 printf (" %s\n", dynamic_strings + psym->st_name);
4839 else if (do_syms && !do_using_dynamic)
4843 for (i = 0, section = section_headers;
4844 i < elf_header.e_shnum;
4849 Elf_Internal_Sym * symtab;
4850 Elf_Internal_Sym * psym;
4853 if ( section->sh_type != SHT_SYMTAB
4854 && section->sh_type != SHT_DYNSYM)
4857 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4858 SECTION_NAME (section),
4859 (unsigned long) (section->sh_size / section->sh_entsize));
4861 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4863 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4865 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4866 section->sh_size / section->sh_entsize);
4870 if (section->sh_link == elf_header.e_shstrndx)
4871 strtab = string_table;
4874 Elf32_Internal_Shdr * string_sec;
4876 string_sec = section_headers + section->sh_link;
4878 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4879 strtab, char *, "string table");
4882 for (si = 0, psym = symtab;
4883 si < section->sh_size / section->sh_entsize;
4886 printf ("%6d: ", si);
4887 print_vma (psym->st_value, LONG_HEX);
4889 print_vma (psym->st_size, DEC_5);
4890 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4891 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4892 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4893 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4894 printf (" %s", strtab + psym->st_name);
4896 if (section->sh_type == SHT_DYNSYM &&
4897 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4899 unsigned char data[2];
4900 unsigned short vers_data;
4901 unsigned long offset;
4905 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4908 GET_DATA (offset + si * sizeof (vers_data), data,
4911 vers_data = byte_get (data, 2);
4913 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4914 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4917 check_def = (psym->st_shndx != SHN_UNDEF);
4919 if ((vers_data & 0x8000) || vers_data > 1)
4921 if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4922 && (is_nobits || ! check_def))
4924 Elf_External_Verneed evn;
4925 Elf_Internal_Verneed ivn;
4926 Elf_Internal_Vernaux ivna;
4928 /* We must test both. */
4929 offset = version_info
4930 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4934 unsigned long vna_off;
4936 GET_DATA (offset, evn, "version need");
4938 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4939 ivn.vn_next = BYTE_GET (evn.vn_next);
4941 vna_off = offset + ivn.vn_aux;
4945 Elf_External_Vernaux evna;
4947 GET_DATA (vna_off, evna,
4948 "version need aux (3)");
4950 ivna.vna_other = BYTE_GET (evna.vna_other);
4951 ivna.vna_next = BYTE_GET (evna.vna_next);
4952 ivna.vna_name = BYTE_GET (evna.vna_name);
4954 vna_off += ivna.vna_next;
4956 while (ivna.vna_other != vers_data
4957 && ivna.vna_next != 0);
4959 if (ivna.vna_other == vers_data)
4962 offset += ivn.vn_next;
4964 while (ivn.vn_next != 0);
4966 if (ivna.vna_other == vers_data)
4969 strtab + ivna.vna_name, ivna.vna_other);
4972 else if (! is_nobits)
4973 error (_("bad dynamic symbol"));
4980 if (vers_data != 0x8001
4981 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
4983 Elf_Internal_Verdef ivd;
4984 Elf_Internal_Verdaux ivda;
4985 Elf_External_Verdaux evda;
4986 unsigned long offset;
4989 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4994 Elf_External_Verdef evd;
4996 GET_DATA (offset, evd, "version def");
4998 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4999 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5000 ivd.vd_next = BYTE_GET (evd.vd_next);
5002 offset += ivd.vd_next;
5004 while (ivd.vd_ndx != (vers_data & 0x7fff)
5005 && ivd.vd_next != 0);
5007 offset -= ivd.vd_next;
5008 offset += ivd.vd_aux;
5010 GET_DATA (offset, evda, "version def aux");
5012 ivda.vda_name = BYTE_GET (evda.vda_name);
5014 if (psym->st_name != ivda.vda_name)
5015 printf ((vers_data & 0x8000)
5017 strtab + ivda.vda_name);
5027 if (strtab != string_table)
5033 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5035 if (do_histogram && buckets != NULL)
5042 int nzero_counts = 0;
5045 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5047 printf (_(" Length Number %% of total Coverage\n"));
5049 lengths = (int *) calloc (nbuckets, sizeof (int));
5050 if (lengths == NULL)
5052 error (_("Out of memory"));
5055 for (hn = 0; hn < nbuckets; ++hn)
5060 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5063 if (maxlength < ++lengths[hn])
5068 counts = (int *) calloc (maxlength + 1, sizeof (int));
5071 error (_("Out of memory"));
5075 for (hn = 0; hn < nbuckets; ++hn)
5076 ++ counts [lengths [hn]];
5080 printf (" 0 %-10d (%5.1f%%)\n",
5081 counts[0], (counts[0] * 100.0) / nbuckets);
5082 for (si = 1; si <= maxlength; ++si)
5084 nzero_counts += counts[si] * si;
5085 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5086 si, counts[si], (counts[si] * 100.0) / nbuckets,
5087 (nzero_counts * 100.0) / nsyms);
5095 if (buckets != NULL)
5105 process_syminfo (file)
5106 FILE * file ATTRIBUTE_UNUSED;
5110 if (dynamic_syminfo == NULL
5112 /* No syminfo, this is ok. */
5115 /* There better should be a dynamic symbol section. */
5116 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5120 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5121 dynamic_syminfo_offset, dynamic_syminfo_nent);
5123 printf (_(" Num: Name BoundTo Flags\n"));
5124 for (i = 0; i < dynamic_syminfo_nent; ++i)
5126 unsigned short int flags = dynamic_syminfo[i].si_flags;
5128 printf ("%4d: %-30s ", i,
5129 dynamic_strings + dynamic_symbols[i].st_name);
5131 switch (dynamic_syminfo[i].si_boundto)
5133 case SYMINFO_BT_SELF:
5134 fputs ("SELF ", stdout);
5136 case SYMINFO_BT_PARENT:
5137 fputs ("PARENT ", stdout);
5140 if (dynamic_syminfo[i].si_boundto > 0
5141 && dynamic_syminfo[i].si_boundto < dynamic_size)
5144 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
5146 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5150 if (flags & SYMINFO_FLG_DIRECT)
5152 if (flags & SYMINFO_FLG_PASSTHRU)
5153 printf (" PASSTHRU");
5154 if (flags & SYMINFO_FLG_COPY)
5156 if (flags & SYMINFO_FLG_LAZYLOAD)
5157 printf (" LAZYLOAD");
5165 #ifdef SUPPORT_DISASSEMBLY
5167 disassemble_section (section, file)
5168 Elf32_Internal_Shdr * section;
5171 printf (_("\nAssembly dump of section %s\n"),
5172 SECTION_NAME (section));
5174 /* XXX -- to be done --- XXX */
5181 dump_section (section, file)
5182 Elf32_Internal_Shdr * section;
5185 bfd_size_type bytes;
5187 unsigned char * data;
5188 unsigned char * start;
5190 bytes = section->sh_size;
5194 printf (_("\nSection '%s' has no data to dump.\n"),
5195 SECTION_NAME (section));
5199 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5201 addr = section->sh_addr;
5203 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
5214 lbytes = (bytes > 16 ? 16 : bytes);
5216 printf (" 0x%8.8lx ", (unsigned long) addr);
5218 switch (elf_header.e_ident [EI_DATA])
5222 for (j = 15; j >= 0; j --)
5225 printf ("%2.2x", data [j]);
5235 for (j = 0; j < 16; j++)
5238 printf ("%2.2x", data [j]);
5248 for (j = 0; j < lbytes; j++)
5251 if (k >= ' ' && k < 0x80)
5270 static unsigned long int
5271 read_leb128 (data, length_return, sign)
5272 unsigned char * data;
5273 int * length_return;
5276 unsigned long int result = 0;
5277 unsigned int num_read = 0;
5286 result |= (byte & 0x7f) << shift;
5291 while (byte & 0x80);
5293 if (length_return != NULL)
5294 * length_return = num_read;
5296 if (sign && (shift < 32) && (byte & 0x40))
5297 result |= -1 << shift;
5302 typedef struct State_Machine_Registers
5304 unsigned long address;
5307 unsigned int column;
5311 /* This variable hold the number of the last entry seen
5312 in the File Table. */
5313 unsigned int last_file_entry;
5316 static SMR state_machine_regs;
5319 reset_state_machine (is_stmt)
5322 state_machine_regs.address = 0;
5323 state_machine_regs.file = 1;
5324 state_machine_regs.line = 1;
5325 state_machine_regs.column = 0;
5326 state_machine_regs.is_stmt = is_stmt;
5327 state_machine_regs.basic_block = 0;
5328 state_machine_regs.end_sequence = 0;
5329 state_machine_regs.last_file_entry = 0;
5332 /* Handled an extend line op. Returns true if this is the end
5335 process_extended_line_op (data, is_stmt, pointer_size)
5336 unsigned char * data;
5340 unsigned char op_code;
5343 unsigned char * name;
5346 len = read_leb128 (data, & bytes_read, 0);
5351 warn (_("badly formed extended line op encountered!"));
5356 op_code = * data ++;
5358 printf (_(" Extended opcode %d: "), op_code);
5362 case DW_LNE_end_sequence:
5363 printf (_("End of Sequence\n\n"));
5364 reset_state_machine (is_stmt);
5367 case DW_LNE_set_address:
5368 adr = byte_get (data, pointer_size);
5369 printf (_("set Address to 0x%lx\n"), adr);
5370 state_machine_regs.address = adr;
5373 case DW_LNE_define_file:
5374 printf (_(" define new File Table entry\n"));
5375 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5377 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5379 data += strlen ((char *) data) + 1;
5380 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5382 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5384 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5385 printf (_("%s\n\n"), name);
5389 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5396 /* Size of pointers in the .debug_line section. This information is not
5397 really present in that section. It's obtained before dumping the debug
5398 sections by doing some pre-scan of the .debug_info section. */
5399 static int debug_line_pointer_size = 4;
5402 display_debug_lines (section, start, file)
5403 Elf32_Internal_Shdr * section;
5404 unsigned char * start;
5405 FILE * file ATTRIBUTE_UNUSED;
5407 DWARF2_External_LineInfo * external;
5408 DWARF2_Internal_LineInfo info;
5409 unsigned char * standard_opcodes;
5410 unsigned char * data = start;
5411 unsigned char * end = start + section->sh_size;
5412 unsigned char * end_of_sequence;
5415 printf (_("\nDump of debug contents of section %s:\n\n"),
5416 SECTION_NAME (section));
5420 external = (DWARF2_External_LineInfo *) data;
5422 /* Check the length of the block. */
5423 info.li_length = BYTE_GET (external->li_length);
5424 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5427 (_("The line info appears to be corrupt - the section is too small\n"));
5431 /* Check its version number. */
5432 info.li_version = BYTE_GET (external->li_version);
5433 if (info.li_version != 2)
5435 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5439 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5440 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5441 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5442 info.li_line_base = BYTE_GET (external->li_line_base);
5443 info.li_line_range = BYTE_GET (external->li_line_range);
5444 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5446 /* Sign extend the line base field. */
5447 info.li_line_base <<= 24;
5448 info.li_line_base >>= 24;
5450 printf (_(" Length: %ld\n"), info.li_length);
5451 printf (_(" DWARF Version: %d\n"), info.li_version);
5452 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
5453 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5454 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5455 printf (_(" Line Base: %d\n"), info.li_line_base);
5456 printf (_(" Line Range: %d\n"), info.li_line_range);
5457 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5459 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5461 reset_state_machine (info.li_default_is_stmt);
5463 /* Display the contents of the Opcodes table. */
5464 standard_opcodes = data + sizeof (* external);
5466 printf (_("\n Opcodes:\n"));
5468 for (i = 1; i < info.li_opcode_base; i++)
5469 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5471 /* Display the contents of the Directory table. */
5472 data = standard_opcodes + info.li_opcode_base - 1;
5475 printf (_("\n The Directory Table is empty.\n"));
5478 printf (_("\n The Directory Table:\n"));
5482 printf (_(" %s\n"), data);
5484 data += strlen ((char *) data) + 1;
5488 /* Skip the NUL at the end of the table. */
5491 /* Display the contents of the File Name table. */
5493 printf (_("\n The File Name Table is empty.\n"));
5496 printf (_("\n The File Name Table:\n"));
5497 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5501 unsigned char * name;
5504 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5507 data += strlen ((char *) data) + 1;
5509 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5511 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5513 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5515 printf (_("%s\n"), name);
5519 /* Skip the NUL at the end of the table. */
5522 /* Now display the statements. */
5523 printf (_("\n Line Number Statements:\n"));
5526 while (data < end_of_sequence)
5528 unsigned char op_code;
5532 op_code = * data ++;
5536 case DW_LNS_extended_op:
5537 data += process_extended_line_op (data, info.li_default_is_stmt,
5538 debug_line_pointer_size);
5542 printf (_(" Copy\n"));
5545 case DW_LNS_advance_pc:
5546 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5548 state_machine_regs.address += adv;
5549 printf (_(" Advance PC by %d to %lx\n"), adv,
5550 state_machine_regs.address);
5553 case DW_LNS_advance_line:
5554 adv = read_leb128 (data, & bytes_read, 1);
5556 state_machine_regs.line += adv;
5557 printf (_(" Advance Line by %d to %d\n"), adv,
5558 state_machine_regs.line);
5561 case DW_LNS_set_file:
5562 adv = read_leb128 (data, & bytes_read, 0);
5564 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5566 state_machine_regs.file = adv;
5569 case DW_LNS_set_column:
5570 adv = read_leb128 (data, & bytes_read, 0);
5572 printf (_(" Set column to %d\n"), adv);
5573 state_machine_regs.column = adv;
5576 case DW_LNS_negate_stmt:
5577 adv = state_machine_regs.is_stmt;
5579 printf (_(" Set is_stmt to %d\n"), adv);
5580 state_machine_regs.is_stmt = adv;
5583 case DW_LNS_set_basic_block:
5584 printf (_(" Set basic block\n"));
5585 state_machine_regs.basic_block = 1;
5588 case DW_LNS_const_add_pc:
5589 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5590 * info.li_min_insn_length);
5591 state_machine_regs.address += adv;
5592 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5593 state_machine_regs.address);
5596 case DW_LNS_fixed_advance_pc:
5597 adv = byte_get (data, 2);
5599 state_machine_regs.address += adv;
5600 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5601 adv, state_machine_regs.address);
5605 op_code -= info.li_opcode_base;
5606 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5607 state_machine_regs.address += adv;
5608 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5609 op_code, adv, state_machine_regs.address);
5610 adv = (op_code % info.li_line_range) + info.li_line_base;
5611 state_machine_regs.line += adv;
5612 printf (_(" and Line by %d to %d\n"),
5613 adv, state_machine_regs.line);
5624 display_debug_pubnames (section, start, file)
5625 Elf32_Internal_Shdr * section;
5626 unsigned char * start;
5627 FILE * file ATTRIBUTE_UNUSED;
5629 DWARF2_External_PubNames * external;
5630 DWARF2_Internal_PubNames pubnames;
5631 unsigned char * end;
5633 end = start + section->sh_size;
5635 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5639 unsigned char * data;
5640 unsigned long offset;
5642 external = (DWARF2_External_PubNames *) start;
5644 pubnames.pn_length = BYTE_GET (external->pn_length);
5645 pubnames.pn_version = BYTE_GET (external->pn_version);
5646 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5647 pubnames.pn_size = BYTE_GET (external->pn_size);
5649 data = start + sizeof (* external);
5650 start += pubnames.pn_length + sizeof (external->pn_length);
5652 if (pubnames.pn_version != 2)
5654 static int warned = 0;
5658 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5665 printf (_(" Length: %ld\n"),
5666 pubnames.pn_length);
5667 printf (_(" Version: %d\n"),
5668 pubnames.pn_version);
5669 printf (_(" Offset into .debug_info section: %ld\n"),
5670 pubnames.pn_offset);
5671 printf (_(" Size of area in .debug_info section: %ld\n"),
5674 printf (_("\n Offset\tName\n"));
5678 offset = byte_get (data, 4);
5683 printf (" %ld\t\t%s\n", offset, data);
5684 data += strlen ((char *) data) + 1;
5687 while (offset != 0);
5700 case DW_TAG_padding: return "DW_TAG_padding";
5701 case DW_TAG_array_type: return "DW_TAG_array_type";
5702 case DW_TAG_class_type: return "DW_TAG_class_type";
5703 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5704 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5705 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5706 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5707 case DW_TAG_label: return "DW_TAG_label";
5708 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5709 case DW_TAG_member: return "DW_TAG_member";
5710 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5711 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5712 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5713 case DW_TAG_string_type: return "DW_TAG_string_type";
5714 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5715 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5716 case DW_TAG_typedef: return "DW_TAG_typedef";
5717 case DW_TAG_union_type: return "DW_TAG_union_type";
5718 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5719 case DW_TAG_variant: return "DW_TAG_variant";
5720 case DW_TAG_common_block: return "DW_TAG_common_block";
5721 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5722 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5723 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5724 case DW_TAG_module: return "DW_TAG_module";
5725 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5726 case DW_TAG_set_type: return "DW_TAG_set_type";
5727 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5728 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5729 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5730 case DW_TAG_base_type: return "DW_TAG_base_type";
5731 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5732 case DW_TAG_const_type: return "DW_TAG_const_type";
5733 case DW_TAG_constant: return "DW_TAG_constant";
5734 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5735 case DW_TAG_file_type: return "DW_TAG_file_type";
5736 case DW_TAG_friend: return "DW_TAG_friend";
5737 case DW_TAG_namelist: return "DW_TAG_namelist";
5738 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5739 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5740 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5741 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5742 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5743 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5744 case DW_TAG_try_block: return "DW_TAG_try_block";
5745 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5746 case DW_TAG_variable: return "DW_TAG_variable";
5747 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5748 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5749 case DW_TAG_format_label: return "DW_TAG_format_label";
5750 case DW_TAG_function_template: return "DW_TAG_function_template";
5751 case DW_TAG_class_template: return "DW_TAG_class_template";
5754 static char buffer [100];
5756 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5763 get_AT_name (attribute)
5764 unsigned long attribute;
5768 case DW_AT_sibling: return "DW_AT_sibling";
5769 case DW_AT_location: return "DW_AT_location";
5770 case DW_AT_name: return "DW_AT_name";
5771 case DW_AT_ordering: return "DW_AT_ordering";
5772 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5773 case DW_AT_byte_size: return "DW_AT_byte_size";
5774 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5775 case DW_AT_bit_size: return "DW_AT_bit_size";
5776 case DW_AT_element_list: return "DW_AT_element_list";
5777 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5778 case DW_AT_low_pc: return "DW_AT_low_pc";
5779 case DW_AT_high_pc: return "DW_AT_high_pc";
5780 case DW_AT_language: return "DW_AT_language";
5781 case DW_AT_member: return "DW_AT_member";
5782 case DW_AT_discr: return "DW_AT_discr";
5783 case DW_AT_discr_value: return "DW_AT_discr_value";
5784 case DW_AT_visibility: return "DW_AT_visibility";
5785 case DW_AT_import: return "DW_AT_import";
5786 case DW_AT_string_length: return "DW_AT_string_length";
5787 case DW_AT_common_reference: return "DW_AT_common_reference";
5788 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5789 case DW_AT_const_value: return "DW_AT_const_value";
5790 case DW_AT_containing_type: return "DW_AT_containing_type";
5791 case DW_AT_default_value: return "DW_AT_default_value";
5792 case DW_AT_inline: return "DW_AT_inline";
5793 case DW_AT_is_optional: return "DW_AT_is_optional";
5794 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5795 case DW_AT_producer: return "DW_AT_producer";
5796 case DW_AT_prototyped: return "DW_AT_prototyped";
5797 case DW_AT_return_addr: return "DW_AT_return_addr";
5798 case DW_AT_start_scope: return "DW_AT_start_scope";
5799 case DW_AT_stride_size: return "DW_AT_stride_size";
5800 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5801 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5802 case DW_AT_accessibility: return "DW_AT_accessibility";
5803 case DW_AT_address_class: return "DW_AT_address_class";
5804 case DW_AT_artificial: return "DW_AT_artificial";
5805 case DW_AT_base_types: return "DW_AT_base_types";
5806 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5807 case DW_AT_count: return "DW_AT_count";
5808 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5809 case DW_AT_decl_column: return "DW_AT_decl_column";
5810 case DW_AT_decl_file: return "DW_AT_decl_file";
5811 case DW_AT_decl_line: return "DW_AT_decl_line";
5812 case DW_AT_declaration: return "DW_AT_declaration";
5813 case DW_AT_discr_list: return "DW_AT_discr_list";
5814 case DW_AT_encoding: return "DW_AT_encoding";
5815 case DW_AT_external: return "DW_AT_external";
5816 case DW_AT_frame_base: return "DW_AT_frame_base";
5817 case DW_AT_friend: return "DW_AT_friend";
5818 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5819 case DW_AT_macro_info: return "DW_AT_macro_info";
5820 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5821 case DW_AT_priority: return "DW_AT_priority";
5822 case DW_AT_segment: return "DW_AT_segment";
5823 case DW_AT_specification: return "DW_AT_specification";
5824 case DW_AT_static_link: return "DW_AT_static_link";
5825 case DW_AT_type: return "DW_AT_type";
5826 case DW_AT_use_location: return "DW_AT_use_location";
5827 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5828 case DW_AT_virtuality: return "DW_AT_virtuality";
5829 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5830 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5831 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5832 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5833 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5834 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5835 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5836 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5837 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5838 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5839 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5840 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5841 case DW_AT_sf_names: return "DW_AT_sf_names";
5842 case DW_AT_src_info: return "DW_AT_src_info";
5843 case DW_AT_mac_info: return "DW_AT_mac_info";
5844 case DW_AT_src_coords: return "DW_AT_src_coords";
5845 case DW_AT_body_begin: return "DW_AT_body_begin";
5846 case DW_AT_body_end: return "DW_AT_body_end";
5849 static char buffer [100];
5851 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5858 get_FORM_name (form)
5863 case DW_FORM_addr: return "DW_FORM_addr";
5864 case DW_FORM_block2: return "DW_FORM_block2";
5865 case DW_FORM_block4: return "DW_FORM_block4";
5866 case DW_FORM_data2: return "DW_FORM_data2";
5867 case DW_FORM_data4: return "DW_FORM_data4";
5868 case DW_FORM_data8: return "DW_FORM_data8";
5869 case DW_FORM_string: return "DW_FORM_string";
5870 case DW_FORM_block: return "DW_FORM_block";
5871 case DW_FORM_block1: return "DW_FORM_block1";
5872 case DW_FORM_data1: return "DW_FORM_data1";
5873 case DW_FORM_flag: return "DW_FORM_flag";
5874 case DW_FORM_sdata: return "DW_FORM_sdata";
5875 case DW_FORM_strp: return "DW_FORM_strp";
5876 case DW_FORM_udata: return "DW_FORM_udata";
5877 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5878 case DW_FORM_ref1: return "DW_FORM_ref1";
5879 case DW_FORM_ref2: return "DW_FORM_ref2";
5880 case DW_FORM_ref4: return "DW_FORM_ref4";
5881 case DW_FORM_ref8: return "DW_FORM_ref8";
5882 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5883 case DW_FORM_indirect: return "DW_FORM_indirect";
5886 static char buffer [100];
5888 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5894 /* FIXME: There are better and more effiecint ways to handle
5895 these structures. For now though, I just want something that
5896 is simple to implement. */
5897 typedef struct abbrev_attr
5899 unsigned long attribute;
5901 struct abbrev_attr * next;
5905 typedef struct abbrev_entry
5907 unsigned long entry;
5910 struct abbrev_attr * first_attr;
5911 struct abbrev_attr * last_attr;
5912 struct abbrev_entry * next;
5916 static abbrev_entry * first_abbrev = NULL;
5917 static abbrev_entry * last_abbrev = NULL;
5920 free_abbrevs PARAMS ((void))
5922 abbrev_entry * abbrev;
5924 for (abbrev = first_abbrev; abbrev;)
5926 abbrev_entry * next = abbrev->next;
5929 for (attr = abbrev->first_attr; attr;)
5931 abbrev_attr * next = attr->next;
5941 last_abbrev = first_abbrev = NULL;
5945 add_abbrev (number, tag, children)
5946 unsigned long number;
5950 abbrev_entry * entry;
5952 entry = (abbrev_entry *) malloc (sizeof (* entry));
5958 entry->entry = number;
5960 entry->children = children;
5961 entry->first_attr = NULL;
5962 entry->last_attr = NULL;
5965 if (first_abbrev == NULL)
5966 first_abbrev = entry;
5968 last_abbrev->next = entry;
5970 last_abbrev = entry;
5974 add_abbrev_attr (attribute, form)
5975 unsigned long attribute;
5980 attr = (abbrev_attr *) malloc (sizeof (* attr));
5986 attr->attribute = attribute;
5990 if (last_abbrev->first_attr == NULL)
5991 last_abbrev->first_attr = attr;
5993 last_abbrev->last_attr->next = attr;
5995 last_abbrev->last_attr = attr;
5998 /* Processes the (partial) contents of a .debug_abbrev section.
5999 Returns NULL if the end of the section was encountered.
6000 Returns the address after the last byte read if the end of
6001 an abbreviation set was found. */
6003 static unsigned char *
6004 process_abbrev_section (start, end)
6005 unsigned char * start;
6006 unsigned char * end;
6008 if (first_abbrev != NULL)
6014 unsigned long entry;
6016 unsigned long attribute;
6019 entry = read_leb128 (start, & bytes_read, 0);
6020 start += bytes_read;
6022 /* A single zero is supposed to end the section according
6023 to the standard. If there's more, then signal that to
6026 return start == end ? NULL : start;
6028 tag = read_leb128 (start, & bytes_read, 0);
6029 start += bytes_read;
6031 children = * start ++;
6033 add_abbrev (entry, tag, children);
6039 attribute = read_leb128 (start, & bytes_read, 0);
6040 start += bytes_read;
6042 form = read_leb128 (start, & bytes_read, 0);
6043 start += bytes_read;
6046 add_abbrev_attr (attribute, form);
6048 while (attribute != 0);
6056 display_debug_abbrev (section, start, file)
6057 Elf32_Internal_Shdr * section;
6058 unsigned char * start;
6059 FILE * file ATTRIBUTE_UNUSED;
6061 abbrev_entry * entry;
6062 unsigned char * end = start + section->sh_size;
6064 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6068 start = process_abbrev_section (start, end);
6070 printf (_(" Number TAG\n"));
6072 for (entry = first_abbrev; entry; entry = entry->next)
6076 printf (_(" %ld %s [%s]\n"),
6078 get_TAG_name (entry->tag),
6079 entry->children ? _("has children") : _("no children"));
6081 for (attr = entry->first_attr; attr; attr = attr->next)
6083 printf (_(" %-18s %s\n"),
6084 get_AT_name (attr->attribute),
6085 get_FORM_name (attr->form));
6097 static unsigned char *
6098 display_block (data, length)
6099 unsigned char * data;
6100 unsigned long length;
6102 printf (_(" %lu byte block: "), length);
6105 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6111 decode_location_expression (data, pointer_size, length)
6112 unsigned char * data;
6113 unsigned int pointer_size;
6114 unsigned long length;
6118 unsigned long uvalue;
6119 unsigned char * end = data + length;
6128 printf ("DW_OP_addr: %lx",
6129 (unsigned long) byte_get (data, pointer_size));
6130 data += pointer_size;
6133 printf ("DW_OP_deref");
6136 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6139 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6142 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6146 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6150 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6154 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6158 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6159 (unsigned long) byte_get (data + 4, 4));
6163 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6164 (long) byte_get (data + 4, 4));
6168 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6172 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6176 printf ("DW_OP_dup");
6179 printf ("DW_OP_drop");
6182 printf ("DW_OP_over");
6185 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6188 printf ("DW_OP_swap");
6191 printf ("DW_OP_rot");
6194 printf ("DW_OP_xderef");
6197 printf ("DW_OP_abs");
6200 printf ("DW_OP_and");
6203 printf ("DW_OP_div");
6206 printf ("DW_OP_minus");
6209 printf ("DW_OP_mod");
6212 printf ("DW_OP_mul");
6215 printf ("DW_OP_neg");
6218 printf ("DW_OP_not");
6221 printf ("DW_OP_or");
6224 printf ("DW_OP_plus");
6226 case DW_OP_plus_uconst:
6227 printf ("DW_OP_plus_uconst: %lu",
6228 read_leb128 (data, &bytes_read, 0));
6232 printf ("DW_OP_shl");
6235 printf ("DW_OP_shr");
6238 printf ("DW_OP_shra");
6241 printf ("DW_OP_xor");
6244 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
6248 printf ("DW_OP_eq");
6251 printf ("DW_OP_ge");
6254 printf ("DW_OP_gt");
6257 printf ("DW_OP_le");
6260 printf ("DW_OP_lt");
6263 printf ("DW_OP_ne");
6266 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
6302 printf ("DW_OP_lit%d", op - DW_OP_lit0);
6337 printf ("DW_OP_reg%d", op - DW_OP_reg0);
6372 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
6373 read_leb128 (data, &bytes_read, 1));
6378 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6382 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6386 uvalue = read_leb128 (data, &bytes_read, 0);
6388 printf ("DW_OP_bregx: %lu %ld", uvalue,
6389 read_leb128 (data, &bytes_read, 1));
6393 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6396 case DW_OP_deref_size:
6397 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6399 case DW_OP_xderef_size:
6400 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6403 printf ("DW_OP_nop");
6407 if (op >= DW_OP_lo_user
6408 && op <= DW_OP_hi_user)
6409 printf (_("(User defined location op)"));
6411 printf (_("(Unknown location op)"));
6412 /* No way to tell where the next op is, so just bail. */
6419 static unsigned char *
6420 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6421 unsigned long attribute;
6423 unsigned char * data;
6424 unsigned long cu_offset;
6425 unsigned long pointer_size;
6427 unsigned long uvalue = 0;
6428 unsigned char * block_start = NULL;
6431 printf (" %-18s:", get_AT_name (attribute));
6438 case DW_FORM_ref_addr:
6440 uvalue = byte_get (data, pointer_size);
6441 data += pointer_size;
6447 uvalue = byte_get (data ++, 1);
6452 uvalue = byte_get (data, 2);
6458 uvalue = byte_get (data, 4);
6463 uvalue = read_leb128 (data, & bytes_read, 1);
6467 case DW_FORM_ref_udata:
6469 uvalue = read_leb128 (data, & bytes_read, 0);
6476 case DW_FORM_ref_addr:
6477 printf (" <#%lx>", uvalue);
6483 case DW_FORM_ref_udata:
6484 printf (" <%lx>", uvalue + cu_offset);
6488 printf (" %#lx", uvalue);
6496 printf (" %ld", uvalue);
6501 uvalue = byte_get (data, 4);
6502 printf (" %lx", uvalue);
6503 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6507 case DW_FORM_string:
6508 printf (" %s", data);
6509 data += strlen ((char *) data) + 1;
6513 uvalue = read_leb128 (data, & bytes_read, 0);
6514 block_start = data + bytes_read;
6515 data = display_block (block_start, uvalue);
6518 case DW_FORM_block1:
6519 uvalue = byte_get (data, 1);
6520 block_start = data + 1;
6521 data = display_block (block_start, uvalue);
6524 case DW_FORM_block2:
6525 uvalue = byte_get (data, 2);
6526 block_start = data + 2;
6527 data = display_block (block_start, uvalue);
6530 case DW_FORM_block4:
6531 uvalue = byte_get (data, 4);
6532 block_start = data + 4;
6533 data = display_block (block_start, uvalue);
6537 case DW_FORM_indirect:
6538 warn (_("Unable to handle FORM: %d"), form);
6542 warn (_("Unrecognised form: %d"), form);
6546 /* For some attributes we can display futher information. */
6555 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6556 case DW_INL_inlined: printf (_("(inlined)")); break;
6557 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6558 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6559 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6563 case DW_AT_language:
6566 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6567 case DW_LANG_C89: printf ("(ANSI C)"); break;
6568 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6569 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6570 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6571 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6572 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6573 case DW_LANG_Ada83: printf ("(Ada)"); break;
6574 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6575 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6576 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6577 default: printf ("(Unknown: %lx)", uvalue); break;
6581 case DW_AT_encoding:
6584 case DW_ATE_void: printf ("(void)"); break;
6585 case DW_ATE_address: printf ("(machine address)"); break;
6586 case DW_ATE_boolean: printf ("(boolean)"); break;
6587 case DW_ATE_complex_float: printf ("(complex float)"); break;
6588 case DW_ATE_float: printf ("(float)"); break;
6589 case DW_ATE_signed: printf ("(signed)"); break;
6590 case DW_ATE_signed_char: printf ("(signed char)"); break;
6591 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6592 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6594 if (uvalue >= DW_ATE_lo_user
6595 && uvalue <= DW_ATE_hi_user)
6596 printf ("(user defined type)");
6598 printf ("(unknown type)");
6603 case DW_AT_accessibility:
6606 case DW_ACCESS_public: printf ("(public)"); break;
6607 case DW_ACCESS_protected: printf ("(protected)"); break;
6608 case DW_ACCESS_private: printf ("(private)"); break;
6609 default: printf ("(unknown accessibility)"); break;
6613 case DW_AT_visibility:
6616 case DW_VIS_local: printf ("(local)"); break;
6617 case DW_VIS_exported: printf ("(exported)"); break;
6618 case DW_VIS_qualified: printf ("(qualified)"); break;
6619 default: printf ("(unknown visibility)"); break;
6623 case DW_AT_virtuality:
6626 case DW_VIRTUALITY_none: printf ("(none)"); break;
6627 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6628 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6629 default: printf ("(unknown virtuality)"); break;
6633 case DW_AT_identifier_case:
6636 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6637 case DW_ID_up_case: printf ("(up_case)"); break;
6638 case DW_ID_down_case: printf ("(down_case)"); break;
6639 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6640 default: printf ("(unknown case)"); break;
6644 case DW_AT_calling_convention:
6647 case DW_CC_normal: printf ("(normal)"); break;
6648 case DW_CC_program: printf ("(program)"); break;
6649 case DW_CC_nocall: printf ("(nocall)"); break;
6651 if (uvalue >= DW_CC_lo_user
6652 && uvalue <= DW_CC_hi_user)
6653 printf ("(user defined)");
6655 printf ("(unknown convention)");
6659 case DW_AT_frame_base:
6660 case DW_AT_location:
6661 case DW_AT_data_member_location:
6662 case DW_AT_vtable_elem_location:
6666 decode_location_expression (block_start, pointer_size, uvalue);
6680 display_debug_info (section, start, file)
6681 Elf32_Internal_Shdr * section;
6682 unsigned char * start;
6685 unsigned char * end = start + section->sh_size;
6686 unsigned char * section_begin = start;
6688 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6692 DWARF2_External_CompUnit * external;
6693 DWARF2_Internal_CompUnit compunit;
6694 unsigned char * tags;
6697 unsigned long cu_offset;
6699 external = (DWARF2_External_CompUnit *) start;
6701 compunit.cu_length = BYTE_GET (external->cu_length);
6702 compunit.cu_version = BYTE_GET (external->cu_version);
6703 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6704 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6706 tags = start + sizeof (* external);
6707 cu_offset = start - section_begin;
6708 start += compunit.cu_length + sizeof (external->cu_length);
6710 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
6711 printf (_(" Length: %ld\n"), compunit.cu_length);
6712 printf (_(" Version: %d\n"), compunit.cu_version);
6713 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6714 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6716 if (compunit.cu_version != 2)
6718 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6722 if (first_abbrev != NULL)
6725 /* Read in the abbrevs used by this compilation unit. */
6728 Elf32_Internal_Shdr * sec;
6729 unsigned char * begin;
6731 /* Locate the .debug_abbrev section and process it. */
6732 for (i = 0, sec = section_headers;
6733 i < elf_header.e_shnum;
6735 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6738 if (i == -1 || sec->sh_size == 0)
6740 warn (_("Unable to locate .debug_abbrev section!\n"));
6744 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6745 "debug_abbrev section data");
6747 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6748 begin + sec->sh_size);
6754 while (tags < start)
6757 unsigned long abbrev_number;
6758 abbrev_entry * entry;
6761 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6764 /* A null DIE marks the end of a list of children. */
6765 if (abbrev_number == 0)
6771 /* Scan through the abbreviation list until we reach the
6773 for (entry = first_abbrev;
6774 entry && entry->entry != abbrev_number;
6775 entry = entry->next)
6780 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6785 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6786 level, tags - section_begin - bytes_read,
6788 get_TAG_name (entry->tag));
6790 for (attr = entry->first_attr; attr; attr = attr->next)
6791 tags = read_and_display_attr (attr->attribute,
6794 compunit.cu_pointer_size);
6796 if (entry->children)
6807 display_debug_aranges (section, start, file)
6808 Elf32_Internal_Shdr * section;
6809 unsigned char * start;
6810 FILE * file ATTRIBUTE_UNUSED;
6812 unsigned char * end = start + section->sh_size;
6814 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6818 DWARF2_External_ARange * external;
6819 DWARF2_Internal_ARange arange;
6820 unsigned char * ranges;
6821 unsigned long length;
6822 unsigned long address;
6825 external = (DWARF2_External_ARange *) start;
6827 arange.ar_length = BYTE_GET (external->ar_length);
6828 arange.ar_version = BYTE_GET (external->ar_version);
6829 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6830 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6831 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6833 if (arange.ar_version != 2)
6835 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6839 printf (_(" Length: %ld\n"), arange.ar_length);
6840 printf (_(" Version: %d\n"), arange.ar_version);
6841 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6842 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6843 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6845 printf (_("\n Address Length\n"));
6847 ranges = start + sizeof (* external);
6849 /* Must pad to an alignment boundary that is twice the pointer size. */
6850 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
6852 ranges += (2 * arange.ar_pointer_size) - excess;
6856 address = byte_get (ranges, arange.ar_pointer_size);
6858 ranges += arange.ar_pointer_size;
6860 length = byte_get (ranges, arange.ar_pointer_size);
6862 ranges += arange.ar_pointer_size;
6864 /* A pair of zeros marks the end of the list. */
6865 if (address == 0 && length == 0)
6868 printf (" %8.8lx %lu\n", address, length);
6871 start += arange.ar_length + sizeof (external->ar_length);
6879 typedef struct Frame_Chunk
6881 struct Frame_Chunk * next;
6882 unsigned char * chunk_start;
6884 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6885 short int * col_type;
6887 char * augmentation;
6888 unsigned int code_factor;
6889 unsigned int data_factor;
6890 unsigned long pc_begin;
6891 unsigned long pc_range;
6898 /* A marker for a col_type that means this column was never referenced
6899 in the frame info. */
6900 #define DW_CFA_unreferenced (-1)
6903 frame_need_space (fc, reg)
6907 int prev = fc->ncols;
6909 if (reg < fc->ncols)
6912 fc->ncols = reg + 1;
6913 fc->col_type = (short int *) xrealloc (fc->col_type,
6914 fc->ncols * sizeof (short int));
6915 fc->col_offset = (int *) xrealloc (fc->col_offset,
6916 fc->ncols * sizeof (int));
6918 while (prev < fc->ncols)
6920 fc->col_type[prev] = DW_CFA_unreferenced;
6921 fc->col_offset[prev] = 0;
6927 frame_display_row (fc, need_col_headers, max_regs)
6929 int * need_col_headers;
6935 if (* max_regs < fc->ncols)
6936 * max_regs = fc->ncols;
6938 if (* need_col_headers)
6940 * need_col_headers = 0;
6942 printf (" LOC CFA ");
6944 for (r = 0; r < * max_regs; r++)
6945 if (fc->col_type[r] != DW_CFA_unreferenced)
6950 printf ("r%-4d", r);
6956 printf ("%08x ", (unsigned int) fc->pc_begin);
6957 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
6958 printf ("%-8s ", tmp);
6960 for (r = 0; r < fc->ncols; r++)
6962 if (fc->col_type[r] != DW_CFA_unreferenced)
6964 switch (fc->col_type[r])
6966 case DW_CFA_undefined:
6969 case DW_CFA_same_value:
6973 sprintf (tmp, "c%+d", fc->col_offset[r]);
6975 case DW_CFA_register:
6976 sprintf (tmp, "r%d", fc->col_offset[r]);
6979 strcpy (tmp, "n/a");
6982 printf ("%-5s", tmp);
6988 #define GET(N) byte_get (start, N); start += N
6989 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
6990 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
6993 display_debug_frames (section, start, file)
6994 Elf32_Internal_Shdr * section;
6995 unsigned char * start;
6996 FILE * file ATTRIBUTE_UNUSED;
6998 unsigned char * end = start + section->sh_size;
6999 unsigned char * section_start = start;
7000 Frame_Chunk * chunks = 0;
7001 Frame_Chunk * remembered_state = 0;
7003 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
7007 printf (_("The section %s contains:\n"), SECTION_NAME (section));
7011 unsigned char * saved_start;
7012 unsigned char * block_end;
7013 unsigned long length;
7014 unsigned long cie_id;
7017 int need_col_headers = 1;
7019 saved_start = start;
7020 length = byte_get (start, 4); start += 4;
7025 block_end = saved_start + length + 4;
7026 cie_id = byte_get (start, 4); start += 4;
7028 printf ("\n%08x %08lx %08lx ", saved_start - section_start, length, cie_id);
7030 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
7032 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7033 memset (fc, 0, sizeof (Frame_Chunk));
7037 fc->chunk_start = saved_start;
7039 fc->col_type = (short int *) xmalloc (sizeof (short int));
7040 fc->col_offset = (int *) xmalloc (sizeof (int));
7041 frame_need_space (fc, max_regs-1);
7043 start ++; /* version */
7044 fc->augmentation = start;
7049 start++; /* skip past NUL */
7051 if (fc->augmentation[0] == 'z')
7054 fc->code_factor = LEB ();
7055 fc->data_factor = SLEB ();
7056 fc->ra = byte_get (start, 1); start += 1;
7058 printf ("skipping %d extra bytes\n", xtra);
7061 else if (strcmp (fc->augmentation, "eh") == 0)
7064 fc->code_factor = LEB ();
7065 fc->data_factor = SLEB ();
7066 fc->ra = byte_get (start, 1); start += 1;
7070 fc->code_factor = LEB ();
7071 fc->data_factor = SLEB ();
7072 fc->ra = byte_get (start, 1); start += 1;
7075 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n",
7076 fc->augmentation, fc->code_factor, fc->data_factor, fc->ra);
7078 frame_need_space (fc, fc->ra);
7082 unsigned char * look_for;
7083 static Frame_Chunk fde_fc;
7086 memset (fc, 0, sizeof (Frame_Chunk));
7088 look_for = is_eh ? start-4-cie_id : (unsigned char *) cie_id;
7090 fc->pc_begin = byte_get (start, 4); start += 4;
7091 fc->pc_range = byte_get (start, 4); start += 4;
7093 for (cie=chunks; cie && (cie->chunk_start != look_for); cie = cie->next);
7096 warn ("Invalid CIE pointer %08x in FDE at %08x\n", cie_id, saved_start);
7099 fc->col_type = (short int *) xmalloc (sizeof (short int));
7100 fc->col_offset = (int *) xmalloc (sizeof (int));
7101 frame_need_space (fc, max_regs - 1);
7103 fc->augmentation = "";
7107 fc->ncols = cie->ncols;
7108 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
7109 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
7110 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7111 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7112 fc->augmentation = cie->augmentation;
7113 fc->code_factor = cie->code_factor;
7114 fc->data_factor = cie->data_factor;
7115 fc->cfa_reg = cie->cfa_reg;
7116 fc->cfa_offset = cie->cfa_offset;
7118 frame_need_space (fc, max_regs-1);
7121 if (cie->augmentation[0] == 'z')
7123 unsigned long l = LEB ();
7127 printf ("FDE cie=%08x pc=%08lx..%08lx\n",
7128 cie->chunk_start-section_start, fc->pc_begin,
7129 fc->pc_begin + fc->pc_range);
7132 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7133 about to interpret instructions for the chunk. */
7135 /* This exists for readelf maintainers. */
7139 /* Start by making a pass over the chunk, allocating storage
7140 and taking note of what registers are used. */
7141 unsigned char * tmp = start;
7143 while (start < block_end)
7154 /* Warning: if you add any more cases to this switch, be
7155 sure to add them to the corresponding switch below. */
7158 case DW_CFA_advance_loc:
7162 frame_need_space (fc, opa);
7163 fc->col_type[opa] = DW_CFA_undefined;
7165 case DW_CFA_restore:
7166 frame_need_space (fc, opa);
7167 fc->col_type[opa] = DW_CFA_undefined;
7169 case DW_CFA_set_loc:
7170 start += sizeof (vma);
7172 case DW_CFA_advance_loc1:
7175 case DW_CFA_advance_loc2:
7178 case DW_CFA_advance_loc4:
7181 case DW_CFA_offset_extended:
7182 reg = LEB (); LEB ();
7183 frame_need_space (fc, reg);
7184 fc->col_type[reg] = DW_CFA_undefined;
7186 case DW_CFA_restore_extended:
7188 frame_need_space (fc, reg);
7189 fc->col_type[reg] = DW_CFA_undefined;
7191 case DW_CFA_undefined:
7193 frame_need_space (fc, reg);
7194 fc->col_type[reg] = DW_CFA_undefined;
7196 case DW_CFA_same_value:
7198 frame_need_space (fc, reg);
7199 fc->col_type[reg] = DW_CFA_undefined;
7201 case DW_CFA_register:
7202 reg = LEB (); LEB ();
7203 frame_need_space (fc, reg);
7204 fc->col_type[reg] = DW_CFA_undefined;
7206 case DW_CFA_def_cfa:
7209 case DW_CFA_def_cfa_register:
7212 case DW_CFA_def_cfa_offset:
7215 #ifndef DW_CFA_GNU_args_size
7216 #define DW_CFA_GNU_args_size 0x2e
7218 case DW_CFA_GNU_args_size:
7221 #ifndef DW_CFA_GNU_negative_offset_extended
7222 #define DW_CFA_GNU_negative_offset_extended 0x2f
7224 case DW_CFA_GNU_negative_offset_extended:
7225 reg = LEB (); LEB ();
7226 frame_need_space (fc, reg);
7227 fc->col_type[reg] = DW_CFA_undefined;
7236 /* Now we know what registers are used, make a second pass over
7237 the chunk, this time actually printing out the info. */
7239 while (start < block_end)
7242 unsigned long ul, reg, roffs;
7251 /* Warning: if you add any more cases to this switch, be
7252 sure to add them to the corresponding switch above. */
7255 case DW_CFA_advance_loc:
7256 frame_display_row (fc, &need_col_headers, &max_regs);
7258 printf (" DW_CFA_advance_loc: %08x = %08x + %d*%d\n",
7259 fc->pc_begin + opa * fc->code_factor, fc->pc_begin, opa, fc->code_factor);
7261 fc->pc_begin += opa * fc->code_factor;
7267 printf (" DW_CFA_offset: r%d = cfa[%d*%d]\n", opa, roffs, fc->data_factor);
7269 fc->col_type[opa] = DW_CFA_offset;
7270 fc->col_offset[opa] = roffs * fc->data_factor;
7273 case DW_CFA_restore:
7275 printf (" DW_CFA_restore: r%d\n", opa);
7277 fc->col_type[opa] = cie->col_type[opa];
7278 fc->col_offset[opa] = cie->col_offset[opa];
7281 case DW_CFA_set_loc:
7282 frame_display_row (fc, &need_col_headers, &max_regs);
7283 vma = byte_get (start, sizeof (vma)); start += sizeof (vma);
7285 printf (" DW_CFA_set_loc: %08x\n", vma);
7290 case DW_CFA_advance_loc1:
7291 frame_display_row (fc, &need_col_headers, &max_regs);
7292 ofs = byte_get (start, 1); start += 1;
7294 printf (" DW_CFA_advance_loc1: %08x = %08x + %d*%d\n",
7295 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7297 fc->pc_begin += ofs * fc->code_factor;
7300 case DW_CFA_advance_loc2:
7301 frame_display_row (fc, &need_col_headers, &max_regs);
7302 ofs = byte_get (start, 2); start += 2;
7304 printf (" DW_CFA_advance_loc2: %08x = %08x + %d*%d\n",
7305 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7307 fc->pc_begin += ofs * fc->code_factor;
7310 case DW_CFA_advance_loc4:
7311 frame_display_row (fc, &need_col_headers, &max_regs);
7312 ofs = byte_get (start, 4); start += 4;
7314 printf (" DW_CFA_advance_loc4: %08x = %08x + %d*%d\n",
7315 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7317 fc->pc_begin += ofs * fc->code_factor;
7320 case DW_CFA_offset_extended:
7324 printf (" DW_CFA_offset_extended: r%d = cfa[%d*%d]\n", reg, roffs, fc->data_factor);
7326 fc->col_type[reg] = DW_CFA_offset;
7327 fc->col_offset[reg] = roffs * fc->data_factor;
7330 case DW_CFA_restore_extended:
7333 printf (" DW_CFA_restore_extended: r%d\n", reg);
7335 fc->col_type[reg] = cie->col_type[reg];
7336 fc->col_offset[reg] = cie->col_offset[reg];
7339 case DW_CFA_undefined:
7342 printf (" DW_CFA_undefined: r%d\n", reg);
7344 fc->col_type[reg] = DW_CFA_undefined;
7345 fc->col_offset[reg] = 0;
7348 case DW_CFA_same_value:
7351 printf (" DW_CFA_same_value: r%d\n", reg);
7353 fc->col_type[reg] = DW_CFA_same_value;
7354 fc->col_offset[reg] = 0;
7357 case DW_CFA_register:
7361 printf (" DW_CFA_register: r%d\n", reg);
7363 fc->col_type[reg] = DW_CFA_register;
7364 fc->col_offset[reg] = roffs;
7367 case DW_CFA_remember_state:
7369 printf (" DW_CFA_remember_state\n");
7371 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7372 rs->ncols = fc->ncols;
7373 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
7374 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
7375 memcpy (rs->col_type, fc->col_type, rs->ncols);
7376 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
7377 rs->next = remembered_state;
7378 remembered_state = rs;
7381 case DW_CFA_restore_state:
7383 printf (" DW_CFA_restore_state\n");
7385 rs = remembered_state;
7386 remembered_state = rs->next;
7387 frame_need_space (fc, rs->ncols-1);
7388 memcpy (fc->col_type, rs->col_type, rs->ncols);
7389 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
7390 free (rs->col_type);
7391 free (rs->col_offset);
7395 case DW_CFA_def_cfa:
7396 fc->cfa_reg = LEB ();
7397 fc->cfa_offset = LEB ();
7399 printf (" DW_CFA_def_cfa: reg %d ofs %d\n", fc->cfa_reg, fc->cfa_offset);
7403 case DW_CFA_def_cfa_register:
7404 fc->cfa_reg = LEB ();
7406 printf (" DW_CFA_def_cfa_reg: %d\n", fc->cfa_reg);
7410 case DW_CFA_def_cfa_offset:
7411 fc->cfa_offset = LEB ();
7413 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
7419 printf (" DW_CFA_nop\n");
7423 #ifndef DW_CFA_GNU_window_save
7424 #define DW_CFA_GNU_window_save 0x2d
7426 case DW_CFA_GNU_window_save:
7428 printf (" DW_CFA_GNU_window_save\n");
7432 #ifndef DW_CFA_GNU_args_size
7433 #define DW_CFA_GNU_args_size 0x2e
7435 case DW_CFA_GNU_args_size:
7438 printf (" DW_CFA_GNU_args_size: %d\n", ul);
7442 #ifndef DW_CFA_GNU_negative_offset_extended
7443 #define DW_CFA_GNU_negative_offset_extended 0x2f
7445 case DW_CFA_GNU_negative_offset_extended:
7448 frame_need_space (fc, reg);
7450 printf (" DW_CFA_GNU_negative_offset_extended: r%d = cfa[%d*%d]\n", reg, l, fc->data_factor);
7452 fc->col_type[reg] = DW_CFA_offset;
7453 fc->col_offset[reg] = l * fc->data_factor;
7457 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
7462 frame_display_row (fc, &need_col_headers, &max_regs);
7477 display_debug_not_supported (section, start, file)
7478 Elf32_Internal_Shdr * section;
7479 unsigned char * start ATTRIBUTE_UNUSED;
7480 FILE * file ATTRIBUTE_UNUSED;
7482 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7483 SECTION_NAME (section));
7488 /* Pre-scan the .debug_info section to record the size of address.
7489 When dumping the .debug_line, we use that size information, assuming
7490 that all compilation units have the same address size. */
7492 prescan_debug_info (section, start, file)
7493 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
7494 unsigned char * start;
7495 FILE * file ATTRIBUTE_UNUSED;
7497 DWARF2_External_CompUnit * external;
7499 external = (DWARF2_External_CompUnit *) start;
7501 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
7505 /* A structure containing the name of a debug section and a pointer
7506 to a function that can decode it. The third field is a prescan
7507 function to be run over the section before displaying any of the
7512 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7513 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7517 { ".debug_info", display_debug_info, prescan_debug_info },
7518 { ".debug_abbrev", display_debug_abbrev, NULL },
7519 { ".debug_line", display_debug_lines, NULL },
7520 { ".debug_aranges", display_debug_aranges, NULL },
7521 { ".debug_pubnames", display_debug_pubnames, NULL },
7522 { ".debug_frame", display_debug_frames, NULL },
7523 { ".eh_frame", display_debug_frames, NULL },
7524 { ".debug_macinfo", display_debug_not_supported, NULL },
7525 { ".debug_frame", display_debug_not_supported, NULL },
7526 { ".debug_str", display_debug_not_supported, NULL },
7527 { ".debug_static_func", display_debug_not_supported, NULL },
7528 { ".debug_static_vars", display_debug_not_supported, NULL },
7529 { ".debug_types", display_debug_not_supported, NULL },
7530 { ".debug_weaknames", display_debug_not_supported, NULL }
7534 display_debug_section (section, file)
7535 Elf32_Internal_Shdr * section;
7538 char * name = SECTION_NAME (section);
7539 bfd_size_type length;
7540 unsigned char * start;
7543 length = section->sh_size;
7546 printf (_("\nSection '%s' has no debugging data.\n"), name);
7550 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7551 "debug section data");
7553 /* See if we know how to display the contents of this section. */
7554 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
7555 name = ".debug_info";
7557 for (i = NUM_ELEM (debug_displays); i--;)
7558 if (strcmp (debug_displays[i].name, name) == 0)
7560 debug_displays[i].display (section, start, file);
7565 printf (_("Unrecognised debug section: %s\n"), name);
7569 /* If we loaded in the abbrev section at some point,
7570 we must release it here. */
7571 if (first_abbrev != NULL)
7578 process_section_contents (file)
7581 Elf32_Internal_Shdr * section;
7587 /* Pre-scan the debug sections to find some debug information not
7588 present in some of them. For the .debug_line, we must find out the
7589 size of address (specified in .debug_info and .debug_aranges). */
7590 for (i = 0, section = section_headers;
7591 i < elf_header.e_shnum && i < num_dump_sects;
7594 char * name = SECTION_NAME (section);
7597 if (section->sh_size == 0)
7600 /* See if there is some pre-scan operation for this section. */
7601 for (j = NUM_ELEM (debug_displays); j--;)
7602 if (strcmp (debug_displays[j].name, name) == 0)
7604 if (debug_displays[j].prescan != NULL)
7606 bfd_size_type length;
7607 unsigned char * start;
7609 length = section->sh_size;
7610 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7611 "debug section data");
7613 debug_displays[j].prescan (section, start, file);
7621 for (i = 0, section = section_headers;
7622 i < elf_header.e_shnum && i < num_dump_sects;
7625 #ifdef SUPPORT_DISASSEMBLY
7626 if (dump_sects[i] & DISASS_DUMP)
7627 disassemble_section (section, file);
7629 if (dump_sects[i] & HEX_DUMP)
7630 dump_section (section, file);
7632 if (dump_sects[i] & DEBUG_DUMP)
7633 display_debug_section (section, file);
7636 if (i < num_dump_sects)
7637 warn (_("Some sections were not dumped because they do not exist!\n"));
7643 process_mips_fpe_exception (mask)
7649 if (mask & OEX_FPU_INEX)
7650 fputs ("INEX", stdout), first = 0;
7651 if (mask & OEX_FPU_UFLO)
7652 printf ("%sUFLO", first ? "" : "|"), first = 0;
7653 if (mask & OEX_FPU_OFLO)
7654 printf ("%sOFLO", first ? "" : "|"), first = 0;
7655 if (mask & OEX_FPU_DIV0)
7656 printf ("%sDIV0", first ? "" : "|"), first = 0;
7657 if (mask & OEX_FPU_INVAL)
7658 printf ("%sINVAL", first ? "" : "|");
7661 fputs ("0", stdout);
7665 process_mips_specific (file)
7668 Elf_Internal_Dyn * entry;
7669 size_t liblist_offset = 0;
7670 size_t liblistno = 0;
7671 size_t conflictsno = 0;
7672 size_t options_offset = 0;
7673 size_t conflicts_offset = 0;
7675 /* We have a lot of special sections. Thanks SGI! */
7676 if (dynamic_segment == NULL)
7677 /* No information available. */
7680 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
7681 switch (entry->d_tag)
7683 case DT_MIPS_LIBLIST:
7684 liblist_offset = entry->d_un.d_val - loadaddr;
7686 case DT_MIPS_LIBLISTNO:
7687 liblistno = entry->d_un.d_val;
7689 case DT_MIPS_OPTIONS:
7690 options_offset = entry->d_un.d_val - loadaddr;
7692 case DT_MIPS_CONFLICT:
7693 conflicts_offset = entry->d_un.d_val - loadaddr;
7695 case DT_MIPS_CONFLICTNO:
7696 conflictsno = entry->d_un.d_val;
7702 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
7704 Elf32_External_Lib * elib;
7707 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
7708 elib, Elf32_External_Lib *, "liblist");
7710 printf ("\nSection '.liblist' contains %lu entries:\n",
7711 (unsigned long) liblistno);
7712 fputs (" Library Time Stamp Checksum Version Flags\n",
7715 for (cnt = 0; cnt < liblistno; ++cnt)
7722 liblist.l_name = BYTE_GET (elib[cnt].l_name);
7723 time = BYTE_GET (elib[cnt].l_time_stamp);
7724 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
7725 liblist.l_version = BYTE_GET (elib[cnt].l_version);
7726 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
7728 tmp = gmtime (&time);
7729 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
7730 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7731 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7733 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
7734 dynamic_strings + liblist.l_name, timebuf,
7735 liblist.l_checksum, liblist.l_version);
7737 if (liblist.l_flags == 0)
7748 { " EXACT_MATCH", LL_EXACT_MATCH },
7749 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
7750 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
7751 { " EXPORTS", LL_EXPORTS },
7752 { " DELAY_LOAD", LL_DELAY_LOAD },
7753 { " DELTA", LL_DELTA }
7755 int flags = liblist.l_flags;
7759 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
7761 if ((flags & l_flags_vals[fcnt].bit) != 0)
7763 fputs (l_flags_vals[fcnt].name, stdout);
7764 flags ^= l_flags_vals[fcnt].bit;
7767 printf (" %#x", (unsigned int) flags);
7776 if (options_offset != 0)
7778 Elf_External_Options * eopt;
7779 Elf_Internal_Shdr * sect = section_headers;
7780 Elf_Internal_Options * iopt;
7781 Elf_Internal_Options * option;
7785 /* Find the section header so that we get the size. */
7786 while (sect->sh_type != SHT_MIPS_OPTIONS)
7789 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
7790 Elf_External_Options *, "options");
7792 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
7796 error (_("Out of memory"));
7803 while (offset < sect->sh_size)
7805 Elf_External_Options * eoption;
7807 eoption = (Elf_External_Options *) ((char *) eopt + offset);
7809 option->kind = BYTE_GET (eoption->kind);
7810 option->size = BYTE_GET (eoption->size);
7811 option->section = BYTE_GET (eoption->section);
7812 option->info = BYTE_GET (eoption->info);
7814 offset += option->size;
7820 printf (_("\nSection '%s' contains %d entries:\n"),
7821 SECTION_NAME (sect), cnt);
7829 switch (option->kind)
7832 /* This shouldn't happen. */
7833 printf (" NULL %d %lx", option->section, option->info);
7836 printf (" REGINFO ");
7837 if (elf_header.e_machine == EM_MIPS)
7840 Elf32_External_RegInfo * ereg;
7841 Elf32_RegInfo reginfo;
7843 ereg = (Elf32_External_RegInfo *) (option + 1);
7844 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7845 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7846 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7847 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7848 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7849 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
7851 printf ("GPR %08lx GP 0x%lx\n",
7853 (unsigned long) reginfo.ri_gp_value);
7854 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7855 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7856 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7861 Elf64_External_RegInfo * ereg;
7862 Elf64_Internal_RegInfo reginfo;
7864 ereg = (Elf64_External_RegInfo *) (option + 1);
7865 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7866 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7867 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7868 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7869 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7870 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
7872 printf ("GPR %08lx GP 0x",
7873 reginfo.ri_gprmask);
7874 printf_vma (reginfo.ri_gp_value);
7877 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7878 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7879 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7883 case ODK_EXCEPTIONS:
7884 fputs (" EXCEPTIONS fpe_min(", stdout);
7885 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
7886 fputs (") fpe_max(", stdout);
7887 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
7888 fputs (")", stdout);
7890 if (option->info & OEX_PAGE0)
7891 fputs (" PAGE0", stdout);
7892 if (option->info & OEX_SMM)
7893 fputs (" SMM", stdout);
7894 if (option->info & OEX_FPDBUG)
7895 fputs (" FPDBUG", stdout);
7896 if (option->info & OEX_DISMISS)
7897 fputs (" DISMISS", stdout);
7900 fputs (" PAD ", stdout);
7901 if (option->info & OPAD_PREFIX)
7902 fputs (" PREFIX", stdout);
7903 if (option->info & OPAD_POSTFIX)
7904 fputs (" POSTFIX", stdout);
7905 if (option->info & OPAD_SYMBOL)
7906 fputs (" SYMBOL", stdout);
7909 fputs (" HWPATCH ", stdout);
7910 if (option->info & OHW_R4KEOP)
7911 fputs (" R4KEOP", stdout);
7912 if (option->info & OHW_R8KPFETCH)
7913 fputs (" R8KPFETCH", stdout);
7914 if (option->info & OHW_R5KEOP)
7915 fputs (" R5KEOP", stdout);
7916 if (option->info & OHW_R5KCVTL)
7917 fputs (" R5KCVTL", stdout);
7920 fputs (" FILL ", stdout);
7921 /* XXX Print content of info word? */
7924 fputs (" TAGS ", stdout);
7925 /* XXX Print content of info word? */
7928 fputs (" HWAND ", stdout);
7929 if (option->info & OHWA0_R4KEOP_CHECKED)
7930 fputs (" R4KEOP_CHECKED", stdout);
7931 if (option->info & OHWA0_R4KEOP_CLEAN)
7932 fputs (" R4KEOP_CLEAN", stdout);
7935 fputs (" HWOR ", stdout);
7936 if (option->info & OHWA0_R4KEOP_CHECKED)
7937 fputs (" R4KEOP_CHECKED", stdout);
7938 if (option->info & OHWA0_R4KEOP_CLEAN)
7939 fputs (" R4KEOP_CLEAN", stdout);
7942 printf (" GP_GROUP %#06lx self-contained %#06lx",
7943 option->info & OGP_GROUP,
7944 (option->info & OGP_SELF) >> 16);
7947 printf (" IDENT %#06lx self-contained %#06lx",
7948 option->info & OGP_GROUP,
7949 (option->info & OGP_SELF) >> 16);
7952 /* This shouldn't happen. */
7953 printf (" %3d ??? %d %lx",
7954 option->kind, option->section, option->info);
7958 len = sizeof (* eopt);
7959 while (len < option->size)
7960 if (((char *) option)[len] >= ' '
7961 && ((char *) option)[len] < 0x7f)
7962 printf ("%c", ((char *) option)[len++]);
7964 printf ("\\%03o", ((char *) option)[len++]);
7966 fputs ("\n", stdout);
7973 if (conflicts_offset != 0 && conflictsno != 0)
7975 Elf32_External_Conflict * econf32;
7976 Elf64_External_Conflict * econf64;
7977 Elf32_Conflict * iconf;
7980 if (dynamic_symbols == NULL)
7982 error (_("conflict list with without table"));
7986 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
7989 error (_("Out of memory"));
7995 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf32),
7996 econf32, Elf32_External_Conflict *, "conflict");
7998 for (cnt = 0; cnt < conflictsno; ++cnt)
7999 iconf[cnt] = BYTE_GET (econf32[cnt]);
8003 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf64),
8004 econf64, Elf64_External_Conflict *, "conflict");
8006 for (cnt = 0; cnt < conflictsno; ++cnt)
8007 iconf[cnt] = BYTE_GET (econf64[cnt]);
8010 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
8011 puts (_(" Num: Index Value Name"));
8013 for (cnt = 0; cnt < conflictsno; ++cnt)
8015 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
8017 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
8018 print_vma (psym->st_value, FULL_HEX);
8019 printf (" %s\n", dynamic_strings + psym->st_name);
8029 get_note_type (e_type)
8032 static char buff[64];
8036 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
8037 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
8038 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
8039 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
8040 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
8041 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
8042 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
8043 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
8044 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8045 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8046 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8048 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
8053 /* Note that by the ELF standard, the name field is already null byte
8054 terminated, and namesz includes the terminating null byte.
8055 I.E. the value of namesz for the name "FSF" is 4.
8057 If the value of namesz is zero, there is no name present. */
8059 process_note (pnote)
8060 Elf32_Internal_Note * pnote;
8062 printf (" %s\t\t0x%08lx\t%s\n",
8063 pnote->namesz ? pnote->namedata : "(NONE)",
8064 pnote->descsz, get_note_type (pnote->type));
8070 process_corefile_note_segment (file, offset, length)
8075 Elf_External_Note * pnotes;
8076 Elf_External_Note * external;
8082 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
8086 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8087 (unsigned long) offset, (unsigned long) length);
8088 printf (_(" Owner\t\tData size\tDescription\n"));
8090 while (external < (Elf_External_Note *)((char *) pnotes + length))
8092 Elf32_Internal_Note inote;
8095 inote.type = BYTE_GET (external->type);
8096 inote.namesz = BYTE_GET (external->namesz);
8097 inote.namedata = external->name;
8098 inote.descsz = BYTE_GET (external->descsz);
8099 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8100 inote.descpos = offset + (inote.descdata - (char *) pnotes);
8102 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8104 /* Verify that name is null terminated. It appears that at least
8105 one version of Linux (RedHat 6.0) generates corefiles that don't
8106 comply with the ELF spec by failing to include the null byte in
8108 if (inote.namedata[inote.namesz] != '\0')
8110 temp = malloc (inote.namesz + 1);
8114 error (_("Out of memory\n"));
8119 strncpy (temp, inote.namedata, inote.namesz);
8120 temp[inote.namesz] = 0;
8122 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8123 inote.namedata = temp;
8126 res &= process_note (& inote);
8141 process_corefile_note_segments (file)
8144 Elf_Internal_Phdr * program_headers;
8145 Elf_Internal_Phdr * segment;
8149 program_headers = (Elf_Internal_Phdr *) malloc
8150 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
8152 if (program_headers == NULL)
8154 error (_("Out of memory\n"));
8159 i = get_32bit_program_headers (file, program_headers);
8161 i = get_64bit_program_headers (file, program_headers);
8165 free (program_headers);
8169 for (i = 0, segment = program_headers;
8170 i < elf_header.e_phnum;
8173 if (segment->p_type == PT_NOTE)
8174 res &= process_corefile_note_segment (file,
8175 (bfd_vma) segment->p_offset,
8176 (bfd_vma) segment->p_filesz);
8179 free (program_headers);
8185 process_corefile_contents (file)
8188 /* If we have not been asked to display the notes then do nothing. */
8192 /* If file is not a core file then exit. */
8193 if (elf_header.e_type != ET_CORE)
8196 /* No program headers means no NOTE segment. */
8197 if (elf_header.e_phnum == 0)
8199 printf (_("No note segments present in the core file.\n"));
8203 return process_corefile_note_segments (file);
8207 process_arch_specific (file)
8213 switch (elf_header.e_machine)
8216 case EM_MIPS_RS4_BE:
8217 return process_mips_specific (file);
8226 get_file_header (file)
8229 /* Read in the identity array. */
8230 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8233 /* Determine how to read the rest of the header. */
8234 switch (elf_header.e_ident [EI_DATA])
8236 default: /* fall through */
8237 case ELFDATANONE: /* fall through */
8238 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
8239 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
8242 /* For now we only support 32 bit and 64 bit ELF files. */
8243 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
8245 /* Read in the rest of the header. */
8248 Elf32_External_Ehdr ehdr32;
8250 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8253 elf_header.e_type = BYTE_GET (ehdr32.e_type);
8254 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
8255 elf_header.e_version = BYTE_GET (ehdr32.e_version);
8256 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
8257 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
8258 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
8259 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
8260 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
8261 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8262 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
8263 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8264 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
8265 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
8269 Elf64_External_Ehdr ehdr64;
8271 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8272 we will not be able to cope with the 64bit data found in
8273 64 ELF files. Detect this now and abort before we start
8274 overwritting things. */
8275 if (sizeof (bfd_vma) < 8)
8277 error (_("This instance of readelf has been built without support for a\n"));
8278 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
8282 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
8285 elf_header.e_type = BYTE_GET (ehdr64.e_type);
8286 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
8287 elf_header.e_version = BYTE_GET (ehdr64.e_version);
8288 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
8289 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
8290 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
8291 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
8292 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
8293 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
8294 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
8295 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
8296 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
8297 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
8304 process_file (file_name)
8308 struct stat statbuf;
8311 if (stat (file_name, & statbuf) < 0)
8313 error (_("Cannot stat input file %s.\n"), file_name);
8317 file = fopen (file_name, "rb");
8320 error (_("Input file %s not found.\n"), file_name);
8324 if (! get_file_header (file))
8326 error (_("%s: Failed to read file header\n"), file_name);
8331 /* Initialise per file variables. */
8332 for (i = NUM_ELEM (version_info); i--;)
8333 version_info[i] = 0;
8335 for (i = NUM_ELEM (dynamic_info); i--;)
8336 dynamic_info[i] = 0;
8338 /* Process the file. */
8340 printf (_("\nFile: %s\n"), file_name);
8342 if (! process_file_header ())
8348 process_section_headers (file);
8350 process_program_headers (file);
8352 process_dynamic_segment (file);
8354 process_relocs (file);
8356 process_unwind (file);
8358 process_symbol_table (file);
8360 process_syminfo (file);
8362 process_version_sections (file);
8364 process_section_contents (file);
8366 process_corefile_contents (file);
8368 process_arch_specific (file);
8372 if (section_headers)
8374 free (section_headers);
8375 section_headers = NULL;
8380 free (string_table);
8381 string_table = NULL;
8382 string_table_length = 0;
8385 if (dynamic_strings)
8387 free (dynamic_strings);
8388 dynamic_strings = NULL;
8391 if (dynamic_symbols)
8393 free (dynamic_symbols);
8394 dynamic_symbols = NULL;
8395 num_dynamic_syms = 0;
8398 if (dynamic_syminfo)
8400 free (dynamic_syminfo);
8401 dynamic_syminfo = NULL;
8405 #ifdef SUPPORT_DISASSEMBLY
8406 /* Needed by the i386 disassembler. For extra credit, someone could
8407 fix this so that we insert symbolic addresses here, esp for GOT/PLT
8411 print_address (unsigned int addr, FILE * outfile)
8413 fprintf (outfile,"0x%8.8x", addr);
8416 /* Needed by the i386 disassembler. */
8418 db_task_printsym (unsigned int addr)
8420 print_address (addr, stderr);
8429 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
8430 setlocale (LC_MESSAGES, "");
8432 bindtextdomain (PACKAGE, LOCALEDIR);
8433 textdomain (PACKAGE);
8435 parse_args (argc, argv);
8437 if (optind < (argc - 1))
8440 while (optind < argc)
8441 process_file (argv [optind ++]);
8443 if (dump_sects != NULL)