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");
1358 strcat (buf,", <unknown>");
1362 get_machine_flags (e_flags, e_machine)
1366 static char buf [1024];
1378 decode_ARM_machine_flags (e_flags, buf);
1382 if (e_flags & EF_CPU32)
1383 strcat (buf, ", cpu32");
1387 if (e_flags & EF_PPC_EMB)
1388 strcat (buf, ", emb");
1390 if (e_flags & EF_PPC_RELOCATABLE)
1391 strcat (buf, ", relocatable");
1393 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1394 strcat (buf, ", relocatable-lib");
1397 case EM_CYGNUS_V850:
1398 switch (e_flags & EF_V850_ARCH)
1401 strcat (buf, ", v850e");
1404 strcat (buf, ", v850ea");
1407 strcat (buf, ", v850");
1410 strcat (buf, ", unknown v850 architecture variant");
1415 case EM_CYGNUS_M32R:
1416 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1417 strcat (buf, ", m32r");
1422 case EM_MIPS_RS4_BE:
1423 if (e_flags & EF_MIPS_NOREORDER)
1424 strcat (buf, ", noreorder");
1426 if (e_flags & EF_MIPS_PIC)
1427 strcat (buf, ", pic");
1429 if (e_flags & EF_MIPS_CPIC)
1430 strcat (buf, ", cpic");
1432 if (e_flags & EF_MIPS_ABI2)
1433 strcat (buf, ", abi2");
1435 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1436 strcat (buf, ", mips1");
1438 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1439 strcat (buf, ", mips2");
1441 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1442 strcat (buf, ", mips3");
1444 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1445 strcat (buf, ", mips4");
1449 if (e_flags & EF_SPARC_32PLUS)
1450 strcat (buf, ", v8+");
1452 if (e_flags & EF_SPARC_SUN_US1)
1453 strcat (buf, ", ultrasparcI");
1455 if (e_flags & EF_SPARC_SUN_US3)
1456 strcat (buf, ", ultrasparcIII");
1458 if (e_flags & EF_SPARC_HAL_R1)
1459 strcat (buf, ", halr1");
1461 if (e_flags & EF_SPARC_LEDATA)
1462 strcat (buf, ", ledata");
1464 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1465 strcat (buf, ", tso");
1467 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1468 strcat (buf, ", pso");
1470 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1471 strcat (buf, ", rmo");
1475 switch (e_flags & EF_PARISC_ARCH)
1477 case EFA_PARISC_1_0:
1478 strcpy (buf, ", PA-RISC 1.0");
1480 case EFA_PARISC_1_1:
1481 strcpy (buf, ", PA-RISC 1.1");
1483 case EFA_PARISC_2_0:
1484 strcpy (buf, ", PA-RISC 2.0");
1489 if (e_flags & EF_PARISC_TRAPNIL)
1490 strcat (buf, ", trapnil");
1491 if (e_flags & EF_PARISC_EXT)
1492 strcat (buf, ", ext");
1493 if (e_flags & EF_PARISC_LSB)
1494 strcat (buf, ", lsb");
1495 if (e_flags & EF_PARISC_WIDE)
1496 strcat (buf, ", wide");
1497 if (e_flags & EF_PARISC_NO_KABP)
1498 strcat (buf, ", no kabp");
1499 if (e_flags & EF_PARISC_LAZYSWAP)
1500 strcat (buf, ", lazyswap");
1504 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1505 strcat (buf, ", new calling convention");
1507 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1508 strcat (buf, ", gnu calling convention");
1517 get_mips_segment_type (type)
1522 case PT_MIPS_REGINFO:
1524 case PT_MIPS_RTPROC:
1526 case PT_MIPS_OPTIONS:
1536 get_parisc_segment_type (type)
1541 case PT_HP_TLS: return "HP_TLS";
1542 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1543 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1544 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1545 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1546 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1547 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1548 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1549 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1550 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1551 case PT_HP_PARALLEL: return "HP_PARALLEL";
1552 case PT_HP_FASTBIND: return "HP_FASTBIND";
1553 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1554 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1563 get_segment_type (p_type)
1564 unsigned long p_type;
1566 static char buff [32];
1570 case PT_NULL: return "NULL";
1571 case PT_LOAD: return "LOAD";
1572 case PT_DYNAMIC: return "DYNAMIC";
1573 case PT_INTERP: return "INTERP";
1574 case PT_NOTE: return "NOTE";
1575 case PT_SHLIB: return "SHLIB";
1576 case PT_PHDR: return "PHDR";
1579 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1581 const char * result;
1583 switch (elf_header.e_machine)
1586 case EM_MIPS_RS4_BE:
1587 result = get_mips_segment_type (p_type);
1590 result = get_parisc_segment_type (p_type);
1600 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1602 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1604 const char * result;
1606 switch (elf_header.e_machine)
1609 result = get_parisc_segment_type (p_type);
1619 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1622 sprintf (buff, _("<unknown>: %lx"), p_type);
1629 get_mips_section_type_name (sh_type)
1630 unsigned int sh_type;
1634 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1635 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1636 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1637 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1638 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1639 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1640 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1641 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1642 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1643 case SHT_MIPS_RELD: return "MIPS_RELD";
1644 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1645 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1646 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1647 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1648 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1649 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1650 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1651 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1652 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1653 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1654 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1655 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1656 case SHT_MIPS_LINE: return "MIPS_LINE";
1657 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1658 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1659 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1660 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1661 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1662 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1663 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1664 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1665 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1666 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1667 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1668 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1669 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1670 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1671 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1672 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1680 get_parisc_section_type_name (sh_type)
1681 unsigned int sh_type;
1685 case SHT_PARISC_EXT: return "PARISC_EXT";
1686 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1687 case SHT_PARISC_DOC: return "PARISC_DOC";
1695 get_section_type_name (sh_type)
1696 unsigned int sh_type;
1698 static char buff [32];
1702 case SHT_NULL: return "NULL";
1703 case SHT_PROGBITS: return "PROGBITS";
1704 case SHT_SYMTAB: return "SYMTAB";
1705 case SHT_STRTAB: return "STRTAB";
1706 case SHT_RELA: return "RELA";
1707 case SHT_HASH: return "HASH";
1708 case SHT_DYNAMIC: return "DYNAMIC";
1709 case SHT_NOTE: return "NOTE";
1710 case SHT_NOBITS: return "NOBITS";
1711 case SHT_REL: return "REL";
1712 case SHT_SHLIB: return "SHLIB";
1713 case SHT_DYNSYM: return "DYNSYM";
1714 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1715 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1716 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1717 case SHT_GNU_verdef: return "VERDEF";
1718 case SHT_GNU_verneed: return "VERNEED";
1719 case SHT_GNU_versym: return "VERSYM";
1720 case 0x6ffffff0: return "VERSYM";
1721 case 0x6ffffffc: return "VERDEF";
1722 case 0x7ffffffd: return "AUXILIARY";
1723 case 0x7fffffff: return "FILTER";
1726 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1728 const char * result;
1730 switch (elf_header.e_machine)
1733 case EM_MIPS_RS4_BE:
1734 result = get_mips_section_type_name (sh_type);
1737 result = get_parisc_section_type_name (sh_type);
1747 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1749 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1750 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1751 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1752 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1754 sprintf (buff, _("<unknown>: %x"), sh_type);
1760 struct option options [] =
1762 {"all", no_argument, 0, 'a'},
1763 {"file-header", no_argument, 0, 'h'},
1764 {"program-headers", no_argument, 0, 'l'},
1765 {"headers", no_argument, 0, 'e'},
1766 {"histogram", no_argument, 0, 'I'},
1767 {"segments", no_argument, 0, 'l'},
1768 {"sections", no_argument, 0, 'S'},
1769 {"section-headers", no_argument, 0, 'S'},
1770 {"symbols", no_argument, 0, 's'},
1771 {"syms", no_argument, 0, 's'},
1772 {"relocs", no_argument, 0, 'r'},
1773 {"notes", no_argument, 0, 'n'},
1774 {"dynamic", no_argument, 0, 'd'},
1775 {"arch-specific", no_argument, 0, 'A'},
1776 {"version-info", no_argument, 0, 'V'},
1777 {"use-dynamic", no_argument, 0, 'D'},
1778 {"hex-dump", required_argument, 0, 'x'},
1779 {"debug-dump", optional_argument, 0, 'w'},
1780 #ifdef SUPPORT_DISASSEMBLY
1781 {"instruction-dump", required_argument, 0, 'i'},
1784 {"version", no_argument, 0, 'v'},
1785 {"help", no_argument, 0, 'H'},
1786 {0, no_argument, 0, 0}
1792 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1793 fprintf (stdout, _(" Options are:\n"));
1794 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1795 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1796 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1797 fprintf (stdout, _(" Display the program headers\n"));
1798 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1799 fprintf (stdout, _(" Display the sections' header\n"));
1800 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1801 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1802 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1803 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1804 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1805 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1806 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1807 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1808 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1809 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1810 fprintf (stdout, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1811 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
1812 #ifdef SUPPORT_DISASSEMBLY
1813 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1814 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1816 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1817 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1818 fprintf (stdout, _(" -H or --help Display this information\n"));
1819 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
1825 request_dump (section, type)
1826 unsigned int section;
1829 if (section >= num_dump_sects)
1831 char * new_dump_sects;
1833 new_dump_sects = (char *) calloc (section + 1, 1);
1835 if (new_dump_sects == NULL)
1836 error (_("Out of memory allocating dump request table."));
1839 /* Copy current flag settings. */
1840 memcpy (new_dump_sects, dump_sects, num_dump_sects);
1844 dump_sects = new_dump_sects;
1845 num_dump_sects = section + 1;
1850 dump_sects [section] |= type;
1856 parse_args (argc, argv)
1865 while ((c = getopt_long
1866 (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
1901 do_using_dynamic ++;
1929 section = strtoul (optarg, & cp, 0);
1930 if (! * cp && section >= 0)
1932 request_dump (section, HEX_DUMP);
1952 do_debug_abbrevs = 1;
1962 do_debug_pubnames = 1;
1967 do_debug_aranges = 1;
1971 warn (_("Unrecognised debug option '%s'\n"), optarg);
1976 #ifdef SUPPORT_DISASSEMBLY
1979 section = strtoul (optarg, & cp, 0);
1980 if (! * cp && section >= 0)
1982 request_dump (section, DISASS_DUMP);
1988 print_version (program_name);
1995 /* xgettext:c-format */
1996 error (_("Invalid option '-%c'\n"), c);
2003 if (!do_dynamic && !do_syms && !do_reloc && !do_sections
2004 && !do_segments && !do_header && !do_dump && !do_version
2005 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2009 warn (_("Nothing to do.\n"));
2015 get_elf_class (elf_class)
2016 unsigned char elf_class;
2018 static char buff [32];
2022 case ELFCLASSNONE: return _("none");
2023 case ELFCLASS32: return _("ELF32");
2024 case ELFCLASS64: return _("ELF64");
2026 sprintf (buff, _("<unknown: %x>"), elf_class);
2032 get_data_encoding (encoding)
2033 unsigned char encoding;
2035 static char buff [32];
2039 case ELFDATANONE: return _("none");
2040 case ELFDATA2LSB: return _("2's complement, little endian");
2041 case ELFDATA2MSB: return _("2's complement, big endian");
2043 sprintf (buff, _("<unknown: %x>"), encoding);
2049 get_osabi_name (osabi)
2050 unsigned char osabi;
2052 static char buff [32];
2056 case ELFOSABI_SYSV: return _("UNIX - System V");
2057 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2058 case ELFOSABI_LINUX: return _("UNIX - Linux");
2059 case ELFOSABI_STANDALONE: return _("Standalone App");
2060 case ELFOSABI_ARM: return _("ARM");
2062 sprintf (buff, _("<unknown: %x>"), osabi);
2067 /* Decode the data held in 'elf_header'. */
2069 process_file_header ()
2071 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2072 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2073 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2074 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2077 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2085 printf (_("ELF Header:\n"));
2086 printf (_(" Magic: "));
2087 for (i = 0; i < EI_NIDENT; i ++)
2088 printf ("%2.2x ", elf_header.e_ident [i]);
2090 printf (_(" Class: %s\n"),
2091 get_elf_class (elf_header.e_ident [EI_CLASS]));
2092 printf (_(" Data: %s\n"),
2093 get_data_encoding (elf_header.e_ident [EI_DATA]));
2094 printf (_(" Version: %d %s\n"),
2095 elf_header.e_ident [EI_VERSION],
2096 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2098 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2101 printf (_(" OS/ABI: %s\n"),
2102 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2103 printf (_(" ABI Version: %d\n"),
2104 elf_header.e_ident [EI_ABIVERSION]);
2105 printf (_(" Type: %s\n"),
2106 get_file_type (elf_header.e_type));
2107 printf (_(" Machine: %s\n"),
2108 get_machine_name (elf_header.e_machine));
2109 printf (_(" Version: 0x%lx\n"),
2110 (unsigned long) elf_header.e_version);
2112 printf (_(" Entry point address: "));
2113 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2114 printf (_("\n Start of program headers: "));
2115 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2116 printf (_(" (bytes into file)\n Start of section headers: "));
2117 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2118 printf (_(" (bytes into file)\n"));
2120 printf (_(" Flags: 0x%lx%s\n"),
2121 (unsigned long) elf_header.e_flags,
2122 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2123 printf (_(" Size of this header: %ld (bytes)\n"),
2124 (long) elf_header.e_ehsize);
2125 printf (_(" Size of program headers: %ld (bytes)\n"),
2126 (long) elf_header.e_phentsize);
2127 printf (_(" Number of program headers: %ld\n"),
2128 (long) elf_header.e_phnum);
2129 printf (_(" Size of section headers: %ld (bytes)\n"),
2130 (long) elf_header.e_shentsize);
2131 printf (_(" Number of section headers: %ld\n"),
2132 (long) elf_header.e_shnum);
2133 printf (_(" Section header string table index: %ld\n"),
2134 (long) elf_header.e_shstrndx);
2142 get_32bit_program_headers (file, program_headers)
2144 Elf_Internal_Phdr * program_headers;
2146 Elf32_External_Phdr * phdrs;
2147 Elf32_External_Phdr * external;
2148 Elf32_Internal_Phdr * internal;
2151 GET_DATA_ALLOC (elf_header.e_phoff,
2152 elf_header.e_phentsize * elf_header.e_phnum,
2153 phdrs, Elf32_External_Phdr *, "program headers");
2155 for (i = 0, internal = program_headers, external = phdrs;
2156 i < elf_header.e_phnum;
2157 i ++, internal ++, external ++)
2159 internal->p_type = BYTE_GET (external->p_type);
2160 internal->p_offset = BYTE_GET (external->p_offset);
2161 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2162 internal->p_paddr = BYTE_GET (external->p_paddr);
2163 internal->p_filesz = BYTE_GET (external->p_filesz);
2164 internal->p_memsz = BYTE_GET (external->p_memsz);
2165 internal->p_flags = BYTE_GET (external->p_flags);
2166 internal->p_align = BYTE_GET (external->p_align);
2175 get_64bit_program_headers (file, program_headers)
2177 Elf_Internal_Phdr * program_headers;
2179 Elf64_External_Phdr * phdrs;
2180 Elf64_External_Phdr * external;
2181 Elf64_Internal_Phdr * internal;
2184 GET_DATA_ALLOC (elf_header.e_phoff,
2185 elf_header.e_phentsize * elf_header.e_phnum,
2186 phdrs, Elf64_External_Phdr *, "program headers");
2188 for (i = 0, internal = program_headers, external = phdrs;
2189 i < elf_header.e_phnum;
2190 i ++, internal ++, external ++)
2192 internal->p_type = BYTE_GET (external->p_type);
2193 internal->p_flags = BYTE_GET (external->p_flags);
2194 internal->p_offset = BYTE_GET8 (external->p_offset);
2195 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2196 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2197 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2198 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2199 internal->p_align = BYTE_GET8 (external->p_align);
2208 process_program_headers (file)
2211 Elf_Internal_Phdr * program_headers;
2212 Elf_Internal_Phdr * segment;
2215 if (elf_header.e_phnum == 0)
2218 printf (_("\nThere are no program headers in this file.\n"));
2222 if (do_segments && !do_header)
2224 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2225 printf (_("Entry point "));
2226 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2227 printf (_("\nThere are %d program headers, starting at offset "),
2228 elf_header.e_phnum);
2229 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2233 program_headers = (Elf_Internal_Phdr *) malloc
2234 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2236 if (program_headers == NULL)
2238 error (_("Out of memory\n"));
2243 i = get_32bit_program_headers (file, program_headers);
2245 i = get_64bit_program_headers (file, program_headers);
2249 free (program_headers);
2256 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2260 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2264 (_(" Type Offset VirtAddr PhysAddr\n"));
2266 (_(" FileSiz MemSiz Flags Align\n"));
2274 for (i = 0, segment = program_headers;
2275 i < elf_header.e_phnum;
2280 printf (" %-14.14s ", get_segment_type (segment->p_type));
2284 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2285 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2286 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2287 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2288 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2290 (segment->p_flags & PF_R ? 'R' : ' '),
2291 (segment->p_flags & PF_W ? 'W' : ' '),
2292 (segment->p_flags & PF_X ? 'E' : ' '));
2293 printf ("%#lx", (unsigned long) segment->p_align);
2297 print_vma (segment->p_offset, FULL_HEX);
2299 print_vma (segment->p_vaddr, FULL_HEX);
2301 print_vma (segment->p_paddr, FULL_HEX);
2303 print_vma (segment->p_filesz, FULL_HEX);
2305 print_vma (segment->p_memsz, FULL_HEX);
2307 (segment->p_flags & PF_R ? 'R' : ' '),
2308 (segment->p_flags & PF_W ? 'W' : ' '),
2309 (segment->p_flags & PF_X ? 'E' : ' '));
2310 print_vma (segment->p_align, HEX);
2314 switch (segment->p_type)
2318 loadaddr = (segment->p_vaddr & 0xfffff000)
2319 - (segment->p_offset & 0xfffff000);
2324 error (_("more than one dynamic segment\n"));
2326 dynamic_addr = segment->p_offset;
2327 dynamic_size = segment->p_filesz;
2331 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2332 error (_("Unable to find program interpreter name\n"));
2335 program_interpreter[0] = 0;
2336 fscanf (file, "%63s", program_interpreter);
2339 printf (_("\n [Requesting program interpreter: %s]"),
2340 program_interpreter);
2346 putc ('\n', stdout);
2355 if (do_segments && section_headers != NULL)
2357 printf (_("\n Section to Segment mapping:\n"));
2358 printf (_(" Segment Sections...\n"));
2360 assert (string_table != NULL);
2362 for (i = 0; i < elf_header.e_phnum; i++)
2365 Elf_Internal_Shdr * section;
2367 segment = program_headers + i;
2368 section = section_headers;
2370 printf (" %2.2d ", i);
2372 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2374 if (section->sh_size > 0
2375 /* Compare allocated sections by VMA, unallocated
2376 sections by file offset. */
2377 && (section->sh_flags & SHF_ALLOC
2378 ? (section->sh_addr >= segment->p_vaddr
2379 && section->sh_addr + section->sh_size
2380 <= segment->p_vaddr + segment->p_memsz)
2381 : ((bfd_vma) section->sh_offset >= segment->p_offset
2382 && (section->sh_offset + section->sh_size
2383 <= segment->p_offset + segment->p_filesz))))
2384 printf ("%s ", SECTION_NAME (section));
2391 free (program_headers);
2398 get_32bit_section_headers (file)
2401 Elf32_External_Shdr * shdrs;
2402 Elf32_Internal_Shdr * internal;
2405 GET_DATA_ALLOC (elf_header.e_shoff,
2406 elf_header.e_shentsize * elf_header.e_shnum,
2407 shdrs, Elf32_External_Shdr *, "section headers");
2409 section_headers = (Elf_Internal_Shdr *) malloc
2410 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2412 if (section_headers == NULL)
2414 error (_("Out of memory\n"));
2418 for (i = 0, internal = section_headers;
2419 i < elf_header.e_shnum;
2422 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2423 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2424 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2425 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2426 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2427 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2428 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2429 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2430 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2431 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2440 get_64bit_section_headers (file)
2443 Elf64_External_Shdr * shdrs;
2444 Elf64_Internal_Shdr * internal;
2447 GET_DATA_ALLOC (elf_header.e_shoff,
2448 elf_header.e_shentsize * elf_header.e_shnum,
2449 shdrs, Elf64_External_Shdr *, "section headers");
2451 section_headers = (Elf_Internal_Shdr *) malloc
2452 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2454 if (section_headers == NULL)
2456 error (_("Out of memory\n"));
2460 for (i = 0, internal = section_headers;
2461 i < elf_header.e_shnum;
2464 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2465 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2466 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2467 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2468 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2469 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2470 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2471 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2472 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2473 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2481 static Elf_Internal_Sym *
2482 get_32bit_elf_symbols (file, offset, number)
2484 unsigned long offset;
2485 unsigned long number;
2487 Elf32_External_Sym * esyms;
2488 Elf_Internal_Sym * isyms;
2489 Elf_Internal_Sym * psym;
2492 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2493 esyms, Elf32_External_Sym *, "symbols");
2495 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2499 error (_("Out of memory\n"));
2505 for (j = 0, psym = isyms;
2509 psym->st_name = BYTE_GET (esyms[j].st_name);
2510 psym->st_value = BYTE_GET (esyms[j].st_value);
2511 psym->st_size = BYTE_GET (esyms[j].st_size);
2512 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2513 psym->st_info = BYTE_GET (esyms[j].st_info);
2514 psym->st_other = BYTE_GET (esyms[j].st_other);
2522 static Elf_Internal_Sym *
2523 get_64bit_elf_symbols (file, offset, number)
2525 unsigned long offset;
2526 unsigned long number;
2528 Elf64_External_Sym * esyms;
2529 Elf_Internal_Sym * isyms;
2530 Elf_Internal_Sym * psym;
2533 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2534 esyms, Elf64_External_Sym *, "symbols");
2536 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2540 error (_("Out of memory\n"));
2546 for (j = 0, psym = isyms;
2550 psym->st_name = BYTE_GET (esyms[j].st_name);
2551 psym->st_info = BYTE_GET (esyms[j].st_info);
2552 psym->st_other = BYTE_GET (esyms[j].st_other);
2553 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2554 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2555 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2564 get_elf_section_flags (sh_flags)
2567 static char buff [32];
2575 flag = sh_flags & - sh_flags;
2580 case SHF_WRITE: strcat (buff, "W"); break;
2581 case SHF_ALLOC: strcat (buff, "A"); break;
2582 case SHF_EXECINSTR: strcat (buff, "X"); break;
2583 case SHF_MERGE: strcat (buff, "M"); break;
2584 case SHF_STRINGS: strcat (buff, "S"); break;
2585 case SHF_INFO_LINK: strcat (buff, "I"); break;
2586 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2587 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2590 if (flag & SHF_MASKOS)
2593 sh_flags &= ~ SHF_MASKOS;
2595 else if (flag & SHF_MASKPROC)
2598 sh_flags &= ~ SHF_MASKPROC;
2610 process_section_headers (file)
2613 Elf_Internal_Shdr * section;
2616 section_headers = NULL;
2618 if (elf_header.e_shnum == 0)
2621 printf (_("\nThere are no sections in this file.\n"));
2626 if (do_sections && !do_header)
2627 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2628 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2632 if (! get_32bit_section_headers (file))
2635 else if (! get_64bit_section_headers (file))
2638 /* Read in the string table, so that we have names to display. */
2639 section = section_headers + elf_header.e_shstrndx;
2641 if (section->sh_size != 0)
2643 unsigned long string_table_offset;
2645 string_table_offset = section->sh_offset;
2647 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2648 string_table, char *, "string table");
2651 /* Scan the sections for the dynamic symbol table
2652 and dynamic string table and debug sections. */
2653 dynamic_symbols = NULL;
2654 dynamic_strings = NULL;
2655 dynamic_syminfo = NULL;
2657 for (i = 0, section = section_headers;
2658 i < elf_header.e_shnum;
2661 char * name = SECTION_NAME (section);
2663 if (section->sh_type == SHT_DYNSYM)
2665 if (dynamic_symbols != NULL)
2667 error (_("File contains multiple dynamic symbol tables\n"));
2671 num_dynamic_syms = section->sh_size / section->sh_entsize;
2673 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2675 else if (section->sh_type == SHT_STRTAB
2676 && strcmp (name, ".dynstr") == 0)
2678 if (dynamic_strings != NULL)
2680 error (_("File contains multiple dynamic string tables\n"));
2684 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2685 dynamic_strings, char *, "dynamic strings");
2687 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2688 || do_debug_lines || do_debug_pubnames || do_debug_aranges)
2689 && strncmp (name, ".debug_", 7) == 0)
2694 || (do_debug_info && (strcmp (name, "info") == 0))
2695 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2696 || (do_debug_lines && (strcmp (name, "line") == 0))
2697 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2698 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2700 request_dump (i, DEBUG_DUMP);
2707 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2711 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2714 printf (_(" [Nr] Name Type Address Offset\n"));
2715 printf (_(" Size EntSize Flags Link Info Align\n"));
2718 for (i = 0, section = section_headers;
2719 i < elf_header.e_shnum;
2722 printf (" [%2d] %-17.17s %-15.15s ",
2724 SECTION_NAME (section),
2725 get_section_type_name (section->sh_type));
2729 print_vma (section->sh_addr, LONG_HEX);
2731 printf ( " %6.6lx %6.6lx %2.2lx",
2732 (unsigned long) section->sh_offset,
2733 (unsigned long) section->sh_size,
2734 (unsigned long) section->sh_entsize);
2736 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2738 printf (" %2ld %3lx %ld\n",
2739 (unsigned long) section->sh_link,
2740 (unsigned long) section->sh_info,
2741 (unsigned long) section->sh_addralign);
2746 print_vma (section->sh_addr, LONG_HEX);
2747 printf (" %8.8lx", section->sh_offset);
2749 print_vma (section->sh_size, LONG_HEX);
2751 print_vma (section->sh_entsize, LONG_HEX);
2753 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2755 printf (" %2ld %3lx %ld\n",
2756 (unsigned long) section->sh_link,
2757 (unsigned long) section->sh_info,
2758 (unsigned long) section->sh_addralign);
2762 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2763 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2764 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2769 /* Process the reloc section. */
2771 process_relocs (file)
2774 unsigned long rel_size;
2775 unsigned long rel_offset;
2781 if (do_using_dynamic)
2783 int is_rela = FALSE;
2788 if (dynamic_info[DT_REL])
2790 rel_offset = dynamic_info[DT_REL];
2791 rel_size = dynamic_info[DT_RELSZ];
2794 else if (dynamic_info [DT_RELA])
2796 rel_offset = dynamic_info[DT_RELA];
2797 rel_size = dynamic_info[DT_RELASZ];
2800 else if (dynamic_info[DT_JMPREL])
2802 rel_offset = dynamic_info[DT_JMPREL];
2803 rel_size = dynamic_info[DT_PLTRELSZ];
2805 switch (dynamic_info[DT_PLTREL])
2822 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2823 rel_offset, rel_size);
2825 dump_relocations (file, rel_offset - loadaddr, rel_size,
2826 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2829 printf (_("\nThere are no dynamic relocations in this file.\n"));
2833 Elf32_Internal_Shdr * section;
2837 for (i = 0, section = section_headers;
2838 i < elf_header.e_shnum;
2841 if ( section->sh_type != SHT_RELA
2842 && section->sh_type != SHT_REL)
2845 rel_offset = section->sh_offset;
2846 rel_size = section->sh_size;
2850 Elf32_Internal_Shdr * strsec;
2851 Elf32_Internal_Shdr * symsec;
2852 Elf_Internal_Sym * symtab;
2855 unsigned long nsyms;
2857 printf (_("\nRelocation section "));
2859 if (string_table == NULL)
2860 printf ("%d", section->sh_name);
2862 printf ("'%s'", SECTION_NAME (section));
2864 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2865 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2867 symsec = section_headers + section->sh_link;
2869 nsyms = symsec->sh_size / symsec->sh_entsize;
2870 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2875 strsec = section_headers + symsec->sh_link;
2877 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2878 char *, "string table");
2880 is_rela = section->sh_type == SHT_RELA;
2882 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2892 printf (_("\nThere are no relocations in this file.\n"));
2900 dynamic_segment_mips_val (entry)
2901 Elf_Internal_Dyn * entry;
2903 switch (entry->d_tag)
2906 if (entry->d_un.d_val == 0)
2910 static const char * opts[] =
2912 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2913 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2914 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2915 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2920 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2921 if (entry->d_un.d_val & (1 << cnt))
2923 printf ("%s%s", first ? "" : " ", opts[cnt]);
2930 case DT_MIPS_IVERSION:
2931 if (dynamic_strings != NULL)
2932 printf ("Interface Version: %s\n",
2933 dynamic_strings + entry->d_un.d_val);
2935 printf ("%ld\n", (long) entry->d_un.d_ptr);
2938 case DT_MIPS_TIME_STAMP:
2941 time_t time = entry->d_un.d_val;
2942 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
2943 printf ("Time Stamp: %s\n", timebuf);
2947 case DT_MIPS_RLD_VERSION:
2948 case DT_MIPS_LOCAL_GOTNO:
2949 case DT_MIPS_CONFLICTNO:
2950 case DT_MIPS_LIBLISTNO:
2951 case DT_MIPS_SYMTABNO:
2952 case DT_MIPS_UNREFEXTNO:
2953 case DT_MIPS_HIPAGENO:
2954 case DT_MIPS_DELTA_CLASS_NO:
2955 case DT_MIPS_DELTA_INSTANCE_NO:
2956 case DT_MIPS_DELTA_RELOC_NO:
2957 case DT_MIPS_DELTA_SYM_NO:
2958 case DT_MIPS_DELTA_CLASSSYM_NO:
2959 case DT_MIPS_COMPACT_SIZE:
2960 printf ("%ld\n", (long) entry->d_un.d_ptr);
2964 printf ("%#lx\n", (long) entry->d_un.d_ptr);
2970 dynamic_segment_parisc_val (entry)
2971 Elf_Internal_Dyn * entry;
2973 switch (entry->d_tag)
2975 case DT_HP_DLD_FLAGS:
2984 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
2985 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
2986 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
2987 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
2988 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
2989 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
2990 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
2991 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
2992 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
2993 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
2994 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
2998 bfd_vma val = entry->d_un.d_val;
3000 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3001 if (val & flags[cnt].bit)
3005 fputs (flags[cnt].str, stdout);
3007 val ^= flags[cnt].bit;
3010 if (val != 0 || first)
3014 print_vma (val, HEX);
3020 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3026 get_32bit_dynamic_segment (file)
3029 Elf32_External_Dyn * edyn;
3030 Elf_Internal_Dyn * entry;
3033 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3034 edyn, Elf32_External_Dyn *, "dynamic segment");
3036 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3037 how large this .dynamic is now. We can do this even before the byte
3038 swapping since the DT_NULL tag is recognizable. */
3040 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3043 dynamic_segment = (Elf_Internal_Dyn *)
3044 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3046 if (dynamic_segment == NULL)
3048 error (_("Out of memory\n"));
3053 for (i = 0, entry = dynamic_segment;
3057 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3058 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3067 get_64bit_dynamic_segment (file)
3070 Elf64_External_Dyn * edyn;
3071 Elf_Internal_Dyn * entry;
3074 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3075 edyn, Elf64_External_Dyn *, "dynamic segment");
3077 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3078 how large this .dynamic is now. We can do this even before the byte
3079 swapping since the DT_NULL tag is recognizable. */
3081 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3084 dynamic_segment = (Elf_Internal_Dyn *)
3085 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3087 if (dynamic_segment == NULL)
3089 error (_("Out of memory\n"));
3094 for (i = 0, entry = dynamic_segment;
3098 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3099 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3108 get_dynamic_flags (flags)
3111 static char buff [64];
3116 flag = flags & - flags;
3121 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3122 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3123 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3124 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3125 default: strcat (buff, "unknown "); break;
3131 /* Parse and display the contents of the dynamic segment. */
3133 process_dynamic_segment (file)
3136 Elf_Internal_Dyn * entry;
3139 if (dynamic_size == 0)
3142 printf (_("\nThere is no dynamic segment in this file.\n"));
3149 if (! get_32bit_dynamic_segment (file))
3152 else if (! get_64bit_dynamic_segment (file))
3155 /* Find the appropriate symbol table. */
3156 if (dynamic_symbols == NULL)
3158 for (i = 0, entry = dynamic_segment;
3162 unsigned long offset;
3164 if (entry->d_tag != DT_SYMTAB)
3167 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3169 /* Since we do not know how big the symbol table is,
3170 we default to reading in the entire file (!) and
3171 processing that. This is overkill, I know, but it
3173 offset = entry->d_un.d_val - loadaddr;
3175 if (fseek (file, 0, SEEK_END))
3176 error (_("Unable to seek to end of file!"));
3179 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3181 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3183 if (num_dynamic_syms < 1)
3185 error (_("Unable to determine the number of symbols to load\n"));
3189 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3193 /* Similarly find a string table. */
3194 if (dynamic_strings == NULL)
3196 for (i = 0, entry = dynamic_segment;
3200 unsigned long offset;
3203 if (entry->d_tag != DT_STRTAB)
3206 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3208 /* Since we do not know how big the string table is,
3209 we default to reading in the entire file (!) and
3210 processing that. This is overkill, I know, but it
3213 offset = entry->d_un.d_val - loadaddr;
3214 if (fseek (file, 0, SEEK_END))
3215 error (_("Unable to seek to end of file\n"));
3216 str_tab_len = ftell (file) - offset;
3218 if (str_tab_len < 1)
3221 (_("Unable to determine the length of the dynamic string table\n"));
3225 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3226 "dynamic string table");
3232 /* And find the syminfo section if available. */
3233 if (dynamic_syminfo == NULL)
3235 unsigned int syminsz = 0;
3237 for (i = 0, entry = dynamic_segment;
3241 if (entry->d_tag == DT_SYMINENT)
3243 /* Note: these braces are necessary to avoid a syntax
3244 error from the SunOS4 C compiler. */
3245 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3247 else if (entry->d_tag == DT_SYMINSZ)
3248 syminsz = entry->d_un.d_val;
3249 else if (entry->d_tag == DT_SYMINFO)
3250 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3253 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3255 Elf_External_Syminfo * extsyminfo;
3256 Elf_Internal_Syminfo * syminfo;
3258 /* There is a syminfo section. Read the data. */
3259 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3260 Elf_External_Syminfo *, "symbol information");
3262 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3263 if (dynamic_syminfo == NULL)
3265 error (_("Out of memory\n"));
3269 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3270 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3273 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3274 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3281 if (do_dynamic && dynamic_addr)
3282 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3283 dynamic_addr, (long) dynamic_size);
3285 printf (_(" Tag Type Name/Value\n"));
3287 for (i = 0, entry = dynamic_segment;
3296 print_vma (entry->d_tag, FULL_HEX);
3297 dtype = get_dynamic_type (entry->d_tag);
3298 printf (" (%s)%*s", dtype,
3299 ((is_32bit_elf ? 27 : 19)
3300 - (int) strlen (dtype)),
3304 switch (entry->d_tag)
3308 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3315 if (entry->d_tag == DT_AUXILIARY)
3316 printf (_("Auxiliary library"));
3318 printf (_("Filter library"));
3320 if (dynamic_strings)
3321 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3325 print_vma (entry->d_un.d_val, PREFIX_HEX);
3334 printf (_("Flags:"));
3335 if (entry->d_un.d_val == 0)
3336 printf (_(" None\n"));
3339 unsigned long int val = entry->d_un.d_val;
3340 if (val & DTF_1_PARINIT)
3342 printf (" PARINIT");
3343 val ^= DTF_1_PARINIT;
3346 printf (" %lx", val);
3355 printf (_("Flags:"));
3356 if (entry->d_un.d_val == 0)
3357 printf (_(" None\n"));
3360 unsigned long int val = entry->d_un.d_val;
3361 if (val & DF_P1_LAZYLOAD)
3363 printf (" LAZYLOAD");
3364 val ^= DF_P1_LAZYLOAD;
3366 if (val & DF_P1_GROUPPERM)
3368 printf (" GROUPPERM");
3369 val ^= DF_P1_GROUPPERM;
3372 printf (" %lx", val);
3381 printf (_("Flags:"));
3382 if (entry->d_un.d_val == 0)
3383 printf (_(" None\n"));
3386 unsigned long int val = entry->d_un.d_val;
3392 if (val & DF_1_GLOBAL)
3397 if (val & DF_1_GROUP)
3402 if (val & DF_1_NODELETE)
3404 printf (" NODELETE");
3405 val ^= DF_1_NODELETE;
3407 if (val & DF_1_LOADFLTR)
3409 printf (" LOADFLTR");
3410 val ^= DF_1_LOADFLTR;
3412 if (val & DF_1_INITFIRST)
3414 printf (" INITFIRST");
3415 val ^= DF_1_INITFIRST;
3417 if (val & DF_1_NOOPEN)
3422 if (val & DF_1_ORIGIN)
3427 if (val & DF_1_DIRECT)
3432 if (val & DF_1_TRANS)
3437 if (val & DF_1_INTERPOSE)
3439 printf (" INTERPOSE");
3440 val ^= DF_1_INTERPOSE;
3443 printf (" %lx", val);
3451 puts (get_dynamic_type (entry->d_un.d_val));
3470 dynamic_info[entry->d_tag] = entry->d_un.d_val;
3476 if (dynamic_strings == NULL)
3479 name = dynamic_strings + entry->d_un.d_val;
3483 switch (entry->d_tag)
3486 printf (_("Shared library: [%s]"), name);
3488 if (strcmp (name, program_interpreter) == 0)
3489 printf (_(" program interpreter"));
3493 printf (_("Library soname: [%s]"), name);
3497 printf (_("Library rpath: [%s]"), name);
3501 print_vma (entry->d_un.d_val, PREFIX_HEX);
3506 print_vma (entry->d_un.d_val, PREFIX_HEX);
3522 case DT_INIT_ARRAYSZ:
3523 case DT_FINI_ARRAYSZ:
3526 print_vma (entry->d_un.d_val, UNSIGNED);
3527 printf (" (bytes)\n");
3537 print_vma (entry->d_un.d_val, UNSIGNED);
3550 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3554 name = dynamic_strings + entry->d_un.d_val;
3558 printf (_("Not needed object: [%s]\n"), name);
3563 print_vma (entry->d_un.d_val, PREFIX_HEX);
3569 /* The value of this entry is ignored. */
3573 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3574 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3579 switch (elf_header.e_machine)
3582 case EM_MIPS_RS4_BE:
3583 dynamic_segment_mips_val (entry);
3586 dynamic_segment_parisc_val (entry);
3589 print_vma (entry->d_un.d_val, PREFIX_HEX);
3601 get_ver_flags (flags)
3604 static char buff [32];
3611 if (flags & VER_FLG_BASE)
3612 strcat (buff, "BASE ");
3614 if (flags & VER_FLG_WEAK)
3616 if (flags & VER_FLG_BASE)
3617 strcat (buff, "| ");
3619 strcat (buff, "WEAK ");
3622 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3623 strcat (buff, "| <unknown>");
3628 /* Display the contents of the version sections. */
3630 process_version_sections (file)
3633 Elf32_Internal_Shdr * section;
3640 for (i = 0, section = section_headers;
3641 i < elf_header.e_shnum;
3644 switch (section->sh_type)
3646 case SHT_GNU_verdef:
3648 Elf_External_Verdef * edefs;
3655 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3656 SECTION_NAME (section), section->sh_info);
3658 printf (_(" Addr: 0x"));
3659 printf_vma (section->sh_addr);
3660 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3661 (unsigned long) section->sh_offset, section->sh_link,
3662 SECTION_NAME (section_headers + section->sh_link));
3664 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3665 edefs, Elf_External_Verdef *,
3666 "version definition section");
3668 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3671 Elf_External_Verdef * edef;
3672 Elf_Internal_Verdef ent;
3673 Elf_External_Verdaux * eaux;
3674 Elf_Internal_Verdaux aux;
3678 vstart = ((char *) edefs) + idx;
3680 edef = (Elf_External_Verdef *) vstart;
3682 ent.vd_version = BYTE_GET (edef->vd_version);
3683 ent.vd_flags = BYTE_GET (edef->vd_flags);
3684 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
3685 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
3686 ent.vd_hash = BYTE_GET (edef->vd_hash);
3687 ent.vd_aux = BYTE_GET (edef->vd_aux);
3688 ent.vd_next = BYTE_GET (edef->vd_next);
3690 printf (_(" %#06x: Rev: %d Flags: %s"),
3691 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3693 printf (_(" Index: %d Cnt: %d "),
3694 ent.vd_ndx, ent.vd_cnt);
3696 vstart += ent.vd_aux;
3698 eaux = (Elf_External_Verdaux *) vstart;
3700 aux.vda_name = BYTE_GET (eaux->vda_name);
3701 aux.vda_next = BYTE_GET (eaux->vda_next);
3703 if (dynamic_strings)
3704 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3706 printf (_("Name index: %ld\n"), aux.vda_name);
3708 isum = idx + ent.vd_aux;
3710 for (j = 1; j < ent.vd_cnt; j ++)
3712 isum += aux.vda_next;
3713 vstart += aux.vda_next;
3715 eaux = (Elf_External_Verdaux *) vstart;
3717 aux.vda_name = BYTE_GET (eaux->vda_name);
3718 aux.vda_next = BYTE_GET (eaux->vda_next);
3720 if (dynamic_strings)
3721 printf (_(" %#06x: Parent %d: %s\n"),
3722 isum, j, dynamic_strings + aux.vda_name);
3724 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3725 isum, j, aux.vda_name);
3735 case SHT_GNU_verneed:
3737 Elf_External_Verneed * eneed;
3743 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3744 SECTION_NAME (section), section->sh_info);
3746 printf (_(" Addr: 0x"));
3747 printf_vma (section->sh_addr);
3748 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3749 (unsigned long) section->sh_offset, section->sh_link,
3750 SECTION_NAME (section_headers + section->sh_link));
3752 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3753 eneed, Elf_External_Verneed *,
3754 "version need section");
3756 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3758 Elf_External_Verneed * entry;
3759 Elf_Internal_Verneed ent;
3764 vstart = ((char *) eneed) + idx;
3766 entry = (Elf_External_Verneed *) vstart;
3768 ent.vn_version = BYTE_GET (entry->vn_version);
3769 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
3770 ent.vn_file = BYTE_GET (entry->vn_file);
3771 ent.vn_aux = BYTE_GET (entry->vn_aux);
3772 ent.vn_next = BYTE_GET (entry->vn_next);
3774 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
3776 if (dynamic_strings)
3777 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
3779 printf (_(" File: %lx"), ent.vn_file);
3781 printf (_(" Cnt: %d\n"), ent.vn_cnt);
3783 vstart += ent.vn_aux;
3785 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3787 Elf_External_Vernaux * eaux;
3788 Elf_Internal_Vernaux aux;
3790 eaux = (Elf_External_Vernaux *) vstart;
3792 aux.vna_hash = BYTE_GET (eaux->vna_hash);
3793 aux.vna_flags = BYTE_GET (eaux->vna_flags);
3794 aux.vna_other = BYTE_GET (eaux->vna_other);
3795 aux.vna_name = BYTE_GET (eaux->vna_name);
3796 aux.vna_next = BYTE_GET (eaux->vna_next);
3798 if (dynamic_strings)
3799 printf (_(" %#06x: Name: %s"),
3800 isum, dynamic_strings + aux.vna_name);
3802 printf (_(" %#06x: Name index: %lx"),
3803 isum, aux.vna_name);
3805 printf (_(" Flags: %s Version: %d\n"),
3806 get_ver_flags (aux.vna_flags), aux.vna_other);
3808 isum += aux.vna_next;
3809 vstart += aux.vna_next;
3819 case SHT_GNU_versym:
3821 Elf32_Internal_Shdr * link_section;
3824 unsigned char * edata;
3825 unsigned short * data;
3827 Elf_Internal_Sym * symbols;
3828 Elf32_Internal_Shdr * string_sec;
3830 link_section = section_headers + section->sh_link;
3831 total = section->sh_size / section->sh_entsize;
3835 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3836 link_section->sh_size / link_section->sh_entsize);
3838 string_sec = section_headers + link_section->sh_link;
3840 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3841 strtab, char *, "version string table");
3843 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3844 SECTION_NAME (section), total);
3846 printf (_(" Addr: "));
3847 printf_vma (section->sh_addr);
3848 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3849 (unsigned long) section->sh_offset, section->sh_link,
3850 SECTION_NAME (link_section));
3852 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3854 total * sizeof (short), edata,
3855 unsigned char *, "version symbol data");
3857 data = (unsigned short *) malloc (total * sizeof (short));
3859 for (cnt = total; cnt --;)
3860 data [cnt] = byte_get (edata + cnt * sizeof (short),
3865 for (cnt = 0; cnt < total; cnt += 4)
3870 printf (" %03x:", cnt);
3872 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3873 switch (data [cnt + j])
3876 fputs (_(" 0 (*local*) "), stdout);
3880 fputs (_(" 1 (*global*) "), stdout);
3884 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
3885 data [cnt + j] & 0x8000 ? 'h' : ' ');
3887 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
3888 && section_headers[symbols [cnt + j].st_shndx].sh_type
3891 /* We must test both. */
3892 Elf_Internal_Verneed ivn;
3893 unsigned long offset;
3895 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3900 Elf_External_Verneed evn;
3901 Elf_External_Vernaux evna;
3902 Elf_Internal_Vernaux ivna;
3903 unsigned long vna_off;
3905 GET_DATA (offset, evn, "version need");
3907 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3908 ivn.vn_next = BYTE_GET (evn.vn_next);
3910 vna_off = offset + ivn.vn_aux;
3914 GET_DATA (vna_off, evna,
3915 "version need aux (1)");
3917 ivna.vna_next = BYTE_GET (evna.vna_next);
3918 ivna.vna_other = BYTE_GET (evna.vna_other);
3920 vna_off += ivna.vna_next;
3922 while (ivna.vna_other != data [cnt + j]
3923 && ivna.vna_next != 0);
3925 if (ivna.vna_other == data [cnt + j])
3927 ivna.vna_name = BYTE_GET (evna.vna_name);
3929 name = strtab + ivna.vna_name;
3930 nn += printf ("(%s%-*s",
3932 12 - (int) strlen (name),
3936 else if (ivn.vn_next == 0)
3938 if (data [cnt + j] != 0x8001)
3940 Elf_Internal_Verdef ivd;
3941 Elf_External_Verdef evd;
3943 offset = version_info
3944 [DT_VERSIONTAGIDX (DT_VERDEF)]
3949 GET_DATA (offset, evd,
3950 "version definition");
3952 ivd.vd_next = BYTE_GET (evd.vd_next);
3953 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
3955 offset += ivd.vd_next;
3958 != (data [cnt + j] & 0x7fff)
3959 && ivd.vd_next != 0);
3962 == (data [cnt + j] & 0x7fff))
3964 Elf_External_Verdaux evda;
3965 Elf_Internal_Verdaux ivda;
3967 ivd.vd_aux = BYTE_GET (evd.vd_aux);
3969 GET_DATA (offset + ivd.vd_aux, evda,
3970 "version definition aux");
3973 BYTE_GET (evda.vda_name);
3975 name = strtab + ivda.vda_name;
3979 12 - (int) strlen (name),
3987 offset += ivn.vn_next;
3989 while (ivn.vn_next);
3991 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
3993 Elf_Internal_Verneed ivn;
3994 unsigned long offset;
3996 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4001 Elf_Internal_Vernaux ivna;
4002 Elf_External_Verneed evn;
4003 Elf_External_Vernaux evna;
4004 unsigned long a_off;
4006 GET_DATA (offset, evn, "version need");
4008 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4009 ivn.vn_next = BYTE_GET (evn.vn_next);
4011 a_off = offset + ivn.vn_aux;
4015 GET_DATA (a_off, evna,
4016 "version need aux (2)");
4018 ivna.vna_next = BYTE_GET (evna.vna_next);
4019 ivna.vna_other = BYTE_GET (evna.vna_other);
4021 a_off += ivna.vna_next;
4023 while (ivna.vna_other != data [cnt + j]
4024 && ivna.vna_next != 0);
4026 if (ivna.vna_other == data [cnt + j])
4028 ivna.vna_name = BYTE_GET (evna.vna_name);
4030 name = strtab + ivna.vna_name;
4031 nn += printf ("(%s%-*s",
4033 12 - (int) strlen (name),
4038 offset += ivn.vn_next;
4040 while (ivn.vn_next);
4042 else if (data [cnt + j] != 0x8001)
4044 Elf_Internal_Verdef ivd;
4045 Elf_External_Verdef evd;
4046 unsigned long offset;
4048 offset = version_info
4049 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4053 GET_DATA (offset, evd, "version def");
4055 ivd.vd_next = BYTE_GET (evd.vd_next);
4056 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4058 offset += ivd.vd_next;
4060 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4061 && ivd.vd_next != 0);
4063 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4065 Elf_External_Verdaux evda;
4066 Elf_Internal_Verdaux ivda;
4068 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4070 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4071 evda, "version def aux");
4073 ivda.vda_name = BYTE_GET (evda.vda_name);
4075 name = strtab + ivda.vda_name;
4076 nn += printf ("(%s%-*s",
4078 12 - (int) strlen (name),
4084 printf ("%*c", 18 - nn, ' ');
4102 printf (_("\nNo version information found in this file.\n"));
4108 get_symbol_binding (binding)
4109 unsigned int binding;
4111 static char buff [32];
4115 case STB_LOCAL: return "LOCAL";
4116 case STB_GLOBAL: return "GLOBAL";
4117 case STB_WEAK: return "WEAK";
4119 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4120 sprintf (buff, _("<processor specific>: %d"), binding);
4121 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4122 sprintf (buff, _("<OS specific>: %d"), binding);
4124 sprintf (buff, _("<unknown>: %d"), binding);
4130 get_symbol_type (type)
4133 static char buff [32];
4137 case STT_NOTYPE: return "NOTYPE";
4138 case STT_OBJECT: return "OBJECT";
4139 case STT_FUNC: return "FUNC";
4140 case STT_SECTION: return "SECTION";
4141 case STT_FILE: return "FILE";
4142 case STT_COMMON: return "COMMON";
4144 if (type >= STT_LOPROC && type <= STT_HIPROC)
4146 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4147 return "THUMB_FUNC";
4149 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4152 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4153 return "PARISC_MILLI";
4155 sprintf (buff, _("<processor specific>: %d"), type);
4157 else if (type >= STT_LOOS && type <= STT_HIOS)
4159 if (elf_header.e_machine == EM_PARISC)
4161 if (type == STT_HP_OPAQUE)
4163 if (type == STT_HP_STUB)
4167 sprintf (buff, _("<OS specific>: %d"), type);
4170 sprintf (buff, _("<unknown>: %d"), type);
4176 get_symbol_visibility (visibility)
4177 unsigned int visibility;
4181 case STV_DEFAULT: return "DEFAULT";
4182 case STV_INTERNAL: return "INTERNAL";
4183 case STV_HIDDEN: return "HIDDEN";
4184 case STV_PROTECTED: return "PROTECTED";
4190 get_symbol_index_type (type)
4195 case SHN_UNDEF: return "UND";
4196 case SHN_ABS: return "ABS";
4197 case SHN_COMMON: return "COM";
4199 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4201 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4203 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4207 static char buff [32];
4209 sprintf (buff, "%3d", type);
4216 get_dynamic_data (file, number)
4218 unsigned int number;
4223 e_data = (char *) malloc (number * 4);
4227 error (_("Out of memory\n"));
4231 if (fread (e_data, 4, number, file) != number)
4233 error (_("Unable to read in dynamic data\n"));
4237 i_data = (int *) malloc (number * sizeof (* i_data));
4241 error (_("Out of memory\n"));
4247 i_data [number] = byte_get (e_data + number * 4, 4);
4254 /* Dump the symbol table */
4256 process_symbol_table (file)
4259 Elf32_Internal_Shdr * section;
4264 int * buckets = NULL;
4265 int * chains = NULL;
4267 if (! do_syms && !do_histogram)
4270 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4273 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4275 error (_("Unable to seek to start of dynamic information"));
4279 if (fread (nb, sizeof (nb), 1, file) != 1)
4281 error (_("Failed to read in number of buckets\n"));
4285 if (fread (nc, sizeof (nc), 1, file) != 1)
4287 error (_("Failed to read in number of chains\n"));
4291 nbuckets = byte_get (nb, 4);
4292 nchains = byte_get (nc, 4);
4294 buckets = get_dynamic_data (file, nbuckets);
4295 chains = get_dynamic_data (file, nchains);
4297 if (buckets == NULL || chains == NULL)
4302 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4307 printf (_("\nSymbol table for image:\n"));
4309 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4311 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4313 for (hn = 0; hn < nbuckets; hn++)
4318 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4320 Elf_Internal_Sym * psym;
4322 psym = dynamic_symbols + si;
4324 printf (" %3d %3d: ", si, hn);
4325 print_vma (psym->st_value, LONG_HEX);
4327 print_vma (psym->st_size, DEC_5);
4329 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4330 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4331 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4332 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4333 printf (" %s\n", dynamic_strings + psym->st_name);
4337 else if (do_syms && !do_using_dynamic)
4341 for (i = 0, section = section_headers;
4342 i < elf_header.e_shnum;
4347 Elf_Internal_Sym * symtab;
4348 Elf_Internal_Sym * psym;
4351 if ( section->sh_type != SHT_SYMTAB
4352 && section->sh_type != SHT_DYNSYM)
4355 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4356 SECTION_NAME (section),
4357 (unsigned long) (section->sh_size / section->sh_entsize));
4359 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4361 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4363 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4364 section->sh_size / section->sh_entsize);
4368 if (section->sh_link == elf_header.e_shstrndx)
4369 strtab = string_table;
4372 Elf32_Internal_Shdr * string_sec;
4374 string_sec = section_headers + section->sh_link;
4376 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4377 strtab, char *, "string table");
4380 for (si = 0, psym = symtab;
4381 si < section->sh_size / section->sh_entsize;
4384 printf ("%6d: ", si);
4385 print_vma (psym->st_value, LONG_HEX);
4387 print_vma (psym->st_size, DEC_5);
4388 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4389 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4390 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4391 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4392 printf (" %s", strtab + psym->st_name);
4394 if (section->sh_type == SHT_DYNSYM &&
4395 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4397 unsigned char data[2];
4398 unsigned short vers_data;
4399 unsigned long offset;
4403 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4406 GET_DATA (offset + si * sizeof (vers_data), data,
4409 vers_data = byte_get (data, 2);
4411 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4412 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4415 check_def = (psym->st_shndx != SHN_UNDEF);
4417 if ((vers_data & 0x8000) || vers_data > 1)
4419 if (is_nobits || ! check_def)
4421 Elf_External_Verneed evn;
4422 Elf_Internal_Verneed ivn;
4423 Elf_Internal_Vernaux ivna;
4425 /* We must test both. */
4426 offset = version_info
4427 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4431 unsigned long vna_off;
4433 GET_DATA (offset, evn, "version need");
4435 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4436 ivn.vn_next = BYTE_GET (evn.vn_next);
4438 vna_off = offset + ivn.vn_aux;
4442 Elf_External_Vernaux evna;
4444 GET_DATA (vna_off, evna,
4445 "version need aux (3)");
4447 ivna.vna_other = BYTE_GET (evna.vna_other);
4448 ivna.vna_next = BYTE_GET (evna.vna_next);
4449 ivna.vna_name = BYTE_GET (evna.vna_name);
4451 vna_off += ivna.vna_next;
4453 while (ivna.vna_other != vers_data
4454 && ivna.vna_next != 0);
4456 if (ivna.vna_other == vers_data)
4459 offset += ivn.vn_next;
4461 while (ivn.vn_next != 0);
4463 if (ivna.vna_other == vers_data)
4466 strtab + ivna.vna_name, ivna.vna_other);
4469 else if (! is_nobits)
4470 error (_("bad dynamic symbol"));
4477 if (vers_data != 0x8001)
4479 Elf_Internal_Verdef ivd;
4480 Elf_Internal_Verdaux ivda;
4481 Elf_External_Verdaux evda;
4482 unsigned long offset;
4485 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4490 Elf_External_Verdef evd;
4492 GET_DATA (offset, evd, "version def");
4494 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4495 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4496 ivd.vd_next = BYTE_GET (evd.vd_next);
4498 offset += ivd.vd_next;
4500 while (ivd.vd_ndx != (vers_data & 0x7fff)
4501 && ivd.vd_next != 0);
4503 offset -= ivd.vd_next;
4504 offset += ivd.vd_aux;
4506 GET_DATA (offset, evda, "version def aux");
4508 ivda.vda_name = BYTE_GET (evda.vda_name);
4510 if (psym->st_name != ivda.vda_name)
4511 printf ((vers_data & 0x8000)
4513 strtab + ivda.vda_name);
4523 if (strtab != string_table)
4529 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4531 if (do_histogram && buckets != NULL)
4538 int nzero_counts = 0;
4541 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4543 printf (_(" Length Number %% of total Coverage\n"));
4545 lengths = (int *) calloc (nbuckets, sizeof (int));
4546 if (lengths == NULL)
4548 error (_("Out of memory"));
4551 for (hn = 0; hn < nbuckets; ++hn)
4556 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4559 if (maxlength < ++lengths[hn])
4564 counts = (int *) calloc (maxlength + 1, sizeof (int));
4567 error (_("Out of memory"));
4571 for (hn = 0; hn < nbuckets; ++hn)
4572 ++ counts [lengths [hn]];
4576 printf (" 0 %-10d (%5.1f%%)\n",
4577 counts[0], (counts[0] * 100.0) / nbuckets);
4578 for (si = 1; si <= maxlength; ++si)
4580 nzero_counts += counts[si] * si;
4581 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4582 si, counts[si], (counts[si] * 100.0) / nbuckets,
4583 (nzero_counts * 100.0) / nsyms);
4591 if (buckets != NULL)
4601 process_syminfo (file)
4602 FILE * file ATTRIBUTE_UNUSED;
4606 if (dynamic_syminfo == NULL
4608 /* No syminfo, this is ok. */
4611 /* There better should be a dynamic symbol section. */
4612 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4616 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4617 dynamic_syminfo_offset, dynamic_syminfo_nent);
4619 printf (_(" Num: Name BoundTo Flags\n"));
4620 for (i = 0; i < dynamic_syminfo_nent; ++i)
4622 unsigned short int flags = dynamic_syminfo[i].si_flags;
4624 printf ("%4d: %-30s ", i,
4625 dynamic_strings + dynamic_symbols[i].st_name);
4627 switch (dynamic_syminfo[i].si_boundto)
4629 case SYMINFO_BT_SELF:
4630 fputs ("SELF ", stdout);
4632 case SYMINFO_BT_PARENT:
4633 fputs ("PARENT ", stdout);
4636 if (dynamic_syminfo[i].si_boundto > 0
4637 && dynamic_syminfo[i].si_boundto < dynamic_size)
4640 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4642 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4646 if (flags & SYMINFO_FLG_DIRECT)
4648 if (flags & SYMINFO_FLG_PASSTHRU)
4649 printf (" PASSTHRU");
4650 if (flags & SYMINFO_FLG_COPY)
4652 if (flags & SYMINFO_FLG_LAZYLOAD)
4653 printf (" LAZYLOAD");
4661 #ifdef SUPPORT_DISASSEMBLY
4663 disassemble_section (section, file)
4664 Elf32_Internal_Shdr * section;
4667 printf (_("\nAssembly dump of section %s\n"),
4668 SECTION_NAME (section));
4670 /* XXX -- to be done --- XXX */
4677 dump_section (section, file)
4678 Elf32_Internal_Shdr * section;
4681 bfd_size_type bytes;
4683 unsigned char * data;
4684 unsigned char * start;
4686 bytes = section->sh_size;
4690 printf (_("\nSection '%s' has no data to dump.\n"),
4691 SECTION_NAME (section));
4695 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4697 addr = section->sh_addr;
4699 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4710 lbytes = (bytes > 16 ? 16 : bytes);
4712 printf (" 0x%8.8lx ", (unsigned long) addr);
4714 switch (elf_header.e_ident [EI_DATA])
4718 for (j = 15; j >= 0; j --)
4721 printf ("%2.2x", data [j]);
4731 for (j = 0; j < 16; j++)
4734 printf ("%2.2x", data [j]);
4744 for (j = 0; j < lbytes; j++)
4747 if (k >= ' ' && k < 0x80)
4766 static unsigned long int
4767 read_leb128 (data, length_return, sign)
4768 unsigned char * data;
4769 int * length_return;
4772 unsigned long int result = 0;
4773 unsigned int num_read = 0;
4782 result |= (byte & 0x7f) << shift;
4787 while (byte & 0x80);
4789 if (length_return != NULL)
4790 * length_return = num_read;
4792 if (sign && (shift < 32) && (byte & 0x40))
4793 result |= -1 << shift;
4798 typedef struct State_Machine_Registers
4800 unsigned long address;
4803 unsigned int column;
4807 /* This variable hold the number of the last entry seen
4808 in the File Table. */
4809 unsigned int last_file_entry;
4812 static SMR state_machine_regs;
4815 reset_state_machine (is_stmt)
4818 state_machine_regs.address = 0;
4819 state_machine_regs.file = 1;
4820 state_machine_regs.line = 1;
4821 state_machine_regs.column = 0;
4822 state_machine_regs.is_stmt = is_stmt;
4823 state_machine_regs.basic_block = 0;
4824 state_machine_regs.end_sequence = 0;
4825 state_machine_regs.last_file_entry = 0;
4828 /* Handled an extend line op. Returns true if this is the end
4831 process_extended_line_op (data, is_stmt, pointer_size)
4832 unsigned char * data;
4836 unsigned char op_code;
4839 unsigned char * name;
4842 len = read_leb128 (data, & bytes_read, 0);
4847 warn (_("badly formed extended line op encountered!"));
4852 op_code = * data ++;
4854 printf (_(" Extended opcode %d: "), op_code);
4858 case DW_LNE_end_sequence:
4859 printf (_("End of Sequence\n\n"));
4860 reset_state_machine (is_stmt);
4863 case DW_LNE_set_address:
4864 adr = byte_get (data, pointer_size);
4865 printf (_("set Address to 0x%lx\n"), adr);
4866 state_machine_regs.address = adr;
4869 case DW_LNE_define_file:
4870 printf (_(" define new File Table entry\n"));
4871 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4873 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4875 data += strlen (data) + 1;
4876 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4878 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4880 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4881 printf (_("%s\n\n"), name);
4885 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
4892 /* Size of pointers in the .debug_line section. This information is not
4893 really present in that section. It's obtained before dumping the debug
4894 sections by doing some pre-scan of the .debug_info section. */
4895 static int debug_line_pointer_size = 4;
4898 display_debug_lines (section, start, file)
4899 Elf32_Internal_Shdr * section;
4900 unsigned char * start;
4901 FILE * file ATTRIBUTE_UNUSED;
4903 DWARF2_External_LineInfo * external;
4904 DWARF2_Internal_LineInfo info;
4905 unsigned char * standard_opcodes;
4906 unsigned char * data = start;
4907 unsigned char * end = start + section->sh_size;
4908 unsigned char * end_of_sequence;
4911 printf (_("\nDump of debug contents of section %s:\n\n"),
4912 SECTION_NAME (section));
4916 external = (DWARF2_External_LineInfo *) data;
4918 /* Check the length of the block. */
4919 info.li_length = BYTE_GET (external->li_length);
4920 if (info.li_length > section->sh_size)
4923 (_("The line info appears to be corrupt - the section is too small\n"));
4927 /* Check its version number. */
4928 info.li_version = BYTE_GET (external->li_version);
4929 if (info.li_version != 2)
4931 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4935 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
4936 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
4937 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
4938 info.li_line_base = BYTE_GET (external->li_line_base);
4939 info.li_line_range = BYTE_GET (external->li_line_range);
4940 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
4942 /* Sign extend the line base field. */
4943 info.li_line_base <<= 24;
4944 info.li_line_base >>= 24;
4946 printf (_(" Length: %ld\n"), info.li_length);
4947 printf (_(" DWARF Version: %d\n"), info.li_version);
4948 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
4949 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
4950 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
4951 printf (_(" Line Base: %d\n"), info.li_line_base);
4952 printf (_(" Line Range: %d\n"), info.li_line_range);
4953 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
4955 end_of_sequence = data + info.li_length + sizeof (info.li_length);
4957 reset_state_machine (info.li_default_is_stmt);
4959 /* Display the contents of the Opcodes table. */
4960 standard_opcodes = data + sizeof (* external);
4962 printf (_("\n Opcodes:\n"));
4964 for (i = 1; i < info.li_opcode_base; i++)
4965 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
4967 /* Display the contents of the Directory table. */
4968 data = standard_opcodes + info.li_opcode_base - 1;
4971 printf (_("\n The Directory Table is empty.\n"));
4974 printf (_("\n The Directory Table:\n"));
4978 printf (_(" %s\n"), data);
4980 data += strlen (data) + 1;
4984 /* Skip the NUL at the end of the table. */
4987 /* Display the contents of the File Name table. */
4989 printf (_("\n The File Name Table is empty.\n"));
4992 printf (_("\n The File Name Table:\n"));
4993 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5000 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5003 data += strlen (data) + 1;
5005 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5007 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5009 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5011 printf (_("%s\n"), name);
5015 /* Skip the NUL at the end of the table. */
5018 /* Now display the statements. */
5019 printf (_("\n Line Number Statements:\n"));
5022 while (data < end_of_sequence)
5024 unsigned char op_code;
5028 op_code = * data ++;
5032 case DW_LNS_extended_op:
5033 data += process_extended_line_op (data, info.li_default_is_stmt,
5034 debug_line_pointer_size);
5038 printf (_(" Copy\n"));
5041 case DW_LNS_advance_pc:
5042 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5044 state_machine_regs.address += adv;
5045 printf (_(" Advance PC by %d to %lx\n"), adv,
5046 state_machine_regs.address);
5049 case DW_LNS_advance_line:
5050 adv = read_leb128 (data, & bytes_read, 1);
5052 state_machine_regs.line += adv;
5053 printf (_(" Advance Line by %d to %d\n"), adv,
5054 state_machine_regs.line);
5057 case DW_LNS_set_file:
5058 adv = read_leb128 (data, & bytes_read, 0);
5060 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5062 state_machine_regs.file = adv;
5065 case DW_LNS_set_column:
5066 adv = read_leb128 (data, & bytes_read, 0);
5068 printf (_(" Set column to %d\n"), adv);
5069 state_machine_regs.column = adv;
5072 case DW_LNS_negate_stmt:
5073 adv = state_machine_regs.is_stmt;
5075 printf (_(" Set is_stmt to %d\n"), adv);
5076 state_machine_regs.is_stmt = adv;
5079 case DW_LNS_set_basic_block:
5080 printf (_(" Set basic block\n"));
5081 state_machine_regs.basic_block = 1;
5084 case DW_LNS_const_add_pc:
5085 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5086 * info.li_min_insn_length);
5087 state_machine_regs.address += adv;
5088 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5089 state_machine_regs.address);
5092 case DW_LNS_fixed_advance_pc:
5093 adv = byte_get (data, 2);
5095 state_machine_regs.address += adv;
5096 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5097 adv, state_machine_regs.address);
5101 op_code -= info.li_opcode_base;
5102 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5103 state_machine_regs.address += adv;
5104 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5105 op_code, adv, state_machine_regs.address);
5106 adv = (op_code % info.li_line_range) + info.li_line_base;
5107 state_machine_regs.line += adv;
5108 printf (_(" and Line by %d to %d\n"),
5109 adv, state_machine_regs.line);
5120 display_debug_pubnames (section, start, file)
5121 Elf32_Internal_Shdr * section;
5122 unsigned char * start;
5123 FILE * file ATTRIBUTE_UNUSED;
5125 DWARF2_External_PubNames * external;
5126 DWARF2_Internal_PubNames pubnames;
5127 unsigned char * end;
5129 end = start + section->sh_size;
5131 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5135 unsigned char * data;
5136 unsigned long offset;
5138 external = (DWARF2_External_PubNames *) start;
5140 pubnames.pn_length = BYTE_GET (external->pn_length);
5141 pubnames.pn_version = BYTE_GET (external->pn_version);
5142 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5143 pubnames.pn_size = BYTE_GET (external->pn_size);
5145 data = start + sizeof (* external);
5146 start += pubnames.pn_length + sizeof (external->pn_length);
5148 if (pubnames.pn_version != 2)
5150 warn (_("Only DWARF 2 pubnames are currently supported"));
5154 printf (_(" Length: %ld\n"),
5155 pubnames.pn_length);
5156 printf (_(" Version: %d\n"),
5157 pubnames.pn_version);
5158 printf (_(" Offset into .debug_info section: %ld\n"),
5159 pubnames.pn_offset);
5160 printf (_(" Size of area in .debug_info section: %ld\n"),
5163 printf (_("\n Offset\tName\n"));
5167 offset = byte_get (data, 4);
5172 printf (" %ld\t\t%s\n", offset, data);
5173 data += strlen (data) + 1;
5176 while (offset != 0);
5189 case DW_TAG_padding: return "DW_TAG_padding";
5190 case DW_TAG_array_type: return "DW_TAG_array_type";
5191 case DW_TAG_class_type: return "DW_TAG_class_type";
5192 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5193 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5194 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5195 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5196 case DW_TAG_label: return "DW_TAG_label";
5197 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5198 case DW_TAG_member: return "DW_TAG_member";
5199 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5200 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5201 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5202 case DW_TAG_string_type: return "DW_TAG_string_type";
5203 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5204 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5205 case DW_TAG_typedef: return "DW_TAG_typedef";
5206 case DW_TAG_union_type: return "DW_TAG_union_type";
5207 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5208 case DW_TAG_variant: return "DW_TAG_variant";
5209 case DW_TAG_common_block: return "DW_TAG_common_block";
5210 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5211 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5212 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5213 case DW_TAG_module: return "DW_TAG_module";
5214 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5215 case DW_TAG_set_type: return "DW_TAG_set_type";
5216 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5217 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5218 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5219 case DW_TAG_base_type: return "DW_TAG_base_type";
5220 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5221 case DW_TAG_const_type: return "DW_TAG_const_type";
5222 case DW_TAG_constant: return "DW_TAG_constant";
5223 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5224 case DW_TAG_file_type: return "DW_TAG_file_type";
5225 case DW_TAG_friend: return "DW_TAG_friend";
5226 case DW_TAG_namelist: return "DW_TAG_namelist";
5227 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5228 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5229 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5230 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5231 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5232 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5233 case DW_TAG_try_block: return "DW_TAG_try_block";
5234 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5235 case DW_TAG_variable: return "DW_TAG_variable";
5236 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5237 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5238 case DW_TAG_format_label: return "DW_TAG_format_label";
5239 case DW_TAG_function_template: return "DW_TAG_function_template";
5240 case DW_TAG_class_template: return "DW_TAG_class_template";
5243 static char buffer [100];
5245 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5252 get_AT_name (attribute)
5253 unsigned long attribute;
5257 case DW_AT_sibling: return "DW_AT_sibling";
5258 case DW_AT_location: return "DW_AT_location";
5259 case DW_AT_name: return "DW_AT_name";
5260 case DW_AT_ordering: return "DW_AT_ordering";
5261 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5262 case DW_AT_byte_size: return "DW_AT_byte_size";
5263 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5264 case DW_AT_bit_size: return "DW_AT_bit_size";
5265 case DW_AT_element_list: return "DW_AT_element_list";
5266 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5267 case DW_AT_low_pc: return "DW_AT_low_pc";
5268 case DW_AT_high_pc: return "DW_AT_high_pc";
5269 case DW_AT_language: return "DW_AT_language";
5270 case DW_AT_member: return "DW_AT_member";
5271 case DW_AT_discr: return "DW_AT_discr";
5272 case DW_AT_discr_value: return "DW_AT_discr_value";
5273 case DW_AT_visibility: return "DW_AT_visibility";
5274 case DW_AT_import: return "DW_AT_import";
5275 case DW_AT_string_length: return "DW_AT_string_length";
5276 case DW_AT_common_reference: return "DW_AT_common_reference";
5277 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5278 case DW_AT_const_value: return "DW_AT_const_value";
5279 case DW_AT_containing_type: return "DW_AT_containing_type";
5280 case DW_AT_default_value: return "DW_AT_default_value";
5281 case DW_AT_inline: return "DW_AT_inline";
5282 case DW_AT_is_optional: return "DW_AT_is_optional";
5283 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5284 case DW_AT_producer: return "DW_AT_producer";
5285 case DW_AT_prototyped: return "DW_AT_prototyped";
5286 case DW_AT_return_addr: return "DW_AT_return_addr";
5287 case DW_AT_start_scope: return "DW_AT_start_scope";
5288 case DW_AT_stride_size: return "DW_AT_stride_size";
5289 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5290 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5291 case DW_AT_accessibility: return "DW_AT_accessibility";
5292 case DW_AT_address_class: return "DW_AT_address_class";
5293 case DW_AT_artificial: return "DW_AT_artificial";
5294 case DW_AT_base_types: return "DW_AT_base_types";
5295 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5296 case DW_AT_count: return "DW_AT_count";
5297 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5298 case DW_AT_decl_column: return "DW_AT_decl_column";
5299 case DW_AT_decl_file: return "DW_AT_decl_file";
5300 case DW_AT_decl_line: return "DW_AT_decl_line";
5301 case DW_AT_declaration: return "DW_AT_declaration";
5302 case DW_AT_discr_list: return "DW_AT_discr_list";
5303 case DW_AT_encoding: return "DW_AT_encoding";
5304 case DW_AT_external: return "DW_AT_external";
5305 case DW_AT_frame_base: return "DW_AT_frame_base";
5306 case DW_AT_friend: return "DW_AT_friend";
5307 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5308 case DW_AT_macro_info: return "DW_AT_macro_info";
5309 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5310 case DW_AT_priority: return "DW_AT_priority";
5311 case DW_AT_segment: return "DW_AT_segment";
5312 case DW_AT_specification: return "DW_AT_specification";
5313 case DW_AT_static_link: return "DW_AT_static_link";
5314 case DW_AT_type: return "DW_AT_type";
5315 case DW_AT_use_location: return "DW_AT_use_location";
5316 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5317 case DW_AT_virtuality: return "DW_AT_virtuality";
5318 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5319 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5320 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5321 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5322 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5323 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5324 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5325 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5326 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5327 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5328 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5329 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5330 case DW_AT_sf_names: return "DW_AT_sf_names";
5331 case DW_AT_src_info: return "DW_AT_src_info";
5332 case DW_AT_mac_info: return "DW_AT_mac_info";
5333 case DW_AT_src_coords: return "DW_AT_src_coords";
5334 case DW_AT_body_begin: return "DW_AT_body_begin";
5335 case DW_AT_body_end: return "DW_AT_body_end";
5338 static char buffer [100];
5340 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5347 get_FORM_name (form)
5352 case DW_FORM_addr: return "DW_FORM_addr";
5353 case DW_FORM_block2: return "DW_FORM_block2";
5354 case DW_FORM_block4: return "DW_FORM_block4";
5355 case DW_FORM_data2: return "DW_FORM_data2";
5356 case DW_FORM_data4: return "DW_FORM_data4";
5357 case DW_FORM_data8: return "DW_FORM_data8";
5358 case DW_FORM_string: return "DW_FORM_string";
5359 case DW_FORM_block: return "DW_FORM_block";
5360 case DW_FORM_block1: return "DW_FORM_block1";
5361 case DW_FORM_data1: return "DW_FORM_data1";
5362 case DW_FORM_flag: return "DW_FORM_flag";
5363 case DW_FORM_sdata: return "DW_FORM_sdata";
5364 case DW_FORM_strp: return "DW_FORM_strp";
5365 case DW_FORM_udata: return "DW_FORM_udata";
5366 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5367 case DW_FORM_ref1: return "DW_FORM_ref1";
5368 case DW_FORM_ref2: return "DW_FORM_ref2";
5369 case DW_FORM_ref4: return "DW_FORM_ref4";
5370 case DW_FORM_ref8: return "DW_FORM_ref8";
5371 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5372 case DW_FORM_indirect: return "DW_FORM_indirect";
5375 static char buffer [100];
5377 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5383 /* FIXME: There are better and more effiecint ways to handle
5384 these structures. For now though, I just want something that
5385 is simple to implement. */
5386 typedef struct abbrev_attr
5388 unsigned long attribute;
5390 struct abbrev_attr * next;
5394 typedef struct abbrev_entry
5396 unsigned long entry;
5399 struct abbrev_attr * first_attr;
5400 struct abbrev_attr * last_attr;
5401 struct abbrev_entry * next;
5405 static abbrev_entry * first_abbrev = NULL;
5406 static abbrev_entry * last_abbrev = NULL;
5409 free_abbrevs PARAMS ((void))
5411 abbrev_entry * abbrev;
5413 for (abbrev = first_abbrev; abbrev;)
5415 abbrev_entry * next = abbrev->next;
5418 for (attr = abbrev->first_attr; attr;)
5420 abbrev_attr * next = attr->next;
5430 last_abbrev = first_abbrev = NULL;
5434 add_abbrev (number, tag, children)
5435 unsigned long number;
5439 abbrev_entry * entry;
5441 entry = (abbrev_entry *) malloc (sizeof (* entry));
5447 entry->entry = number;
5449 entry->children = children;
5450 entry->first_attr = NULL;
5451 entry->last_attr = NULL;
5454 if (first_abbrev == NULL)
5455 first_abbrev = entry;
5457 last_abbrev->next = entry;
5459 last_abbrev = entry;
5463 add_abbrev_attr (attribute, form)
5464 unsigned long attribute;
5469 attr = (abbrev_attr *) malloc (sizeof (* attr));
5475 attr->attribute = attribute;
5479 if (last_abbrev->first_attr == NULL)
5480 last_abbrev->first_attr = attr;
5482 last_abbrev->last_attr->next = attr;
5484 last_abbrev->last_attr = attr;
5487 /* Processes the (partial) contents of a .debug_abbrev section.
5488 Returns NULL if the end of the section was encountered.
5489 Returns the address after the last byte read if the end of
5490 an abbreviation set was found. */
5492 static unsigned char *
5493 process_abbrev_section (start, end)
5494 unsigned char * start;
5495 unsigned char * end;
5497 if (first_abbrev != NULL)
5503 unsigned long entry;
5505 unsigned long attribute;
5508 entry = read_leb128 (start, & bytes_read, 0);
5509 start += bytes_read;
5511 /* A single zero is supposed to end the section according
5512 to the standard. If there's more, then signal that to
5515 return start == end ? NULL : start;
5517 tag = read_leb128 (start, & bytes_read, 0);
5518 start += bytes_read;
5520 children = * start ++;
5522 add_abbrev (entry, tag, children);
5528 attribute = read_leb128 (start, & bytes_read, 0);
5529 start += bytes_read;
5531 form = read_leb128 (start, & bytes_read, 0);
5532 start += bytes_read;
5535 add_abbrev_attr (attribute, form);
5537 while (attribute != 0);
5545 display_debug_abbrev (section, start, file)
5546 Elf32_Internal_Shdr * section;
5547 unsigned char * start;
5548 FILE * file ATTRIBUTE_UNUSED;
5550 abbrev_entry * entry;
5551 unsigned char * end = start + section->sh_size;
5553 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5557 start = process_abbrev_section (start, end);
5559 printf (_(" Number TAG\n"));
5561 for (entry = first_abbrev; entry; entry = entry->next)
5565 printf (_(" %ld %s [%s]\n"),
5567 get_TAG_name (entry->tag),
5568 entry->children ? _("has children") : _("no children"));
5570 for (attr = entry->first_attr; attr; attr = attr->next)
5572 printf (_(" %-18s %s\n"),
5573 get_AT_name (attr->attribute),
5574 get_FORM_name (attr->form));
5586 static unsigned char *
5587 display_block (data, length)
5588 unsigned char * data;
5589 unsigned long length;
5591 printf (_(" %lu byte block: "), length);
5594 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5600 decode_location_expression (data, pointer_size)
5601 unsigned char * data;
5602 unsigned int pointer_size;
5606 unsigned long uvalue;
5613 printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data, pointer_size));
5616 printf ("DW_OP_deref");
5619 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data, 1));
5622 printf ("DW_OP_const1s: %ld", (long) byte_get (data, 1));
5625 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5628 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5631 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5634 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5637 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5638 (unsigned long) byte_get (data + 4, 4));
5641 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5642 (long) byte_get (data + 4, 4));
5645 printf ("DW_OP_constu: %lu", read_leb128 (data, NULL, 0));
5648 printf ("DW_OP_consts: %ld", read_leb128 (data, NULL, 1));
5651 printf ("DW_OP_dup");
5654 printf ("DW_OP_drop");
5657 printf ("DW_OP_over");
5660 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data, 1));
5663 printf ("DW_OP_swap");
5666 printf ("DW_OP_rot");
5669 printf ("DW_OP_xderef");
5672 printf ("DW_OP_abs");
5675 printf ("DW_OP_and");
5678 printf ("DW_OP_div");
5681 printf ("DW_OP_minus");
5684 printf ("DW_OP_mod");
5687 printf ("DW_OP_mul");
5690 printf ("DW_OP_neg");
5693 printf ("DW_OP_not");
5696 printf ("DW_OP_or");
5699 printf ("DW_OP_plus");
5701 case DW_OP_plus_uconst:
5702 printf ("DW_OP_plus_uconst: %lu", read_leb128 (data, NULL, 0));
5705 printf ("DW_OP_shl");
5708 printf ("DW_OP_shr");
5711 printf ("DW_OP_shra");
5714 printf ("DW_OP_xor");
5717 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5720 printf ("DW_OP_eq");
5723 printf ("DW_OP_ge");
5726 printf ("DW_OP_gt");
5729 printf ("DW_OP_le");
5732 printf ("DW_OP_lt");
5735 printf ("DW_OP_ne");
5738 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5741 printf ("DW_OP_lit0");
5744 printf ("DW_OP_lit1");
5747 printf ("DW_OP_lit2");
5750 printf ("DW_OP_lit3");
5753 printf ("DW_OP_lit4");
5756 printf ("DW_OP_lit5");
5759 printf ("DW_OP_lit6");
5762 printf ("DW_OP_lit7");
5765 printf ("DW_OP_lit8");
5768 printf ("DW_OP_lit9");
5771 printf ("DW_OP_lit10");
5774 printf ("DW_OP_lit11");
5777 printf ("DW_OP_lit12");
5780 printf ("DW_OP_lit13");
5783 printf ("DW_OP_lit14");
5786 printf ("DW_OP_lit15");
5789 printf ("DW_OP_lit16");
5792 printf ("DW_OP_lit17");
5795 printf ("DW_OP_lit18");
5798 printf ("DW_OP_lit19");
5801 printf ("DW_OP_lit20");
5804 printf ("DW_OP_lit21");
5807 printf ("DW_OP_lit22");
5810 printf ("DW_OP_lit23");
5813 printf ("DW_OP_lit24");
5816 printf ("DW_OP_lit25");
5819 printf ("DW_OP_lit26");
5822 printf ("DW_OP_lit27");
5825 printf ("DW_OP_lit28");
5828 printf ("DW_OP_lit29");
5831 printf ("DW_OP_lit30");
5834 printf ("DW_OP_lit31");
5837 printf ("DW_OP_reg0");
5840 printf ("DW_OP_reg1");
5843 printf ("DW_OP_reg2");
5846 printf ("DW_OP_reg3");
5849 printf ("DW_OP_reg4");
5852 printf ("DW_OP_reg5");
5855 printf ("DW_OP_reg6");
5858 printf ("DW_OP_reg7");
5861 printf ("DW_OP_reg8");
5864 printf ("DW_OP_reg9");
5867 printf ("DW_OP_reg10");
5870 printf ("DW_OP_reg11");
5873 printf ("DW_OP_reg12");
5876 printf ("DW_OP_reg13");
5879 printf ("DW_OP_reg14");
5882 printf ("DW_OP_reg15");
5885 printf ("DW_OP_reg16");
5888 printf ("DW_OP_reg17");
5891 printf ("DW_OP_reg18");
5894 printf ("DW_OP_reg19");
5897 printf ("DW_OP_reg20");
5900 printf ("DW_OP_reg21");
5903 printf ("DW_OP_reg22");
5906 printf ("DW_OP_reg23");
5909 printf ("DW_OP_reg24");
5912 printf ("DW_OP_reg25");
5915 printf ("DW_OP_reg26");
5918 printf ("DW_OP_reg27");
5921 printf ("DW_OP_reg28");
5924 printf ("DW_OP_reg29");
5927 printf ("DW_OP_reg30");
5930 printf ("DW_OP_reg31");
5933 printf ("DW_OP_breg0: %ld", read_leb128 (data, NULL, 1));
5936 printf ("DW_OP_breg1: %ld", read_leb128 (data, NULL, 1));
5939 printf ("DW_OP_breg2: %ld", read_leb128 (data, NULL, 1));
5942 printf ("DW_OP_breg3: %ld", read_leb128 (data, NULL, 1));
5945 printf ("DW_OP_breg4: %ld", read_leb128 (data, NULL, 1));
5948 printf ("DW_OP_breg5: %ld", read_leb128 (data, NULL, 1));
5951 printf ("DW_OP_breg6: %ld", read_leb128 (data, NULL, 1));
5954 printf ("DW_OP_breg7: %ld", read_leb128 (data, NULL, 1));
5957 printf ("DW_OP_breg8: %ld", read_leb128 (data, NULL, 1));
5960 printf ("DW_OP_breg9: %ld", read_leb128 (data, NULL, 1));
5963 printf ("DW_OP_breg10: %ld", read_leb128 (data, NULL, 1));
5966 printf ("DW_OP_breg11: %ld", read_leb128 (data, NULL, 1));
5969 printf ("DW_OP_breg12: %ld", read_leb128 (data, NULL, 1));
5972 printf ("DW_OP_breg13: %ld", read_leb128 (data, NULL, 1));
5975 printf ("DW_OP_breg14: %ld", read_leb128 (data, NULL, 1));
5978 printf ("DW_OP_breg15: %ld", read_leb128 (data, NULL, 1));
5981 printf ("DW_OP_breg16: %ld", read_leb128 (data, NULL, 1));
5984 printf ("DW_OP_breg17: %ld", read_leb128 (data, NULL, 1));
5987 printf ("DW_OP_breg18: %ld", read_leb128 (data, NULL, 1));
5990 printf ("DW_OP_breg19: %ld", read_leb128 (data, NULL, 1));
5993 printf ("DW_OP_breg20: %ld", read_leb128 (data, NULL, 1));
5996 printf ("DW_OP_breg21: %ld", read_leb128 (data, NULL, 1));
5999 printf ("DW_OP_breg22: %ld", read_leb128 (data, NULL, 1));
6002 printf ("DW_OP_breg23: %ld", read_leb128 (data, NULL, 1));
6005 printf ("DW_OP_breg24: %ld", read_leb128 (data, NULL, 1));
6008 printf ("DW_OP_breg25: %ld", read_leb128 (data, NULL, 1));
6011 printf ("DW_OP_breg26: %ld", read_leb128 (data, NULL, 1));
6014 printf ("DW_OP_breg27: %ld", read_leb128 (data, NULL, 1));
6017 printf ("DW_OP_breg28: %ld", read_leb128 (data, NULL, 1));
6020 printf ("DW_OP_breg29: %ld", read_leb128 (data, NULL, 1));
6023 printf ("DW_OP_breg30: %ld", read_leb128 (data, NULL, 1));
6026 printf ("DW_OP_breg31: %ld", read_leb128 (data, NULL, 1));
6029 printf ("DW_OP_regx: %lu", read_leb128 (data, NULL, 0));
6032 printf ("DW_OP_fbreg: %ld", read_leb128 (data, NULL, 1));
6035 uvalue = read_leb128 (data, &bytes_read, 0);
6036 printf ("DW_OP_bregx: %lu %ld", uvalue,
6037 read_leb128 (data + bytes_read, NULL, 1));
6040 printf ("DW_OP_piece: %lu", read_leb128 (data, NULL, 0));
6042 case DW_OP_deref_size:
6043 printf ("DW_OP_deref_size: %ld", (long) byte_get (data, 1));
6045 case DW_OP_xderef_size:
6046 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data, 1));
6049 printf ("DW_OP_nop");
6053 if (op >= DW_OP_lo_user
6054 && op <= DW_OP_hi_user)
6055 printf (_("(User defined location op)"));
6057 printf (_("(Unknown location op)"));
6063 static unsigned char *
6064 read_and_display_attr (attribute, form, data, pointer_size)
6065 unsigned long attribute;
6067 unsigned char * data;
6068 unsigned long pointer_size;
6070 unsigned long uvalue = 0;
6071 unsigned char * block_start = NULL;
6075 printf (" %-18s:", get_AT_name (attribute));
6079 case DW_FORM_ref_addr:
6084 case DW_FORM_ref_udata:
6090 case DW_FORM_ref_addr:
6092 uvalue = byte_get (data, pointer_size);
6093 printf (is_ref ? " <%lx>" : " %#lx", uvalue);
6094 data += pointer_size;
6100 uvalue = byte_get (data ++, 1);
6101 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6106 uvalue = byte_get (data, 2);
6108 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6113 uvalue = byte_get (data, 4);
6115 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6120 uvalue = byte_get (data, 4);
6121 printf (" %lx", uvalue);
6122 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6126 case DW_FORM_string:
6127 printf (" %s", data);
6128 data += strlen (data) + 1;
6132 uvalue = read_leb128 (data, & bytes_read, 1);
6134 printf (" %ld", (long) uvalue);
6137 case DW_FORM_ref_udata:
6139 uvalue = read_leb128 (data, & bytes_read, 0);
6141 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6145 uvalue = read_leb128 (data, & bytes_read, 0);
6146 block_start = data + bytes_read;
6147 data = display_block (block_start, uvalue);
6148 uvalue = * block_start;
6151 case DW_FORM_block1:
6152 uvalue = byte_get (data, 1);
6153 block_start = data + 1;
6154 data = display_block (block_start, uvalue);
6155 uvalue = * block_start;
6158 case DW_FORM_block2:
6159 uvalue = byte_get (data, 2);
6160 block_start = data + 2;
6161 data = display_block (block_start, uvalue);
6162 uvalue = * block_start;
6165 case DW_FORM_block4:
6166 uvalue = byte_get (data, 4);
6167 block_start = data + 4;
6168 data = display_block (block_start, uvalue);
6169 uvalue = * block_start;
6173 case DW_FORM_indirect:
6174 warn (_("Unable to handle FORM: %d"), form);
6178 warn (_("Unrecognised form: %d"), form);
6182 /* For some attributes we can display futher information. */
6191 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6192 case DW_INL_inlined: printf (_("(inlined)")); break;
6193 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6194 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6195 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6199 case DW_AT_frame_base:
6200 if (uvalue >= DW_OP_reg0 && uvalue <= DW_OP_reg31)
6201 printf ("(reg %ld)", uvalue - DW_OP_reg0);
6204 case DW_AT_language:
6207 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6208 case DW_LANG_C89: printf ("(ANSI C)"); break;
6209 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6210 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6211 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6212 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6213 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6214 case DW_LANG_Ada83: printf ("(Ada)"); break;
6215 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6216 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6217 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6218 default: printf ("(Unknown: %lx)", uvalue); break;
6222 case DW_AT_encoding:
6225 case DW_ATE_void: printf ("(void)"); break;
6226 case DW_ATE_address: printf ("(machine address)"); break;
6227 case DW_ATE_boolean: printf ("(boolean)"); break;
6228 case DW_ATE_complex_float: printf ("(complex float)"); break;
6229 case DW_ATE_float: printf ("(float)"); break;
6230 case DW_ATE_signed: printf ("(signed)"); break;
6231 case DW_ATE_signed_char: printf ("(signed char)"); break;
6232 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6233 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6235 if (uvalue >= DW_ATE_lo_user
6236 && uvalue <= DW_ATE_hi_user)
6237 printf ("(user defined type)");
6239 printf ("(unknown type)");
6244 case DW_AT_accessibility:
6247 case DW_ACCESS_public: printf ("(public)"); break;
6248 case DW_ACCESS_protected: printf ("(protected)"); break;
6249 case DW_ACCESS_private: printf ("(private)"); break;
6250 default: printf ("(unknown accessibility)"); break;
6254 case DW_AT_visibility:
6257 case DW_VIS_local: printf ("(local)"); break;
6258 case DW_VIS_exported: printf ("(exported)"); break;
6259 case DW_VIS_qualified: printf ("(qualified)"); break;
6260 default: printf ("(unknown visibility)"); break;
6264 case DW_AT_virtuality:
6267 case DW_VIRTUALITY_none: printf ("(none)"); break;
6268 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6269 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6270 default: printf ("(unknown virtuality)"); break;
6274 case DW_AT_identifier_case:
6277 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6278 case DW_ID_up_case: printf ("(up_case)"); break;
6279 case DW_ID_down_case: printf ("(down_case)"); break;
6280 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6281 default: printf ("(unknown case)"); break;
6285 case DW_AT_calling_convention:
6288 case DW_CC_normal: printf ("(normal)"); break;
6289 case DW_CC_program: printf ("(program)"); break;
6290 case DW_CC_nocall: printf ("(nocall)"); break;
6292 if (uvalue >= DW_CC_lo_user
6293 && uvalue <= DW_CC_hi_user)
6294 printf ("(user defined)");
6296 printf ("(unknown convention)");
6300 case DW_AT_location:
6301 case DW_AT_data_member_location:
6302 case DW_AT_vtable_elem_location:
6304 decode_location_expression (block_start, pointer_size);
6317 display_debug_info (section, start, file)
6318 Elf32_Internal_Shdr * section;
6319 unsigned char * start;
6322 unsigned char * end = start + section->sh_size;
6323 unsigned char * section_begin = start;
6325 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6329 DWARF2_External_CompUnit * external;
6330 DWARF2_Internal_CompUnit compunit;
6331 unsigned char * tags;
6335 external = (DWARF2_External_CompUnit *) start;
6337 compunit.cu_length = BYTE_GET (external->cu_length);
6338 compunit.cu_version = BYTE_GET (external->cu_version);
6339 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6340 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6342 tags = start + sizeof (* external);
6343 start += compunit.cu_length + sizeof (external->cu_length);
6345 if (compunit.cu_version != 2)
6347 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6351 printf (_(" Compilation Unit:\n"));
6352 printf (_(" Length: %ld\n"), compunit.cu_length);
6353 printf (_(" Version: %d\n"), compunit.cu_version);
6354 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6355 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6357 if (first_abbrev != NULL)
6360 /* Read in the abbrevs used by this compilation unit. */
6363 Elf32_Internal_Shdr * sec;
6364 unsigned char * begin;
6366 /* Locate the .debug_abbrev section and process it. */
6367 for (i = 0, sec = section_headers;
6368 i < elf_header.e_shnum;
6370 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6373 if (i == -1 || sec->sh_size == 0)
6375 warn (_("Unable to locate .debug_abbrev section!\n"));
6379 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6380 "debug_abbrev section data");
6382 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6383 begin + sec->sh_size);
6389 while (tags < start)
6392 unsigned long abbrev_number;
6393 abbrev_entry * entry;
6396 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6399 /* A null DIE marks the end of a list of children. */
6400 if (abbrev_number == 0)
6406 /* Scan through the abbreviation list until we reach the
6408 for (entry = first_abbrev;
6409 entry && entry->entry != abbrev_number;
6410 entry = entry->next)
6415 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6420 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6421 level, tags - section_begin - bytes_read,
6423 get_TAG_name (entry->tag));
6425 for (attr = entry->first_attr; attr; attr = attr->next)
6426 tags = read_and_display_attr (attr->attribute,
6429 compunit.cu_pointer_size);
6431 if (entry->children)
6442 display_debug_aranges (section, start, file)
6443 Elf32_Internal_Shdr * section;
6444 unsigned char * start;
6445 FILE * file ATTRIBUTE_UNUSED;
6447 unsigned char * end = start + section->sh_size;
6449 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6453 DWARF2_External_ARange * external;
6454 DWARF2_Internal_ARange arange;
6455 unsigned char * ranges;
6456 unsigned long length;
6457 unsigned long address;
6460 external = (DWARF2_External_ARange *) start;
6462 arange.ar_length = BYTE_GET (external->ar_length);
6463 arange.ar_version = BYTE_GET (external->ar_version);
6464 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6465 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6466 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6468 printf (_(" Length: %ld\n"), arange.ar_length);
6469 printf (_(" Version: %d\n"), arange.ar_version);
6470 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6471 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6472 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6474 printf (_("\n Address Length\n"));
6476 ranges = start + sizeof (* external);
6478 /* Must pad to an alignment boundary that is twice the pointer size. */
6479 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6481 ranges += (2 * arange.ar_pointer_size) - excess;
6485 address = byte_get (ranges, arange.ar_pointer_size);
6487 ranges += arange.ar_pointer_size;
6489 length = byte_get (ranges, arange.ar_pointer_size);
6491 ranges += arange.ar_pointer_size;
6493 /* A pair of zeros marks the end of the list. */
6494 if (address == 0 && length == 0)
6497 printf (" %8.8lx %lu\n", address, length);
6500 start += arange.ar_length + sizeof (external->ar_length);
6510 display_debug_not_supported (section, start, file)
6511 Elf32_Internal_Shdr * section;
6512 unsigned char * start ATTRIBUTE_UNUSED;
6513 FILE * file ATTRIBUTE_UNUSED;
6515 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6516 SECTION_NAME (section));
6521 /* Pre-scan the .debug_info section to record the size of address.
6522 When dumping the .debug_line, we use that size information, assuming
6523 that all compilation units have the same address size. */
6525 prescan_debug_info (section, start, file)
6526 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6527 unsigned char * start;
6528 FILE * file ATTRIBUTE_UNUSED;
6530 DWARF2_External_CompUnit * external;
6532 external = (DWARF2_External_CompUnit *) start;
6534 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6538 /* A structure containing the name of a debug section and a pointer
6539 to a function that can decode it. The third field is a prescan
6540 function to be run over the section before displaying any of the
6545 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6546 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6550 { ".debug_info", display_debug_info, prescan_debug_info },
6551 { ".debug_abbrev", display_debug_abbrev, NULL },
6552 { ".debug_line", display_debug_lines, NULL },
6553 { ".debug_aranges", display_debug_aranges, NULL },
6554 { ".debug_pubnames", display_debug_pubnames, NULL },
6555 { ".debug_macinfo", display_debug_not_supported, NULL },
6556 { ".debug_frame", display_debug_not_supported, NULL },
6557 { ".debug_str", display_debug_not_supported, NULL },
6558 { ".debug_static_func", display_debug_not_supported, NULL },
6559 { ".debug_static_vars", display_debug_not_supported, NULL },
6560 { ".debug_types", display_debug_not_supported, NULL },
6561 { ".debug_weaknames", display_debug_not_supported, NULL }
6565 display_debug_section (section, file)
6566 Elf32_Internal_Shdr * section;
6569 char * name = SECTION_NAME (section);
6570 bfd_size_type length;
6571 unsigned char * start;
6574 length = section->sh_size;
6577 printf (_("\nSection '%s' has no debugging data.\n"), name);
6581 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6582 "debug section data");
6584 /* See if we know how to display the contents of this section. */
6585 for (i = NUM_ELEM (debug_displays); i--;)
6586 if (strcmp (debug_displays[i].name, name) == 0)
6588 debug_displays[i].display (section, start, file);
6593 printf (_("Unrecognised debug section: %s\n"), name);
6597 /* If we loaded in the abbrev section at some point,
6598 we must release it here. */
6599 if (first_abbrev != NULL)
6606 process_section_contents (file)
6609 Elf32_Internal_Shdr * section;
6615 /* Pre-scan the debug sections to find some debug information not
6616 present in some of them. For the .debug_line, we must find out the
6617 size of address (specified in .debug_info and .debug_aranges). */
6618 for (i = 0, section = section_headers;
6619 i < elf_header.e_shnum && i < num_dump_sects;
6622 char * name = SECTION_NAME (section);
6625 if (section->sh_size == 0)
6628 /* See if there is some pre-scan operation for this section. */
6629 for (j = NUM_ELEM (debug_displays); j--;)
6630 if (strcmp (debug_displays[j].name, name) == 0)
6632 if (debug_displays[j].prescan != NULL)
6634 bfd_size_type length;
6635 unsigned char * start;
6637 length = section->sh_size;
6638 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6639 "debug section data");
6641 debug_displays[j].prescan (section, start, file);
6649 for (i = 0, section = section_headers;
6650 i < elf_header.e_shnum && i < num_dump_sects;
6653 #ifdef SUPPORT_DISASSEMBLY
6654 if (dump_sects[i] & DISASS_DUMP)
6655 disassemble_section (section, file);
6657 if (dump_sects[i] & HEX_DUMP)
6658 dump_section (section, file);
6660 if (dump_sects[i] & DEBUG_DUMP)
6661 display_debug_section (section, file);
6664 if (i < num_dump_sects)
6665 warn (_("Some sections were not dumped because they do not exist!\n"));
6671 process_mips_fpe_exception (mask)
6677 if (mask & OEX_FPU_INEX)
6678 fputs ("INEX", stdout), first = 0;
6679 if (mask & OEX_FPU_UFLO)
6680 printf ("%sUFLO", first ? "" : "|"), first = 0;
6681 if (mask & OEX_FPU_OFLO)
6682 printf ("%sOFLO", first ? "" : "|"), first = 0;
6683 if (mask & OEX_FPU_DIV0)
6684 printf ("%sDIV0", first ? "" : "|"), first = 0;
6685 if (mask & OEX_FPU_INVAL)
6686 printf ("%sINVAL", first ? "" : "|");
6689 fputs ("0", stdout);
6693 process_mips_specific (file)
6696 Elf_Internal_Dyn * entry;
6697 size_t liblist_offset = 0;
6698 size_t liblistno = 0;
6699 size_t conflictsno = 0;
6700 size_t options_offset = 0;
6701 size_t conflicts_offset = 0;
6703 /* We have a lot of special sections. Thanks SGI! */
6704 if (dynamic_segment == NULL)
6705 /* No information available. */
6708 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
6709 switch (entry->d_tag)
6711 case DT_MIPS_LIBLIST:
6712 liblist_offset = entry->d_un.d_val - loadaddr;
6714 case DT_MIPS_LIBLISTNO:
6715 liblistno = entry->d_un.d_val;
6717 case DT_MIPS_OPTIONS:
6718 options_offset = entry->d_un.d_val - loadaddr;
6720 case DT_MIPS_CONFLICT:
6721 conflicts_offset = entry->d_un.d_val - loadaddr;
6723 case DT_MIPS_CONFLICTNO:
6724 conflictsno = entry->d_un.d_val;
6730 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
6732 Elf32_External_Lib * elib;
6735 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
6736 elib, Elf32_External_Lib *, "liblist");
6738 printf ("\nSection '.liblist' contains %lu entries:\n",
6739 (unsigned long) liblistno);
6740 fputs (" Library Time Stamp Checksum Version Flags\n",
6743 for (cnt = 0; cnt < liblistno; ++cnt)
6749 liblist.l_name = BYTE_GET (elib[cnt].l_name);
6750 time = BYTE_GET (elib[cnt].l_time_stamp);
6751 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
6752 liblist.l_version = BYTE_GET (elib[cnt].l_version);
6753 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
6755 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
6757 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
6758 dynamic_strings + liblist.l_name, timebuf,
6759 liblist.l_checksum, liblist.l_version);
6761 if (liblist.l_flags == 0)
6772 { " EXACT_MATCH", LL_EXACT_MATCH },
6773 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
6774 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
6775 { " EXPORTS", LL_EXPORTS },
6776 { " DELAY_LOAD", LL_DELAY_LOAD },
6777 { " DELTA", LL_DELTA }
6779 int flags = liblist.l_flags;
6783 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
6785 if ((flags & l_flags_vals[fcnt].bit) != 0)
6787 fputs (l_flags_vals[fcnt].name, stdout);
6788 flags ^= l_flags_vals[fcnt].bit;
6791 printf (" %#x", (unsigned int) flags);
6800 if (options_offset != 0)
6802 Elf_External_Options * eopt;
6803 Elf_Internal_Shdr * sect = section_headers;
6804 Elf_Internal_Options * iopt;
6805 Elf_Internal_Options * option;
6809 /* Find the section header so that we get the size. */
6810 while (sect->sh_type != SHT_MIPS_OPTIONS)
6813 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
6814 Elf_External_Options *, "options");
6816 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
6820 error (_("Out of memory"));
6827 while (offset < sect->sh_size)
6829 Elf_External_Options * eoption;
6831 eoption = (Elf_External_Options *) ((char *) eopt + offset);
6833 option->kind = BYTE_GET (eoption->kind);
6834 option->size = BYTE_GET (eoption->size);
6835 option->section = BYTE_GET (eoption->section);
6836 option->info = BYTE_GET (eoption->info);
6838 offset += option->size;
6844 printf (_("\nSection '%s' contains %d entries:\n"),
6845 string_table + sect->sh_name, cnt);
6853 switch (option->kind)
6856 /* This shouldn't happen. */
6857 printf (" NULL %d %lx", option->section, option->info);
6860 printf (" REGINFO ");
6861 if (elf_header.e_machine == EM_MIPS)
6864 Elf32_External_RegInfo *ereg;
6865 Elf32_RegInfo reginfo;
6867 ereg = (Elf32_External_RegInfo *) (option + 1);
6868 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6869 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6870 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6871 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6872 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6873 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
6875 printf ("GPR %08lx GP 0x%lx\n",
6877 (unsigned long) reginfo.ri_gp_value);
6878 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6879 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6880 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6885 Elf64_External_RegInfo * ereg;
6886 Elf64_Internal_RegInfo reginfo;
6888 ereg = (Elf64_External_RegInfo *) (option + 1);
6889 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6890 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6891 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6892 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6893 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6894 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
6896 printf ("GPR %08lx GP 0x",
6897 reginfo.ri_gprmask);
6898 printf_vma (reginfo.ri_gp_value);
6901 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6902 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6903 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6907 case ODK_EXCEPTIONS:
6908 fputs (" EXCEPTIONS fpe_min(", stdout);
6909 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
6910 fputs (") fpe_max(", stdout);
6911 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
6912 fputs (")", stdout);
6914 if (option->info & OEX_PAGE0)
6915 fputs (" PAGE0", stdout);
6916 if (option->info & OEX_SMM)
6917 fputs (" SMM", stdout);
6918 if (option->info & OEX_FPDBUG)
6919 fputs (" FPDBUG", stdout);
6920 if (option->info & OEX_DISMISS)
6921 fputs (" DISMISS", stdout);
6924 fputs (" PAD ", stdout);
6925 if (option->info & OPAD_PREFIX)
6926 fputs (" PREFIX", stdout);
6927 if (option->info & OPAD_POSTFIX)
6928 fputs (" POSTFIX", stdout);
6929 if (option->info & OPAD_SYMBOL)
6930 fputs (" SYMBOL", stdout);
6933 fputs (" HWPATCH ", stdout);
6934 if (option->info & OHW_R4KEOP)
6935 fputs (" R4KEOP", stdout);
6936 if (option->info & OHW_R8KPFETCH)
6937 fputs (" R8KPFETCH", stdout);
6938 if (option->info & OHW_R5KEOP)
6939 fputs (" R5KEOP", stdout);
6940 if (option->info & OHW_R5KCVTL)
6941 fputs (" R5KCVTL", stdout);
6944 fputs (" FILL ", stdout);
6945 /* XXX Print content of info word? */
6948 fputs (" TAGS ", stdout);
6949 /* XXX Print content of info word? */
6952 fputs (" HWAND ", stdout);
6953 if (option->info & OHWA0_R4KEOP_CHECKED)
6954 fputs (" R4KEOP_CHECKED", stdout);
6955 if (option->info & OHWA0_R4KEOP_CLEAN)
6956 fputs (" R4KEOP_CLEAN", stdout);
6959 fputs (" HWOR ", stdout);
6960 if (option->info & OHWA0_R4KEOP_CHECKED)
6961 fputs (" R4KEOP_CHECKED", stdout);
6962 if (option->info & OHWA0_R4KEOP_CLEAN)
6963 fputs (" R4KEOP_CLEAN", stdout);
6966 printf (" GP_GROUP %#06lx self-contained %#06lx",
6967 option->info & OGP_GROUP,
6968 (option->info & OGP_SELF) >> 16);
6971 printf (" IDENT %#06lx self-contained %#06lx",
6972 option->info & OGP_GROUP,
6973 (option->info & OGP_SELF) >> 16);
6976 /* This shouldn't happen. */
6977 printf (" %3d ??? %d %lx",
6978 option->kind, option->section, option->info);
6982 len = sizeof (*eopt);
6983 while (len < option->size)
6984 if (((char *) option)[len] >= ' '
6985 && ((char *) option)[len] < 0x7f)
6986 printf ("%c", ((char *) option)[len++]);
6988 printf ("\\%03o", ((char *) option)[len++]);
6990 fputs ("\n", stdout);
6997 if (conflicts_offset != 0 && conflictsno != 0)
6999 Elf32_External_Conflict * econf32;
7000 Elf64_External_Conflict * econf64;
7001 Elf32_Conflict * iconf;
7004 if (dynamic_symbols == NULL)
7006 error (_("conflict list with without table"));
7010 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
7013 error (_("Out of memory"));
7019 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
7020 econf32, Elf32_External_Conflict *, "conflict");
7022 for (cnt = 0; cnt < conflictsno; ++cnt)
7023 iconf[cnt] = BYTE_GET (econf32[cnt]);
7027 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
7028 econf64, Elf64_External_Conflict *, "conflict");
7030 for (cnt = 0; cnt < conflictsno; ++cnt)
7031 iconf[cnt] = BYTE_GET (econf64[cnt]);
7034 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
7035 puts (_(" Num: Index Value Name"));
7037 for (cnt = 0; cnt < conflictsno; ++cnt)
7039 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
7041 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
7042 print_vma (psym->st_value, FULL_HEX);
7043 printf (" %s\n", dynamic_strings + psym->st_name);
7053 get_note_type (e_type)
7056 static char buff[64];
7060 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
7061 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
7062 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
7063 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
7064 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
7065 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
7066 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
7067 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
7068 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
7069 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7070 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7072 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
7077 /* Note that by the ELF standard, the name field is already null byte
7078 terminated, and namesz includes the terminating null byte.
7079 I.E. the value of namesz for the name "FSF" is 4.
7081 If the value of namesz is zero, there is no name present. */
7083 process_note (pnote)
7084 Elf32_Internal_Note * pnote;
7086 printf (" %s\t\t0x%08lx\t%s\n",
7087 pnote->namesz ? pnote->namedata : "(NONE)",
7088 pnote->descsz, get_note_type (pnote->type));
7094 process_corefile_note_segment (file, offset, length)
7099 Elf_External_Note * pnotes;
7100 Elf_External_Note * external;
7106 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
7110 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7111 (unsigned long) offset, (unsigned long) length);
7112 printf (_(" Owner\t\tData size\tDescription\n"));
7114 while (external < (Elf_External_Note *)((char *) pnotes + length))
7116 Elf32_Internal_Note inote;
7119 inote.type = BYTE_GET (external->type);
7120 inote.namesz = BYTE_GET (external->namesz);
7121 inote.namedata = external->name;
7122 inote.descsz = BYTE_GET (external->descsz);
7123 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
7124 inote.descpos = offset + (inote.descdata - (char *) pnotes);
7126 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7128 /* Verify that name is null terminated. It appears that at least
7129 one version of Linux (RedHat 6.0) generates corefiles that don't
7130 comply with the ELF spec by failing to include the null byte in
7132 if (inote.namedata[inote.namesz] != '\0')
7134 temp = malloc (inote.namesz + 1);
7138 error (_("Out of memory\n"));
7143 strncpy (temp, inote.namedata, inote.namesz);
7144 temp[inote.namesz] = 0;
7146 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7147 inote.namedata = temp;
7150 res &= process_note (& inote);
7165 process_corefile_note_segments (file)
7168 Elf_Internal_Phdr * program_headers;
7169 Elf_Internal_Phdr * segment;
7173 program_headers = (Elf_Internal_Phdr *) malloc
7174 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7176 if (program_headers == NULL)
7178 error (_("Out of memory\n"));
7183 i = get_32bit_program_headers (file, program_headers);
7185 i = get_64bit_program_headers (file, program_headers);
7189 free (program_headers);
7193 for (i = 0, segment = program_headers;
7194 i < elf_header.e_phnum;
7197 if (segment->p_type == PT_NOTE)
7198 res &= process_corefile_note_segment (file,
7199 (bfd_vma) segment->p_offset,
7200 (bfd_vma) segment->p_filesz);
7203 free (program_headers);
7209 process_corefile_contents (file)
7212 /* If we have not been asked to display the notes then do nothing. */
7216 /* If file is not a core file then exit. */
7217 if (elf_header.e_type != ET_CORE)
7220 /* No program headers means no NOTE segment. */
7221 if (elf_header.e_phnum == 0)
7223 printf (_("No note segments present in the core file.\n"));
7227 return process_corefile_note_segments (file);
7231 process_arch_specific (file)
7237 switch (elf_header.e_machine)
7240 case EM_MIPS_RS4_BE:
7241 return process_mips_specific (file);
7250 get_file_header (file)
7253 /* Read in the identity array. */
7254 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7257 /* Determine how to read the rest of the header. */
7258 switch (elf_header.e_ident [EI_DATA])
7260 default: /* fall through */
7261 case ELFDATANONE: /* fall through */
7262 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7263 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7266 /* For now we only support 32 bit and 64 bit ELF files. */
7267 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7269 /* Read in the rest of the header. */
7272 Elf32_External_Ehdr ehdr32;
7274 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7277 elf_header.e_type = BYTE_GET (ehdr32.e_type);
7278 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
7279 elf_header.e_version = BYTE_GET (ehdr32.e_version);
7280 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7281 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7282 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7283 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7284 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7285 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7286 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7287 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7288 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7289 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7293 Elf64_External_Ehdr ehdr64;
7295 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7296 we will not be able to cope with the 64bit data found in
7297 64 ELF files. Detect this now and abort before we start
7298 overwritting things. */
7299 if (sizeof (bfd_vma) < 8)
7301 error (_("This instance of readelf has been built without support for a\n"));
7302 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7306 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7309 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7310 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7311 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7312 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7313 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7314 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7315 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7316 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7317 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7318 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7319 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7320 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7321 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7328 process_file (file_name)
7332 struct stat statbuf;
7335 if (stat (file_name, & statbuf) < 0)
7337 error (_("Cannot stat input file %s.\n"), file_name);
7341 file = fopen (file_name, "rb");
7344 error (_("Input file %s not found.\n"), file_name);
7348 if (! get_file_header (file))
7350 error (_("%s: Failed to read file header\n"), file_name);
7355 /* Initialise per file variables. */
7356 for (i = NUM_ELEM (version_info); i--;)
7357 version_info[i] = 0;
7359 for (i = NUM_ELEM (dynamic_info); i--;)
7360 dynamic_info[i] = 0;
7362 /* Process the file. */
7364 printf (_("\nFile: %s\n"), file_name);
7366 if (! process_file_header ())
7372 process_section_headers (file);
7374 process_program_headers (file);
7376 process_dynamic_segment (file);
7378 process_relocs (file);
7380 process_symbol_table (file);
7382 process_syminfo (file);
7384 process_version_sections (file);
7386 process_section_contents (file);
7388 process_corefile_contents (file);
7390 process_arch_specific (file);
7394 if (section_headers)
7396 free (section_headers);
7397 section_headers = NULL;
7402 free (string_table);
7403 string_table = NULL;
7406 if (dynamic_strings)
7408 free (dynamic_strings);
7409 dynamic_strings = NULL;
7412 if (dynamic_symbols)
7414 free (dynamic_symbols);
7415 dynamic_symbols = NULL;
7416 num_dynamic_syms = 0;
7419 if (dynamic_syminfo)
7421 free (dynamic_syminfo);
7422 dynamic_syminfo = NULL;
7426 #ifdef SUPPORT_DISASSEMBLY
7427 /* Needed by the i386 disassembler. For extra credit, someone could
7428 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7432 print_address (unsigned int addr, FILE * outfile)
7434 fprintf (outfile,"0x%8.8x", addr);
7437 /* Needed by the i386 disassembler. */
7439 db_task_printsym (unsigned int addr)
7441 print_address (addr, stderr);
7450 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7451 setlocale (LC_MESSAGES, "");
7453 bindtextdomain (PACKAGE, LOCALEDIR);
7454 textdomain (PACKAGE);
7456 parse_args (argc, argv);
7458 if (optind < (argc - 1))
7461 while (optind < argc)
7462 process_file (argv [optind ++]);
7464 if (dump_sects != NULL)