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"
77 #ifdef ANSI_PROTOTYPES
83 char * program_name = "readelf";
84 unsigned int dynamic_addr;
85 bfd_size_type dynamic_size;
86 unsigned int rela_addr;
87 unsigned int rela_size;
88 char * dynamic_strings;
90 unsigned long num_dynamic_syms;
91 Elf_Internal_Sym * dynamic_symbols;
92 Elf_Internal_Syminfo * dynamic_syminfo;
93 unsigned long dynamic_syminfo_offset;
94 unsigned int dynamic_syminfo_nent;
95 char program_interpreter [64];
96 int dynamic_info[DT_JMPREL + 1];
99 Elf_Internal_Ehdr elf_header;
100 Elf_Internal_Shdr * section_headers;
101 Elf_Internal_Dyn * dynamic_segment;
108 int do_using_dynamic;
115 int do_debug_abbrevs;
117 int do_debug_pubnames;
118 int do_debug_aranges;
123 /* A dynamic array of flags indicating which sections require dumping. */
124 char * dump_sects = NULL;
125 unsigned int num_dump_sects = 0;
127 #define HEX_DUMP (1 << 0)
128 #define DISASS_DUMP (1 << 1)
129 #define DEBUG_DUMP (1 << 2)
131 /* How to rpint a vma value. */
132 typedef enum print_mode
144 /* Forward declarations for dumb compilers. */
145 static void print_vma PARAMS ((bfd_vma, print_mode));
146 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
147 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
148 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
149 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
150 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
151 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
152 static const char * get_dynamic_type PARAMS ((unsigned long));
153 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
154 static char * get_file_type PARAMS ((unsigned));
155 static char * get_machine_name PARAMS ((unsigned));
156 static void decode_ARM_machine_flags PARAMS ((unsigned, char []));
157 static char * get_machine_flags PARAMS ((unsigned, unsigned));
158 static const char * get_mips_segment_type PARAMS ((unsigned long));
159 static const char * get_parisc_segment_type PARAMS ((unsigned long));
160 static const char * get_segment_type PARAMS ((unsigned long));
161 static const char * get_mips_section_type_name PARAMS ((unsigned int));
162 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
163 static const char * get_section_type_name PARAMS ((unsigned int));
164 static const char * get_symbol_binding PARAMS ((unsigned int));
165 static const char * get_symbol_type PARAMS ((unsigned int));
166 static const char * get_symbol_visibility PARAMS ((unsigned int));
167 static const char * get_symbol_index_type PARAMS ((unsigned int));
168 static const char * get_dynamic_flags PARAMS ((bfd_vma));
169 static void usage PARAMS ((void));
170 static void parse_args PARAMS ((int, char **));
171 static int process_file_header PARAMS ((void));
172 static int process_program_headers PARAMS ((FILE *));
173 static int process_section_headers PARAMS ((FILE *));
174 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
175 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
176 static int process_dynamic_segment PARAMS ((FILE *));
177 static int process_symbol_table PARAMS ((FILE *));
178 static int process_section_contents PARAMS ((FILE *));
179 static void process_file PARAMS ((char *));
180 static int process_relocs PARAMS ((FILE *));
181 static int process_version_sections PARAMS ((FILE *));
182 static char * get_ver_flags PARAMS ((unsigned int));
183 static int get_32bit_section_headers PARAMS ((FILE *));
184 static int get_64bit_section_headers PARAMS ((FILE *));
185 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
186 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
187 static int get_file_header PARAMS ((FILE *));
188 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
189 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
190 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
191 static int get_32bit_dynamic_segment PARAMS ((FILE *));
192 static int get_64bit_dynamic_segment PARAMS ((FILE *));
193 #ifdef SUPPORT_DISASSEMBLY
194 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
196 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
197 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
198 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
199 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
200 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
201 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
202 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
203 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
204 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
205 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
206 static void reset_state_machine PARAMS ((int));
207 static char * get_TAG_name PARAMS ((unsigned long));
208 static char * get_AT_name PARAMS ((unsigned long));
209 static char * get_FORM_name PARAMS ((unsigned long));
210 static void free_abbrevs PARAMS ((void));
211 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
212 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
213 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
214 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
215 static void decode_location_expression PARAMS ((unsigned char *, unsigned int));
216 static void request_dump PARAMS ((unsigned int, char));
217 static const char * get_elf_class PARAMS ((unsigned char));
218 static const char * get_data_encoding PARAMS ((unsigned char));
219 static const char * get_osabi_name PARAMS ((unsigned char));
220 static int guess_is_rela PARAMS ((unsigned long));
221 static char * get_note_type PARAMS ((unsigned int));
222 static int process_note PARAMS ((Elf32_Internal_Note *));
223 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
224 static int process_corefile_note_segments PARAMS ((FILE *));
225 static int process_corefile_contents PARAMS ((FILE *));
227 typedef int Elf32_Word;
235 #define SECTION_NAME(X) (string_table + (X)->sh_name)
237 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
239 #define BYTE_GET(field) byte_get (field, sizeof (field))
241 /* If we can support a 64 bit data type then BFD64 should be defined
242 and sizeof (bfd_vma) == 8. In this case when translating from an
243 external 8 byte field to an internal field, we can assume that the
244 internal field is also 8 bytes wide and so we can extact all the data.
245 If, however, BFD64 is not defined, then we must assume that the
246 internal data structure only has 4 byte wide fields that are the
247 equivalent of the 8 byte wide external counterparts, and so we must
248 truncate the data. */
250 #define BYTE_GET8(field) byte_get (field, -8)
252 #define BYTE_GET8(field) byte_get (field, 8)
255 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
257 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
258 if (fseek (file, offset, SEEK_SET)) \
260 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
264 var = (type) malloc (size); \
268 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
272 if (fread (var, size, 1, file) != 1) \
274 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
281 #define GET_DATA(offset, var, reason) \
282 if (fseek (file, offset, SEEK_SET)) \
284 error (_("Unable to seek to %x for %s\n"), offset, reason); \
287 else if (fread (& var, sizeof (var), 1, file) != 1) \
289 error (_("Unable to read data at %x for %s\n"), offset, reason); \
293 #define GET_ELF_SYMBOLS(file, offset, size) \
294 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
295 : get_64bit_elf_symbols (file, offset, size))
298 #ifdef ANSI_PROTOTYPES
300 error (const char * message, ...)
304 fprintf (stderr, _("%s: Error: "), program_name);
305 va_start (args, message);
306 vfprintf (stderr, message, args);
312 warn (const char * message, ...)
316 fprintf (stderr, _("%s: Warning: "), program_name);
317 va_start (args, message);
318 vfprintf (stderr, message, args);
330 fprintf (stderr, _("%s: Error: "), program_name);
332 message = va_arg (args, char *);
333 vfprintf (stderr, message, args);
345 fprintf (stderr, _("%s: Warning: "), program_name);
347 message = va_arg (args, char *);
348 vfprintf (stderr, message, args);
355 byte_get_little_endian (field, size)
356 unsigned char * field;
365 return ((unsigned int) (field [0]))
366 | (((unsigned int) (field [1])) << 8);
369 /* We want to extract data from an 8 byte wide field and
370 place it into a 4 byte wide field. Since this is a little
371 endian source we can juts use the 4 byte extraction code. */
374 return ((unsigned long) (field [0]))
375 | (((unsigned long) (field [1])) << 8)
376 | (((unsigned long) (field [2])) << 16)
377 | (((unsigned long) (field [3])) << 24);
381 /* This is a special case, generated by the BYTE_GET8 macro.
382 It means that we are loading an 8 byte value from a field
383 in an external structure into an 8 byte value in a field
384 in an internal strcuture. */
385 return ((bfd_vma) (field [0]))
386 | (((bfd_vma) (field [1])) << 8)
387 | (((bfd_vma) (field [2])) << 16)
388 | (((bfd_vma) (field [3])) << 24)
389 | (((bfd_vma) (field [4])) << 32)
390 | (((bfd_vma) (field [5])) << 40)
391 | (((bfd_vma) (field [6])) << 48)
392 | (((bfd_vma) (field [7])) << 56);
395 error (_("Unhandled data length: %d\n"), size);
400 /* Print a VMA value. */
402 print_vma (vma, mode)
412 case FULL_HEX: printf ("0x"); /* drop through */
413 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
414 case PREFIX_HEX: printf ("0x"); /* drop through */
415 case HEX: printf ("%lx", (unsigned long) vma); break;
416 case DEC: printf ("%ld", (unsigned long) vma); break;
417 case DEC_5: printf ("%5ld", (long) vma); break;
418 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
439 #if BFD_HOST_64BIT_LONG
442 if (_bfd_int64_high (vma))
443 printf ("%lx%lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
445 printf ("%lx", _bfd_int64_low (vma));
450 #if BFD_HOST_64BIT_LONG
453 if (_bfd_int64_high (vma))
455 printf ("++%ld", _bfd_int64_low (vma));
457 printf ("%ld", _bfd_int64_low (vma));
462 #if BFD_HOST_64BIT_LONG
463 printf ("%5ld", vma);
465 if (_bfd_int64_high (vma))
467 printf ("++%ld", _bfd_int64_low (vma));
469 printf ("%5ld", _bfd_int64_low (vma));
474 #if BFD_HOST_64BIT_LONG
477 if (_bfd_int64_high (vma))
479 printf ("++%lu", _bfd_int64_low (vma));
481 printf ("%lu", _bfd_int64_low (vma));
490 byte_get_big_endian (field, size)
491 unsigned char * field;
500 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
503 return ((unsigned long) (field [3]))
504 | (((unsigned long) (field [2])) << 8)
505 | (((unsigned long) (field [1])) << 16)
506 | (((unsigned long) (field [0])) << 24);
509 /* Although we are extracing data from an 8 byte wide field, we
510 are returning only 4 bytes of data. */
511 return ((unsigned long) (field [7]))
512 | (((unsigned long) (field [6])) << 8)
513 | (((unsigned long) (field [5])) << 16)
514 | (((unsigned long) (field [4])) << 24);
518 /* This is a special case, generated by the BYTE_GET8 macro.
519 It means that we are loading an 8 byte value from a field
520 in an external structure into an 8 byte value in a field
521 in an internal strcuture. */
522 return ((bfd_vma) (field [7]))
523 | (((bfd_vma) (field [6])) << 8)
524 | (((bfd_vma) (field [5])) << 16)
525 | (((bfd_vma) (field [4])) << 24)
526 | (((bfd_vma) (field [3])) << 32)
527 | (((bfd_vma) (field [2])) << 40)
528 | (((bfd_vma) (field [1])) << 48)
529 | (((bfd_vma) (field [0])) << 56);
533 error (_("Unhandled data length: %d\n"), size);
539 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
541 guess_is_rela (e_machine)
542 unsigned long e_machine;
546 /* Targets that use REL relocations. */
557 /* Targets that use RELA relocations. */
565 case EM_CYGNUS_MN10200:
566 case EM_CYGNUS_MN10300:
592 warn (_("Don't know about relocations on this machine architecture\n"));
597 /* Display the contents of the relocation data found at the specified offset. */
599 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
601 unsigned long rel_offset;
602 unsigned long rel_size;
603 Elf_Internal_Sym * symtab;
609 Elf_Internal_Rel * rels;
610 Elf_Internal_Rela * relas;
613 if (is_rela == UNKNOWN)
614 is_rela = guess_is_rela (elf_header.e_machine);
620 Elf32_External_Rela * erelas;
622 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
623 Elf32_External_Rela *, "relocs");
625 rel_size = rel_size / sizeof (Elf32_External_Rela);
627 relas = (Elf_Internal_Rela *)
628 malloc (rel_size * sizeof (Elf_Internal_Rela));
632 error(_("out of memory parsing relocs"));
636 for (i = 0; i < rel_size; i++)
638 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
639 relas[i].r_info = BYTE_GET (erelas[i].r_info);
640 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
645 rels = (Elf_Internal_Rel *) relas;
649 Elf64_External_Rela * erelas;
651 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
652 Elf64_External_Rela *, "relocs");
654 rel_size = rel_size / sizeof (Elf64_External_Rela);
656 relas = (Elf_Internal_Rela *)
657 malloc (rel_size * sizeof (Elf_Internal_Rela));
661 error(_("out of memory parsing relocs"));
665 for (i = 0; i < rel_size; i++)
667 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
668 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
669 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
674 rels = (Elf_Internal_Rel *) relas;
681 Elf32_External_Rel * erels;
683 GET_DATA_ALLOC (rel_offset, rel_size, erels,
684 Elf32_External_Rel *, "relocs");
686 rel_size = rel_size / sizeof (Elf32_External_Rel);
688 rels = (Elf_Internal_Rel *)
689 malloc (rel_size * sizeof (Elf_Internal_Rel));
693 error(_("out of memory parsing relocs"));
697 for (i = 0; i < rel_size; i++)
699 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
700 rels[i].r_info = BYTE_GET (erels[i].r_info);
705 relas = (Elf_Internal_Rela *) rels;
709 Elf64_External_Rel * erels;
711 GET_DATA_ALLOC (rel_offset, rel_size, erels,
712 Elf64_External_Rel *, "relocs");
714 rel_size = rel_size / sizeof (Elf64_External_Rel);
716 rels = (Elf_Internal_Rel *)
717 malloc (rel_size * sizeof (Elf_Internal_Rel));
721 error(_("out of memory parsing relocs"));
725 for (i = 0; i < rel_size; i++)
727 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
728 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
733 relas = (Elf_Internal_Rela *) rels;
739 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
742 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
744 for (i = 0; i < rel_size; i++)
749 bfd_vma symtab_index;
754 offset = relas [i].r_offset;
755 info = relas [i].r_info;
759 offset = rels [i].r_offset;
760 info = rels [i].r_info;
765 type = ELF32_R_TYPE (info);
766 symtab_index = ELF32_R_SYM (info);
770 if (elf_header.e_machine == EM_SPARCV9)
771 type = ELF64_R_TYPE_ID (info);
773 type = ELF64_R_TYPE (info);
774 /* The #ifdef BFD64 below is to prevent a compile time warning.
775 We know that if we do not have a 64 bit data type that we
776 will never execute this code anyway. */
778 symtab_index = ELF64_R_SYM (info);
782 #ifdef _bfd_int64_low
783 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
785 printf (" %8.8lx %5.5lx ", offset, info);
788 switch (elf_header.e_machine)
795 rtype = elf_m32r_reloc_type (type);
800 rtype = elf_i386_reloc_type (type);
804 rtype = elf_m68k_reloc_type (type);
808 rtype = elf_i960_reloc_type (type);
812 rtype = elf_avr_reloc_type (type);
819 rtype = elf_sparc_reloc_type (type);
823 rtype = v850_reloc_type (type);
827 rtype = elf_d10v_reloc_type (type);
831 rtype = elf_d30v_reloc_type (type);
835 rtype = elf_sh_reloc_type (type);
838 case EM_CYGNUS_MN10300:
839 rtype = elf_mn10300_reloc_type (type);
842 case EM_CYGNUS_MN10200:
843 rtype = elf_mn10200_reloc_type (type);
847 rtype = elf_fr30_reloc_type (type);
851 rtype = elf_mcore_reloc_type (type);
855 rtype = elf_ppc_reloc_type (type);
860 rtype = elf_mips_reloc_type (type);
864 rtype = elf_alpha_reloc_type (type);
868 rtype = elf_arm_reloc_type (type);
872 rtype = elf_arc_reloc_type (type);
876 rtype = elf_hppa_reloc_type (type);
880 rtype = elf_pj_reloc_type (type);
885 #ifdef _bfd_int64_low
886 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
888 printf (_("unrecognised: %-7lx"), type);
891 printf ("%-21.21s", rtype);
897 if (symtab_index >= nsyms)
898 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
901 Elf_Internal_Sym * psym;
903 psym = symtab + symtab_index;
906 print_vma (psym->st_value, LONG_HEX);
909 if (psym->st_name == 0)
911 SECTION_NAME (section_headers + psym->st_shndx));
912 else if (strtab == NULL)
913 printf (_("<string table index %3ld>"), psym->st_name);
915 printf ("%-25.25s", strtab + psym->st_name);
918 printf (" + %lx", (unsigned long) relas [i].r_addend);
924 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
925 print_vma (relas[i].r_addend, LONG_HEX);
928 if (elf_header.e_machine == EM_SPARCV9
929 && !strcmp (rtype, "R_SPARC_OLO10"))
930 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
941 get_mips_dynamic_type (type)
946 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
947 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
948 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
949 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
950 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
951 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
952 case DT_MIPS_MSYM: return "MIPS_MSYM";
953 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
954 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
955 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
956 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
957 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
958 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
959 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
960 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
961 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
962 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
963 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
964 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
965 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
966 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
967 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
968 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
969 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
970 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
971 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
972 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
973 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
974 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
975 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
976 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
977 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
978 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
979 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
980 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
981 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
982 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
983 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
984 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
985 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
986 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
987 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
988 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
995 get_sparc64_dynamic_type (type)
1000 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1007 get_parisc_dynamic_type (type)
1012 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1013 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1014 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1015 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1016 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1017 case DT_HP_PREINIT: return "HP_PREINIT";
1018 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1019 case DT_HP_NEEDED: return "HP_NEEDED";
1020 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1021 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1022 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1023 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1024 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1031 get_dynamic_type (type)
1034 static char buff [32];
1038 case DT_NULL: return "NULL";
1039 case DT_NEEDED: return "NEEDED";
1040 case DT_PLTRELSZ: return "PLTRELSZ";
1041 case DT_PLTGOT: return "PLTGOT";
1042 case DT_HASH: return "HASH";
1043 case DT_STRTAB: return "STRTAB";
1044 case DT_SYMTAB: return "SYMTAB";
1045 case DT_RELA: return "RELA";
1046 case DT_RELASZ: return "RELASZ";
1047 case DT_RELAENT: return "RELAENT";
1048 case DT_STRSZ: return "STRSZ";
1049 case DT_SYMENT: return "SYMENT";
1050 case DT_INIT: return "INIT";
1051 case DT_FINI: return "FINI";
1052 case DT_SONAME: return "SONAME";
1053 case DT_RPATH: return "RPATH";
1054 case DT_SYMBOLIC: return "SYMBOLIC";
1055 case DT_REL: return "REL";
1056 case DT_RELSZ: return "RELSZ";
1057 case DT_RELENT: return "RELENT";
1058 case DT_PLTREL: return "PLTREL";
1059 case DT_DEBUG: return "DEBUG";
1060 case DT_TEXTREL: return "TEXTREL";
1061 case DT_JMPREL: return "JMPREL";
1062 case DT_BIND_NOW: return "BIND_NOW";
1063 case DT_INIT_ARRAY: return "INIT_ARRAY";
1064 case DT_FINI_ARRAY: return "FINI_ARRAY";
1065 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1066 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1067 case DT_RUNPATH: return "RUNPATH";
1068 case DT_FLAGS: return "FLAGS";
1070 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1071 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1073 case DT_PLTPADSZ: return "PLTPADSZ";
1074 case DT_MOVEENT: return "MOVEENT";
1075 case DT_MOVESZ: return "MOVESZ";
1076 case DT_FEATURE_1: return "FEATURE_1";
1077 case DT_POSFLAG_1: return "POSFLAG_1";
1078 case DT_SYMINSZ: return "SYMINSZ";
1079 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1081 case DT_ADDRRNGLO: return "ADDRRNGLO";
1082 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1084 case DT_VERSYM: return "VERSYM";
1086 case DT_RELACOUNT: return "RELACOUNT";
1087 case DT_RELCOUNT: return "RELCOUNT";
1088 case DT_FLAGS_1: return "FLAGS_1";
1089 case DT_VERDEF: return "VERDEF";
1090 case DT_VERDEFNUM: return "VERDEFNUM";
1091 case DT_VERNEED: return "VERNEED";
1092 case DT_VERNEEDNUM: return "VERNEEDNUM";
1094 case DT_AUXILIARY: return "AUXILARY";
1095 case DT_USED: return "USED";
1096 case DT_FILTER: return "FILTER";
1099 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1101 const char * result;
1103 switch (elf_header.e_machine)
1106 case EM_MIPS_RS4_BE:
1107 result = get_mips_dynamic_type (type);
1110 result = get_sparc64_dynamic_type (type);
1120 sprintf (buff, _("Processor Specific: %lx"), type);
1122 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1124 const char * result;
1126 switch (elf_header.e_machine)
1129 result = get_parisc_dynamic_type (type);
1139 sprintf (buff, _("Operating System specific: %lx"), type);
1142 sprintf (buff, _("<unknown>: %lx"), type);
1149 get_file_type (e_type)
1152 static char buff [32];
1156 case ET_NONE: return _("NONE (None)");
1157 case ET_REL: return _("REL (Relocatable file)");
1158 case ET_EXEC: return _("EXEC (Executable file)");
1159 case ET_DYN: return _("DYN (Shared object file)");
1160 case ET_CORE: return _("CORE (Core file)");
1163 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1164 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1165 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1166 sprintf (buff, _("OS Specific: (%x)"), e_type);
1168 sprintf (buff, _("<unknown>: %x"), e_type);
1174 get_machine_name (e_machine)
1177 static char buff [64]; /* XXX */
1181 case EM_NONE: return _("None");
1182 case EM_M32: return "WE32100";
1183 case EM_SPARC: return "Sparc";
1184 case EM_386: return "Intel 80386";
1185 case EM_68K: return "MC68000";
1186 case EM_88K: return "MC88000";
1187 case EM_486: return "Intel 80486";
1188 case EM_860: return "Intel 80860";
1189 case EM_MIPS: return "MIPS R3000";
1190 case EM_S370: return "IBM System/370";
1191 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1192 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1193 case EM_PARISC: return "HPPA";
1194 case EM_PPC_OLD: return "Power PC (old)";
1195 case EM_SPARC32PLUS: return "Sparc v8+" ;
1196 case EM_960: return "Intel 90860";
1197 case EM_PPC: return "PowerPC";
1198 case EM_V800: return "NEC V800";
1199 case EM_FR20: return "Fujitsu FR20";
1200 case EM_RH32: return "TRW RH32";
1201 case EM_MCORE: return "MCORE";
1202 case EM_ARM: return "ARM";
1203 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1204 case EM_SH: return "Hitachi SH";
1205 case EM_SPARCV9: return "Sparc v9";
1206 case EM_TRICORE: return "Siemens Tricore";
1207 case EM_ARC: return "Argonaut RISC Core";
1208 case EM_H8_300: return "Hitachi H8/300";
1209 case EM_H8_300H: return "Hitachi H8/300H";
1210 case EM_H8S: return "Hitachi H8S";
1211 case EM_H8_500: return "Hitachi H8/500";
1212 case EM_IA_64: return "Intel IA-64";
1213 case EM_MIPS_X: return "Stanford MIPS-X";
1214 case EM_COLDFIRE: return "Motorola Coldfire";
1215 case EM_68HC12: return "Motorola M68HC12";
1216 case EM_ALPHA: return "Alpha";
1217 case EM_CYGNUS_D10V: return "d10v";
1218 case EM_CYGNUS_D30V: return "d30v";
1219 case EM_CYGNUS_ARC: return "Arc";
1220 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1221 case EM_CYGNUS_V850: return "NEC v850";
1222 case EM_CYGNUS_MN10300: return "mn10300";
1223 case EM_CYGNUS_MN10200: return "mn10200";
1224 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1225 case EM_PJ: return "picoJava";
1226 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1227 case EM_PCP: return "Siemens PCP";
1228 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1229 case EM_NDR1: return "Denso NDR1 microprocesspr";
1230 case EM_STARCORE: return "Motorola Star*Core processor";
1231 case EM_ME16: return "Toyota ME16 processor";
1232 case EM_ST100: return "STMicroelectronics ST100 processor";
1233 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1234 case EM_FX66: return "Siemens FX66 microcontroller";
1235 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1236 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1237 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1238 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1239 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1240 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1241 case EM_SVX: return "Silicon Graphics SVx";
1242 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1243 case EM_VAX: return "Digital VAX";
1244 case EM_AVR: return "AVR";
1246 sprintf (buff, _("<unknown>: %x"), e_machine);
1252 decode_ARM_machine_flags (e_flags, buf)
1259 eabi = EF_ARM_EABI_VERSION (e_flags);
1260 e_flags &= ~ EF_ARM_EABIMASK;
1262 /* Handle "generic" ARM flags. */
1263 if (e_flags & EF_ARM_RELEXEC)
1265 strcat (buf, ", relocatable executable");
1266 e_flags &= ~ EF_ARM_RELEXEC;
1269 if (e_flags & EF_ARM_HASENTRY)
1271 strcat (buf, ", has entry point");
1272 e_flags &= ~ EF_ARM_HASENTRY;
1275 /* Now handle EABI specific flags. */
1279 strcat (buf, ", <unknown EABI>");
1284 case EF_ARM_EABI_VER1:
1289 /* Process flags one bit at a time. */
1290 flag = e_flags & - e_flags;
1295 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_INTERWORK. */
1296 strcat (buf, ", sorted symbol tables");
1306 case EF_ARM_EABI_UNKNOWN:
1311 /* Process flags one bit at a time. */
1312 flag = e_flags & - e_flags;
1318 strcat (buf, ", interworking enabled");
1322 strcat (buf, ", uses APCS/26");
1326 strcat (buf, ", uses APCS/float");
1330 strcat (buf, ", position independent");
1334 strcat (buf, ", 8 bit structure alignment");
1338 strcat (buf, ", uses new ABI");
1342 strcat (buf, ", uses old ABI");
1346 strcat (buf, ", software FP");
1357 strcat (buf,", <unknown>");
1361 get_machine_flags (e_flags, e_machine)
1365 static char buf [1024];
1377 decode_ARM_machine_flags (e_flags, buf);
1381 if (e_flags & EF_CPU32)
1382 strcat (buf, ", cpu32");
1386 if (e_flags & EF_PPC_EMB)
1387 strcat (buf, ", emb");
1389 if (e_flags & EF_PPC_RELOCATABLE)
1390 strcat (buf, ", relocatable");
1392 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1393 strcat (buf, ", relocatable-lib");
1396 case EM_CYGNUS_V850:
1397 switch (e_flags & EF_V850_ARCH)
1400 strcat (buf, ", v850e");
1403 strcat (buf, ", v850ea");
1406 strcat (buf, ", v850");
1409 strcat (buf, ", unknown v850 architecture variant");
1414 case EM_CYGNUS_M32R:
1415 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1416 strcat (buf, ", m32r");
1421 case EM_MIPS_RS4_BE:
1422 if (e_flags & EF_MIPS_NOREORDER)
1423 strcat (buf, ", noreorder");
1425 if (e_flags & EF_MIPS_PIC)
1426 strcat (buf, ", pic");
1428 if (e_flags & EF_MIPS_CPIC)
1429 strcat (buf, ", cpic");
1431 if (e_flags & EF_MIPS_ABI2)
1432 strcat (buf, ", abi2");
1434 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1435 strcat (buf, ", mips1");
1437 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1438 strcat (buf, ", mips2");
1440 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1441 strcat (buf, ", mips3");
1443 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1444 strcat (buf, ", mips4");
1448 if (e_flags & EF_SPARC_32PLUS)
1449 strcat (buf, ", v8+");
1451 if (e_flags & EF_SPARC_SUN_US1)
1452 strcat (buf, ", ultrasparcI");
1454 if (e_flags & EF_SPARC_SUN_US3)
1455 strcat (buf, ", ultrasparcIII");
1457 if (e_flags & EF_SPARC_HAL_R1)
1458 strcat (buf, ", halr1");
1460 if (e_flags & EF_SPARC_LEDATA)
1461 strcat (buf, ", ledata");
1463 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1464 strcat (buf, ", tso");
1466 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1467 strcat (buf, ", pso");
1469 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1470 strcat (buf, ", rmo");
1474 switch (e_flags & EF_PARISC_ARCH)
1476 case EFA_PARISC_1_0:
1477 strcpy (buf, ", PA-RISC 1.0");
1479 case EFA_PARISC_1_1:
1480 strcpy (buf, ", PA-RISC 1.1");
1482 case EFA_PARISC_2_0:
1483 strcpy (buf, ", PA-RISC 2.0");
1488 if (e_flags & EF_PARISC_TRAPNIL)
1489 strcat (buf, ", trapnil");
1490 if (e_flags & EF_PARISC_EXT)
1491 strcat (buf, ", ext");
1492 if (e_flags & EF_PARISC_LSB)
1493 strcat (buf, ", lsb");
1494 if (e_flags & EF_PARISC_WIDE)
1495 strcat (buf, ", wide");
1496 if (e_flags & EF_PARISC_NO_KABP)
1497 strcat (buf, ", no kabp");
1498 if (e_flags & EF_PARISC_LAZYSWAP)
1499 strcat (buf, ", lazyswap");
1503 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1504 strcat (buf, ", new calling convention");
1506 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1507 strcat (buf, ", gnu calling convention");
1516 get_mips_segment_type (type)
1521 case PT_MIPS_REGINFO:
1523 case PT_MIPS_RTPROC:
1525 case PT_MIPS_OPTIONS:
1535 get_parisc_segment_type (type)
1540 case PT_HP_TLS: return "HP_TLS";
1541 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1542 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1543 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1544 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1545 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1546 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1547 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1548 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1549 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1550 case PT_HP_PARALLEL: return "HP_PARALLEL";
1551 case PT_HP_FASTBIND: return "HP_FASTBIND";
1552 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1553 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1562 get_segment_type (p_type)
1563 unsigned long p_type;
1565 static char buff [32];
1569 case PT_NULL: return "NULL";
1570 case PT_LOAD: return "LOAD";
1571 case PT_DYNAMIC: return "DYNAMIC";
1572 case PT_INTERP: return "INTERP";
1573 case PT_NOTE: return "NOTE";
1574 case PT_SHLIB: return "SHLIB";
1575 case PT_PHDR: return "PHDR";
1578 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1580 const char * result;
1582 switch (elf_header.e_machine)
1585 case EM_MIPS_RS4_BE:
1586 result = get_mips_segment_type (p_type);
1589 result = get_parisc_segment_type (p_type);
1599 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1601 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1603 const char * result;
1605 switch (elf_header.e_machine)
1608 result = get_parisc_segment_type (p_type);
1618 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1621 sprintf (buff, _("<unknown>: %lx"), p_type);
1628 get_mips_section_type_name (sh_type)
1629 unsigned int sh_type;
1633 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1634 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1635 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1636 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1637 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1638 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1639 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1640 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1641 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1642 case SHT_MIPS_RELD: return "MIPS_RELD";
1643 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1644 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1645 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1646 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1647 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1648 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1649 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1650 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1651 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1652 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1653 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1654 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1655 case SHT_MIPS_LINE: return "MIPS_LINE";
1656 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1657 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1658 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1659 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1660 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1661 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1662 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1663 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1664 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1665 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1666 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1667 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1668 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1669 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1670 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1671 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1679 get_parisc_section_type_name (sh_type)
1680 unsigned int sh_type;
1684 case SHT_PARISC_EXT: return "PARISC_EXT";
1685 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1686 case SHT_PARISC_DOC: return "PARISC_DOC";
1694 get_section_type_name (sh_type)
1695 unsigned int sh_type;
1697 static char buff [32];
1701 case SHT_NULL: return "NULL";
1702 case SHT_PROGBITS: return "PROGBITS";
1703 case SHT_SYMTAB: return "SYMTAB";
1704 case SHT_STRTAB: return "STRTAB";
1705 case SHT_RELA: return "RELA";
1706 case SHT_HASH: return "HASH";
1707 case SHT_DYNAMIC: return "DYNAMIC";
1708 case SHT_NOTE: return "NOTE";
1709 case SHT_NOBITS: return "NOBITS";
1710 case SHT_REL: return "REL";
1711 case SHT_SHLIB: return "SHLIB";
1712 case SHT_DYNSYM: return "DYNSYM";
1713 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1714 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1715 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1716 case SHT_GNU_verdef: return "VERDEF";
1717 case SHT_GNU_verneed: return "VERNEED";
1718 case SHT_GNU_versym: return "VERSYM";
1719 case 0x6ffffff0: return "VERSYM";
1720 case 0x6ffffffc: return "VERDEF";
1721 case 0x7ffffffd: return "AUXILIARY";
1722 case 0x7fffffff: return "FILTER";
1725 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1727 const char * result;
1729 switch (elf_header.e_machine)
1732 case EM_MIPS_RS4_BE:
1733 result = get_mips_section_type_name (sh_type);
1736 result = get_parisc_section_type_name (sh_type);
1746 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1748 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1749 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1750 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1751 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1753 sprintf (buff, _("<unknown>: %x"), sh_type);
1759 struct option options [] =
1761 {"all", no_argument, 0, 'a'},
1762 {"file-header", no_argument, 0, 'h'},
1763 {"program-headers", no_argument, 0, 'l'},
1764 {"headers", no_argument, 0, 'e'},
1765 {"histogram", no_argument, 0, 'I'},
1766 {"segments", no_argument, 0, 'l'},
1767 {"sections", no_argument, 0, 'S'},
1768 {"section-headers", no_argument, 0, 'S'},
1769 {"symbols", no_argument, 0, 's'},
1770 {"syms", no_argument, 0, 's'},
1771 {"relocs", no_argument, 0, 'r'},
1772 {"notes", no_argument, 0, 'n'},
1773 {"dynamic", no_argument, 0, 'd'},
1774 {"arch-specific", no_argument, 0, 'A'},
1775 {"version-info", no_argument, 0, 'V'},
1776 {"use-dynamic", no_argument, 0, 'D'},
1777 {"hex-dump", required_argument, 0, 'x'},
1778 {"debug-dump", optional_argument, 0, 'w'},
1779 #ifdef SUPPORT_DISASSEMBLY
1780 {"instruction-dump", required_argument, 0, 'i'},
1783 {"version", no_argument, 0, 'v'},
1784 {"help", no_argument, 0, 'H'},
1785 {0, no_argument, 0, 0}
1791 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1792 fprintf (stdout, _(" Options are:\n"));
1793 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1794 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1795 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1796 fprintf (stdout, _(" Display the program headers\n"));
1797 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1798 fprintf (stdout, _(" Display the sections' header\n"));
1799 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1800 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1801 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1802 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1803 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1804 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1805 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1806 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1807 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1808 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1809 fprintf (stdout, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1810 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
1811 #ifdef SUPPORT_DISASSEMBLY
1812 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1813 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1815 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1816 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1817 fprintf (stdout, _(" -H or --help Display this information\n"));
1818 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
1824 request_dump (section, type)
1825 unsigned int section;
1828 if (section >= num_dump_sects)
1830 char * new_dump_sects;
1832 new_dump_sects = (char *) calloc (section + 1, 1);
1834 if (new_dump_sects == NULL)
1835 error (_("Out of memory allocating dump request table."));
1838 /* Copy current flag settings. */
1839 memcpy (new_dump_sects, dump_sects, num_dump_sects);
1843 dump_sects = new_dump_sects;
1844 num_dump_sects = section + 1;
1849 dump_sects [section] |= type;
1855 parse_args (argc, argv)
1864 while ((c = getopt_long
1865 (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
1900 do_using_dynamic ++;
1928 section = strtoul (optarg, & cp, 0);
1929 if (! * cp && section >= 0)
1931 request_dump (section, HEX_DUMP);
1951 do_debug_abbrevs = 1;
1961 do_debug_pubnames = 1;
1966 do_debug_aranges = 1;
1970 warn (_("Unrecognised debug option '%s'\n"), optarg);
1975 #ifdef SUPPORT_DISASSEMBLY
1978 section = strtoul (optarg, & cp, 0);
1979 if (! * cp && section >= 0)
1981 request_dump (section, DISASS_DUMP);
1987 print_version (program_name);
1994 /* xgettext:c-format */
1995 error (_("Invalid option '-%c'\n"), c);
2002 if (!do_dynamic && !do_syms && !do_reloc && !do_sections
2003 && !do_segments && !do_header && !do_dump && !do_version
2004 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2008 warn (_("Nothing to do.\n"));
2014 get_elf_class (elf_class)
2015 unsigned char elf_class;
2017 static char buff [32];
2021 case ELFCLASSNONE: return _("none");
2022 case ELFCLASS32: return _("ELF32");
2023 case ELFCLASS64: return _("ELF64");
2025 sprintf (buff, _("<unknown: %x>"), elf_class);
2031 get_data_encoding (encoding)
2032 unsigned char encoding;
2034 static char buff [32];
2038 case ELFDATANONE: return _("none");
2039 case ELFDATA2LSB: return _("2's complement, little endian");
2040 case ELFDATA2MSB: return _("2's complement, big endian");
2042 sprintf (buff, _("<unknown: %x>"), encoding);
2048 get_osabi_name (osabi)
2049 unsigned char osabi;
2051 static char buff [32];
2055 case ELFOSABI_SYSV: return _("UNIX - System V");
2056 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2057 case ELFOSABI_LINUX: return _("UNIX - Linux");
2058 case ELFOSABI_STANDALONE: return _("Standalone App");
2059 case ELFOSABI_ARM: return _("ARM");
2061 sprintf (buff, _("<unknown: %x>"), osabi);
2066 /* Decode the data held in 'elf_header'. */
2068 process_file_header ()
2070 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2071 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2072 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2073 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2076 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2084 printf (_("ELF Header:\n"));
2085 printf (_(" Magic: "));
2086 for (i = 0; i < EI_NIDENT; i ++)
2087 printf ("%2.2x ", elf_header.e_ident [i]);
2089 printf (_(" Class: %s\n"),
2090 get_elf_class (elf_header.e_ident [EI_CLASS]));
2091 printf (_(" Data: %s\n"),
2092 get_data_encoding (elf_header.e_ident [EI_DATA]));
2093 printf (_(" Version: %d %s\n"),
2094 elf_header.e_ident [EI_VERSION],
2095 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2097 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2100 printf (_(" OS/ABI: %s\n"),
2101 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2102 printf (_(" ABI Version: %d\n"),
2103 elf_header.e_ident [EI_ABIVERSION]);
2104 printf (_(" Type: %s\n"),
2105 get_file_type (elf_header.e_type));
2106 printf (_(" Machine: %s\n"),
2107 get_machine_name (elf_header.e_machine));
2108 printf (_(" Version: 0x%lx\n"),
2109 (unsigned long) elf_header.e_version);
2111 printf (_(" Entry point address: "));
2112 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2113 printf (_("\n Start of program headers: "));
2114 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2115 printf (_(" (bytes into file)\n Start of section headers: "));
2116 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2117 printf (_(" (bytes into file)\n"));
2119 printf (_(" Flags: 0x%lx%s\n"),
2120 (unsigned long) elf_header.e_flags,
2121 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2122 printf (_(" Size of this header: %ld (bytes)\n"),
2123 (long) elf_header.e_ehsize);
2124 printf (_(" Size of program headers: %ld (bytes)\n"),
2125 (long) elf_header.e_phentsize);
2126 printf (_(" Number of program headers: %ld\n"),
2127 (long) elf_header.e_phnum);
2128 printf (_(" Size of section headers: %ld (bytes)\n"),
2129 (long) elf_header.e_shentsize);
2130 printf (_(" Number of section headers: %ld\n"),
2131 (long) elf_header.e_shnum);
2132 printf (_(" Section header string table index: %ld\n"),
2133 (long) elf_header.e_shstrndx);
2141 get_32bit_program_headers (file, program_headers)
2143 Elf_Internal_Phdr * program_headers;
2145 Elf32_External_Phdr * phdrs;
2146 Elf32_External_Phdr * external;
2147 Elf32_Internal_Phdr * internal;
2150 GET_DATA_ALLOC (elf_header.e_phoff,
2151 elf_header.e_phentsize * elf_header.e_phnum,
2152 phdrs, Elf32_External_Phdr *, "program headers");
2154 for (i = 0, internal = program_headers, external = phdrs;
2155 i < elf_header.e_phnum;
2156 i ++, internal ++, external ++)
2158 internal->p_type = BYTE_GET (external->p_type);
2159 internal->p_offset = BYTE_GET (external->p_offset);
2160 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2161 internal->p_paddr = BYTE_GET (external->p_paddr);
2162 internal->p_filesz = BYTE_GET (external->p_filesz);
2163 internal->p_memsz = BYTE_GET (external->p_memsz);
2164 internal->p_flags = BYTE_GET (external->p_flags);
2165 internal->p_align = BYTE_GET (external->p_align);
2174 get_64bit_program_headers (file, program_headers)
2176 Elf_Internal_Phdr * program_headers;
2178 Elf64_External_Phdr * phdrs;
2179 Elf64_External_Phdr * external;
2180 Elf64_Internal_Phdr * internal;
2183 GET_DATA_ALLOC (elf_header.e_phoff,
2184 elf_header.e_phentsize * elf_header.e_phnum,
2185 phdrs, Elf64_External_Phdr *, "program headers");
2187 for (i = 0, internal = program_headers, external = phdrs;
2188 i < elf_header.e_phnum;
2189 i ++, internal ++, external ++)
2191 internal->p_type = BYTE_GET (external->p_type);
2192 internal->p_flags = BYTE_GET (external->p_flags);
2193 internal->p_offset = BYTE_GET8 (external->p_offset);
2194 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2195 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2196 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2197 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2198 internal->p_align = BYTE_GET8 (external->p_align);
2207 process_program_headers (file)
2210 Elf_Internal_Phdr * program_headers;
2211 Elf_Internal_Phdr * segment;
2214 if (elf_header.e_phnum == 0)
2217 printf (_("\nThere are no program headers in this file.\n"));
2221 if (do_segments && !do_header)
2223 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2224 printf (_("Entry point "));
2225 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2226 printf (_("\nThere are %d program headers, starting at offset "),
2227 elf_header.e_phnum);
2228 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2232 program_headers = (Elf_Internal_Phdr *) malloc
2233 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2235 if (program_headers == NULL)
2237 error (_("Out of memory\n"));
2242 i = get_32bit_program_headers (file, program_headers);
2244 i = get_64bit_program_headers (file, program_headers);
2248 free (program_headers);
2255 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2259 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2263 (_(" Type Offset VirtAddr PhysAddr\n"));
2265 (_(" FileSiz MemSiz Flags Align\n"));
2273 for (i = 0, segment = program_headers;
2274 i < elf_header.e_phnum;
2279 printf (" %-14.14s ", get_segment_type (segment->p_type));
2283 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2284 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2285 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2286 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2287 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2289 (segment->p_flags & PF_R ? 'R' : ' '),
2290 (segment->p_flags & PF_W ? 'W' : ' '),
2291 (segment->p_flags & PF_X ? 'E' : ' '));
2292 printf ("%#lx", (unsigned long) segment->p_align);
2296 print_vma (segment->p_offset, FULL_HEX);
2298 print_vma (segment->p_vaddr, FULL_HEX);
2300 print_vma (segment->p_paddr, FULL_HEX);
2302 print_vma (segment->p_filesz, FULL_HEX);
2304 print_vma (segment->p_memsz, FULL_HEX);
2306 (segment->p_flags & PF_R ? 'R' : ' '),
2307 (segment->p_flags & PF_W ? 'W' : ' '),
2308 (segment->p_flags & PF_X ? 'E' : ' '));
2309 print_vma (segment->p_align, HEX);
2313 switch (segment->p_type)
2317 loadaddr = (segment->p_vaddr & 0xfffff000)
2318 - (segment->p_offset & 0xfffff000);
2323 error (_("more than one dynamic segment\n"));
2325 dynamic_addr = segment->p_offset;
2326 dynamic_size = segment->p_filesz;
2330 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2331 error (_("Unable to find program interpreter name\n"));
2334 program_interpreter[0] = 0;
2335 fscanf (file, "%63s", program_interpreter);
2338 printf (_("\n [Requesting program interpreter: %s]"),
2339 program_interpreter);
2345 putc ('\n', stdout);
2354 if (do_segments && section_headers != NULL)
2356 printf (_("\n Section to Segment mapping:\n"));
2357 printf (_(" Segment Sections...\n"));
2359 assert (string_table != NULL);
2361 for (i = 0; i < elf_header.e_phnum; i++)
2364 Elf_Internal_Shdr * section;
2366 segment = program_headers + i;
2367 section = section_headers;
2369 printf (" %2.2d ", i);
2371 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2373 if (section->sh_size > 0
2374 /* Compare allocated sections by VMA, unallocated
2375 sections by file offset. */
2376 && (section->sh_flags & SHF_ALLOC
2377 ? (section->sh_addr >= segment->p_vaddr
2378 && section->sh_addr + section->sh_size
2379 <= segment->p_vaddr + segment->p_memsz)
2380 : ((bfd_vma) section->sh_offset >= segment->p_offset
2381 && (section->sh_offset + section->sh_size
2382 <= segment->p_offset + segment->p_filesz))))
2383 printf ("%s ", SECTION_NAME (section));
2390 free (program_headers);
2397 get_32bit_section_headers (file)
2400 Elf32_External_Shdr * shdrs;
2401 Elf32_Internal_Shdr * internal;
2404 GET_DATA_ALLOC (elf_header.e_shoff,
2405 elf_header.e_shentsize * elf_header.e_shnum,
2406 shdrs, Elf32_External_Shdr *, "section headers");
2408 section_headers = (Elf_Internal_Shdr *) malloc
2409 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2411 if (section_headers == NULL)
2413 error (_("Out of memory\n"));
2417 for (i = 0, internal = section_headers;
2418 i < elf_header.e_shnum;
2421 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2422 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2423 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2424 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2425 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2426 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2427 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2428 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2429 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2430 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2439 get_64bit_section_headers (file)
2442 Elf64_External_Shdr * shdrs;
2443 Elf64_Internal_Shdr * internal;
2446 GET_DATA_ALLOC (elf_header.e_shoff,
2447 elf_header.e_shentsize * elf_header.e_shnum,
2448 shdrs, Elf64_External_Shdr *, "section headers");
2450 section_headers = (Elf_Internal_Shdr *) malloc
2451 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2453 if (section_headers == NULL)
2455 error (_("Out of memory\n"));
2459 for (i = 0, internal = section_headers;
2460 i < elf_header.e_shnum;
2463 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2464 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2465 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2466 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2467 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2468 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2469 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2470 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2471 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2472 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2480 static Elf_Internal_Sym *
2481 get_32bit_elf_symbols (file, offset, number)
2483 unsigned long offset;
2484 unsigned long number;
2486 Elf32_External_Sym * esyms;
2487 Elf_Internal_Sym * isyms;
2488 Elf_Internal_Sym * psym;
2491 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2492 esyms, Elf32_External_Sym *, "symbols");
2494 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2498 error (_("Out of memory\n"));
2504 for (j = 0, psym = isyms;
2508 psym->st_name = BYTE_GET (esyms[j].st_name);
2509 psym->st_value = BYTE_GET (esyms[j].st_value);
2510 psym->st_size = BYTE_GET (esyms[j].st_size);
2511 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2512 psym->st_info = BYTE_GET (esyms[j].st_info);
2513 psym->st_other = BYTE_GET (esyms[j].st_other);
2521 static Elf_Internal_Sym *
2522 get_64bit_elf_symbols (file, offset, number)
2524 unsigned long offset;
2525 unsigned long number;
2527 Elf64_External_Sym * esyms;
2528 Elf_Internal_Sym * isyms;
2529 Elf_Internal_Sym * psym;
2532 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2533 esyms, Elf64_External_Sym *, "symbols");
2535 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2539 error (_("Out of memory\n"));
2545 for (j = 0, psym = isyms;
2549 psym->st_name = BYTE_GET (esyms[j].st_name);
2550 psym->st_info = BYTE_GET (esyms[j].st_info);
2551 psym->st_other = BYTE_GET (esyms[j].st_other);
2552 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2553 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2554 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2563 get_elf_section_flags (sh_flags)
2566 static char buff [32];
2574 flag = sh_flags & - sh_flags;
2579 case SHF_WRITE: strcat (buff, "W"); break;
2580 case SHF_ALLOC: strcat (buff, "A"); break;
2581 case SHF_EXECINSTR: strcat (buff, "X"); break;
2582 case SHF_MERGE: strcat (buff, "M"); break;
2583 case SHF_STRINGS: strcat (buff, "S"); break;
2584 case SHF_INFO_LINK: strcat (buff, "I"); break;
2585 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2586 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2589 if (flag & SHF_MASKOS)
2592 sh_flags &= ~ SHF_MASKOS;
2594 else if (flag & SHF_MASKPROC)
2597 sh_flags &= ~ SHF_MASKPROC;
2609 process_section_headers (file)
2612 Elf_Internal_Shdr * section;
2615 section_headers = NULL;
2617 if (elf_header.e_shnum == 0)
2620 printf (_("\nThere are no sections in this file.\n"));
2625 if (do_sections && !do_header)
2626 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2627 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2631 if (! get_32bit_section_headers (file))
2634 else if (! get_64bit_section_headers (file))
2637 /* Read in the string table, so that we have names to display. */
2638 section = section_headers + elf_header.e_shstrndx;
2640 if (section->sh_size != 0)
2642 unsigned long string_table_offset;
2644 string_table_offset = section->sh_offset;
2646 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2647 string_table, char *, "string table");
2650 /* Scan the sections for the dynamic symbol table
2651 and dynamic string table and debug sections. */
2652 dynamic_symbols = NULL;
2653 dynamic_strings = NULL;
2654 dynamic_syminfo = NULL;
2656 for (i = 0, section = section_headers;
2657 i < elf_header.e_shnum;
2660 char * name = SECTION_NAME (section);
2662 if (section->sh_type == SHT_DYNSYM)
2664 if (dynamic_symbols != NULL)
2666 error (_("File contains multiple dynamic symbol tables\n"));
2670 num_dynamic_syms = section->sh_size / section->sh_entsize;
2672 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2674 else if (section->sh_type == SHT_STRTAB
2675 && strcmp (name, ".dynstr") == 0)
2677 if (dynamic_strings != NULL)
2679 error (_("File contains multiple dynamic string tables\n"));
2683 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2684 dynamic_strings, char *, "dynamic strings");
2686 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2687 || do_debug_lines || do_debug_pubnames || do_debug_aranges)
2688 && strncmp (name, ".debug_", 7) == 0)
2693 || (do_debug_info && (strcmp (name, "info") == 0))
2694 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2695 || (do_debug_lines && (strcmp (name, "line") == 0))
2696 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2697 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2699 request_dump (i, DEBUG_DUMP);
2706 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2710 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2713 printf (_(" [Nr] Name Type Address Offset\n"));
2714 printf (_(" Size EntSize Flags Link Info Align\n"));
2717 for (i = 0, section = section_headers;
2718 i < elf_header.e_shnum;
2721 printf (" [%2d] %-17.17s %-15.15s ",
2723 SECTION_NAME (section),
2724 get_section_type_name (section->sh_type));
2728 print_vma (section->sh_addr, LONG_HEX);
2730 printf ( " %6.6lx %6.6lx %2.2lx",
2731 (unsigned long) section->sh_offset,
2732 (unsigned long) section->sh_size,
2733 (unsigned long) section->sh_entsize);
2735 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2737 printf (" %2ld %3lx %ld\n",
2738 (unsigned long) section->sh_link,
2739 (unsigned long) section->sh_info,
2740 (unsigned long) section->sh_addralign);
2745 print_vma (section->sh_addr, LONG_HEX);
2746 printf (" %8.8lx", section->sh_offset);
2748 print_vma (section->sh_size, LONG_HEX);
2750 print_vma (section->sh_entsize, LONG_HEX);
2752 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2754 printf (" %2ld %3lx %ld\n",
2755 (unsigned long) section->sh_link,
2756 (unsigned long) section->sh_info,
2757 (unsigned long) section->sh_addralign);
2761 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2762 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2763 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2768 /* Process the reloc section. */
2770 process_relocs (file)
2773 unsigned long rel_size;
2774 unsigned long rel_offset;
2780 if (do_using_dynamic)
2782 int is_rela = FALSE;
2787 if (dynamic_info[DT_REL])
2789 rel_offset = dynamic_info[DT_REL];
2790 rel_size = dynamic_info[DT_RELSZ];
2793 else if (dynamic_info [DT_RELA])
2795 rel_offset = dynamic_info[DT_RELA];
2796 rel_size = dynamic_info[DT_RELASZ];
2799 else if (dynamic_info[DT_JMPREL])
2801 rel_offset = dynamic_info[DT_JMPREL];
2802 rel_size = dynamic_info[DT_PLTRELSZ];
2804 switch (dynamic_info[DT_PLTREL])
2821 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2822 rel_offset, rel_size);
2824 dump_relocations (file, rel_offset - loadaddr, rel_size,
2825 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2828 printf (_("\nThere are no dynamic relocations in this file.\n"));
2832 Elf32_Internal_Shdr * section;
2836 for (i = 0, section = section_headers;
2837 i < elf_header.e_shnum;
2840 if ( section->sh_type != SHT_RELA
2841 && section->sh_type != SHT_REL)
2844 rel_offset = section->sh_offset;
2845 rel_size = section->sh_size;
2849 Elf32_Internal_Shdr * strsec;
2850 Elf32_Internal_Shdr * symsec;
2851 Elf_Internal_Sym * symtab;
2854 unsigned long nsyms;
2856 printf (_("\nRelocation section "));
2858 if (string_table == NULL)
2859 printf ("%d", section->sh_name);
2861 printf ("'%s'", SECTION_NAME (section));
2863 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2864 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2866 symsec = section_headers + section->sh_link;
2868 nsyms = symsec->sh_size / symsec->sh_entsize;
2869 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2874 strsec = section_headers + symsec->sh_link;
2876 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2877 char *, "string table");
2879 is_rela = section->sh_type == SHT_RELA;
2881 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2891 printf (_("\nThere are no relocations in this file.\n"));
2899 dynamic_segment_mips_val (entry)
2900 Elf_Internal_Dyn * entry;
2902 switch (entry->d_tag)
2905 if (entry->d_un.d_val == 0)
2909 static const char * opts[] =
2911 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2912 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2913 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2914 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2919 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2920 if (entry->d_un.d_val & (1 << cnt))
2922 printf ("%s%s", first ? "" : " ", opts[cnt]);
2929 case DT_MIPS_IVERSION:
2930 if (dynamic_strings != NULL)
2931 printf ("Interface Version: %s\n",
2932 dynamic_strings + entry->d_un.d_val);
2934 printf ("%ld\n", (long) entry->d_un.d_ptr);
2937 case DT_MIPS_TIME_STAMP:
2940 time_t time = entry->d_un.d_val;
2941 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
2942 printf ("Time Stamp: %s\n", timebuf);
2946 case DT_MIPS_RLD_VERSION:
2947 case DT_MIPS_LOCAL_GOTNO:
2948 case DT_MIPS_CONFLICTNO:
2949 case DT_MIPS_LIBLISTNO:
2950 case DT_MIPS_SYMTABNO:
2951 case DT_MIPS_UNREFEXTNO:
2952 case DT_MIPS_HIPAGENO:
2953 case DT_MIPS_DELTA_CLASS_NO:
2954 case DT_MIPS_DELTA_INSTANCE_NO:
2955 case DT_MIPS_DELTA_RELOC_NO:
2956 case DT_MIPS_DELTA_SYM_NO:
2957 case DT_MIPS_DELTA_CLASSSYM_NO:
2958 case DT_MIPS_COMPACT_SIZE:
2959 printf ("%ld\n", (long) entry->d_un.d_ptr);
2963 printf ("%#lx\n", (long) entry->d_un.d_ptr);
2969 dynamic_segment_parisc_val (entry)
2970 Elf_Internal_Dyn * entry;
2972 switch (entry->d_tag)
2974 case DT_HP_DLD_FLAGS:
2983 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
2984 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
2985 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
2986 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
2987 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
2988 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
2989 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
2990 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
2991 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
2992 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
2993 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
2997 bfd_vma val = entry->d_un.d_val;
2999 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3000 if (val & flags[cnt].bit)
3004 fputs (flags[cnt].str, stdout);
3006 val ^= flags[cnt].bit;
3009 if (val != 0 || first)
3013 print_vma (val, HEX);
3019 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3025 get_32bit_dynamic_segment (file)
3028 Elf32_External_Dyn * edyn;
3029 Elf_Internal_Dyn * entry;
3032 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3033 edyn, Elf32_External_Dyn *, "dynamic segment");
3035 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3036 how large this .dynamic is now. We can do this even before the byte
3037 swapping since the DT_NULL tag is recognizable. */
3039 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3042 dynamic_segment = (Elf_Internal_Dyn *)
3043 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3045 if (dynamic_segment == NULL)
3047 error (_("Out of memory\n"));
3052 for (i = 0, entry = dynamic_segment;
3056 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3057 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3066 get_64bit_dynamic_segment (file)
3069 Elf64_External_Dyn * edyn;
3070 Elf_Internal_Dyn * entry;
3073 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3074 edyn, Elf64_External_Dyn *, "dynamic segment");
3076 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3077 how large this .dynamic is now. We can do this even before the byte
3078 swapping since the DT_NULL tag is recognizable. */
3080 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3083 dynamic_segment = (Elf_Internal_Dyn *)
3084 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3086 if (dynamic_segment == NULL)
3088 error (_("Out of memory\n"));
3093 for (i = 0, entry = dynamic_segment;
3097 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3098 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3107 get_dynamic_flags (flags)
3110 static char buff [64];
3115 flag = flags & - flags;
3120 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3121 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3122 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3123 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3124 default: strcat (buff, "unknown "); break;
3130 /* Parse and display the contents of the dynamic segment. */
3132 process_dynamic_segment (file)
3135 Elf_Internal_Dyn * entry;
3138 if (dynamic_size == 0)
3141 printf (_("\nThere is no dynamic segment in this file.\n"));
3148 if (! get_32bit_dynamic_segment (file))
3151 else if (! get_64bit_dynamic_segment (file))
3154 /* Find the appropriate symbol table. */
3155 if (dynamic_symbols == NULL)
3157 for (i = 0, entry = dynamic_segment;
3161 unsigned long offset;
3163 if (entry->d_tag != DT_SYMTAB)
3166 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3168 /* Since we do not know how big the symbol table is,
3169 we default to reading in the entire file (!) and
3170 processing that. This is overkill, I know, but it
3172 offset = entry->d_un.d_val - loadaddr;
3174 if (fseek (file, 0, SEEK_END))
3175 error (_("Unable to seek to end of file!"));
3178 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3180 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3182 if (num_dynamic_syms < 1)
3184 error (_("Unable to determine the number of symbols to load\n"));
3188 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3192 /* Similarly find a string table. */
3193 if (dynamic_strings == NULL)
3195 for (i = 0, entry = dynamic_segment;
3199 unsigned long offset;
3202 if (entry->d_tag != DT_STRTAB)
3205 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3207 /* Since we do not know how big the string table is,
3208 we default to reading in the entire file (!) and
3209 processing that. This is overkill, I know, but it
3212 offset = entry->d_un.d_val - loadaddr;
3213 if (fseek (file, 0, SEEK_END))
3214 error (_("Unable to seek to end of file\n"));
3215 str_tab_len = ftell (file) - offset;
3217 if (str_tab_len < 1)
3220 (_("Unable to determine the length of the dynamic string table\n"));
3224 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3225 "dynamic string table");
3231 /* And find the syminfo section if available. */
3232 if (dynamic_syminfo == NULL)
3234 unsigned int syminsz = 0;
3236 for (i = 0, entry = dynamic_segment;
3240 if (entry->d_tag == DT_SYMINENT)
3242 /* Note: these braces are necessary to avoid a syntax
3243 error from the SunOS4 C compiler. */
3244 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3246 else if (entry->d_tag == DT_SYMINSZ)
3247 syminsz = entry->d_un.d_val;
3248 else if (entry->d_tag == DT_SYMINFO)
3249 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3252 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3254 Elf_External_Syminfo * extsyminfo;
3255 Elf_Internal_Syminfo * syminfo;
3257 /* There is a syminfo section. Read the data. */
3258 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3259 Elf_External_Syminfo *, "symbol information");
3261 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3262 if (dynamic_syminfo == NULL)
3264 error (_("Out of memory\n"));
3268 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3269 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3272 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3273 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3280 if (do_dynamic && dynamic_addr)
3281 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3282 dynamic_addr, (long) dynamic_size);
3284 printf (_(" Tag Type Name/Value\n"));
3286 for (i = 0, entry = dynamic_segment;
3295 print_vma (entry->d_tag, FULL_HEX);
3296 dtype = get_dynamic_type (entry->d_tag);
3297 printf (" (%s)%*s", dtype,
3298 ((is_32bit_elf ? 27 : 19)
3299 - (int) strlen (dtype)),
3303 switch (entry->d_tag)
3307 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3314 if (entry->d_tag == DT_AUXILIARY)
3315 printf (_("Auxiliary library"));
3317 printf (_("Filter library"));
3319 if (dynamic_strings)
3320 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3324 print_vma (entry->d_un.d_val, PREFIX_HEX);
3333 printf (_("Flags:"));
3334 if (entry->d_un.d_val == 0)
3335 printf (_(" None\n"));
3338 unsigned long int val = entry->d_un.d_val;
3339 if (val & DTF_1_PARINIT)
3341 printf (" PARINIT");
3342 val ^= DTF_1_PARINIT;
3345 printf (" %lx", val);
3354 printf (_("Flags:"));
3355 if (entry->d_un.d_val == 0)
3356 printf (_(" None\n"));
3359 unsigned long int val = entry->d_un.d_val;
3360 if (val & DF_P1_LAZYLOAD)
3362 printf (" LAZYLOAD");
3363 val ^= DF_P1_LAZYLOAD;
3365 if (val & DF_P1_GROUPPERM)
3367 printf (" GROUPPERM");
3368 val ^= DF_P1_GROUPPERM;
3371 printf (" %lx", val);
3380 printf (_("Flags:"));
3381 if (entry->d_un.d_val == 0)
3382 printf (_(" None\n"));
3385 unsigned long int val = entry->d_un.d_val;
3391 if (val & DF_1_GLOBAL)
3396 if (val & DF_1_GROUP)
3401 if (val & DF_1_NODELETE)
3403 printf (" NODELETE");
3404 val ^= DF_1_NODELETE;
3406 if (val & DF_1_LOADFLTR)
3408 printf (" LOADFLTR");
3409 val ^= DF_1_LOADFLTR;
3411 if (val & DF_1_INITFIRST)
3413 printf (" INITFIRST");
3414 val ^= DF_1_INITFIRST;
3416 if (val & DF_1_NOOPEN)
3421 if (val & DF_1_ORIGIN)
3426 if (val & DF_1_DIRECT)
3431 if (val & DF_1_TRANS)
3436 if (val & DF_1_INTERPOSE)
3438 printf (" INTERPOSE");
3439 val ^= DF_1_INTERPOSE;
3442 printf (" %lx", val);
3450 puts (get_dynamic_type (entry->d_un.d_val));
3469 dynamic_info[entry->d_tag] = entry->d_un.d_val;
3475 if (dynamic_strings == NULL)
3478 name = dynamic_strings + entry->d_un.d_val;
3482 switch (entry->d_tag)
3485 printf (_("Shared library: [%s]"), name);
3487 if (strcmp (name, program_interpreter) == 0)
3488 printf (_(" program interpreter"));
3492 printf (_("Library soname: [%s]"), name);
3496 printf (_("Library rpath: [%s]"), name);
3500 print_vma (entry->d_un.d_val, PREFIX_HEX);
3505 print_vma (entry->d_un.d_val, PREFIX_HEX);
3521 case DT_INIT_ARRAYSZ:
3522 case DT_FINI_ARRAYSZ:
3525 print_vma (entry->d_un.d_val, UNSIGNED);
3526 printf (" (bytes)\n");
3536 print_vma (entry->d_un.d_val, UNSIGNED);
3549 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3553 name = dynamic_strings + entry->d_un.d_val;
3557 printf (_("Not needed object: [%s]\n"), name);
3562 print_vma (entry->d_un.d_val, PREFIX_HEX);
3568 /* The value of this entry is ignored. */
3572 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3573 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3578 switch (elf_header.e_machine)
3581 case EM_MIPS_RS4_BE:
3582 dynamic_segment_mips_val (entry);
3585 dynamic_segment_parisc_val (entry);
3588 print_vma (entry->d_un.d_val, PREFIX_HEX);
3600 get_ver_flags (flags)
3603 static char buff [32];
3610 if (flags & VER_FLG_BASE)
3611 strcat (buff, "BASE ");
3613 if (flags & VER_FLG_WEAK)
3615 if (flags & VER_FLG_BASE)
3616 strcat (buff, "| ");
3618 strcat (buff, "WEAK ");
3621 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3622 strcat (buff, "| <unknown>");
3627 /* Display the contents of the version sections. */
3629 process_version_sections (file)
3632 Elf32_Internal_Shdr * section;
3639 for (i = 0, section = section_headers;
3640 i < elf_header.e_shnum;
3643 switch (section->sh_type)
3645 case SHT_GNU_verdef:
3647 Elf_External_Verdef * edefs;
3654 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3655 SECTION_NAME (section), section->sh_info);
3657 printf (_(" Addr: 0x"));
3658 printf_vma (section->sh_addr);
3659 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3660 (unsigned long) section->sh_offset, section->sh_link,
3661 SECTION_NAME (section_headers + section->sh_link));
3663 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3664 edefs, Elf_External_Verdef *,
3665 "version definition section");
3667 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3670 Elf_External_Verdef * edef;
3671 Elf_Internal_Verdef ent;
3672 Elf_External_Verdaux * eaux;
3673 Elf_Internal_Verdaux aux;
3677 vstart = ((char *) edefs) + idx;
3679 edef = (Elf_External_Verdef *) vstart;
3681 ent.vd_version = BYTE_GET (edef->vd_version);
3682 ent.vd_flags = BYTE_GET (edef->vd_flags);
3683 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
3684 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
3685 ent.vd_hash = BYTE_GET (edef->vd_hash);
3686 ent.vd_aux = BYTE_GET (edef->vd_aux);
3687 ent.vd_next = BYTE_GET (edef->vd_next);
3689 printf (_(" %#06x: Rev: %d Flags: %s"),
3690 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3692 printf (_(" Index: %d Cnt: %d "),
3693 ent.vd_ndx, ent.vd_cnt);
3695 vstart += ent.vd_aux;
3697 eaux = (Elf_External_Verdaux *) vstart;
3699 aux.vda_name = BYTE_GET (eaux->vda_name);
3700 aux.vda_next = BYTE_GET (eaux->vda_next);
3702 if (dynamic_strings)
3703 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3705 printf (_("Name index: %ld\n"), aux.vda_name);
3707 isum = idx + ent.vd_aux;
3709 for (j = 1; j < ent.vd_cnt; j ++)
3711 isum += aux.vda_next;
3712 vstart += aux.vda_next;
3714 eaux = (Elf_External_Verdaux *) vstart;
3716 aux.vda_name = BYTE_GET (eaux->vda_name);
3717 aux.vda_next = BYTE_GET (eaux->vda_next);
3719 if (dynamic_strings)
3720 printf (_(" %#06x: Parent %d: %s\n"),
3721 isum, j, dynamic_strings + aux.vda_name);
3723 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3724 isum, j, aux.vda_name);
3734 case SHT_GNU_verneed:
3736 Elf_External_Verneed * eneed;
3742 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3743 SECTION_NAME (section), section->sh_info);
3745 printf (_(" Addr: 0x"));
3746 printf_vma (section->sh_addr);
3747 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3748 (unsigned long) section->sh_offset, section->sh_link,
3749 SECTION_NAME (section_headers + section->sh_link));
3751 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3752 eneed, Elf_External_Verneed *,
3753 "version need section");
3755 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3757 Elf_External_Verneed * entry;
3758 Elf_Internal_Verneed ent;
3763 vstart = ((char *) eneed) + idx;
3765 entry = (Elf_External_Verneed *) vstart;
3767 ent.vn_version = BYTE_GET (entry->vn_version);
3768 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
3769 ent.vn_file = BYTE_GET (entry->vn_file);
3770 ent.vn_aux = BYTE_GET (entry->vn_aux);
3771 ent.vn_next = BYTE_GET (entry->vn_next);
3773 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
3775 if (dynamic_strings)
3776 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
3778 printf (_(" File: %lx"), ent.vn_file);
3780 printf (_(" Cnt: %d\n"), ent.vn_cnt);
3782 vstart += ent.vn_aux;
3784 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3786 Elf_External_Vernaux * eaux;
3787 Elf_Internal_Vernaux aux;
3789 eaux = (Elf_External_Vernaux *) vstart;
3791 aux.vna_hash = BYTE_GET (eaux->vna_hash);
3792 aux.vna_flags = BYTE_GET (eaux->vna_flags);
3793 aux.vna_other = BYTE_GET (eaux->vna_other);
3794 aux.vna_name = BYTE_GET (eaux->vna_name);
3795 aux.vna_next = BYTE_GET (eaux->vna_next);
3797 if (dynamic_strings)
3798 printf (_(" %#06x: Name: %s"),
3799 isum, dynamic_strings + aux.vna_name);
3801 printf (_(" %#06x: Name index: %lx"),
3802 isum, aux.vna_name);
3804 printf (_(" Flags: %s Version: %d\n"),
3805 get_ver_flags (aux.vna_flags), aux.vna_other);
3807 isum += aux.vna_next;
3808 vstart += aux.vna_next;
3818 case SHT_GNU_versym:
3820 Elf32_Internal_Shdr * link_section;
3823 unsigned char * edata;
3824 unsigned short * data;
3826 Elf_Internal_Sym * symbols;
3827 Elf32_Internal_Shdr * string_sec;
3829 link_section = section_headers + section->sh_link;
3830 total = section->sh_size / section->sh_entsize;
3834 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3835 link_section->sh_size / link_section->sh_entsize);
3837 string_sec = section_headers + link_section->sh_link;
3839 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3840 strtab, char *, "version string table");
3842 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3843 SECTION_NAME (section), total);
3845 printf (_(" Addr: "));
3846 printf_vma (section->sh_addr);
3847 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3848 (unsigned long) section->sh_offset, section->sh_link,
3849 SECTION_NAME (link_section));
3851 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3853 total * sizeof (short), edata,
3854 unsigned char *, "version symbol data");
3856 data = (unsigned short *) malloc (total * sizeof (short));
3858 for (cnt = total; cnt --;)
3859 data [cnt] = byte_get (edata + cnt * sizeof (short),
3864 for (cnt = 0; cnt < total; cnt += 4)
3869 printf (" %03x:", cnt);
3871 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3872 switch (data [cnt + j])
3875 fputs (_(" 0 (*local*) "), stdout);
3879 fputs (_(" 1 (*global*) "), stdout);
3883 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
3884 data [cnt + j] & 0x8000 ? 'h' : ' ');
3886 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
3887 && section_headers[symbols [cnt + j].st_shndx].sh_type
3890 /* We must test both. */
3891 Elf_Internal_Verneed ivn;
3892 unsigned long offset;
3894 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3899 Elf_External_Verneed evn;
3900 Elf_External_Vernaux evna;
3901 Elf_Internal_Vernaux ivna;
3902 unsigned long vna_off;
3904 GET_DATA (offset, evn, "version need");
3906 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3907 ivn.vn_next = BYTE_GET (evn.vn_next);
3909 vna_off = offset + ivn.vn_aux;
3913 GET_DATA (vna_off, evna,
3914 "version need aux (1)");
3916 ivna.vna_next = BYTE_GET (evna.vna_next);
3917 ivna.vna_other = BYTE_GET (evna.vna_other);
3919 vna_off += ivna.vna_next;
3921 while (ivna.vna_other != data [cnt + j]
3922 && ivna.vna_next != 0);
3924 if (ivna.vna_other == data [cnt + j])
3926 ivna.vna_name = BYTE_GET (evna.vna_name);
3928 name = strtab + ivna.vna_name;
3929 nn += printf ("(%s%-*s",
3931 12 - (int) strlen (name),
3935 else if (ivn.vn_next == 0)
3937 if (data [cnt + j] != 0x8001)
3939 Elf_Internal_Verdef ivd;
3940 Elf_External_Verdef evd;
3942 offset = version_info
3943 [DT_VERSIONTAGIDX (DT_VERDEF)]
3948 GET_DATA (offset, evd,
3949 "version definition");
3951 ivd.vd_next = BYTE_GET (evd.vd_next);
3952 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
3954 offset += ivd.vd_next;
3957 != (data [cnt + j] & 0x7fff)
3958 && ivd.vd_next != 0);
3961 == (data [cnt + j] & 0x7fff))
3963 Elf_External_Verdaux evda;
3964 Elf_Internal_Verdaux ivda;
3966 ivd.vd_aux = BYTE_GET (evd.vd_aux);
3968 GET_DATA (offset + ivd.vd_aux, evda,
3969 "version definition aux");
3972 BYTE_GET (evda.vda_name);
3974 name = strtab + ivda.vda_name;
3978 12 - (int) strlen (name),
3986 offset += ivn.vn_next;
3988 while (ivn.vn_next);
3990 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
3992 Elf_Internal_Verneed ivn;
3993 unsigned long offset;
3995 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4000 Elf_Internal_Vernaux ivna;
4001 Elf_External_Verneed evn;
4002 Elf_External_Vernaux evna;
4003 unsigned long a_off;
4005 GET_DATA (offset, evn, "version need");
4007 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4008 ivn.vn_next = BYTE_GET (evn.vn_next);
4010 a_off = offset + ivn.vn_aux;
4014 GET_DATA (a_off, evna,
4015 "version need aux (2)");
4017 ivna.vna_next = BYTE_GET (evna.vna_next);
4018 ivna.vna_other = BYTE_GET (evna.vna_other);
4020 a_off += ivna.vna_next;
4022 while (ivna.vna_other != data [cnt + j]
4023 && ivna.vna_next != 0);
4025 if (ivna.vna_other == data [cnt + j])
4027 ivna.vna_name = BYTE_GET (evna.vna_name);
4029 name = strtab + ivna.vna_name;
4030 nn += printf ("(%s%-*s",
4032 12 - (int) strlen (name),
4037 offset += ivn.vn_next;
4039 while (ivn.vn_next);
4041 else if (data [cnt + j] != 0x8001)
4043 Elf_Internal_Verdef ivd;
4044 Elf_External_Verdef evd;
4045 unsigned long offset;
4047 offset = version_info
4048 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4052 GET_DATA (offset, evd, "version def");
4054 ivd.vd_next = BYTE_GET (evd.vd_next);
4055 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4057 offset += ivd.vd_next;
4059 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4060 && ivd.vd_next != 0);
4062 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4064 Elf_External_Verdaux evda;
4065 Elf_Internal_Verdaux ivda;
4067 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4069 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4070 evda, "version def aux");
4072 ivda.vda_name = BYTE_GET (evda.vda_name);
4074 name = strtab + ivda.vda_name;
4075 nn += printf ("(%s%-*s",
4077 12 - (int) strlen (name),
4083 printf ("%*c", 18 - nn, ' ');
4101 printf (_("\nNo version information found in this file.\n"));
4107 get_symbol_binding (binding)
4108 unsigned int binding;
4110 static char buff [32];
4114 case STB_LOCAL: return "LOCAL";
4115 case STB_GLOBAL: return "GLOBAL";
4116 case STB_WEAK: return "WEAK";
4118 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4119 sprintf (buff, _("<processor specific>: %d"), binding);
4120 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4121 sprintf (buff, _("<OS specific>: %d"), binding);
4123 sprintf (buff, _("<unknown>: %d"), binding);
4129 get_symbol_type (type)
4132 static char buff [32];
4136 case STT_NOTYPE: return "NOTYPE";
4137 case STT_OBJECT: return "OBJECT";
4138 case STT_FUNC: return "FUNC";
4139 case STT_SECTION: return "SECTION";
4140 case STT_FILE: return "FILE";
4141 case STT_COMMON: return "COMMON";
4143 if (type >= STT_LOPROC && type <= STT_HIPROC)
4145 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4146 return "THUMB_FUNC";
4148 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4151 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4152 return "PARISC_MILLI";
4154 sprintf (buff, _("<processor specific>: %d"), type);
4156 else if (type >= STT_LOOS && type <= STT_HIOS)
4158 if (elf_header.e_machine == EM_PARISC)
4160 if (type == STT_HP_OPAQUE)
4162 if (type == STT_HP_STUB)
4166 sprintf (buff, _("<OS specific>: %d"), type);
4169 sprintf (buff, _("<unknown>: %d"), type);
4175 get_symbol_visibility (visibility)
4176 unsigned int visibility;
4180 case STV_DEFAULT: return "DEFAULT";
4181 case STV_INTERNAL: return "INTERNAL";
4182 case STV_HIDDEN: return "HIDDEN";
4183 case STV_PROTECTED: return "PROTECTED";
4189 get_symbol_index_type (type)
4194 case SHN_UNDEF: return "UND";
4195 case SHN_ABS: return "ABS";
4196 case SHN_COMMON: return "COM";
4198 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4200 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4202 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4206 static char buff [32];
4208 sprintf (buff, "%3d", type);
4215 get_dynamic_data (file, number)
4217 unsigned int number;
4222 e_data = (char *) malloc (number * 4);
4226 error (_("Out of memory\n"));
4230 if (fread (e_data, 4, number, file) != number)
4232 error (_("Unable to read in dynamic data\n"));
4236 i_data = (int *) malloc (number * sizeof (* i_data));
4240 error (_("Out of memory\n"));
4246 i_data [number] = byte_get (e_data + number * 4, 4);
4253 /* Dump the symbol table */
4255 process_symbol_table (file)
4258 Elf32_Internal_Shdr * section;
4263 int * buckets = NULL;
4264 int * chains = NULL;
4266 if (! do_syms && !do_histogram)
4269 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4272 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4274 error (_("Unable to seek to start of dynamic information"));
4278 if (fread (nb, sizeof (nb), 1, file) != 1)
4280 error (_("Failed to read in number of buckets\n"));
4284 if (fread (nc, sizeof (nc), 1, file) != 1)
4286 error (_("Failed to read in number of chains\n"));
4290 nbuckets = byte_get (nb, 4);
4291 nchains = byte_get (nc, 4);
4293 buckets = get_dynamic_data (file, nbuckets);
4294 chains = get_dynamic_data (file, nchains);
4296 if (buckets == NULL || chains == NULL)
4301 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4306 printf (_("\nSymbol table for image:\n"));
4308 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4310 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4312 for (hn = 0; hn < nbuckets; hn++)
4317 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4319 Elf_Internal_Sym * psym;
4321 psym = dynamic_symbols + si;
4323 printf (" %3d %3d: ", si, hn);
4324 print_vma (psym->st_value, LONG_HEX);
4326 print_vma (psym->st_size, DEC_5);
4328 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4329 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4330 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4331 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4332 printf (" %s\n", dynamic_strings + psym->st_name);
4336 else if (do_syms && !do_using_dynamic)
4340 for (i = 0, section = section_headers;
4341 i < elf_header.e_shnum;
4346 Elf_Internal_Sym * symtab;
4347 Elf_Internal_Sym * psym;
4350 if ( section->sh_type != SHT_SYMTAB
4351 && section->sh_type != SHT_DYNSYM)
4354 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4355 SECTION_NAME (section),
4356 (unsigned long) (section->sh_size / section->sh_entsize));
4358 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4360 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4362 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4363 section->sh_size / section->sh_entsize);
4367 if (section->sh_link == elf_header.e_shstrndx)
4368 strtab = string_table;
4371 Elf32_Internal_Shdr * string_sec;
4373 string_sec = section_headers + section->sh_link;
4375 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4376 strtab, char *, "string table");
4379 for (si = 0, psym = symtab;
4380 si < section->sh_size / section->sh_entsize;
4383 printf ("%6d: ", si);
4384 print_vma (psym->st_value, LONG_HEX);
4386 print_vma (psym->st_size, DEC_5);
4387 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4388 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4389 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4390 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4391 printf (" %s", strtab + psym->st_name);
4393 if (section->sh_type == SHT_DYNSYM &&
4394 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4396 unsigned char data[2];
4397 unsigned short vers_data;
4398 unsigned long offset;
4402 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4405 GET_DATA (offset + si * sizeof (vers_data), data,
4408 vers_data = byte_get (data, 2);
4410 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4411 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4414 check_def = (psym->st_shndx != SHN_UNDEF);
4416 if ((vers_data & 0x8000) || vers_data > 1)
4418 if (is_nobits || ! check_def)
4420 Elf_External_Verneed evn;
4421 Elf_Internal_Verneed ivn;
4422 Elf_Internal_Vernaux ivna;
4424 /* We must test both. */
4425 offset = version_info
4426 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4430 unsigned long vna_off;
4432 GET_DATA (offset, evn, "version need");
4434 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4435 ivn.vn_next = BYTE_GET (evn.vn_next);
4437 vna_off = offset + ivn.vn_aux;
4441 Elf_External_Vernaux evna;
4443 GET_DATA (vna_off, evna,
4444 "version need aux (3)");
4446 ivna.vna_other = BYTE_GET (evna.vna_other);
4447 ivna.vna_next = BYTE_GET (evna.vna_next);
4448 ivna.vna_name = BYTE_GET (evna.vna_name);
4450 vna_off += ivna.vna_next;
4452 while (ivna.vna_other != vers_data
4453 && ivna.vna_next != 0);
4455 if (ivna.vna_other == vers_data)
4458 offset += ivn.vn_next;
4460 while (ivn.vn_next != 0);
4462 if (ivna.vna_other == vers_data)
4465 strtab + ivna.vna_name, ivna.vna_other);
4468 else if (! is_nobits)
4469 error (_("bad dynamic symbol"));
4476 if (vers_data != 0x8001)
4478 Elf_Internal_Verdef ivd;
4479 Elf_Internal_Verdaux ivda;
4480 Elf_External_Verdaux evda;
4481 unsigned long offset;
4484 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4489 Elf_External_Verdef evd;
4491 GET_DATA (offset, evd, "version def");
4493 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4494 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4495 ivd.vd_next = BYTE_GET (evd.vd_next);
4497 offset += ivd.vd_next;
4499 while (ivd.vd_ndx != (vers_data & 0x7fff)
4500 && ivd.vd_next != 0);
4502 offset -= ivd.vd_next;
4503 offset += ivd.vd_aux;
4505 GET_DATA (offset, evda, "version def aux");
4507 ivda.vda_name = BYTE_GET (evda.vda_name);
4509 if (psym->st_name != ivda.vda_name)
4510 printf ((vers_data & 0x8000)
4512 strtab + ivda.vda_name);
4522 if (strtab != string_table)
4528 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4530 if (do_histogram && buckets != NULL)
4537 int nzero_counts = 0;
4540 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4542 printf (_(" Length Number %% of total Coverage\n"));
4544 lengths = (int *) calloc (nbuckets, sizeof (int));
4545 if (lengths == NULL)
4547 error (_("Out of memory"));
4550 for (hn = 0; hn < nbuckets; ++hn)
4555 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4558 if (maxlength < ++lengths[hn])
4563 counts = (int *) calloc (maxlength + 1, sizeof (int));
4566 error (_("Out of memory"));
4570 for (hn = 0; hn < nbuckets; ++hn)
4571 ++ counts [lengths [hn]];
4575 printf (" 0 %-10d (%5.1f%%)\n",
4576 counts[0], (counts[0] * 100.0) / nbuckets);
4577 for (si = 1; si <= maxlength; ++si)
4579 nzero_counts += counts[si] * si;
4580 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4581 si, counts[si], (counts[si] * 100.0) / nbuckets,
4582 (nzero_counts * 100.0) / nsyms);
4590 if (buckets != NULL)
4600 process_syminfo (file)
4601 FILE * file ATTRIBUTE_UNUSED;
4605 if (dynamic_syminfo == NULL
4607 /* No syminfo, this is ok. */
4610 /* There better should be a dynamic symbol section. */
4611 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4615 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4616 dynamic_syminfo_offset, dynamic_syminfo_nent);
4618 printf (_(" Num: Name BoundTo Flags\n"));
4619 for (i = 0; i < dynamic_syminfo_nent; ++i)
4621 unsigned short int flags = dynamic_syminfo[i].si_flags;
4623 printf ("%4d: %-30s ", i,
4624 dynamic_strings + dynamic_symbols[i].st_name);
4626 switch (dynamic_syminfo[i].si_boundto)
4628 case SYMINFO_BT_SELF:
4629 fputs ("SELF ", stdout);
4631 case SYMINFO_BT_PARENT:
4632 fputs ("PARENT ", stdout);
4635 if (dynamic_syminfo[i].si_boundto > 0
4636 && dynamic_syminfo[i].si_boundto < dynamic_size)
4639 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4641 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4645 if (flags & SYMINFO_FLG_DIRECT)
4647 if (flags & SYMINFO_FLG_PASSTHRU)
4648 printf (" PASSTHRU");
4649 if (flags & SYMINFO_FLG_COPY)
4651 if (flags & SYMINFO_FLG_LAZYLOAD)
4652 printf (" LAZYLOAD");
4660 #ifdef SUPPORT_DISASSEMBLY
4662 disassemble_section (section, file)
4663 Elf32_Internal_Shdr * section;
4666 printf (_("\nAssembly dump of section %s\n"),
4667 SECTION_NAME (section));
4669 /* XXX -- to be done --- XXX */
4676 dump_section (section, file)
4677 Elf32_Internal_Shdr * section;
4680 bfd_size_type bytes;
4682 unsigned char * data;
4683 unsigned char * start;
4685 bytes = section->sh_size;
4689 printf (_("\nSection '%s' has no data to dump.\n"),
4690 SECTION_NAME (section));
4694 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4696 addr = section->sh_addr;
4698 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4709 lbytes = (bytes > 16 ? 16 : bytes);
4711 printf (" 0x%8.8lx ", (unsigned long) addr);
4713 switch (elf_header.e_ident [EI_DATA])
4717 for (j = 15; j >= 0; j --)
4720 printf ("%2.2x", data [j]);
4730 for (j = 0; j < 16; j++)
4733 printf ("%2.2x", data [j]);
4743 for (j = 0; j < lbytes; j++)
4746 if (k >= ' ' && k < 0x80)
4765 static unsigned long int
4766 read_leb128 (data, length_return, sign)
4767 unsigned char * data;
4768 int * length_return;
4771 unsigned long int result = 0;
4772 unsigned int num_read = 0;
4781 result |= (byte & 0x7f) << shift;
4786 while (byte & 0x80);
4788 if (length_return != NULL)
4789 * length_return = num_read;
4791 if (sign && (shift < 32) && (byte & 0x40))
4792 result |= -1 << shift;
4797 typedef struct State_Machine_Registers
4799 unsigned long address;
4802 unsigned int column;
4806 /* This variable hold the number of the last entry seen
4807 in the File Table. */
4808 unsigned int last_file_entry;
4811 static SMR state_machine_regs;
4814 reset_state_machine (is_stmt)
4817 state_machine_regs.address = 0;
4818 state_machine_regs.file = 1;
4819 state_machine_regs.line = 1;
4820 state_machine_regs.column = 0;
4821 state_machine_regs.is_stmt = is_stmt;
4822 state_machine_regs.basic_block = 0;
4823 state_machine_regs.end_sequence = 0;
4824 state_machine_regs.last_file_entry = 0;
4827 /* Handled an extend line op. Returns true if this is the end
4830 process_extended_line_op (data, is_stmt, pointer_size)
4831 unsigned char * data;
4835 unsigned char op_code;
4838 unsigned char * name;
4841 len = read_leb128 (data, & bytes_read, 0);
4846 warn (_("badly formed extended line op encountered!"));
4851 op_code = * data ++;
4853 printf (_(" Extended opcode %d: "), op_code);
4857 case DW_LNE_end_sequence:
4858 printf (_("End of Sequence\n\n"));
4859 reset_state_machine (is_stmt);
4862 case DW_LNE_set_address:
4863 adr = byte_get (data, pointer_size);
4864 printf (_("set Address to 0x%lx\n"), adr);
4865 state_machine_regs.address = adr;
4868 case DW_LNE_define_file:
4869 printf (_(" define new File Table entry\n"));
4870 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4872 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4874 data += strlen (data) + 1;
4875 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4877 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4879 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4880 printf (_("%s\n\n"), name);
4884 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
4891 /* Size of pointers in the .debug_line section. This information is not
4892 really present in that section. It's obtained before dumping the debug
4893 sections by doing some pre-scan of the .debug_info section. */
4894 static int debug_line_pointer_size = 4;
4897 display_debug_lines (section, start, file)
4898 Elf32_Internal_Shdr * section;
4899 unsigned char * start;
4900 FILE * file ATTRIBUTE_UNUSED;
4902 DWARF2_External_LineInfo * external;
4903 DWARF2_Internal_LineInfo info;
4904 unsigned char * standard_opcodes;
4905 unsigned char * data = start;
4906 unsigned char * end = start + section->sh_size;
4907 unsigned char * end_of_sequence;
4910 printf (_("\nDump of debug contents of section %s:\n\n"),
4911 SECTION_NAME (section));
4915 external = (DWARF2_External_LineInfo *) data;
4917 /* Check the length of the block. */
4918 info.li_length = BYTE_GET (external->li_length);
4919 if (info.li_length > section->sh_size)
4922 (_("The line info appears to be corrupt - the section is too small\n"));
4926 /* Check its version number. */
4927 info.li_version = BYTE_GET (external->li_version);
4928 if (info.li_version != 2)
4930 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4934 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
4935 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
4936 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
4937 info.li_line_base = BYTE_GET (external->li_line_base);
4938 info.li_line_range = BYTE_GET (external->li_line_range);
4939 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
4941 /* Sign extend the line base field. */
4942 info.li_line_base <<= 24;
4943 info.li_line_base >>= 24;
4945 printf (_(" Length: %ld\n"), info.li_length);
4946 printf (_(" DWARF Version: %d\n"), info.li_version);
4947 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
4948 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
4949 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
4950 printf (_(" Line Base: %d\n"), info.li_line_base);
4951 printf (_(" Line Range: %d\n"), info.li_line_range);
4952 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
4954 end_of_sequence = data + info.li_length + sizeof (info.li_length);
4956 reset_state_machine (info.li_default_is_stmt);
4958 /* Display the contents of the Opcodes table. */
4959 standard_opcodes = data + sizeof (* external);
4961 printf (_("\n Opcodes:\n"));
4963 for (i = 1; i < info.li_opcode_base; i++)
4964 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
4966 /* Display the contents of the Directory table. */
4967 data = standard_opcodes + info.li_opcode_base - 1;
4970 printf (_("\n The Directory Table is empty.\n"));
4973 printf (_("\n The Directory Table:\n"));
4977 printf (_(" %s\n"), data);
4979 data += strlen (data) + 1;
4983 /* Skip the NUL at the end of the table. */
4986 /* Display the contents of the File Name table. */
4988 printf (_("\n The File Name Table is empty.\n"));
4991 printf (_("\n The File Name Table:\n"));
4992 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4999 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5002 data += strlen (data) + 1;
5004 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5006 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5008 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5010 printf (_("%s\n"), name);
5014 /* Skip the NUL at the end of the table. */
5017 /* Now display the statements. */
5018 printf (_("\n Line Number Statements:\n"));
5021 while (data < end_of_sequence)
5023 unsigned char op_code;
5027 op_code = * data ++;
5031 case DW_LNS_extended_op:
5032 data += process_extended_line_op (data, info.li_default_is_stmt,
5033 debug_line_pointer_size);
5037 printf (_(" Copy\n"));
5040 case DW_LNS_advance_pc:
5041 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5043 state_machine_regs.address += adv;
5044 printf (_(" Advance PC by %d to %lx\n"), adv,
5045 state_machine_regs.address);
5048 case DW_LNS_advance_line:
5049 adv = read_leb128 (data, & bytes_read, 1);
5051 state_machine_regs.line += adv;
5052 printf (_(" Advance Line by %d to %d\n"), adv,
5053 state_machine_regs.line);
5056 case DW_LNS_set_file:
5057 adv = read_leb128 (data, & bytes_read, 0);
5059 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5061 state_machine_regs.file = adv;
5064 case DW_LNS_set_column:
5065 adv = read_leb128 (data, & bytes_read, 0);
5067 printf (_(" Set column to %d\n"), adv);
5068 state_machine_regs.column = adv;
5071 case DW_LNS_negate_stmt:
5072 adv = state_machine_regs.is_stmt;
5074 printf (_(" Set is_stmt to %d\n"), adv);
5075 state_machine_regs.is_stmt = adv;
5078 case DW_LNS_set_basic_block:
5079 printf (_(" Set basic block\n"));
5080 state_machine_regs.basic_block = 1;
5083 case DW_LNS_const_add_pc:
5084 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5085 * info.li_min_insn_length);
5086 state_machine_regs.address += adv;
5087 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5088 state_machine_regs.address);
5091 case DW_LNS_fixed_advance_pc:
5092 adv = byte_get (data, 2);
5094 state_machine_regs.address += adv;
5095 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5096 adv, state_machine_regs.address);
5100 op_code -= info.li_opcode_base;
5101 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5102 state_machine_regs.address += adv;
5103 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5104 op_code, adv, state_machine_regs.address);
5105 adv = (op_code % info.li_line_range) + info.li_line_base;
5106 state_machine_regs.line += adv;
5107 printf (_(" and Line by %d to %d\n"),
5108 adv, state_machine_regs.line);
5119 display_debug_pubnames (section, start, file)
5120 Elf32_Internal_Shdr * section;
5121 unsigned char * start;
5122 FILE * file ATTRIBUTE_UNUSED;
5124 DWARF2_External_PubNames * external;
5125 DWARF2_Internal_PubNames pubnames;
5126 unsigned char * end;
5128 end = start + section->sh_size;
5130 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5134 unsigned char * data;
5135 unsigned long offset;
5137 external = (DWARF2_External_PubNames *) start;
5139 pubnames.pn_length = BYTE_GET (external->pn_length);
5140 pubnames.pn_version = BYTE_GET (external->pn_version);
5141 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5142 pubnames.pn_size = BYTE_GET (external->pn_size);
5144 data = start + sizeof (* external);
5145 start += pubnames.pn_length + sizeof (external->pn_length);
5147 if (pubnames.pn_version != 2)
5149 warn (_("Only DWARF 2 pubnames are currently supported"));
5153 printf (_(" Length: %ld\n"),
5154 pubnames.pn_length);
5155 printf (_(" Version: %d\n"),
5156 pubnames.pn_version);
5157 printf (_(" Offset into .debug_info section: %ld\n"),
5158 pubnames.pn_offset);
5159 printf (_(" Size of area in .debug_info section: %ld\n"),
5162 printf (_("\n Offset\tName\n"));
5166 offset = byte_get (data, 4);
5171 printf (" %ld\t\t%s\n", offset, data);
5172 data += strlen (data) + 1;
5175 while (offset != 0);
5188 case DW_TAG_padding: return "DW_TAG_padding";
5189 case DW_TAG_array_type: return "DW_TAG_array_type";
5190 case DW_TAG_class_type: return "DW_TAG_class_type";
5191 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5192 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5193 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5194 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5195 case DW_TAG_label: return "DW_TAG_label";
5196 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5197 case DW_TAG_member: return "DW_TAG_member";
5198 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5199 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5200 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5201 case DW_TAG_string_type: return "DW_TAG_string_type";
5202 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5203 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5204 case DW_TAG_typedef: return "DW_TAG_typedef";
5205 case DW_TAG_union_type: return "DW_TAG_union_type";
5206 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5207 case DW_TAG_variant: return "DW_TAG_variant";
5208 case DW_TAG_common_block: return "DW_TAG_common_block";
5209 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5210 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5211 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5212 case DW_TAG_module: return "DW_TAG_module";
5213 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5214 case DW_TAG_set_type: return "DW_TAG_set_type";
5215 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5216 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5217 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5218 case DW_TAG_base_type: return "DW_TAG_base_type";
5219 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5220 case DW_TAG_const_type: return "DW_TAG_const_type";
5221 case DW_TAG_constant: return "DW_TAG_constant";
5222 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5223 case DW_TAG_file_type: return "DW_TAG_file_type";
5224 case DW_TAG_friend: return "DW_TAG_friend";
5225 case DW_TAG_namelist: return "DW_TAG_namelist";
5226 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5227 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5228 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5229 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5230 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5231 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5232 case DW_TAG_try_block: return "DW_TAG_try_block";
5233 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5234 case DW_TAG_variable: return "DW_TAG_variable";
5235 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5236 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5237 case DW_TAG_format_label: return "DW_TAG_format_label";
5238 case DW_TAG_function_template: return "DW_TAG_function_template";
5239 case DW_TAG_class_template: return "DW_TAG_class_template";
5242 static char buffer [100];
5244 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5251 get_AT_name (attribute)
5252 unsigned long attribute;
5256 case DW_AT_sibling: return "DW_AT_sibling";
5257 case DW_AT_location: return "DW_AT_location";
5258 case DW_AT_name: return "DW_AT_name";
5259 case DW_AT_ordering: return "DW_AT_ordering";
5260 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5261 case DW_AT_byte_size: return "DW_AT_byte_size";
5262 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5263 case DW_AT_bit_size: return "DW_AT_bit_size";
5264 case DW_AT_element_list: return "DW_AT_element_list";
5265 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5266 case DW_AT_low_pc: return "DW_AT_low_pc";
5267 case DW_AT_high_pc: return "DW_AT_high_pc";
5268 case DW_AT_language: return "DW_AT_language";
5269 case DW_AT_member: return "DW_AT_member";
5270 case DW_AT_discr: return "DW_AT_discr";
5271 case DW_AT_discr_value: return "DW_AT_discr_value";
5272 case DW_AT_visibility: return "DW_AT_visibility";
5273 case DW_AT_import: return "DW_AT_import";
5274 case DW_AT_string_length: return "DW_AT_string_length";
5275 case DW_AT_common_reference: return "DW_AT_common_reference";
5276 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5277 case DW_AT_const_value: return "DW_AT_const_value";
5278 case DW_AT_containing_type: return "DW_AT_containing_type";
5279 case DW_AT_default_value: return "DW_AT_default_value";
5280 case DW_AT_inline: return "DW_AT_inline";
5281 case DW_AT_is_optional: return "DW_AT_is_optional";
5282 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5283 case DW_AT_producer: return "DW_AT_producer";
5284 case DW_AT_prototyped: return "DW_AT_prototyped";
5285 case DW_AT_return_addr: return "DW_AT_return_addr";
5286 case DW_AT_start_scope: return "DW_AT_start_scope";
5287 case DW_AT_stride_size: return "DW_AT_stride_size";
5288 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5289 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5290 case DW_AT_accessibility: return "DW_AT_accessibility";
5291 case DW_AT_address_class: return "DW_AT_address_class";
5292 case DW_AT_artificial: return "DW_AT_artificial";
5293 case DW_AT_base_types: return "DW_AT_base_types";
5294 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5295 case DW_AT_count: return "DW_AT_count";
5296 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5297 case DW_AT_decl_column: return "DW_AT_decl_column";
5298 case DW_AT_decl_file: return "DW_AT_decl_file";
5299 case DW_AT_decl_line: return "DW_AT_decl_line";
5300 case DW_AT_declaration: return "DW_AT_declaration";
5301 case DW_AT_discr_list: return "DW_AT_discr_list";
5302 case DW_AT_encoding: return "DW_AT_encoding";
5303 case DW_AT_external: return "DW_AT_external";
5304 case DW_AT_frame_base: return "DW_AT_frame_base";
5305 case DW_AT_friend: return "DW_AT_friend";
5306 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5307 case DW_AT_macro_info: return "DW_AT_macro_info";
5308 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5309 case DW_AT_priority: return "DW_AT_priority";
5310 case DW_AT_segment: return "DW_AT_segment";
5311 case DW_AT_specification: return "DW_AT_specification";
5312 case DW_AT_static_link: return "DW_AT_static_link";
5313 case DW_AT_type: return "DW_AT_type";
5314 case DW_AT_use_location: return "DW_AT_use_location";
5315 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5316 case DW_AT_virtuality: return "DW_AT_virtuality";
5317 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5318 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5319 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5320 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5321 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5322 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5323 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5324 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5325 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5326 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5327 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5328 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5329 case DW_AT_sf_names: return "DW_AT_sf_names";
5330 case DW_AT_src_info: return "DW_AT_src_info";
5331 case DW_AT_mac_info: return "DW_AT_mac_info";
5332 case DW_AT_src_coords: return "DW_AT_src_coords";
5333 case DW_AT_body_begin: return "DW_AT_body_begin";
5334 case DW_AT_body_end: return "DW_AT_body_end";
5337 static char buffer [100];
5339 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5346 get_FORM_name (form)
5351 case DW_FORM_addr: return "DW_FORM_addr";
5352 case DW_FORM_block2: return "DW_FORM_block2";
5353 case DW_FORM_block4: return "DW_FORM_block4";
5354 case DW_FORM_data2: return "DW_FORM_data2";
5355 case DW_FORM_data4: return "DW_FORM_data4";
5356 case DW_FORM_data8: return "DW_FORM_data8";
5357 case DW_FORM_string: return "DW_FORM_string";
5358 case DW_FORM_block: return "DW_FORM_block";
5359 case DW_FORM_block1: return "DW_FORM_block1";
5360 case DW_FORM_data1: return "DW_FORM_data1";
5361 case DW_FORM_flag: return "DW_FORM_flag";
5362 case DW_FORM_sdata: return "DW_FORM_sdata";
5363 case DW_FORM_strp: return "DW_FORM_strp";
5364 case DW_FORM_udata: return "DW_FORM_udata";
5365 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5366 case DW_FORM_ref1: return "DW_FORM_ref1";
5367 case DW_FORM_ref2: return "DW_FORM_ref2";
5368 case DW_FORM_ref4: return "DW_FORM_ref4";
5369 case DW_FORM_ref8: return "DW_FORM_ref8";
5370 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5371 case DW_FORM_indirect: return "DW_FORM_indirect";
5374 static char buffer [100];
5376 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5382 /* FIXME: There are better and more effiecint ways to handle
5383 these structures. For now though, I just want something that
5384 is simple to implement. */
5385 typedef struct abbrev_attr
5387 unsigned long attribute;
5389 struct abbrev_attr * next;
5393 typedef struct abbrev_entry
5395 unsigned long entry;
5398 struct abbrev_attr * first_attr;
5399 struct abbrev_attr * last_attr;
5400 struct abbrev_entry * next;
5404 static abbrev_entry * first_abbrev = NULL;
5405 static abbrev_entry * last_abbrev = NULL;
5408 free_abbrevs PARAMS ((void))
5410 abbrev_entry * abbrev;
5412 for (abbrev = first_abbrev; abbrev;)
5414 abbrev_entry * next = abbrev->next;
5417 for (attr = abbrev->first_attr; attr;)
5419 abbrev_attr * next = attr->next;
5429 last_abbrev = first_abbrev = NULL;
5433 add_abbrev (number, tag, children)
5434 unsigned long number;
5438 abbrev_entry * entry;
5440 entry = (abbrev_entry *) malloc (sizeof (* entry));
5446 entry->entry = number;
5448 entry->children = children;
5449 entry->first_attr = NULL;
5450 entry->last_attr = NULL;
5453 if (first_abbrev == NULL)
5454 first_abbrev = entry;
5456 last_abbrev->next = entry;
5458 last_abbrev = entry;
5462 add_abbrev_attr (attribute, form)
5463 unsigned long attribute;
5468 attr = (abbrev_attr *) malloc (sizeof (* attr));
5474 attr->attribute = attribute;
5478 if (last_abbrev->first_attr == NULL)
5479 last_abbrev->first_attr = attr;
5481 last_abbrev->last_attr->next = attr;
5483 last_abbrev->last_attr = attr;
5486 /* Processes the (partial) contents of a .debug_abbrev section.
5487 Returns NULL if the end of the section was encountered.
5488 Returns the address after the last byte read if the end of
5489 an abbreviation set was found. */
5491 static unsigned char *
5492 process_abbrev_section (start, end)
5493 unsigned char * start;
5494 unsigned char * end;
5496 if (first_abbrev != NULL)
5502 unsigned long entry;
5504 unsigned long attribute;
5507 entry = read_leb128 (start, & bytes_read, 0);
5508 start += bytes_read;
5510 /* A single zero is supposed to end the section according
5511 to the standard. If there's more, then signal that to
5514 return start == end ? NULL : start;
5516 tag = read_leb128 (start, & bytes_read, 0);
5517 start += bytes_read;
5519 children = * start ++;
5521 add_abbrev (entry, tag, children);
5527 attribute = read_leb128 (start, & bytes_read, 0);
5528 start += bytes_read;
5530 form = read_leb128 (start, & bytes_read, 0);
5531 start += bytes_read;
5534 add_abbrev_attr (attribute, form);
5536 while (attribute != 0);
5544 display_debug_abbrev (section, start, file)
5545 Elf32_Internal_Shdr * section;
5546 unsigned char * start;
5547 FILE * file ATTRIBUTE_UNUSED;
5549 abbrev_entry * entry;
5550 unsigned char * end = start + section->sh_size;
5552 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5556 start = process_abbrev_section (start, end);
5558 printf (_(" Number TAG\n"));
5560 for (entry = first_abbrev; entry; entry = entry->next)
5564 printf (_(" %ld %s [%s]\n"),
5566 get_TAG_name (entry->tag),
5567 entry->children ? _("has children") : _("no children"));
5569 for (attr = entry->first_attr; attr; attr = attr->next)
5571 printf (_(" %-18s %s\n"),
5572 get_AT_name (attr->attribute),
5573 get_FORM_name (attr->form));
5585 static unsigned char *
5586 display_block (data, length)
5587 unsigned char * data;
5588 unsigned long length;
5590 printf (_(" %lu byte block: "), length);
5593 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5599 decode_location_expression (data, pointer_size)
5600 unsigned char * data;
5601 unsigned int pointer_size;
5605 unsigned long uvalue;
5612 printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data, pointer_size));
5615 printf ("DW_OP_deref");
5618 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data, 1));
5621 printf ("DW_OP_const1s: %ld", (long) byte_get (data, 1));
5624 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5627 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5630 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5633 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5636 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5637 (unsigned long) byte_get (data + 4, 4));
5640 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5641 (long) byte_get (data + 4, 4));
5644 printf ("DW_OP_constu: %lu", read_leb128 (data, NULL, 0));
5647 printf ("DW_OP_consts: %ld", read_leb128 (data, NULL, 1));
5650 printf ("DW_OP_dup");
5653 printf ("DW_OP_drop");
5656 printf ("DW_OP_over");
5659 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data, 1));
5662 printf ("DW_OP_swap");
5665 printf ("DW_OP_rot");
5668 printf ("DW_OP_xderef");
5671 printf ("DW_OP_abs");
5674 printf ("DW_OP_and");
5677 printf ("DW_OP_div");
5680 printf ("DW_OP_minus");
5683 printf ("DW_OP_mod");
5686 printf ("DW_OP_mul");
5689 printf ("DW_OP_neg");
5692 printf ("DW_OP_not");
5695 printf ("DW_OP_or");
5698 printf ("DW_OP_plus");
5700 case DW_OP_plus_uconst:
5701 printf ("DW_OP_plus_uconst: %lu", read_leb128 (data, NULL, 0));
5704 printf ("DW_OP_shl");
5707 printf ("DW_OP_shr");
5710 printf ("DW_OP_shra");
5713 printf ("DW_OP_xor");
5716 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5719 printf ("DW_OP_eq");
5722 printf ("DW_OP_ge");
5725 printf ("DW_OP_gt");
5728 printf ("DW_OP_le");
5731 printf ("DW_OP_lt");
5734 printf ("DW_OP_ne");
5737 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5740 printf ("DW_OP_lit0");
5743 printf ("DW_OP_lit1");
5746 printf ("DW_OP_lit2");
5749 printf ("DW_OP_lit3");
5752 printf ("DW_OP_lit4");
5755 printf ("DW_OP_lit5");
5758 printf ("DW_OP_lit6");
5761 printf ("DW_OP_lit7");
5764 printf ("DW_OP_lit8");
5767 printf ("DW_OP_lit9");
5770 printf ("DW_OP_lit10");
5773 printf ("DW_OP_lit11");
5776 printf ("DW_OP_lit12");
5779 printf ("DW_OP_lit13");
5782 printf ("DW_OP_lit14");
5785 printf ("DW_OP_lit15");
5788 printf ("DW_OP_lit16");
5791 printf ("DW_OP_lit17");
5794 printf ("DW_OP_lit18");
5797 printf ("DW_OP_lit19");
5800 printf ("DW_OP_lit20");
5803 printf ("DW_OP_lit21");
5806 printf ("DW_OP_lit22");
5809 printf ("DW_OP_lit23");
5812 printf ("DW_OP_lit24");
5815 printf ("DW_OP_lit25");
5818 printf ("DW_OP_lit26");
5821 printf ("DW_OP_lit27");
5824 printf ("DW_OP_lit28");
5827 printf ("DW_OP_lit29");
5830 printf ("DW_OP_lit30");
5833 printf ("DW_OP_lit31");
5836 printf ("DW_OP_reg0");
5839 printf ("DW_OP_reg1");
5842 printf ("DW_OP_reg2");
5845 printf ("DW_OP_reg3");
5848 printf ("DW_OP_reg4");
5851 printf ("DW_OP_reg5");
5854 printf ("DW_OP_reg6");
5857 printf ("DW_OP_reg7");
5860 printf ("DW_OP_reg8");
5863 printf ("DW_OP_reg9");
5866 printf ("DW_OP_reg10");
5869 printf ("DW_OP_reg11");
5872 printf ("DW_OP_reg12");
5875 printf ("DW_OP_reg13");
5878 printf ("DW_OP_reg14");
5881 printf ("DW_OP_reg15");
5884 printf ("DW_OP_reg16");
5887 printf ("DW_OP_reg17");
5890 printf ("DW_OP_reg18");
5893 printf ("DW_OP_reg19");
5896 printf ("DW_OP_reg20");
5899 printf ("DW_OP_reg21");
5902 printf ("DW_OP_reg22");
5905 printf ("DW_OP_reg23");
5908 printf ("DW_OP_reg24");
5911 printf ("DW_OP_reg25");
5914 printf ("DW_OP_reg26");
5917 printf ("DW_OP_reg27");
5920 printf ("DW_OP_reg28");
5923 printf ("DW_OP_reg29");
5926 printf ("DW_OP_reg30");
5929 printf ("DW_OP_reg31");
5932 printf ("DW_OP_breg0: %ld", read_leb128 (data, NULL, 1));
5935 printf ("DW_OP_breg1: %ld", read_leb128 (data, NULL, 1));
5938 printf ("DW_OP_breg2: %ld", read_leb128 (data, NULL, 1));
5941 printf ("DW_OP_breg3: %ld", read_leb128 (data, NULL, 1));
5944 printf ("DW_OP_breg4: %ld", read_leb128 (data, NULL, 1));
5947 printf ("DW_OP_breg5: %ld", read_leb128 (data, NULL, 1));
5950 printf ("DW_OP_breg6: %ld", read_leb128 (data, NULL, 1));
5953 printf ("DW_OP_breg7: %ld", read_leb128 (data, NULL, 1));
5956 printf ("DW_OP_breg8: %ld", read_leb128 (data, NULL, 1));
5959 printf ("DW_OP_breg9: %ld", read_leb128 (data, NULL, 1));
5962 printf ("DW_OP_breg10: %ld", read_leb128 (data, NULL, 1));
5965 printf ("DW_OP_breg11: %ld", read_leb128 (data, NULL, 1));
5968 printf ("DW_OP_breg12: %ld", read_leb128 (data, NULL, 1));
5971 printf ("DW_OP_breg13: %ld", read_leb128 (data, NULL, 1));
5974 printf ("DW_OP_breg14: %ld", read_leb128 (data, NULL, 1));
5977 printf ("DW_OP_breg15: %ld", read_leb128 (data, NULL, 1));
5980 printf ("DW_OP_breg16: %ld", read_leb128 (data, NULL, 1));
5983 printf ("DW_OP_breg17: %ld", read_leb128 (data, NULL, 1));
5986 printf ("DW_OP_breg18: %ld", read_leb128 (data, NULL, 1));
5989 printf ("DW_OP_breg19: %ld", read_leb128 (data, NULL, 1));
5992 printf ("DW_OP_breg20: %ld", read_leb128 (data, NULL, 1));
5995 printf ("DW_OP_breg21: %ld", read_leb128 (data, NULL, 1));
5998 printf ("DW_OP_breg22: %ld", read_leb128 (data, NULL, 1));
6001 printf ("DW_OP_breg23: %ld", read_leb128 (data, NULL, 1));
6004 printf ("DW_OP_breg24: %ld", read_leb128 (data, NULL, 1));
6007 printf ("DW_OP_breg25: %ld", read_leb128 (data, NULL, 1));
6010 printf ("DW_OP_breg26: %ld", read_leb128 (data, NULL, 1));
6013 printf ("DW_OP_breg27: %ld", read_leb128 (data, NULL, 1));
6016 printf ("DW_OP_breg28: %ld", read_leb128 (data, NULL, 1));
6019 printf ("DW_OP_breg29: %ld", read_leb128 (data, NULL, 1));
6022 printf ("DW_OP_breg30: %ld", read_leb128 (data, NULL, 1));
6025 printf ("DW_OP_breg31: %ld", read_leb128 (data, NULL, 1));
6028 printf ("DW_OP_regx: %lu", read_leb128 (data, NULL, 0));
6031 printf ("DW_OP_fbreg: %ld", read_leb128 (data, NULL, 1));
6034 uvalue = read_leb128 (data, &bytes_read, 0);
6035 printf ("DW_OP_bregx: %lu %ld", uvalue,
6036 read_leb128 (data + bytes_read, NULL, 1));
6039 printf ("DW_OP_piece: %lu", read_leb128 (data, NULL, 0));
6041 case DW_OP_deref_size:
6042 printf ("DW_OP_deref_size: %ld", (long) byte_get (data, 1));
6044 case DW_OP_xderef_size:
6045 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data, 1));
6048 printf ("DW_OP_nop");
6052 if (op >= DW_OP_lo_user
6053 && op <= DW_OP_hi_user)
6054 printf (_("(User defined location op)"));
6056 printf (_("(Unknown location op)"));
6062 static unsigned char *
6063 read_and_display_attr (attribute, form, data, pointer_size)
6064 unsigned long attribute;
6066 unsigned char * data;
6067 unsigned long pointer_size;
6069 unsigned long uvalue = 0;
6070 unsigned char * block_start = NULL;
6074 printf (" %-18s:", get_AT_name (attribute));
6078 case DW_FORM_ref_addr:
6083 case DW_FORM_ref_udata:
6089 case DW_FORM_ref_addr:
6091 uvalue = byte_get (data, pointer_size);
6092 printf (is_ref ? " <%lx>" : " %#lx", uvalue);
6093 data += pointer_size;
6099 uvalue = byte_get (data ++, 1);
6100 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6105 uvalue = byte_get (data, 2);
6107 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6112 uvalue = byte_get (data, 4);
6114 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6119 uvalue = byte_get (data, 4);
6120 printf (" %lx", uvalue);
6121 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6125 case DW_FORM_string:
6126 printf (" %s", data);
6127 data += strlen (data) + 1;
6131 uvalue = read_leb128 (data, & bytes_read, 1);
6133 printf (" %ld", (long) uvalue);
6136 case DW_FORM_ref_udata:
6138 uvalue = read_leb128 (data, & bytes_read, 0);
6140 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6144 uvalue = read_leb128 (data, & bytes_read, 0);
6145 block_start = data + bytes_read;
6146 data = display_block (block_start, uvalue);
6147 uvalue = * block_start;
6150 case DW_FORM_block1:
6151 uvalue = byte_get (data, 1);
6152 block_start = data + 1;
6153 data = display_block (block_start, uvalue);
6154 uvalue = * block_start;
6157 case DW_FORM_block2:
6158 uvalue = byte_get (data, 2);
6159 block_start = data + 2;
6160 data = display_block (block_start, uvalue);
6161 uvalue = * block_start;
6164 case DW_FORM_block4:
6165 uvalue = byte_get (data, 4);
6166 block_start = data + 4;
6167 data = display_block (block_start, uvalue);
6168 uvalue = * block_start;
6172 case DW_FORM_indirect:
6173 warn (_("Unable to handle FORM: %d"), form);
6177 warn (_("Unrecognised form: %d"), form);
6181 /* For some attributes we can display futher information. */
6190 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6191 case DW_INL_inlined: printf (_("(inlined)")); break;
6192 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6193 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6194 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6198 case DW_AT_frame_base:
6199 if (uvalue >= DW_OP_reg0 && uvalue <= DW_OP_reg31)
6200 printf ("(reg %ld)", uvalue - DW_OP_reg0);
6203 case DW_AT_language:
6206 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6207 case DW_LANG_C89: printf ("(ANSI C)"); break;
6208 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6209 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6210 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6211 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6212 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6213 case DW_LANG_Ada83: printf ("(Ada)"); break;
6214 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6215 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6216 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6217 default: printf ("(Unknown: %lx)", uvalue); break;
6221 case DW_AT_encoding:
6224 case DW_ATE_void: printf ("(void)"); break;
6225 case DW_ATE_address: printf ("(machine address)"); break;
6226 case DW_ATE_boolean: printf ("(boolean)"); break;
6227 case DW_ATE_complex_float: printf ("(complex float)"); break;
6228 case DW_ATE_float: printf ("(float)"); break;
6229 case DW_ATE_signed: printf ("(signed)"); break;
6230 case DW_ATE_signed_char: printf ("(signed char)"); break;
6231 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6232 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6234 if (uvalue >= DW_ATE_lo_user
6235 && uvalue <= DW_ATE_hi_user)
6236 printf ("(user defined type)");
6238 printf ("(unknown type)");
6243 case DW_AT_accessibility:
6246 case DW_ACCESS_public: printf ("(public)"); break;
6247 case DW_ACCESS_protected: printf ("(protected)"); break;
6248 case DW_ACCESS_private: printf ("(private)"); break;
6249 default: printf ("(unknown accessibility)"); break;
6253 case DW_AT_visibility:
6256 case DW_VIS_local: printf ("(local)"); break;
6257 case DW_VIS_exported: printf ("(exported)"); break;
6258 case DW_VIS_qualified: printf ("(qualified)"); break;
6259 default: printf ("(unknown visibility)"); break;
6263 case DW_AT_virtuality:
6266 case DW_VIRTUALITY_none: printf ("(none)"); break;
6267 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6268 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6269 default: printf ("(unknown virtuality)"); break;
6273 case DW_AT_identifier_case:
6276 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6277 case DW_ID_up_case: printf ("(up_case)"); break;
6278 case DW_ID_down_case: printf ("(down_case)"); break;
6279 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6280 default: printf ("(unknown case)"); break;
6284 case DW_AT_calling_convention:
6287 case DW_CC_normal: printf ("(normal)"); break;
6288 case DW_CC_program: printf ("(program)"); break;
6289 case DW_CC_nocall: printf ("(nocall)"); break;
6291 if (uvalue >= DW_CC_lo_user
6292 && uvalue <= DW_CC_hi_user)
6293 printf ("(user defined)");
6295 printf ("(unknown convention)");
6299 case DW_AT_location:
6300 case DW_AT_data_member_location:
6301 case DW_AT_vtable_elem_location:
6303 decode_location_expression (block_start, pointer_size);
6316 display_debug_info (section, start, file)
6317 Elf32_Internal_Shdr * section;
6318 unsigned char * start;
6321 unsigned char * end = start + section->sh_size;
6322 unsigned char * section_begin = start;
6324 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6328 DWARF2_External_CompUnit * external;
6329 DWARF2_Internal_CompUnit compunit;
6330 unsigned char * tags;
6334 external = (DWARF2_External_CompUnit *) start;
6336 compunit.cu_length = BYTE_GET (external->cu_length);
6337 compunit.cu_version = BYTE_GET (external->cu_version);
6338 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6339 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6341 tags = start + sizeof (* external);
6342 start += compunit.cu_length + sizeof (external->cu_length);
6344 if (compunit.cu_version != 2)
6346 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6350 printf (_(" Compilation Unit:\n"));
6351 printf (_(" Length: %ld\n"), compunit.cu_length);
6352 printf (_(" Version: %d\n"), compunit.cu_version);
6353 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6354 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6356 if (first_abbrev != NULL)
6359 /* Read in the abbrevs used by this compilation unit. */
6362 Elf32_Internal_Shdr * sec;
6363 unsigned char * begin;
6365 /* Locate the .debug_abbrev section and process it. */
6366 for (i = 0, sec = section_headers;
6367 i < elf_header.e_shnum;
6369 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6372 if (i == -1 || sec->sh_size == 0)
6374 warn (_("Unable to locate .debug_abbrev section!\n"));
6378 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6379 "debug_abbrev section data");
6381 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6382 begin + sec->sh_size);
6388 while (tags < start)
6391 unsigned long abbrev_number;
6392 abbrev_entry * entry;
6395 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6398 /* A null DIE marks the end of a list of children. */
6399 if (abbrev_number == 0)
6405 /* Scan through the abbreviation list until we reach the
6407 for (entry = first_abbrev;
6408 entry && entry->entry != abbrev_number;
6409 entry = entry->next)
6414 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6419 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6420 level, tags - section_begin - bytes_read,
6422 get_TAG_name (entry->tag));
6424 for (attr = entry->first_attr; attr; attr = attr->next)
6425 tags = read_and_display_attr (attr->attribute,
6428 compunit.cu_pointer_size);
6430 if (entry->children)
6441 display_debug_aranges (section, start, file)
6442 Elf32_Internal_Shdr * section;
6443 unsigned char * start;
6444 FILE * file ATTRIBUTE_UNUSED;
6446 unsigned char * end = start + section->sh_size;
6448 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6452 DWARF2_External_ARange * external;
6453 DWARF2_Internal_ARange arange;
6454 unsigned char * ranges;
6455 unsigned long length;
6456 unsigned long address;
6459 external = (DWARF2_External_ARange *) start;
6461 arange.ar_length = BYTE_GET (external->ar_length);
6462 arange.ar_version = BYTE_GET (external->ar_version);
6463 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6464 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6465 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6467 printf (_(" Length: %ld\n"), arange.ar_length);
6468 printf (_(" Version: %d\n"), arange.ar_version);
6469 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6470 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6471 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6473 printf (_("\n Address Length\n"));
6475 ranges = start + sizeof (* external);
6477 /* Must pad to an alignment boundary that is twice the pointer size. */
6478 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6480 ranges += (2 * arange.ar_pointer_size) - excess;
6484 address = byte_get (ranges, arange.ar_pointer_size);
6486 ranges += arange.ar_pointer_size;
6488 length = byte_get (ranges, arange.ar_pointer_size);
6490 ranges += arange.ar_pointer_size;
6492 /* A pair of zeros marks the end of the list. */
6493 if (address == 0 && length == 0)
6496 printf (" %8.8lx %lu\n", address, length);
6499 start += arange.ar_length + sizeof (external->ar_length);
6509 display_debug_not_supported (section, start, file)
6510 Elf32_Internal_Shdr * section;
6511 unsigned char * start ATTRIBUTE_UNUSED;
6512 FILE * file ATTRIBUTE_UNUSED;
6514 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6515 SECTION_NAME (section));
6520 /* Pre-scan the .debug_info section to record the size of address.
6521 When dumping the .debug_line, we use that size information, assuming
6522 that all compilation units have the same address size. */
6524 prescan_debug_info (section, start, file)
6525 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6526 unsigned char * start;
6527 FILE * file ATTRIBUTE_UNUSED;
6529 DWARF2_External_CompUnit * external;
6531 external = (DWARF2_External_CompUnit *) start;
6533 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6537 /* A structure containing the name of a debug section and a pointer
6538 to a function that can decode it. The third field is a prescan
6539 function to be run over the section before displaying any of the
6544 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6545 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6549 { ".debug_info", display_debug_info, prescan_debug_info },
6550 { ".debug_abbrev", display_debug_abbrev, NULL },
6551 { ".debug_line", display_debug_lines, NULL },
6552 { ".debug_aranges", display_debug_aranges, NULL },
6553 { ".debug_pubnames", display_debug_pubnames, NULL },
6554 { ".debug_macinfo", display_debug_not_supported, NULL },
6555 { ".debug_frame", display_debug_not_supported, NULL },
6556 { ".debug_str", display_debug_not_supported, NULL },
6557 { ".debug_static_func", display_debug_not_supported, NULL },
6558 { ".debug_static_vars", display_debug_not_supported, NULL },
6559 { ".debug_types", display_debug_not_supported, NULL },
6560 { ".debug_weaknames", display_debug_not_supported, NULL }
6564 display_debug_section (section, file)
6565 Elf32_Internal_Shdr * section;
6568 char * name = SECTION_NAME (section);
6569 bfd_size_type length;
6570 unsigned char * start;
6573 length = section->sh_size;
6576 printf (_("\nSection '%s' has no debugging data.\n"), name);
6580 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6581 "debug section data");
6583 /* See if we know how to display the contents of this section. */
6584 for (i = NUM_ELEM (debug_displays); i--;)
6585 if (strcmp (debug_displays[i].name, name) == 0)
6587 debug_displays[i].display (section, start, file);
6592 printf (_("Unrecognised debug section: %s\n"), name);
6596 /* If we loaded in the abbrev section at some point,
6597 we must release it here. */
6598 if (first_abbrev != NULL)
6605 process_section_contents (file)
6608 Elf32_Internal_Shdr * section;
6614 /* Pre-scan the debug sections to find some debug information not
6615 present in some of them. For the .debug_line, we must find out the
6616 size of address (specified in .debug_info and .debug_aranges). */
6617 for (i = 0, section = section_headers;
6618 i < elf_header.e_shnum && i < num_dump_sects;
6621 char * name = SECTION_NAME (section);
6624 if (section->sh_size == 0)
6627 /* See if there is some pre-scan operation for this section. */
6628 for (j = NUM_ELEM (debug_displays); j--;)
6629 if (strcmp (debug_displays[j].name, name) == 0)
6631 if (debug_displays[j].prescan != NULL)
6633 bfd_size_type length;
6634 unsigned char * start;
6636 length = section->sh_size;
6637 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6638 "debug section data");
6640 debug_displays[j].prescan (section, start, file);
6648 for (i = 0, section = section_headers;
6649 i < elf_header.e_shnum && i < num_dump_sects;
6652 #ifdef SUPPORT_DISASSEMBLY
6653 if (dump_sects[i] & DISASS_DUMP)
6654 disassemble_section (section, file);
6656 if (dump_sects[i] & HEX_DUMP)
6657 dump_section (section, file);
6659 if (dump_sects[i] & DEBUG_DUMP)
6660 display_debug_section (section, file);
6663 if (i < num_dump_sects)
6664 warn (_("Some sections were not dumped because they do not exist!\n"));
6670 process_mips_fpe_exception (mask)
6676 if (mask & OEX_FPU_INEX)
6677 fputs ("INEX", stdout), first = 0;
6678 if (mask & OEX_FPU_UFLO)
6679 printf ("%sUFLO", first ? "" : "|"), first = 0;
6680 if (mask & OEX_FPU_OFLO)
6681 printf ("%sOFLO", first ? "" : "|"), first = 0;
6682 if (mask & OEX_FPU_DIV0)
6683 printf ("%sDIV0", first ? "" : "|"), first = 0;
6684 if (mask & OEX_FPU_INVAL)
6685 printf ("%sINVAL", first ? "" : "|");
6688 fputs ("0", stdout);
6692 process_mips_specific (file)
6695 Elf_Internal_Dyn * entry;
6696 size_t liblist_offset = 0;
6697 size_t liblistno = 0;
6698 size_t conflictsno = 0;
6699 size_t options_offset = 0;
6700 size_t conflicts_offset = 0;
6702 /* We have a lot of special sections. Thanks SGI! */
6703 if (dynamic_segment == NULL)
6704 /* No information available. */
6707 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
6708 switch (entry->d_tag)
6710 case DT_MIPS_LIBLIST:
6711 liblist_offset = entry->d_un.d_val - loadaddr;
6713 case DT_MIPS_LIBLISTNO:
6714 liblistno = entry->d_un.d_val;
6716 case DT_MIPS_OPTIONS:
6717 options_offset = entry->d_un.d_val - loadaddr;
6719 case DT_MIPS_CONFLICT:
6720 conflicts_offset = entry->d_un.d_val - loadaddr;
6722 case DT_MIPS_CONFLICTNO:
6723 conflictsno = entry->d_un.d_val;
6729 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
6731 Elf32_External_Lib * elib;
6734 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
6735 elib, Elf32_External_Lib *, "liblist");
6737 printf ("\nSection '.liblist' contains %lu entries:\n",
6738 (unsigned long) liblistno);
6739 fputs (" Library Time Stamp Checksum Version Flags\n",
6742 for (cnt = 0; cnt < liblistno; ++cnt)
6748 liblist.l_name = BYTE_GET (elib[cnt].l_name);
6749 time = BYTE_GET (elib[cnt].l_time_stamp);
6750 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
6751 liblist.l_version = BYTE_GET (elib[cnt].l_version);
6752 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
6754 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
6756 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
6757 dynamic_strings + liblist.l_name, timebuf,
6758 liblist.l_checksum, liblist.l_version);
6760 if (liblist.l_flags == 0)
6771 { " EXACT_MATCH", LL_EXACT_MATCH },
6772 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
6773 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
6774 { " EXPORTS", LL_EXPORTS },
6775 { " DELAY_LOAD", LL_DELAY_LOAD },
6776 { " DELTA", LL_DELTA }
6778 int flags = liblist.l_flags;
6782 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
6784 if ((flags & l_flags_vals[fcnt].bit) != 0)
6786 fputs (l_flags_vals[fcnt].name, stdout);
6787 flags ^= l_flags_vals[fcnt].bit;
6790 printf (" %#x", (unsigned int) flags);
6799 if (options_offset != 0)
6801 Elf_External_Options * eopt;
6802 Elf_Internal_Shdr * sect = section_headers;
6803 Elf_Internal_Options * iopt;
6804 Elf_Internal_Options * option;
6808 /* Find the section header so that we get the size. */
6809 while (sect->sh_type != SHT_MIPS_OPTIONS)
6812 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
6813 Elf_External_Options *, "options");
6815 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
6819 error (_("Out of memory"));
6826 while (offset < sect->sh_size)
6828 Elf_External_Options * eoption;
6830 eoption = (Elf_External_Options *) ((char *) eopt + offset);
6832 option->kind = BYTE_GET (eoption->kind);
6833 option->size = BYTE_GET (eoption->size);
6834 option->section = BYTE_GET (eoption->section);
6835 option->info = BYTE_GET (eoption->info);
6837 offset += option->size;
6843 printf (_("\nSection '%s' contains %d entries:\n"),
6844 string_table + sect->sh_name, cnt);
6852 switch (option->kind)
6855 /* This shouldn't happen. */
6856 printf (" NULL %d %lx", option->section, option->info);
6859 printf (" REGINFO ");
6860 if (elf_header.e_machine == EM_MIPS)
6863 Elf32_External_RegInfo *ereg;
6864 Elf32_RegInfo reginfo;
6866 ereg = (Elf32_External_RegInfo *) (option + 1);
6867 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6868 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6869 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6870 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6871 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6872 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
6874 printf ("GPR %08lx GP 0x%lx\n",
6876 (unsigned long) reginfo.ri_gp_value);
6877 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6878 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6879 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6884 Elf64_External_RegInfo * ereg;
6885 Elf64_Internal_RegInfo reginfo;
6887 ereg = (Elf64_External_RegInfo *) (option + 1);
6888 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6889 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6890 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6891 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6892 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6893 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
6895 printf ("GPR %08lx GP 0x",
6896 reginfo.ri_gprmask);
6897 printf_vma (reginfo.ri_gp_value);
6900 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6901 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6902 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6906 case ODK_EXCEPTIONS:
6907 fputs (" EXCEPTIONS fpe_min(", stdout);
6908 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
6909 fputs (") fpe_max(", stdout);
6910 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
6911 fputs (")", stdout);
6913 if (option->info & OEX_PAGE0)
6914 fputs (" PAGE0", stdout);
6915 if (option->info & OEX_SMM)
6916 fputs (" SMM", stdout);
6917 if (option->info & OEX_FPDBUG)
6918 fputs (" FPDBUG", stdout);
6919 if (option->info & OEX_DISMISS)
6920 fputs (" DISMISS", stdout);
6923 fputs (" PAD ", stdout);
6924 if (option->info & OPAD_PREFIX)
6925 fputs (" PREFIX", stdout);
6926 if (option->info & OPAD_POSTFIX)
6927 fputs (" POSTFIX", stdout);
6928 if (option->info & OPAD_SYMBOL)
6929 fputs (" SYMBOL", stdout);
6932 fputs (" HWPATCH ", stdout);
6933 if (option->info & OHW_R4KEOP)
6934 fputs (" R4KEOP", stdout);
6935 if (option->info & OHW_R8KPFETCH)
6936 fputs (" R8KPFETCH", stdout);
6937 if (option->info & OHW_R5KEOP)
6938 fputs (" R5KEOP", stdout);
6939 if (option->info & OHW_R5KCVTL)
6940 fputs (" R5KCVTL", stdout);
6943 fputs (" FILL ", stdout);
6944 /* XXX Print content of info word? */
6947 fputs (" TAGS ", stdout);
6948 /* XXX Print content of info word? */
6951 fputs (" HWAND ", stdout);
6952 if (option->info & OHWA0_R4KEOP_CHECKED)
6953 fputs (" R4KEOP_CHECKED", stdout);
6954 if (option->info & OHWA0_R4KEOP_CLEAN)
6955 fputs (" R4KEOP_CLEAN", stdout);
6958 fputs (" HWOR ", stdout);
6959 if (option->info & OHWA0_R4KEOP_CHECKED)
6960 fputs (" R4KEOP_CHECKED", stdout);
6961 if (option->info & OHWA0_R4KEOP_CLEAN)
6962 fputs (" R4KEOP_CLEAN", stdout);
6965 printf (" GP_GROUP %#06lx self-contained %#06lx",
6966 option->info & OGP_GROUP,
6967 (option->info & OGP_SELF) >> 16);
6970 printf (" IDENT %#06lx self-contained %#06lx",
6971 option->info & OGP_GROUP,
6972 (option->info & OGP_SELF) >> 16);
6975 /* This shouldn't happen. */
6976 printf (" %3d ??? %d %lx",
6977 option->kind, option->section, option->info);
6981 len = sizeof (*eopt);
6982 while (len < option->size)
6983 if (((char *) option)[len] >= ' '
6984 && ((char *) option)[len] < 0x7f)
6985 printf ("%c", ((char *) option)[len++]);
6987 printf ("\\%03o", ((char *) option)[len++]);
6989 fputs ("\n", stdout);
6996 if (conflicts_offset != 0 && conflictsno != 0)
6998 Elf32_External_Conflict * econf32;
6999 Elf64_External_Conflict * econf64;
7000 Elf32_Conflict * iconf;
7003 if (dynamic_symbols == NULL)
7005 error (_("conflict list with without table"));
7009 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
7012 error (_("Out of memory"));
7018 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
7019 econf32, Elf32_External_Conflict *, "conflict");
7021 for (cnt = 0; cnt < conflictsno; ++cnt)
7022 iconf[cnt] = BYTE_GET (econf32[cnt]);
7026 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
7027 econf64, Elf64_External_Conflict *, "conflict");
7029 for (cnt = 0; cnt < conflictsno; ++cnt)
7030 iconf[cnt] = BYTE_GET (econf64[cnt]);
7033 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
7034 puts (_(" Num: Index Value Name"));
7036 for (cnt = 0; cnt < conflictsno; ++cnt)
7038 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
7040 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
7041 print_vma (psym->st_value, FULL_HEX);
7042 printf (" %s\n", dynamic_strings + psym->st_name);
7052 get_note_type (e_type)
7055 static char buff[64];
7059 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
7060 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
7061 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
7062 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
7063 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
7064 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
7065 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
7066 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
7067 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
7068 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7069 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7071 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
7076 /* Note that by the ELF standard, the name field is already null byte
7077 terminated, and namesz includes the terminating null byte.
7078 I.E. the value of namesz for the name "FSF" is 4.
7080 If the value of namesz is zero, there is no name present. */
7082 process_note (pnote)
7083 Elf32_Internal_Note * pnote;
7085 printf (" %s\t\t0x%08lx\t%s\n",
7086 pnote->namesz ? pnote->namedata : "(NONE)",
7087 pnote->descsz, get_note_type (pnote->type));
7093 process_corefile_note_segment (file, offset, length)
7098 Elf_External_Note * pnotes;
7099 Elf_External_Note * external;
7105 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
7109 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7110 (unsigned long) offset, (unsigned long) length);
7111 printf (_(" Owner\t\tData size\tDescription\n"));
7113 while (external < (Elf_External_Note *)((char *) pnotes + length))
7115 Elf32_Internal_Note inote;
7118 inote.type = BYTE_GET (external->type);
7119 inote.namesz = BYTE_GET (external->namesz);
7120 inote.namedata = external->name;
7121 inote.descsz = BYTE_GET (external->descsz);
7122 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
7123 inote.descpos = offset + (inote.descdata - (char *) pnotes);
7125 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7127 /* Verify that name is null terminated. It appears that at least
7128 one version of Linux (RedHat 6.0) generates corefiles that don't
7129 comply with the ELF spec by failing to include the null byte in
7131 if (inote.namedata[inote.namesz] != '\0')
7133 temp = malloc (inote.namesz + 1);
7137 error (_("Out of memory\n"));
7142 strncpy (temp, inote.namedata, inote.namesz);
7143 temp[inote.namesz] = 0;
7145 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7146 inote.namedata = temp;
7149 res &= process_note (& inote);
7164 process_corefile_note_segments (file)
7167 Elf_Internal_Phdr * program_headers;
7168 Elf_Internal_Phdr * segment;
7172 program_headers = (Elf_Internal_Phdr *) malloc
7173 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7175 if (program_headers == NULL)
7177 error (_("Out of memory\n"));
7182 i = get_32bit_program_headers (file, program_headers);
7184 i = get_64bit_program_headers (file, program_headers);
7188 free (program_headers);
7192 for (i = 0, segment = program_headers;
7193 i < elf_header.e_phnum;
7196 if (segment->p_type == PT_NOTE)
7197 res &= process_corefile_note_segment (file,
7198 (bfd_vma) segment->p_offset,
7199 (bfd_vma) segment->p_filesz);
7202 free (program_headers);
7208 process_corefile_contents (file)
7211 /* If we have not been asked to display the notes then do nothing. */
7215 /* If file is not a core file then exit. */
7216 if (elf_header.e_type != ET_CORE)
7219 /* No program headers means no NOTE segment. */
7220 if (elf_header.e_phnum == 0)
7222 printf (_("No note segments present in the core file.\n"));
7226 return process_corefile_note_segments (file);
7230 process_arch_specific (file)
7236 switch (elf_header.e_machine)
7239 case EM_MIPS_RS4_BE:
7240 return process_mips_specific (file);
7249 get_file_header (file)
7252 /* Read in the identity array. */
7253 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7256 /* Determine how to read the rest of the header. */
7257 switch (elf_header.e_ident [EI_DATA])
7259 default: /* fall through */
7260 case ELFDATANONE: /* fall through */
7261 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7262 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7265 /* For now we only support 32 bit and 64 bit ELF files. */
7266 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7268 /* Read in the rest of the header. */
7271 Elf32_External_Ehdr ehdr32;
7273 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7276 elf_header.e_type = BYTE_GET (ehdr32.e_type);
7277 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
7278 elf_header.e_version = BYTE_GET (ehdr32.e_version);
7279 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7280 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7281 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7282 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7283 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7284 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7285 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7286 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7287 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7288 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7292 Elf64_External_Ehdr ehdr64;
7294 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7295 we will not be able to cope with the 64bit data found in
7296 64 ELF files. Detect this now and abort before we start
7297 overwritting things. */
7298 if (sizeof (bfd_vma) < 8)
7300 error (_("This instance of readelf has been built without support for a\n"));
7301 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7305 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7308 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7309 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7310 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7311 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7312 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7313 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7314 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7315 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7316 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7317 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7318 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7319 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7320 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7327 process_file (file_name)
7331 struct stat statbuf;
7334 if (stat (file_name, & statbuf) < 0)
7336 error (_("Cannot stat input file %s.\n"), file_name);
7340 file = fopen (file_name, "rb");
7343 error (_("Input file %s not found.\n"), file_name);
7347 if (! get_file_header (file))
7349 error (_("%s: Failed to read file header\n"), file_name);
7354 /* Initialise per file variables. */
7355 for (i = NUM_ELEM (version_info); i--;)
7356 version_info[i] = 0;
7358 for (i = NUM_ELEM (dynamic_info); i--;)
7359 dynamic_info[i] = 0;
7361 /* Process the file. */
7363 printf (_("\nFile: %s\n"), file_name);
7365 if (! process_file_header ())
7371 process_section_headers (file);
7373 process_program_headers (file);
7375 process_dynamic_segment (file);
7377 process_relocs (file);
7379 process_symbol_table (file);
7381 process_syminfo (file);
7383 process_version_sections (file);
7385 process_section_contents (file);
7387 process_corefile_contents (file);
7389 process_arch_specific (file);
7393 if (section_headers)
7395 free (section_headers);
7396 section_headers = NULL;
7401 free (string_table);
7402 string_table = NULL;
7405 if (dynamic_strings)
7407 free (dynamic_strings);
7408 dynamic_strings = NULL;
7411 if (dynamic_symbols)
7413 free (dynamic_symbols);
7414 dynamic_symbols = NULL;
7415 num_dynamic_syms = 0;
7418 if (dynamic_syminfo)
7420 free (dynamic_syminfo);
7421 dynamic_syminfo = NULL;
7425 #ifdef SUPPORT_DISASSEMBLY
7426 /* Needed by the i386 disassembler. For extra credit, someone could
7427 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7431 print_address (unsigned int addr, FILE * outfile)
7433 fprintf (outfile,"0x%8.8x", addr);
7436 /* Needed by the i386 disassembler. */
7438 db_task_printsym (unsigned int addr)
7440 print_address (addr, stderr);
7449 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7450 setlocale (LC_MESSAGES, "");
7452 bindtextdomain (PACKAGE, LOCALEDIR);
7453 textdomain (PACKAGE);
7455 parse_args (argc, argv);
7457 if (optind < (argc - 1))
7460 while (optind < argc)
7461 process_file (argv [optind ++]);
7463 if (dump_sects != NULL)