1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 1999 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
31 /* Define BFD64 here, even if our default architecture is 32 bit ELF
32 as this will allow us to read in and parse 64bit and 32bit ELF files.
33 Only do this if we belive that the compiler can support a 64 bit
34 data type. For now we only rely on GCC being able to do this. */
40 #include "elf/common.h"
41 #include "elf/external.h"
42 #include "elf/internal.h"
43 #include "elf/dwarf2.h"
45 /* The following headers use the elf/reloc-macros.h file to
46 automatically generate relocation recognition functions
47 such as elf_mips_reloc_type() */
49 #define RELOC_MACROS_GEN_FUNC
55 #include "elf/alpha.h"
58 #include "elf/sparc.h"
63 #include "elf/mn10200.h"
64 #include "elf/mn10300.h"
68 #include "elf/mcore.h"
75 #ifdef ANSI_PROTOTYPES
81 char * program_name = "readelf";
82 unsigned int dynamic_addr;
83 bfd_size_type dynamic_size;
84 unsigned int rela_addr;
85 unsigned int rela_size;
86 char * dynamic_strings;
88 unsigned long num_dynamic_syms;
89 Elf_Internal_Sym * dynamic_symbols;
90 Elf_Internal_Syminfo * dynamic_syminfo;
91 unsigned long dynamic_syminfo_offset;
92 unsigned int dynamic_syminfo_nent;
93 char program_interpreter [64];
94 int dynamic_info[DT_JMPREL + 1];
97 Elf_Internal_Ehdr elf_header;
98 Elf_Internal_Shdr * section_headers;
99 Elf_Internal_Dyn * dynamic_segment;
106 int do_using_dynamic;
113 int do_debug_abbrevs;
115 int do_debug_pubnames;
116 int do_debug_aranges;
121 /* A dynamic array of flags indicating which sections require dumping. */
122 char * dump_sects = NULL;
123 unsigned int num_dump_sects = 0;
125 #define HEX_DUMP (1 << 0)
126 #define DISASS_DUMP (1 << 1)
127 #define DEBUG_DUMP (1 << 2)
129 /* How to rpint a vma value. */
130 typedef enum print_mode
142 /* Forward declarations for dumb compilers. */
143 static void print_vma PARAMS ((bfd_vma, print_mode));
144 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
145 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
146 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
147 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
148 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
149 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
150 static const char * get_dynamic_type PARAMS ((unsigned long));
151 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
152 static char * get_file_type PARAMS ((unsigned));
153 static char * get_machine_name PARAMS ((unsigned));
154 static char * get_machine_flags PARAMS ((unsigned, unsigned));
155 static const char * get_mips_segment_type PARAMS ((unsigned long));
156 static const char * get_parisc_segment_type PARAMS ((unsigned long));
157 static const char * get_segment_type PARAMS ((unsigned long));
158 static const char * get_mips_section_type_name PARAMS ((unsigned int));
159 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
160 static const char * get_section_type_name PARAMS ((unsigned int));
161 static const char * get_symbol_binding PARAMS ((unsigned int));
162 static const char * get_symbol_type PARAMS ((unsigned int));
163 static const char * get_symbol_visibility PARAMS ((unsigned int));
164 static const char * get_symbol_index_type PARAMS ((unsigned int));
165 static const char * get_dynamic_flags PARAMS ((bfd_vma));
166 static void usage PARAMS ((void));
167 static void parse_args PARAMS ((int, char **));
168 static int process_file_header PARAMS ((void));
169 static int process_program_headers PARAMS ((FILE *));
170 static int process_section_headers PARAMS ((FILE *));
171 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
172 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
173 static int process_dynamic_segment PARAMS ((FILE *));
174 static int process_symbol_table PARAMS ((FILE *));
175 static int process_section_contents PARAMS ((FILE *));
176 static void process_file PARAMS ((char *));
177 static int process_relocs PARAMS ((FILE *));
178 static int process_version_sections PARAMS ((FILE *));
179 static char * get_ver_flags PARAMS ((unsigned int));
180 static int get_32bit_section_headers PARAMS ((FILE *));
181 static int get_64bit_section_headers PARAMS ((FILE *));
182 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
183 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
184 static int get_file_header PARAMS ((FILE *));
185 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
186 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
187 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
188 static int get_32bit_dynamic_segment PARAMS ((FILE *));
189 static int get_64bit_dynamic_segment PARAMS ((FILE *));
190 #ifdef SUPPORT_DISASSEMBLY
191 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
193 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
194 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
195 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
196 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
197 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
198 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
199 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
200 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
201 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
202 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
203 static void reset_state_machine PARAMS ((int));
204 static char * get_TAG_name PARAMS ((unsigned long));
205 static char * get_AT_name PARAMS ((unsigned long));
206 static char * get_FORM_name PARAMS ((unsigned long));
207 static void free_abbrevs PARAMS ((void));
208 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
209 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
210 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
211 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
212 static void decode_location_expression PARAMS ((unsigned char *, unsigned int));
213 static void request_dump PARAMS ((unsigned int, char));
214 static const char * get_elf_class PARAMS ((unsigned char));
215 static const char * get_data_encoding PARAMS ((unsigned char));
216 static const char * get_osabi_name PARAMS ((unsigned char));
217 static int guess_is_rela PARAMS ((unsigned long));
218 static char * get_note_type PARAMS ((unsigned int));
219 static int process_note PARAMS ((Elf32_Internal_Note *));
220 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
221 static int process_corefile_note_segments PARAMS ((FILE *));
222 static int process_corefile_contents PARAMS ((FILE *));
224 typedef int Elf32_Word;
232 #define SECTION_NAME(X) (string_table + (X)->sh_name)
234 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
236 #define BYTE_GET(field) byte_get (field, sizeof (field))
238 /* If we can support a 64 bit data type then BFD64 should be defined
239 and sizeof (bfd_vma) == 8. In this case when translating from an
240 external 8 byte field to an internal field, we can assume that the
241 internal field is also 8 bytes wide and so we can extact all the data.
242 If, however, BFD64 is not defined, then we must assume that the
243 internal data structure only has 4 byte wide fields that are the
244 equivalent of the 8 byte wide external counterparts, and so we must
245 truncate the data. */
247 #define BYTE_GET8(field) byte_get (field, -8)
249 #define BYTE_GET8(field) byte_get (field, 8)
252 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
254 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
255 if (fseek (file, offset, SEEK_SET)) \
257 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
261 var = (type) malloc (size); \
265 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
269 if (fread (var, size, 1, file) != 1) \
271 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
278 #define GET_DATA(offset, var, reason) \
279 if (fseek (file, offset, SEEK_SET)) \
281 error (_("Unable to seek to %x for %s\n"), offset, reason); \
284 else if (fread (& var, sizeof (var), 1, file) != 1) \
286 error (_("Unable to read data at %x for %s\n"), offset, reason); \
290 #define GET_ELF_SYMBOLS(file, offset, size) \
291 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
292 : get_64bit_elf_symbols (file, offset, size))
295 #ifdef ANSI_PROTOTYPES
297 error (const char * message, ...)
301 fprintf (stderr, _("%s: Error: "), program_name);
302 va_start (args, message);
303 vfprintf (stderr, message, args);
309 warn (const char * message, ...)
313 fprintf (stderr, _("%s: Warning: "), program_name);
314 va_start (args, message);
315 vfprintf (stderr, message, args);
327 fprintf (stderr, _("%s: Error: "), program_name);
329 message = va_arg (args, char *);
330 vfprintf (stderr, message, args);
342 fprintf (stderr, _("%s: Warning: "), program_name);
344 message = va_arg (args, char *);
345 vfprintf (stderr, message, args);
352 byte_get_little_endian (field, size)
353 unsigned char * field;
362 return ((unsigned int) (field [0]))
363 | (((unsigned int) (field [1])) << 8);
366 /* We want to extract data from an 8 byte wide field and
367 place it into a 4 byte wide field. Since this is a little
368 endian source we can juts use the 4 byte extraction code. */
371 return ((unsigned long) (field [0]))
372 | (((unsigned long) (field [1])) << 8)
373 | (((unsigned long) (field [2])) << 16)
374 | (((unsigned long) (field [3])) << 24);
378 /* This is a special case, generated by the BYTE_GET8 macro.
379 It means that we are loading an 8 byte value from a field
380 in an external structure into an 8 byte value in a field
381 in an internal strcuture. */
382 return ((bfd_vma) (field [0]))
383 | (((bfd_vma) (field [1])) << 8)
384 | (((bfd_vma) (field [2])) << 16)
385 | (((bfd_vma) (field [3])) << 24)
386 | (((bfd_vma) (field [4])) << 32)
387 | (((bfd_vma) (field [5])) << 40)
388 | (((bfd_vma) (field [6])) << 48)
389 | (((bfd_vma) (field [7])) << 56);
392 error (_("Unhandled data length: %d\n"), size);
397 /* Print a VMA value. */
399 print_vma (vma, mode)
409 case FULL_HEX: printf ("0x"); /* drop through */
410 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
411 case PREFIX_HEX: printf ("0x"); /* drop through */
412 case HEX: printf ("%lx", (unsigned long) vma); break;
413 case DEC: printf ("%ld", (unsigned long) vma); break;
414 case DEC_5: printf ("%5ld", (long) vma); break;
415 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
436 #if BFD_HOST_64BIT_LONG
439 if (_bfd_int64_high (vma))
440 printf ("%lx%lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
442 printf ("%lx", _bfd_int64_low (vma));
447 #if BFD_HOST_64BIT_LONG
450 if (_bfd_int64_high (vma))
452 printf ("++%ld", _bfd_int64_low (vma));
454 printf ("%ld", _bfd_int64_low (vma));
459 #if BFD_HOST_64BIT_LONG
460 printf ("%5ld", vma);
462 if (_bfd_int64_high (vma))
464 printf ("++%ld", _bfd_int64_low (vma));
466 printf ("%5ld", _bfd_int64_low (vma));
471 #if BFD_HOST_64BIT_LONG
474 if (_bfd_int64_high (vma))
476 printf ("++%lu", _bfd_int64_low (vma));
478 printf ("%lu", _bfd_int64_low (vma));
487 byte_get_big_endian (field, size)
488 unsigned char * field;
497 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
500 return ((unsigned long) (field [3]))
501 | (((unsigned long) (field [2])) << 8)
502 | (((unsigned long) (field [1])) << 16)
503 | (((unsigned long) (field [0])) << 24);
506 /* Although we are extracing data from an 8 byte wide field, we
507 are returning only 4 bytes of data. */
508 return ((unsigned long) (field [7]))
509 | (((unsigned long) (field [6])) << 8)
510 | (((unsigned long) (field [5])) << 16)
511 | (((unsigned long) (field [4])) << 24);
515 /* This is a special case, generated by the BYTE_GET8 macro.
516 It means that we are loading an 8 byte value from a field
517 in an external structure into an 8 byte value in a field
518 in an internal strcuture. */
519 return ((bfd_vma) (field [7]))
520 | (((bfd_vma) (field [6])) << 8)
521 | (((bfd_vma) (field [5])) << 16)
522 | (((bfd_vma) (field [4])) << 24)
523 | (((bfd_vma) (field [3])) << 32)
524 | (((bfd_vma) (field [2])) << 40)
525 | (((bfd_vma) (field [1])) << 48)
526 | (((bfd_vma) (field [0])) << 56);
530 error (_("Unhandled data length: %d\n"), size);
536 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
538 guess_is_rela (e_machine)
539 unsigned long e_machine;
543 /* Targets that use REL relocations. */
554 /* Targets that use RELA relocations. */
562 case EM_CYGNUS_MN10200:
563 case EM_CYGNUS_MN10300:
589 warn (_("Don't know about relocations on this machine architecture\n"));
594 /* Display the contents of the relocation data found at the specified offset. */
596 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
598 unsigned long rel_offset;
599 unsigned long rel_size;
600 Elf_Internal_Sym * symtab;
606 Elf_Internal_Rel * rels;
607 Elf_Internal_Rela * relas;
610 if (is_rela == UNKNOWN)
611 is_rela = guess_is_rela (elf_header.e_machine);
617 Elf32_External_Rela * erelas;
619 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
620 Elf32_External_Rela *, "relocs");
622 rel_size = rel_size / sizeof (Elf32_External_Rela);
624 relas = (Elf_Internal_Rela *)
625 malloc (rel_size * sizeof (Elf_Internal_Rela));
629 error(_("out of memory parsing relocs"));
633 for (i = 0; i < rel_size; i++)
635 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
636 relas[i].r_info = BYTE_GET (erelas[i].r_info);
637 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
642 rels = (Elf_Internal_Rel *) relas;
646 Elf64_External_Rela * erelas;
648 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
649 Elf64_External_Rela *, "relocs");
651 rel_size = rel_size / sizeof (Elf64_External_Rela);
653 relas = (Elf_Internal_Rela *)
654 malloc (rel_size * sizeof (Elf_Internal_Rela));
658 error(_("out of memory parsing relocs"));
662 for (i = 0; i < rel_size; i++)
664 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
665 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
666 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
671 rels = (Elf_Internal_Rel *) relas;
678 Elf32_External_Rel * erels;
680 GET_DATA_ALLOC (rel_offset, rel_size, erels,
681 Elf32_External_Rel *, "relocs");
683 rel_size = rel_size / sizeof (Elf32_External_Rel);
685 rels = (Elf_Internal_Rel *)
686 malloc (rel_size * sizeof (Elf_Internal_Rel));
690 error(_("out of memory parsing relocs"));
694 for (i = 0; i < rel_size; i++)
696 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
697 rels[i].r_info = BYTE_GET (erels[i].r_info);
702 relas = (Elf_Internal_Rela *) rels;
706 Elf64_External_Rel * erels;
708 GET_DATA_ALLOC (rel_offset, rel_size, erels,
709 Elf64_External_Rel *, "relocs");
711 rel_size = rel_size / sizeof (Elf64_External_Rel);
713 rels = (Elf_Internal_Rel *)
714 malloc (rel_size * sizeof (Elf_Internal_Rel));
718 error(_("out of memory parsing relocs"));
722 for (i = 0; i < rel_size; i++)
724 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
725 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
730 relas = (Elf_Internal_Rela *) rels;
736 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
739 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
741 for (i = 0; i < rel_size; i++)
746 bfd_vma symtab_index;
751 offset = relas [i].r_offset;
752 info = relas [i].r_info;
756 offset = rels [i].r_offset;
757 info = rels [i].r_info;
762 type = ELF32_R_TYPE (info);
763 symtab_index = ELF32_R_SYM (info);
767 if (elf_header.e_machine == EM_SPARCV9)
768 type = ELF64_R_TYPE_ID (info);
770 type = ELF64_R_TYPE (info);
771 /* The #ifdef BFD64 below is to prevent a compile time warning.
772 We know that if we do not have a 64 bit data type that we
773 will never execute this code anyway. */
775 symtab_index = ELF64_R_SYM (info);
779 #ifdef _bfd_int64_low
780 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
782 printf (" %8.8lx %5.5lx ", offset, info);
785 switch (elf_header.e_machine)
792 rtype = elf_m32r_reloc_type (type);
797 rtype = elf_i386_reloc_type (type);
801 rtype = elf_m68k_reloc_type (type);
805 rtype = elf_i960_reloc_type (type);
812 rtype = elf_sparc_reloc_type (type);
816 rtype = v850_reloc_type (type);
820 rtype = elf_d10v_reloc_type (type);
824 rtype = elf_d30v_reloc_type (type);
828 rtype = elf_sh_reloc_type (type);
831 case EM_CYGNUS_MN10300:
832 rtype = elf_mn10300_reloc_type (type);
835 case EM_CYGNUS_MN10200:
836 rtype = elf_mn10200_reloc_type (type);
840 rtype = elf_fr30_reloc_type (type);
844 rtype = elf_mcore_reloc_type (type);
848 rtype = elf_ppc_reloc_type (type);
853 rtype = elf_mips_reloc_type (type);
857 rtype = elf_alpha_reloc_type (type);
861 rtype = elf_arm_reloc_type (type);
865 rtype = elf_arc_reloc_type (type);
869 rtype = elf_hppa_reloc_type (type);
873 rtype = elf_pj_reloc_type (type);
878 #ifdef _bfd_int64_low
879 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
881 printf (_("unrecognised: %-7lx"), type);
884 printf ("%-21.21s", rtype);
890 if (symtab_index >= nsyms)
891 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
894 Elf_Internal_Sym * psym;
896 psym = symtab + symtab_index;
899 print_vma (psym->st_value, LONG_HEX);
902 if (psym->st_name == 0)
904 SECTION_NAME (section_headers + psym->st_shndx));
905 else if (strtab == NULL)
906 printf (_("<string table index %3ld>"), psym->st_name);
908 printf ("%-25.25s", strtab + psym->st_name);
911 printf (" + %lx", (unsigned long) relas [i].r_addend);
917 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
918 print_vma (relas[i].r_addend, LONG_HEX);
921 if (elf_header.e_machine == EM_SPARCV9
922 && !strcmp (rtype, "R_SPARC_OLO10"))
923 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
934 get_mips_dynamic_type (type)
939 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
940 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
941 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
942 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
943 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
944 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
945 case DT_MIPS_MSYM: return "MIPS_MSYM";
946 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
947 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
948 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
949 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
950 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
951 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
952 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
953 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
954 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
955 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
956 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
957 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
958 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
959 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
960 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
961 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
962 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
963 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
964 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
965 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
966 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
967 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
968 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
969 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
970 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
971 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
972 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
973 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
974 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
975 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
976 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
977 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
978 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
979 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
980 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
981 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
988 get_sparc64_dynamic_type (type)
993 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1000 get_parisc_dynamic_type (type)
1005 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1006 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1007 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1008 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1009 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1010 case DT_HP_PREINIT: return "HP_PREINIT";
1011 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1012 case DT_HP_NEEDED: return "HP_NEEDED";
1013 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1014 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1015 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1016 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1017 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1024 get_dynamic_type (type)
1027 static char buff [32];
1031 case DT_NULL: return "NULL";
1032 case DT_NEEDED: return "NEEDED";
1033 case DT_PLTRELSZ: return "PLTRELSZ";
1034 case DT_PLTGOT: return "PLTGOT";
1035 case DT_HASH: return "HASH";
1036 case DT_STRTAB: return "STRTAB";
1037 case DT_SYMTAB: return "SYMTAB";
1038 case DT_RELA: return "RELA";
1039 case DT_RELASZ: return "RELASZ";
1040 case DT_RELAENT: return "RELAENT";
1041 case DT_STRSZ: return "STRSZ";
1042 case DT_SYMENT: return "SYMENT";
1043 case DT_INIT: return "INIT";
1044 case DT_FINI: return "FINI";
1045 case DT_SONAME: return "SONAME";
1046 case DT_RPATH: return "RPATH";
1047 case DT_SYMBOLIC: return "SYMBOLIC";
1048 case DT_REL: return "REL";
1049 case DT_RELSZ: return "RELSZ";
1050 case DT_RELENT: return "RELENT";
1051 case DT_PLTREL: return "PLTREL";
1052 case DT_DEBUG: return "DEBUG";
1053 case DT_TEXTREL: return "TEXTREL";
1054 case DT_JMPREL: return "JMPREL";
1055 case DT_BIND_NOW: return "BIND_NOW";
1056 case DT_INIT_ARRAY: return "INIT_ARRAY";
1057 case DT_FINI_ARRAY: return "FINI_ARRAY";
1058 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1059 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1060 case DT_RUNPATH: return "RUNPATH";
1061 case DT_FLAGS: return "FLAGS";
1062 case DT_ENCODING: return "ENCODING";
1063 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1064 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1066 case DT_PLTPADSZ: return "PLTPADSZ";
1067 case DT_MOVEENT: return "MOVEENT";
1068 case DT_MOVESZ: return "MOVESZ";
1069 case DT_FEATURE_1: return "FEATURE_1";
1070 case DT_POSFLAG_1: return "POSFLAG_1";
1071 case DT_SYMINSZ: return "SYMINSZ";
1072 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1074 case DT_ADDRRNGLO: return "ADDRRNGLO";
1075 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1077 case DT_VERSYM: return "VERSYM";
1079 case DT_RELACOUNT: return "RELACOUNT";
1080 case DT_RELCOUNT: return "RELCOUNT";
1081 case DT_FLAGS_1: return "FLAGS_1";
1082 case DT_VERDEF: return "VERDEF";
1083 case DT_VERDEFNUM: return "VERDEFNUM";
1084 case DT_VERNEED: return "VERNEED";
1085 case DT_VERNEEDNUM: return "VERNEEDNUM";
1087 case DT_AUXILIARY: return "AUXILARY";
1088 case DT_USED: return "USED";
1089 case DT_FILTER: return "FILTER";
1092 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1094 const char * result;
1096 switch (elf_header.e_machine)
1099 case EM_MIPS_RS4_BE:
1100 result = get_mips_dynamic_type (type);
1103 result = get_sparc64_dynamic_type (type);
1113 sprintf (buff, _("Processor Specific: %lx"), type);
1115 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1117 const char * result;
1119 switch (elf_header.e_machine)
1122 result = get_parisc_dynamic_type (type);
1132 sprintf (buff, _("Operating System specific: %lx"), type);
1135 sprintf (buff, _("<unknown>: %lx"), type);
1142 get_file_type (e_type)
1145 static char buff [32];
1149 case ET_NONE: return _("NONE (None)");
1150 case ET_REL: return _("REL (Relocatable file)");
1151 case ET_EXEC: return _("EXEC (Executable file)");
1152 case ET_DYN: return _("DYN (Shared object file)");
1153 case ET_CORE: return _("CORE (Core file)");
1156 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1157 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1158 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1159 sprintf (buff, _("OS Specific: (%x)"), e_type);
1161 sprintf (buff, _("<unknown>: %x"), e_type);
1167 get_machine_name (e_machine)
1170 static char buff [64]; /* XXX */
1174 case EM_NONE: return _("None");
1175 case EM_M32: return "WE32100";
1176 case EM_SPARC: return "Sparc";
1177 case EM_386: return "Intel 80386";
1178 case EM_68K: return "MC68000";
1179 case EM_88K: return "MC88000";
1180 case EM_486: return "Intel 80486";
1181 case EM_860: return "Intel 80860";
1182 case EM_MIPS: return "MIPS R3000";
1183 case EM_S370: return "Amdahl";
1184 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1185 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1186 case EM_PARISC: return "HPPA";
1187 case EM_PPC_OLD: return "Power PC (old)";
1188 case EM_SPARC32PLUS: return "Sparc v8+" ;
1189 case EM_960: return "Intel 90860";
1190 case EM_PPC: return "PowerPC";
1191 case EM_V800: return "NEC V800";
1192 case EM_FR20: return "Fujitsu FR20";
1193 case EM_RH32: return "TRW RH32";
1194 case EM_MCORE: return "MCORE";
1195 case EM_ARM: return "ARM";
1196 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1197 case EM_SH: return "Hitachi SH";
1198 case EM_SPARCV9: return "Sparc v9";
1199 case EM_TRICORE: return "Siemens Tricore";
1200 case EM_ARC: return "Argonaut RISC Core";
1201 case EM_H8_300: return "Hitachi H8/300";
1202 case EM_H8_300H: return "Hitachi H8/300H";
1203 case EM_H8S: return "Hitachi H8S";
1204 case EM_H8_500: return "Hitachi H8/500";
1205 case EM_IA_64: return "Intel IA-64";
1206 case EM_MIPS_X: return "Stanford MIPS-X";
1207 case EM_COLDFIRE: return "Motorola Coldfire";
1208 case EM_68HC12: return "Motorola M68HC12";
1209 case EM_ALPHA: return "Alpha";
1210 case EM_CYGNUS_D10V: return "d10v";
1211 case EM_CYGNUS_D30V: return "d30v";
1212 case EM_CYGNUS_ARC: return "Arc";
1213 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1214 case EM_CYGNUS_V850: return "NEC v850";
1215 case EM_CYGNUS_MN10300: return "mn10300";
1216 case EM_CYGNUS_MN10200: return "mn10200";
1217 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1218 case EM_PJ: return "picoJava";
1219 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1220 case EM_PCP: return "Siemens PCP";
1221 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1222 case EM_NDR1: return "Denso NDR1 microprocesspr";
1223 case EM_STARCORE: return "Motorola Star*Core processor";
1224 case EM_ME16: return "Toyota ME16 processor";
1225 case EM_ST100: return "STMicroelectronics ST100 processor";
1226 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1227 case EM_FX66: return "Siemens FX66 microcontroller";
1228 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1229 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1230 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1231 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1232 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1233 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1234 case EM_SVX: return "Silicon Graphics SVx";
1235 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1236 case EM_VAX: return "Digital VAX";
1238 sprintf (buff, _("<unknown>: %x"), e_machine);
1244 get_machine_flags (e_flags, e_machine)
1248 static char buf [1024];
1260 if (e_flags & EF_CPU32)
1261 strcat (buf, ", cpu32");
1265 if (e_flags & EF_PPC_EMB)
1266 strcat (buf, ", emb");
1268 if (e_flags & EF_PPC_RELOCATABLE)
1269 strcat (buf, ", relocatable");
1271 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1272 strcat (buf, ", relocatable-lib");
1275 case EM_CYGNUS_V850:
1276 switch (e_flags & EF_V850_ARCH)
1279 strcat (buf, ", v850e");
1282 strcat (buf, ", v850ea");
1285 strcat (buf, ", v850");
1288 strcat (buf, ", unknown v850 architecture variant");
1293 case EM_CYGNUS_M32R:
1294 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1295 strcat (buf, ", m32r");
1300 case EM_MIPS_RS4_BE:
1301 if (e_flags & EF_MIPS_NOREORDER)
1302 strcat (buf, ", noreorder");
1304 if (e_flags & EF_MIPS_PIC)
1305 strcat (buf, ", pic");
1307 if (e_flags & EF_MIPS_CPIC)
1308 strcat (buf, ", cpic");
1310 if (e_flags & EF_MIPS_ABI2)
1311 strcat (buf, ", abi2");
1313 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1314 strcat (buf, ", mips1");
1316 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1317 strcat (buf, ", mips2");
1319 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1320 strcat (buf, ", mips3");
1322 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1323 strcat (buf, ", mips4");
1327 if (e_flags & EF_SPARC_32PLUS)
1328 strcat (buf, ", v8+");
1330 if (e_flags & EF_SPARC_SUN_US1)
1331 strcat (buf, ", ultrasparcI");
1333 if (e_flags & EF_SPARC_SUN_US3)
1334 strcat (buf, ", ultrasparcIII");
1336 if (e_flags & EF_SPARC_HAL_R1)
1337 strcat (buf, ", halr1");
1339 if (e_flags & EF_SPARC_LEDATA)
1340 strcat (buf, ", ledata");
1342 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1343 strcat (buf, ", tso");
1345 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1346 strcat (buf, ", pso");
1348 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1349 strcat (buf, ", rmo");
1353 switch (e_flags & EF_PARISC_ARCH)
1355 case EFA_PARISC_1_0:
1356 strcpy (buf, ", PA-RISC 1.0");
1358 case EFA_PARISC_1_1:
1359 strcpy (buf, ", PA-RISC 1.1");
1361 case EFA_PARISC_2_0:
1362 strcpy (buf, ", PA-RISC 2.0");
1367 if (e_flags & EF_PARISC_TRAPNIL)
1368 strcat (buf, ", trapnil");
1369 if (e_flags & EF_PARISC_EXT)
1370 strcat (buf, ", ext");
1371 if (e_flags & EF_PARISC_LSB)
1372 strcat (buf, ", lsb");
1373 if (e_flags & EF_PARISC_WIDE)
1374 strcat (buf, ", wide");
1375 if (e_flags & EF_PARISC_NO_KABP)
1376 strcat (buf, ", no kabp");
1377 if (e_flags & EF_PARISC_LAZYSWAP)
1378 strcat (buf, ", lazyswap");
1382 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1383 strcat (buf, ", new calling convention");
1385 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1386 strcat (buf, ", gnu calling convention");
1395 get_mips_segment_type (type)
1400 case PT_MIPS_REGINFO:
1402 case PT_MIPS_RTPROC:
1404 case PT_MIPS_OPTIONS:
1414 get_parisc_segment_type (type)
1419 case PT_HP_TLS: return "HP_TLS";
1420 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1421 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1422 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1423 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1424 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1425 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1426 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1427 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1428 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1429 case PT_HP_PARALLEL: return "HP_PARALLEL";
1430 case PT_HP_FASTBIND: return "HP_FASTBIND";
1431 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1432 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1441 get_segment_type (p_type)
1442 unsigned long p_type;
1444 static char buff [32];
1448 case PT_NULL: return "NULL";
1449 case PT_LOAD: return "LOAD";
1450 case PT_DYNAMIC: return "DYNAMIC";
1451 case PT_INTERP: return "INTERP";
1452 case PT_NOTE: return "NOTE";
1453 case PT_SHLIB: return "SHLIB";
1454 case PT_PHDR: return "PHDR";
1457 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1459 const char * result;
1461 switch (elf_header.e_machine)
1464 case EM_MIPS_RS4_BE:
1465 result = get_mips_segment_type (p_type);
1468 result = get_parisc_segment_type (p_type);
1478 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1480 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1482 const char * result;
1484 switch (elf_header.e_machine)
1487 result = get_parisc_segment_type (p_type);
1497 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1500 sprintf (buff, _("<unknown>: %lx"), p_type);
1507 get_mips_section_type_name (sh_type)
1508 unsigned int sh_type;
1512 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1513 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1514 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1515 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1516 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1517 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1518 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1519 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1520 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1521 case SHT_MIPS_RELD: return "MIPS_RELD";
1522 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1523 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1524 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1525 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1526 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1527 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1528 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1529 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1530 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1531 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1532 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1533 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1534 case SHT_MIPS_LINE: return "MIPS_LINE";
1535 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1536 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1537 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1538 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1539 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1540 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1541 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1542 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1543 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1544 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1545 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1546 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1547 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1548 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1549 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1550 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1558 get_parisc_section_type_name (sh_type)
1559 unsigned int sh_type;
1563 case SHT_PARISC_EXT: return "PARISC_EXT";
1564 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1565 case SHT_PARISC_DOC: return "PARISC_DOC";
1573 get_section_type_name (sh_type)
1574 unsigned int sh_type;
1576 static char buff [32];
1580 case SHT_NULL: return "NULL";
1581 case SHT_PROGBITS: return "PROGBITS";
1582 case SHT_SYMTAB: return "SYMTAB";
1583 case SHT_STRTAB: return "STRTAB";
1584 case SHT_RELA: return "RELA";
1585 case SHT_HASH: return "HASH";
1586 case SHT_DYNAMIC: return "DYNAMIC";
1587 case SHT_NOTE: return "NOTE";
1588 case SHT_NOBITS: return "NOBITS";
1589 case SHT_REL: return "REL";
1590 case SHT_SHLIB: return "SHLIB";
1591 case SHT_DYNSYM: return "DYNSYM";
1592 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1593 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1594 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1595 case SHT_GNU_verdef: return "VERDEF";
1596 case SHT_GNU_verneed: return "VERNEED";
1597 case SHT_GNU_versym: return "VERSYM";
1598 case 0x6ffffff0: return "VERSYM";
1599 case 0x6ffffffc: return "VERDEF";
1600 case 0x7ffffffd: return "AUXILIARY";
1601 case 0x7fffffff: return "FILTER";
1604 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1606 const char * result;
1608 switch (elf_header.e_machine)
1611 case EM_MIPS_RS4_BE:
1612 result = get_mips_section_type_name (sh_type);
1615 result = get_parisc_section_type_name (sh_type);
1625 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1627 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1628 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1629 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1630 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1632 sprintf (buff, _("<unknown>: %x"), sh_type);
1638 struct option options [] =
1640 {"all", no_argument, 0, 'a'},
1641 {"file-header", no_argument, 0, 'h'},
1642 {"program-headers", no_argument, 0, 'l'},
1643 {"headers", no_argument, 0, 'e'},
1644 {"histogram", no_argument, 0, 'I'},
1645 {"segments", no_argument, 0, 'l'},
1646 {"sections", no_argument, 0, 'S'},
1647 {"section-headers", no_argument, 0, 'S'},
1648 {"symbols", no_argument, 0, 's'},
1649 {"syms", no_argument, 0, 's'},
1650 {"relocs", no_argument, 0, 'r'},
1651 {"notes", no_argument, 0, 'n'},
1652 {"dynamic", no_argument, 0, 'd'},
1653 {"arch-specific", no_argument, 0, 'A'},
1654 {"version-info", no_argument, 0, 'V'},
1655 {"use-dynamic", no_argument, 0, 'D'},
1656 {"hex-dump", required_argument, 0, 'x'},
1657 {"debug-dump", optional_argument, 0, 'w'},
1658 #ifdef SUPPORT_DISASSEMBLY
1659 {"instruction-dump", required_argument, 0, 'i'},
1662 {"version", no_argument, 0, 'v'},
1663 {"help", no_argument, 0, 'H'},
1664 {0, no_argument, 0, 0}
1670 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1671 fprintf (stdout, _(" Options are:\n"));
1672 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1673 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1674 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1675 fprintf (stdout, _(" Display the program headers\n"));
1676 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1677 fprintf (stdout, _(" Display the sections' header\n"));
1678 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1679 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1680 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1681 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1682 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1683 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1684 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1685 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1686 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1687 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1688 fprintf (stdout, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1689 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
1690 #ifdef SUPPORT_DISASSEMBLY
1691 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1692 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1694 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1695 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1696 fprintf (stdout, _(" -H or --help Display this information\n"));
1697 fprintf (stdout, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1703 request_dump (section, type)
1704 unsigned int section;
1707 if (section >= num_dump_sects)
1709 char * new_dump_sects;
1711 new_dump_sects = (char *) calloc (section + 1, 1);
1713 if (new_dump_sects == NULL)
1714 error (_("Out of memory allocating dump request table."));
1717 /* Copy current flag settings. */
1718 memcpy (new_dump_sects, dump_sects, num_dump_sects);
1722 dump_sects = new_dump_sects;
1723 num_dump_sects = section + 1;
1728 dump_sects [section] |= type;
1734 parse_args (argc, argv)
1743 while ((c = getopt_long
1744 (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
1779 do_using_dynamic ++;
1807 section = strtoul (optarg, & cp, 0);
1808 if (! * cp && section >= 0)
1810 request_dump (section, HEX_DUMP);
1830 do_debug_abbrevs = 1;
1840 do_debug_pubnames = 1;
1845 do_debug_aranges = 1;
1849 warn (_("Unrecognised debug option '%s'\n"), optarg);
1854 #ifdef SUPPORT_DISASSEMBLY
1857 section = strtoul (optarg, & cp, 0);
1858 if (! * cp && section >= 0)
1860 request_dump (section, DISASS_DUMP);
1866 print_version (program_name);
1873 /* xgettext:c-format */
1874 error (_("Invalid option '-%c'\n"), c);
1881 if (!do_dynamic && !do_syms && !do_reloc && !do_sections
1882 && !do_segments && !do_header && !do_dump && !do_version
1883 && !do_histogram && !do_debugging && !do_arch && !do_notes)
1887 warn (_("Nothing to do.\n"));
1893 get_elf_class (elf_class)
1894 unsigned char elf_class;
1896 static char buff [32];
1900 case ELFCLASSNONE: return _("none");
1901 case ELFCLASS32: return _("ELF32");
1902 case ELFCLASS64: return _("ELF64");
1904 sprintf (buff, _("<unknown: %x>"), elf_class);
1910 get_data_encoding (encoding)
1911 unsigned char encoding;
1913 static char buff [32];
1917 case ELFDATANONE: return _("none");
1918 case ELFDATA2LSB: return _("2's complement, little endian");
1919 case ELFDATA2MSB: return _("2's complement, big endian");
1921 sprintf (buff, _("<unknown: %x>"), encoding);
1927 get_osabi_name (osabi)
1928 unsigned char osabi;
1930 static char buff [32];
1934 case ELFOSABI_SYSV: return _("UNIX - System V");
1935 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
1936 case ELFOSABI_STANDALONE: return _("Standalone App");
1938 sprintf (buff, _("<unknown: %x>"), osabi);
1943 /* Decode the data held in 'elf_header'. */
1945 process_file_header ()
1947 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
1948 || elf_header.e_ident [EI_MAG1] != ELFMAG1
1949 || elf_header.e_ident [EI_MAG2] != ELFMAG2
1950 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
1953 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1961 printf (_("ELF Header:\n"));
1962 printf (_(" Magic: "));
1963 for (i = 0; i < EI_NIDENT; i ++)
1964 printf ("%2.2x ", elf_header.e_ident [i]);
1966 printf (_(" Class: %s\n"),
1967 get_elf_class (elf_header.e_ident [EI_CLASS]));
1968 printf (_(" Data: %s\n"),
1969 get_data_encoding (elf_header.e_ident [EI_DATA]));
1970 printf (_(" Version: %d %s\n"),
1971 elf_header.e_ident [EI_VERSION],
1972 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
1974 : (elf_header.e_ident [EI_VERSION] != EV_NONE
1977 printf (_(" OS/ABI: %s\n"),
1978 get_osabi_name (elf_header.e_ident [EI_OSABI]));
1979 printf (_(" ABI Version: %d\n"),
1980 elf_header.e_ident [EI_ABIVERSION]);
1981 printf (_(" Type: %s\n"),
1982 get_file_type (elf_header.e_type));
1983 printf (_(" Machine: %s\n"),
1984 get_machine_name (elf_header.e_machine));
1985 printf (_(" Version: 0x%lx\n"),
1986 (unsigned long) elf_header.e_version);
1988 printf (_(" Entry point address: "));
1989 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
1990 printf (_("\n Start of program headers: "));
1991 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
1992 printf (_(" (bytes into file)\n Start of section headers: "));
1993 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
1994 printf (_(" (bytes into file)\n"));
1996 printf (_(" Flags: 0x%lx%s\n"),
1997 (unsigned long) elf_header.e_flags,
1998 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
1999 printf (_(" Size of this header: %ld (bytes)\n"),
2000 (long) elf_header.e_ehsize);
2001 printf (_(" Size of program headers: %ld (bytes)\n"),
2002 (long) elf_header.e_phentsize);
2003 printf (_(" Number of program headers: %ld\n"),
2004 (long) elf_header.e_phnum);
2005 printf (_(" Size of section headers: %ld (bytes)\n"),
2006 (long) elf_header.e_shentsize);
2007 printf (_(" Number of section headers: %ld\n"),
2008 (long) elf_header.e_shnum);
2009 printf (_(" Section header string table index: %ld\n"),
2010 (long) elf_header.e_shstrndx);
2018 get_32bit_program_headers (file, program_headers)
2020 Elf_Internal_Phdr * program_headers;
2022 Elf32_External_Phdr * phdrs;
2023 Elf32_External_Phdr * external;
2024 Elf32_Internal_Phdr * internal;
2027 GET_DATA_ALLOC (elf_header.e_phoff,
2028 elf_header.e_phentsize * elf_header.e_phnum,
2029 phdrs, Elf32_External_Phdr *, "program headers");
2031 for (i = 0, internal = program_headers, external = phdrs;
2032 i < elf_header.e_phnum;
2033 i ++, internal ++, external ++)
2035 internal->p_type = BYTE_GET (external->p_type);
2036 internal->p_offset = BYTE_GET (external->p_offset);
2037 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2038 internal->p_paddr = BYTE_GET (external->p_paddr);
2039 internal->p_filesz = BYTE_GET (external->p_filesz);
2040 internal->p_memsz = BYTE_GET (external->p_memsz);
2041 internal->p_flags = BYTE_GET (external->p_flags);
2042 internal->p_align = BYTE_GET (external->p_align);
2051 get_64bit_program_headers (file, program_headers)
2053 Elf_Internal_Phdr * program_headers;
2055 Elf64_External_Phdr * phdrs;
2056 Elf64_External_Phdr * external;
2057 Elf64_Internal_Phdr * internal;
2060 GET_DATA_ALLOC (elf_header.e_phoff,
2061 elf_header.e_phentsize * elf_header.e_phnum,
2062 phdrs, Elf64_External_Phdr *, "program headers");
2064 for (i = 0, internal = program_headers, external = phdrs;
2065 i < elf_header.e_phnum;
2066 i ++, internal ++, external ++)
2068 internal->p_type = BYTE_GET (external->p_type);
2069 internal->p_flags = BYTE_GET (external->p_flags);
2070 internal->p_offset = BYTE_GET8 (external->p_offset);
2071 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2072 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2073 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2074 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2075 internal->p_align = BYTE_GET8 (external->p_align);
2084 process_program_headers (file)
2087 Elf_Internal_Phdr * program_headers;
2088 Elf_Internal_Phdr * segment;
2091 if (elf_header.e_phnum == 0)
2094 printf (_("\nThere are no program headers in this file.\n"));
2098 if (do_segments && !do_header)
2100 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2101 printf (_("Entry point "));
2102 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2103 printf (_("\nThere are %d program headers, starting at offset "),
2104 elf_header.e_phnum);
2105 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2109 program_headers = (Elf_Internal_Phdr *) malloc
2110 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2112 if (program_headers == NULL)
2114 error (_("Out of memory\n"));
2119 i = get_32bit_program_headers (file, program_headers);
2121 i = get_64bit_program_headers (file, program_headers);
2125 free (program_headers);
2132 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2136 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2140 (_(" Type Offset VirtAddr PhysAddr\n"));
2142 (_(" FileSiz MemSiz Flags Align\n"));
2150 for (i = 0, segment = program_headers;
2151 i < elf_header.e_phnum;
2156 printf (" %-14.14s ", get_segment_type (segment->p_type));
2160 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2161 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2162 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2163 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2164 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2166 (segment->p_flags & PF_R ? 'R' : ' '),
2167 (segment->p_flags & PF_W ? 'W' : ' '),
2168 (segment->p_flags & PF_X ? 'E' : ' '));
2169 printf ("%#lx", (unsigned long) segment->p_align);
2173 print_vma (segment->p_offset, FULL_HEX);
2175 print_vma (segment->p_vaddr, FULL_HEX);
2177 print_vma (segment->p_paddr, FULL_HEX);
2179 print_vma (segment->p_filesz, FULL_HEX);
2181 print_vma (segment->p_memsz, FULL_HEX);
2183 (segment->p_flags & PF_R ? 'R' : ' '),
2184 (segment->p_flags & PF_W ? 'W' : ' '),
2185 (segment->p_flags & PF_X ? 'E' : ' '));
2186 print_vma (segment->p_align, HEX);
2190 switch (segment->p_type)
2194 loadaddr = (segment->p_vaddr & 0xfffff000)
2195 - (segment->p_offset & 0xfffff000);
2200 error (_("more than one dynamic segment\n"));
2202 dynamic_addr = segment->p_offset;
2203 dynamic_size = segment->p_filesz;
2207 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2208 error (_("Unable to find program interpreter name\n"));
2211 program_interpreter[0] = 0;
2212 fscanf (file, "%63s", program_interpreter);
2215 printf (_("\n [Requesting program interpreter: %s]"),
2216 program_interpreter);
2222 putc ('\n', stdout);
2231 if (do_segments && section_headers != NULL)
2233 printf (_("\n Section to Segment mapping:\n"));
2234 printf (_(" Segment Sections...\n"));
2236 assert (string_table != NULL);
2238 for (i = 0; i < elf_header.e_phnum; i++)
2241 Elf_Internal_Shdr * section;
2243 segment = program_headers + i;
2244 section = section_headers;
2246 printf (" %2.2d ", i);
2248 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2250 if (section->sh_size > 0
2251 /* Compare allocated sections by VMA, unallocated
2252 sections by file offset. */
2253 && (section->sh_flags & SHF_ALLOC
2254 ? (section->sh_addr >= segment->p_vaddr
2255 && section->sh_addr + section->sh_size
2256 <= segment->p_vaddr + segment->p_memsz)
2257 : ((bfd_vma) section->sh_offset >= segment->p_offset
2258 && (section->sh_offset + section->sh_size
2259 <= segment->p_offset + segment->p_filesz))))
2260 printf ("%s ", SECTION_NAME (section));
2267 free (program_headers);
2274 get_32bit_section_headers (file)
2277 Elf32_External_Shdr * shdrs;
2278 Elf32_Internal_Shdr * internal;
2281 GET_DATA_ALLOC (elf_header.e_shoff,
2282 elf_header.e_shentsize * elf_header.e_shnum,
2283 shdrs, Elf32_External_Shdr *, "section headers");
2285 section_headers = (Elf_Internal_Shdr *) malloc
2286 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2288 if (section_headers == NULL)
2290 error (_("Out of memory\n"));
2294 for (i = 0, internal = section_headers;
2295 i < elf_header.e_shnum;
2298 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2299 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2300 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2301 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2302 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2303 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2304 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2305 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2306 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2307 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2316 get_64bit_section_headers (file)
2319 Elf64_External_Shdr * shdrs;
2320 Elf64_Internal_Shdr * internal;
2323 GET_DATA_ALLOC (elf_header.e_shoff,
2324 elf_header.e_shentsize * elf_header.e_shnum,
2325 shdrs, Elf64_External_Shdr *, "section headers");
2327 section_headers = (Elf_Internal_Shdr *) malloc
2328 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2330 if (section_headers == NULL)
2332 error (_("Out of memory\n"));
2336 for (i = 0, internal = section_headers;
2337 i < elf_header.e_shnum;
2340 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2341 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2342 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2343 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2344 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2345 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2346 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2347 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2348 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2349 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2357 static Elf_Internal_Sym *
2358 get_32bit_elf_symbols (file, offset, number)
2360 unsigned long offset;
2361 unsigned long number;
2363 Elf32_External_Sym * esyms;
2364 Elf_Internal_Sym * isyms;
2365 Elf_Internal_Sym * psym;
2368 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2369 esyms, Elf32_External_Sym *, "symbols");
2371 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2375 error (_("Out of memory\n"));
2381 for (j = 0, psym = isyms;
2385 psym->st_name = BYTE_GET (esyms[j].st_name);
2386 psym->st_value = BYTE_GET (esyms[j].st_value);
2387 psym->st_size = BYTE_GET (esyms[j].st_size);
2388 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2389 psym->st_info = BYTE_GET (esyms[j].st_info);
2390 psym->st_other = BYTE_GET (esyms[j].st_other);
2398 static Elf_Internal_Sym *
2399 get_64bit_elf_symbols (file, offset, number)
2401 unsigned long offset;
2402 unsigned long number;
2404 Elf64_External_Sym * esyms;
2405 Elf_Internal_Sym * isyms;
2406 Elf_Internal_Sym * psym;
2409 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2410 esyms, Elf64_External_Sym *, "symbols");
2412 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2416 error (_("Out of memory\n"));
2422 for (j = 0, psym = isyms;
2426 psym->st_name = BYTE_GET (esyms[j].st_name);
2427 psym->st_info = BYTE_GET (esyms[j].st_info);
2428 psym->st_other = BYTE_GET (esyms[j].st_other);
2429 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2430 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2431 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2440 get_elf_section_flags (sh_flags)
2443 static char buff [32];
2451 flag = sh_flags & - sh_flags;
2456 case SHF_WRITE: strcat (buff, "W"); break;
2457 case SHF_ALLOC: strcat (buff, "A"); break;
2458 case SHF_EXECINSTR: strcat (buff, "X"); break;
2459 case SHF_MERGE: strcat (buff, "M"); break;
2460 case SHF_STRINGS: strcat (buff, "S"); break;
2461 case SHF_INFO_LINK: strcat (buff, "I"); break;
2462 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2463 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2466 if (flag & SHF_MASKOS)
2469 sh_flags &= ~ SHF_MASKOS;
2471 else if (flag & SHF_MASKPROC)
2474 sh_flags &= ~ SHF_MASKPROC;
2486 process_section_headers (file)
2489 Elf_Internal_Shdr * section;
2492 section_headers = NULL;
2494 if (elf_header.e_shnum == 0)
2497 printf (_("\nThere are no sections in this file.\n"));
2502 if (do_sections && !do_header)
2503 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2504 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2508 if (! get_32bit_section_headers (file))
2511 else if (! get_64bit_section_headers (file))
2514 /* Read in the string table, so that we have names to display. */
2515 section = section_headers + elf_header.e_shstrndx;
2517 if (section->sh_size != 0)
2519 unsigned long string_table_offset;
2521 string_table_offset = section->sh_offset;
2523 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2524 string_table, char *, "string table");
2527 /* Scan the sections for the dynamic symbol table
2528 and dynamic string table and debug sections. */
2529 dynamic_symbols = NULL;
2530 dynamic_strings = NULL;
2531 dynamic_syminfo = NULL;
2533 for (i = 0, section = section_headers;
2534 i < elf_header.e_shnum;
2537 char * name = SECTION_NAME (section);
2539 if (section->sh_type == SHT_DYNSYM)
2541 if (dynamic_symbols != NULL)
2543 error (_("File contains multiple dynamic symbol tables\n"));
2547 num_dynamic_syms = section->sh_size / section->sh_entsize;
2549 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2551 else if (section->sh_type == SHT_STRTAB
2552 && strcmp (name, ".dynstr") == 0)
2554 if (dynamic_strings != NULL)
2556 error (_("File contains multiple dynamic string tables\n"));
2560 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2561 dynamic_strings, char *, "dynamic strings");
2563 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2564 || do_debug_lines || do_debug_pubnames || do_debug_aranges)
2565 && strncmp (name, ".debug_", 7) == 0)
2570 || (do_debug_info && (strcmp (name, "info") == 0))
2571 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2572 || (do_debug_lines && (strcmp (name, "line") == 0))
2573 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2574 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2576 request_dump (i, DEBUG_DUMP);
2583 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2587 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2590 printf (_(" [Nr] Name Type Address Offset\n"));
2591 printf (_(" Size EntSize Flags Link Info Align\n"));
2594 for (i = 0, section = section_headers;
2595 i < elf_header.e_shnum;
2598 printf (" [%2d] %-17.17s %-15.15s ",
2600 SECTION_NAME (section),
2601 get_section_type_name (section->sh_type));
2605 print_vma (section->sh_addr, LONG_HEX);
2607 printf ( " %6.6lx %6.6lx %2.2lx",
2608 (unsigned long) section->sh_offset,
2609 (unsigned long) section->sh_size,
2610 (unsigned long) section->sh_entsize);
2612 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2614 printf (" %2ld %3lx %ld\n",
2615 (unsigned long) section->sh_link,
2616 (unsigned long) section->sh_info,
2617 (unsigned long) section->sh_addralign);
2622 print_vma (section->sh_addr, LONG_HEX);
2623 printf (" %8.8lx", section->sh_offset);
2625 print_vma (section->sh_size, LONG_HEX);
2627 print_vma (section->sh_entsize, LONG_HEX);
2629 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2631 printf (" %2ld %3lx %ld\n",
2632 (unsigned long) section->sh_link,
2633 (unsigned long) section->sh_info,
2634 (unsigned long) section->sh_addralign);
2638 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2639 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2640 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2645 /* Process the reloc section. */
2647 process_relocs (file)
2650 unsigned long rel_size;
2651 unsigned long rel_offset;
2657 if (do_using_dynamic)
2659 int is_rela = FALSE;
2664 if (dynamic_info[DT_REL])
2666 rel_offset = dynamic_info[DT_REL];
2667 rel_size = dynamic_info[DT_RELSZ];
2670 else if (dynamic_info [DT_RELA])
2672 rel_offset = dynamic_info[DT_RELA];
2673 rel_size = dynamic_info[DT_RELASZ];
2676 else if (dynamic_info[DT_JMPREL])
2678 rel_offset = dynamic_info[DT_JMPREL];
2679 rel_size = dynamic_info[DT_PLTRELSZ];
2681 switch (dynamic_info[DT_PLTREL])
2698 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2699 rel_offset, rel_size);
2701 dump_relocations (file, rel_offset - loadaddr, rel_size,
2702 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2705 printf (_("\nThere are no dynamic relocations in this file.\n"));
2709 Elf32_Internal_Shdr * section;
2713 for (i = 0, section = section_headers;
2714 i < elf_header.e_shnum;
2717 if ( section->sh_type != SHT_RELA
2718 && section->sh_type != SHT_REL)
2721 rel_offset = section->sh_offset;
2722 rel_size = section->sh_size;
2726 Elf32_Internal_Shdr * strsec;
2727 Elf32_Internal_Shdr * symsec;
2728 Elf_Internal_Sym * symtab;
2731 unsigned long nsyms;
2733 printf (_("\nRelocation section "));
2735 if (string_table == NULL)
2736 printf ("%d", section->sh_name);
2738 printf ("'%s'", SECTION_NAME (section));
2740 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2741 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2743 symsec = section_headers + section->sh_link;
2745 nsyms = symsec->sh_size / symsec->sh_entsize;
2746 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2751 strsec = section_headers + symsec->sh_link;
2753 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2754 char *, "string table");
2756 is_rela = section->sh_type == SHT_RELA;
2758 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2768 printf (_("\nThere are no relocations in this file.\n"));
2776 dynamic_segment_mips_val (entry)
2777 Elf_Internal_Dyn * entry;
2779 switch (entry->d_tag)
2782 if (entry->d_un.d_val == 0)
2786 static const char * opts[] =
2788 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2789 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2790 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2791 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2796 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2797 if (entry->d_un.d_val & (1 << cnt))
2799 printf ("%s%s", first ? "" : " ", opts[cnt]);
2806 case DT_MIPS_IVERSION:
2807 if (dynamic_strings != NULL)
2808 printf ("Interface Version: %s\n",
2809 dynamic_strings + entry->d_un.d_val);
2811 printf ("%ld\n", (long) entry->d_un.d_ptr);
2814 case DT_MIPS_TIME_STAMP:
2817 time_t time = entry->d_un.d_val;
2818 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
2819 printf ("Time Stamp: %s\n", timebuf);
2823 case DT_MIPS_RLD_VERSION:
2824 case DT_MIPS_LOCAL_GOTNO:
2825 case DT_MIPS_CONFLICTNO:
2826 case DT_MIPS_LIBLISTNO:
2827 case DT_MIPS_SYMTABNO:
2828 case DT_MIPS_UNREFEXTNO:
2829 case DT_MIPS_HIPAGENO:
2830 case DT_MIPS_DELTA_CLASS_NO:
2831 case DT_MIPS_DELTA_INSTANCE_NO:
2832 case DT_MIPS_DELTA_RELOC_NO:
2833 case DT_MIPS_DELTA_SYM_NO:
2834 case DT_MIPS_DELTA_CLASSSYM_NO:
2835 case DT_MIPS_COMPACT_SIZE:
2836 printf ("%ld\n", (long) entry->d_un.d_ptr);
2840 printf ("%#lx\n", (long) entry->d_un.d_ptr);
2846 dynamic_segment_parisc_val (entry)
2847 Elf_Internal_Dyn * entry;
2849 switch (entry->d_tag)
2851 case DT_HP_DLD_FLAGS:
2860 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
2861 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
2862 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
2863 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
2864 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
2865 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
2866 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
2867 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
2868 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
2869 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
2870 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
2874 bfd_vma val = entry->d_un.d_val;
2876 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
2877 if (val & flags[cnt].bit)
2881 fputs (flags[cnt].str, stdout);
2883 val ^= flags[cnt].bit;
2886 if (val != 0 || first)
2890 print_vma (val, HEX);
2896 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
2902 get_32bit_dynamic_segment (file)
2905 Elf32_External_Dyn * edyn;
2906 Elf_Internal_Dyn * entry;
2909 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
2910 edyn, Elf32_External_Dyn *, "dynamic segment");
2912 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2913 how large this .dynamic is now. We can do this even before the byte
2914 swapping since the DT_NULL tag is recognizable. */
2916 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
2919 dynamic_segment = (Elf_Internal_Dyn *)
2920 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
2922 if (dynamic_segment == NULL)
2924 error (_("Out of memory\n"));
2929 for (i = 0, entry = dynamic_segment;
2933 entry->d_tag = BYTE_GET (edyn [i].d_tag);
2934 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
2943 get_64bit_dynamic_segment (file)
2946 Elf64_External_Dyn * edyn;
2947 Elf_Internal_Dyn * entry;
2950 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
2951 edyn, Elf64_External_Dyn *, "dynamic segment");
2953 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2954 how large this .dynamic is now. We can do this even before the byte
2955 swapping since the DT_NULL tag is recognizable. */
2957 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
2960 dynamic_segment = (Elf_Internal_Dyn *)
2961 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
2963 if (dynamic_segment == NULL)
2965 error (_("Out of memory\n"));
2970 for (i = 0, entry = dynamic_segment;
2974 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
2975 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
2984 get_dynamic_flags (flags)
2987 static char buff [64];
2992 flag = flags & - flags;
2997 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
2998 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
2999 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3000 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3001 default: strcat (buff, "unknown "); return;
3006 /* Parse and display the contents of the dynamic segment. */
3008 process_dynamic_segment (file)
3011 Elf_Internal_Dyn * entry;
3014 if (dynamic_size == 0)
3017 printf (_("\nThere is no dynamic segment in this file.\n"));
3024 if (! get_32bit_dynamic_segment (file))
3027 else if (! get_64bit_dynamic_segment (file))
3030 /* Find the appropriate symbol table. */
3031 if (dynamic_symbols == NULL)
3033 for (i = 0, entry = dynamic_segment;
3037 unsigned long offset;
3039 if (entry->d_tag != DT_SYMTAB)
3042 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3044 /* Since we do not know how big the symbol table is,
3045 we default to reading in the entire file (!) and
3046 processing that. This is overkill, I know, but it
3048 offset = entry->d_un.d_val - loadaddr;
3050 if (fseek (file, 0, SEEK_END))
3051 error (_("Unable to seek to end of file!"));
3054 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3056 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3058 if (num_dynamic_syms < 1)
3060 error (_("Unable to determine the number of symbols to load\n"));
3064 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3068 /* Similarly find a string table. */
3069 if (dynamic_strings == NULL)
3071 for (i = 0, entry = dynamic_segment;
3075 unsigned long offset;
3078 if (entry->d_tag != DT_STRTAB)
3081 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3083 /* Since we do not know how big the string table is,
3084 we default to reading in the entire file (!) and
3085 processing that. This is overkill, I know, but it
3088 offset = entry->d_un.d_val - loadaddr;
3089 if (fseek (file, 0, SEEK_END))
3090 error (_("Unable to seek to end of file\n"));
3091 str_tab_len = ftell (file) - offset;
3093 if (str_tab_len < 1)
3096 (_("Unable to determine the length of the dynamic string table\n"));
3100 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3101 "dynamic string table");
3107 /* And find the syminfo section if available. */
3108 if (dynamic_syminfo == NULL)
3110 unsigned int syminsz = 0;
3112 for (i = 0, entry = dynamic_segment;
3116 if (entry->d_tag == DT_SYMINENT)
3118 /* Note: these braces are necessary to avoid a syntax
3119 error from the SunOS4 C compiler. */
3120 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3122 else if (entry->d_tag == DT_SYMINSZ)
3123 syminsz = entry->d_un.d_val;
3124 else if (entry->d_tag == DT_SYMINFO)
3125 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3128 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3130 Elf_External_Syminfo * extsyminfo;
3131 Elf_Internal_Syminfo * syminfo;
3133 /* There is a syminfo section. Read the data. */
3134 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3135 Elf_External_Syminfo *, "symbol information");
3137 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3138 if (dynamic_syminfo == NULL)
3140 error (_("Out of memory\n"));
3144 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3145 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3148 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3149 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3156 if (do_dynamic && dynamic_addr)
3157 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3158 dynamic_addr, (long) dynamic_size);
3160 printf (_(" Tag Type Name/Value\n"));
3162 for (i = 0, entry = dynamic_segment;
3169 print_vma (entry->d_tag, FULL_HEX);
3171 get_dynamic_type (entry->d_tag),
3172 (is_32bit_elf ? 27 : 19) - strlen (get_dynamic_type (entry->d_tag)),
3176 switch (entry->d_tag)
3180 printf (get_dynamic_flags (entry->d_un.d_val));
3187 if (entry->d_tag == DT_AUXILIARY)
3188 printf (_("Auxiliary library"));
3190 printf (_("Filter library"));
3192 if (dynamic_strings)
3193 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3197 print_vma (entry->d_un.d_val, PREFIX_HEX);
3206 printf (_("Flags:"));
3207 if (entry->d_un.d_val == 0)
3208 printf (_(" None\n"));
3211 unsigned long int val = entry->d_un.d_val;
3212 if (val & DTF_1_PARINIT)
3214 printf (" PARINIT");
3215 val ^= DTF_1_PARINIT;
3218 printf (" %lx", val);
3227 printf (_("Flags:"));
3228 if (entry->d_un.d_val == 0)
3229 printf (_(" None\n"));
3232 unsigned long int val = entry->d_un.d_val;
3233 if (val & DF_P1_LAZYLOAD)
3235 printf (" LAZYLOAD");
3236 val ^= DF_P1_LAZYLOAD;
3238 if (val & DF_P1_GROUPPERM)
3240 printf (" GROUPPERM");
3241 val ^= DF_P1_GROUPPERM;
3244 printf (" %lx", val);
3253 printf (_("Flags:"));
3254 if (entry->d_un.d_val == 0)
3255 printf (_(" None\n"));
3258 unsigned long int val = entry->d_un.d_val;
3264 if (val & DF_1_GLOBAL)
3269 if (val & DF_1_GROUP)
3274 if (val & DF_1_NODELETE)
3276 printf (" NODELETE");
3277 val ^= DF_1_NODELETE;
3279 if (val & DF_1_LOADFLTR)
3281 printf (" LOADFLTR");
3282 val ^= DF_1_LOADFLTR;
3284 if (val & DF_1_INITFIRST)
3286 printf (" INITFIRST");
3287 val ^= DF_1_INITFIRST;
3289 if (val & DF_1_NOOPEN)
3294 if (val & DF_1_ORIGIN)
3299 if (val & DF_1_DIRECT)
3304 if (val & DF_1_TRANS)
3309 if (val & DF_1_INTERPOSE)
3311 printf (" INTERPOSE");
3312 val ^= DF_1_INTERPOSE;
3315 printf (" %lx", val);
3323 puts (get_dynamic_type (entry->d_un.d_val));
3342 dynamic_info[entry->d_tag] = entry->d_un.d_val;
3348 if (dynamic_strings == NULL)
3351 name = dynamic_strings + entry->d_un.d_val;
3355 switch (entry->d_tag)
3358 printf (_("Shared library: [%s]"), name);
3360 if (strcmp (name, program_interpreter) == 0)
3361 printf (_(" program interpreter"));
3365 printf (_("Library soname: [%s]"), name);
3369 printf (_("Library rpath: [%s]"), name);
3373 print_vma (entry->d_un.d_val, PREFIX_HEX);
3378 print_vma (entry->d_un.d_val, PREFIX_HEX);
3394 case DT_INIT_ARRAYSZ:
3395 case DT_FINI_ARRAYSZ:
3398 print_vma (entry->d_un.d_val, UNSIGNED);
3399 printf (" (bytes)\n");
3409 print_vma (entry->d_un.d_val, UNSIGNED);
3422 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3426 name = dynamic_strings + entry->d_un.d_val;
3430 printf (_("Not needed object: [%s]\n"), name);
3435 print_vma (entry->d_un.d_val, PREFIX_HEX);
3441 /* The value of this entry is ignored. */
3445 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3446 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3451 switch (elf_header.e_machine)
3454 case EM_MIPS_RS4_BE:
3455 dynamic_segment_mips_val (entry);
3458 dynamic_segment_parisc_val (entry);
3461 print_vma (entry->d_un.d_val, PREFIX_HEX);
3473 get_ver_flags (flags)
3476 static char buff [32];
3483 if (flags & VER_FLG_BASE)
3484 strcat (buff, "BASE ");
3486 if (flags & VER_FLG_WEAK)
3488 if (flags & VER_FLG_BASE)
3489 strcat (buff, "| ");
3491 strcat (buff, "WEAK ");
3494 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3495 strcat (buff, "| <unknown>");
3500 /* Display the contents of the version sections. */
3502 process_version_sections (file)
3505 Elf32_Internal_Shdr * section;
3512 for (i = 0, section = section_headers;
3513 i < elf_header.e_shnum;
3516 switch (section->sh_type)
3518 case SHT_GNU_verdef:
3520 Elf_External_Verdef * edefs;
3527 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3528 SECTION_NAME (section), section->sh_info);
3530 printf (_(" Addr: 0x"));
3531 printf_vma (section->sh_addr);
3532 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3533 (unsigned long) section->sh_offset, section->sh_link,
3534 SECTION_NAME (section_headers + section->sh_link));
3536 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3537 edefs, Elf_External_Verdef *,
3538 "version definition section");
3540 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3543 Elf_External_Verdef * edef;
3544 Elf_Internal_Verdef ent;
3545 Elf_External_Verdaux * eaux;
3546 Elf_Internal_Verdaux aux;
3550 vstart = ((char *) edefs) + idx;
3552 edef = (Elf_External_Verdef *) vstart;
3554 ent.vd_version = BYTE_GET (edef->vd_version);
3555 ent.vd_flags = BYTE_GET (edef->vd_flags);
3556 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
3557 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
3558 ent.vd_hash = BYTE_GET (edef->vd_hash);
3559 ent.vd_aux = BYTE_GET (edef->vd_aux);
3560 ent.vd_next = BYTE_GET (edef->vd_next);
3562 printf (_(" %#06x: Rev: %d Flags: %s"),
3563 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3565 printf (_(" Index: %d Cnt: %d "),
3566 ent.vd_ndx, ent.vd_cnt);
3568 vstart += ent.vd_aux;
3570 eaux = (Elf_External_Verdaux *) vstart;
3572 aux.vda_name = BYTE_GET (eaux->vda_name);
3573 aux.vda_next = BYTE_GET (eaux->vda_next);
3575 if (dynamic_strings)
3576 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3578 printf (_("Name index: %ld\n"), aux.vda_name);
3580 isum = idx + ent.vd_aux;
3582 for (j = 1; j < ent.vd_cnt; j ++)
3584 isum += aux.vda_next;
3585 vstart += aux.vda_next;
3587 eaux = (Elf_External_Verdaux *) vstart;
3589 aux.vda_name = BYTE_GET (eaux->vda_name);
3590 aux.vda_next = BYTE_GET (eaux->vda_next);
3592 if (dynamic_strings)
3593 printf (_(" %#06x: Parent %d: %s\n"),
3594 isum, j, dynamic_strings + aux.vda_name);
3596 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3597 isum, j, aux.vda_name);
3607 case SHT_GNU_verneed:
3609 Elf_External_Verneed * eneed;
3615 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3616 SECTION_NAME (section), section->sh_info);
3618 printf (_(" Addr: 0x"));
3619 printf_vma (section->sh_addr);
3620 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3621 (unsigned long) section->sh_offset, section->sh_link,
3622 SECTION_NAME (section_headers + section->sh_link));
3624 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3625 eneed, Elf_External_Verneed *,
3626 "version need section");
3628 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3630 Elf_External_Verneed * entry;
3631 Elf_Internal_Verneed ent;
3636 vstart = ((char *) eneed) + idx;
3638 entry = (Elf_External_Verneed *) vstart;
3640 ent.vn_version = BYTE_GET (entry->vn_version);
3641 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
3642 ent.vn_file = BYTE_GET (entry->vn_file);
3643 ent.vn_aux = BYTE_GET (entry->vn_aux);
3644 ent.vn_next = BYTE_GET (entry->vn_next);
3646 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
3648 if (dynamic_strings)
3649 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
3651 printf (_(" File: %lx"), ent.vn_file);
3653 printf (_(" Cnt: %d\n"), ent.vn_cnt);
3655 vstart += ent.vn_aux;
3657 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3659 Elf_External_Vernaux * eaux;
3660 Elf_Internal_Vernaux aux;
3662 eaux = (Elf_External_Vernaux *) vstart;
3664 aux.vna_hash = BYTE_GET (eaux->vna_hash);
3665 aux.vna_flags = BYTE_GET (eaux->vna_flags);
3666 aux.vna_other = BYTE_GET (eaux->vna_other);
3667 aux.vna_name = BYTE_GET (eaux->vna_name);
3668 aux.vna_next = BYTE_GET (eaux->vna_next);
3670 if (dynamic_strings)
3671 printf (_(" %#06x: Name: %s"),
3672 isum, dynamic_strings + aux.vna_name);
3674 printf (_(" %#06x: Name index: %lx"),
3675 isum, aux.vna_name);
3677 printf (_(" Flags: %s Version: %d\n"),
3678 get_ver_flags (aux.vna_flags), aux.vna_other);
3680 isum += aux.vna_next;
3681 vstart += aux.vna_next;
3691 case SHT_GNU_versym:
3693 Elf32_Internal_Shdr * link_section;
3696 unsigned char * edata;
3697 unsigned short * data;
3699 Elf_Internal_Sym * symbols;
3700 Elf32_Internal_Shdr * string_sec;
3702 link_section = section_headers + section->sh_link;
3703 total = section->sh_size / section->sh_entsize;
3707 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3708 link_section->sh_size / link_section->sh_entsize);
3710 string_sec = section_headers + link_section->sh_link;
3712 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3713 strtab, char *, "version string table");
3715 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3716 SECTION_NAME (section), total);
3718 printf (_(" Addr: "));
3719 printf_vma (section->sh_addr);
3720 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3721 (unsigned long) section->sh_offset, section->sh_link,
3722 SECTION_NAME (link_section));
3724 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3726 total * sizeof (short), edata,
3727 unsigned char *, "version symbol data");
3729 data = (unsigned short *) malloc (total * sizeof (short));
3731 for (cnt = total; cnt --;)
3732 data [cnt] = byte_get (edata + cnt * sizeof (short),
3737 for (cnt = 0; cnt < total; cnt += 4)
3741 printf (" %03x:", cnt);
3743 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3744 switch (data [cnt + j])
3747 fputs (_(" 0 (*local*) "), stdout);
3751 fputs (_(" 1 (*global*) "), stdout);
3755 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
3756 data [cnt + j] & 0x8000 ? 'h' : ' ');
3758 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
3759 && section_headers[symbols [cnt + j].st_shndx].sh_type
3762 /* We must test both. */
3763 Elf_Internal_Verneed ivn;
3764 unsigned long offset;
3766 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3771 Elf_External_Verneed evn;
3772 Elf_External_Vernaux evna;
3773 Elf_Internal_Vernaux ivna;
3774 unsigned long vna_off;
3776 GET_DATA (offset, evn, "version need");
3778 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3779 ivn.vn_next = BYTE_GET (evn.vn_next);
3781 vna_off = offset + ivn.vn_aux;
3785 GET_DATA (vna_off, evna,
3786 "version need aux (1)");
3788 ivna.vna_next = BYTE_GET (evna.vna_next);
3789 ivna.vna_other = BYTE_GET (evna.vna_other);
3791 vna_off += ivna.vna_next;
3793 while (ivna.vna_other != data [cnt + j]
3794 && ivna.vna_next != 0);
3796 if (ivna.vna_other == data [cnt + j])
3798 ivna.vna_name = BYTE_GET (evna.vna_name);
3800 nn += printf ("(%s%-*s",
3801 strtab + ivna.vna_name,
3807 else if (ivn.vn_next == 0)
3809 if (data [cnt + j] != 0x8001)
3811 Elf_Internal_Verdef ivd;
3812 Elf_External_Verdef evd;
3814 offset = version_info
3815 [DT_VERSIONTAGIDX (DT_VERDEF)]
3820 GET_DATA (offset, evd,
3821 "version definition");
3823 ivd.vd_next = BYTE_GET (evd.vd_next);
3824 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
3826 offset += ivd.vd_next;
3829 != (data [cnt + j] & 0x7fff)
3830 && ivd.vd_next != 0);
3833 == (data [cnt + j] & 0x7fff))
3835 Elf_External_Verdaux evda;
3836 Elf_Internal_Verdaux ivda;
3838 ivd.vd_aux = BYTE_GET (evd.vd_aux);
3840 GET_DATA (offset + ivd.vd_aux, evda,
3841 "version definition aux");
3844 BYTE_GET (evda.vda_name);
3848 strtab + ivda.vda_name,
3859 offset += ivn.vn_next;
3861 while (ivn.vn_next);
3863 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
3865 Elf_Internal_Verneed ivn;
3866 unsigned long offset;
3868 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
3873 Elf_Internal_Vernaux ivna;
3874 Elf_External_Verneed evn;
3875 Elf_External_Vernaux evna;
3876 unsigned long a_off;
3878 GET_DATA (offset, evn, "version need");
3880 ivn.vn_aux = BYTE_GET (evn.vn_aux);
3881 ivn.vn_next = BYTE_GET (evn.vn_next);
3883 a_off = offset + ivn.vn_aux;
3887 GET_DATA (a_off, evna,
3888 "version need aux (2)");
3890 ivna.vna_next = BYTE_GET (evna.vna_next);
3891 ivna.vna_other = BYTE_GET (evna.vna_other);
3893 a_off += ivna.vna_next;
3895 while (ivna.vna_other != data [cnt + j]
3896 && ivna.vna_next != 0);
3898 if (ivna.vna_other == data [cnt + j])
3900 ivna.vna_name = BYTE_GET (evna.vna_name);
3902 nn += printf ("(%s%-*s",
3903 strtab + ivna.vna_name,
3910 offset += ivn.vn_next;
3912 while (ivn.vn_next);
3914 else if (data [cnt + j] != 0x8001)
3916 Elf_Internal_Verdef ivd;
3917 Elf_External_Verdef evd;
3918 unsigned long offset;
3920 offset = version_info
3921 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
3925 GET_DATA (offset, evd, "version def");
3927 ivd.vd_next = BYTE_GET (evd.vd_next);
3928 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
3930 offset += ivd.vd_next;
3932 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
3933 && ivd.vd_next != 0);
3935 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
3937 Elf_External_Verdaux evda;
3938 Elf_Internal_Verdaux ivda;
3940 ivd.vd_aux = BYTE_GET (evd.vd_aux);
3942 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
3943 evda, "version def aux");
3945 ivda.vda_name = BYTE_GET (evda.vda_name);
3947 nn += printf ("(%s%-*s",
3948 strtab + ivda.vda_name,
3956 printf ("%*c", 18 - nn, ' ');
3974 printf (_("\nNo version information found in this file.\n"));
3980 get_symbol_binding (binding)
3981 unsigned int binding;
3983 static char buff [32];
3987 case STB_LOCAL: return "LOCAL";
3988 case STB_GLOBAL: return "GLOBAL";
3989 case STB_WEAK: return "WEAK";
3991 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
3992 sprintf (buff, _("<processor specific>: %d"), binding);
3993 else if (binding >= STB_LOOS && binding <= STB_HIOS)
3994 sprintf (buff, _("<OS specific>: %d"), binding);
3996 sprintf (buff, _("<unknown>: %d"), binding);
4002 get_symbol_type (type)
4005 static char buff [32];
4009 case STT_NOTYPE: return "NOTYPE";
4010 case STT_OBJECT: return "OBJECT";
4011 case STT_FUNC: return "FUNC";
4012 case STT_SECTION: return "SECTION";
4013 case STT_FILE: return "FILE";
4014 case STT_COMMON: return "COMMON";
4016 if (type >= STT_LOPROC && type <= STT_HIPROC)
4018 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4019 return "THUMB_FUNC";
4021 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4024 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4025 return "PARISC_MILLI";
4027 sprintf (buff, _("<processor specific>: %d"), type);
4029 else if (type >= STT_LOOS && type <= STT_HIOS)
4031 if (elf_header.e_machine == EM_PARISC)
4033 if (type == STT_HP_OPAQUE)
4035 if (type == STT_HP_STUB)
4039 sprintf (buff, _("<OS specific>: %d"), type);
4042 sprintf (buff, _("<unknown>: %d"), type);
4048 get_symbol_visibility (visibility)
4049 unsigned int visibility;
4053 case STV_DEFAULT: return "DEFAULT";
4054 case STV_INTERNAL: return "INTERNAL";
4055 case STV_HIDDEN: return "HIDDEN";
4056 case STV_PROTECTED: return "PROTECTED";
4062 get_symbol_index_type (type)
4067 case SHN_UNDEF: return "UND";
4068 case SHN_ABS: return "ABS";
4069 case SHN_COMMON: return "COM";
4071 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4073 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4075 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4079 static char buff [32];
4081 sprintf (buff, "%3d", type);
4088 get_dynamic_data (file, number)
4090 unsigned int number;
4095 e_data = (char *) malloc (number * 4);
4099 error (_("Out of memory\n"));
4103 if (fread (e_data, 4, number, file) != number)
4105 error (_("Unable to read in dynamic data\n"));
4109 i_data = (int *) malloc (number * sizeof (* i_data));
4113 error (_("Out of memory\n"));
4119 i_data [number] = byte_get (e_data + number * 4, 4);
4126 /* Dump the symbol table */
4128 process_symbol_table (file)
4131 Elf32_Internal_Shdr * section;
4136 int * buckets = NULL;
4137 int * chains = NULL;
4139 if (! do_syms && !do_histogram)
4142 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4145 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4147 error (_("Unable to seek to start of dynamic information"));
4151 if (fread (nb, sizeof (nb), 1, file) != 1)
4153 error (_("Failed to read in number of buckets\n"));
4157 if (fread (nc, sizeof (nc), 1, file) != 1)
4159 error (_("Failed to read in number of chains\n"));
4163 nbuckets = byte_get (nb, 4);
4164 nchains = byte_get (nc, 4);
4166 buckets = get_dynamic_data (file, nbuckets);
4167 chains = get_dynamic_data (file, nchains);
4169 if (buckets == NULL || chains == NULL)
4174 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4179 printf (_("\nSymbol table for image:\n"));
4181 printf (_(" Num Buc: Value Size Type Bind Vis Ot Ndx Name\n"));
4183 printf (_(" Num Buc: Value Size Type Bind Vis Ot Ndx Name\n"));
4185 for (hn = 0; hn < nbuckets; hn++)
4190 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4192 Elf_Internal_Sym * psym;
4194 psym = dynamic_symbols + si;
4196 printf (" %3d %3d: ", si, hn);
4197 print_vma (psym->st_value, LONG_HEX);
4199 print_vma (psym->st_size, DEC_5);
4201 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4202 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4203 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4204 printf (" %2d", ELF_ST_OTHER (psym->st_other));
4205 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4206 printf (" %s\n", dynamic_strings + psym->st_name);
4210 else if (do_syms && !do_using_dynamic)
4214 for (i = 0, section = section_headers;
4215 i < elf_header.e_shnum;
4220 Elf_Internal_Sym * symtab;
4221 Elf_Internal_Sym * psym;
4224 if ( section->sh_type != SHT_SYMTAB
4225 && section->sh_type != SHT_DYNSYM)
4228 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4229 SECTION_NAME (section),
4230 (unsigned long) (section->sh_size / section->sh_entsize));
4232 printf (_(" Num: Value Size Type Bind Vis Ot Ndx Name\n"));
4234 printf (_(" Num: Value Size Type Bind Vis Ot Ndx Name\n"));
4236 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4237 section->sh_size / section->sh_entsize);
4241 if (section->sh_link == elf_header.e_shstrndx)
4242 strtab = string_table;
4245 Elf32_Internal_Shdr * string_sec;
4247 string_sec = section_headers + section->sh_link;
4249 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4250 strtab, char *, "string table");
4253 for (si = 0, psym = symtab;
4254 si < section->sh_size / section->sh_entsize;
4257 printf ("%6d: ", si);
4258 print_vma (psym->st_value, LONG_HEX);
4260 print_vma (psym->st_size, DEC_5);
4261 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4262 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4263 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4264 printf (" %2d", ELF_ST_OTHER (psym->st_other));
4265 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4266 printf (" %s", strtab + psym->st_name);
4268 if (section->sh_type == SHT_DYNSYM &&
4269 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4271 unsigned char data[2];
4272 unsigned short vers_data;
4273 unsigned long offset;
4277 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4280 GET_DATA (offset + si * sizeof (vers_data), data,
4283 vers_data = byte_get (data, 2);
4285 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4286 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4289 check_def = (psym->st_shndx != SHN_UNDEF);
4291 if ((vers_data & 0x8000) || vers_data > 1)
4293 if (is_nobits || ! check_def)
4295 Elf_External_Verneed evn;
4296 Elf_Internal_Verneed ivn;
4297 Elf_Internal_Vernaux ivna;
4299 /* We must test both. */
4300 offset = version_info
4301 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4303 GET_DATA (offset, evn, "version need");
4305 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4306 ivn.vn_next = BYTE_GET (evn.vn_next);
4310 unsigned long vna_off;
4312 vna_off = offset + ivn.vn_aux;
4316 Elf_External_Vernaux evna;
4318 GET_DATA (vna_off, evna,
4319 "version need aux (3)");
4321 ivna.vna_other = BYTE_GET (evna.vna_other);
4322 ivna.vna_next = BYTE_GET (evna.vna_next);
4323 ivna.vna_name = BYTE_GET (evna.vna_name);
4325 vna_off += ivna.vna_next;
4327 while (ivna.vna_other != vers_data
4328 && ivna.vna_next != 0);
4330 if (ivna.vna_other == vers_data)
4333 offset += ivn.vn_next;
4335 while (ivn.vn_next != 0);
4337 if (ivna.vna_other == vers_data)
4340 strtab + ivna.vna_name, ivna.vna_other);
4343 else if (! is_nobits)
4344 error (_("bad dynamic symbol"));
4351 if (vers_data != 0x8001)
4353 Elf_Internal_Verdef ivd;
4354 Elf_Internal_Verdaux ivda;
4355 Elf_External_Verdaux evda;
4356 unsigned long offset;
4359 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4364 Elf_External_Verdef evd;
4366 GET_DATA (offset, evd, "version def");
4368 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4369 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4370 ivd.vd_next = BYTE_GET (evd.vd_next);
4372 offset += ivd.vd_next;
4374 while (ivd.vd_ndx != (vers_data & 0x7fff)
4375 && ivd.vd_next != 0);
4377 offset -= ivd.vd_next;
4378 offset += ivd.vd_aux;
4380 GET_DATA (offset, evda, "version def aux");
4382 ivda.vda_name = BYTE_GET (evda.vda_name);
4384 if (psym->st_name != ivda.vda_name)
4385 printf ((vers_data & 0x8000)
4387 strtab + ivda.vda_name);
4397 if (strtab != string_table)
4403 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4405 if (do_histogram && buckets != NULL)
4412 int nzero_counts = 0;
4415 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4417 printf (_(" Length Number %% of total Coverage\n"));
4419 lengths = (int *) calloc (nbuckets, sizeof (int));
4420 if (lengths == NULL)
4422 error (_("Out of memory"));
4425 for (hn = 0; hn < nbuckets; ++hn)
4430 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4433 if (maxlength < ++lengths[hn])
4438 counts = (int *) calloc (maxlength + 1, sizeof (int));
4441 error (_("Out of memory"));
4445 for (hn = 0; hn < nbuckets; ++hn)
4446 ++ counts [lengths [hn]];
4450 printf (" 0 %-10d (%5.1f%%)\n",
4451 counts[0], (counts[0] * 100.0) / nbuckets);
4452 for (si = 1; si <= maxlength; ++si)
4454 nzero_counts += counts[si] * si;
4455 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4456 si, counts[si], (counts[si] * 100.0) / nbuckets,
4457 (nzero_counts * 100.0) / nsyms);
4465 if (buckets != NULL)
4475 process_syminfo (file)
4476 FILE * file ATTRIBUTE_UNUSED;
4480 if (dynamic_syminfo == NULL
4482 /* No syminfo, this is ok. */
4485 /* There better should be a dynamic symbol section. */
4486 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4490 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4491 dynamic_syminfo_offset, dynamic_syminfo_nent);
4493 printf (_(" Num: Name BoundTo Flags\n"));
4494 for (i = 0; i < dynamic_syminfo_nent; ++i)
4496 unsigned short int flags = dynamic_syminfo[i].si_flags;
4498 printf ("%4d: %-30s ", i,
4499 dynamic_strings + dynamic_symbols[i].st_name);
4501 switch (dynamic_syminfo[i].si_boundto)
4503 case SYMINFO_BT_SELF:
4504 fputs ("SELF ", stdout);
4506 case SYMINFO_BT_PARENT:
4507 fputs ("PARENT ", stdout);
4510 if (dynamic_syminfo[i].si_boundto > 0
4511 && dynamic_syminfo[i].si_boundto < dynamic_size)
4514 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4516 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4520 if (flags & SYMINFO_FLG_DIRECT)
4522 if (flags & SYMINFO_FLG_PASSTHRU)
4523 printf (" PASSTHRU");
4524 if (flags & SYMINFO_FLG_COPY)
4526 if (flags & SYMINFO_FLG_LAZYLOAD)
4527 printf (" LAZYLOAD");
4535 #ifdef SUPPORT_DISASSEMBLY
4537 disassemble_section (section, file)
4538 Elf32_Internal_Shdr * section;
4541 printf (_("\nAssembly dump of section %s\n"),
4542 SECTION_NAME (section));
4544 /* XXX -- to be done --- XXX */
4551 dump_section (section, file)
4552 Elf32_Internal_Shdr * section;
4555 bfd_size_type bytes;
4557 unsigned char * data;
4558 unsigned char * start;
4560 bytes = section->sh_size;
4564 printf (_("\nSection '%s' has no data to dump.\n"),
4565 SECTION_NAME (section));
4569 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4571 addr = section->sh_addr;
4573 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4584 lbytes = (bytes > 16 ? 16 : bytes);
4586 printf (" 0x%8.8lx ", (unsigned long) addr);
4588 switch (elf_header.e_ident [EI_DATA])
4592 for (j = 15; j >= 0; j --)
4595 printf ("%2.2x", data [j]);
4605 for (j = 0; j < 16; j++)
4608 printf ("%2.2x", data [j]);
4618 for (j = 0; j < lbytes; j++)
4621 if (k >= ' ' && k < 0x80)
4640 static unsigned long int
4641 read_leb128 (data, length_return, sign)
4642 unsigned char * data;
4643 int * length_return;
4646 unsigned long int result = 0;
4647 unsigned int num_read = 0;
4656 result |= (byte & 0x7f) << shift;
4661 while (byte & 0x80);
4663 if (length_return != NULL)
4664 * length_return = num_read;
4666 if (sign && (shift < 32) && (byte & 0x40))
4667 result |= -1 << shift;
4672 typedef struct State_Machine_Registers
4674 unsigned long address;
4677 unsigned int column;
4681 /* This variable hold the number of the last entry seen
4682 in the File Table. */
4683 unsigned int last_file_entry;
4686 static SMR state_machine_regs;
4689 reset_state_machine (is_stmt)
4692 state_machine_regs.address = 0;
4693 state_machine_regs.file = 1;
4694 state_machine_regs.line = 1;
4695 state_machine_regs.column = 0;
4696 state_machine_regs.is_stmt = is_stmt;
4697 state_machine_regs.basic_block = 0;
4698 state_machine_regs.end_sequence = 0;
4699 state_machine_regs.last_file_entry = 0;
4702 /* Handled an extend line op. Returns true if this is the end
4705 process_extended_line_op (data, is_stmt, pointer_size)
4706 unsigned char * data;
4710 unsigned char op_code;
4713 unsigned char * name;
4716 len = read_leb128 (data, & bytes_read, 0);
4721 warn (_("badly formed extended line op encountered!"));
4726 op_code = * data ++;
4728 printf (_(" Extended opcode %d: "), op_code);
4732 case DW_LNE_end_sequence:
4733 printf (_("End of Sequence\n\n"));
4734 reset_state_machine (is_stmt);
4737 case DW_LNE_set_address:
4738 adr = byte_get (data, pointer_size);
4739 printf (_("set Address to 0x%lx\n"), adr);
4740 state_machine_regs.address = adr;
4743 case DW_LNE_define_file:
4744 printf (_(" define new File Table entry\n"));
4745 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4747 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4749 data += strlen (data) + 1;
4750 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4752 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4754 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4755 printf (_("%s\n\n"), name);
4759 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
4766 /* Size of pointers in the .debug_line section. This information is not
4767 really present in that section. It's obtained before dumping the debug
4768 sections by doing some pre-scan of the .debug_info section. */
4769 static int debug_line_pointer_size = 4;
4772 display_debug_lines (section, start, file)
4773 Elf32_Internal_Shdr * section;
4774 unsigned char * start;
4775 FILE * file ATTRIBUTE_UNUSED;
4777 DWARF2_External_LineInfo * external;
4778 DWARF2_Internal_LineInfo info;
4779 unsigned char * standard_opcodes;
4780 unsigned char * data = start;
4781 unsigned char * end = start + section->sh_size;
4782 unsigned char * end_of_sequence;
4785 printf (_("\nDump of debug contents of section %s:\n\n"),
4786 SECTION_NAME (section));
4790 external = (DWARF2_External_LineInfo *) data;
4792 /* Check the length of the block. */
4793 info.li_length = BYTE_GET (external->li_length);
4794 if (info.li_length > section->sh_size)
4797 (_("The line info appears to be corrupt - the section is too small\n"));
4801 /* Check its version number. */
4802 info.li_version = BYTE_GET (external->li_version);
4803 if (info.li_version != 2)
4805 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4809 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
4810 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
4811 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
4812 info.li_line_base = BYTE_GET (external->li_line_base);
4813 info.li_line_range = BYTE_GET (external->li_line_range);
4814 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
4816 /* Sign extend the line base field. */
4817 info.li_line_base <<= 24;
4818 info.li_line_base >>= 24;
4820 printf (_(" Length: %ld\n"), info.li_length);
4821 printf (_(" DWARF Version: %d\n"), info.li_version);
4822 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
4823 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
4824 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
4825 printf (_(" Line Base: %d\n"), info.li_line_base);
4826 printf (_(" Line Range: %d\n"), info.li_line_range);
4827 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
4829 end_of_sequence = data + info.li_length + sizeof (info.li_length);
4831 reset_state_machine (info.li_default_is_stmt);
4833 /* Display the contents of the Opcodes table. */
4834 standard_opcodes = data + sizeof (* external);
4836 printf (_("\n Opcodes:\n"));
4838 for (i = 1; i < info.li_opcode_base; i++)
4839 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
4841 /* Display the contents of the Directory table. */
4842 data = standard_opcodes + info.li_opcode_base - 1;
4845 printf (_("\n The Directory Table is empty.\n"));
4848 printf (_("\n The Directory Table:\n"));
4852 printf (_(" %s\n"), data);
4854 data += strlen (data) + 1;
4858 /* Skip the NUL at the end of the table. */
4861 /* Display the contents of the File Name table. */
4863 printf (_("\n The File Name Table is empty.\n"));
4866 printf (_("\n The File Name Table:\n"));
4867 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4874 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4877 data += strlen (data) + 1;
4879 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4881 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4883 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4885 printf (_("%s\n"), name);
4889 /* Skip the NUL at the end of the table. */
4892 /* Now display the statements. */
4893 printf (_("\n Line Number Statements:\n"));
4896 while (data < end_of_sequence)
4898 unsigned char op_code;
4902 op_code = * data ++;
4906 case DW_LNS_extended_op:
4907 data += process_extended_line_op (data, info.li_default_is_stmt,
4908 debug_line_pointer_size);
4912 printf (_(" Copy\n"));
4915 case DW_LNS_advance_pc:
4916 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
4918 state_machine_regs.address += adv;
4919 printf (_(" Advance PC by %d to %lx\n"), adv,
4920 state_machine_regs.address);
4923 case DW_LNS_advance_line:
4924 adv = read_leb128 (data, & bytes_read, 1);
4926 state_machine_regs.line += adv;
4927 printf (_(" Advance Line by %d to %d\n"), adv,
4928 state_machine_regs.line);
4931 case DW_LNS_set_file:
4932 adv = read_leb128 (data, & bytes_read, 0);
4934 printf (_(" Set File Name to entry %d in the File Name Table\n"),
4936 state_machine_regs.file = adv;
4939 case DW_LNS_set_column:
4940 adv = read_leb128 (data, & bytes_read, 0);
4942 printf (_(" Set column to %d\n"), adv);
4943 state_machine_regs.column = adv;
4946 case DW_LNS_negate_stmt:
4947 adv = state_machine_regs.is_stmt;
4949 printf (_(" Set is_stmt to %d\n"), adv);
4950 state_machine_regs.is_stmt = adv;
4953 case DW_LNS_set_basic_block:
4954 printf (_(" Set basic block\n"));
4955 state_machine_regs.basic_block = 1;
4958 case DW_LNS_const_add_pc:
4959 adv = (((255 - info.li_opcode_base) / info.li_line_range)
4960 * info.li_min_insn_length);
4961 state_machine_regs.address += adv;
4962 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
4963 state_machine_regs.address);
4966 case DW_LNS_fixed_advance_pc:
4967 adv = byte_get (data, 2);
4969 state_machine_regs.address += adv;
4970 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
4971 adv, state_machine_regs.address);
4975 op_code -= info.li_opcode_base;
4976 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
4977 state_machine_regs.address += adv;
4978 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
4979 op_code, adv, state_machine_regs.address);
4980 adv = (op_code % info.li_line_range) + info.li_line_base;
4981 state_machine_regs.line += adv;
4982 printf (_(" and Line by %d to %d\n"),
4983 adv, state_machine_regs.line);
4994 display_debug_pubnames (section, start, file)
4995 Elf32_Internal_Shdr * section;
4996 unsigned char * start;
4997 FILE * file ATTRIBUTE_UNUSED;
4999 DWARF2_External_PubNames * external;
5000 DWARF2_Internal_PubNames pubnames;
5001 unsigned char * end;
5003 end = start + section->sh_size;
5005 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5009 unsigned char * data;
5010 unsigned long offset;
5012 external = (DWARF2_External_PubNames *) start;
5014 pubnames.pn_length = BYTE_GET (external->pn_length);
5015 pubnames.pn_version = BYTE_GET (external->pn_version);
5016 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5017 pubnames.pn_size = BYTE_GET (external->pn_size);
5019 data = start + sizeof (* external);
5020 start += pubnames.pn_length + sizeof (external->pn_length);
5022 if (pubnames.pn_version != 2)
5024 warn (_("Only DWARF 2 pubnames are currently supported"));
5028 printf (_(" Length: %ld\n"),
5029 pubnames.pn_length);
5030 printf (_(" Version: %d\n"),
5031 pubnames.pn_version);
5032 printf (_(" Offset into .debug_info section: %ld\n"),
5033 pubnames.pn_offset);
5034 printf (_(" Size of area in .debug_info section: %ld\n"),
5037 printf (_("\n Offset\tName\n"));
5041 offset = byte_get (data, 4);
5046 printf (" %ld\t\t%s\n", offset, data);
5047 data += strlen (data) + 1;
5050 while (offset != 0);
5063 case DW_TAG_padding: return "DW_TAG_padding";
5064 case DW_TAG_array_type: return "DW_TAG_array_type";
5065 case DW_TAG_class_type: return "DW_TAG_class_type";
5066 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5067 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5068 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5069 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5070 case DW_TAG_label: return "DW_TAG_label";
5071 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5072 case DW_TAG_member: return "DW_TAG_member";
5073 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5074 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5075 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5076 case DW_TAG_string_type: return "DW_TAG_string_type";
5077 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5078 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5079 case DW_TAG_typedef: return "DW_TAG_typedef";
5080 case DW_TAG_union_type: return "DW_TAG_union_type";
5081 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5082 case DW_TAG_variant: return "DW_TAG_variant";
5083 case DW_TAG_common_block: return "DW_TAG_common_block";
5084 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5085 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5086 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5087 case DW_TAG_module: return "DW_TAG_module";
5088 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5089 case DW_TAG_set_type: return "DW_TAG_set_type";
5090 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5091 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5092 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5093 case DW_TAG_base_type: return "DW_TAG_base_type";
5094 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5095 case DW_TAG_const_type: return "DW_TAG_const_type";
5096 case DW_TAG_constant: return "DW_TAG_constant";
5097 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5098 case DW_TAG_file_type: return "DW_TAG_file_type";
5099 case DW_TAG_friend: return "DW_TAG_friend";
5100 case DW_TAG_namelist: return "DW_TAG_namelist";
5101 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5102 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5103 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5104 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5105 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5106 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5107 case DW_TAG_try_block: return "DW_TAG_try_block";
5108 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5109 case DW_TAG_variable: return "DW_TAG_variable";
5110 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5111 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5112 case DW_TAG_format_label: return "DW_TAG_format_label";
5113 case DW_TAG_function_template: return "DW_TAG_function_template";
5114 case DW_TAG_class_template: return "DW_TAG_class_template";
5117 static char buffer [100];
5119 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5126 get_AT_name (attribute)
5127 unsigned long attribute;
5131 case DW_AT_sibling: return "DW_AT_sibling";
5132 case DW_AT_location: return "DW_AT_location";
5133 case DW_AT_name: return "DW_AT_name";
5134 case DW_AT_ordering: return "DW_AT_ordering";
5135 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5136 case DW_AT_byte_size: return "DW_AT_byte_size";
5137 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5138 case DW_AT_bit_size: return "DW_AT_bit_size";
5139 case DW_AT_element_list: return "DW_AT_element_list";
5140 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5141 case DW_AT_low_pc: return "DW_AT_low_pc";
5142 case DW_AT_high_pc: return "DW_AT_high_pc";
5143 case DW_AT_language: return "DW_AT_language";
5144 case DW_AT_member: return "DW_AT_member";
5145 case DW_AT_discr: return "DW_AT_discr";
5146 case DW_AT_discr_value: return "DW_AT_discr_value";
5147 case DW_AT_visibility: return "DW_AT_visibility";
5148 case DW_AT_import: return "DW_AT_import";
5149 case DW_AT_string_length: return "DW_AT_string_length";
5150 case DW_AT_common_reference: return "DW_AT_common_reference";
5151 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5152 case DW_AT_const_value: return "DW_AT_const_value";
5153 case DW_AT_containing_type: return "DW_AT_containing_type";
5154 case DW_AT_default_value: return "DW_AT_default_value";
5155 case DW_AT_inline: return "DW_AT_inline";
5156 case DW_AT_is_optional: return "DW_AT_is_optional";
5157 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5158 case DW_AT_producer: return "DW_AT_producer";
5159 case DW_AT_prototyped: return "DW_AT_prototyped";
5160 case DW_AT_return_addr: return "DW_AT_return_addr";
5161 case DW_AT_start_scope: return "DW_AT_start_scope";
5162 case DW_AT_stride_size: return "DW_AT_stride_size";
5163 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5164 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5165 case DW_AT_accessibility: return "DW_AT_accessibility";
5166 case DW_AT_address_class: return "DW_AT_address_class";
5167 case DW_AT_artificial: return "DW_AT_artificial";
5168 case DW_AT_base_types: return "DW_AT_base_types";
5169 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5170 case DW_AT_count: return "DW_AT_count";
5171 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5172 case DW_AT_decl_column: return "DW_AT_decl_column";
5173 case DW_AT_decl_file: return "DW_AT_decl_file";
5174 case DW_AT_decl_line: return "DW_AT_decl_line";
5175 case DW_AT_declaration: return "DW_AT_declaration";
5176 case DW_AT_discr_list: return "DW_AT_discr_list";
5177 case DW_AT_encoding: return "DW_AT_encoding";
5178 case DW_AT_external: return "DW_AT_external";
5179 case DW_AT_frame_base: return "DW_AT_frame_base";
5180 case DW_AT_friend: return "DW_AT_friend";
5181 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5182 case DW_AT_macro_info: return "DW_AT_macro_info";
5183 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5184 case DW_AT_priority: return "DW_AT_priority";
5185 case DW_AT_segment: return "DW_AT_segment";
5186 case DW_AT_specification: return "DW_AT_specification";
5187 case DW_AT_static_link: return "DW_AT_static_link";
5188 case DW_AT_type: return "DW_AT_type";
5189 case DW_AT_use_location: return "DW_AT_use_location";
5190 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5191 case DW_AT_virtuality: return "DW_AT_virtuality";
5192 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5193 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5194 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5195 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5196 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5197 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5198 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5199 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5200 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5201 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5202 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5203 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5204 case DW_AT_sf_names: return "DW_AT_sf_names";
5205 case DW_AT_src_info: return "DW_AT_src_info";
5206 case DW_AT_mac_info: return "DW_AT_mac_info";
5207 case DW_AT_src_coords: return "DW_AT_src_coords";
5208 case DW_AT_body_begin: return "DW_AT_body_begin";
5209 case DW_AT_body_end: return "DW_AT_body_end";
5212 static char buffer [100];
5214 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5221 get_FORM_name (form)
5226 case DW_FORM_addr: return "DW_FORM_addr";
5227 case DW_FORM_block2: return "DW_FORM_block2";
5228 case DW_FORM_block4: return "DW_FORM_block4";
5229 case DW_FORM_data2: return "DW_FORM_data2";
5230 case DW_FORM_data4: return "DW_FORM_data4";
5231 case DW_FORM_data8: return "DW_FORM_data8";
5232 case DW_FORM_string: return "DW_FORM_string";
5233 case DW_FORM_block: return "DW_FORM_block";
5234 case DW_FORM_block1: return "DW_FORM_block1";
5235 case DW_FORM_data1: return "DW_FORM_data1";
5236 case DW_FORM_flag: return "DW_FORM_flag";
5237 case DW_FORM_sdata: return "DW_FORM_sdata";
5238 case DW_FORM_strp: return "DW_FORM_strp";
5239 case DW_FORM_udata: return "DW_FORM_udata";
5240 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5241 case DW_FORM_ref1: return "DW_FORM_ref1";
5242 case DW_FORM_ref2: return "DW_FORM_ref2";
5243 case DW_FORM_ref4: return "DW_FORM_ref4";
5244 case DW_FORM_ref8: return "DW_FORM_ref8";
5245 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5246 case DW_FORM_indirect: return "DW_FORM_indirect";
5249 static char buffer [100];
5251 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5257 /* FIXME: There are better and more effiecint ways to handle
5258 these structures. For now though, I just want something that
5259 is simple to implement. */
5260 typedef struct abbrev_attr
5262 unsigned long attribute;
5264 struct abbrev_attr * next;
5268 typedef struct abbrev_entry
5270 unsigned long entry;
5273 struct abbrev_attr * first_attr;
5274 struct abbrev_attr * last_attr;
5275 struct abbrev_entry * next;
5279 static abbrev_entry * first_abbrev = NULL;
5280 static abbrev_entry * last_abbrev = NULL;
5283 free_abbrevs PARAMS ((void))
5285 abbrev_entry * abbrev;
5287 for (abbrev = first_abbrev; abbrev;)
5289 abbrev_entry * next = abbrev->next;
5292 for (attr = abbrev->first_attr; attr;)
5294 abbrev_attr * next = attr->next;
5304 last_abbrev = first_abbrev = NULL;
5308 add_abbrev (number, tag, children)
5309 unsigned long number;
5313 abbrev_entry * entry;
5315 entry = (abbrev_entry *) malloc (sizeof (* entry));
5321 entry->entry = number;
5323 entry->children = children;
5324 entry->first_attr = NULL;
5325 entry->last_attr = NULL;
5328 if (first_abbrev == NULL)
5329 first_abbrev = entry;
5331 last_abbrev->next = entry;
5333 last_abbrev = entry;
5337 add_abbrev_attr (attribute, form)
5338 unsigned long attribute;
5343 attr = (abbrev_attr *) malloc (sizeof (* attr));
5349 attr->attribute = attribute;
5353 if (last_abbrev->first_attr == NULL)
5354 last_abbrev->first_attr = attr;
5356 last_abbrev->last_attr->next = attr;
5358 last_abbrev->last_attr = attr;
5361 /* Processes the (partial) contents of a .debug_abbrev section.
5362 Returns NULL if the end of the section was encountered.
5363 Returns the address after the last byte read if the end of
5364 an abbreviation set was found. */
5366 static unsigned char *
5367 process_abbrev_section (start, end)
5368 unsigned char * start;
5369 unsigned char * end;
5371 if (first_abbrev != NULL)
5377 unsigned long entry;
5379 unsigned long attribute;
5382 entry = read_leb128 (start, & bytes_read, 0);
5383 start += bytes_read;
5385 /* A single zero is supposed to end the section according
5386 to the standard. If there's more, then signal that to
5389 return start == end ? NULL : start;
5391 tag = read_leb128 (start, & bytes_read, 0);
5392 start += bytes_read;
5394 children = * start ++;
5396 add_abbrev (entry, tag, children);
5402 attribute = read_leb128 (start, & bytes_read, 0);
5403 start += bytes_read;
5405 form = read_leb128 (start, & bytes_read, 0);
5406 start += bytes_read;
5409 add_abbrev_attr (attribute, form);
5411 while (attribute != 0);
5419 display_debug_abbrev (section, start, file)
5420 Elf32_Internal_Shdr * section;
5421 unsigned char * start;
5422 FILE * file ATTRIBUTE_UNUSED;
5424 abbrev_entry * entry;
5425 unsigned char * end = start + section->sh_size;
5427 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5431 start = process_abbrev_section (start, end);
5433 printf (_(" Number TAG\n"));
5435 for (entry = first_abbrev; entry; entry = entry->next)
5439 printf (_(" %ld %s [%s]\n"),
5441 get_TAG_name (entry->tag),
5442 entry->children ? _("has children") : _("no children"));
5444 for (attr = entry->first_attr; attr; attr = attr->next)
5446 printf (_(" %-18s %s\n"),
5447 get_AT_name (attr->attribute),
5448 get_FORM_name (attr->form));
5460 static unsigned char *
5461 display_block (data, length)
5462 unsigned char * data;
5463 unsigned long length;
5465 printf (_(" %lu byte block: "), length);
5468 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5474 decode_location_expression (data, pointer_size)
5475 unsigned char * data;
5476 unsigned int pointer_size;
5480 unsigned long uvalue;
5487 printf ("DW_OP_addr: %lx", (unsigned long) byte_get (data, pointer_size));
5490 printf ("DW_OP_deref");
5493 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data, 1));
5496 printf ("DW_OP_const1s: %ld", (long) byte_get (data, 1));
5499 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5502 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5505 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5508 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5511 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5512 (unsigned long) byte_get (data + 4, 4));
5515 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5516 (long) byte_get (data + 4, 4));
5519 printf ("DW_OP_constu: %lu", read_leb128 (data, NULL, 0));
5522 printf ("DW_OP_consts: %ld", read_leb128 (data, NULL, 1));
5525 printf ("DW_OP_dup");
5528 printf ("DW_OP_drop");
5531 printf ("DW_OP_over");
5534 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data, 1));
5537 printf ("DW_OP_swap");
5540 printf ("DW_OP_rot");
5543 printf ("DW_OP_xderef");
5546 printf ("DW_OP_abs");
5549 printf ("DW_OP_and");
5552 printf ("DW_OP_div");
5555 printf ("DW_OP_minus");
5558 printf ("DW_OP_mod");
5561 printf ("DW_OP_mul");
5564 printf ("DW_OP_neg");
5567 printf ("DW_OP_not");
5570 printf ("DW_OP_or");
5573 printf ("DW_OP_plus");
5575 case DW_OP_plus_uconst:
5576 printf ("DW_OP_plus_uconst: %lu", read_leb128 (data, NULL, 0));
5579 printf ("DW_OP_shl");
5582 printf ("DW_OP_shr");
5585 printf ("DW_OP_shra");
5588 printf ("DW_OP_xor");
5591 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5594 printf ("DW_OP_eq");
5597 printf ("DW_OP_ge");
5600 printf ("DW_OP_gt");
5603 printf ("DW_OP_le");
5606 printf ("DW_OP_lt");
5609 printf ("DW_OP_ne");
5612 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5615 printf ("DW_OP_lit0");
5618 printf ("DW_OP_lit1");
5621 printf ("DW_OP_lit2");
5624 printf ("DW_OP_lit3");
5627 printf ("DW_OP_lit4");
5630 printf ("DW_OP_lit5");
5633 printf ("DW_OP_lit6");
5636 printf ("DW_OP_lit7");
5639 printf ("DW_OP_lit8");
5642 printf ("DW_OP_lit9");
5645 printf ("DW_OP_lit10");
5648 printf ("DW_OP_lit11");
5651 printf ("DW_OP_lit12");
5654 printf ("DW_OP_lit13");
5657 printf ("DW_OP_lit14");
5660 printf ("DW_OP_lit15");
5663 printf ("DW_OP_lit16");
5666 printf ("DW_OP_lit17");
5669 printf ("DW_OP_lit18");
5672 printf ("DW_OP_lit19");
5675 printf ("DW_OP_lit20");
5678 printf ("DW_OP_lit21");
5681 printf ("DW_OP_lit22");
5684 printf ("DW_OP_lit23");
5687 printf ("DW_OP_lit24");
5690 printf ("DW_OP_lit25");
5693 printf ("DW_OP_lit26");
5696 printf ("DW_OP_lit27");
5699 printf ("DW_OP_lit28");
5702 printf ("DW_OP_lit29");
5705 printf ("DW_OP_lit30");
5708 printf ("DW_OP_lit31");
5711 printf ("DW_OP_reg0");
5714 printf ("DW_OP_reg1");
5717 printf ("DW_OP_reg2");
5720 printf ("DW_OP_reg3");
5723 printf ("DW_OP_reg4");
5726 printf ("DW_OP_reg5");
5729 printf ("DW_OP_reg6");
5732 printf ("DW_OP_reg7");
5735 printf ("DW_OP_reg8");
5738 printf ("DW_OP_reg9");
5741 printf ("DW_OP_reg10");
5744 printf ("DW_OP_reg11");
5747 printf ("DW_OP_reg12");
5750 printf ("DW_OP_reg13");
5753 printf ("DW_OP_reg14");
5756 printf ("DW_OP_reg15");
5759 printf ("DW_OP_reg16");
5762 printf ("DW_OP_reg17");
5765 printf ("DW_OP_reg18");
5768 printf ("DW_OP_reg19");
5771 printf ("DW_OP_reg20");
5774 printf ("DW_OP_reg21");
5777 printf ("DW_OP_reg22");
5780 printf ("DW_OP_reg23");
5783 printf ("DW_OP_reg24");
5786 printf ("DW_OP_reg25");
5789 printf ("DW_OP_reg26");
5792 printf ("DW_OP_reg27");
5795 printf ("DW_OP_reg28");
5798 printf ("DW_OP_reg29");
5801 printf ("DW_OP_reg30");
5804 printf ("DW_OP_reg31");
5807 printf ("DW_OP_breg0: %ld", read_leb128 (data, NULL, 1));
5810 printf ("DW_OP_breg1: %ld", read_leb128 (data, NULL, 1));
5813 printf ("DW_OP_breg2: %ld", read_leb128 (data, NULL, 1));
5816 printf ("DW_OP_breg3: %ld", read_leb128 (data, NULL, 1));
5819 printf ("DW_OP_breg4: %ld", read_leb128 (data, NULL, 1));
5822 printf ("DW_OP_breg5: %ld", read_leb128 (data, NULL, 1));
5825 printf ("DW_OP_breg6: %ld", read_leb128 (data, NULL, 1));
5828 printf ("DW_OP_breg7: %ld", read_leb128 (data, NULL, 1));
5831 printf ("DW_OP_breg8: %ld", read_leb128 (data, NULL, 1));
5834 printf ("DW_OP_breg9: %ld", read_leb128 (data, NULL, 1));
5837 printf ("DW_OP_breg10: %ld", read_leb128 (data, NULL, 1));
5840 printf ("DW_OP_breg11: %ld", read_leb128 (data, NULL, 1));
5843 printf ("DW_OP_breg12: %ld", read_leb128 (data, NULL, 1));
5846 printf ("DW_OP_breg13: %ld", read_leb128 (data, NULL, 1));
5849 printf ("DW_OP_breg14: %ld", read_leb128 (data, NULL, 1));
5852 printf ("DW_OP_breg15: %ld", read_leb128 (data, NULL, 1));
5855 printf ("DW_OP_breg16: %ld", read_leb128 (data, NULL, 1));
5858 printf ("DW_OP_breg17: %ld", read_leb128 (data, NULL, 1));
5861 printf ("DW_OP_breg18: %ld", read_leb128 (data, NULL, 1));
5864 printf ("DW_OP_breg19: %ld", read_leb128 (data, NULL, 1));
5867 printf ("DW_OP_breg20: %ld", read_leb128 (data, NULL, 1));
5870 printf ("DW_OP_breg21: %ld", read_leb128 (data, NULL, 1));
5873 printf ("DW_OP_breg22: %ld", read_leb128 (data, NULL, 1));
5876 printf ("DW_OP_breg23: %ld", read_leb128 (data, NULL, 1));
5879 printf ("DW_OP_breg24: %ld", read_leb128 (data, NULL, 1));
5882 printf ("DW_OP_breg25: %ld", read_leb128 (data, NULL, 1));
5885 printf ("DW_OP_breg26: %ld", read_leb128 (data, NULL, 1));
5888 printf ("DW_OP_breg27: %ld", read_leb128 (data, NULL, 1));
5891 printf ("DW_OP_breg28: %ld", read_leb128 (data, NULL, 1));
5894 printf ("DW_OP_breg29: %ld", read_leb128 (data, NULL, 1));
5897 printf ("DW_OP_breg30: %ld", read_leb128 (data, NULL, 1));
5900 printf ("DW_OP_breg31: %ld", read_leb128 (data, NULL, 1));
5903 printf ("DW_OP_regx: %lu", read_leb128 (data, NULL, 0));
5906 printf ("DW_OP_fbreg: %ld", read_leb128 (data, NULL, 1));
5909 uvalue = read_leb128 (data, &bytes_read, 0);
5910 printf ("DW_OP_bregx: %lu %ld", uvalue,
5911 read_leb128 (data + bytes_read, NULL, 1));
5914 printf ("DW_OP_piece: %lu", read_leb128 (data, NULL, 0));
5916 case DW_OP_deref_size:
5917 printf ("DW_OP_deref_size: %ld", (long) byte_get (data, 1));
5919 case DW_OP_xderef_size:
5920 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data, 1));
5923 printf ("DW_OP_nop");
5927 if (op >= DW_OP_lo_user
5928 && op <= DW_OP_hi_user)
5929 printf (_("(User defined location op)"));
5931 printf (_("(Unknown location op)"));
5937 static unsigned char *
5938 read_and_display_attr (attribute, form, data, pointer_size)
5939 unsigned long attribute;
5941 unsigned char * data;
5942 unsigned long pointer_size;
5944 unsigned long uvalue = 0;
5945 unsigned char * block_start = NULL;
5949 printf (" %-18s:", get_AT_name (attribute));
5953 case DW_FORM_ref_addr:
5958 case DW_FORM_ref_udata:
5964 case DW_FORM_ref_addr:
5966 uvalue = byte_get (data, pointer_size);
5967 printf (is_ref ? " <%x>" : " %#x", uvalue);
5968 data += pointer_size;
5974 uvalue = byte_get (data ++, 1);
5975 printf (is_ref ? " <%x>" : " %d", uvalue);
5980 uvalue = byte_get (data, 2);
5982 printf (is_ref ? " <%x>" : " %d", uvalue);
5987 uvalue = byte_get (data, 4);
5989 printf (is_ref ? " <%x>" : " %d", uvalue);
5994 uvalue = byte_get (data, 4);
5995 printf (" %lx", uvalue);
5996 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6000 case DW_FORM_string:
6001 printf (" %s", data);
6002 data += strlen (data) + 1;
6006 uvalue = read_leb128 (data, & bytes_read, 1);
6008 printf (" %ld", (long) uvalue);
6011 case DW_FORM_ref_udata:
6013 uvalue = read_leb128 (data, & bytes_read, 0);
6015 printf (is_ref ? " <%lx>" : " %ld", uvalue);
6019 uvalue = read_leb128 (data, & bytes_read, 0);
6020 block_start = data + bytes_read;
6021 data = display_block (block_start, uvalue);
6022 uvalue = * block_start;
6025 case DW_FORM_block1:
6026 uvalue = byte_get (data, 1);
6027 block_start = data + 1;
6028 data = display_block (block_start, uvalue);
6029 uvalue = * block_start;
6032 case DW_FORM_block2:
6033 uvalue = byte_get (data, 2);
6034 block_start = data + 2;
6035 data = display_block (block_start, uvalue);
6036 uvalue = * block_start;
6039 case DW_FORM_block4:
6040 uvalue = byte_get (data, 4);
6041 block_start = data + 4;
6042 data = display_block (block_start, uvalue);
6043 uvalue = * block_start;
6047 case DW_FORM_indirect:
6048 warn (_("Unable to handle FORM: %d"), form);
6052 warn (_("Unrecognised form: %d"), form);
6056 /* For some attributes we can display futher information. */
6065 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6066 case DW_INL_inlined: printf (_("(inlined)")); break;
6067 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6068 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6069 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6073 case DW_AT_frame_base:
6074 if (uvalue >= DW_OP_reg0 && uvalue <= DW_OP_reg31)
6075 printf ("(reg %ld)", uvalue - DW_OP_reg0);
6078 case DW_AT_language:
6081 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6082 case DW_LANG_C89: printf ("(ANSI C)"); break;
6083 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6084 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6085 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6086 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6087 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6088 case DW_LANG_Ada83: printf ("(Ada)"); break;
6089 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6090 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6091 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6092 default: printf ("(Unknown: %lx)", uvalue); break;
6096 case DW_AT_encoding:
6099 case DW_ATE_void: printf ("(void)"); break;
6100 case DW_ATE_address: printf ("(machine address)"); break;
6101 case DW_ATE_boolean: printf ("(boolean)"); break;
6102 case DW_ATE_complex_float: printf ("(complex float)"); break;
6103 case DW_ATE_float: printf ("(float)"); break;
6104 case DW_ATE_signed: printf ("(signed)"); break;
6105 case DW_ATE_signed_char: printf ("(signed char)"); break;
6106 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6107 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6109 if (uvalue >= DW_ATE_lo_user
6110 && uvalue <= DW_ATE_hi_user)
6111 printf ("(user defined type)");
6113 printf ("(unknown type)");
6118 case DW_AT_accessibility:
6121 case DW_ACCESS_public: printf ("(public)"); break;
6122 case DW_ACCESS_protected: printf ("(protected)"); break;
6123 case DW_ACCESS_private: printf ("(private)"); break;
6124 default: printf ("(unknown accessibility)"); break;
6128 case DW_AT_visibility:
6131 case DW_VIS_local: printf ("(local)"); break;
6132 case DW_VIS_exported: printf ("(exported)"); break;
6133 case DW_VIS_qualified: printf ("(qualified)"); break;
6134 default: printf ("(unknown visibility)"); break;
6138 case DW_AT_virtuality:
6141 case DW_VIRTUALITY_none: printf ("(none)"); break;
6142 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6143 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6144 default: printf ("(unknown virtuality)"); break;
6148 case DW_AT_identifier_case:
6151 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6152 case DW_ID_up_case: printf ("(up_case)"); break;
6153 case DW_ID_down_case: printf ("(down_case)"); break;
6154 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6155 default: printf ("(unknown case)"); break;
6159 case DW_AT_calling_convention:
6162 case DW_CC_normal: printf ("(normal)"); break;
6163 case DW_CC_program: printf ("(program)"); break;
6164 case DW_CC_nocall: printf ("(nocall)"); break;
6166 if (uvalue >= DW_CC_lo_user
6167 && uvalue <= DW_CC_hi_user)
6168 printf ("(user defined)");
6170 printf ("(unknown convention)");
6174 case DW_AT_location:
6175 case DW_AT_data_member_location:
6176 case DW_AT_vtable_elem_location:
6178 decode_location_expression (block_start, pointer_size);
6191 display_debug_info (section, start, file)
6192 Elf32_Internal_Shdr * section;
6193 unsigned char * start;
6196 unsigned char * end = start + section->sh_size;
6197 unsigned char * section_begin = start;
6199 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6203 DWARF2_External_CompUnit * external;
6204 DWARF2_Internal_CompUnit compunit;
6205 unsigned char * tags;
6209 external = (DWARF2_External_CompUnit *) start;
6211 compunit.cu_length = BYTE_GET (external->cu_length);
6212 compunit.cu_version = BYTE_GET (external->cu_version);
6213 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6214 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6216 tags = start + sizeof (* external);
6217 start += compunit.cu_length + sizeof (external->cu_length);
6219 if (compunit.cu_version != 2)
6221 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6225 printf (_(" Compilation Unit:\n"));
6226 printf (_(" Length: %ld\n"), compunit.cu_length);
6227 printf (_(" Version: %d\n"), compunit.cu_version);
6228 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6229 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6231 if (first_abbrev != NULL)
6234 /* Read in the abbrevs used by this compilation unit. */
6237 Elf32_Internal_Shdr * sec;
6238 unsigned char * begin;
6240 /* Locate the .debug_abbrev section and process it. */
6241 for (i = 0, sec = section_headers;
6242 i < elf_header.e_shnum;
6244 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6247 if (i == -1 || sec->sh_size == 0)
6249 warn (_("Unable to locate .debug_abbrev section!\n"));
6253 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6254 "debug_abbrev section data");
6256 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6257 begin + sec->sh_size);
6263 while (tags < start)
6266 unsigned long abbrev_number;
6267 abbrev_entry * entry;
6270 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6273 /* A null DIE marks the end of a list of children. */
6274 if (abbrev_number == 0)
6280 /* Scan through the abbreviation list until we reach the
6282 for (entry = first_abbrev;
6283 entry && entry->entry != abbrev_number;
6284 entry = entry->next)
6289 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6294 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6295 level, tags - section_begin - bytes_read,
6297 get_TAG_name (entry->tag));
6299 for (attr = entry->first_attr; attr; attr = attr->next)
6300 tags = read_and_display_attr (attr->attribute,
6303 compunit.cu_pointer_size);
6305 if (entry->children)
6316 display_debug_aranges (section, start, file)
6317 Elf32_Internal_Shdr * section;
6318 unsigned char * start;
6319 FILE * file ATTRIBUTE_UNUSED;
6321 unsigned char * end = start + section->sh_size;
6323 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6327 DWARF2_External_ARange * external;
6328 DWARF2_Internal_ARange arange;
6329 unsigned char * ranges;
6330 unsigned long length;
6331 unsigned long address;
6334 external = (DWARF2_External_ARange *) start;
6336 arange.ar_length = BYTE_GET (external->ar_length);
6337 arange.ar_version = BYTE_GET (external->ar_version);
6338 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6339 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6340 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6342 printf (_(" Length: %ld\n"), arange.ar_length);
6343 printf (_(" Version: %d\n"), arange.ar_version);
6344 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6345 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6346 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6348 printf (_("\n Address Length\n"));
6350 ranges = start + sizeof (* external);
6352 /* Must pad to an alignment boundary that is twice the pointer size. */
6353 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6355 ranges += (2 * arange.ar_pointer_size) - excess;
6359 address = byte_get (ranges, arange.ar_pointer_size);
6361 ranges += arange.ar_pointer_size;
6363 length = byte_get (ranges, arange.ar_pointer_size);
6365 ranges += arange.ar_pointer_size;
6367 /* A pair of zeros marks the end of the list. */
6368 if (address == 0 && length == 0)
6371 printf (" %8.8lx %lu\n", address, length);
6374 start += arange.ar_length + sizeof (external->ar_length);
6384 display_debug_not_supported (section, start, file)
6385 Elf32_Internal_Shdr * section;
6386 unsigned char * start ATTRIBUTE_UNUSED;
6387 FILE * file ATTRIBUTE_UNUSED;
6389 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6390 SECTION_NAME (section));
6395 /* Pre-scan the .debug_info section to record the size of address.
6396 When dumping the .debug_line, we use that size information, assuming
6397 that all compilation units have the same address size. */
6399 prescan_debug_info (section, start, file)
6400 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6401 unsigned char * start;
6402 FILE * file ATTRIBUTE_UNUSED;
6404 DWARF2_External_CompUnit * external;
6406 external = (DWARF2_External_CompUnit *) start;
6408 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6412 /* A structure containing the name of a debug section and a pointer
6413 to a function that can decode it. The third field is a prescan
6414 function to be run over the section before displaying any of the
6419 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6420 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
6424 { ".debug_info", display_debug_info, prescan_debug_info },
6425 { ".debug_abbrev", display_debug_abbrev, NULL },
6426 { ".debug_line", display_debug_lines, NULL },
6427 { ".debug_aranges", display_debug_aranges, NULL },
6428 { ".debug_pubnames", display_debug_pubnames, NULL },
6429 { ".debug_macinfo", display_debug_not_supported, NULL },
6430 { ".debug_frame", display_debug_not_supported, NULL },
6431 { ".debug_str", display_debug_not_supported, NULL },
6432 { ".debug_static_func", display_debug_not_supported, NULL },
6433 { ".debug_static_vars", display_debug_not_supported, NULL },
6434 { ".debug_types", display_debug_not_supported, NULL },
6435 { ".debug_weaknames", display_debug_not_supported, NULL }
6439 display_debug_section (section, file)
6440 Elf32_Internal_Shdr * section;
6443 char * name = SECTION_NAME (section);
6444 bfd_size_type length;
6445 unsigned char * start;
6448 length = section->sh_size;
6451 printf (_("\nSection '%s' has no debugging data.\n"), name);
6455 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6456 "debug section data");
6458 /* See if we know how to display the contents of this section. */
6459 for (i = NUM_ELEM (debug_displays); i--;)
6460 if (strcmp (debug_displays[i].name, name) == 0)
6462 debug_displays[i].display (section, start, file);
6467 printf (_("Unrecognised debug section: %s\n"), name);
6471 /* If we loaded in the abbrev section at some point,
6472 we must release it here. */
6473 if (first_abbrev != NULL)
6480 process_section_contents (file)
6483 Elf32_Internal_Shdr * section;
6489 /* Pre-scan the debug sections to find some debug information not
6490 present in some of them. For the .debug_line, we must find out the
6491 size of address (specified in .debug_info and .debug_aranges). */
6492 for (i = 0, section = section_headers;
6493 i < elf_header.e_shnum && i < num_dump_sects;
6496 char * name = SECTION_NAME (section);
6499 if (section->sh_size == 0)
6502 /* See if there is some pre-scan operation for this section. */
6503 for (j = NUM_ELEM (debug_displays); j--;)
6504 if (strcmp (debug_displays[j].name, name) == 0)
6506 if (debug_displays[j].prescan != NULL)
6508 bfd_size_type length;
6509 unsigned char * start;
6511 length = section->sh_size;
6512 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
6513 "debug section data");
6515 debug_displays[j].prescan (section, start, file);
6523 for (i = 0, section = section_headers;
6524 i < elf_header.e_shnum && i < num_dump_sects;
6527 #ifdef SUPPORT_DISASSEMBLY
6528 if (dump_sects[i] & DISASS_DUMP)
6529 disassemble_section (section, file);
6531 if (dump_sects[i] & HEX_DUMP)
6532 dump_section (section, file);
6534 if (dump_sects[i] & DEBUG_DUMP)
6535 display_debug_section (section, file);
6538 if (i < num_dump_sects)
6539 warn (_("Some sections were not dumped because they do not exist!\n"));
6545 process_mips_fpe_exception (mask)
6551 if (mask & OEX_FPU_INEX)
6552 fputs ("INEX", stdout), first = 0;
6553 if (mask & OEX_FPU_UFLO)
6554 printf ("%sUFLO", first ? "" : "|"), first = 0;
6555 if (mask & OEX_FPU_OFLO)
6556 printf ("%sOFLO", first ? "" : "|"), first = 0;
6557 if (mask & OEX_FPU_DIV0)
6558 printf ("%sDIV0", first ? "" : "|"), first = 0;
6559 if (mask & OEX_FPU_INVAL)
6560 printf ("%sINVAL", first ? "" : "|");
6563 fputs ("0", stdout);
6567 process_mips_specific (file)
6570 Elf_Internal_Dyn * entry;
6571 size_t liblist_offset = 0;
6572 size_t liblistno = 0;
6573 size_t conflictsno = 0;
6574 size_t options_offset = 0;
6575 size_t conflicts_offset = 0;
6577 /* We have a lot of special sections. Thanks SGI! */
6578 if (dynamic_segment == NULL)
6579 /* No information available. */
6582 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
6583 switch (entry->d_tag)
6585 case DT_MIPS_LIBLIST:
6586 liblist_offset = entry->d_un.d_val - loadaddr;
6588 case DT_MIPS_LIBLISTNO:
6589 liblistno = entry->d_un.d_val;
6591 case DT_MIPS_OPTIONS:
6592 options_offset = entry->d_un.d_val - loadaddr;
6594 case DT_MIPS_CONFLICT:
6595 conflicts_offset = entry->d_un.d_val - loadaddr;
6597 case DT_MIPS_CONFLICTNO:
6598 conflictsno = entry->d_un.d_val;
6604 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
6606 Elf32_External_Lib * elib;
6609 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
6610 elib, Elf32_External_Lib *, "liblist");
6612 printf ("\nSection '.liblist' contains %d entries:\n", liblistno);
6613 fputs (" Library Time Stamp Checksum Version Flags\n",
6616 for (cnt = 0; cnt < liblistno; ++cnt)
6622 liblist.l_name = BYTE_GET (elib[cnt].l_name);
6623 time = BYTE_GET (elib[cnt].l_time_stamp);
6624 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
6625 liblist.l_version = BYTE_GET (elib[cnt].l_version);
6626 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
6628 strftime (timebuf, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time));
6630 printf ("%3d: %-20s %s %#10lx %-7ld", cnt,
6631 dynamic_strings + liblist.l_name, timebuf,
6632 liblist.l_checksum, liblist.l_version);
6634 if (liblist.l_flags == 0)
6645 { " EXACT_MATCH", LL_EXACT_MATCH },
6646 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
6647 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
6648 { " EXPORTS", LL_EXPORTS },
6649 { " DELAY_LOAD", LL_DELAY_LOAD },
6650 { " DELTA", LL_DELTA }
6652 int flags = liblist.l_flags;
6656 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
6658 if ((flags & l_flags_vals[fcnt].bit) != 0)
6660 fputs (l_flags_vals[fcnt].name, stdout);
6661 flags ^= l_flags_vals[fcnt].bit;
6664 printf (" %#x", (unsigned int) flags);
6673 if (options_offset != 0)
6675 Elf_External_Options * eopt;
6676 Elf_Internal_Shdr * sect = section_headers;
6677 Elf_Internal_Options * iopt;
6678 Elf_Internal_Options * option;
6682 /* Find the section header so that we get the size. */
6683 while (sect->sh_type != SHT_MIPS_OPTIONS)
6686 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
6687 Elf_External_Options *, "options");
6689 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
6693 error (_("Out of memory"));
6700 while (offset < sect->sh_size)
6702 Elf_External_Options * eoption;
6704 eoption = (Elf_External_Options *) ((char *) eopt + offset);
6706 option->kind = BYTE_GET (eoption->kind);
6707 option->size = BYTE_GET (eoption->size);
6708 option->section = BYTE_GET (eoption->section);
6709 option->info = BYTE_GET (eoption->info);
6711 offset += option->size;
6717 printf (_("\nSection '%s' contains %d entries:\n"),
6718 string_table + sect->sh_name, cnt);
6726 switch (option->kind)
6729 /* This shouldn't happen. */
6730 printf (" NULL %d %lx", option->section, option->info);
6733 printf (" REGINFO ");
6734 if (elf_header.e_machine == EM_MIPS)
6737 Elf32_External_RegInfo *ereg;
6738 Elf32_RegInfo reginfo;
6740 ereg = (Elf32_External_RegInfo *) (option + 1);
6741 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6742 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6743 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6744 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6745 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6746 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
6748 printf ("GPR %08lx GP 0x%lx\n",
6750 (unsigned long) reginfo.ri_gp_value);
6751 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6752 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6753 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6758 Elf64_External_RegInfo * ereg;
6759 Elf64_Internal_RegInfo reginfo;
6761 ereg = (Elf64_External_RegInfo *) (option + 1);
6762 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
6763 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
6764 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
6765 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
6766 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
6767 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
6769 printf ("GPR %08lx GP 0x",
6770 reginfo.ri_gprmask);
6771 printf_vma (reginfo.ri_gp_value);
6774 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6775 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
6776 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
6780 case ODK_EXCEPTIONS:
6781 fputs (" EXCEPTIONS fpe_min(", stdout);
6782 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
6783 fputs (") fpe_max(", stdout);
6784 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
6785 fputs (")", stdout);
6787 if (option->info & OEX_PAGE0)
6788 fputs (" PAGE0", stdout);
6789 if (option->info & OEX_SMM)
6790 fputs (" SMM", stdout);
6791 if (option->info & OEX_FPDBUG)
6792 fputs (" FPDBUG", stdout);
6793 if (option->info & OEX_DISMISS)
6794 fputs (" DISMISS", stdout);
6797 fputs (" PAD ", stdout);
6798 if (option->info & OPAD_PREFIX)
6799 fputs (" PREFIX", stdout);
6800 if (option->info & OPAD_POSTFIX)
6801 fputs (" POSTFIX", stdout);
6802 if (option->info & OPAD_SYMBOL)
6803 fputs (" SYMBOL", stdout);
6806 fputs (" HWPATCH ", stdout);
6807 if (option->info & OHW_R4KEOP)
6808 fputs (" R4KEOP", stdout);
6809 if (option->info & OHW_R8KPFETCH)
6810 fputs (" R8KPFETCH", stdout);
6811 if (option->info & OHW_R5KEOP)
6812 fputs (" R5KEOP", stdout);
6813 if (option->info & OHW_R5KCVTL)
6814 fputs (" R5KCVTL", stdout);
6817 fputs (" FILL ", stdout);
6818 /* XXX Print content of info word? */
6821 fputs (" TAGS ", stdout);
6822 /* XXX Print content of info word? */
6825 fputs (" HWAND ", stdout);
6826 if (option->info & OHWA0_R4KEOP_CHECKED)
6827 fputs (" R4KEOP_CHECKED", stdout);
6828 if (option->info & OHWA0_R4KEOP_CLEAN)
6829 fputs (" R4KEOP_CLEAN", stdout);
6832 fputs (" HWOR ", stdout);
6833 if (option->info & OHWA0_R4KEOP_CHECKED)
6834 fputs (" R4KEOP_CHECKED", stdout);
6835 if (option->info & OHWA0_R4KEOP_CLEAN)
6836 fputs (" R4KEOP_CLEAN", stdout);
6839 printf (" GP_GROUP %#06lx self-contained %#06lx",
6840 option->info & OGP_GROUP,
6841 (option->info & OGP_SELF) >> 16);
6844 printf (" IDENT %#06lx self-contained %#06lx",
6845 option->info & OGP_GROUP,
6846 (option->info & OGP_SELF) >> 16);
6849 /* This shouldn't happen. */
6850 printf (" %3d ??? %d %lx",
6851 option->kind, option->section, option->info);
6855 len = sizeof (*eopt);
6856 while (len < option->size)
6857 if (((char *) option)[len] >= ' '
6858 && ((char *) option)[len] < 0x7f)
6859 printf ("%c", ((char *) option)[len++]);
6861 printf ("\\%03o", ((char *) option)[len++]);
6863 fputs ("\n", stdout);
6870 if (conflicts_offset != 0 && conflictsno != 0)
6872 Elf32_External_Conflict * econf32;
6873 Elf64_External_Conflict * econf64;
6874 Elf32_Conflict * iconf;
6877 if (dynamic_symbols == NULL)
6879 error (_("conflict list with without table"));
6883 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
6886 error (_("Out of memory"));
6892 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
6893 econf32, Elf32_External_Conflict *, "conflict");
6895 for (cnt = 0; cnt < conflictsno; ++cnt)
6896 iconf[cnt] = BYTE_GET (econf32[cnt]);
6900 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
6901 econf64, Elf64_External_Conflict *, "conflict");
6903 for (cnt = 0; cnt < conflictsno; ++cnt)
6904 iconf[cnt] = BYTE_GET (econf64[cnt]);
6907 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
6908 puts (_(" Num: Index Value Name"));
6910 for (cnt = 0; cnt < conflictsno; ++cnt)
6912 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
6914 printf ("%5u: %8lu ", cnt, iconf[cnt]);
6915 print_vma (psym->st_value, FULL_HEX);
6916 printf (" %s\n", dynamic_strings + psym->st_name);
6926 get_note_type (e_type)
6929 static char buff[64];
6933 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
6934 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
6935 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
6936 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
6937 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
6938 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
6939 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
6940 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
6941 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6942 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
6943 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
6945 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
6950 /* Note that by the ELF standard, the name field is already null byte
6951 terminated, and namesz includes the terminating null byte.
6952 I.E. the value of namesz for the name "FSF" is 4.
6954 If the value of namesz is zero, there is no name present. */
6956 process_note (pnote)
6957 Elf32_Internal_Note * pnote;
6959 printf (" %s\t\t0x%08lx\t%s\n",
6960 pnote->namesz ? pnote->namedata : "(NONE)",
6961 pnote->descsz, get_note_type (pnote->type));
6967 process_corefile_note_segment (file, offset, length)
6972 Elf_External_Note * pnotes;
6973 Elf_External_Note * external;
6979 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
6983 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"), offset, length);
6984 printf (_(" Owner\t\tData size\tDescription\n"));
6986 while (external < (Elf_External_Note *)((char *) pnotes + length))
6988 Elf32_Internal_Note inote;
6991 inote.type = BYTE_GET (external->type);
6992 inote.namesz = BYTE_GET (external->namesz);
6993 inote.namedata = external->name;
6994 inote.descsz = BYTE_GET (external->descsz);
6995 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
6996 inote.descpos = offset + (inote.descdata - (char *) pnotes);
6998 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7000 /* Verify that name is null terminated. It appears that at least
7001 one version of Linux (RedHat 6.0) generates corefiles that don't
7002 comply with the ELF spec by failing to include the null byte in
7004 if (inote.namedata[inote.namesz] != '\0')
7006 temp = malloc (inote.namesz + 1);
7010 error (_("Out of memory\n"));
7015 strncpy (temp, inote.namedata, inote.namesz);
7016 temp[inote.namesz] = 0;
7018 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7019 inote.namedata = temp;
7022 res &= process_note (& inote);
7037 process_corefile_note_segments (file)
7040 Elf_Internal_Phdr * program_headers;
7041 Elf_Internal_Phdr * segment;
7045 program_headers = (Elf_Internal_Phdr *) malloc
7046 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7048 if (program_headers == NULL)
7050 error (_("Out of memory\n"));
7055 i = get_32bit_program_headers (file, program_headers);
7057 i = get_64bit_program_headers (file, program_headers);
7061 free (program_headers);
7065 for (i = 0, segment = program_headers;
7066 i < elf_header.e_phnum;
7069 if (segment->p_type == PT_NOTE)
7070 res &= process_corefile_note_segment (file,
7071 (bfd_vma) segment->p_offset,
7072 (bfd_vma) segment->p_filesz);
7075 free (program_headers);
7081 process_corefile_contents (file)
7084 /* If we have not been asked to display the notes then do nothing. */
7088 /* If file is not a core file then exit. */
7089 if (elf_header.e_type != ET_CORE)
7092 /* No program headers means no NOTE segment. */
7093 if (elf_header.e_phnum == 0)
7095 printf (_("No note segments present in the core file.\n"));
7099 return process_corefile_note_segments (file);
7103 process_arch_specific (file)
7109 switch (elf_header.e_machine)
7112 case EM_MIPS_RS4_BE:
7113 return process_mips_specific (file);
7122 get_file_header (file)
7125 /* Read in the identity array. */
7126 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7129 /* Determine how to read the rest of the header. */
7130 switch (elf_header.e_ident [EI_DATA])
7132 default: /* fall through */
7133 case ELFDATANONE: /* fall through */
7134 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7135 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7138 /* For now we only support 32 bit and 64 bit ELF files. */
7139 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7141 /* Read in the rest of the header. */
7144 Elf32_External_Ehdr ehdr32;
7146 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7149 elf_header.e_type = BYTE_GET (ehdr32.e_type);
7150 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
7151 elf_header.e_version = BYTE_GET (ehdr32.e_version);
7152 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7153 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7154 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7155 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7156 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7157 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7158 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7159 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7160 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7161 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7165 Elf64_External_Ehdr ehdr64;
7167 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7168 we will not be able to cope with the 64bit data found in
7169 64 ELF files. Detect this now and abort before we start
7170 overwritting things. */
7171 if (sizeof (bfd_vma) < 8)
7173 error (_("This instance of readelf has been built without support for a\n"));
7174 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7178 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7181 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7182 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7183 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7184 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7185 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7186 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7187 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7188 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7189 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7190 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7191 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7192 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7193 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7200 process_file (file_name)
7204 struct stat statbuf;
7207 if (stat (file_name, & statbuf) < 0)
7209 error (_("Cannot stat input file %s.\n"), file_name);
7213 file = fopen (file_name, "rb");
7216 error (_("Input file %s not found.\n"), file_name);
7220 if (! get_file_header (file))
7222 error (_("%s: Failed to read file header\n"), file_name);
7227 /* Initialise per file variables. */
7228 for (i = NUM_ELEM (version_info); i--;)
7229 version_info[i] = 0;
7231 for (i = NUM_ELEM (dynamic_info); i--;)
7232 dynamic_info[i] = 0;
7234 /* Process the file. */
7236 printf (_("\nFile: %s\n"), file_name);
7238 if (! process_file_header ())
7244 process_section_headers (file);
7246 process_program_headers (file);
7248 process_dynamic_segment (file);
7250 process_relocs (file);
7252 process_symbol_table (file);
7254 process_syminfo (file);
7256 process_version_sections (file);
7258 process_section_contents (file);
7260 process_corefile_contents (file);
7262 process_arch_specific (file);
7266 if (section_headers)
7268 free (section_headers);
7269 section_headers = NULL;
7274 free (string_table);
7275 string_table = NULL;
7278 if (dynamic_strings)
7280 free (dynamic_strings);
7281 dynamic_strings = NULL;
7284 if (dynamic_symbols)
7286 free (dynamic_symbols);
7287 dynamic_symbols = NULL;
7288 num_dynamic_syms = 0;
7291 if (dynamic_syminfo)
7293 free (dynamic_syminfo);
7294 dynamic_syminfo = NULL;
7298 #ifdef SUPPORT_DISASSEMBLY
7299 /* Needed by the i386 disassembler. For extra credit, someone could
7300 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7304 print_address (unsigned int addr, FILE * outfile)
7306 fprintf (outfile,"0x%8.8x", addr);
7309 /* Needed by the i386 disassembler. */
7311 db_task_printsym (unsigned int addr)
7313 print_address (addr, stderr);
7322 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7323 setlocale (LC_MESSAGES, "");
7325 bindtextdomain (PACKAGE, LOCALEDIR);
7326 textdomain (PACKAGE);
7328 parse_args (argc, argv);
7330 if (optind < (argc - 1))
7333 while (optind < argc)
7334 process_file (argv [optind ++]);
7336 if (dump_sects != NULL)