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_CHECKSUM: return "CHECKSUM";
1074 case DT_PLTPADSZ: return "PLTPADSZ";
1075 case DT_MOVEENT: return "MOVEENT";
1076 case DT_MOVESZ: return "MOVESZ";
1077 case DT_FEATURE: return "FEATURE";
1078 case DT_POSFLAG_1: return "POSFLAG_1";
1079 case DT_SYMINSZ: return "SYMINSZ";
1080 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1082 case DT_ADDRRNGLO: return "ADDRRNGLO";
1083 case DT_CONFIG: return "CONFIG";
1084 case DT_DEPAUDIT: return "DEPAUDIT";
1085 case DT_AUDIT: return "AUDIT";
1086 case DT_PLTPAD: return "PLTPAD";
1087 case DT_MOVETAB: return "MOVETAB";
1088 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1090 case DT_VERSYM: return "VERSYM";
1092 case DT_RELACOUNT: return "RELACOUNT";
1093 case DT_RELCOUNT: return "RELCOUNT";
1094 case DT_FLAGS_1: return "FLAGS_1";
1095 case DT_VERDEF: return "VERDEF";
1096 case DT_VERDEFNUM: return "VERDEFNUM";
1097 case DT_VERNEED: return "VERNEED";
1098 case DT_VERNEEDNUM: return "VERNEEDNUM";
1100 case DT_AUXILIARY: return "AUXILIARY";
1101 case DT_USED: return "USED";
1102 case DT_FILTER: return "FILTER";
1105 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1107 const char * result;
1109 switch (elf_header.e_machine)
1112 case EM_MIPS_RS4_BE:
1113 result = get_mips_dynamic_type (type);
1116 result = get_sparc64_dynamic_type (type);
1126 sprintf (buff, _("Processor Specific: %lx"), type);
1128 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1130 const char * result;
1132 switch (elf_header.e_machine)
1135 result = get_parisc_dynamic_type (type);
1145 sprintf (buff, _("Operating System specific: %lx"), type);
1148 sprintf (buff, _("<unknown>: %lx"), type);
1155 get_file_type (e_type)
1158 static char buff [32];
1162 case ET_NONE: return _("NONE (None)");
1163 case ET_REL: return _("REL (Relocatable file)");
1164 case ET_EXEC: return _("EXEC (Executable file)");
1165 case ET_DYN: return _("DYN (Shared object file)");
1166 case ET_CORE: return _("CORE (Core file)");
1169 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1170 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1171 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1172 sprintf (buff, _("OS Specific: (%x)"), e_type);
1174 sprintf (buff, _("<unknown>: %x"), e_type);
1180 get_machine_name (e_machine)
1183 static char buff [64]; /* XXX */
1187 case EM_NONE: return _("None");
1188 case EM_M32: return "WE32100";
1189 case EM_SPARC: return "Sparc";
1190 case EM_386: return "Intel 80386";
1191 case EM_68K: return "MC68000";
1192 case EM_88K: return "MC88000";
1193 case EM_486: return "Intel 80486";
1194 case EM_860: return "Intel 80860";
1195 case EM_MIPS: return "MIPS R3000";
1196 case EM_S370: return "IBM System/370";
1197 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1198 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1199 case EM_PARISC: return "HPPA";
1200 case EM_PPC_OLD: return "Power PC (old)";
1201 case EM_SPARC32PLUS: return "Sparc v8+" ;
1202 case EM_960: return "Intel 90860";
1203 case EM_PPC: return "PowerPC";
1204 case EM_V800: return "NEC V800";
1205 case EM_FR20: return "Fujitsu FR20";
1206 case EM_RH32: return "TRW RH32";
1207 case EM_MCORE: return "MCORE";
1208 case EM_ARM: return "ARM";
1209 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1210 case EM_SH: return "Hitachi SH";
1211 case EM_SPARCV9: return "Sparc v9";
1212 case EM_TRICORE: return "Siemens Tricore";
1213 case EM_ARC: return "Argonaut RISC Core";
1214 case EM_H8_300: return "Hitachi H8/300";
1215 case EM_H8_300H: return "Hitachi H8/300H";
1216 case EM_H8S: return "Hitachi H8S";
1217 case EM_H8_500: return "Hitachi H8/500";
1218 case EM_IA_64: return "Intel IA-64";
1219 case EM_MIPS_X: return "Stanford MIPS-X";
1220 case EM_COLDFIRE: return "Motorola Coldfire";
1221 case EM_68HC12: return "Motorola M68HC12";
1222 case EM_ALPHA: return "Alpha";
1223 case EM_CYGNUS_D10V: return "d10v";
1224 case EM_CYGNUS_D30V: return "d30v";
1225 case EM_CYGNUS_ARC: return "Arc";
1226 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1227 case EM_CYGNUS_V850: return "NEC v850";
1228 case EM_CYGNUS_MN10300: return "mn10300";
1229 case EM_CYGNUS_MN10200: return "mn10200";
1230 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1231 case EM_PJ: return "picoJava";
1232 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1233 case EM_PCP: return "Siemens PCP";
1234 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1235 case EM_NDR1: return "Denso NDR1 microprocesspr";
1236 case EM_STARCORE: return "Motorola Star*Core processor";
1237 case EM_ME16: return "Toyota ME16 processor";
1238 case EM_ST100: return "STMicroelectronics ST100 processor";
1239 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1240 case EM_FX66: return "Siemens FX66 microcontroller";
1241 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1242 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1243 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1244 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1245 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1246 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1247 case EM_SVX: return "Silicon Graphics SVx";
1248 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1249 case EM_VAX: return "Digital VAX";
1250 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1252 sprintf (buff, _("<unknown>: %x"), e_machine);
1258 decode_ARM_machine_flags (e_flags, buf)
1265 eabi = EF_ARM_EABI_VERSION (e_flags);
1266 e_flags &= ~ EF_ARM_EABIMASK;
1268 /* Handle "generic" ARM flags. */
1269 if (e_flags & EF_ARM_RELEXEC)
1271 strcat (buf, ", relocatable executable");
1272 e_flags &= ~ EF_ARM_RELEXEC;
1275 if (e_flags & EF_ARM_HASENTRY)
1277 strcat (buf, ", has entry point");
1278 e_flags &= ~ EF_ARM_HASENTRY;
1281 /* Now handle EABI specific flags. */
1285 strcat (buf, ", <unknown EABI>");
1290 case EF_ARM_EABI_VER1:
1295 /* Process flags one bit at a time. */
1296 flag = e_flags & - e_flags;
1301 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_INTERWORK. */
1302 strcat (buf, ", sorted symbol tables");
1312 case EF_ARM_EABI_UNKNOWN:
1317 /* Process flags one bit at a time. */
1318 flag = e_flags & - e_flags;
1324 strcat (buf, ", interworking enabled");
1328 strcat (buf, ", uses APCS/26");
1332 strcat (buf, ", uses APCS/float");
1336 strcat (buf, ", position independent");
1340 strcat (buf, ", 8 bit structure alignment");
1344 strcat (buf, ", uses new ABI");
1348 strcat (buf, ", uses old ABI");
1352 strcat (buf, ", software FP");
1363 strcat (buf,", <unknown>");
1367 get_machine_flags (e_flags, e_machine)
1371 static char buf [1024];
1383 decode_ARM_machine_flags (e_flags, buf);
1387 if (e_flags & EF_CPU32)
1388 strcat (buf, ", cpu32");
1392 if (e_flags & EF_PPC_EMB)
1393 strcat (buf, ", emb");
1395 if (e_flags & EF_PPC_RELOCATABLE)
1396 strcat (buf, ", relocatable");
1398 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1399 strcat (buf, ", relocatable-lib");
1402 case EM_CYGNUS_V850:
1403 switch (e_flags & EF_V850_ARCH)
1406 strcat (buf, ", v850e");
1409 strcat (buf, ", v850ea");
1412 strcat (buf, ", v850");
1415 strcat (buf, ", unknown v850 architecture variant");
1420 case EM_CYGNUS_M32R:
1421 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1422 strcat (buf, ", m32r");
1427 case EM_MIPS_RS4_BE:
1428 if (e_flags & EF_MIPS_NOREORDER)
1429 strcat (buf, ", noreorder");
1431 if (e_flags & EF_MIPS_PIC)
1432 strcat (buf, ", pic");
1434 if (e_flags & EF_MIPS_CPIC)
1435 strcat (buf, ", cpic");
1437 if (e_flags & EF_MIPS_ABI2)
1438 strcat (buf, ", abi2");
1440 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1441 strcat (buf, ", mips1");
1443 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1444 strcat (buf, ", mips2");
1446 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1447 strcat (buf, ", mips3");
1449 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1450 strcat (buf, ", mips4");
1454 if (e_flags & EF_SPARC_32PLUS)
1455 strcat (buf, ", v8+");
1457 if (e_flags & EF_SPARC_SUN_US1)
1458 strcat (buf, ", ultrasparcI");
1460 if (e_flags & EF_SPARC_SUN_US3)
1461 strcat (buf, ", ultrasparcIII");
1463 if (e_flags & EF_SPARC_HAL_R1)
1464 strcat (buf, ", halr1");
1466 if (e_flags & EF_SPARC_LEDATA)
1467 strcat (buf, ", ledata");
1469 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1470 strcat (buf, ", tso");
1472 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1473 strcat (buf, ", pso");
1475 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1476 strcat (buf, ", rmo");
1480 switch (e_flags & EF_PARISC_ARCH)
1482 case EFA_PARISC_1_0:
1483 strcpy (buf, ", PA-RISC 1.0");
1485 case EFA_PARISC_1_1:
1486 strcpy (buf, ", PA-RISC 1.1");
1488 case EFA_PARISC_2_0:
1489 strcpy (buf, ", PA-RISC 2.0");
1494 if (e_flags & EF_PARISC_TRAPNIL)
1495 strcat (buf, ", trapnil");
1496 if (e_flags & EF_PARISC_EXT)
1497 strcat (buf, ", ext");
1498 if (e_flags & EF_PARISC_LSB)
1499 strcat (buf, ", lsb");
1500 if (e_flags & EF_PARISC_WIDE)
1501 strcat (buf, ", wide");
1502 if (e_flags & EF_PARISC_NO_KABP)
1503 strcat (buf, ", no kabp");
1504 if (e_flags & EF_PARISC_LAZYSWAP)
1505 strcat (buf, ", lazyswap");
1509 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1510 strcat (buf, ", new calling convention");
1512 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1513 strcat (buf, ", gnu calling convention");
1522 get_mips_segment_type (type)
1527 case PT_MIPS_REGINFO:
1529 case PT_MIPS_RTPROC:
1531 case PT_MIPS_OPTIONS:
1541 get_parisc_segment_type (type)
1546 case PT_HP_TLS: return "HP_TLS";
1547 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1548 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1549 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1550 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1551 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1552 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1553 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1554 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1555 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1556 case PT_HP_PARALLEL: return "HP_PARALLEL";
1557 case PT_HP_FASTBIND: return "HP_FASTBIND";
1558 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1559 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1568 get_segment_type (p_type)
1569 unsigned long p_type;
1571 static char buff [32];
1575 case PT_NULL: return "NULL";
1576 case PT_LOAD: return "LOAD";
1577 case PT_DYNAMIC: return "DYNAMIC";
1578 case PT_INTERP: return "INTERP";
1579 case PT_NOTE: return "NOTE";
1580 case PT_SHLIB: return "SHLIB";
1581 case PT_PHDR: return "PHDR";
1584 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1586 const char * result;
1588 switch (elf_header.e_machine)
1591 case EM_MIPS_RS4_BE:
1592 result = get_mips_segment_type (p_type);
1595 result = get_parisc_segment_type (p_type);
1605 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1607 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1609 const char * result;
1611 switch (elf_header.e_machine)
1614 result = get_parisc_segment_type (p_type);
1624 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1627 sprintf (buff, _("<unknown>: %lx"), p_type);
1634 get_mips_section_type_name (sh_type)
1635 unsigned int sh_type;
1639 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1640 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1641 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1642 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1643 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1644 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1645 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1646 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1647 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1648 case SHT_MIPS_RELD: return "MIPS_RELD";
1649 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1650 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1651 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1652 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1653 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1654 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1655 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1656 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1657 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1658 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1659 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1660 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1661 case SHT_MIPS_LINE: return "MIPS_LINE";
1662 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1663 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1664 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1665 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1666 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1667 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1668 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1669 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1670 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1671 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1672 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1673 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1674 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1675 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1676 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1677 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1685 get_parisc_section_type_name (sh_type)
1686 unsigned int sh_type;
1690 case SHT_PARISC_EXT: return "PARISC_EXT";
1691 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1692 case SHT_PARISC_DOC: return "PARISC_DOC";
1700 get_section_type_name (sh_type)
1701 unsigned int sh_type;
1703 static char buff [32];
1707 case SHT_NULL: return "NULL";
1708 case SHT_PROGBITS: return "PROGBITS";
1709 case SHT_SYMTAB: return "SYMTAB";
1710 case SHT_STRTAB: return "STRTAB";
1711 case SHT_RELA: return "RELA";
1712 case SHT_HASH: return "HASH";
1713 case SHT_DYNAMIC: return "DYNAMIC";
1714 case SHT_NOTE: return "NOTE";
1715 case SHT_NOBITS: return "NOBITS";
1716 case SHT_REL: return "REL";
1717 case SHT_SHLIB: return "SHLIB";
1718 case SHT_DYNSYM: return "DYNSYM";
1719 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1720 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1721 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1722 case SHT_GNU_verdef: return "VERDEF";
1723 case SHT_GNU_verneed: return "VERNEED";
1724 case SHT_GNU_versym: return "VERSYM";
1725 case 0x6ffffff0: return "VERSYM";
1726 case 0x6ffffffc: return "VERDEF";
1727 case 0x7ffffffd: return "AUXILIARY";
1728 case 0x7fffffff: return "FILTER";
1731 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1733 const char * result;
1735 switch (elf_header.e_machine)
1738 case EM_MIPS_RS4_BE:
1739 result = get_mips_section_type_name (sh_type);
1742 result = get_parisc_section_type_name (sh_type);
1752 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1754 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1755 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1756 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1757 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1759 sprintf (buff, _("<unknown>: %x"), sh_type);
1765 struct option options [] =
1767 {"all", no_argument, 0, 'a'},
1768 {"file-header", no_argument, 0, 'h'},
1769 {"program-headers", no_argument, 0, 'l'},
1770 {"headers", no_argument, 0, 'e'},
1771 {"histogram", no_argument, 0, 'I'},
1772 {"segments", no_argument, 0, 'l'},
1773 {"sections", no_argument, 0, 'S'},
1774 {"section-headers", no_argument, 0, 'S'},
1775 {"symbols", no_argument, 0, 's'},
1776 {"syms", no_argument, 0, 's'},
1777 {"relocs", no_argument, 0, 'r'},
1778 {"notes", no_argument, 0, 'n'},
1779 {"dynamic", no_argument, 0, 'd'},
1780 {"arch-specific", no_argument, 0, 'A'},
1781 {"version-info", no_argument, 0, 'V'},
1782 {"use-dynamic", no_argument, 0, 'D'},
1783 {"hex-dump", required_argument, 0, 'x'},
1784 {"debug-dump", optional_argument, 0, 'w'},
1785 #ifdef SUPPORT_DISASSEMBLY
1786 {"instruction-dump", required_argument, 0, 'i'},
1789 {"version", no_argument, 0, 'v'},
1790 {"help", no_argument, 0, 'H'},
1791 {0, no_argument, 0, 0}
1797 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1798 fprintf (stdout, _(" Options are:\n"));
1799 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1800 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1801 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1802 fprintf (stdout, _(" Display the program headers\n"));
1803 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1804 fprintf (stdout, _(" Display the sections' header\n"));
1805 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1806 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1807 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1808 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1809 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1810 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1811 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1812 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1813 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1814 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1815 fprintf (stdout, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1816 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
1817 #ifdef SUPPORT_DISASSEMBLY
1818 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1819 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1821 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1822 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1823 fprintf (stdout, _(" -H or --help Display this information\n"));
1824 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
1830 request_dump (section, type)
1831 unsigned int section;
1834 if (section >= num_dump_sects)
1836 char * new_dump_sects;
1838 new_dump_sects = (char *) calloc (section + 1, 1);
1840 if (new_dump_sects == NULL)
1841 error (_("Out of memory allocating dump request table."));
1844 /* Copy current flag settings. */
1845 memcpy (new_dump_sects, dump_sects, num_dump_sects);
1849 dump_sects = new_dump_sects;
1850 num_dump_sects = section + 1;
1855 dump_sects [section] |= type;
1861 parse_args (argc, argv)
1870 while ((c = getopt_long
1871 (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
1906 do_using_dynamic ++;
1934 section = strtoul (optarg, & cp, 0);
1935 if (! * cp && section >= 0)
1937 request_dump (section, HEX_DUMP);
1957 do_debug_abbrevs = 1;
1967 do_debug_pubnames = 1;
1972 do_debug_aranges = 1;
1976 warn (_("Unrecognised debug option '%s'\n"), optarg);
1981 #ifdef SUPPORT_DISASSEMBLY
1984 section = strtoul (optarg, & cp, 0);
1985 if (! * cp && section >= 0)
1987 request_dump (section, DISASS_DUMP);
1993 print_version (program_name);
2000 /* xgettext:c-format */
2001 error (_("Invalid option '-%c'\n"), c);
2008 if (!do_dynamic && !do_syms && !do_reloc && !do_sections
2009 && !do_segments && !do_header && !do_dump && !do_version
2010 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2014 warn (_("Nothing to do.\n"));
2020 get_elf_class (elf_class)
2021 unsigned char elf_class;
2023 static char buff [32];
2027 case ELFCLASSNONE: return _("none");
2028 case ELFCLASS32: return _("ELF32");
2029 case ELFCLASS64: return _("ELF64");
2031 sprintf (buff, _("<unknown: %x>"), elf_class);
2037 get_data_encoding (encoding)
2038 unsigned char encoding;
2040 static char buff [32];
2044 case ELFDATANONE: return _("none");
2045 case ELFDATA2LSB: return _("2's complement, little endian");
2046 case ELFDATA2MSB: return _("2's complement, big endian");
2048 sprintf (buff, _("<unknown: %x>"), encoding);
2054 get_osabi_name (osabi)
2055 unsigned char osabi;
2057 static char buff [32];
2061 case ELFOSABI_NONE: return _("UNIX - System V");
2062 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2063 case ELFOSABI_NETBSD: return _("UNIX - NetBSD");
2064 case ELFOSABI_LINUX: return _("UNIX - Linux");
2065 case ELFOSABI_HURD: return _("GNU/Hurd");
2066 case ELFOSABI_SOLARIS: return _("UNIX - Solaris");
2067 case ELFOSABI_MONTEREY: return _("UNIX - Monterey");
2068 case ELFOSABI_IRIX: return _("UNIX - IRIX");
2069 case ELFOSABI_FREEBSD: return _("UNIX - FreeBSD");
2070 case ELFOSABI_TRU64: return _("UNIX - TRU64");
2071 case ELFOSABI_MODESTO: return _("Novell - Modesto");
2072 case ELFOSABI_OPENBSD: return _("UNIX - OpenBSD");
2073 case ELFOSABI_STANDALONE: return _("Standalone App");
2074 case ELFOSABI_ARM: return _("ARM");
2076 sprintf (buff, _("<unknown: %x>"), osabi);
2081 /* Decode the data held in 'elf_header'. */
2083 process_file_header ()
2085 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2086 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2087 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2088 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2091 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2099 printf (_("ELF Header:\n"));
2100 printf (_(" Magic: "));
2101 for (i = 0; i < EI_NIDENT; i ++)
2102 printf ("%2.2x ", elf_header.e_ident [i]);
2104 printf (_(" Class: %s\n"),
2105 get_elf_class (elf_header.e_ident [EI_CLASS]));
2106 printf (_(" Data: %s\n"),
2107 get_data_encoding (elf_header.e_ident [EI_DATA]));
2108 printf (_(" Version: %d %s\n"),
2109 elf_header.e_ident [EI_VERSION],
2110 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2112 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2115 printf (_(" OS/ABI: %s\n"),
2116 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2117 printf (_(" ABI Version: %d\n"),
2118 elf_header.e_ident [EI_ABIVERSION]);
2119 printf (_(" Type: %s\n"),
2120 get_file_type (elf_header.e_type));
2121 printf (_(" Machine: %s\n"),
2122 get_machine_name (elf_header.e_machine));
2123 printf (_(" Version: 0x%lx\n"),
2124 (unsigned long) elf_header.e_version);
2126 printf (_(" Entry point address: "));
2127 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2128 printf (_("\n Start of program headers: "));
2129 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2130 printf (_(" (bytes into file)\n Start of section headers: "));
2131 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2132 printf (_(" (bytes into file)\n"));
2134 printf (_(" Flags: 0x%lx%s\n"),
2135 (unsigned long) elf_header.e_flags,
2136 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2137 printf (_(" Size of this header: %ld (bytes)\n"),
2138 (long) elf_header.e_ehsize);
2139 printf (_(" Size of program headers: %ld (bytes)\n"),
2140 (long) elf_header.e_phentsize);
2141 printf (_(" Number of program headers: %ld\n"),
2142 (long) elf_header.e_phnum);
2143 printf (_(" Size of section headers: %ld (bytes)\n"),
2144 (long) elf_header.e_shentsize);
2145 printf (_(" Number of section headers: %ld\n"),
2146 (long) elf_header.e_shnum);
2147 printf (_(" Section header string table index: %ld\n"),
2148 (long) elf_header.e_shstrndx);
2156 get_32bit_program_headers (file, program_headers)
2158 Elf_Internal_Phdr * program_headers;
2160 Elf32_External_Phdr * phdrs;
2161 Elf32_External_Phdr * external;
2162 Elf32_Internal_Phdr * internal;
2165 GET_DATA_ALLOC (elf_header.e_phoff,
2166 elf_header.e_phentsize * elf_header.e_phnum,
2167 phdrs, Elf32_External_Phdr *, "program headers");
2169 for (i = 0, internal = program_headers, external = phdrs;
2170 i < elf_header.e_phnum;
2171 i ++, internal ++, external ++)
2173 internal->p_type = BYTE_GET (external->p_type);
2174 internal->p_offset = BYTE_GET (external->p_offset);
2175 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2176 internal->p_paddr = BYTE_GET (external->p_paddr);
2177 internal->p_filesz = BYTE_GET (external->p_filesz);
2178 internal->p_memsz = BYTE_GET (external->p_memsz);
2179 internal->p_flags = BYTE_GET (external->p_flags);
2180 internal->p_align = BYTE_GET (external->p_align);
2189 get_64bit_program_headers (file, program_headers)
2191 Elf_Internal_Phdr * program_headers;
2193 Elf64_External_Phdr * phdrs;
2194 Elf64_External_Phdr * external;
2195 Elf64_Internal_Phdr * internal;
2198 GET_DATA_ALLOC (elf_header.e_phoff,
2199 elf_header.e_phentsize * elf_header.e_phnum,
2200 phdrs, Elf64_External_Phdr *, "program headers");
2202 for (i = 0, internal = program_headers, external = phdrs;
2203 i < elf_header.e_phnum;
2204 i ++, internal ++, external ++)
2206 internal->p_type = BYTE_GET (external->p_type);
2207 internal->p_flags = BYTE_GET (external->p_flags);
2208 internal->p_offset = BYTE_GET8 (external->p_offset);
2209 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2210 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2211 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2212 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2213 internal->p_align = BYTE_GET8 (external->p_align);
2222 process_program_headers (file)
2225 Elf_Internal_Phdr * program_headers;
2226 Elf_Internal_Phdr * segment;
2229 if (elf_header.e_phnum == 0)
2232 printf (_("\nThere are no program headers in this file.\n"));
2236 if (do_segments && !do_header)
2238 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2239 printf (_("Entry point "));
2240 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2241 printf (_("\nThere are %d program headers, starting at offset "),
2242 elf_header.e_phnum);
2243 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2247 program_headers = (Elf_Internal_Phdr *) malloc
2248 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2250 if (program_headers == NULL)
2252 error (_("Out of memory\n"));
2257 i = get_32bit_program_headers (file, program_headers);
2259 i = get_64bit_program_headers (file, program_headers);
2263 free (program_headers);
2270 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2274 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2278 (_(" Type Offset VirtAddr PhysAddr\n"));
2280 (_(" FileSiz MemSiz Flags Align\n"));
2288 for (i = 0, segment = program_headers;
2289 i < elf_header.e_phnum;
2294 printf (" %-14.14s ", get_segment_type (segment->p_type));
2298 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2299 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2300 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2301 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2302 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2304 (segment->p_flags & PF_R ? 'R' : ' '),
2305 (segment->p_flags & PF_W ? 'W' : ' '),
2306 (segment->p_flags & PF_X ? 'E' : ' '));
2307 printf ("%#lx", (unsigned long) segment->p_align);
2311 print_vma (segment->p_offset, FULL_HEX);
2313 print_vma (segment->p_vaddr, FULL_HEX);
2315 print_vma (segment->p_paddr, FULL_HEX);
2317 print_vma (segment->p_filesz, FULL_HEX);
2319 print_vma (segment->p_memsz, FULL_HEX);
2321 (segment->p_flags & PF_R ? 'R' : ' '),
2322 (segment->p_flags & PF_W ? 'W' : ' '),
2323 (segment->p_flags & PF_X ? 'E' : ' '));
2324 print_vma (segment->p_align, HEX);
2328 switch (segment->p_type)
2332 loadaddr = (segment->p_vaddr & 0xfffff000)
2333 - (segment->p_offset & 0xfffff000);
2338 error (_("more than one dynamic segment\n"));
2340 dynamic_addr = segment->p_offset;
2341 dynamic_size = segment->p_filesz;
2345 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2346 error (_("Unable to find program interpreter name\n"));
2349 program_interpreter[0] = 0;
2350 fscanf (file, "%63s", program_interpreter);
2353 printf (_("\n [Requesting program interpreter: %s]"),
2354 program_interpreter);
2360 putc ('\n', stdout);
2369 if (do_segments && section_headers != NULL)
2371 printf (_("\n Section to Segment mapping:\n"));
2372 printf (_(" Segment Sections...\n"));
2374 assert (string_table != NULL);
2376 for (i = 0; i < elf_header.e_phnum; i++)
2379 Elf_Internal_Shdr * section;
2381 segment = program_headers + i;
2382 section = section_headers;
2384 printf (" %2.2d ", i);
2386 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2388 if (section->sh_size > 0
2389 /* Compare allocated sections by VMA, unallocated
2390 sections by file offset. */
2391 && (section->sh_flags & SHF_ALLOC
2392 ? (section->sh_addr >= segment->p_vaddr
2393 && section->sh_addr + section->sh_size
2394 <= segment->p_vaddr + segment->p_memsz)
2395 : ((bfd_vma) section->sh_offset >= segment->p_offset
2396 && (section->sh_offset + section->sh_size
2397 <= segment->p_offset + segment->p_filesz))))
2398 printf ("%s ", SECTION_NAME (section));
2405 free (program_headers);
2412 get_32bit_section_headers (file)
2415 Elf32_External_Shdr * shdrs;
2416 Elf32_Internal_Shdr * internal;
2419 GET_DATA_ALLOC (elf_header.e_shoff,
2420 elf_header.e_shentsize * elf_header.e_shnum,
2421 shdrs, Elf32_External_Shdr *, "section headers");
2423 section_headers = (Elf_Internal_Shdr *) malloc
2424 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2426 if (section_headers == NULL)
2428 error (_("Out of memory\n"));
2432 for (i = 0, internal = section_headers;
2433 i < elf_header.e_shnum;
2436 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2437 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2438 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2439 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2440 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2441 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2442 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2443 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2444 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2445 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2454 get_64bit_section_headers (file)
2457 Elf64_External_Shdr * shdrs;
2458 Elf64_Internal_Shdr * internal;
2461 GET_DATA_ALLOC (elf_header.e_shoff,
2462 elf_header.e_shentsize * elf_header.e_shnum,
2463 shdrs, Elf64_External_Shdr *, "section headers");
2465 section_headers = (Elf_Internal_Shdr *) malloc
2466 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2468 if (section_headers == NULL)
2470 error (_("Out of memory\n"));
2474 for (i = 0, internal = section_headers;
2475 i < elf_header.e_shnum;
2478 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2479 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2480 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2481 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2482 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2483 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2484 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2485 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2486 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2487 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2495 static Elf_Internal_Sym *
2496 get_32bit_elf_symbols (file, offset, number)
2498 unsigned long offset;
2499 unsigned long number;
2501 Elf32_External_Sym * esyms;
2502 Elf_Internal_Sym * isyms;
2503 Elf_Internal_Sym * psym;
2506 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2507 esyms, Elf32_External_Sym *, "symbols");
2509 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2513 error (_("Out of memory\n"));
2519 for (j = 0, psym = isyms;
2523 psym->st_name = BYTE_GET (esyms[j].st_name);
2524 psym->st_value = BYTE_GET (esyms[j].st_value);
2525 psym->st_size = BYTE_GET (esyms[j].st_size);
2526 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2527 psym->st_info = BYTE_GET (esyms[j].st_info);
2528 psym->st_other = BYTE_GET (esyms[j].st_other);
2536 static Elf_Internal_Sym *
2537 get_64bit_elf_symbols (file, offset, number)
2539 unsigned long offset;
2540 unsigned long number;
2542 Elf64_External_Sym * esyms;
2543 Elf_Internal_Sym * isyms;
2544 Elf_Internal_Sym * psym;
2547 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2548 esyms, Elf64_External_Sym *, "symbols");
2550 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2554 error (_("Out of memory\n"));
2560 for (j = 0, psym = isyms;
2564 psym->st_name = BYTE_GET (esyms[j].st_name);
2565 psym->st_info = BYTE_GET (esyms[j].st_info);
2566 psym->st_other = BYTE_GET (esyms[j].st_other);
2567 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2568 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2569 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2578 get_elf_section_flags (sh_flags)
2581 static char buff [32];
2589 flag = sh_flags & - sh_flags;
2594 case SHF_WRITE: strcat (buff, "W"); break;
2595 case SHF_ALLOC: strcat (buff, "A"); break;
2596 case SHF_EXECINSTR: strcat (buff, "X"); break;
2597 case SHF_MERGE: strcat (buff, "M"); break;
2598 case SHF_STRINGS: strcat (buff, "S"); break;
2599 case SHF_INFO_LINK: strcat (buff, "I"); break;
2600 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2601 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2604 if (flag & SHF_MASKOS)
2607 sh_flags &= ~ SHF_MASKOS;
2609 else if (flag & SHF_MASKPROC)
2612 sh_flags &= ~ SHF_MASKPROC;
2624 process_section_headers (file)
2627 Elf_Internal_Shdr * section;
2630 section_headers = NULL;
2632 if (elf_header.e_shnum == 0)
2635 printf (_("\nThere are no sections in this file.\n"));
2640 if (do_sections && !do_header)
2641 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2642 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2646 if (! get_32bit_section_headers (file))
2649 else if (! get_64bit_section_headers (file))
2652 /* Read in the string table, so that we have names to display. */
2653 section = section_headers + elf_header.e_shstrndx;
2655 if (section->sh_size != 0)
2657 unsigned long string_table_offset;
2659 string_table_offset = section->sh_offset;
2661 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2662 string_table, char *, "string table");
2665 /* Scan the sections for the dynamic symbol table
2666 and dynamic string table and debug sections. */
2667 dynamic_symbols = NULL;
2668 dynamic_strings = NULL;
2669 dynamic_syminfo = NULL;
2671 for (i = 0, section = section_headers;
2672 i < elf_header.e_shnum;
2675 char * name = SECTION_NAME (section);
2677 if (section->sh_type == SHT_DYNSYM)
2679 if (dynamic_symbols != NULL)
2681 error (_("File contains multiple dynamic symbol tables\n"));
2685 num_dynamic_syms = section->sh_size / section->sh_entsize;
2687 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2689 else if (section->sh_type == SHT_STRTAB
2690 && strcmp (name, ".dynstr") == 0)
2692 if (dynamic_strings != NULL)
2694 error (_("File contains multiple dynamic string tables\n"));
2698 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2699 dynamic_strings, char *, "dynamic strings");
2701 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2702 || do_debug_lines || do_debug_pubnames || do_debug_aranges)
2703 && strncmp (name, ".debug_", 7) == 0)
2708 || (do_debug_info && (strcmp (name, "info") == 0))
2709 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2710 || (do_debug_lines && (strcmp (name, "line") == 0))
2711 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2712 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2714 request_dump (i, DEBUG_DUMP);
2721 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2725 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2728 printf (_(" [Nr] Name Type Address Offset\n"));
2729 printf (_(" Size EntSize Flags Link Info Align\n"));
2732 for (i = 0, section = section_headers;
2733 i < elf_header.e_shnum;
2736 printf (" [%2d] %-17.17s %-15.15s ",
2738 SECTION_NAME (section),
2739 get_section_type_name (section->sh_type));
2743 print_vma (section->sh_addr, LONG_HEX);
2745 printf ( " %6.6lx %6.6lx %2.2lx",
2746 (unsigned long) section->sh_offset,
2747 (unsigned long) section->sh_size,
2748 (unsigned long) section->sh_entsize);
2750 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2752 printf (" %2ld %3lx %ld\n",
2753 (unsigned long) section->sh_link,
2754 (unsigned long) section->sh_info,
2755 (unsigned long) section->sh_addralign);
2760 print_vma (section->sh_addr, LONG_HEX);
2761 printf (" %8.8lx", section->sh_offset);
2763 print_vma (section->sh_size, LONG_HEX);
2765 print_vma (section->sh_entsize, LONG_HEX);
2767 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2769 printf (" %2ld %3lx %ld\n",
2770 (unsigned long) section->sh_link,
2771 (unsigned long) section->sh_info,
2772 (unsigned long) section->sh_addralign);
2776 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2777 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2778 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2783 /* Process the reloc section. */
2785 process_relocs (file)
2788 unsigned long rel_size;
2789 unsigned long rel_offset;
2795 if (do_using_dynamic)
2797 int is_rela = FALSE;
2802 if (dynamic_info[DT_REL])
2804 rel_offset = dynamic_info[DT_REL];
2805 rel_size = dynamic_info[DT_RELSZ];
2808 else if (dynamic_info [DT_RELA])
2810 rel_offset = dynamic_info[DT_RELA];
2811 rel_size = dynamic_info[DT_RELASZ];
2814 else if (dynamic_info[DT_JMPREL])
2816 rel_offset = dynamic_info[DT_JMPREL];
2817 rel_size = dynamic_info[DT_PLTRELSZ];
2819 switch (dynamic_info[DT_PLTREL])
2836 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2837 rel_offset, rel_size);
2839 dump_relocations (file, rel_offset - loadaddr, rel_size,
2840 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2843 printf (_("\nThere are no dynamic relocations in this file.\n"));
2847 Elf32_Internal_Shdr * section;
2851 for (i = 0, section = section_headers;
2852 i < elf_header.e_shnum;
2855 if ( section->sh_type != SHT_RELA
2856 && section->sh_type != SHT_REL)
2859 rel_offset = section->sh_offset;
2860 rel_size = section->sh_size;
2864 Elf32_Internal_Shdr * strsec;
2865 Elf32_Internal_Shdr * symsec;
2866 Elf_Internal_Sym * symtab;
2869 unsigned long nsyms;
2871 printf (_("\nRelocation section "));
2873 if (string_table == NULL)
2874 printf ("%d", section->sh_name);
2876 printf ("'%s'", SECTION_NAME (section));
2878 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2879 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2881 symsec = section_headers + section->sh_link;
2883 nsyms = symsec->sh_size / symsec->sh_entsize;
2884 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2889 strsec = section_headers + symsec->sh_link;
2891 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2892 char *, "string table");
2894 is_rela = section->sh_type == SHT_RELA;
2896 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2906 printf (_("\nThere are no relocations in this file.\n"));
2914 dynamic_segment_mips_val (entry)
2915 Elf_Internal_Dyn * entry;
2917 switch (entry->d_tag)
2920 if (entry->d_un.d_val == 0)
2924 static const char * opts[] =
2926 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2927 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2928 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2929 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2934 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2935 if (entry->d_un.d_val & (1 << cnt))
2937 printf ("%s%s", first ? "" : " ", opts[cnt]);
2944 case DT_MIPS_IVERSION:
2945 if (dynamic_strings != NULL)
2946 printf ("Interface Version: %s\n",
2947 dynamic_strings + entry->d_un.d_val);
2949 printf ("%ld\n", (long) entry->d_un.d_ptr);
2952 case DT_MIPS_TIME_STAMP:
2957 time_t time = entry->d_un.d_val;
2958 tmp = gmtime (&time);
2959 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
2960 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
2961 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
2962 printf ("Time Stamp: %s\n", timebuf);
2966 case DT_MIPS_RLD_VERSION:
2967 case DT_MIPS_LOCAL_GOTNO:
2968 case DT_MIPS_CONFLICTNO:
2969 case DT_MIPS_LIBLISTNO:
2970 case DT_MIPS_SYMTABNO:
2971 case DT_MIPS_UNREFEXTNO:
2972 case DT_MIPS_HIPAGENO:
2973 case DT_MIPS_DELTA_CLASS_NO:
2974 case DT_MIPS_DELTA_INSTANCE_NO:
2975 case DT_MIPS_DELTA_RELOC_NO:
2976 case DT_MIPS_DELTA_SYM_NO:
2977 case DT_MIPS_DELTA_CLASSSYM_NO:
2978 case DT_MIPS_COMPACT_SIZE:
2979 printf ("%ld\n", (long) entry->d_un.d_ptr);
2983 printf ("%#lx\n", (long) entry->d_un.d_ptr);
2989 dynamic_segment_parisc_val (entry)
2990 Elf_Internal_Dyn * entry;
2992 switch (entry->d_tag)
2994 case DT_HP_DLD_FLAGS:
3003 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3004 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3005 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3006 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3007 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3008 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3009 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3010 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3011 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3012 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3013 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3017 bfd_vma val = entry->d_un.d_val;
3019 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3020 if (val & flags[cnt].bit)
3024 fputs (flags[cnt].str, stdout);
3026 val ^= flags[cnt].bit;
3029 if (val != 0 || first)
3033 print_vma (val, HEX);
3039 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3045 get_32bit_dynamic_segment (file)
3048 Elf32_External_Dyn * edyn;
3049 Elf_Internal_Dyn * entry;
3052 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3053 edyn, Elf32_External_Dyn *, "dynamic segment");
3055 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3056 how large this .dynamic is now. We can do this even before the byte
3057 swapping since the DT_NULL tag is recognizable. */
3059 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3062 dynamic_segment = (Elf_Internal_Dyn *)
3063 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3065 if (dynamic_segment == NULL)
3067 error (_("Out of memory\n"));
3072 for (i = 0, entry = dynamic_segment;
3076 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3077 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3086 get_64bit_dynamic_segment (file)
3089 Elf64_External_Dyn * edyn;
3090 Elf_Internal_Dyn * entry;
3093 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3094 edyn, Elf64_External_Dyn *, "dynamic segment");
3096 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3097 how large this .dynamic is now. We can do this even before the byte
3098 swapping since the DT_NULL tag is recognizable. */
3100 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3103 dynamic_segment = (Elf_Internal_Dyn *)
3104 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3106 if (dynamic_segment == NULL)
3108 error (_("Out of memory\n"));
3113 for (i = 0, entry = dynamic_segment;
3117 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3118 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3127 get_dynamic_flags (flags)
3130 static char buff [64];
3135 flag = flags & - flags;
3140 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3141 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3142 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3143 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3144 default: strcat (buff, "unknown "); break;
3150 /* Parse and display the contents of the dynamic segment. */
3152 process_dynamic_segment (file)
3155 Elf_Internal_Dyn * entry;
3158 if (dynamic_size == 0)
3161 printf (_("\nThere is no dynamic segment in this file.\n"));
3168 if (! get_32bit_dynamic_segment (file))
3171 else if (! get_64bit_dynamic_segment (file))
3174 /* Find the appropriate symbol table. */
3175 if (dynamic_symbols == NULL)
3177 for (i = 0, entry = dynamic_segment;
3181 unsigned long offset;
3183 if (entry->d_tag != DT_SYMTAB)
3186 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3188 /* Since we do not know how big the symbol table is,
3189 we default to reading in the entire file (!) and
3190 processing that. This is overkill, I know, but it
3192 offset = entry->d_un.d_val - loadaddr;
3194 if (fseek (file, 0, SEEK_END))
3195 error (_("Unable to seek to end of file!"));
3198 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3200 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3202 if (num_dynamic_syms < 1)
3204 error (_("Unable to determine the number of symbols to load\n"));
3208 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3212 /* Similarly find a string table. */
3213 if (dynamic_strings == NULL)
3215 for (i = 0, entry = dynamic_segment;
3219 unsigned long offset;
3222 if (entry->d_tag != DT_STRTAB)
3225 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3227 /* Since we do not know how big the string table is,
3228 we default to reading in the entire file (!) and
3229 processing that. This is overkill, I know, but it
3232 offset = entry->d_un.d_val - loadaddr;
3233 if (fseek (file, 0, SEEK_END))
3234 error (_("Unable to seek to end of file\n"));
3235 str_tab_len = ftell (file) - offset;
3237 if (str_tab_len < 1)
3240 (_("Unable to determine the length of the dynamic string table\n"));
3244 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3245 "dynamic string table");
3251 /* And find the syminfo section if available. */
3252 if (dynamic_syminfo == NULL)
3254 unsigned int syminsz = 0;
3256 for (i = 0, entry = dynamic_segment;
3260 if (entry->d_tag == DT_SYMINENT)
3262 /* Note: these braces are necessary to avoid a syntax
3263 error from the SunOS4 C compiler. */
3264 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3266 else if (entry->d_tag == DT_SYMINSZ)
3267 syminsz = entry->d_un.d_val;
3268 else if (entry->d_tag == DT_SYMINFO)
3269 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3272 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3274 Elf_External_Syminfo * extsyminfo;
3275 Elf_Internal_Syminfo * syminfo;
3277 /* There is a syminfo section. Read the data. */
3278 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3279 Elf_External_Syminfo *, "symbol information");
3281 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3282 if (dynamic_syminfo == NULL)
3284 error (_("Out of memory\n"));
3288 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3289 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3292 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3293 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3300 if (do_dynamic && dynamic_addr)
3301 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3302 dynamic_addr, (long) dynamic_size);
3304 printf (_(" Tag Type Name/Value\n"));
3306 for (i = 0, entry = dynamic_segment;
3315 print_vma (entry->d_tag, FULL_HEX);
3316 dtype = get_dynamic_type (entry->d_tag);
3317 printf (" (%s)%*s", dtype,
3318 ((is_32bit_elf ? 27 : 19)
3319 - (int) strlen (dtype)),
3323 switch (entry->d_tag)
3327 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3337 switch (entry->d_tag)
3340 printf (_("Auxiliary library"));
3344 printf (_("Filter library"));
3348 printf (_("Configuration file"));
3352 printf (_("Dependency audit library"));
3356 printf (_("Audit library"));
3360 if (dynamic_strings)
3361 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3365 print_vma (entry->d_un.d_val, PREFIX_HEX);
3374 printf (_("Flags:"));
3375 if (entry->d_un.d_val == 0)
3376 printf (_(" None\n"));
3379 unsigned long int val = entry->d_un.d_val;
3380 if (val & DTF_1_PARINIT)
3382 printf (" PARINIT");
3383 val ^= DTF_1_PARINIT;
3385 if (val & DTF_1_CONFEXP)
3387 printf (" CONFEXP");
3388 val ^= DTF_1_CONFEXP;
3391 printf (" %lx", val);
3400 printf (_("Flags:"));
3401 if (entry->d_un.d_val == 0)
3402 printf (_(" None\n"));
3405 unsigned long int val = entry->d_un.d_val;
3406 if (val & DF_P1_LAZYLOAD)
3408 printf (" LAZYLOAD");
3409 val ^= DF_P1_LAZYLOAD;
3411 if (val & DF_P1_GROUPPERM)
3413 printf (" GROUPPERM");
3414 val ^= DF_P1_GROUPPERM;
3417 printf (" %lx", val);
3426 printf (_("Flags:"));
3427 if (entry->d_un.d_val == 0)
3428 printf (_(" None\n"));
3431 unsigned long int val = entry->d_un.d_val;
3437 if (val & DF_1_GLOBAL)
3442 if (val & DF_1_GROUP)
3447 if (val & DF_1_NODELETE)
3449 printf (" NODELETE");
3450 val ^= DF_1_NODELETE;
3452 if (val & DF_1_LOADFLTR)
3454 printf (" LOADFLTR");
3455 val ^= DF_1_LOADFLTR;
3457 if (val & DF_1_INITFIRST)
3459 printf (" INITFIRST");
3460 val ^= DF_1_INITFIRST;
3462 if (val & DF_1_NOOPEN)
3467 if (val & DF_1_ORIGIN)
3472 if (val & DF_1_DIRECT)
3477 if (val & DF_1_TRANS)
3482 if (val & DF_1_INTERPOSE)
3484 printf (" INTERPOSE");
3485 val ^= DF_1_INTERPOSE;
3487 if (val & DF_1_NODEFLIB)
3489 printf (" NODEFLIB");
3490 val ^= DF_1_NODEFLIB;
3492 if (val & DF_1_NODUMP)
3497 if (val & DF_1_CONLFAT)
3499 printf (" CONLFAT");
3500 val ^= DF_1_CONLFAT;
3503 printf (" %lx", val);
3511 puts (get_dynamic_type (entry->d_un.d_val));
3531 dynamic_info[entry->d_tag] = entry->d_un.d_val;
3537 if (dynamic_strings == NULL)
3540 name = dynamic_strings + entry->d_un.d_val;
3544 switch (entry->d_tag)
3547 printf (_("Shared library: [%s]"), name);
3549 if (strcmp (name, program_interpreter) == 0)
3550 printf (_(" program interpreter"));
3554 printf (_("Library soname: [%s]"), name);
3558 printf (_("Library rpath: [%s]"), name);
3562 printf (_("Library runpath: [%s]"), name);
3566 print_vma (entry->d_un.d_val, PREFIX_HEX);
3571 print_vma (entry->d_un.d_val, PREFIX_HEX);
3587 case DT_INIT_ARRAYSZ:
3588 case DT_FINI_ARRAYSZ:
3591 print_vma (entry->d_un.d_val, UNSIGNED);
3592 printf (" (bytes)\n");
3602 print_vma (entry->d_un.d_val, UNSIGNED);
3615 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3619 name = dynamic_strings + entry->d_un.d_val;
3623 printf (_("Not needed object: [%s]\n"), name);
3628 print_vma (entry->d_un.d_val, PREFIX_HEX);
3634 /* The value of this entry is ignored. */
3638 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3639 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3644 switch (elf_header.e_machine)
3647 case EM_MIPS_RS4_BE:
3648 dynamic_segment_mips_val (entry);
3651 dynamic_segment_parisc_val (entry);
3654 print_vma (entry->d_un.d_val, PREFIX_HEX);
3666 get_ver_flags (flags)
3669 static char buff [32];
3676 if (flags & VER_FLG_BASE)
3677 strcat (buff, "BASE ");
3679 if (flags & VER_FLG_WEAK)
3681 if (flags & VER_FLG_BASE)
3682 strcat (buff, "| ");
3684 strcat (buff, "WEAK ");
3687 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3688 strcat (buff, "| <unknown>");
3693 /* Display the contents of the version sections. */
3695 process_version_sections (file)
3698 Elf32_Internal_Shdr * section;
3705 for (i = 0, section = section_headers;
3706 i < elf_header.e_shnum;
3709 switch (section->sh_type)
3711 case SHT_GNU_verdef:
3713 Elf_External_Verdef * edefs;
3720 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3721 SECTION_NAME (section), section->sh_info);
3723 printf (_(" Addr: 0x"));
3724 printf_vma (section->sh_addr);
3725 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3726 (unsigned long) section->sh_offset, section->sh_link,
3727 SECTION_NAME (section_headers + section->sh_link));
3729 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3730 edefs, Elf_External_Verdef *,
3731 "version definition section");
3733 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3736 Elf_External_Verdef * edef;
3737 Elf_Internal_Verdef ent;
3738 Elf_External_Verdaux * eaux;
3739 Elf_Internal_Verdaux aux;
3743 vstart = ((char *) edefs) + idx;
3745 edef = (Elf_External_Verdef *) vstart;
3747 ent.vd_version = BYTE_GET (edef->vd_version);
3748 ent.vd_flags = BYTE_GET (edef->vd_flags);
3749 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
3750 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
3751 ent.vd_hash = BYTE_GET (edef->vd_hash);
3752 ent.vd_aux = BYTE_GET (edef->vd_aux);
3753 ent.vd_next = BYTE_GET (edef->vd_next);
3755 printf (_(" %#06x: Rev: %d Flags: %s"),
3756 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3758 printf (_(" Index: %d Cnt: %d "),
3759 ent.vd_ndx, ent.vd_cnt);
3761 vstart += ent.vd_aux;
3763 eaux = (Elf_External_Verdaux *) vstart;
3765 aux.vda_name = BYTE_GET (eaux->vda_name);
3766 aux.vda_next = BYTE_GET (eaux->vda_next);
3768 if (dynamic_strings)
3769 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3771 printf (_("Name index: %ld\n"), aux.vda_name);
3773 isum = idx + ent.vd_aux;
3775 for (j = 1; j < ent.vd_cnt; j ++)
3777 isum += aux.vda_next;
3778 vstart += aux.vda_next;
3780 eaux = (Elf_External_Verdaux *) vstart;
3782 aux.vda_name = BYTE_GET (eaux->vda_name);
3783 aux.vda_next = BYTE_GET (eaux->vda_next);
3785 if (dynamic_strings)
3786 printf (_(" %#06x: Parent %d: %s\n"),
3787 isum, j, dynamic_strings + aux.vda_name);
3789 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3790 isum, j, aux.vda_name);
3800 case SHT_GNU_verneed:
3802 Elf_External_Verneed * eneed;
3808 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3809 SECTION_NAME (section), section->sh_info);
3811 printf (_(" Addr: 0x"));
3812 printf_vma (section->sh_addr);
3813 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3814 (unsigned long) section->sh_offset, section->sh_link,
3815 SECTION_NAME (section_headers + section->sh_link));
3817 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3818 eneed, Elf_External_Verneed *,
3819 "version need section");
3821 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3823 Elf_External_Verneed * entry;
3824 Elf_Internal_Verneed ent;
3829 vstart = ((char *) eneed) + idx;
3831 entry = (Elf_External_Verneed *) vstart;
3833 ent.vn_version = BYTE_GET (entry->vn_version);
3834 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
3835 ent.vn_file = BYTE_GET (entry->vn_file);
3836 ent.vn_aux = BYTE_GET (entry->vn_aux);
3837 ent.vn_next = BYTE_GET (entry->vn_next);
3839 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
3841 if (dynamic_strings)
3842 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
3844 printf (_(" File: %lx"), ent.vn_file);
3846 printf (_(" Cnt: %d\n"), ent.vn_cnt);
3848 vstart += ent.vn_aux;
3850 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3852 Elf_External_Vernaux * eaux;
3853 Elf_Internal_Vernaux aux;
3855 eaux = (Elf_External_Vernaux *) vstart;
3857 aux.vna_hash = BYTE_GET (eaux->vna_hash);
3858 aux.vna_flags = BYTE_GET (eaux->vna_flags);
3859 aux.vna_other = BYTE_GET (eaux->vna_other);
3860 aux.vna_name = BYTE_GET (eaux->vna_name);
3861 aux.vna_next = BYTE_GET (eaux->vna_next);
3863 if (dynamic_strings)
3864 printf (_(" %#06x: Name: %s"),
3865 isum, dynamic_strings + aux.vna_name);
3867 printf (_(" %#06x: Name index: %lx"),
3868 isum, aux.vna_name);
3870 printf (_(" Flags: %s Version: %d\n"),
3871 get_ver_flags (aux.vna_flags), aux.vna_other);
3873 isum += aux.vna_next;
3874 vstart += aux.vna_next;
3884 case SHT_GNU_versym:
3886 Elf32_Internal_Shdr * link_section;
3889 unsigned char * edata;
3890 unsigned short * data;
3892 Elf_Internal_Sym * symbols;
3893 Elf32_Internal_Shdr * string_sec;
3895 link_section = section_headers + section->sh_link;
3896 total = section->sh_size / section->sh_entsize;
3900 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3901 link_section->sh_size / link_section->sh_entsize);
3903 string_sec = section_headers + link_section->sh_link;
3905 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3906 strtab, char *, "version string table");
3908 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3909 SECTION_NAME (section), total);
3911 printf (_(" Addr: "));
3912 printf_vma (section->sh_addr);
3913 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3914 (unsigned long) section->sh_offset, section->sh_link,
3915 SECTION_NAME (link_section));
3917 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3919 total * sizeof (short), edata,
3920 unsigned char *, "version symbol data");
3922 data = (unsigned short *) malloc (total * sizeof (short));
3924 for (cnt = total; cnt --;)
3925 data [cnt] = byte_get (edata + cnt * sizeof (short),
3930 for (cnt = 0; cnt < total; cnt += 4)
3935 printf (" %03x:", cnt);
3937 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3938 switch (data [cnt + j])
3941 fputs (_(" 0 (*local*) "), stdout);
3945 fputs (_(" 1 (*global*) "), stdout);
3949 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
3950 data [cnt + j] & 0x8000 ? 'h' : ' ');
3952 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
3953 && section_headers[symbols [cnt + j].st_shndx].sh_type
3956 /* We must test both. */
3957 Elf_Internal_Verneed ivn;
3958 unsigned long offset;
3960 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3965 Elf_External_Verneed evn;
3966 Elf_External_Vernaux evna;
3967 Elf_Internal_Vernaux ivna;
3968 unsigned long vna_off;
3970 GET_DATA (offset, evn, "version need");
3972 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3973 ivn.vn_next = BYTE_GET (evn.vn_next);
3975 vna_off = offset + ivn.vn_aux;
3979 GET_DATA (vna_off, evna,
3980 "version need aux (1)");
3982 ivna.vna_next = BYTE_GET (evna.vna_next);
3983 ivna.vna_other = BYTE_GET (evna.vna_other);
3985 vna_off += ivna.vna_next;
3987 while (ivna.vna_other != data [cnt + j]
3988 && ivna.vna_next != 0);
3990 if (ivna.vna_other == data [cnt + j])
3992 ivna.vna_name = BYTE_GET (evna.vna_name);
3994 name = strtab + ivna.vna_name;
3995 nn += printf ("(%s%-*s",
3997 12 - (int) strlen (name),
4001 else if (ivn.vn_next == 0)
4003 if (data [cnt + j] != 0x8001)
4005 Elf_Internal_Verdef ivd;
4006 Elf_External_Verdef evd;
4008 offset = version_info
4009 [DT_VERSIONTAGIDX (DT_VERDEF)]
4014 GET_DATA (offset, evd,
4015 "version definition");
4017 ivd.vd_next = BYTE_GET (evd.vd_next);
4018 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4020 offset += ivd.vd_next;
4023 != (data [cnt + j] & 0x7fff)
4024 && ivd.vd_next != 0);
4027 == (data [cnt + j] & 0x7fff))
4029 Elf_External_Verdaux evda;
4030 Elf_Internal_Verdaux ivda;
4032 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4034 GET_DATA (offset + ivd.vd_aux, evda,
4035 "version definition aux");
4038 BYTE_GET (evda.vda_name);
4040 name = strtab + ivda.vda_name;
4044 12 - (int) strlen (name),
4052 offset += ivn.vn_next;
4054 while (ivn.vn_next);
4056 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4058 Elf_Internal_Verneed ivn;
4059 unsigned long offset;
4061 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4066 Elf_Internal_Vernaux ivna;
4067 Elf_External_Verneed evn;
4068 Elf_External_Vernaux evna;
4069 unsigned long a_off;
4071 GET_DATA (offset, evn, "version need");
4073 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4074 ivn.vn_next = BYTE_GET (evn.vn_next);
4076 a_off = offset + ivn.vn_aux;
4080 GET_DATA (a_off, evna,
4081 "version need aux (2)");
4083 ivna.vna_next = BYTE_GET (evna.vna_next);
4084 ivna.vna_other = BYTE_GET (evna.vna_other);
4086 a_off += ivna.vna_next;
4088 while (ivna.vna_other != data [cnt + j]
4089 && ivna.vna_next != 0);
4091 if (ivna.vna_other == data [cnt + j])
4093 ivna.vna_name = BYTE_GET (evna.vna_name);
4095 name = strtab + ivna.vna_name;
4096 nn += printf ("(%s%-*s",
4098 12 - (int) strlen (name),
4103 offset += ivn.vn_next;
4105 while (ivn.vn_next);
4107 else if (data [cnt + j] != 0x8001)
4109 Elf_Internal_Verdef ivd;
4110 Elf_External_Verdef evd;
4111 unsigned long offset;
4113 offset = version_info
4114 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4118 GET_DATA (offset, evd, "version def");
4120 ivd.vd_next = BYTE_GET (evd.vd_next);
4121 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4123 offset += ivd.vd_next;
4125 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4126 && ivd.vd_next != 0);
4128 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4130 Elf_External_Verdaux evda;
4131 Elf_Internal_Verdaux ivda;
4133 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4135 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4136 evda, "version def aux");
4138 ivda.vda_name = BYTE_GET (evda.vda_name);
4140 name = strtab + ivda.vda_name;
4141 nn += printf ("(%s%-*s",
4143 12 - (int) strlen (name),
4149 printf ("%*c", 18 - nn, ' ');
4167 printf (_("\nNo version information found in this file.\n"));
4173 get_symbol_binding (binding)
4174 unsigned int binding;
4176 static char buff [32];
4180 case STB_LOCAL: return "LOCAL";
4181 case STB_GLOBAL: return "GLOBAL";
4182 case STB_WEAK: return "WEAK";
4184 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4185 sprintf (buff, _("<processor specific>: %d"), binding);
4186 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4187 sprintf (buff, _("<OS specific>: %d"), binding);
4189 sprintf (buff, _("<unknown>: %d"), binding);
4195 get_symbol_type (type)
4198 static char buff [32];
4202 case STT_NOTYPE: return "NOTYPE";
4203 case STT_OBJECT: return "OBJECT";
4204 case STT_FUNC: return "FUNC";
4205 case STT_SECTION: return "SECTION";
4206 case STT_FILE: return "FILE";
4207 case STT_COMMON: return "COMMON";
4209 if (type >= STT_LOPROC && type <= STT_HIPROC)
4211 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4212 return "THUMB_FUNC";
4214 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4217 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4218 return "PARISC_MILLI";
4220 sprintf (buff, _("<processor specific>: %d"), type);
4222 else if (type >= STT_LOOS && type <= STT_HIOS)
4224 if (elf_header.e_machine == EM_PARISC)
4226 if (type == STT_HP_OPAQUE)
4228 if (type == STT_HP_STUB)
4232 sprintf (buff, _("<OS specific>: %d"), type);
4235 sprintf (buff, _("<unknown>: %d"), type);
4241 get_symbol_visibility (visibility)
4242 unsigned int visibility;
4246 case STV_DEFAULT: return "DEFAULT";
4247 case STV_INTERNAL: return "INTERNAL";
4248 case STV_HIDDEN: return "HIDDEN";
4249 case STV_PROTECTED: return "PROTECTED";
4255 get_symbol_index_type (type)
4260 case SHN_UNDEF: return "UND";
4261 case SHN_ABS: return "ABS";
4262 case SHN_COMMON: return "COM";
4264 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4266 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4268 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4272 static char buff [32];
4274 sprintf (buff, "%3d", type);
4281 get_dynamic_data (file, number)
4283 unsigned int number;
4285 unsigned char * e_data;
4288 e_data = (unsigned char *) malloc (number * 4);
4292 error (_("Out of memory\n"));
4296 if (fread (e_data, 4, number, file) != number)
4298 error (_("Unable to read in dynamic data\n"));
4302 i_data = (int *) malloc (number * sizeof (* i_data));
4306 error (_("Out of memory\n"));
4312 i_data [number] = byte_get (e_data + number * 4, 4);
4319 /* Dump the symbol table */
4321 process_symbol_table (file)
4324 Elf32_Internal_Shdr * section;
4325 unsigned char nb [4];
4326 unsigned char nc [4];
4329 int * buckets = NULL;
4330 int * chains = NULL;
4332 if (! do_syms && !do_histogram)
4335 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4338 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4340 error (_("Unable to seek to start of dynamic information"));
4344 if (fread (nb, sizeof (nb), 1, file) != 1)
4346 error (_("Failed to read in number of buckets\n"));
4350 if (fread (nc, sizeof (nc), 1, file) != 1)
4352 error (_("Failed to read in number of chains\n"));
4356 nbuckets = byte_get (nb, 4);
4357 nchains = byte_get (nc, 4);
4359 buckets = get_dynamic_data (file, nbuckets);
4360 chains = get_dynamic_data (file, nchains);
4362 if (buckets == NULL || chains == NULL)
4367 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4372 printf (_("\nSymbol table for image:\n"));
4374 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4376 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4378 for (hn = 0; hn < nbuckets; hn++)
4383 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4385 Elf_Internal_Sym * psym;
4387 psym = dynamic_symbols + si;
4389 printf (" %3d %3d: ", si, hn);
4390 print_vma (psym->st_value, LONG_HEX);
4392 print_vma (psym->st_size, DEC_5);
4394 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4395 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4396 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4397 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4398 printf (" %s\n", dynamic_strings + psym->st_name);
4402 else if (do_syms && !do_using_dynamic)
4406 for (i = 0, section = section_headers;
4407 i < elf_header.e_shnum;
4412 Elf_Internal_Sym * symtab;
4413 Elf_Internal_Sym * psym;
4416 if ( section->sh_type != SHT_SYMTAB
4417 && section->sh_type != SHT_DYNSYM)
4420 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4421 SECTION_NAME (section),
4422 (unsigned long) (section->sh_size / section->sh_entsize));
4424 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4426 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4428 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4429 section->sh_size / section->sh_entsize);
4433 if (section->sh_link == elf_header.e_shstrndx)
4434 strtab = string_table;
4437 Elf32_Internal_Shdr * string_sec;
4439 string_sec = section_headers + section->sh_link;
4441 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4442 strtab, char *, "string table");
4445 for (si = 0, psym = symtab;
4446 si < section->sh_size / section->sh_entsize;
4449 printf ("%6d: ", si);
4450 print_vma (psym->st_value, LONG_HEX);
4452 print_vma (psym->st_size, DEC_5);
4453 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4454 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4455 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4456 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4457 printf (" %s", strtab + psym->st_name);
4459 if (section->sh_type == SHT_DYNSYM &&
4460 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4462 unsigned char data[2];
4463 unsigned short vers_data;
4464 unsigned long offset;
4468 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4471 GET_DATA (offset + si * sizeof (vers_data), data,
4474 vers_data = byte_get (data, 2);
4476 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4477 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4480 check_def = (psym->st_shndx != SHN_UNDEF);
4482 if ((vers_data & 0x8000) || vers_data > 1)
4484 if (is_nobits || ! check_def)
4486 Elf_External_Verneed evn;
4487 Elf_Internal_Verneed ivn;
4488 Elf_Internal_Vernaux ivna;
4490 /* We must test both. */
4491 offset = version_info
4492 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4496 unsigned long vna_off;
4498 GET_DATA (offset, evn, "version need");
4500 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4501 ivn.vn_next = BYTE_GET (evn.vn_next);
4503 vna_off = offset + ivn.vn_aux;
4507 Elf_External_Vernaux evna;
4509 GET_DATA (vna_off, evna,
4510 "version need aux (3)");
4512 ivna.vna_other = BYTE_GET (evna.vna_other);
4513 ivna.vna_next = BYTE_GET (evna.vna_next);
4514 ivna.vna_name = BYTE_GET (evna.vna_name);
4516 vna_off += ivna.vna_next;
4518 while (ivna.vna_other != vers_data
4519 && ivna.vna_next != 0);
4521 if (ivna.vna_other == vers_data)
4524 offset += ivn.vn_next;
4526 while (ivn.vn_next != 0);
4528 if (ivna.vna_other == vers_data)
4531 strtab + ivna.vna_name, ivna.vna_other);
4534 else if (! is_nobits)
4535 error (_("bad dynamic symbol"));
4542 if (vers_data != 0x8001)
4544 Elf_Internal_Verdef ivd;
4545 Elf_Internal_Verdaux ivda;
4546 Elf_External_Verdaux evda;
4547 unsigned long offset;
4550 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4555 Elf_External_Verdef evd;
4557 GET_DATA (offset, evd, "version def");
4559 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4560 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4561 ivd.vd_next = BYTE_GET (evd.vd_next);
4563 offset += ivd.vd_next;
4565 while (ivd.vd_ndx != (vers_data & 0x7fff)
4566 && ivd.vd_next != 0);
4568 offset -= ivd.vd_next;
4569 offset += ivd.vd_aux;
4571 GET_DATA (offset, evda, "version def aux");
4573 ivda.vda_name = BYTE_GET (evda.vda_name);
4575 if (psym->st_name != ivda.vda_name)
4576 printf ((vers_data & 0x8000)
4578 strtab + ivda.vda_name);
4588 if (strtab != string_table)
4594 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4596 if (do_histogram && buckets != NULL)
4603 int nzero_counts = 0;
4606 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4608 printf (_(" Length Number %% of total Coverage\n"));
4610 lengths = (int *) calloc (nbuckets, sizeof (int));
4611 if (lengths == NULL)
4613 error (_("Out of memory"));
4616 for (hn = 0; hn < nbuckets; ++hn)
4621 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4624 if (maxlength < ++lengths[hn])
4629 counts = (int *) calloc (maxlength + 1, sizeof (int));
4632 error (_("Out of memory"));
4636 for (hn = 0; hn < nbuckets; ++hn)
4637 ++ counts [lengths [hn]];
4641 printf (" 0 %-10d (%5.1f%%)\n",
4642 counts[0], (counts[0] * 100.0) / nbuckets);
4643 for (si = 1; si <= maxlength; ++si)
4645 nzero_counts += counts[si] * si;
4646 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4647 si, counts[si], (counts[si] * 100.0) / nbuckets,
4648 (nzero_counts * 100.0) / nsyms);
4656 if (buckets != NULL)
4666 process_syminfo (file)
4667 FILE * file ATTRIBUTE_UNUSED;
4671 if (dynamic_syminfo == NULL
4673 /* No syminfo, this is ok. */
4676 /* There better should be a dynamic symbol section. */
4677 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4681 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4682 dynamic_syminfo_offset, dynamic_syminfo_nent);
4684 printf (_(" Num: Name BoundTo Flags\n"));
4685 for (i = 0; i < dynamic_syminfo_nent; ++i)
4687 unsigned short int flags = dynamic_syminfo[i].si_flags;
4689 printf ("%4d: %-30s ", i,
4690 dynamic_strings + dynamic_symbols[i].st_name);
4692 switch (dynamic_syminfo[i].si_boundto)
4694 case SYMINFO_BT_SELF:
4695 fputs ("SELF ", stdout);
4697 case SYMINFO_BT_PARENT:
4698 fputs ("PARENT ", stdout);
4701 if (dynamic_syminfo[i].si_boundto > 0
4702 && dynamic_syminfo[i].si_boundto < dynamic_size)
4705 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4707 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4711 if (flags & SYMINFO_FLG_DIRECT)
4713 if (flags & SYMINFO_FLG_PASSTHRU)
4714 printf (" PASSTHRU");
4715 if (flags & SYMINFO_FLG_COPY)
4717 if (flags & SYMINFO_FLG_LAZYLOAD)
4718 printf (" LAZYLOAD");
4726 #ifdef SUPPORT_DISASSEMBLY
4728 disassemble_section (section, file)
4729 Elf32_Internal_Shdr * section;
4732 printf (_("\nAssembly dump of section %s\n"),
4733 SECTION_NAME (section));
4735 /* XXX -- to be done --- XXX */
4742 dump_section (section, file)
4743 Elf32_Internal_Shdr * section;
4746 bfd_size_type bytes;
4748 unsigned char * data;
4749 unsigned char * start;
4751 bytes = section->sh_size;
4755 printf (_("\nSection '%s' has no data to dump.\n"),
4756 SECTION_NAME (section));
4760 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4762 addr = section->sh_addr;
4764 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4775 lbytes = (bytes > 16 ? 16 : bytes);
4777 printf (" 0x%8.8lx ", (unsigned long) addr);
4779 switch (elf_header.e_ident [EI_DATA])
4783 for (j = 15; j >= 0; j --)
4786 printf ("%2.2x", data [j]);
4796 for (j = 0; j < 16; j++)
4799 printf ("%2.2x", data [j]);
4809 for (j = 0; j < lbytes; j++)
4812 if (k >= ' ' && k < 0x80)
4831 static unsigned long int
4832 read_leb128 (data, length_return, sign)
4833 unsigned char * data;
4834 int * length_return;
4837 unsigned long int result = 0;
4838 unsigned int num_read = 0;
4847 result |= (byte & 0x7f) << shift;
4852 while (byte & 0x80);
4854 if (length_return != NULL)
4855 * length_return = num_read;
4857 if (sign && (shift < 32) && (byte & 0x40))
4858 result |= -1 << shift;
4863 typedef struct State_Machine_Registers
4865 unsigned long address;
4868 unsigned int column;
4872 /* This variable hold the number of the last entry seen
4873 in the File Table. */
4874 unsigned int last_file_entry;
4877 static SMR state_machine_regs;
4880 reset_state_machine (is_stmt)
4883 state_machine_regs.address = 0;
4884 state_machine_regs.file = 1;
4885 state_machine_regs.line = 1;
4886 state_machine_regs.column = 0;
4887 state_machine_regs.is_stmt = is_stmt;
4888 state_machine_regs.basic_block = 0;
4889 state_machine_regs.end_sequence = 0;
4890 state_machine_regs.last_file_entry = 0;
4893 /* Handled an extend line op. Returns true if this is the end
4896 process_extended_line_op (data, is_stmt, pointer_size)
4897 unsigned char * data;
4901 unsigned char op_code;
4904 unsigned char * name;
4907 len = read_leb128 (data, & bytes_read, 0);
4912 warn (_("badly formed extended line op encountered!"));
4917 op_code = * data ++;
4919 printf (_(" Extended opcode %d: "), op_code);
4923 case DW_LNE_end_sequence:
4924 printf (_("End of Sequence\n\n"));
4925 reset_state_machine (is_stmt);
4928 case DW_LNE_set_address:
4929 adr = byte_get (data, pointer_size);
4930 printf (_("set Address to 0x%lx\n"), adr);
4931 state_machine_regs.address = adr;
4934 case DW_LNE_define_file:
4935 printf (_(" define new File Table entry\n"));
4936 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4938 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4940 data += strlen ((char *) data) + 1;
4941 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4943 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4945 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4946 printf (_("%s\n\n"), name);
4950 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
4957 /* Size of pointers in the .debug_line section. This information is not
4958 really present in that section. It's obtained before dumping the debug
4959 sections by doing some pre-scan of the .debug_info section. */
4960 static int debug_line_pointer_size = 4;
4963 display_debug_lines (section, start, file)
4964 Elf32_Internal_Shdr * section;
4965 unsigned char * start;
4966 FILE * file ATTRIBUTE_UNUSED;
4968 DWARF2_External_LineInfo * external;
4969 DWARF2_Internal_LineInfo info;
4970 unsigned char * standard_opcodes;
4971 unsigned char * data = start;
4972 unsigned char * end = start + section->sh_size;
4973 unsigned char * end_of_sequence;
4976 printf (_("\nDump of debug contents of section %s:\n\n"),
4977 SECTION_NAME (section));
4981 external = (DWARF2_External_LineInfo *) data;
4983 /* Check the length of the block. */
4984 info.li_length = BYTE_GET (external->li_length);
4985 if (info.li_length > section->sh_size)
4988 (_("The line info appears to be corrupt - the section is too small\n"));
4992 /* Check its version number. */
4993 info.li_version = BYTE_GET (external->li_version);
4994 if (info.li_version != 2)
4996 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5000 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5001 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5002 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5003 info.li_line_base = BYTE_GET (external->li_line_base);
5004 info.li_line_range = BYTE_GET (external->li_line_range);
5005 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5007 /* Sign extend the line base field. */
5008 info.li_line_base <<= 24;
5009 info.li_line_base >>= 24;
5011 printf (_(" Length: %ld\n"), info.li_length);
5012 printf (_(" DWARF Version: %d\n"), info.li_version);
5013 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
5014 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5015 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5016 printf (_(" Line Base: %d\n"), info.li_line_base);
5017 printf (_(" Line Range: %d\n"), info.li_line_range);
5018 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5020 end_of_sequence = data + info.li_length + sizeof (info.li_length);
5022 reset_state_machine (info.li_default_is_stmt);
5024 /* Display the contents of the Opcodes table. */
5025 standard_opcodes = data + sizeof (* external);
5027 printf (_("\n Opcodes:\n"));
5029 for (i = 1; i < info.li_opcode_base; i++)
5030 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5032 /* Display the contents of the Directory table. */
5033 data = standard_opcodes + info.li_opcode_base - 1;
5036 printf (_("\n The Directory Table is empty.\n"));
5039 printf (_("\n The Directory Table:\n"));
5043 printf (_(" %s\n"), data);
5045 data += strlen ((char *) data) + 1;
5049 /* Skip the NUL at the end of the table. */
5052 /* Display the contents of the File Name table. */
5054 printf (_("\n The File Name Table is empty.\n"));
5057 printf (_("\n The File Name Table:\n"));
5058 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5062 unsigned char * name;
5065 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5068 data += strlen ((char *) data) + 1;
5070 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5072 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5074 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5076 printf (_("%s\n"), name);
5080 /* Skip the NUL at the end of the table. */
5083 /* Now display the statements. */
5084 printf (_("\n Line Number Statements:\n"));
5087 while (data < end_of_sequence)
5089 unsigned char op_code;
5093 op_code = * data ++;
5097 case DW_LNS_extended_op:
5098 data += process_extended_line_op (data, info.li_default_is_stmt,
5099 debug_line_pointer_size);
5103 printf (_(" Copy\n"));
5106 case DW_LNS_advance_pc:
5107 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5109 state_machine_regs.address += adv;
5110 printf (_(" Advance PC by %d to %lx\n"), adv,
5111 state_machine_regs.address);
5114 case DW_LNS_advance_line:
5115 adv = read_leb128 (data, & bytes_read, 1);
5117 state_machine_regs.line += adv;
5118 printf (_(" Advance Line by %d to %d\n"), adv,
5119 state_machine_regs.line);
5122 case DW_LNS_set_file:
5123 adv = read_leb128 (data, & bytes_read, 0);
5125 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5127 state_machine_regs.file = adv;
5130 case DW_LNS_set_column:
5131 adv = read_leb128 (data, & bytes_read, 0);
5133 printf (_(" Set column to %d\n"), adv);
5134 state_machine_regs.column = adv;
5137 case DW_LNS_negate_stmt:
5138 adv = state_machine_regs.is_stmt;
5140 printf (_(" Set is_stmt to %d\n"), adv);
5141 state_machine_regs.is_stmt = adv;
5144 case DW_LNS_set_basic_block:
5145 printf (_(" Set basic block\n"));
5146 state_machine_regs.basic_block = 1;
5149 case DW_LNS_const_add_pc:
5150 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5151 * info.li_min_insn_length);
5152 state_machine_regs.address += adv;
5153 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5154 state_machine_regs.address);
5157 case DW_LNS_fixed_advance_pc:
5158 adv = byte_get (data, 2);
5160 state_machine_regs.address += adv;
5161 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5162 adv, state_machine_regs.address);
5166 op_code -= info.li_opcode_base;
5167 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5168 state_machine_regs.address += adv;
5169 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5170 op_code, adv, state_machine_regs.address);
5171 adv = (op_code % info.li_line_range) + info.li_line_base;
5172 state_machine_regs.line += adv;
5173 printf (_(" and Line by %d to %d\n"),
5174 adv, state_machine_regs.line);
5185 display_debug_pubnames (section, start, file)
5186 Elf32_Internal_Shdr * section;
5187 unsigned char * start;
5188 FILE * file ATTRIBUTE_UNUSED;
5190 DWARF2_External_PubNames * external;
5191 DWARF2_Internal_PubNames pubnames;
5192 unsigned char * end;
5194 end = start + section->sh_size;
5196 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5200 unsigned char * data;
5201 unsigned long offset;
5203 external = (DWARF2_External_PubNames *) start;
5205 pubnames.pn_length = BYTE_GET (external->pn_length);
5206 pubnames.pn_version = BYTE_GET (external->pn_version);
5207 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5208 pubnames.pn_size = BYTE_GET (external->pn_size);
5210 data = start + sizeof (* external);
5211 start += pubnames.pn_length + sizeof (external->pn_length);
5213 if (pubnames.pn_version != 2)
5215 warn (_("Only DWARF 2 pubnames are currently supported"));
5219 printf (_(" Length: %ld\n"),
5220 pubnames.pn_length);
5221 printf (_(" Version: %d\n"),
5222 pubnames.pn_version);
5223 printf (_(" Offset into .debug_info section: %ld\n"),
5224 pubnames.pn_offset);
5225 printf (_(" Size of area in .debug_info section: %ld\n"),
5228 printf (_("\n Offset\tName\n"));
5232 offset = byte_get (data, 4);
5237 printf (" %ld\t\t%s\n", offset, data);
5238 data += strlen ((char *) data) + 1;
5241 while (offset != 0);
5254 case DW_TAG_padding: return "DW_TAG_padding";
5255 case DW_TAG_array_type: return "DW_TAG_array_type";
5256 case DW_TAG_class_type: return "DW_TAG_class_type";
5257 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5258 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5259 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5260 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5261 case DW_TAG_label: return "DW_TAG_label";
5262 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5263 case DW_TAG_member: return "DW_TAG_member";
5264 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5265 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5266 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5267 case DW_TAG_string_type: return "DW_TAG_string_type";
5268 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5269 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5270 case DW_TAG_typedef: return "DW_TAG_typedef";
5271 case DW_TAG_union_type: return "DW_TAG_union_type";
5272 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5273 case DW_TAG_variant: return "DW_TAG_variant";
5274 case DW_TAG_common_block: return "DW_TAG_common_block";
5275 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5276 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5277 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5278 case DW_TAG_module: return "DW_TAG_module";
5279 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5280 case DW_TAG_set_type: return "DW_TAG_set_type";
5281 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5282 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5283 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5284 case DW_TAG_base_type: return "DW_TAG_base_type";
5285 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5286 case DW_TAG_const_type: return "DW_TAG_const_type";
5287 case DW_TAG_constant: return "DW_TAG_constant";
5288 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5289 case DW_TAG_file_type: return "DW_TAG_file_type";
5290 case DW_TAG_friend: return "DW_TAG_friend";
5291 case DW_TAG_namelist: return "DW_TAG_namelist";
5292 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5293 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5294 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5295 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5296 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5297 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5298 case DW_TAG_try_block: return "DW_TAG_try_block";
5299 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5300 case DW_TAG_variable: return "DW_TAG_variable";
5301 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5302 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5303 case DW_TAG_format_label: return "DW_TAG_format_label";
5304 case DW_TAG_function_template: return "DW_TAG_function_template";
5305 case DW_TAG_class_template: return "DW_TAG_class_template";
5308 static char buffer [100];
5310 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5317 get_AT_name (attribute)
5318 unsigned long attribute;
5322 case DW_AT_sibling: return "DW_AT_sibling";
5323 case DW_AT_location: return "DW_AT_location";
5324 case DW_AT_name: return "DW_AT_name";
5325 case DW_AT_ordering: return "DW_AT_ordering";
5326 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5327 case DW_AT_byte_size: return "DW_AT_byte_size";
5328 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5329 case DW_AT_bit_size: return "DW_AT_bit_size";
5330 case DW_AT_element_list: return "DW_AT_element_list";
5331 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5332 case DW_AT_low_pc: return "DW_AT_low_pc";
5333 case DW_AT_high_pc: return "DW_AT_high_pc";
5334 case DW_AT_language: return "DW_AT_language";
5335 case DW_AT_member: return "DW_AT_member";
5336 case DW_AT_discr: return "DW_AT_discr";
5337 case DW_AT_discr_value: return "DW_AT_discr_value";
5338 case DW_AT_visibility: return "DW_AT_visibility";
5339 case DW_AT_import: return "DW_AT_import";
5340 case DW_AT_string_length: return "DW_AT_string_length";
5341 case DW_AT_common_reference: return "DW_AT_common_reference";
5342 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5343 case DW_AT_const_value: return "DW_AT_const_value";
5344 case DW_AT_containing_type: return "DW_AT_containing_type";
5345 case DW_AT_default_value: return "DW_AT_default_value";
5346 case DW_AT_inline: return "DW_AT_inline";
5347 case DW_AT_is_optional: return "DW_AT_is_optional";
5348 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5349 case DW_AT_producer: return "DW_AT_producer";
5350 case DW_AT_prototyped: return "DW_AT_prototyped";
5351 case DW_AT_return_addr: return "DW_AT_return_addr";
5352 case DW_AT_start_scope: return "DW_AT_start_scope";
5353 case DW_AT_stride_size: return "DW_AT_stride_size";
5354 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5355 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5356 case DW_AT_accessibility: return "DW_AT_accessibility";
5357 case DW_AT_address_class: return "DW_AT_address_class";
5358 case DW_AT_artificial: return "DW_AT_artificial";
5359 case DW_AT_base_types: return "DW_AT_base_types";
5360 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5361 case DW_AT_count: return "DW_AT_count";
5362 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5363 case DW_AT_decl_column: return "DW_AT_decl_column";
5364 case DW_AT_decl_file: return "DW_AT_decl_file";
5365 case DW_AT_decl_line: return "DW_AT_decl_line";
5366 case DW_AT_declaration: return "DW_AT_declaration";
5367 case DW_AT_discr_list: return "DW_AT_discr_list";
5368 case DW_AT_encoding: return "DW_AT_encoding";
5369 case DW_AT_external: return "DW_AT_external";
5370 case DW_AT_frame_base: return "DW_AT_frame_base";
5371 case DW_AT_friend: return "DW_AT_friend";
5372 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5373 case DW_AT_macro_info: return "DW_AT_macro_info";
5374 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5375 case DW_AT_priority: return "DW_AT_priority";
5376 case DW_AT_segment: return "DW_AT_segment";
5377 case DW_AT_specification: return "DW_AT_specification";
5378 case DW_AT_static_link: return "DW_AT_static_link";
5379 case DW_AT_type: return "DW_AT_type";
5380 case DW_AT_use_location: return "DW_AT_use_location";
5381 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5382 case DW_AT_virtuality: return "DW_AT_virtuality";
5383 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5384 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5385 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5386 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5387 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5388 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5389 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5390 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5391 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5392 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5393 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5394 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5395 case DW_AT_sf_names: return "DW_AT_sf_names";
5396 case DW_AT_src_info: return "DW_AT_src_info";
5397 case DW_AT_mac_info: return "DW_AT_mac_info";
5398 case DW_AT_src_coords: return "DW_AT_src_coords";
5399 case DW_AT_body_begin: return "DW_AT_body_begin";
5400 case DW_AT_body_end: return "DW_AT_body_end";
5403 static char buffer [100];
5405 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5412 get_FORM_name (form)
5417 case DW_FORM_addr: return "DW_FORM_addr";
5418 case DW_FORM_block2: return "DW_FORM_block2";
5419 case DW_FORM_block4: return "DW_FORM_block4";
5420 case DW_FORM_data2: return "DW_FORM_data2";
5421 case DW_FORM_data4: return "DW_FORM_data4";
5422 case DW_FORM_data8: return "DW_FORM_data8";
5423 case DW_FORM_string: return "DW_FORM_string";
5424 case DW_FORM_block: return "DW_FORM_block";
5425 case DW_FORM_block1: return "DW_FORM_block1";
5426 case DW_FORM_data1: return "DW_FORM_data1";
5427 case DW_FORM_flag: return "DW_FORM_flag";
5428 case DW_FORM_sdata: return "DW_FORM_sdata";
5429 case DW_FORM_strp: return "DW_FORM_strp";
5430 case DW_FORM_udata: return "DW_FORM_udata";
5431 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5432 case DW_FORM_ref1: return "DW_FORM_ref1";
5433 case DW_FORM_ref2: return "DW_FORM_ref2";
5434 case DW_FORM_ref4: return "DW_FORM_ref4";
5435 case DW_FORM_ref8: return "DW_FORM_ref8";
5436 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5437 case DW_FORM_indirect: return "DW_FORM_indirect";
5440 static char buffer [100];
5442 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5448 /* FIXME: There are better and more effiecint ways to handle
5449 these structures. For now though, I just want something that
5450 is simple to implement. */
5451 typedef struct abbrev_attr
5453 unsigned long attribute;
5455 struct abbrev_attr * next;
5459 typedef struct abbrev_entry
5461 unsigned long entry;
5464 struct abbrev_attr * first_attr;
5465 struct abbrev_attr * last_attr;
5466 struct abbrev_entry * next;
5470 static abbrev_entry * first_abbrev = NULL;
5471 static abbrev_entry * last_abbrev = NULL;
5474 free_abbrevs PARAMS ((void))
5476 abbrev_entry * abbrev;
5478 for (abbrev = first_abbrev; abbrev;)
5480 abbrev_entry * next = abbrev->next;
5483 for (attr = abbrev->first_attr; attr;)
5485 abbrev_attr * next = attr->next;
5495 last_abbrev = first_abbrev = NULL;
5499 add_abbrev (number, tag, children)
5500 unsigned long number;
5504 abbrev_entry * entry;
5506 entry = (abbrev_entry *) malloc (sizeof (* entry));
5512 entry->entry = number;
5514 entry->children = children;
5515 entry->first_attr = NULL;
5516 entry->last_attr = NULL;
5519 if (first_abbrev == NULL)
5520 first_abbrev = entry;
5522 last_abbrev->next = entry;
5524 last_abbrev = entry;
5528 add_abbrev_attr (attribute, form)
5529 unsigned long attribute;
5534 attr = (abbrev_attr *) malloc (sizeof (* attr));
5540 attr->attribute = attribute;
5544 if (last_abbrev->first_attr == NULL)
5545 last_abbrev->first_attr = attr;
5547 last_abbrev->last_attr->next = attr;
5549 last_abbrev->last_attr = attr;
5552 /* Processes the (partial) contents of a .debug_abbrev section.
5553 Returns NULL if the end of the section was encountered.
5554 Returns the address after the last byte read if the end of
5555 an abbreviation set was found. */
5557 static unsigned char *
5558 process_abbrev_section (start, end)
5559 unsigned char * start;
5560 unsigned char * end;
5562 if (first_abbrev != NULL)
5568 unsigned long entry;
5570 unsigned long attribute;
5573 entry = read_leb128 (start, & bytes_read, 0);
5574 start += bytes_read;
5576 /* A single zero is supposed to end the section according
5577 to the standard. If there's more, then signal that to
5580 return start == end ? NULL : start;
5582 tag = read_leb128 (start, & bytes_read, 0);
5583 start += bytes_read;
5585 children = * start ++;
5587 add_abbrev (entry, tag, children);
5593 attribute = read_leb128 (start, & bytes_read, 0);
5594 start += bytes_read;
5596 form = read_leb128 (start, & bytes_read, 0);
5597 start += bytes_read;
5600 add_abbrev_attr (attribute, form);
5602 while (attribute != 0);
5610 display_debug_abbrev (section, start, file)
5611 Elf32_Internal_Shdr * section;
5612 unsigned char * start;
5613 FILE * file ATTRIBUTE_UNUSED;
5615 abbrev_entry * entry;
5616 unsigned char * end = start + section->sh_size;
5618 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5622 start = process_abbrev_section (start, end);
5624 printf (_(" Number TAG\n"));
5626 for (entry = first_abbrev; entry; entry = entry->next)
5630 printf (_(" %ld %s [%s]\n"),
5632 get_TAG_name (entry->tag),
5633 entry->children ? _("has children") : _("no children"));
5635 for (attr = entry->first_attr; attr; attr = attr->next)
5637 printf (_(" %-18s %s\n"),
5638 get_AT_name (attr->attribute),
5639 get_FORM_name (attr->form));
5651 static unsigned char *
5652 display_block (data, length)
5653 unsigned char * data;
5654 unsigned long length;
5656 printf (_(" %lu byte block: "), length);
5659 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5665 decode_location_expression (data, pointer_size, length)
5666 unsigned char * data;
5667 unsigned int pointer_size;
5668 unsigned long length;
5672 unsigned long uvalue;
5673 unsigned char *end = data + length;
5682 printf ("DW_OP_addr: %lx",
5683 (unsigned long) byte_get (data, pointer_size));
5684 data += pointer_size;
5687 printf ("DW_OP_deref");
5690 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
5693 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
5696 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5700 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5704 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5708 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5712 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5713 (unsigned long) byte_get (data + 4, 4));
5717 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5718 (long) byte_get (data + 4, 4));
5722 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
5726 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
5730 printf ("DW_OP_dup");
5733 printf ("DW_OP_drop");
5736 printf ("DW_OP_over");
5739 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
5742 printf ("DW_OP_swap");
5745 printf ("DW_OP_rot");
5748 printf ("DW_OP_xderef");
5751 printf ("DW_OP_abs");
5754 printf ("DW_OP_and");
5757 printf ("DW_OP_div");
5760 printf ("DW_OP_minus");
5763 printf ("DW_OP_mod");
5766 printf ("DW_OP_mul");
5769 printf ("DW_OP_neg");
5772 printf ("DW_OP_not");
5775 printf ("DW_OP_or");
5778 printf ("DW_OP_plus");
5780 case DW_OP_plus_uconst:
5781 printf ("DW_OP_plus_uconst: %lu",
5782 read_leb128 (data, &bytes_read, 0));
5786 printf ("DW_OP_shl");
5789 printf ("DW_OP_shr");
5792 printf ("DW_OP_shra");
5795 printf ("DW_OP_xor");
5798 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5802 printf ("DW_OP_eq");
5805 printf ("DW_OP_ge");
5808 printf ("DW_OP_gt");
5811 printf ("DW_OP_le");
5814 printf ("DW_OP_lt");
5817 printf ("DW_OP_ne");
5820 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5856 printf ("DW_OP_lit%d", op - DW_OP_lit0);
5891 printf ("DW_OP_reg%d", op - DW_OP_reg0);
5926 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
5927 read_leb128 (data, &bytes_read, 1));
5932 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
5936 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
5940 uvalue = read_leb128 (data, &bytes_read, 0);
5942 printf ("DW_OP_bregx: %lu %ld", uvalue,
5943 read_leb128 (data, &bytes_read, 1));
5947 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
5950 case DW_OP_deref_size:
5951 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
5953 case DW_OP_xderef_size:
5954 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
5957 printf ("DW_OP_nop");
5961 if (op >= DW_OP_lo_user
5962 && op <= DW_OP_hi_user)
5963 printf (_("(User defined location op)"));
5965 printf (_("(Unknown location op)"));
5966 /* No way to tell where the next op is, so just bail. */
5973 static unsigned char *
5974 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
5975 unsigned long attribute;
5977 unsigned char * data;
5978 unsigned long cu_offset;
5979 unsigned long pointer_size;
5981 unsigned long uvalue = 0;
5982 unsigned char * block_start = NULL;
5985 printf (" %-18s:", get_AT_name (attribute));
5992 case DW_FORM_ref_addr:
5994 uvalue = byte_get (data, pointer_size);
5995 data += pointer_size;
6001 uvalue = byte_get (data ++, 1);
6006 uvalue = byte_get (data, 2);
6012 uvalue = byte_get (data, 4);
6017 uvalue = read_leb128 (data, & bytes_read, 1);
6021 case DW_FORM_ref_udata:
6023 uvalue = read_leb128 (data, & bytes_read, 0);
6030 case DW_FORM_ref_addr:
6031 printf (" <#%lx>", uvalue);
6037 case DW_FORM_ref_udata:
6038 printf (" <%lx>", uvalue + cu_offset);
6042 printf (" %#lx", uvalue);
6050 printf (" %ld", uvalue);
6055 uvalue = byte_get (data, 4);
6056 printf (" %lx", uvalue);
6057 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6061 case DW_FORM_string:
6062 printf (" %s", data);
6063 data += strlen ((char *) data) + 1;
6067 uvalue = read_leb128 (data, & bytes_read, 0);
6068 block_start = data + bytes_read;
6069 data = display_block (block_start, uvalue);
6072 case DW_FORM_block1:
6073 uvalue = byte_get (data, 1);
6074 block_start = data + 1;
6075 data = display_block (block_start, uvalue);
6078 case DW_FORM_block2:
6079 uvalue = byte_get (data, 2);
6080 block_start = data + 2;
6081 data = display_block (block_start, uvalue);
6084 case DW_FORM_block4:
6085 uvalue = byte_get (data, 4);
6086 block_start = data + 4;
6087 data = display_block (block_start, uvalue);
6091 case DW_FORM_indirect:
6092 warn (_("Unable to handle FORM: %d"), form);
6096 warn (_("Unrecognised form: %d"), form);
6100 /* For some attributes we can display futher information. */
6109 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6110 case DW_INL_inlined: printf (_("(inlined)")); break;
6111 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6112 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6113 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6117 case DW_AT_language:
6120 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6121 case DW_LANG_C89: printf ("(ANSI C)"); break;
6122 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6123 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6124 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6125 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6126 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6127 case DW_LANG_Ada83: printf ("(Ada)"); break;
6128 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6129 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6130 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6131 default: printf ("(Unknown: %lx)", uvalue); break;
6135 case DW_AT_encoding:
6138 case DW_ATE_void: printf ("(void)"); break;
6139 case DW_ATE_address: printf ("(machine address)"); break;
6140 case DW_ATE_boolean: printf ("(boolean)"); break;
6141 case DW_ATE_complex_float: printf ("(complex float)"); break;
6142 case DW_ATE_float: printf ("(float)"); break;
6143 case DW_ATE_signed: printf ("(signed)"); break;
6144 case DW_ATE_signed_char: printf ("(signed char)"); break;
6145 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6146 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6148 if (uvalue >= DW_ATE_lo_user
6149 && uvalue <= DW_ATE_hi_user)
6150 printf ("(user defined type)");
6152 printf ("(unknown type)");
6157 case DW_AT_accessibility:
6160 case DW_ACCESS_public: printf ("(public)"); break;
6161 case DW_ACCESS_protected: printf ("(protected)"); break;
6162 case DW_ACCESS_private: printf ("(private)"); break;
6163 default: printf ("(unknown accessibility)"); break;
6167 case DW_AT_visibility:
6170 case DW_VIS_local: printf ("(local)"); break;
6171 case DW_VIS_exported: printf ("(exported)"); break;
6172 case DW_VIS_qualified: printf ("(qualified)"); break;
6173 default: printf ("(unknown visibility)"); break;
6177 case DW_AT_virtuality:
6180 case DW_VIRTUALITY_none: printf ("(none)"); break;
6181 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6182 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6183 default: printf ("(unknown virtuality)"); break;
6187 case DW_AT_identifier_case:
6190 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6191 case DW_ID_up_case: printf ("(up_case)"); break;
6192 case DW_ID_down_case: printf ("(down_case)"); break;
6193 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6194 default: printf ("(unknown case)"); break;
6198 case DW_AT_calling_convention:
6201 case DW_CC_normal: printf ("(normal)"); break;
6202 case DW_CC_program: printf ("(program)"); break;
6203 case DW_CC_nocall: printf ("(nocall)"); break;
6205 if (uvalue >= DW_CC_lo_user
6206 && uvalue <= DW_CC_hi_user)
6207 printf ("(user defined)");
6209 printf ("(unknown convention)");
6213 case DW_AT_frame_base:
6214 case DW_AT_location:
6215 case DW_AT_data_member_location:
6216 case DW_AT_vtable_elem_location:
6220 decode_location_expression (block_start, pointer_size, uvalue);
6234 display_debug_info (section, start, file)
6235 Elf32_Internal_Shdr * section;
6236 unsigned char * start;
6239 unsigned char * end = start + section->sh_size;
6240 unsigned char * section_begin = start;
6242 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6246 DWARF2_External_CompUnit * external;
6247 DWARF2_Internal_CompUnit compunit;
6248 unsigned char * tags;
6251 unsigned long cu_offset;
6253 external = (DWARF2_External_CompUnit *) start;
6255 compunit.cu_length = BYTE_GET (external->cu_length);
6256 compunit.cu_version = BYTE_GET (external->cu_version);
6257 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6258 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6260 tags = start + sizeof (* external);
6261 cu_offset = start - section_begin;
6262 start += compunit.cu_length + sizeof (external->cu_length);
6264 if (compunit.cu_version != 2)
6266 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6270 printf (_(" Compilation Unit:\n"));
6271 printf (_(" Length: %ld\n"), compunit.cu_length);
6272 printf (_(" Version: %d\n"), compunit.cu_version);
6273 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6274 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6276 if (first_abbrev != NULL)
6279 /* Read in the abbrevs used by this compilation unit. */
6282 Elf32_Internal_Shdr * sec;
6283 unsigned char * begin;
6285 /* Locate the .debug_abbrev section and process it. */
6286 for (i = 0, sec = section_headers;
6287 i < elf_header.e_shnum;
6289 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6292 if (i == -1 || sec->sh_size == 0)
6294 warn (_("Unable to locate .debug_abbrev section!\n"));
6298 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6299 "debug_abbrev section data");
6301 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6302 begin + sec->sh_size);
6308 while (tags < start)
6311 unsigned long abbrev_number;
6312 abbrev_entry * entry;
6315 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6318 /* A null DIE marks the end of a list of children. */
6319 if (abbrev_number == 0)
6325 /* Scan through the abbreviation list until we reach the
6327 for (entry = first_abbrev;
6328 entry && entry->entry != abbrev_number;
6329 entry = entry->next)
6334 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6339 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6340 level, tags - section_begin - bytes_read,
6342 get_TAG_name (entry->tag));
6344 for (attr = entry->first_attr; attr; attr = attr->next)
6345 tags = read_and_display_attr (attr->attribute,
6348 compunit.cu_pointer_size);
6350 if (entry->children)
6361 display_debug_aranges (section, start, file)
6362 Elf32_Internal_Shdr * section;
6363 unsigned char * start;
6364 FILE * file ATTRIBUTE_UNUSED;
6366 unsigned char * end = start + section->sh_size;
6368 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6372 DWARF2_External_ARange * external;
6373 DWARF2_Internal_ARange arange;
6374 unsigned char * ranges;
6375 unsigned long length;
6376 unsigned long address;
6379 external = (DWARF2_External_ARange *) start;
6381 arange.ar_length = BYTE_GET (external->ar_length);
6382 arange.ar_version = BYTE_GET (external->ar_version);
6383 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6384 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6385 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6387 printf (_(" Length: %ld\n"), arange.ar_length);
6388 printf (_(" Version: %d\n"), arange.ar_version);
6389 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6390 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6391 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6393 printf (_("\n Address Length\n"));
6395 ranges = start + sizeof (* external);
6397 /* Must pad to an alignment boundary that is twice the pointer size. */
6398 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6400 ranges += (2 * arange.ar_pointer_size) - excess;
6404 address = byte_get (ranges, arange.ar_pointer_size);
6406 ranges += arange.ar_pointer_size;
6408 length = byte_get (ranges, arange.ar_pointer_size);
6410 ranges += arange.ar_pointer_size;
6412 /* A pair of zeros marks the end of the list. */
6413 if (address == 0 && length == 0)
6416 printf (" %8.8lx %lu\n", address, length);
6419 start += arange.ar_length + sizeof (external->ar_length);
6429 display_debug_not_supported (section, start, file)
6430 Elf32_Internal_Shdr * section;
6431 unsigned char * start ATTRIBUTE_UNUSED;
6432 FILE * file ATTRIBUTE_UNUSED;
6434 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6435 SECTION_NAME (section));
6440 /* Pre-scan the .debug_info section to record the size of address.
6441 When dumping the .debug_line, we use that size information, assuming
6442 that all compilation units have the same address size. */
6444 prescan_debug_info (section, start, file)
6445 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6446 unsigned char * start;
6447 FILE * file ATTRIBUTE_UNUSED;
6449 DWARF2_External_CompUnit * external;
6451 external = (DWARF2_External_CompUnit *) start;
6453 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6457 /* A structure containing the name of a debug section and a pointer
6458 to a function that can decode it. The third field is a prescan
6459 function to be run over the section before displaying any of the
6464 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6465 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6469 { ".debug_info", display_debug_info, prescan_debug_info },
6470 { ".debug_abbrev", display_debug_abbrev, NULL },
6471 { ".debug_line", display_debug_lines, NULL },
6472 { ".debug_aranges", display_debug_aranges, NULL },
6473 { ".debug_pubnames", display_debug_pubnames, NULL },
6474 { ".debug_macinfo", display_debug_not_supported, NULL },
6475 { ".debug_frame", display_debug_not_supported, NULL },
6476 { ".debug_str", display_debug_not_supported, NULL },
6477 { ".debug_static_func", display_debug_not_supported, NULL },
6478 { ".debug_static_vars", display_debug_not_supported, NULL },
6479 { ".debug_types", display_debug_not_supported, NULL },
6480 { ".debug_weaknames", display_debug_not_supported, NULL }
6484 display_debug_section (section, file)
6485 Elf32_Internal_Shdr * section;
6488 char * name = SECTION_NAME (section);
6489 bfd_size_type length;
6490 unsigned char * start;
6493 length = section->sh_size;
6496 printf (_("\nSection '%s' has no debugging data.\n"), name);
6500 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6501 "debug section data");
6503 /* See if we know how to display the contents of this section. */
6504 for (i = NUM_ELEM (debug_displays); i--;)
6505 if (strcmp (debug_displays[i].name, name) == 0)
6507 debug_displays[i].display (section, start, file);
6512 printf (_("Unrecognised debug section: %s\n"), name);
6516 /* If we loaded in the abbrev section at some point,
6517 we must release it here. */
6518 if (first_abbrev != NULL)
6525 process_section_contents (file)
6528 Elf32_Internal_Shdr * section;
6534 /* Pre-scan the debug sections to find some debug information not
6535 present in some of them. For the .debug_line, we must find out the
6536 size of address (specified in .debug_info and .debug_aranges). */
6537 for (i = 0, section = section_headers;
6538 i < elf_header.e_shnum && i < num_dump_sects;
6541 char * name = SECTION_NAME (section);
6544 if (section->sh_size == 0)
6547 /* See if there is some pre-scan operation for this section. */
6548 for (j = NUM_ELEM (debug_displays); j--;)
6549 if (strcmp (debug_displays[j].name, name) == 0)
6551 if (debug_displays[j].prescan != NULL)
6553 bfd_size_type length;
6554 unsigned char * start;
6556 length = section->sh_size;
6557 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6558 "debug section data");
6560 debug_displays[j].prescan (section, start, file);
6568 for (i = 0, section = section_headers;
6569 i < elf_header.e_shnum && i < num_dump_sects;
6572 #ifdef SUPPORT_DISASSEMBLY
6573 if (dump_sects[i] & DISASS_DUMP)
6574 disassemble_section (section, file);
6576 if (dump_sects[i] & HEX_DUMP)
6577 dump_section (section, file);
6579 if (dump_sects[i] & DEBUG_DUMP)
6580 display_debug_section (section, file);
6583 if (i < num_dump_sects)
6584 warn (_("Some sections were not dumped because they do not exist!\n"));
6590 process_mips_fpe_exception (mask)
6596 if (mask & OEX_FPU_INEX)
6597 fputs ("INEX", stdout), first = 0;
6598 if (mask & OEX_FPU_UFLO)
6599 printf ("%sUFLO", first ? "" : "|"), first = 0;
6600 if (mask & OEX_FPU_OFLO)
6601 printf ("%sOFLO", first ? "" : "|"), first = 0;
6602 if (mask & OEX_FPU_DIV0)
6603 printf ("%sDIV0", first ? "" : "|"), first = 0;
6604 if (mask & OEX_FPU_INVAL)
6605 printf ("%sINVAL", first ? "" : "|");
6608 fputs ("0", stdout);
6612 process_mips_specific (file)
6615 Elf_Internal_Dyn * entry;
6616 size_t liblist_offset = 0;
6617 size_t liblistno = 0;
6618 size_t conflictsno = 0;
6619 size_t options_offset = 0;
6620 size_t conflicts_offset = 0;
6622 /* We have a lot of special sections. Thanks SGI! */
6623 if (dynamic_segment == NULL)
6624 /* No information available. */
6627 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
6628 switch (entry->d_tag)
6630 case DT_MIPS_LIBLIST:
6631 liblist_offset = entry->d_un.d_val - loadaddr;
6633 case DT_MIPS_LIBLISTNO:
6634 liblistno = entry->d_un.d_val;
6636 case DT_MIPS_OPTIONS:
6637 options_offset = entry->d_un.d_val - loadaddr;
6639 case DT_MIPS_CONFLICT:
6640 conflicts_offset = entry->d_un.d_val - loadaddr;
6642 case DT_MIPS_CONFLICTNO:
6643 conflictsno = entry->d_un.d_val;
6649 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
6651 Elf32_External_Lib * elib;
6654 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
6655 elib, Elf32_External_Lib *, "liblist");
6657 printf ("\nSection '.liblist' contains %lu entries:\n",
6658 (unsigned long) liblistno);
6659 fputs (" Library Time Stamp Checksum Version Flags\n",
6662 for (cnt = 0; cnt < liblistno; ++cnt)
6669 liblist.l_name = BYTE_GET (elib[cnt].l_name);
6670 time = BYTE_GET (elib[cnt].l_time_stamp);
6671 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
6672 liblist.l_version = BYTE_GET (elib[cnt].l_version);
6673 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
6675 tmp = gmtime (&time);
6676 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
6677 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6678 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6680 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
6681 dynamic_strings + liblist.l_name, timebuf,
6682 liblist.l_checksum, liblist.l_version);
6684 if (liblist.l_flags == 0)
6695 { " EXACT_MATCH", LL_EXACT_MATCH },
6696 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
6697 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
6698 { " EXPORTS", LL_EXPORTS },
6699 { " DELAY_LOAD", LL_DELAY_LOAD },
6700 { " DELTA", LL_DELTA }
6702 int flags = liblist.l_flags;
6706 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
6708 if ((flags & l_flags_vals[fcnt].bit) != 0)
6710 fputs (l_flags_vals[fcnt].name, stdout);
6711 flags ^= l_flags_vals[fcnt].bit;
6714 printf (" %#x", (unsigned int) flags);
6723 if (options_offset != 0)
6725 Elf_External_Options * eopt;
6726 Elf_Internal_Shdr * sect = section_headers;
6727 Elf_Internal_Options * iopt;
6728 Elf_Internal_Options * option;
6732 /* Find the section header so that we get the size. */
6733 while (sect->sh_type != SHT_MIPS_OPTIONS)
6736 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
6737 Elf_External_Options *, "options");
6739 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
6743 error (_("Out of memory"));
6750 while (offset < sect->sh_size)
6752 Elf_External_Options * eoption;
6754 eoption = (Elf_External_Options *) ((char *) eopt + offset);
6756 option->kind = BYTE_GET (eoption->kind);
6757 option->size = BYTE_GET (eoption->size);
6758 option->section = BYTE_GET (eoption->section);
6759 option->info = BYTE_GET (eoption->info);
6761 offset += option->size;
6767 printf (_("\nSection '%s' contains %d entries:\n"),
6768 string_table + sect->sh_name, cnt);
6776 switch (option->kind)
6779 /* This shouldn't happen. */
6780 printf (" NULL %d %lx", option->section, option->info);
6783 printf (" REGINFO ");
6784 if (elf_header.e_machine == EM_MIPS)
6787 Elf32_External_RegInfo *ereg;
6788 Elf32_RegInfo reginfo;
6790 ereg = (Elf32_External_RegInfo *) (option + 1);
6791 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6792 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6793 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6794 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6795 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6796 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
6798 printf ("GPR %08lx GP 0x%lx\n",
6800 (unsigned long) reginfo.ri_gp_value);
6801 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6802 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6803 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6808 Elf64_External_RegInfo * ereg;
6809 Elf64_Internal_RegInfo reginfo;
6811 ereg = (Elf64_External_RegInfo *) (option + 1);
6812 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6813 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6814 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6815 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6816 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6817 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
6819 printf ("GPR %08lx GP 0x",
6820 reginfo.ri_gprmask);
6821 printf_vma (reginfo.ri_gp_value);
6824 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6825 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6826 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6830 case ODK_EXCEPTIONS:
6831 fputs (" EXCEPTIONS fpe_min(", stdout);
6832 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
6833 fputs (") fpe_max(", stdout);
6834 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
6835 fputs (")", stdout);
6837 if (option->info & OEX_PAGE0)
6838 fputs (" PAGE0", stdout);
6839 if (option->info & OEX_SMM)
6840 fputs (" SMM", stdout);
6841 if (option->info & OEX_FPDBUG)
6842 fputs (" FPDBUG", stdout);
6843 if (option->info & OEX_DISMISS)
6844 fputs (" DISMISS", stdout);
6847 fputs (" PAD ", stdout);
6848 if (option->info & OPAD_PREFIX)
6849 fputs (" PREFIX", stdout);
6850 if (option->info & OPAD_POSTFIX)
6851 fputs (" POSTFIX", stdout);
6852 if (option->info & OPAD_SYMBOL)
6853 fputs (" SYMBOL", stdout);
6856 fputs (" HWPATCH ", stdout);
6857 if (option->info & OHW_R4KEOP)
6858 fputs (" R4KEOP", stdout);
6859 if (option->info & OHW_R8KPFETCH)
6860 fputs (" R8KPFETCH", stdout);
6861 if (option->info & OHW_R5KEOP)
6862 fputs (" R5KEOP", stdout);
6863 if (option->info & OHW_R5KCVTL)
6864 fputs (" R5KCVTL", stdout);
6867 fputs (" FILL ", stdout);
6868 /* XXX Print content of info word? */
6871 fputs (" TAGS ", stdout);
6872 /* XXX Print content of info word? */
6875 fputs (" HWAND ", stdout);
6876 if (option->info & OHWA0_R4KEOP_CHECKED)
6877 fputs (" R4KEOP_CHECKED", stdout);
6878 if (option->info & OHWA0_R4KEOP_CLEAN)
6879 fputs (" R4KEOP_CLEAN", stdout);
6882 fputs (" HWOR ", stdout);
6883 if (option->info & OHWA0_R4KEOP_CHECKED)
6884 fputs (" R4KEOP_CHECKED", stdout);
6885 if (option->info & OHWA0_R4KEOP_CLEAN)
6886 fputs (" R4KEOP_CLEAN", stdout);
6889 printf (" GP_GROUP %#06lx self-contained %#06lx",
6890 option->info & OGP_GROUP,
6891 (option->info & OGP_SELF) >> 16);
6894 printf (" IDENT %#06lx self-contained %#06lx",
6895 option->info & OGP_GROUP,
6896 (option->info & OGP_SELF) >> 16);
6899 /* This shouldn't happen. */
6900 printf (" %3d ??? %d %lx",
6901 option->kind, option->section, option->info);
6905 len = sizeof (*eopt);
6906 while (len < option->size)
6907 if (((char *) option)[len] >= ' '
6908 && ((char *) option)[len] < 0x7f)
6909 printf ("%c", ((char *) option)[len++]);
6911 printf ("\\%03o", ((char *) option)[len++]);
6913 fputs ("\n", stdout);
6920 if (conflicts_offset != 0 && conflictsno != 0)
6922 Elf32_External_Conflict * econf32;
6923 Elf64_External_Conflict * econf64;
6924 Elf32_Conflict * iconf;
6927 if (dynamic_symbols == NULL)
6929 error (_("conflict list with without table"));
6933 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
6936 error (_("Out of memory"));
6942 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
6943 econf32, Elf32_External_Conflict *, "conflict");
6945 for (cnt = 0; cnt < conflictsno; ++cnt)
6946 iconf[cnt] = BYTE_GET (econf32[cnt]);
6950 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
6951 econf64, Elf64_External_Conflict *, "conflict");
6953 for (cnt = 0; cnt < conflictsno; ++cnt)
6954 iconf[cnt] = BYTE_GET (econf64[cnt]);
6957 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
6958 puts (_(" Num: Index Value Name"));
6960 for (cnt = 0; cnt < conflictsno; ++cnt)
6962 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
6964 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
6965 print_vma (psym->st_value, FULL_HEX);
6966 printf (" %s\n", dynamic_strings + psym->st_name);
6976 get_note_type (e_type)
6979 static char buff[64];
6983 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
6984 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
6985 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
6986 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
6987 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
6988 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
6989 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
6990 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
6991 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6992 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
6993 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
6995 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
7000 /* Note that by the ELF standard, the name field is already null byte
7001 terminated, and namesz includes the terminating null byte.
7002 I.E. the value of namesz for the name "FSF" is 4.
7004 If the value of namesz is zero, there is no name present. */
7006 process_note (pnote)
7007 Elf32_Internal_Note * pnote;
7009 printf (" %s\t\t0x%08lx\t%s\n",
7010 pnote->namesz ? pnote->namedata : "(NONE)",
7011 pnote->descsz, get_note_type (pnote->type));
7017 process_corefile_note_segment (file, offset, length)
7022 Elf_External_Note * pnotes;
7023 Elf_External_Note * external;
7029 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
7033 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7034 (unsigned long) offset, (unsigned long) length);
7035 printf (_(" Owner\t\tData size\tDescription\n"));
7037 while (external < (Elf_External_Note *)((char *) pnotes + length))
7039 Elf32_Internal_Note inote;
7042 inote.type = BYTE_GET (external->type);
7043 inote.namesz = BYTE_GET (external->namesz);
7044 inote.namedata = external->name;
7045 inote.descsz = BYTE_GET (external->descsz);
7046 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
7047 inote.descpos = offset + (inote.descdata - (char *) pnotes);
7049 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7051 /* Verify that name is null terminated. It appears that at least
7052 one version of Linux (RedHat 6.0) generates corefiles that don't
7053 comply with the ELF spec by failing to include the null byte in
7055 if (inote.namedata[inote.namesz] != '\0')
7057 temp = malloc (inote.namesz + 1);
7061 error (_("Out of memory\n"));
7066 strncpy (temp, inote.namedata, inote.namesz);
7067 temp[inote.namesz] = 0;
7069 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7070 inote.namedata = temp;
7073 res &= process_note (& inote);
7088 process_corefile_note_segments (file)
7091 Elf_Internal_Phdr * program_headers;
7092 Elf_Internal_Phdr * segment;
7096 program_headers = (Elf_Internal_Phdr *) malloc
7097 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7099 if (program_headers == NULL)
7101 error (_("Out of memory\n"));
7106 i = get_32bit_program_headers (file, program_headers);
7108 i = get_64bit_program_headers (file, program_headers);
7112 free (program_headers);
7116 for (i = 0, segment = program_headers;
7117 i < elf_header.e_phnum;
7120 if (segment->p_type == PT_NOTE)
7121 res &= process_corefile_note_segment (file,
7122 (bfd_vma) segment->p_offset,
7123 (bfd_vma) segment->p_filesz);
7126 free (program_headers);
7132 process_corefile_contents (file)
7135 /* If we have not been asked to display the notes then do nothing. */
7139 /* If file is not a core file then exit. */
7140 if (elf_header.e_type != ET_CORE)
7143 /* No program headers means no NOTE segment. */
7144 if (elf_header.e_phnum == 0)
7146 printf (_("No note segments present in the core file.\n"));
7150 return process_corefile_note_segments (file);
7154 process_arch_specific (file)
7160 switch (elf_header.e_machine)
7163 case EM_MIPS_RS4_BE:
7164 return process_mips_specific (file);
7173 get_file_header (file)
7176 /* Read in the identity array. */
7177 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7180 /* Determine how to read the rest of the header. */
7181 switch (elf_header.e_ident [EI_DATA])
7183 default: /* fall through */
7184 case ELFDATANONE: /* fall through */
7185 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7186 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7189 /* For now we only support 32 bit and 64 bit ELF files. */
7190 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7192 /* Read in the rest of the header. */
7195 Elf32_External_Ehdr ehdr32;
7197 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7200 elf_header.e_type = BYTE_GET (ehdr32.e_type);
7201 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
7202 elf_header.e_version = BYTE_GET (ehdr32.e_version);
7203 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7204 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7205 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7206 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7207 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7208 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7209 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7210 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7211 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7212 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7216 Elf64_External_Ehdr ehdr64;
7218 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7219 we will not be able to cope with the 64bit data found in
7220 64 ELF files. Detect this now and abort before we start
7221 overwritting things. */
7222 if (sizeof (bfd_vma) < 8)
7224 error (_("This instance of readelf has been built without support for a\n"));
7225 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7229 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7232 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7233 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7234 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7235 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7236 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7237 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7238 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7239 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7240 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7241 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7242 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7243 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7244 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7251 process_file (file_name)
7255 struct stat statbuf;
7258 if (stat (file_name, & statbuf) < 0)
7260 error (_("Cannot stat input file %s.\n"), file_name);
7264 file = fopen (file_name, "rb");
7267 error (_("Input file %s not found.\n"), file_name);
7271 if (! get_file_header (file))
7273 error (_("%s: Failed to read file header\n"), file_name);
7278 /* Initialise per file variables. */
7279 for (i = NUM_ELEM (version_info); i--;)
7280 version_info[i] = 0;
7282 for (i = NUM_ELEM (dynamic_info); i--;)
7283 dynamic_info[i] = 0;
7285 /* Process the file. */
7287 printf (_("\nFile: %s\n"), file_name);
7289 if (! process_file_header ())
7295 process_section_headers (file);
7297 process_program_headers (file);
7299 process_dynamic_segment (file);
7301 process_relocs (file);
7303 process_symbol_table (file);
7305 process_syminfo (file);
7307 process_version_sections (file);
7309 process_section_contents (file);
7311 process_corefile_contents (file);
7313 process_arch_specific (file);
7317 if (section_headers)
7319 free (section_headers);
7320 section_headers = NULL;
7325 free (string_table);
7326 string_table = NULL;
7329 if (dynamic_strings)
7331 free (dynamic_strings);
7332 dynamic_strings = NULL;
7335 if (dynamic_symbols)
7337 free (dynamic_symbols);
7338 dynamic_symbols = NULL;
7339 num_dynamic_syms = 0;
7342 if (dynamic_syminfo)
7344 free (dynamic_syminfo);
7345 dynamic_syminfo = NULL;
7349 #ifdef SUPPORT_DISASSEMBLY
7350 /* Needed by the i386 disassembler. For extra credit, someone could
7351 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7355 print_address (unsigned int addr, FILE * outfile)
7357 fprintf (outfile,"0x%8.8x", addr);
7360 /* Needed by the i386 disassembler. */
7362 db_task_printsym (unsigned int addr)
7364 print_address (addr, stderr);
7373 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7374 setlocale (LC_MESSAGES, "");
7376 bindtextdomain (PACKAGE, LOCALEDIR);
7377 textdomain (PACKAGE);
7379 parse_args (argc, argv);
7381 if (optind < (argc - 1))
7384 while (optind < argc)
7385 process_file (argv [optind ++]);
7387 if (dump_sects != NULL)