1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 99, 2000 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we belive that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
56 #include "elf/alpha.h"
59 #include "elf/sparc.h"
64 #include "elf/mn10200.h"
65 #include "elf/mn10300.h"
69 #include "elf/mcore.h"
78 char * program_name = "readelf";
79 unsigned int dynamic_addr;
80 bfd_size_type dynamic_size;
81 unsigned int rela_addr;
82 unsigned int rela_size;
83 char * dynamic_strings;
85 unsigned long num_dynamic_syms;
86 Elf_Internal_Sym * dynamic_symbols;
87 Elf_Internal_Syminfo * dynamic_syminfo;
88 unsigned long dynamic_syminfo_offset;
89 unsigned int dynamic_syminfo_nent;
90 char program_interpreter [64];
91 int dynamic_info[DT_JMPREL + 1];
94 Elf_Internal_Ehdr elf_header;
95 Elf_Internal_Shdr * section_headers;
96 Elf_Internal_Dyn * dynamic_segment;
103 int do_using_dynamic;
110 int do_debug_abbrevs;
112 int do_debug_pubnames;
113 int do_debug_aranges;
118 /* A dynamic array of flags indicating which sections require dumping. */
119 char * dump_sects = NULL;
120 unsigned int num_dump_sects = 0;
122 #define HEX_DUMP (1 << 0)
123 #define DISASS_DUMP (1 << 1)
124 #define DEBUG_DUMP (1 << 2)
126 /* How to rpint a vma value. */
127 typedef enum print_mode
139 /* Forward declarations for dumb compilers. */
140 static void print_vma PARAMS ((bfd_vma, print_mode));
141 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
142 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
143 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
144 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
145 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
146 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
147 static const char * get_dynamic_type PARAMS ((unsigned long));
148 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
149 static char * get_file_type PARAMS ((unsigned));
150 static char * get_machine_name PARAMS ((unsigned));
151 static void decode_ARM_machine_flags PARAMS ((unsigned, char []));
152 static char * get_machine_flags PARAMS ((unsigned, unsigned));
153 static const char * get_mips_segment_type PARAMS ((unsigned long));
154 static const char * get_parisc_segment_type PARAMS ((unsigned long));
155 static const char * get_segment_type PARAMS ((unsigned long));
156 static const char * get_mips_section_type_name PARAMS ((unsigned int));
157 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
158 static const char * get_section_type_name PARAMS ((unsigned int));
159 static const char * get_symbol_binding PARAMS ((unsigned int));
160 static const char * get_symbol_type PARAMS ((unsigned int));
161 static const char * get_symbol_visibility PARAMS ((unsigned int));
162 static const char * get_symbol_index_type PARAMS ((unsigned int));
163 static const char * get_dynamic_flags PARAMS ((bfd_vma));
164 static void usage PARAMS ((void));
165 static void parse_args PARAMS ((int, char **));
166 static int process_file_header PARAMS ((void));
167 static int process_program_headers PARAMS ((FILE *));
168 static int process_section_headers PARAMS ((FILE *));
169 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
170 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
171 static int process_dynamic_segment PARAMS ((FILE *));
172 static int process_symbol_table PARAMS ((FILE *));
173 static int process_section_contents PARAMS ((FILE *));
174 static void process_file PARAMS ((char *));
175 static int process_relocs PARAMS ((FILE *));
176 static int process_version_sections PARAMS ((FILE *));
177 static char * get_ver_flags PARAMS ((unsigned int));
178 static int get_32bit_section_headers PARAMS ((FILE *));
179 static int get_64bit_section_headers PARAMS ((FILE *));
180 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
181 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
182 static int get_file_header PARAMS ((FILE *));
183 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
184 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
185 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
186 static int get_32bit_dynamic_segment PARAMS ((FILE *));
187 static int get_64bit_dynamic_segment PARAMS ((FILE *));
188 #ifdef SUPPORT_DISASSEMBLY
189 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
191 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
192 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
193 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
194 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
195 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
196 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
197 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
198 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
199 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
200 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
201 static void reset_state_machine PARAMS ((int));
202 static char * get_TAG_name PARAMS ((unsigned long));
203 static char * get_AT_name PARAMS ((unsigned long));
204 static char * get_FORM_name PARAMS ((unsigned long));
205 static void free_abbrevs PARAMS ((void));
206 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
207 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
208 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
209 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
210 static void decode_location_expression PARAMS ((unsigned char *, unsigned int, unsigned long));
211 static void request_dump PARAMS ((unsigned int, char));
212 static const char * get_elf_class PARAMS ((unsigned char));
213 static const char * get_data_encoding PARAMS ((unsigned char));
214 static const char * get_osabi_name PARAMS ((unsigned char));
215 static int guess_is_rela PARAMS ((unsigned long));
216 static char * get_note_type PARAMS ((unsigned int));
217 static int process_note PARAMS ((Elf32_Internal_Note *));
218 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
219 static int process_corefile_note_segments PARAMS ((FILE *));
220 static int process_corefile_contents PARAMS ((FILE *));
222 typedef int Elf32_Word;
230 #define SECTION_NAME(X) (string_table + (X)->sh_name)
232 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
234 #define BYTE_GET(field) byte_get (field, sizeof (field))
236 /* If we can support a 64 bit data type then BFD64 should be defined
237 and sizeof (bfd_vma) == 8. In this case when translating from an
238 external 8 byte field to an internal field, we can assume that the
239 internal field is also 8 bytes wide and so we can extact all the data.
240 If, however, BFD64 is not defined, then we must assume that the
241 internal data structure only has 4 byte wide fields that are the
242 equivalent of the 8 byte wide external counterparts, and so we must
243 truncate the data. */
245 #define BYTE_GET8(field) byte_get (field, -8)
247 #define BYTE_GET8(field) byte_get (field, 8)
250 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
252 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
253 if (fseek (file, offset, SEEK_SET)) \
255 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
259 var = (type) malloc (size); \
263 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
267 if (fread (var, size, 1, file) != 1) \
269 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
276 #define GET_DATA(offset, var, reason) \
277 if (fseek (file, offset, SEEK_SET)) \
279 error (_("Unable to seek to %x for %s\n"), offset, reason); \
282 else if (fread (& var, sizeof (var), 1, file) != 1) \
284 error (_("Unable to read data at %x for %s\n"), offset, reason); \
288 #define GET_ELF_SYMBOLS(file, offset, size) \
289 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
290 : get_64bit_elf_symbols (file, offset, size))
293 #ifdef ANSI_PROTOTYPES
295 error (const char * message, ...)
299 fprintf (stderr, _("%s: Error: "), program_name);
300 va_start (args, message);
301 vfprintf (stderr, message, args);
307 warn (const char * message, ...)
311 fprintf (stderr, _("%s: Warning: "), program_name);
312 va_start (args, message);
313 vfprintf (stderr, message, args);
325 fprintf (stderr, _("%s: Error: "), program_name);
327 message = va_arg (args, char *);
328 vfprintf (stderr, message, args);
340 fprintf (stderr, _("%s: Warning: "), program_name);
342 message = va_arg (args, char *);
343 vfprintf (stderr, message, args);
350 byte_get_little_endian (field, size)
351 unsigned char * field;
360 return ((unsigned int) (field [0]))
361 | (((unsigned int) (field [1])) << 8);
364 /* We want to extract data from an 8 byte wide field and
365 place it into a 4 byte wide field. Since this is a little
366 endian source we can juts use the 4 byte extraction code. */
369 return ((unsigned long) (field [0]))
370 | (((unsigned long) (field [1])) << 8)
371 | (((unsigned long) (field [2])) << 16)
372 | (((unsigned long) (field [3])) << 24);
376 /* This is a special case, generated by the BYTE_GET8 macro.
377 It means that we are loading an 8 byte value from a field
378 in an external structure into an 8 byte value in a field
379 in an internal strcuture. */
380 return ((bfd_vma) (field [0]))
381 | (((bfd_vma) (field [1])) << 8)
382 | (((bfd_vma) (field [2])) << 16)
383 | (((bfd_vma) (field [3])) << 24)
384 | (((bfd_vma) (field [4])) << 32)
385 | (((bfd_vma) (field [5])) << 40)
386 | (((bfd_vma) (field [6])) << 48)
387 | (((bfd_vma) (field [7])) << 56);
390 error (_("Unhandled data length: %d\n"), size);
395 /* Print a VMA value. */
397 print_vma (vma, mode)
407 case FULL_HEX: printf ("0x"); /* drop through */
408 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
409 case PREFIX_HEX: printf ("0x"); /* drop through */
410 case HEX: printf ("%lx", (unsigned long) vma); break;
411 case DEC: printf ("%ld", (unsigned long) vma); break;
412 case DEC_5: printf ("%5ld", (long) vma); break;
413 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
434 #if BFD_HOST_64BIT_LONG
437 if (_bfd_int64_high (vma))
438 printf ("%lx%lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
440 printf ("%lx", _bfd_int64_low (vma));
445 #if BFD_HOST_64BIT_LONG
448 if (_bfd_int64_high (vma))
450 printf ("++%ld", _bfd_int64_low (vma));
452 printf ("%ld", _bfd_int64_low (vma));
457 #if BFD_HOST_64BIT_LONG
458 printf ("%5ld", vma);
460 if (_bfd_int64_high (vma))
462 printf ("++%ld", _bfd_int64_low (vma));
464 printf ("%5ld", _bfd_int64_low (vma));
469 #if BFD_HOST_64BIT_LONG
472 if (_bfd_int64_high (vma))
474 printf ("++%lu", _bfd_int64_low (vma));
476 printf ("%lu", _bfd_int64_low (vma));
485 byte_get_big_endian (field, size)
486 unsigned char * field;
495 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
498 return ((unsigned long) (field [3]))
499 | (((unsigned long) (field [2])) << 8)
500 | (((unsigned long) (field [1])) << 16)
501 | (((unsigned long) (field [0])) << 24);
504 /* Although we are extracing data from an 8 byte wide field, we
505 are returning only 4 bytes of data. */
506 return ((unsigned long) (field [7]))
507 | (((unsigned long) (field [6])) << 8)
508 | (((unsigned long) (field [5])) << 16)
509 | (((unsigned long) (field [4])) << 24);
513 /* This is a special case, generated by the BYTE_GET8 macro.
514 It means that we are loading an 8 byte value from a field
515 in an external structure into an 8 byte value in a field
516 in an internal strcuture. */
517 return ((bfd_vma) (field [7]))
518 | (((bfd_vma) (field [6])) << 8)
519 | (((bfd_vma) (field [5])) << 16)
520 | (((bfd_vma) (field [4])) << 24)
521 | (((bfd_vma) (field [3])) << 32)
522 | (((bfd_vma) (field [2])) << 40)
523 | (((bfd_vma) (field [1])) << 48)
524 | (((bfd_vma) (field [0])) << 56);
528 error (_("Unhandled data length: %d\n"), size);
534 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
536 guess_is_rela (e_machine)
537 unsigned long e_machine;
541 /* Targets that use REL relocations. */
552 /* Targets that use RELA relocations. */
560 case EM_CYGNUS_MN10200:
561 case EM_CYGNUS_MN10300:
589 warn (_("Don't know about relocations on this machine architecture\n"));
594 /* Display the contents of the relocation data found at the specified offset. */
596 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
598 unsigned long rel_offset;
599 unsigned long rel_size;
600 Elf_Internal_Sym * symtab;
606 Elf_Internal_Rel * rels;
607 Elf_Internal_Rela * relas;
610 if (is_rela == UNKNOWN)
611 is_rela = guess_is_rela (elf_header.e_machine);
617 Elf32_External_Rela * erelas;
619 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
620 Elf32_External_Rela *, "relocs");
622 rel_size = rel_size / sizeof (Elf32_External_Rela);
624 relas = (Elf_Internal_Rela *)
625 malloc (rel_size * sizeof (Elf_Internal_Rela));
629 error(_("out of memory parsing relocs"));
633 for (i = 0; i < rel_size; i++)
635 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
636 relas[i].r_info = BYTE_GET (erelas[i].r_info);
637 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
642 rels = (Elf_Internal_Rel *) relas;
646 Elf64_External_Rela * erelas;
648 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
649 Elf64_External_Rela *, "relocs");
651 rel_size = rel_size / sizeof (Elf64_External_Rela);
653 relas = (Elf_Internal_Rela *)
654 malloc (rel_size * sizeof (Elf_Internal_Rela));
658 error(_("out of memory parsing relocs"));
662 for (i = 0; i < rel_size; i++)
664 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
665 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
666 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
671 rels = (Elf_Internal_Rel *) relas;
678 Elf32_External_Rel * erels;
680 GET_DATA_ALLOC (rel_offset, rel_size, erels,
681 Elf32_External_Rel *, "relocs");
683 rel_size = rel_size / sizeof (Elf32_External_Rel);
685 rels = (Elf_Internal_Rel *)
686 malloc (rel_size * sizeof (Elf_Internal_Rel));
690 error(_("out of memory parsing relocs"));
694 for (i = 0; i < rel_size; i++)
696 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
697 rels[i].r_info = BYTE_GET (erels[i].r_info);
702 relas = (Elf_Internal_Rela *) rels;
706 Elf64_External_Rel * erels;
708 GET_DATA_ALLOC (rel_offset, rel_size, erels,
709 Elf64_External_Rel *, "relocs");
711 rel_size = rel_size / sizeof (Elf64_External_Rel);
713 rels = (Elf_Internal_Rel *)
714 malloc (rel_size * sizeof (Elf_Internal_Rel));
718 error(_("out of memory parsing relocs"));
722 for (i = 0; i < rel_size; i++)
724 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
725 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
730 relas = (Elf_Internal_Rela *) rels;
736 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
739 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
741 for (i = 0; i < rel_size; i++)
746 bfd_vma symtab_index;
751 offset = relas [i].r_offset;
752 info = relas [i].r_info;
756 offset = rels [i].r_offset;
757 info = rels [i].r_info;
762 type = ELF32_R_TYPE (info);
763 symtab_index = ELF32_R_SYM (info);
767 if (elf_header.e_machine == EM_SPARCV9)
768 type = ELF64_R_TYPE_ID (info);
770 type = ELF64_R_TYPE (info);
771 /* The #ifdef BFD64 below is to prevent a compile time warning.
772 We know that if we do not have a 64 bit data type that we
773 will never execute this code anyway. */
775 symtab_index = ELF64_R_SYM (info);
779 #ifdef _bfd_int64_low
780 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
782 printf (" %8.8lx %5.5lx ", offset, info);
785 switch (elf_header.e_machine)
792 rtype = elf_m32r_reloc_type (type);
797 rtype = elf_i386_reloc_type (type);
801 rtype = elf_m68k_reloc_type (type);
805 rtype = elf_i960_reloc_type (type);
809 rtype = elf_avr_reloc_type (type);
816 rtype = elf_sparc_reloc_type (type);
820 rtype = v850_reloc_type (type);
824 rtype = elf_d10v_reloc_type (type);
828 rtype = elf_d30v_reloc_type (type);
832 rtype = elf_sh_reloc_type (type);
835 case EM_CYGNUS_MN10300:
836 rtype = elf_mn10300_reloc_type (type);
839 case EM_CYGNUS_MN10200:
840 rtype = elf_mn10200_reloc_type (type);
844 rtype = elf_fr30_reloc_type (type);
848 rtype = elf_mcore_reloc_type (type);
852 rtype = elf_ppc_reloc_type (type);
857 rtype = elf_mips_reloc_type (type);
861 rtype = elf_alpha_reloc_type (type);
865 rtype = elf_arm_reloc_type (type);
869 rtype = elf_arc_reloc_type (type);
873 rtype = elf_hppa_reloc_type (type);
877 rtype = elf_pj_reloc_type (type);
880 rtype = elf_ia64_reloc_type (type);
885 #ifdef _bfd_int64_low
886 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
888 printf (_("unrecognised: %-7lx"), type);
891 printf ("%-21.21s", rtype);
897 if (symtab_index >= nsyms)
898 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
901 Elf_Internal_Sym * psym;
903 psym = symtab + symtab_index;
906 print_vma (psym->st_value, LONG_HEX);
909 if (psym->st_name == 0)
911 SECTION_NAME (section_headers + psym->st_shndx));
912 else if (strtab == NULL)
913 printf (_("<string table index %3ld>"), psym->st_name);
915 printf ("%-25.25s", strtab + psym->st_name);
918 printf (" + %lx", (unsigned long) relas [i].r_addend);
924 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
925 print_vma (relas[i].r_addend, LONG_HEX);
928 if (elf_header.e_machine == EM_SPARCV9
929 && !strcmp (rtype, "R_SPARC_OLO10"))
930 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
941 get_mips_dynamic_type (type)
946 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
947 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
948 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
949 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
950 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
951 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
952 case DT_MIPS_MSYM: return "MIPS_MSYM";
953 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
954 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
955 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
956 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
957 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
958 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
959 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
960 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
961 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
962 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
963 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
964 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
965 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
966 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
967 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
968 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
969 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
970 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
971 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
972 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
973 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
974 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
975 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
976 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
977 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
978 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
979 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
980 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
981 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
982 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
983 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
984 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
985 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
986 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
987 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
988 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
995 get_sparc64_dynamic_type (type)
1000 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1007 get_parisc_dynamic_type (type)
1012 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1013 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1014 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1015 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1016 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1017 case DT_HP_PREINIT: return "HP_PREINIT";
1018 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1019 case DT_HP_NEEDED: return "HP_NEEDED";
1020 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1021 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1022 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1023 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1024 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1031 get_dynamic_type (type)
1034 static char buff [32];
1038 case DT_NULL: return "NULL";
1039 case DT_NEEDED: return "NEEDED";
1040 case DT_PLTRELSZ: return "PLTRELSZ";
1041 case DT_PLTGOT: return "PLTGOT";
1042 case DT_HASH: return "HASH";
1043 case DT_STRTAB: return "STRTAB";
1044 case DT_SYMTAB: return "SYMTAB";
1045 case DT_RELA: return "RELA";
1046 case DT_RELASZ: return "RELASZ";
1047 case DT_RELAENT: return "RELAENT";
1048 case DT_STRSZ: return "STRSZ";
1049 case DT_SYMENT: return "SYMENT";
1050 case DT_INIT: return "INIT";
1051 case DT_FINI: return "FINI";
1052 case DT_SONAME: return "SONAME";
1053 case DT_RPATH: return "RPATH";
1054 case DT_SYMBOLIC: return "SYMBOLIC";
1055 case DT_REL: return "REL";
1056 case DT_RELSZ: return "RELSZ";
1057 case DT_RELENT: return "RELENT";
1058 case DT_PLTREL: return "PLTREL";
1059 case DT_DEBUG: return "DEBUG";
1060 case DT_TEXTREL: return "TEXTREL";
1061 case DT_JMPREL: return "JMPREL";
1062 case DT_BIND_NOW: return "BIND_NOW";
1063 case DT_INIT_ARRAY: return "INIT_ARRAY";
1064 case DT_FINI_ARRAY: return "FINI_ARRAY";
1065 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1066 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1067 case DT_RUNPATH: return "RUNPATH";
1068 case DT_FLAGS: return "FLAGS";
1070 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1071 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1073 case DT_PLTPADSZ: return "PLTPADSZ";
1074 case DT_MOVEENT: return "MOVEENT";
1075 case DT_MOVESZ: return "MOVESZ";
1076 case DT_FEATURE_1: return "FEATURE_1";
1077 case DT_POSFLAG_1: return "POSFLAG_1";
1078 case DT_SYMINSZ: return "SYMINSZ";
1079 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1081 case DT_ADDRRNGLO: return "ADDRRNGLO";
1082 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1084 case DT_VERSYM: return "VERSYM";
1086 case DT_RELACOUNT: return "RELACOUNT";
1087 case DT_RELCOUNT: return "RELCOUNT";
1088 case DT_FLAGS_1: return "FLAGS_1";
1089 case DT_VERDEF: return "VERDEF";
1090 case DT_VERDEFNUM: return "VERDEFNUM";
1091 case DT_VERNEED: return "VERNEED";
1092 case DT_VERNEEDNUM: return "VERNEEDNUM";
1094 case DT_AUXILIARY: return "AUXILARY";
1095 case DT_USED: return "USED";
1096 case DT_FILTER: return "FILTER";
1099 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1101 const char * result;
1103 switch (elf_header.e_machine)
1106 case EM_MIPS_RS4_BE:
1107 result = get_mips_dynamic_type (type);
1110 result = get_sparc64_dynamic_type (type);
1120 sprintf (buff, _("Processor Specific: %lx"), type);
1122 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1124 const char * result;
1126 switch (elf_header.e_machine)
1129 result = get_parisc_dynamic_type (type);
1139 sprintf (buff, _("Operating System specific: %lx"), type);
1142 sprintf (buff, _("<unknown>: %lx"), type);
1149 get_file_type (e_type)
1152 static char buff [32];
1156 case ET_NONE: return _("NONE (None)");
1157 case ET_REL: return _("REL (Relocatable file)");
1158 case ET_EXEC: return _("EXEC (Executable file)");
1159 case ET_DYN: return _("DYN (Shared object file)");
1160 case ET_CORE: return _("CORE (Core file)");
1163 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1164 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1165 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1166 sprintf (buff, _("OS Specific: (%x)"), e_type);
1168 sprintf (buff, _("<unknown>: %x"), e_type);
1174 get_machine_name (e_machine)
1177 static char buff [64]; /* XXX */
1181 case EM_NONE: return _("None");
1182 case EM_M32: return "WE32100";
1183 case EM_SPARC: return "Sparc";
1184 case EM_386: return "Intel 80386";
1185 case EM_68K: return "MC68000";
1186 case EM_88K: return "MC88000";
1187 case EM_486: return "Intel 80486";
1188 case EM_860: return "Intel 80860";
1189 case EM_MIPS: return "MIPS R3000";
1190 case EM_S370: return "IBM System/370";
1191 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1192 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1193 case EM_PARISC: return "HPPA";
1194 case EM_PPC_OLD: return "Power PC (old)";
1195 case EM_SPARC32PLUS: return "Sparc v8+" ;
1196 case EM_960: return "Intel 90860";
1197 case EM_PPC: return "PowerPC";
1198 case EM_V800: return "NEC V800";
1199 case EM_FR20: return "Fujitsu FR20";
1200 case EM_RH32: return "TRW RH32";
1201 case EM_MCORE: return "MCORE";
1202 case EM_ARM: return "ARM";
1203 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1204 case EM_SH: return "Hitachi SH";
1205 case EM_SPARCV9: return "Sparc v9";
1206 case EM_TRICORE: return "Siemens Tricore";
1207 case EM_ARC: return "Argonaut RISC Core";
1208 case EM_H8_300: return "Hitachi H8/300";
1209 case EM_H8_300H: return "Hitachi H8/300H";
1210 case EM_H8S: return "Hitachi H8S";
1211 case EM_H8_500: return "Hitachi H8/500";
1212 case EM_IA_64: return "Intel IA-64";
1213 case EM_MIPS_X: return "Stanford MIPS-X";
1214 case EM_COLDFIRE: return "Motorola Coldfire";
1215 case EM_68HC12: return "Motorola M68HC12";
1216 case EM_ALPHA: return "Alpha";
1217 case EM_CYGNUS_D10V: return "d10v";
1218 case EM_CYGNUS_D30V: return "d30v";
1219 case EM_CYGNUS_ARC: return "Arc";
1220 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1221 case EM_CYGNUS_V850: return "NEC v850";
1222 case EM_CYGNUS_MN10300: return "mn10300";
1223 case EM_CYGNUS_MN10200: return "mn10200";
1224 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1225 case EM_PJ: return "picoJava";
1226 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1227 case EM_PCP: return "Siemens PCP";
1228 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1229 case EM_NDR1: return "Denso NDR1 microprocesspr";
1230 case EM_STARCORE: return "Motorola Star*Core processor";
1231 case EM_ME16: return "Toyota ME16 processor";
1232 case EM_ST100: return "STMicroelectronics ST100 processor";
1233 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1234 case EM_FX66: return "Siemens FX66 microcontroller";
1235 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1236 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1237 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1238 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1239 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1240 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1241 case EM_SVX: return "Silicon Graphics SVx";
1242 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1243 case EM_VAX: return "Digital VAX";
1244 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1246 sprintf (buff, _("<unknown>: %x"), e_machine);
1252 decode_ARM_machine_flags (e_flags, buf)
1259 eabi = EF_ARM_EABI_VERSION (e_flags);
1260 e_flags &= ~ EF_ARM_EABIMASK;
1262 /* Handle "generic" ARM flags. */
1263 if (e_flags & EF_ARM_RELEXEC)
1265 strcat (buf, ", relocatable executable");
1266 e_flags &= ~ EF_ARM_RELEXEC;
1269 if (e_flags & EF_ARM_HASENTRY)
1271 strcat (buf, ", has entry point");
1272 e_flags &= ~ EF_ARM_HASENTRY;
1275 /* Now handle EABI specific flags. */
1279 strcat (buf, ", <unknown EABI>");
1284 case EF_ARM_EABI_VER1:
1289 /* Process flags one bit at a time. */
1290 flag = e_flags & - e_flags;
1295 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_INTERWORK. */
1296 strcat (buf, ", sorted symbol tables");
1306 case EF_ARM_EABI_UNKNOWN:
1311 /* Process flags one bit at a time. */
1312 flag = e_flags & - e_flags;
1318 strcat (buf, ", interworking enabled");
1322 strcat (buf, ", uses APCS/26");
1326 strcat (buf, ", uses APCS/float");
1330 strcat (buf, ", position independent");
1334 strcat (buf, ", 8 bit structure alignment");
1338 strcat (buf, ", uses new ABI");
1342 strcat (buf, ", uses old ABI");
1346 strcat (buf, ", software FP");
1357 strcat (buf,", <unknown>");
1361 get_machine_flags (e_flags, e_machine)
1365 static char buf [1024];
1377 decode_ARM_machine_flags (e_flags, buf);
1381 if (e_flags & EF_CPU32)
1382 strcat (buf, ", cpu32");
1386 if (e_flags & EF_PPC_EMB)
1387 strcat (buf, ", emb");
1389 if (e_flags & EF_PPC_RELOCATABLE)
1390 strcat (buf, ", relocatable");
1392 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1393 strcat (buf, ", relocatable-lib");
1396 case EM_CYGNUS_V850:
1397 switch (e_flags & EF_V850_ARCH)
1400 strcat (buf, ", v850e");
1403 strcat (buf, ", v850ea");
1406 strcat (buf, ", v850");
1409 strcat (buf, ", unknown v850 architecture variant");
1414 case EM_CYGNUS_M32R:
1415 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1416 strcat (buf, ", m32r");
1421 case EM_MIPS_RS4_BE:
1422 if (e_flags & EF_MIPS_NOREORDER)
1423 strcat (buf, ", noreorder");
1425 if (e_flags & EF_MIPS_PIC)
1426 strcat (buf, ", pic");
1428 if (e_flags & EF_MIPS_CPIC)
1429 strcat (buf, ", cpic");
1431 if (e_flags & EF_MIPS_ABI2)
1432 strcat (buf, ", abi2");
1434 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1435 strcat (buf, ", mips1");
1437 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1438 strcat (buf, ", mips2");
1440 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1441 strcat (buf, ", mips3");
1443 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1444 strcat (buf, ", mips4");
1448 if (e_flags & EF_SPARC_32PLUS)
1449 strcat (buf, ", v8+");
1451 if (e_flags & EF_SPARC_SUN_US1)
1452 strcat (buf, ", ultrasparcI");
1454 if (e_flags & EF_SPARC_SUN_US3)
1455 strcat (buf, ", ultrasparcIII");
1457 if (e_flags & EF_SPARC_HAL_R1)
1458 strcat (buf, ", halr1");
1460 if (e_flags & EF_SPARC_LEDATA)
1461 strcat (buf, ", ledata");
1463 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1464 strcat (buf, ", tso");
1466 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1467 strcat (buf, ", pso");
1469 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1470 strcat (buf, ", rmo");
1474 switch (e_flags & EF_PARISC_ARCH)
1476 case EFA_PARISC_1_0:
1477 strcpy (buf, ", PA-RISC 1.0");
1479 case EFA_PARISC_1_1:
1480 strcpy (buf, ", PA-RISC 1.1");
1482 case EFA_PARISC_2_0:
1483 strcpy (buf, ", PA-RISC 2.0");
1488 if (e_flags & EF_PARISC_TRAPNIL)
1489 strcat (buf, ", trapnil");
1490 if (e_flags & EF_PARISC_EXT)
1491 strcat (buf, ", ext");
1492 if (e_flags & EF_PARISC_LSB)
1493 strcat (buf, ", lsb");
1494 if (e_flags & EF_PARISC_WIDE)
1495 strcat (buf, ", wide");
1496 if (e_flags & EF_PARISC_NO_KABP)
1497 strcat (buf, ", no kabp");
1498 if (e_flags & EF_PARISC_LAZYSWAP)
1499 strcat (buf, ", lazyswap");
1503 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1504 strcat (buf, ", new calling convention");
1506 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1507 strcat (buf, ", gnu calling convention");
1516 get_mips_segment_type (type)
1521 case PT_MIPS_REGINFO:
1523 case PT_MIPS_RTPROC:
1525 case PT_MIPS_OPTIONS:
1535 get_parisc_segment_type (type)
1540 case PT_HP_TLS: return "HP_TLS";
1541 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1542 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1543 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1544 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1545 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1546 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1547 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1548 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1549 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1550 case PT_HP_PARALLEL: return "HP_PARALLEL";
1551 case PT_HP_FASTBIND: return "HP_FASTBIND";
1552 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1553 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1562 get_segment_type (p_type)
1563 unsigned long p_type;
1565 static char buff [32];
1569 case PT_NULL: return "NULL";
1570 case PT_LOAD: return "LOAD";
1571 case PT_DYNAMIC: return "DYNAMIC";
1572 case PT_INTERP: return "INTERP";
1573 case PT_NOTE: return "NOTE";
1574 case PT_SHLIB: return "SHLIB";
1575 case PT_PHDR: return "PHDR";
1578 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1580 const char * result;
1582 switch (elf_header.e_machine)
1585 case EM_MIPS_RS4_BE:
1586 result = get_mips_segment_type (p_type);
1589 result = get_parisc_segment_type (p_type);
1599 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1601 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1603 const char * result;
1605 switch (elf_header.e_machine)
1608 result = get_parisc_segment_type (p_type);
1618 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1621 sprintf (buff, _("<unknown>: %lx"), p_type);
1628 get_mips_section_type_name (sh_type)
1629 unsigned int sh_type;
1633 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1634 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1635 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1636 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1637 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1638 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1639 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1640 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1641 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1642 case SHT_MIPS_RELD: return "MIPS_RELD";
1643 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1644 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1645 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1646 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1647 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1648 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1649 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1650 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1651 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1652 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1653 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1654 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1655 case SHT_MIPS_LINE: return "MIPS_LINE";
1656 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1657 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1658 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1659 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1660 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1661 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1662 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1663 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1664 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1665 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1666 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1667 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1668 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1669 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1670 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1671 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1679 get_parisc_section_type_name (sh_type)
1680 unsigned int sh_type;
1684 case SHT_PARISC_EXT: return "PARISC_EXT";
1685 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1686 case SHT_PARISC_DOC: return "PARISC_DOC";
1694 get_section_type_name (sh_type)
1695 unsigned int sh_type;
1697 static char buff [32];
1701 case SHT_NULL: return "NULL";
1702 case SHT_PROGBITS: return "PROGBITS";
1703 case SHT_SYMTAB: return "SYMTAB";
1704 case SHT_STRTAB: return "STRTAB";
1705 case SHT_RELA: return "RELA";
1706 case SHT_HASH: return "HASH";
1707 case SHT_DYNAMIC: return "DYNAMIC";
1708 case SHT_NOTE: return "NOTE";
1709 case SHT_NOBITS: return "NOBITS";
1710 case SHT_REL: return "REL";
1711 case SHT_SHLIB: return "SHLIB";
1712 case SHT_DYNSYM: return "DYNSYM";
1713 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1714 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1715 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1716 case SHT_GNU_verdef: return "VERDEF";
1717 case SHT_GNU_verneed: return "VERNEED";
1718 case SHT_GNU_versym: return "VERSYM";
1719 case 0x6ffffff0: return "VERSYM";
1720 case 0x6ffffffc: return "VERDEF";
1721 case 0x7ffffffd: return "AUXILIARY";
1722 case 0x7fffffff: return "FILTER";
1725 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1727 const char * result;
1729 switch (elf_header.e_machine)
1732 case EM_MIPS_RS4_BE:
1733 result = get_mips_section_type_name (sh_type);
1736 result = get_parisc_section_type_name (sh_type);
1746 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1748 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1749 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1750 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1751 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1753 sprintf (buff, _("<unknown>: %x"), sh_type);
1759 struct option options [] =
1761 {"all", no_argument, 0, 'a'},
1762 {"file-header", no_argument, 0, 'h'},
1763 {"program-headers", no_argument, 0, 'l'},
1764 {"headers", no_argument, 0, 'e'},
1765 {"histogram", no_argument, 0, 'I'},
1766 {"segments", no_argument, 0, 'l'},
1767 {"sections", no_argument, 0, 'S'},
1768 {"section-headers", no_argument, 0, 'S'},
1769 {"symbols", no_argument, 0, 's'},
1770 {"syms", no_argument, 0, 's'},
1771 {"relocs", no_argument, 0, 'r'},
1772 {"notes", no_argument, 0, 'n'},
1773 {"dynamic", no_argument, 0, 'd'},
1774 {"arch-specific", no_argument, 0, 'A'},
1775 {"version-info", no_argument, 0, 'V'},
1776 {"use-dynamic", no_argument, 0, 'D'},
1777 {"hex-dump", required_argument, 0, 'x'},
1778 {"debug-dump", optional_argument, 0, 'w'},
1779 #ifdef SUPPORT_DISASSEMBLY
1780 {"instruction-dump", required_argument, 0, 'i'},
1783 {"version", no_argument, 0, 'v'},
1784 {"help", no_argument, 0, 'H'},
1785 {0, no_argument, 0, 0}
1791 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1792 fprintf (stdout, _(" Options are:\n"));
1793 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1794 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1795 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1796 fprintf (stdout, _(" Display the program headers\n"));
1797 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1798 fprintf (stdout, _(" Display the sections' header\n"));
1799 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1800 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1801 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1802 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1803 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1804 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1805 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1806 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1807 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1808 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1809 fprintf (stdout, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1810 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
1811 #ifdef SUPPORT_DISASSEMBLY
1812 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1813 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1815 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1816 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1817 fprintf (stdout, _(" -H or --help Display this information\n"));
1818 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
1824 request_dump (section, type)
1825 unsigned int section;
1828 if (section >= num_dump_sects)
1830 char * new_dump_sects;
1832 new_dump_sects = (char *) calloc (section + 1, 1);
1834 if (new_dump_sects == NULL)
1835 error (_("Out of memory allocating dump request table."));
1838 /* Copy current flag settings. */
1839 memcpy (new_dump_sects, dump_sects, num_dump_sects);
1843 dump_sects = new_dump_sects;
1844 num_dump_sects = section + 1;
1849 dump_sects [section] |= type;
1855 parse_args (argc, argv)
1864 while ((c = getopt_long
1865 (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
1900 do_using_dynamic ++;
1928 section = strtoul (optarg, & cp, 0);
1929 if (! * cp && section >= 0)
1931 request_dump (section, HEX_DUMP);
1951 do_debug_abbrevs = 1;
1961 do_debug_pubnames = 1;
1966 do_debug_aranges = 1;
1970 warn (_("Unrecognised debug option '%s'\n"), optarg);
1975 #ifdef SUPPORT_DISASSEMBLY
1978 section = strtoul (optarg, & cp, 0);
1979 if (! * cp && section >= 0)
1981 request_dump (section, DISASS_DUMP);
1987 print_version (program_name);
1994 /* xgettext:c-format */
1995 error (_("Invalid option '-%c'\n"), c);
2002 if (!do_dynamic && !do_syms && !do_reloc && !do_sections
2003 && !do_segments && !do_header && !do_dump && !do_version
2004 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2008 warn (_("Nothing to do.\n"));
2014 get_elf_class (elf_class)
2015 unsigned char elf_class;
2017 static char buff [32];
2021 case ELFCLASSNONE: return _("none");
2022 case ELFCLASS32: return _("ELF32");
2023 case ELFCLASS64: return _("ELF64");
2025 sprintf (buff, _("<unknown: %x>"), elf_class);
2031 get_data_encoding (encoding)
2032 unsigned char encoding;
2034 static char buff [32];
2038 case ELFDATANONE: return _("none");
2039 case ELFDATA2LSB: return _("2's complement, little endian");
2040 case ELFDATA2MSB: return _("2's complement, big endian");
2042 sprintf (buff, _("<unknown: %x>"), encoding);
2048 get_osabi_name (osabi)
2049 unsigned char osabi;
2051 static char buff [32];
2055 case ELFOSABI_SYSV: return _("UNIX - System V");
2056 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2057 case ELFOSABI_LINUX: return _("UNIX - Linux");
2058 case ELFOSABI_STANDALONE: return _("Standalone App");
2059 case ELFOSABI_ARM: return _("ARM");
2061 sprintf (buff, _("<unknown: %x>"), osabi);
2066 /* Decode the data held in 'elf_header'. */
2068 process_file_header ()
2070 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2071 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2072 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2073 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2076 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2084 printf (_("ELF Header:\n"));
2085 printf (_(" Magic: "));
2086 for (i = 0; i < EI_NIDENT; i ++)
2087 printf ("%2.2x ", elf_header.e_ident [i]);
2089 printf (_(" Class: %s\n"),
2090 get_elf_class (elf_header.e_ident [EI_CLASS]));
2091 printf (_(" Data: %s\n"),
2092 get_data_encoding (elf_header.e_ident [EI_DATA]));
2093 printf (_(" Version: %d %s\n"),
2094 elf_header.e_ident [EI_VERSION],
2095 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2097 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2100 printf (_(" OS/ABI: %s\n"),
2101 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2102 printf (_(" ABI Version: %d\n"),
2103 elf_header.e_ident [EI_ABIVERSION]);
2104 printf (_(" Type: %s\n"),
2105 get_file_type (elf_header.e_type));
2106 printf (_(" Machine: %s\n"),
2107 get_machine_name (elf_header.e_machine));
2108 printf (_(" Version: 0x%lx\n"),
2109 (unsigned long) elf_header.e_version);
2111 printf (_(" Entry point address: "));
2112 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2113 printf (_("\n Start of program headers: "));
2114 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2115 printf (_(" (bytes into file)\n Start of section headers: "));
2116 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2117 printf (_(" (bytes into file)\n"));
2119 printf (_(" Flags: 0x%lx%s\n"),
2120 (unsigned long) elf_header.e_flags,
2121 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2122 printf (_(" Size of this header: %ld (bytes)\n"),
2123 (long) elf_header.e_ehsize);
2124 printf (_(" Size of program headers: %ld (bytes)\n"),
2125 (long) elf_header.e_phentsize);
2126 printf (_(" Number of program headers: %ld\n"),
2127 (long) elf_header.e_phnum);
2128 printf (_(" Size of section headers: %ld (bytes)\n"),
2129 (long) elf_header.e_shentsize);
2130 printf (_(" Number of section headers: %ld\n"),
2131 (long) elf_header.e_shnum);
2132 printf (_(" Section header string table index: %ld\n"),
2133 (long) elf_header.e_shstrndx);
2141 get_32bit_program_headers (file, program_headers)
2143 Elf_Internal_Phdr * program_headers;
2145 Elf32_External_Phdr * phdrs;
2146 Elf32_External_Phdr * external;
2147 Elf32_Internal_Phdr * internal;
2150 GET_DATA_ALLOC (elf_header.e_phoff,
2151 elf_header.e_phentsize * elf_header.e_phnum,
2152 phdrs, Elf32_External_Phdr *, "program headers");
2154 for (i = 0, internal = program_headers, external = phdrs;
2155 i < elf_header.e_phnum;
2156 i ++, internal ++, external ++)
2158 internal->p_type = BYTE_GET (external->p_type);
2159 internal->p_offset = BYTE_GET (external->p_offset);
2160 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2161 internal->p_paddr = BYTE_GET (external->p_paddr);
2162 internal->p_filesz = BYTE_GET (external->p_filesz);
2163 internal->p_memsz = BYTE_GET (external->p_memsz);
2164 internal->p_flags = BYTE_GET (external->p_flags);
2165 internal->p_align = BYTE_GET (external->p_align);
2174 get_64bit_program_headers (file, program_headers)
2176 Elf_Internal_Phdr * program_headers;
2178 Elf64_External_Phdr * phdrs;
2179 Elf64_External_Phdr * external;
2180 Elf64_Internal_Phdr * internal;
2183 GET_DATA_ALLOC (elf_header.e_phoff,
2184 elf_header.e_phentsize * elf_header.e_phnum,
2185 phdrs, Elf64_External_Phdr *, "program headers");
2187 for (i = 0, internal = program_headers, external = phdrs;
2188 i < elf_header.e_phnum;
2189 i ++, internal ++, external ++)
2191 internal->p_type = BYTE_GET (external->p_type);
2192 internal->p_flags = BYTE_GET (external->p_flags);
2193 internal->p_offset = BYTE_GET8 (external->p_offset);
2194 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2195 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2196 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2197 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2198 internal->p_align = BYTE_GET8 (external->p_align);
2207 process_program_headers (file)
2210 Elf_Internal_Phdr * program_headers;
2211 Elf_Internal_Phdr * segment;
2214 if (elf_header.e_phnum == 0)
2217 printf (_("\nThere are no program headers in this file.\n"));
2221 if (do_segments && !do_header)
2223 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2224 printf (_("Entry point "));
2225 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2226 printf (_("\nThere are %d program headers, starting at offset "),
2227 elf_header.e_phnum);
2228 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2232 program_headers = (Elf_Internal_Phdr *) malloc
2233 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2235 if (program_headers == NULL)
2237 error (_("Out of memory\n"));
2242 i = get_32bit_program_headers (file, program_headers);
2244 i = get_64bit_program_headers (file, program_headers);
2248 free (program_headers);
2255 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2259 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2263 (_(" Type Offset VirtAddr PhysAddr\n"));
2265 (_(" FileSiz MemSiz Flags Align\n"));
2273 for (i = 0, segment = program_headers;
2274 i < elf_header.e_phnum;
2279 printf (" %-14.14s ", get_segment_type (segment->p_type));
2283 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2284 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2285 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2286 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2287 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2289 (segment->p_flags & PF_R ? 'R' : ' '),
2290 (segment->p_flags & PF_W ? 'W' : ' '),
2291 (segment->p_flags & PF_X ? 'E' : ' '));
2292 printf ("%#lx", (unsigned long) segment->p_align);
2296 print_vma (segment->p_offset, FULL_HEX);
2298 print_vma (segment->p_vaddr, FULL_HEX);
2300 print_vma (segment->p_paddr, FULL_HEX);
2302 print_vma (segment->p_filesz, FULL_HEX);
2304 print_vma (segment->p_memsz, FULL_HEX);
2306 (segment->p_flags & PF_R ? 'R' : ' '),
2307 (segment->p_flags & PF_W ? 'W' : ' '),
2308 (segment->p_flags & PF_X ? 'E' : ' '));
2309 print_vma (segment->p_align, HEX);
2313 switch (segment->p_type)
2317 loadaddr = (segment->p_vaddr & 0xfffff000)
2318 - (segment->p_offset & 0xfffff000);
2323 error (_("more than one dynamic segment\n"));
2325 dynamic_addr = segment->p_offset;
2326 dynamic_size = segment->p_filesz;
2330 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2331 error (_("Unable to find program interpreter name\n"));
2334 program_interpreter[0] = 0;
2335 fscanf (file, "%63s", program_interpreter);
2338 printf (_("\n [Requesting program interpreter: %s]"),
2339 program_interpreter);
2345 putc ('\n', stdout);
2354 if (do_segments && section_headers != NULL)
2356 printf (_("\n Section to Segment mapping:\n"));
2357 printf (_(" Segment Sections...\n"));
2359 assert (string_table != NULL);
2361 for (i = 0; i < elf_header.e_phnum; i++)
2364 Elf_Internal_Shdr * section;
2366 segment = program_headers + i;
2367 section = section_headers;
2369 printf (" %2.2d ", i);
2371 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2373 if (section->sh_size > 0
2374 /* Compare allocated sections by VMA, unallocated
2375 sections by file offset. */
2376 && (section->sh_flags & SHF_ALLOC
2377 ? (section->sh_addr >= segment->p_vaddr
2378 && section->sh_addr + section->sh_size
2379 <= segment->p_vaddr + segment->p_memsz)
2380 : ((bfd_vma) section->sh_offset >= segment->p_offset
2381 && (section->sh_offset + section->sh_size
2382 <= segment->p_offset + segment->p_filesz))))
2383 printf ("%s ", SECTION_NAME (section));
2390 free (program_headers);
2397 get_32bit_section_headers (file)
2400 Elf32_External_Shdr * shdrs;
2401 Elf32_Internal_Shdr * internal;
2404 GET_DATA_ALLOC (elf_header.e_shoff,
2405 elf_header.e_shentsize * elf_header.e_shnum,
2406 shdrs, Elf32_External_Shdr *, "section headers");
2408 section_headers = (Elf_Internal_Shdr *) malloc
2409 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2411 if (section_headers == NULL)
2413 error (_("Out of memory\n"));
2417 for (i = 0, internal = section_headers;
2418 i < elf_header.e_shnum;
2421 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2422 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2423 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2424 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2425 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2426 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2427 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2428 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2429 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2430 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2439 get_64bit_section_headers (file)
2442 Elf64_External_Shdr * shdrs;
2443 Elf64_Internal_Shdr * internal;
2446 GET_DATA_ALLOC (elf_header.e_shoff,
2447 elf_header.e_shentsize * elf_header.e_shnum,
2448 shdrs, Elf64_External_Shdr *, "section headers");
2450 section_headers = (Elf_Internal_Shdr *) malloc
2451 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2453 if (section_headers == NULL)
2455 error (_("Out of memory\n"));
2459 for (i = 0, internal = section_headers;
2460 i < elf_header.e_shnum;
2463 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2464 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2465 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2466 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2467 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2468 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2469 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2470 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2471 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2472 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2480 static Elf_Internal_Sym *
2481 get_32bit_elf_symbols (file, offset, number)
2483 unsigned long offset;
2484 unsigned long number;
2486 Elf32_External_Sym * esyms;
2487 Elf_Internal_Sym * isyms;
2488 Elf_Internal_Sym * psym;
2491 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2492 esyms, Elf32_External_Sym *, "symbols");
2494 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2498 error (_("Out of memory\n"));
2504 for (j = 0, psym = isyms;
2508 psym->st_name = BYTE_GET (esyms[j].st_name);
2509 psym->st_value = BYTE_GET (esyms[j].st_value);
2510 psym->st_size = BYTE_GET (esyms[j].st_size);
2511 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2512 psym->st_info = BYTE_GET (esyms[j].st_info);
2513 psym->st_other = BYTE_GET (esyms[j].st_other);
2521 static Elf_Internal_Sym *
2522 get_64bit_elf_symbols (file, offset, number)
2524 unsigned long offset;
2525 unsigned long number;
2527 Elf64_External_Sym * esyms;
2528 Elf_Internal_Sym * isyms;
2529 Elf_Internal_Sym * psym;
2532 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2533 esyms, Elf64_External_Sym *, "symbols");
2535 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2539 error (_("Out of memory\n"));
2545 for (j = 0, psym = isyms;
2549 psym->st_name = BYTE_GET (esyms[j].st_name);
2550 psym->st_info = BYTE_GET (esyms[j].st_info);
2551 psym->st_other = BYTE_GET (esyms[j].st_other);
2552 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2553 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2554 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2563 get_elf_section_flags (sh_flags)
2566 static char buff [32];
2574 flag = sh_flags & - sh_flags;
2579 case SHF_WRITE: strcat (buff, "W"); break;
2580 case SHF_ALLOC: strcat (buff, "A"); break;
2581 case SHF_EXECINSTR: strcat (buff, "X"); break;
2582 case SHF_MERGE: strcat (buff, "M"); break;
2583 case SHF_STRINGS: strcat (buff, "S"); break;
2584 case SHF_INFO_LINK: strcat (buff, "I"); break;
2585 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2586 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2589 if (flag & SHF_MASKOS)
2592 sh_flags &= ~ SHF_MASKOS;
2594 else if (flag & SHF_MASKPROC)
2597 sh_flags &= ~ SHF_MASKPROC;
2609 process_section_headers (file)
2612 Elf_Internal_Shdr * section;
2615 section_headers = NULL;
2617 if (elf_header.e_shnum == 0)
2620 printf (_("\nThere are no sections in this file.\n"));
2625 if (do_sections && !do_header)
2626 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2627 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2631 if (! get_32bit_section_headers (file))
2634 else if (! get_64bit_section_headers (file))
2637 /* Read in the string table, so that we have names to display. */
2638 section = section_headers + elf_header.e_shstrndx;
2640 if (section->sh_size != 0)
2642 unsigned long string_table_offset;
2644 string_table_offset = section->sh_offset;
2646 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2647 string_table, char *, "string table");
2650 /* Scan the sections for the dynamic symbol table
2651 and dynamic string table and debug sections. */
2652 dynamic_symbols = NULL;
2653 dynamic_strings = NULL;
2654 dynamic_syminfo = NULL;
2656 for (i = 0, section = section_headers;
2657 i < elf_header.e_shnum;
2660 char * name = SECTION_NAME (section);
2662 if (section->sh_type == SHT_DYNSYM)
2664 if (dynamic_symbols != NULL)
2666 error (_("File contains multiple dynamic symbol tables\n"));
2670 num_dynamic_syms = section->sh_size / section->sh_entsize;
2672 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2674 else if (section->sh_type == SHT_STRTAB
2675 && strcmp (name, ".dynstr") == 0)
2677 if (dynamic_strings != NULL)
2679 error (_("File contains multiple dynamic string tables\n"));
2683 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2684 dynamic_strings, char *, "dynamic strings");
2686 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2687 || do_debug_lines || do_debug_pubnames || do_debug_aranges)
2688 && strncmp (name, ".debug_", 7) == 0)
2693 || (do_debug_info && (strcmp (name, "info") == 0))
2694 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2695 || (do_debug_lines && (strcmp (name, "line") == 0))
2696 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2697 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2699 request_dump (i, DEBUG_DUMP);
2706 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2710 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2713 printf (_(" [Nr] Name Type Address Offset\n"));
2714 printf (_(" Size EntSize Flags Link Info Align\n"));
2717 for (i = 0, section = section_headers;
2718 i < elf_header.e_shnum;
2721 printf (" [%2d] %-17.17s %-15.15s ",
2723 SECTION_NAME (section),
2724 get_section_type_name (section->sh_type));
2728 print_vma (section->sh_addr, LONG_HEX);
2730 printf ( " %6.6lx %6.6lx %2.2lx",
2731 (unsigned long) section->sh_offset,
2732 (unsigned long) section->sh_size,
2733 (unsigned long) section->sh_entsize);
2735 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2737 printf (" %2ld %3lx %ld\n",
2738 (unsigned long) section->sh_link,
2739 (unsigned long) section->sh_info,
2740 (unsigned long) section->sh_addralign);
2745 print_vma (section->sh_addr, LONG_HEX);
2746 printf (" %8.8lx", section->sh_offset);
2748 print_vma (section->sh_size, LONG_HEX);
2750 print_vma (section->sh_entsize, LONG_HEX);
2752 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2754 printf (" %2ld %3lx %ld\n",
2755 (unsigned long) section->sh_link,
2756 (unsigned long) section->sh_info,
2757 (unsigned long) section->sh_addralign);
2761 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2762 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2763 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2768 /* Process the reloc section. */
2770 process_relocs (file)
2773 unsigned long rel_size;
2774 unsigned long rel_offset;
2780 if (do_using_dynamic)
2782 int is_rela = FALSE;
2787 if (dynamic_info[DT_REL])
2789 rel_offset = dynamic_info[DT_REL];
2790 rel_size = dynamic_info[DT_RELSZ];
2793 else if (dynamic_info [DT_RELA])
2795 rel_offset = dynamic_info[DT_RELA];
2796 rel_size = dynamic_info[DT_RELASZ];
2799 else if (dynamic_info[DT_JMPREL])
2801 rel_offset = dynamic_info[DT_JMPREL];
2802 rel_size = dynamic_info[DT_PLTRELSZ];
2804 switch (dynamic_info[DT_PLTREL])
2821 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2822 rel_offset, rel_size);
2824 dump_relocations (file, rel_offset - loadaddr, rel_size,
2825 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2828 printf (_("\nThere are no dynamic relocations in this file.\n"));
2832 Elf32_Internal_Shdr * section;
2836 for (i = 0, section = section_headers;
2837 i < elf_header.e_shnum;
2840 if ( section->sh_type != SHT_RELA
2841 && section->sh_type != SHT_REL)
2844 rel_offset = section->sh_offset;
2845 rel_size = section->sh_size;
2849 Elf32_Internal_Shdr * strsec;
2850 Elf32_Internal_Shdr * symsec;
2851 Elf_Internal_Sym * symtab;
2854 unsigned long nsyms;
2856 printf (_("\nRelocation section "));
2858 if (string_table == NULL)
2859 printf ("%d", section->sh_name);
2861 printf ("'%s'", SECTION_NAME (section));
2863 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2864 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2866 symsec = section_headers + section->sh_link;
2868 nsyms = symsec->sh_size / symsec->sh_entsize;
2869 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2874 strsec = section_headers + symsec->sh_link;
2876 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2877 char *, "string table");
2879 is_rela = section->sh_type == SHT_RELA;
2881 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2891 printf (_("\nThere are no relocations in this file.\n"));
2899 dynamic_segment_mips_val (entry)
2900 Elf_Internal_Dyn * entry;
2902 switch (entry->d_tag)
2905 if (entry->d_un.d_val == 0)
2909 static const char * opts[] =
2911 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2912 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2913 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2914 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2919 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2920 if (entry->d_un.d_val & (1 << cnt))
2922 printf ("%s%s", first ? "" : " ", opts[cnt]);
2929 case DT_MIPS_IVERSION:
2930 if (dynamic_strings != NULL)
2931 printf ("Interface Version: %s\n",
2932 dynamic_strings + entry->d_un.d_val);
2934 printf ("%ld\n", (long) entry->d_un.d_ptr);
2937 case DT_MIPS_TIME_STAMP:
2942 time_t time = entry->d_un.d_val;
2943 tmp = gmtime (&time);
2944 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
2945 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
2946 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
2947 printf ("Time Stamp: %s\n", timebuf);
2951 case DT_MIPS_RLD_VERSION:
2952 case DT_MIPS_LOCAL_GOTNO:
2953 case DT_MIPS_CONFLICTNO:
2954 case DT_MIPS_LIBLISTNO:
2955 case DT_MIPS_SYMTABNO:
2956 case DT_MIPS_UNREFEXTNO:
2957 case DT_MIPS_HIPAGENO:
2958 case DT_MIPS_DELTA_CLASS_NO:
2959 case DT_MIPS_DELTA_INSTANCE_NO:
2960 case DT_MIPS_DELTA_RELOC_NO:
2961 case DT_MIPS_DELTA_SYM_NO:
2962 case DT_MIPS_DELTA_CLASSSYM_NO:
2963 case DT_MIPS_COMPACT_SIZE:
2964 printf ("%ld\n", (long) entry->d_un.d_ptr);
2968 printf ("%#lx\n", (long) entry->d_un.d_ptr);
2974 dynamic_segment_parisc_val (entry)
2975 Elf_Internal_Dyn * entry;
2977 switch (entry->d_tag)
2979 case DT_HP_DLD_FLAGS:
2988 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
2989 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
2990 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
2991 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
2992 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
2993 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
2994 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
2995 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
2996 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
2997 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
2998 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3002 bfd_vma val = entry->d_un.d_val;
3004 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3005 if (val & flags[cnt].bit)
3009 fputs (flags[cnt].str, stdout);
3011 val ^= flags[cnt].bit;
3014 if (val != 0 || first)
3018 print_vma (val, HEX);
3024 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3030 get_32bit_dynamic_segment (file)
3033 Elf32_External_Dyn * edyn;
3034 Elf_Internal_Dyn * entry;
3037 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3038 edyn, Elf32_External_Dyn *, "dynamic segment");
3040 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3041 how large this .dynamic is now. We can do this even before the byte
3042 swapping since the DT_NULL tag is recognizable. */
3044 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3047 dynamic_segment = (Elf_Internal_Dyn *)
3048 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3050 if (dynamic_segment == NULL)
3052 error (_("Out of memory\n"));
3057 for (i = 0, entry = dynamic_segment;
3061 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3062 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3071 get_64bit_dynamic_segment (file)
3074 Elf64_External_Dyn * edyn;
3075 Elf_Internal_Dyn * entry;
3078 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3079 edyn, Elf64_External_Dyn *, "dynamic segment");
3081 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3082 how large this .dynamic is now. We can do this even before the byte
3083 swapping since the DT_NULL tag is recognizable. */
3085 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3088 dynamic_segment = (Elf_Internal_Dyn *)
3089 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3091 if (dynamic_segment == NULL)
3093 error (_("Out of memory\n"));
3098 for (i = 0, entry = dynamic_segment;
3102 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3103 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3112 get_dynamic_flags (flags)
3115 static char buff [64];
3120 flag = flags & - flags;
3125 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3126 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3127 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3128 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3129 default: strcat (buff, "unknown "); break;
3135 /* Parse and display the contents of the dynamic segment. */
3137 process_dynamic_segment (file)
3140 Elf_Internal_Dyn * entry;
3143 if (dynamic_size == 0)
3146 printf (_("\nThere is no dynamic segment in this file.\n"));
3153 if (! get_32bit_dynamic_segment (file))
3156 else if (! get_64bit_dynamic_segment (file))
3159 /* Find the appropriate symbol table. */
3160 if (dynamic_symbols == NULL)
3162 for (i = 0, entry = dynamic_segment;
3166 unsigned long offset;
3168 if (entry->d_tag != DT_SYMTAB)
3171 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3173 /* Since we do not know how big the symbol table is,
3174 we default to reading in the entire file (!) and
3175 processing that. This is overkill, I know, but it
3177 offset = entry->d_un.d_val - loadaddr;
3179 if (fseek (file, 0, SEEK_END))
3180 error (_("Unable to seek to end of file!"));
3183 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3185 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3187 if (num_dynamic_syms < 1)
3189 error (_("Unable to determine the number of symbols to load\n"));
3193 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3197 /* Similarly find a string table. */
3198 if (dynamic_strings == NULL)
3200 for (i = 0, entry = dynamic_segment;
3204 unsigned long offset;
3207 if (entry->d_tag != DT_STRTAB)
3210 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3212 /* Since we do not know how big the string table is,
3213 we default to reading in the entire file (!) and
3214 processing that. This is overkill, I know, but it
3217 offset = entry->d_un.d_val - loadaddr;
3218 if (fseek (file, 0, SEEK_END))
3219 error (_("Unable to seek to end of file\n"));
3220 str_tab_len = ftell (file) - offset;
3222 if (str_tab_len < 1)
3225 (_("Unable to determine the length of the dynamic string table\n"));
3229 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3230 "dynamic string table");
3236 /* And find the syminfo section if available. */
3237 if (dynamic_syminfo == NULL)
3239 unsigned int syminsz = 0;
3241 for (i = 0, entry = dynamic_segment;
3245 if (entry->d_tag == DT_SYMINENT)
3247 /* Note: these braces are necessary to avoid a syntax
3248 error from the SunOS4 C compiler. */
3249 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3251 else if (entry->d_tag == DT_SYMINSZ)
3252 syminsz = entry->d_un.d_val;
3253 else if (entry->d_tag == DT_SYMINFO)
3254 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3257 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3259 Elf_External_Syminfo * extsyminfo;
3260 Elf_Internal_Syminfo * syminfo;
3262 /* There is a syminfo section. Read the data. */
3263 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3264 Elf_External_Syminfo *, "symbol information");
3266 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3267 if (dynamic_syminfo == NULL)
3269 error (_("Out of memory\n"));
3273 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3274 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3277 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3278 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3285 if (do_dynamic && dynamic_addr)
3286 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3287 dynamic_addr, (long) dynamic_size);
3289 printf (_(" Tag Type Name/Value\n"));
3291 for (i = 0, entry = dynamic_segment;
3300 print_vma (entry->d_tag, FULL_HEX);
3301 dtype = get_dynamic_type (entry->d_tag);
3302 printf (" (%s)%*s", dtype,
3303 ((is_32bit_elf ? 27 : 19)
3304 - (int) strlen (dtype)),
3308 switch (entry->d_tag)
3312 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3319 if (entry->d_tag == DT_AUXILIARY)
3320 printf (_("Auxiliary library"));
3322 printf (_("Filter library"));
3324 if (dynamic_strings)
3325 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3329 print_vma (entry->d_un.d_val, PREFIX_HEX);
3338 printf (_("Flags:"));
3339 if (entry->d_un.d_val == 0)
3340 printf (_(" None\n"));
3343 unsigned long int val = entry->d_un.d_val;
3344 if (val & DTF_1_PARINIT)
3346 printf (" PARINIT");
3347 val ^= DTF_1_PARINIT;
3350 printf (" %lx", val);
3359 printf (_("Flags:"));
3360 if (entry->d_un.d_val == 0)
3361 printf (_(" None\n"));
3364 unsigned long int val = entry->d_un.d_val;
3365 if (val & DF_P1_LAZYLOAD)
3367 printf (" LAZYLOAD");
3368 val ^= DF_P1_LAZYLOAD;
3370 if (val & DF_P1_GROUPPERM)
3372 printf (" GROUPPERM");
3373 val ^= DF_P1_GROUPPERM;
3376 printf (" %lx", val);
3385 printf (_("Flags:"));
3386 if (entry->d_un.d_val == 0)
3387 printf (_(" None\n"));
3390 unsigned long int val = entry->d_un.d_val;
3396 if (val & DF_1_GLOBAL)
3401 if (val & DF_1_GROUP)
3406 if (val & DF_1_NODELETE)
3408 printf (" NODELETE");
3409 val ^= DF_1_NODELETE;
3411 if (val & DF_1_LOADFLTR)
3413 printf (" LOADFLTR");
3414 val ^= DF_1_LOADFLTR;
3416 if (val & DF_1_INITFIRST)
3418 printf (" INITFIRST");
3419 val ^= DF_1_INITFIRST;
3421 if (val & DF_1_NOOPEN)
3426 if (val & DF_1_ORIGIN)
3431 if (val & DF_1_DIRECT)
3436 if (val & DF_1_TRANS)
3441 if (val & DF_1_INTERPOSE)
3443 printf (" INTERPOSE");
3444 val ^= DF_1_INTERPOSE;
3447 printf (" %lx", val);
3455 puts (get_dynamic_type (entry->d_un.d_val));
3474 dynamic_info[entry->d_tag] = entry->d_un.d_val;
3480 if (dynamic_strings == NULL)
3483 name = dynamic_strings + entry->d_un.d_val;
3487 switch (entry->d_tag)
3490 printf (_("Shared library: [%s]"), name);
3492 if (strcmp (name, program_interpreter) == 0)
3493 printf (_(" program interpreter"));
3497 printf (_("Library soname: [%s]"), name);
3501 printf (_("Library rpath: [%s]"), name);
3505 print_vma (entry->d_un.d_val, PREFIX_HEX);
3510 print_vma (entry->d_un.d_val, PREFIX_HEX);
3526 case DT_INIT_ARRAYSZ:
3527 case DT_FINI_ARRAYSZ:
3530 print_vma (entry->d_un.d_val, UNSIGNED);
3531 printf (" (bytes)\n");
3541 print_vma (entry->d_un.d_val, UNSIGNED);
3554 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3558 name = dynamic_strings + entry->d_un.d_val;
3562 printf (_("Not needed object: [%s]\n"), name);
3567 print_vma (entry->d_un.d_val, PREFIX_HEX);
3573 /* The value of this entry is ignored. */
3577 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3578 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3583 switch (elf_header.e_machine)
3586 case EM_MIPS_RS4_BE:
3587 dynamic_segment_mips_val (entry);
3590 dynamic_segment_parisc_val (entry);
3593 print_vma (entry->d_un.d_val, PREFIX_HEX);
3605 get_ver_flags (flags)
3608 static char buff [32];
3615 if (flags & VER_FLG_BASE)
3616 strcat (buff, "BASE ");
3618 if (flags & VER_FLG_WEAK)
3620 if (flags & VER_FLG_BASE)
3621 strcat (buff, "| ");
3623 strcat (buff, "WEAK ");
3626 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3627 strcat (buff, "| <unknown>");
3632 /* Display the contents of the version sections. */
3634 process_version_sections (file)
3637 Elf32_Internal_Shdr * section;
3644 for (i = 0, section = section_headers;
3645 i < elf_header.e_shnum;
3648 switch (section->sh_type)
3650 case SHT_GNU_verdef:
3652 Elf_External_Verdef * edefs;
3659 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3660 SECTION_NAME (section), section->sh_info);
3662 printf (_(" Addr: 0x"));
3663 printf_vma (section->sh_addr);
3664 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3665 (unsigned long) section->sh_offset, section->sh_link,
3666 SECTION_NAME (section_headers + section->sh_link));
3668 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3669 edefs, Elf_External_Verdef *,
3670 "version definition section");
3672 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3675 Elf_External_Verdef * edef;
3676 Elf_Internal_Verdef ent;
3677 Elf_External_Verdaux * eaux;
3678 Elf_Internal_Verdaux aux;
3682 vstart = ((char *) edefs) + idx;
3684 edef = (Elf_External_Verdef *) vstart;
3686 ent.vd_version = BYTE_GET (edef->vd_version);
3687 ent.vd_flags = BYTE_GET (edef->vd_flags);
3688 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
3689 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
3690 ent.vd_hash = BYTE_GET (edef->vd_hash);
3691 ent.vd_aux = BYTE_GET (edef->vd_aux);
3692 ent.vd_next = BYTE_GET (edef->vd_next);
3694 printf (_(" %#06x: Rev: %d Flags: %s"),
3695 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3697 printf (_(" Index: %d Cnt: %d "),
3698 ent.vd_ndx, ent.vd_cnt);
3700 vstart += ent.vd_aux;
3702 eaux = (Elf_External_Verdaux *) vstart;
3704 aux.vda_name = BYTE_GET (eaux->vda_name);
3705 aux.vda_next = BYTE_GET (eaux->vda_next);
3707 if (dynamic_strings)
3708 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3710 printf (_("Name index: %ld\n"), aux.vda_name);
3712 isum = idx + ent.vd_aux;
3714 for (j = 1; j < ent.vd_cnt; j ++)
3716 isum += aux.vda_next;
3717 vstart += aux.vda_next;
3719 eaux = (Elf_External_Verdaux *) vstart;
3721 aux.vda_name = BYTE_GET (eaux->vda_name);
3722 aux.vda_next = BYTE_GET (eaux->vda_next);
3724 if (dynamic_strings)
3725 printf (_(" %#06x: Parent %d: %s\n"),
3726 isum, j, dynamic_strings + aux.vda_name);
3728 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3729 isum, j, aux.vda_name);
3739 case SHT_GNU_verneed:
3741 Elf_External_Verneed * eneed;
3747 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3748 SECTION_NAME (section), section->sh_info);
3750 printf (_(" Addr: 0x"));
3751 printf_vma (section->sh_addr);
3752 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3753 (unsigned long) section->sh_offset, section->sh_link,
3754 SECTION_NAME (section_headers + section->sh_link));
3756 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3757 eneed, Elf_External_Verneed *,
3758 "version need section");
3760 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3762 Elf_External_Verneed * entry;
3763 Elf_Internal_Verneed ent;
3768 vstart = ((char *) eneed) + idx;
3770 entry = (Elf_External_Verneed *) vstart;
3772 ent.vn_version = BYTE_GET (entry->vn_version);
3773 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
3774 ent.vn_file = BYTE_GET (entry->vn_file);
3775 ent.vn_aux = BYTE_GET (entry->vn_aux);
3776 ent.vn_next = BYTE_GET (entry->vn_next);
3778 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
3780 if (dynamic_strings)
3781 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
3783 printf (_(" File: %lx"), ent.vn_file);
3785 printf (_(" Cnt: %d\n"), ent.vn_cnt);
3787 vstart += ent.vn_aux;
3789 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3791 Elf_External_Vernaux * eaux;
3792 Elf_Internal_Vernaux aux;
3794 eaux = (Elf_External_Vernaux *) vstart;
3796 aux.vna_hash = BYTE_GET (eaux->vna_hash);
3797 aux.vna_flags = BYTE_GET (eaux->vna_flags);
3798 aux.vna_other = BYTE_GET (eaux->vna_other);
3799 aux.vna_name = BYTE_GET (eaux->vna_name);
3800 aux.vna_next = BYTE_GET (eaux->vna_next);
3802 if (dynamic_strings)
3803 printf (_(" %#06x: Name: %s"),
3804 isum, dynamic_strings + aux.vna_name);
3806 printf (_(" %#06x: Name index: %lx"),
3807 isum, aux.vna_name);
3809 printf (_(" Flags: %s Version: %d\n"),
3810 get_ver_flags (aux.vna_flags), aux.vna_other);
3812 isum += aux.vna_next;
3813 vstart += aux.vna_next;
3823 case SHT_GNU_versym:
3825 Elf32_Internal_Shdr * link_section;
3828 unsigned char * edata;
3829 unsigned short * data;
3831 Elf_Internal_Sym * symbols;
3832 Elf32_Internal_Shdr * string_sec;
3834 link_section = section_headers + section->sh_link;
3835 total = section->sh_size / section->sh_entsize;
3839 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3840 link_section->sh_size / link_section->sh_entsize);
3842 string_sec = section_headers + link_section->sh_link;
3844 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3845 strtab, char *, "version string table");
3847 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3848 SECTION_NAME (section), total);
3850 printf (_(" Addr: "));
3851 printf_vma (section->sh_addr);
3852 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3853 (unsigned long) section->sh_offset, section->sh_link,
3854 SECTION_NAME (link_section));
3856 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3858 total * sizeof (short), edata,
3859 unsigned char *, "version symbol data");
3861 data = (unsigned short *) malloc (total * sizeof (short));
3863 for (cnt = total; cnt --;)
3864 data [cnt] = byte_get (edata + cnt * sizeof (short),
3869 for (cnt = 0; cnt < total; cnt += 4)
3874 printf (" %03x:", cnt);
3876 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3877 switch (data [cnt + j])
3880 fputs (_(" 0 (*local*) "), stdout);
3884 fputs (_(" 1 (*global*) "), stdout);
3888 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
3889 data [cnt + j] & 0x8000 ? 'h' : ' ');
3891 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
3892 && section_headers[symbols [cnt + j].st_shndx].sh_type
3895 /* We must test both. */
3896 Elf_Internal_Verneed ivn;
3897 unsigned long offset;
3899 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3904 Elf_External_Verneed evn;
3905 Elf_External_Vernaux evna;
3906 Elf_Internal_Vernaux ivna;
3907 unsigned long vna_off;
3909 GET_DATA (offset, evn, "version need");
3911 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3912 ivn.vn_next = BYTE_GET (evn.vn_next);
3914 vna_off = offset + ivn.vn_aux;
3918 GET_DATA (vna_off, evna,
3919 "version need aux (1)");
3921 ivna.vna_next = BYTE_GET (evna.vna_next);
3922 ivna.vna_other = BYTE_GET (evna.vna_other);
3924 vna_off += ivna.vna_next;
3926 while (ivna.vna_other != data [cnt + j]
3927 && ivna.vna_next != 0);
3929 if (ivna.vna_other == data [cnt + j])
3931 ivna.vna_name = BYTE_GET (evna.vna_name);
3933 name = strtab + ivna.vna_name;
3934 nn += printf ("(%s%-*s",
3936 12 - (int) strlen (name),
3940 else if (ivn.vn_next == 0)
3942 if (data [cnt + j] != 0x8001)
3944 Elf_Internal_Verdef ivd;
3945 Elf_External_Verdef evd;
3947 offset = version_info
3948 [DT_VERSIONTAGIDX (DT_VERDEF)]
3953 GET_DATA (offset, evd,
3954 "version definition");
3956 ivd.vd_next = BYTE_GET (evd.vd_next);
3957 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
3959 offset += ivd.vd_next;
3962 != (data [cnt + j] & 0x7fff)
3963 && ivd.vd_next != 0);
3966 == (data [cnt + j] & 0x7fff))
3968 Elf_External_Verdaux evda;
3969 Elf_Internal_Verdaux ivda;
3971 ivd.vd_aux = BYTE_GET (evd.vd_aux);
3973 GET_DATA (offset + ivd.vd_aux, evda,
3974 "version definition aux");
3977 BYTE_GET (evda.vda_name);
3979 name = strtab + ivda.vda_name;
3983 12 - (int) strlen (name),
3991 offset += ivn.vn_next;
3993 while (ivn.vn_next);
3995 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
3997 Elf_Internal_Verneed ivn;
3998 unsigned long offset;
4000 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4005 Elf_Internal_Vernaux ivna;
4006 Elf_External_Verneed evn;
4007 Elf_External_Vernaux evna;
4008 unsigned long a_off;
4010 GET_DATA (offset, evn, "version need");
4012 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4013 ivn.vn_next = BYTE_GET (evn.vn_next);
4015 a_off = offset + ivn.vn_aux;
4019 GET_DATA (a_off, evna,
4020 "version need aux (2)");
4022 ivna.vna_next = BYTE_GET (evna.vna_next);
4023 ivna.vna_other = BYTE_GET (evna.vna_other);
4025 a_off += ivna.vna_next;
4027 while (ivna.vna_other != data [cnt + j]
4028 && ivna.vna_next != 0);
4030 if (ivna.vna_other == data [cnt + j])
4032 ivna.vna_name = BYTE_GET (evna.vna_name);
4034 name = strtab + ivna.vna_name;
4035 nn += printf ("(%s%-*s",
4037 12 - (int) strlen (name),
4042 offset += ivn.vn_next;
4044 while (ivn.vn_next);
4046 else if (data [cnt + j] != 0x8001)
4048 Elf_Internal_Verdef ivd;
4049 Elf_External_Verdef evd;
4050 unsigned long offset;
4052 offset = version_info
4053 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4057 GET_DATA (offset, evd, "version def");
4059 ivd.vd_next = BYTE_GET (evd.vd_next);
4060 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4062 offset += ivd.vd_next;
4064 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4065 && ivd.vd_next != 0);
4067 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4069 Elf_External_Verdaux evda;
4070 Elf_Internal_Verdaux ivda;
4072 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4074 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4075 evda, "version def aux");
4077 ivda.vda_name = BYTE_GET (evda.vda_name);
4079 name = strtab + ivda.vda_name;
4080 nn += printf ("(%s%-*s",
4082 12 - (int) strlen (name),
4088 printf ("%*c", 18 - nn, ' ');
4106 printf (_("\nNo version information found in this file.\n"));
4112 get_symbol_binding (binding)
4113 unsigned int binding;
4115 static char buff [32];
4119 case STB_LOCAL: return "LOCAL";
4120 case STB_GLOBAL: return "GLOBAL";
4121 case STB_WEAK: return "WEAK";
4123 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4124 sprintf (buff, _("<processor specific>: %d"), binding);
4125 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4126 sprintf (buff, _("<OS specific>: %d"), binding);
4128 sprintf (buff, _("<unknown>: %d"), binding);
4134 get_symbol_type (type)
4137 static char buff [32];
4141 case STT_NOTYPE: return "NOTYPE";
4142 case STT_OBJECT: return "OBJECT";
4143 case STT_FUNC: return "FUNC";
4144 case STT_SECTION: return "SECTION";
4145 case STT_FILE: return "FILE";
4146 case STT_COMMON: return "COMMON";
4148 if (type >= STT_LOPROC && type <= STT_HIPROC)
4150 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4151 return "THUMB_FUNC";
4153 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4156 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4157 return "PARISC_MILLI";
4159 sprintf (buff, _("<processor specific>: %d"), type);
4161 else if (type >= STT_LOOS && type <= STT_HIOS)
4163 if (elf_header.e_machine == EM_PARISC)
4165 if (type == STT_HP_OPAQUE)
4167 if (type == STT_HP_STUB)
4171 sprintf (buff, _("<OS specific>: %d"), type);
4174 sprintf (buff, _("<unknown>: %d"), type);
4180 get_symbol_visibility (visibility)
4181 unsigned int visibility;
4185 case STV_DEFAULT: return "DEFAULT";
4186 case STV_INTERNAL: return "INTERNAL";
4187 case STV_HIDDEN: return "HIDDEN";
4188 case STV_PROTECTED: return "PROTECTED";
4194 get_symbol_index_type (type)
4199 case SHN_UNDEF: return "UND";
4200 case SHN_ABS: return "ABS";
4201 case SHN_COMMON: return "COM";
4203 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4205 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4207 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4211 static char buff [32];
4213 sprintf (buff, "%3d", type);
4220 get_dynamic_data (file, number)
4222 unsigned int number;
4227 e_data = (char *) malloc (number * 4);
4231 error (_("Out of memory\n"));
4235 if (fread (e_data, 4, number, file) != number)
4237 error (_("Unable to read in dynamic data\n"));
4241 i_data = (int *) malloc (number * sizeof (* i_data));
4245 error (_("Out of memory\n"));
4251 i_data [number] = byte_get (e_data + number * 4, 4);
4258 /* Dump the symbol table */
4260 process_symbol_table (file)
4263 Elf32_Internal_Shdr * section;
4268 int * buckets = NULL;
4269 int * chains = NULL;
4271 if (! do_syms && !do_histogram)
4274 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4277 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4279 error (_("Unable to seek to start of dynamic information"));
4283 if (fread (nb, sizeof (nb), 1, file) != 1)
4285 error (_("Failed to read in number of buckets\n"));
4289 if (fread (nc, sizeof (nc), 1, file) != 1)
4291 error (_("Failed to read in number of chains\n"));
4295 nbuckets = byte_get (nb, 4);
4296 nchains = byte_get (nc, 4);
4298 buckets = get_dynamic_data (file, nbuckets);
4299 chains = get_dynamic_data (file, nchains);
4301 if (buckets == NULL || chains == NULL)
4306 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4311 printf (_("\nSymbol table for image:\n"));
4313 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4315 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4317 for (hn = 0; hn < nbuckets; hn++)
4322 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4324 Elf_Internal_Sym * psym;
4326 psym = dynamic_symbols + si;
4328 printf (" %3d %3d: ", si, hn);
4329 print_vma (psym->st_value, LONG_HEX);
4331 print_vma (psym->st_size, DEC_5);
4333 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4334 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4335 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4336 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4337 printf (" %s\n", dynamic_strings + psym->st_name);
4341 else if (do_syms && !do_using_dynamic)
4345 for (i = 0, section = section_headers;
4346 i < elf_header.e_shnum;
4351 Elf_Internal_Sym * symtab;
4352 Elf_Internal_Sym * psym;
4355 if ( section->sh_type != SHT_SYMTAB
4356 && section->sh_type != SHT_DYNSYM)
4359 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4360 SECTION_NAME (section),
4361 (unsigned long) (section->sh_size / section->sh_entsize));
4363 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4365 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4367 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4368 section->sh_size / section->sh_entsize);
4372 if (section->sh_link == elf_header.e_shstrndx)
4373 strtab = string_table;
4376 Elf32_Internal_Shdr * string_sec;
4378 string_sec = section_headers + section->sh_link;
4380 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4381 strtab, char *, "string table");
4384 for (si = 0, psym = symtab;
4385 si < section->sh_size / section->sh_entsize;
4388 printf ("%6d: ", si);
4389 print_vma (psym->st_value, LONG_HEX);
4391 print_vma (psym->st_size, DEC_5);
4392 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4393 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4394 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4395 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4396 printf (" %s", strtab + psym->st_name);
4398 if (section->sh_type == SHT_DYNSYM &&
4399 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4401 unsigned char data[2];
4402 unsigned short vers_data;
4403 unsigned long offset;
4407 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4410 GET_DATA (offset + si * sizeof (vers_data), data,
4413 vers_data = byte_get (data, 2);
4415 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4416 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4419 check_def = (psym->st_shndx != SHN_UNDEF);
4421 if ((vers_data & 0x8000) || vers_data > 1)
4423 if (is_nobits || ! check_def)
4425 Elf_External_Verneed evn;
4426 Elf_Internal_Verneed ivn;
4427 Elf_Internal_Vernaux ivna;
4429 /* We must test both. */
4430 offset = version_info
4431 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4435 unsigned long vna_off;
4437 GET_DATA (offset, evn, "version need");
4439 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4440 ivn.vn_next = BYTE_GET (evn.vn_next);
4442 vna_off = offset + ivn.vn_aux;
4446 Elf_External_Vernaux evna;
4448 GET_DATA (vna_off, evna,
4449 "version need aux (3)");
4451 ivna.vna_other = BYTE_GET (evna.vna_other);
4452 ivna.vna_next = BYTE_GET (evna.vna_next);
4453 ivna.vna_name = BYTE_GET (evna.vna_name);
4455 vna_off += ivna.vna_next;
4457 while (ivna.vna_other != vers_data
4458 && ivna.vna_next != 0);
4460 if (ivna.vna_other == vers_data)
4463 offset += ivn.vn_next;
4465 while (ivn.vn_next != 0);
4467 if (ivna.vna_other == vers_data)
4470 strtab + ivna.vna_name, ivna.vna_other);
4473 else if (! is_nobits)
4474 error (_("bad dynamic symbol"));
4481 if (vers_data != 0x8001)
4483 Elf_Internal_Verdef ivd;
4484 Elf_Internal_Verdaux ivda;
4485 Elf_External_Verdaux evda;
4486 unsigned long offset;
4489 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4494 Elf_External_Verdef evd;
4496 GET_DATA (offset, evd, "version def");
4498 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4499 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4500 ivd.vd_next = BYTE_GET (evd.vd_next);
4502 offset += ivd.vd_next;
4504 while (ivd.vd_ndx != (vers_data & 0x7fff)
4505 && ivd.vd_next != 0);
4507 offset -= ivd.vd_next;
4508 offset += ivd.vd_aux;
4510 GET_DATA (offset, evda, "version def aux");
4512 ivda.vda_name = BYTE_GET (evda.vda_name);
4514 if (psym->st_name != ivda.vda_name)
4515 printf ((vers_data & 0x8000)
4517 strtab + ivda.vda_name);
4527 if (strtab != string_table)
4533 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4535 if (do_histogram && buckets != NULL)
4542 int nzero_counts = 0;
4545 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4547 printf (_(" Length Number %% of total Coverage\n"));
4549 lengths = (int *) calloc (nbuckets, sizeof (int));
4550 if (lengths == NULL)
4552 error (_("Out of memory"));
4555 for (hn = 0; hn < nbuckets; ++hn)
4560 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4563 if (maxlength < ++lengths[hn])
4568 counts = (int *) calloc (maxlength + 1, sizeof (int));
4571 error (_("Out of memory"));
4575 for (hn = 0; hn < nbuckets; ++hn)
4576 ++ counts [lengths [hn]];
4580 printf (" 0 %-10d (%5.1f%%)\n",
4581 counts[0], (counts[0] * 100.0) / nbuckets);
4582 for (si = 1; si <= maxlength; ++si)
4584 nzero_counts += counts[si] * si;
4585 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4586 si, counts[si], (counts[si] * 100.0) / nbuckets,
4587 (nzero_counts * 100.0) / nsyms);
4595 if (buckets != NULL)
4605 process_syminfo (file)
4606 FILE * file ATTRIBUTE_UNUSED;
4610 if (dynamic_syminfo == NULL
4612 /* No syminfo, this is ok. */
4615 /* There better should be a dynamic symbol section. */
4616 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4620 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4621 dynamic_syminfo_offset, dynamic_syminfo_nent);
4623 printf (_(" Num: Name BoundTo Flags\n"));
4624 for (i = 0; i < dynamic_syminfo_nent; ++i)
4626 unsigned short int flags = dynamic_syminfo[i].si_flags;
4628 printf ("%4d: %-30s ", i,
4629 dynamic_strings + dynamic_symbols[i].st_name);
4631 switch (dynamic_syminfo[i].si_boundto)
4633 case SYMINFO_BT_SELF:
4634 fputs ("SELF ", stdout);
4636 case SYMINFO_BT_PARENT:
4637 fputs ("PARENT ", stdout);
4640 if (dynamic_syminfo[i].si_boundto > 0
4641 && dynamic_syminfo[i].si_boundto < dynamic_size)
4644 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4646 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4650 if (flags & SYMINFO_FLG_DIRECT)
4652 if (flags & SYMINFO_FLG_PASSTHRU)
4653 printf (" PASSTHRU");
4654 if (flags & SYMINFO_FLG_COPY)
4656 if (flags & SYMINFO_FLG_LAZYLOAD)
4657 printf (" LAZYLOAD");
4665 #ifdef SUPPORT_DISASSEMBLY
4667 disassemble_section (section, file)
4668 Elf32_Internal_Shdr * section;
4671 printf (_("\nAssembly dump of section %s\n"),
4672 SECTION_NAME (section));
4674 /* XXX -- to be done --- XXX */
4681 dump_section (section, file)
4682 Elf32_Internal_Shdr * section;
4685 bfd_size_type bytes;
4687 unsigned char * data;
4688 unsigned char * start;
4690 bytes = section->sh_size;
4694 printf (_("\nSection '%s' has no data to dump.\n"),
4695 SECTION_NAME (section));
4699 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4701 addr = section->sh_addr;
4703 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4714 lbytes = (bytes > 16 ? 16 : bytes);
4716 printf (" 0x%8.8lx ", (unsigned long) addr);
4718 switch (elf_header.e_ident [EI_DATA])
4722 for (j = 15; j >= 0; j --)
4725 printf ("%2.2x", data [j]);
4735 for (j = 0; j < 16; j++)
4738 printf ("%2.2x", data [j]);
4748 for (j = 0; j < lbytes; j++)
4751 if (k >= ' ' && k < 0x80)
4770 static unsigned long int
4771 read_leb128 (data, length_return, sign)
4772 unsigned char * data;
4773 int * length_return;
4776 unsigned long int result = 0;
4777 unsigned int num_read = 0;
4786 result |= (byte & 0x7f) << shift;
4791 while (byte & 0x80);
4793 if (length_return != NULL)
4794 * length_return = num_read;
4796 if (sign && (shift < 32) && (byte & 0x40))
4797 result |= -1 << shift;
4802 typedef struct State_Machine_Registers
4804 unsigned long address;
4807 unsigned int column;
4811 /* This variable hold the number of the last entry seen
4812 in the File Table. */
4813 unsigned int last_file_entry;
4816 static SMR state_machine_regs;
4819 reset_state_machine (is_stmt)
4822 state_machine_regs.address = 0;
4823 state_machine_regs.file = 1;
4824 state_machine_regs.line = 1;
4825 state_machine_regs.column = 0;
4826 state_machine_regs.is_stmt = is_stmt;
4827 state_machine_regs.basic_block = 0;
4828 state_machine_regs.end_sequence = 0;
4829 state_machine_regs.last_file_entry = 0;
4832 /* Handled an extend line op. Returns true if this is the end
4835 process_extended_line_op (data, is_stmt, pointer_size)
4836 unsigned char * data;
4840 unsigned char op_code;
4843 unsigned char * name;
4846 len = read_leb128 (data, & bytes_read, 0);
4851 warn (_("badly formed extended line op encountered!"));
4856 op_code = * data ++;
4858 printf (_(" Extended opcode %d: "), op_code);
4862 case DW_LNE_end_sequence:
4863 printf (_("End of Sequence\n\n"));
4864 reset_state_machine (is_stmt);
4867 case DW_LNE_set_address:
4868 adr = byte_get (data, pointer_size);
4869 printf (_("set Address to 0x%lx\n"), adr);
4870 state_machine_regs.address = adr;
4873 case DW_LNE_define_file:
4874 printf (_(" define new File Table entry\n"));
4875 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4877 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4879 data += strlen (data) + 1;
4880 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4882 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4884 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4885 printf (_("%s\n\n"), name);
4889 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
4896 /* Size of pointers in the .debug_line section. This information is not
4897 really present in that section. It's obtained before dumping the debug
4898 sections by doing some pre-scan of the .debug_info section. */
4899 static int debug_line_pointer_size = 4;
4902 display_debug_lines (section, start, file)
4903 Elf32_Internal_Shdr * section;
4904 unsigned char * start;
4905 FILE * file ATTRIBUTE_UNUSED;
4907 DWARF2_External_LineInfo * external;
4908 DWARF2_Internal_LineInfo info;
4909 unsigned char * standard_opcodes;
4910 unsigned char * data = start;
4911 unsigned char * end = start + section->sh_size;
4912 unsigned char * end_of_sequence;
4915 printf (_("\nDump of debug contents of section %s:\n\n"),
4916 SECTION_NAME (section));
4920 external = (DWARF2_External_LineInfo *) data;
4922 /* Check the length of the block. */
4923 info.li_length = BYTE_GET (external->li_length);
4924 if (info.li_length > section->sh_size)
4927 (_("The line info appears to be corrupt - the section is too small\n"));
4931 /* Check its version number. */
4932 info.li_version = BYTE_GET (external->li_version);
4933 if (info.li_version != 2)
4935 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4939 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
4940 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
4941 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
4942 info.li_line_base = BYTE_GET (external->li_line_base);
4943 info.li_line_range = BYTE_GET (external->li_line_range);
4944 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
4946 /* Sign extend the line base field. */
4947 info.li_line_base <<= 24;
4948 info.li_line_base >>= 24;
4950 printf (_(" Length: %ld\n"), info.li_length);
4951 printf (_(" DWARF Version: %d\n"), info.li_version);
4952 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
4953 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
4954 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
4955 printf (_(" Line Base: %d\n"), info.li_line_base);
4956 printf (_(" Line Range: %d\n"), info.li_line_range);
4957 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
4959 end_of_sequence = data + info.li_length + sizeof (info.li_length);
4961 reset_state_machine (info.li_default_is_stmt);
4963 /* Display the contents of the Opcodes table. */
4964 standard_opcodes = data + sizeof (* external);
4966 printf (_("\n Opcodes:\n"));
4968 for (i = 1; i < info.li_opcode_base; i++)
4969 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
4971 /* Display the contents of the Directory table. */
4972 data = standard_opcodes + info.li_opcode_base - 1;
4975 printf (_("\n The Directory Table is empty.\n"));
4978 printf (_("\n The Directory Table:\n"));
4982 printf (_(" %s\n"), data);
4984 data += strlen (data) + 1;
4988 /* Skip the NUL at the end of the table. */
4991 /* Display the contents of the File Name table. */
4993 printf (_("\n The File Name Table is empty.\n"));
4996 printf (_("\n The File Name Table:\n"));
4997 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5004 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5007 data += strlen (data) + 1;
5009 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5011 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5013 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5015 printf (_("%s\n"), name);
5019 /* Skip the NUL at the end of the table. */
5022 /* Now display the statements. */
5023 printf (_("\n Line Number Statements:\n"));
5026 while (data < end_of_sequence)
5028 unsigned char op_code;
5032 op_code = * data ++;
5036 case DW_LNS_extended_op:
5037 data += process_extended_line_op (data, info.li_default_is_stmt,
5038 debug_line_pointer_size);
5042 printf (_(" Copy\n"));
5045 case DW_LNS_advance_pc:
5046 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5048 state_machine_regs.address += adv;
5049 printf (_(" Advance PC by %d to %lx\n"), adv,
5050 state_machine_regs.address);
5053 case DW_LNS_advance_line:
5054 adv = read_leb128 (data, & bytes_read, 1);
5056 state_machine_regs.line += adv;
5057 printf (_(" Advance Line by %d to %d\n"), adv,
5058 state_machine_regs.line);
5061 case DW_LNS_set_file:
5062 adv = read_leb128 (data, & bytes_read, 0);
5064 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5066 state_machine_regs.file = adv;
5069 case DW_LNS_set_column:
5070 adv = read_leb128 (data, & bytes_read, 0);
5072 printf (_(" Set column to %d\n"), adv);
5073 state_machine_regs.column = adv;
5076 case DW_LNS_negate_stmt:
5077 adv = state_machine_regs.is_stmt;
5079 printf (_(" Set is_stmt to %d\n"), adv);
5080 state_machine_regs.is_stmt = adv;
5083 case DW_LNS_set_basic_block:
5084 printf (_(" Set basic block\n"));
5085 state_machine_regs.basic_block = 1;
5088 case DW_LNS_const_add_pc:
5089 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5090 * info.li_min_insn_length);
5091 state_machine_regs.address += adv;
5092 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5093 state_machine_regs.address);
5096 case DW_LNS_fixed_advance_pc:
5097 adv = byte_get (data, 2);
5099 state_machine_regs.address += adv;
5100 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5101 adv, state_machine_regs.address);
5105 op_code -= info.li_opcode_base;
5106 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5107 state_machine_regs.address += adv;
5108 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5109 op_code, adv, state_machine_regs.address);
5110 adv = (op_code % info.li_line_range) + info.li_line_base;
5111 state_machine_regs.line += adv;
5112 printf (_(" and Line by %d to %d\n"),
5113 adv, state_machine_regs.line);
5124 display_debug_pubnames (section, start, file)
5125 Elf32_Internal_Shdr * section;
5126 unsigned char * start;
5127 FILE * file ATTRIBUTE_UNUSED;
5129 DWARF2_External_PubNames * external;
5130 DWARF2_Internal_PubNames pubnames;
5131 unsigned char * end;
5133 end = start + section->sh_size;
5135 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5139 unsigned char * data;
5140 unsigned long offset;
5142 external = (DWARF2_External_PubNames *) start;
5144 pubnames.pn_length = BYTE_GET (external->pn_length);
5145 pubnames.pn_version = BYTE_GET (external->pn_version);
5146 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5147 pubnames.pn_size = BYTE_GET (external->pn_size);
5149 data = start + sizeof (* external);
5150 start += pubnames.pn_length + sizeof (external->pn_length);
5152 if (pubnames.pn_version != 2)
5154 warn (_("Only DWARF 2 pubnames are currently supported"));
5158 printf (_(" Length: %ld\n"),
5159 pubnames.pn_length);
5160 printf (_(" Version: %d\n"),
5161 pubnames.pn_version);
5162 printf (_(" Offset into .debug_info section: %ld\n"),
5163 pubnames.pn_offset);
5164 printf (_(" Size of area in .debug_info section: %ld\n"),
5167 printf (_("\n Offset\tName\n"));
5171 offset = byte_get (data, 4);
5176 printf (" %ld\t\t%s\n", offset, data);
5177 data += strlen (data) + 1;
5180 while (offset != 0);
5193 case DW_TAG_padding: return "DW_TAG_padding";
5194 case DW_TAG_array_type: return "DW_TAG_array_type";
5195 case DW_TAG_class_type: return "DW_TAG_class_type";
5196 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5197 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5198 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5199 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5200 case DW_TAG_label: return "DW_TAG_label";
5201 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5202 case DW_TAG_member: return "DW_TAG_member";
5203 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5204 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5205 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5206 case DW_TAG_string_type: return "DW_TAG_string_type";
5207 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5208 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5209 case DW_TAG_typedef: return "DW_TAG_typedef";
5210 case DW_TAG_union_type: return "DW_TAG_union_type";
5211 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5212 case DW_TAG_variant: return "DW_TAG_variant";
5213 case DW_TAG_common_block: return "DW_TAG_common_block";
5214 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5215 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5216 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5217 case DW_TAG_module: return "DW_TAG_module";
5218 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5219 case DW_TAG_set_type: return "DW_TAG_set_type";
5220 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5221 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5222 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5223 case DW_TAG_base_type: return "DW_TAG_base_type";
5224 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5225 case DW_TAG_const_type: return "DW_TAG_const_type";
5226 case DW_TAG_constant: return "DW_TAG_constant";
5227 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5228 case DW_TAG_file_type: return "DW_TAG_file_type";
5229 case DW_TAG_friend: return "DW_TAG_friend";
5230 case DW_TAG_namelist: return "DW_TAG_namelist";
5231 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5232 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5233 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5234 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5235 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5236 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5237 case DW_TAG_try_block: return "DW_TAG_try_block";
5238 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5239 case DW_TAG_variable: return "DW_TAG_variable";
5240 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5241 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5242 case DW_TAG_format_label: return "DW_TAG_format_label";
5243 case DW_TAG_function_template: return "DW_TAG_function_template";
5244 case DW_TAG_class_template: return "DW_TAG_class_template";
5247 static char buffer [100];
5249 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5256 get_AT_name (attribute)
5257 unsigned long attribute;
5261 case DW_AT_sibling: return "DW_AT_sibling";
5262 case DW_AT_location: return "DW_AT_location";
5263 case DW_AT_name: return "DW_AT_name";
5264 case DW_AT_ordering: return "DW_AT_ordering";
5265 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5266 case DW_AT_byte_size: return "DW_AT_byte_size";
5267 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5268 case DW_AT_bit_size: return "DW_AT_bit_size";
5269 case DW_AT_element_list: return "DW_AT_element_list";
5270 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5271 case DW_AT_low_pc: return "DW_AT_low_pc";
5272 case DW_AT_high_pc: return "DW_AT_high_pc";
5273 case DW_AT_language: return "DW_AT_language";
5274 case DW_AT_member: return "DW_AT_member";
5275 case DW_AT_discr: return "DW_AT_discr";
5276 case DW_AT_discr_value: return "DW_AT_discr_value";
5277 case DW_AT_visibility: return "DW_AT_visibility";
5278 case DW_AT_import: return "DW_AT_import";
5279 case DW_AT_string_length: return "DW_AT_string_length";
5280 case DW_AT_common_reference: return "DW_AT_common_reference";
5281 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5282 case DW_AT_const_value: return "DW_AT_const_value";
5283 case DW_AT_containing_type: return "DW_AT_containing_type";
5284 case DW_AT_default_value: return "DW_AT_default_value";
5285 case DW_AT_inline: return "DW_AT_inline";
5286 case DW_AT_is_optional: return "DW_AT_is_optional";
5287 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5288 case DW_AT_producer: return "DW_AT_producer";
5289 case DW_AT_prototyped: return "DW_AT_prototyped";
5290 case DW_AT_return_addr: return "DW_AT_return_addr";
5291 case DW_AT_start_scope: return "DW_AT_start_scope";
5292 case DW_AT_stride_size: return "DW_AT_stride_size";
5293 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5294 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5295 case DW_AT_accessibility: return "DW_AT_accessibility";
5296 case DW_AT_address_class: return "DW_AT_address_class";
5297 case DW_AT_artificial: return "DW_AT_artificial";
5298 case DW_AT_base_types: return "DW_AT_base_types";
5299 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5300 case DW_AT_count: return "DW_AT_count";
5301 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5302 case DW_AT_decl_column: return "DW_AT_decl_column";
5303 case DW_AT_decl_file: return "DW_AT_decl_file";
5304 case DW_AT_decl_line: return "DW_AT_decl_line";
5305 case DW_AT_declaration: return "DW_AT_declaration";
5306 case DW_AT_discr_list: return "DW_AT_discr_list";
5307 case DW_AT_encoding: return "DW_AT_encoding";
5308 case DW_AT_external: return "DW_AT_external";
5309 case DW_AT_frame_base: return "DW_AT_frame_base";
5310 case DW_AT_friend: return "DW_AT_friend";
5311 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5312 case DW_AT_macro_info: return "DW_AT_macro_info";
5313 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5314 case DW_AT_priority: return "DW_AT_priority";
5315 case DW_AT_segment: return "DW_AT_segment";
5316 case DW_AT_specification: return "DW_AT_specification";
5317 case DW_AT_static_link: return "DW_AT_static_link";
5318 case DW_AT_type: return "DW_AT_type";
5319 case DW_AT_use_location: return "DW_AT_use_location";
5320 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5321 case DW_AT_virtuality: return "DW_AT_virtuality";
5322 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5323 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5324 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5325 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5326 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5327 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5328 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5329 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5330 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5331 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5332 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5333 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5334 case DW_AT_sf_names: return "DW_AT_sf_names";
5335 case DW_AT_src_info: return "DW_AT_src_info";
5336 case DW_AT_mac_info: return "DW_AT_mac_info";
5337 case DW_AT_src_coords: return "DW_AT_src_coords";
5338 case DW_AT_body_begin: return "DW_AT_body_begin";
5339 case DW_AT_body_end: return "DW_AT_body_end";
5342 static char buffer [100];
5344 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5351 get_FORM_name (form)
5356 case DW_FORM_addr: return "DW_FORM_addr";
5357 case DW_FORM_block2: return "DW_FORM_block2";
5358 case DW_FORM_block4: return "DW_FORM_block4";
5359 case DW_FORM_data2: return "DW_FORM_data2";
5360 case DW_FORM_data4: return "DW_FORM_data4";
5361 case DW_FORM_data8: return "DW_FORM_data8";
5362 case DW_FORM_string: return "DW_FORM_string";
5363 case DW_FORM_block: return "DW_FORM_block";
5364 case DW_FORM_block1: return "DW_FORM_block1";
5365 case DW_FORM_data1: return "DW_FORM_data1";
5366 case DW_FORM_flag: return "DW_FORM_flag";
5367 case DW_FORM_sdata: return "DW_FORM_sdata";
5368 case DW_FORM_strp: return "DW_FORM_strp";
5369 case DW_FORM_udata: return "DW_FORM_udata";
5370 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5371 case DW_FORM_ref1: return "DW_FORM_ref1";
5372 case DW_FORM_ref2: return "DW_FORM_ref2";
5373 case DW_FORM_ref4: return "DW_FORM_ref4";
5374 case DW_FORM_ref8: return "DW_FORM_ref8";
5375 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5376 case DW_FORM_indirect: return "DW_FORM_indirect";
5379 static char buffer [100];
5381 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5387 /* FIXME: There are better and more effiecint ways to handle
5388 these structures. For now though, I just want something that
5389 is simple to implement. */
5390 typedef struct abbrev_attr
5392 unsigned long attribute;
5394 struct abbrev_attr * next;
5398 typedef struct abbrev_entry
5400 unsigned long entry;
5403 struct abbrev_attr * first_attr;
5404 struct abbrev_attr * last_attr;
5405 struct abbrev_entry * next;
5409 static abbrev_entry * first_abbrev = NULL;
5410 static abbrev_entry * last_abbrev = NULL;
5413 free_abbrevs PARAMS ((void))
5415 abbrev_entry * abbrev;
5417 for (abbrev = first_abbrev; abbrev;)
5419 abbrev_entry * next = abbrev->next;
5422 for (attr = abbrev->first_attr; attr;)
5424 abbrev_attr * next = attr->next;
5434 last_abbrev = first_abbrev = NULL;
5438 add_abbrev (number, tag, children)
5439 unsigned long number;
5443 abbrev_entry * entry;
5445 entry = (abbrev_entry *) malloc (sizeof (* entry));
5451 entry->entry = number;
5453 entry->children = children;
5454 entry->first_attr = NULL;
5455 entry->last_attr = NULL;
5458 if (first_abbrev == NULL)
5459 first_abbrev = entry;
5461 last_abbrev->next = entry;
5463 last_abbrev = entry;
5467 add_abbrev_attr (attribute, form)
5468 unsigned long attribute;
5473 attr = (abbrev_attr *) malloc (sizeof (* attr));
5479 attr->attribute = attribute;
5483 if (last_abbrev->first_attr == NULL)
5484 last_abbrev->first_attr = attr;
5486 last_abbrev->last_attr->next = attr;
5488 last_abbrev->last_attr = attr;
5491 /* Processes the (partial) contents of a .debug_abbrev section.
5492 Returns NULL if the end of the section was encountered.
5493 Returns the address after the last byte read if the end of
5494 an abbreviation set was found. */
5496 static unsigned char *
5497 process_abbrev_section (start, end)
5498 unsigned char * start;
5499 unsigned char * end;
5501 if (first_abbrev != NULL)
5507 unsigned long entry;
5509 unsigned long attribute;
5512 entry = read_leb128 (start, & bytes_read, 0);
5513 start += bytes_read;
5515 /* A single zero is supposed to end the section according
5516 to the standard. If there's more, then signal that to
5519 return start == end ? NULL : start;
5521 tag = read_leb128 (start, & bytes_read, 0);
5522 start += bytes_read;
5524 children = * start ++;
5526 add_abbrev (entry, tag, children);
5532 attribute = read_leb128 (start, & bytes_read, 0);
5533 start += bytes_read;
5535 form = read_leb128 (start, & bytes_read, 0);
5536 start += bytes_read;
5539 add_abbrev_attr (attribute, form);
5541 while (attribute != 0);
5549 display_debug_abbrev (section, start, file)
5550 Elf32_Internal_Shdr * section;
5551 unsigned char * start;
5552 FILE * file ATTRIBUTE_UNUSED;
5554 abbrev_entry * entry;
5555 unsigned char * end = start + section->sh_size;
5557 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5561 start = process_abbrev_section (start, end);
5563 printf (_(" Number TAG\n"));
5565 for (entry = first_abbrev; entry; entry = entry->next)
5569 printf (_(" %ld %s [%s]\n"),
5571 get_TAG_name (entry->tag),
5572 entry->children ? _("has children") : _("no children"));
5574 for (attr = entry->first_attr; attr; attr = attr->next)
5576 printf (_(" %-18s %s\n"),
5577 get_AT_name (attr->attribute),
5578 get_FORM_name (attr->form));
5590 static unsigned char *
5591 display_block (data, length)
5592 unsigned char * data;
5593 unsigned long length;
5595 printf (_(" %lu byte block: "), length);
5598 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5604 decode_location_expression (data, pointer_size, length)
5605 unsigned char * data;
5606 unsigned int pointer_size;
5607 unsigned long length;
5611 unsigned long uvalue;
5612 unsigned char *end = data + length;
5621 printf ("DW_OP_addr: %lx",
5622 (unsigned long) byte_get (data, pointer_size));
5623 data += pointer_size;
5626 printf ("DW_OP_deref");
5629 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
5632 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
5635 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5639 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5643 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5647 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5651 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5652 (unsigned long) byte_get (data + 4, 4));
5656 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5657 (long) byte_get (data + 4, 4));
5661 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
5665 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
5669 printf ("DW_OP_dup");
5672 printf ("DW_OP_drop");
5675 printf ("DW_OP_over");
5678 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
5681 printf ("DW_OP_swap");
5684 printf ("DW_OP_rot");
5687 printf ("DW_OP_xderef");
5690 printf ("DW_OP_abs");
5693 printf ("DW_OP_and");
5696 printf ("DW_OP_div");
5699 printf ("DW_OP_minus");
5702 printf ("DW_OP_mod");
5705 printf ("DW_OP_mul");
5708 printf ("DW_OP_neg");
5711 printf ("DW_OP_not");
5714 printf ("DW_OP_or");
5717 printf ("DW_OP_plus");
5719 case DW_OP_plus_uconst:
5720 printf ("DW_OP_plus_uconst: %lu",
5721 read_leb128 (data, &bytes_read, 0));
5725 printf ("DW_OP_shl");
5728 printf ("DW_OP_shr");
5731 printf ("DW_OP_shra");
5734 printf ("DW_OP_xor");
5737 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5741 printf ("DW_OP_eq");
5744 printf ("DW_OP_ge");
5747 printf ("DW_OP_gt");
5750 printf ("DW_OP_le");
5753 printf ("DW_OP_lt");
5756 printf ("DW_OP_ne");
5759 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5795 printf ("DW_OP_lit%d", op - DW_OP_lit0);
5830 printf ("DW_OP_reg%d", op - DW_OP_reg0);
5865 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
5866 read_leb128 (data, &bytes_read, 1));
5871 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
5875 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
5879 uvalue = read_leb128 (data, &bytes_read, 0);
5881 printf ("DW_OP_bregx: %lu %ld", uvalue,
5882 read_leb128 (data, &bytes_read, 1));
5886 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
5889 case DW_OP_deref_size:
5890 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
5892 case DW_OP_xderef_size:
5893 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
5896 printf ("DW_OP_nop");
5900 if (op >= DW_OP_lo_user
5901 && op <= DW_OP_hi_user)
5902 printf (_("(User defined location op)"));
5904 printf (_("(Unknown location op)"));
5905 /* No way to tell where the next op is, so just bail. */
5912 static unsigned char *
5913 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
5914 unsigned long attribute;
5916 unsigned char * data;
5917 unsigned long cu_offset;
5918 unsigned long pointer_size;
5920 unsigned long uvalue = 0;
5921 unsigned char * block_start = NULL;
5924 printf (" %-18s:", get_AT_name (attribute));
5928 case DW_FORM_ref_addr:
5930 uvalue = byte_get (data, pointer_size);
5931 data += pointer_size;
5937 uvalue = byte_get (data ++, 1);
5942 uvalue = byte_get (data, 2);
5948 uvalue = byte_get (data, 4);
5953 uvalue = read_leb128 (data, & bytes_read, 1);
5957 case DW_FORM_ref_udata:
5959 uvalue = read_leb128 (data, & bytes_read, 0);
5966 case DW_FORM_ref_addr:
5967 printf (" <#%lx>", uvalue);
5973 case DW_FORM_ref_udata:
5974 printf (" <%lx>", uvalue + cu_offset);
5978 printf (" %#lx", uvalue);
5986 printf (" %ld", uvalue);
5991 uvalue = byte_get (data, 4);
5992 printf (" %lx", uvalue);
5993 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
5997 case DW_FORM_string:
5998 printf (" %s", data);
5999 data += strlen (data) + 1;
6003 uvalue = read_leb128 (data, & bytes_read, 0);
6004 block_start = data + bytes_read;
6005 data = display_block (block_start, uvalue);
6008 case DW_FORM_block1:
6009 uvalue = byte_get (data, 1);
6010 block_start = data + 1;
6011 data = display_block (block_start, uvalue);
6014 case DW_FORM_block2:
6015 uvalue = byte_get (data, 2);
6016 block_start = data + 2;
6017 data = display_block (block_start, uvalue);
6020 case DW_FORM_block4:
6021 uvalue = byte_get (data, 4);
6022 block_start = data + 4;
6023 data = display_block (block_start, uvalue);
6027 case DW_FORM_indirect:
6028 warn (_("Unable to handle FORM: %d"), form);
6032 warn (_("Unrecognised form: %d"), form);
6036 /* For some attributes we can display futher information. */
6045 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6046 case DW_INL_inlined: printf (_("(inlined)")); break;
6047 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6048 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6049 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6053 case DW_AT_language:
6056 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6057 case DW_LANG_C89: printf ("(ANSI C)"); break;
6058 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6059 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6060 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6061 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6062 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6063 case DW_LANG_Ada83: printf ("(Ada)"); break;
6064 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6065 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6066 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6067 default: printf ("(Unknown: %lx)", uvalue); break;
6071 case DW_AT_encoding:
6074 case DW_ATE_void: printf ("(void)"); break;
6075 case DW_ATE_address: printf ("(machine address)"); break;
6076 case DW_ATE_boolean: printf ("(boolean)"); break;
6077 case DW_ATE_complex_float: printf ("(complex float)"); break;
6078 case DW_ATE_float: printf ("(float)"); break;
6079 case DW_ATE_signed: printf ("(signed)"); break;
6080 case DW_ATE_signed_char: printf ("(signed char)"); break;
6081 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6082 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6084 if (uvalue >= DW_ATE_lo_user
6085 && uvalue <= DW_ATE_hi_user)
6086 printf ("(user defined type)");
6088 printf ("(unknown type)");
6093 case DW_AT_accessibility:
6096 case DW_ACCESS_public: printf ("(public)"); break;
6097 case DW_ACCESS_protected: printf ("(protected)"); break;
6098 case DW_ACCESS_private: printf ("(private)"); break;
6099 default: printf ("(unknown accessibility)"); break;
6103 case DW_AT_visibility:
6106 case DW_VIS_local: printf ("(local)"); break;
6107 case DW_VIS_exported: printf ("(exported)"); break;
6108 case DW_VIS_qualified: printf ("(qualified)"); break;
6109 default: printf ("(unknown visibility)"); break;
6113 case DW_AT_virtuality:
6116 case DW_VIRTUALITY_none: printf ("(none)"); break;
6117 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6118 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6119 default: printf ("(unknown virtuality)"); break;
6123 case DW_AT_identifier_case:
6126 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6127 case DW_ID_up_case: printf ("(up_case)"); break;
6128 case DW_ID_down_case: printf ("(down_case)"); break;
6129 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6130 default: printf ("(unknown case)"); break;
6134 case DW_AT_calling_convention:
6137 case DW_CC_normal: printf ("(normal)"); break;
6138 case DW_CC_program: printf ("(program)"); break;
6139 case DW_CC_nocall: printf ("(nocall)"); break;
6141 if (uvalue >= DW_CC_lo_user
6142 && uvalue <= DW_CC_hi_user)
6143 printf ("(user defined)");
6145 printf ("(unknown convention)");
6149 case DW_AT_frame_base:
6150 case DW_AT_location:
6151 case DW_AT_data_member_location:
6152 case DW_AT_vtable_elem_location:
6156 decode_location_expression (block_start, pointer_size, uvalue);
6170 display_debug_info (section, start, file)
6171 Elf32_Internal_Shdr * section;
6172 unsigned char * start;
6175 unsigned char * end = start + section->sh_size;
6176 unsigned char * section_begin = start;
6178 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6182 DWARF2_External_CompUnit * external;
6183 DWARF2_Internal_CompUnit compunit;
6184 unsigned char * tags;
6187 unsigned long cu_offset;
6189 external = (DWARF2_External_CompUnit *) start;
6191 compunit.cu_length = BYTE_GET (external->cu_length);
6192 compunit.cu_version = BYTE_GET (external->cu_version);
6193 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6194 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6196 tags = start + sizeof (* external);
6197 cu_offset = start - section_begin;
6198 start += compunit.cu_length + sizeof (external->cu_length);
6200 if (compunit.cu_version != 2)
6202 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6206 printf (_(" Compilation Unit:\n"));
6207 printf (_(" Length: %ld\n"), compunit.cu_length);
6208 printf (_(" Version: %d\n"), compunit.cu_version);
6209 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6210 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6212 if (first_abbrev != NULL)
6215 /* Read in the abbrevs used by this compilation unit. */
6218 Elf32_Internal_Shdr * sec;
6219 unsigned char * begin;
6221 /* Locate the .debug_abbrev section and process it. */
6222 for (i = 0, sec = section_headers;
6223 i < elf_header.e_shnum;
6225 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6228 if (i == -1 || sec->sh_size == 0)
6230 warn (_("Unable to locate .debug_abbrev section!\n"));
6234 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6235 "debug_abbrev section data");
6237 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6238 begin + sec->sh_size);
6244 while (tags < start)
6247 unsigned long abbrev_number;
6248 abbrev_entry * entry;
6251 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6254 /* A null DIE marks the end of a list of children. */
6255 if (abbrev_number == 0)
6261 /* Scan through the abbreviation list until we reach the
6263 for (entry = first_abbrev;
6264 entry && entry->entry != abbrev_number;
6265 entry = entry->next)
6270 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6275 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6276 level, tags - section_begin - bytes_read,
6278 get_TAG_name (entry->tag));
6280 for (attr = entry->first_attr; attr; attr = attr->next)
6281 tags = read_and_display_attr (attr->attribute,
6284 compunit.cu_pointer_size);
6286 if (entry->children)
6297 display_debug_aranges (section, start, file)
6298 Elf32_Internal_Shdr * section;
6299 unsigned char * start;
6300 FILE * file ATTRIBUTE_UNUSED;
6302 unsigned char * end = start + section->sh_size;
6304 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6308 DWARF2_External_ARange * external;
6309 DWARF2_Internal_ARange arange;
6310 unsigned char * ranges;
6311 unsigned long length;
6312 unsigned long address;
6315 external = (DWARF2_External_ARange *) start;
6317 arange.ar_length = BYTE_GET (external->ar_length);
6318 arange.ar_version = BYTE_GET (external->ar_version);
6319 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6320 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6321 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6323 printf (_(" Length: %ld\n"), arange.ar_length);
6324 printf (_(" Version: %d\n"), arange.ar_version);
6325 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6326 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6327 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6329 printf (_("\n Address Length\n"));
6331 ranges = start + sizeof (* external);
6333 /* Must pad to an alignment boundary that is twice the pointer size. */
6334 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6336 ranges += (2 * arange.ar_pointer_size) - excess;
6340 address = byte_get (ranges, arange.ar_pointer_size);
6342 ranges += arange.ar_pointer_size;
6344 length = byte_get (ranges, arange.ar_pointer_size);
6346 ranges += arange.ar_pointer_size;
6348 /* A pair of zeros marks the end of the list. */
6349 if (address == 0 && length == 0)
6352 printf (" %8.8lx %lu\n", address, length);
6355 start += arange.ar_length + sizeof (external->ar_length);
6365 display_debug_not_supported (section, start, file)
6366 Elf32_Internal_Shdr * section;
6367 unsigned char * start ATTRIBUTE_UNUSED;
6368 FILE * file ATTRIBUTE_UNUSED;
6370 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6371 SECTION_NAME (section));
6376 /* Pre-scan the .debug_info section to record the size of address.
6377 When dumping the .debug_line, we use that size information, assuming
6378 that all compilation units have the same address size. */
6380 prescan_debug_info (section, start, file)
6381 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6382 unsigned char * start;
6383 FILE * file ATTRIBUTE_UNUSED;
6385 DWARF2_External_CompUnit * external;
6387 external = (DWARF2_External_CompUnit *) start;
6389 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6393 /* A structure containing the name of a debug section and a pointer
6394 to a function that can decode it. The third field is a prescan
6395 function to be run over the section before displaying any of the
6400 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6401 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6405 { ".debug_info", display_debug_info, prescan_debug_info },
6406 { ".debug_abbrev", display_debug_abbrev, NULL },
6407 { ".debug_line", display_debug_lines, NULL },
6408 { ".debug_aranges", display_debug_aranges, NULL },
6409 { ".debug_pubnames", display_debug_pubnames, NULL },
6410 { ".debug_macinfo", display_debug_not_supported, NULL },
6411 { ".debug_frame", display_debug_not_supported, NULL },
6412 { ".debug_str", display_debug_not_supported, NULL },
6413 { ".debug_static_func", display_debug_not_supported, NULL },
6414 { ".debug_static_vars", display_debug_not_supported, NULL },
6415 { ".debug_types", display_debug_not_supported, NULL },
6416 { ".debug_weaknames", display_debug_not_supported, NULL }
6420 display_debug_section (section, file)
6421 Elf32_Internal_Shdr * section;
6424 char * name = SECTION_NAME (section);
6425 bfd_size_type length;
6426 unsigned char * start;
6429 length = section->sh_size;
6432 printf (_("\nSection '%s' has no debugging data.\n"), name);
6436 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6437 "debug section data");
6439 /* See if we know how to display the contents of this section. */
6440 for (i = NUM_ELEM (debug_displays); i--;)
6441 if (strcmp (debug_displays[i].name, name) == 0)
6443 debug_displays[i].display (section, start, file);
6448 printf (_("Unrecognised debug section: %s\n"), name);
6452 /* If we loaded in the abbrev section at some point,
6453 we must release it here. */
6454 if (first_abbrev != NULL)
6461 process_section_contents (file)
6464 Elf32_Internal_Shdr * section;
6470 /* Pre-scan the debug sections to find some debug information not
6471 present in some of them. For the .debug_line, we must find out the
6472 size of address (specified in .debug_info and .debug_aranges). */
6473 for (i = 0, section = section_headers;
6474 i < elf_header.e_shnum && i < num_dump_sects;
6477 char * name = SECTION_NAME (section);
6480 if (section->sh_size == 0)
6483 /* See if there is some pre-scan operation for this section. */
6484 for (j = NUM_ELEM (debug_displays); j--;)
6485 if (strcmp (debug_displays[j].name, name) == 0)
6487 if (debug_displays[j].prescan != NULL)
6489 bfd_size_type length;
6490 unsigned char * start;
6492 length = section->sh_size;
6493 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6494 "debug section data");
6496 debug_displays[j].prescan (section, start, file);
6504 for (i = 0, section = section_headers;
6505 i < elf_header.e_shnum && i < num_dump_sects;
6508 #ifdef SUPPORT_DISASSEMBLY
6509 if (dump_sects[i] & DISASS_DUMP)
6510 disassemble_section (section, file);
6512 if (dump_sects[i] & HEX_DUMP)
6513 dump_section (section, file);
6515 if (dump_sects[i] & DEBUG_DUMP)
6516 display_debug_section (section, file);
6519 if (i < num_dump_sects)
6520 warn (_("Some sections were not dumped because they do not exist!\n"));
6526 process_mips_fpe_exception (mask)
6532 if (mask & OEX_FPU_INEX)
6533 fputs ("INEX", stdout), first = 0;
6534 if (mask & OEX_FPU_UFLO)
6535 printf ("%sUFLO", first ? "" : "|"), first = 0;
6536 if (mask & OEX_FPU_OFLO)
6537 printf ("%sOFLO", first ? "" : "|"), first = 0;
6538 if (mask & OEX_FPU_DIV0)
6539 printf ("%sDIV0", first ? "" : "|"), first = 0;
6540 if (mask & OEX_FPU_INVAL)
6541 printf ("%sINVAL", first ? "" : "|");
6544 fputs ("0", stdout);
6548 process_mips_specific (file)
6551 Elf_Internal_Dyn * entry;
6552 size_t liblist_offset = 0;
6553 size_t liblistno = 0;
6554 size_t conflictsno = 0;
6555 size_t options_offset = 0;
6556 size_t conflicts_offset = 0;
6558 /* We have a lot of special sections. Thanks SGI! */
6559 if (dynamic_segment == NULL)
6560 /* No information available. */
6563 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
6564 switch (entry->d_tag)
6566 case DT_MIPS_LIBLIST:
6567 liblist_offset = entry->d_un.d_val - loadaddr;
6569 case DT_MIPS_LIBLISTNO:
6570 liblistno = entry->d_un.d_val;
6572 case DT_MIPS_OPTIONS:
6573 options_offset = entry->d_un.d_val - loadaddr;
6575 case DT_MIPS_CONFLICT:
6576 conflicts_offset = entry->d_un.d_val - loadaddr;
6578 case DT_MIPS_CONFLICTNO:
6579 conflictsno = entry->d_un.d_val;
6585 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
6587 Elf32_External_Lib * elib;
6590 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
6591 elib, Elf32_External_Lib *, "liblist");
6593 printf ("\nSection '.liblist' contains %lu entries:\n",
6594 (unsigned long) liblistno);
6595 fputs (" Library Time Stamp Checksum Version Flags\n",
6598 for (cnt = 0; cnt < liblistno; ++cnt)
6605 liblist.l_name = BYTE_GET (elib[cnt].l_name);
6606 time = BYTE_GET (elib[cnt].l_time_stamp);
6607 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
6608 liblist.l_version = BYTE_GET (elib[cnt].l_version);
6609 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
6611 tmp = gmtime (&time);
6612 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
6613 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6614 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6616 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
6617 dynamic_strings + liblist.l_name, timebuf,
6618 liblist.l_checksum, liblist.l_version);
6620 if (liblist.l_flags == 0)
6631 { " EXACT_MATCH", LL_EXACT_MATCH },
6632 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
6633 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
6634 { " EXPORTS", LL_EXPORTS },
6635 { " DELAY_LOAD", LL_DELAY_LOAD },
6636 { " DELTA", LL_DELTA }
6638 int flags = liblist.l_flags;
6642 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
6644 if ((flags & l_flags_vals[fcnt].bit) != 0)
6646 fputs (l_flags_vals[fcnt].name, stdout);
6647 flags ^= l_flags_vals[fcnt].bit;
6650 printf (" %#x", (unsigned int) flags);
6659 if (options_offset != 0)
6661 Elf_External_Options * eopt;
6662 Elf_Internal_Shdr * sect = section_headers;
6663 Elf_Internal_Options * iopt;
6664 Elf_Internal_Options * option;
6668 /* Find the section header so that we get the size. */
6669 while (sect->sh_type != SHT_MIPS_OPTIONS)
6672 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
6673 Elf_External_Options *, "options");
6675 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
6679 error (_("Out of memory"));
6686 while (offset < sect->sh_size)
6688 Elf_External_Options * eoption;
6690 eoption = (Elf_External_Options *) ((char *) eopt + offset);
6692 option->kind = BYTE_GET (eoption->kind);
6693 option->size = BYTE_GET (eoption->size);
6694 option->section = BYTE_GET (eoption->section);
6695 option->info = BYTE_GET (eoption->info);
6697 offset += option->size;
6703 printf (_("\nSection '%s' contains %d entries:\n"),
6704 string_table + sect->sh_name, cnt);
6712 switch (option->kind)
6715 /* This shouldn't happen. */
6716 printf (" NULL %d %lx", option->section, option->info);
6719 printf (" REGINFO ");
6720 if (elf_header.e_machine == EM_MIPS)
6723 Elf32_External_RegInfo *ereg;
6724 Elf32_RegInfo reginfo;
6726 ereg = (Elf32_External_RegInfo *) (option + 1);
6727 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6728 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6729 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6730 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6731 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6732 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
6734 printf ("GPR %08lx GP 0x%lx\n",
6736 (unsigned long) reginfo.ri_gp_value);
6737 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6738 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6739 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6744 Elf64_External_RegInfo * ereg;
6745 Elf64_Internal_RegInfo reginfo;
6747 ereg = (Elf64_External_RegInfo *) (option + 1);
6748 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6749 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6750 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6751 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6752 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6753 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
6755 printf ("GPR %08lx GP 0x",
6756 reginfo.ri_gprmask);
6757 printf_vma (reginfo.ri_gp_value);
6760 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6761 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6762 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6766 case ODK_EXCEPTIONS:
6767 fputs (" EXCEPTIONS fpe_min(", stdout);
6768 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
6769 fputs (") fpe_max(", stdout);
6770 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
6771 fputs (")", stdout);
6773 if (option->info & OEX_PAGE0)
6774 fputs (" PAGE0", stdout);
6775 if (option->info & OEX_SMM)
6776 fputs (" SMM", stdout);
6777 if (option->info & OEX_FPDBUG)
6778 fputs (" FPDBUG", stdout);
6779 if (option->info & OEX_DISMISS)
6780 fputs (" DISMISS", stdout);
6783 fputs (" PAD ", stdout);
6784 if (option->info & OPAD_PREFIX)
6785 fputs (" PREFIX", stdout);
6786 if (option->info & OPAD_POSTFIX)
6787 fputs (" POSTFIX", stdout);
6788 if (option->info & OPAD_SYMBOL)
6789 fputs (" SYMBOL", stdout);
6792 fputs (" HWPATCH ", stdout);
6793 if (option->info & OHW_R4KEOP)
6794 fputs (" R4KEOP", stdout);
6795 if (option->info & OHW_R8KPFETCH)
6796 fputs (" R8KPFETCH", stdout);
6797 if (option->info & OHW_R5KEOP)
6798 fputs (" R5KEOP", stdout);
6799 if (option->info & OHW_R5KCVTL)
6800 fputs (" R5KCVTL", stdout);
6803 fputs (" FILL ", stdout);
6804 /* XXX Print content of info word? */
6807 fputs (" TAGS ", stdout);
6808 /* XXX Print content of info word? */
6811 fputs (" HWAND ", stdout);
6812 if (option->info & OHWA0_R4KEOP_CHECKED)
6813 fputs (" R4KEOP_CHECKED", stdout);
6814 if (option->info & OHWA0_R4KEOP_CLEAN)
6815 fputs (" R4KEOP_CLEAN", stdout);
6818 fputs (" HWOR ", stdout);
6819 if (option->info & OHWA0_R4KEOP_CHECKED)
6820 fputs (" R4KEOP_CHECKED", stdout);
6821 if (option->info & OHWA0_R4KEOP_CLEAN)
6822 fputs (" R4KEOP_CLEAN", stdout);
6825 printf (" GP_GROUP %#06lx self-contained %#06lx",
6826 option->info & OGP_GROUP,
6827 (option->info & OGP_SELF) >> 16);
6830 printf (" IDENT %#06lx self-contained %#06lx",
6831 option->info & OGP_GROUP,
6832 (option->info & OGP_SELF) >> 16);
6835 /* This shouldn't happen. */
6836 printf (" %3d ??? %d %lx",
6837 option->kind, option->section, option->info);
6841 len = sizeof (*eopt);
6842 while (len < option->size)
6843 if (((char *) option)[len] >= ' '
6844 && ((char *) option)[len] < 0x7f)
6845 printf ("%c", ((char *) option)[len++]);
6847 printf ("\\%03o", ((char *) option)[len++]);
6849 fputs ("\n", stdout);
6856 if (conflicts_offset != 0 && conflictsno != 0)
6858 Elf32_External_Conflict * econf32;
6859 Elf64_External_Conflict * econf64;
6860 Elf32_Conflict * iconf;
6863 if (dynamic_symbols == NULL)
6865 error (_("conflict list with without table"));
6869 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
6872 error (_("Out of memory"));
6878 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
6879 econf32, Elf32_External_Conflict *, "conflict");
6881 for (cnt = 0; cnt < conflictsno; ++cnt)
6882 iconf[cnt] = BYTE_GET (econf32[cnt]);
6886 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
6887 econf64, Elf64_External_Conflict *, "conflict");
6889 for (cnt = 0; cnt < conflictsno; ++cnt)
6890 iconf[cnt] = BYTE_GET (econf64[cnt]);
6893 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
6894 puts (_(" Num: Index Value Name"));
6896 for (cnt = 0; cnt < conflictsno; ++cnt)
6898 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
6900 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
6901 print_vma (psym->st_value, FULL_HEX);
6902 printf (" %s\n", dynamic_strings + psym->st_name);
6912 get_note_type (e_type)
6915 static char buff[64];
6919 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
6920 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
6921 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
6922 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
6923 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
6924 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
6925 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
6926 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
6927 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6928 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
6929 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
6931 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
6936 /* Note that by the ELF standard, the name field is already null byte
6937 terminated, and namesz includes the terminating null byte.
6938 I.E. the value of namesz for the name "FSF" is 4.
6940 If the value of namesz is zero, there is no name present. */
6942 process_note (pnote)
6943 Elf32_Internal_Note * pnote;
6945 printf (" %s\t\t0x%08lx\t%s\n",
6946 pnote->namesz ? pnote->namedata : "(NONE)",
6947 pnote->descsz, get_note_type (pnote->type));
6953 process_corefile_note_segment (file, offset, length)
6958 Elf_External_Note * pnotes;
6959 Elf_External_Note * external;
6965 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
6969 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
6970 (unsigned long) offset, (unsigned long) length);
6971 printf (_(" Owner\t\tData size\tDescription\n"));
6973 while (external < (Elf_External_Note *)((char *) pnotes + length))
6975 Elf32_Internal_Note inote;
6978 inote.type = BYTE_GET (external->type);
6979 inote.namesz = BYTE_GET (external->namesz);
6980 inote.namedata = external->name;
6981 inote.descsz = BYTE_GET (external->descsz);
6982 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
6983 inote.descpos = offset + (inote.descdata - (char *) pnotes);
6985 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
6987 /* Verify that name is null terminated. It appears that at least
6988 one version of Linux (RedHat 6.0) generates corefiles that don't
6989 comply with the ELF spec by failing to include the null byte in
6991 if (inote.namedata[inote.namesz] != '\0')
6993 temp = malloc (inote.namesz + 1);
6997 error (_("Out of memory\n"));
7002 strncpy (temp, inote.namedata, inote.namesz);
7003 temp[inote.namesz] = 0;
7005 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7006 inote.namedata = temp;
7009 res &= process_note (& inote);
7024 process_corefile_note_segments (file)
7027 Elf_Internal_Phdr * program_headers;
7028 Elf_Internal_Phdr * segment;
7032 program_headers = (Elf_Internal_Phdr *) malloc
7033 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7035 if (program_headers == NULL)
7037 error (_("Out of memory\n"));
7042 i = get_32bit_program_headers (file, program_headers);
7044 i = get_64bit_program_headers (file, program_headers);
7048 free (program_headers);
7052 for (i = 0, segment = program_headers;
7053 i < elf_header.e_phnum;
7056 if (segment->p_type == PT_NOTE)
7057 res &= process_corefile_note_segment (file,
7058 (bfd_vma) segment->p_offset,
7059 (bfd_vma) segment->p_filesz);
7062 free (program_headers);
7068 process_corefile_contents (file)
7071 /* If we have not been asked to display the notes then do nothing. */
7075 /* If file is not a core file then exit. */
7076 if (elf_header.e_type != ET_CORE)
7079 /* No program headers means no NOTE segment. */
7080 if (elf_header.e_phnum == 0)
7082 printf (_("No note segments present in the core file.\n"));
7086 return process_corefile_note_segments (file);
7090 process_arch_specific (file)
7096 switch (elf_header.e_machine)
7099 case EM_MIPS_RS4_BE:
7100 return process_mips_specific (file);
7109 get_file_header (file)
7112 /* Read in the identity array. */
7113 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7116 /* Determine how to read the rest of the header. */
7117 switch (elf_header.e_ident [EI_DATA])
7119 default: /* fall through */
7120 case ELFDATANONE: /* fall through */
7121 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7122 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7125 /* For now we only support 32 bit and 64 bit ELF files. */
7126 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7128 /* Read in the rest of the header. */
7131 Elf32_External_Ehdr ehdr32;
7133 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7136 elf_header.e_type = BYTE_GET (ehdr32.e_type);
7137 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
7138 elf_header.e_version = BYTE_GET (ehdr32.e_version);
7139 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7140 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7141 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7142 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7143 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7144 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7145 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7146 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7147 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7148 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7152 Elf64_External_Ehdr ehdr64;
7154 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7155 we will not be able to cope with the 64bit data found in
7156 64 ELF files. Detect this now and abort before we start
7157 overwritting things. */
7158 if (sizeof (bfd_vma) < 8)
7160 error (_("This instance of readelf has been built without support for a\n"));
7161 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7165 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7168 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7169 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7170 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7171 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7172 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7173 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7174 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7175 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7176 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7177 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7178 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7179 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7180 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7187 process_file (file_name)
7191 struct stat statbuf;
7194 if (stat (file_name, & statbuf) < 0)
7196 error (_("Cannot stat input file %s.\n"), file_name);
7200 file = fopen (file_name, "rb");
7203 error (_("Input file %s not found.\n"), file_name);
7207 if (! get_file_header (file))
7209 error (_("%s: Failed to read file header\n"), file_name);
7214 /* Initialise per file variables. */
7215 for (i = NUM_ELEM (version_info); i--;)
7216 version_info[i] = 0;
7218 for (i = NUM_ELEM (dynamic_info); i--;)
7219 dynamic_info[i] = 0;
7221 /* Process the file. */
7223 printf (_("\nFile: %s\n"), file_name);
7225 if (! process_file_header ())
7231 process_section_headers (file);
7233 process_program_headers (file);
7235 process_dynamic_segment (file);
7237 process_relocs (file);
7239 process_symbol_table (file);
7241 process_syminfo (file);
7243 process_version_sections (file);
7245 process_section_contents (file);
7247 process_corefile_contents (file);
7249 process_arch_specific (file);
7253 if (section_headers)
7255 free (section_headers);
7256 section_headers = NULL;
7261 free (string_table);
7262 string_table = NULL;
7265 if (dynamic_strings)
7267 free (dynamic_strings);
7268 dynamic_strings = NULL;
7271 if (dynamic_symbols)
7273 free (dynamic_symbols);
7274 dynamic_symbols = NULL;
7275 num_dynamic_syms = 0;
7278 if (dynamic_syminfo)
7280 free (dynamic_syminfo);
7281 dynamic_syminfo = NULL;
7285 #ifdef SUPPORT_DISASSEMBLY
7286 /* Needed by the i386 disassembler. For extra credit, someone could
7287 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7291 print_address (unsigned int addr, FILE * outfile)
7293 fprintf (outfile,"0x%8.8x", addr);
7296 /* Needed by the i386 disassembler. */
7298 db_task_printsym (unsigned int addr)
7300 print_address (addr, stderr);
7309 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7310 setlocale (LC_MESSAGES, "");
7312 bindtextdomain (PACKAGE, LOCALEDIR);
7313 textdomain (PACKAGE);
7315 parse_args (argc, argv);
7317 if (optind < (argc - 1))
7320 while (optind < argc)
7321 process_file (argv [optind ++]);
7323 if (dump_sects != NULL)