1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 99, 2000 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we belive that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
56 #include "elf/alpha.h"
59 #include "elf/sparc.h"
64 #include "elf/mn10200.h"
65 #include "elf/mn10300.h"
69 #include "elf/mcore.h"
80 char * program_name = "readelf";
81 unsigned int dynamic_addr;
82 bfd_size_type dynamic_size;
83 unsigned int rela_addr;
84 unsigned int rela_size;
85 char * dynamic_strings;
87 unsigned long num_dynamic_syms;
88 Elf_Internal_Sym * dynamic_symbols;
89 Elf_Internal_Syminfo * dynamic_syminfo;
90 unsigned long dynamic_syminfo_offset;
91 unsigned int dynamic_syminfo_nent;
92 char program_interpreter [64];
93 int dynamic_info[DT_JMPREL + 1];
96 Elf_Internal_Ehdr elf_header;
97 Elf_Internal_Shdr * section_headers;
98 Elf_Internal_Dyn * dynamic_segment;
105 int do_using_dynamic;
112 int do_debug_abbrevs;
114 int do_debug_pubnames;
115 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 void decode_ARM_machine_flags PARAMS ((unsigned, char []));
155 static char * get_machine_flags PARAMS ((unsigned, unsigned));
156 static const char * get_mips_segment_type PARAMS ((unsigned long));
157 static const char * get_parisc_segment_type PARAMS ((unsigned long));
158 static const char * get_segment_type PARAMS ((unsigned long));
159 static const char * get_mips_section_type_name PARAMS ((unsigned int));
160 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
161 static const char * get_section_type_name PARAMS ((unsigned int));
162 static const char * get_symbol_binding PARAMS ((unsigned int));
163 static const char * get_symbol_type PARAMS ((unsigned int));
164 static const char * get_symbol_visibility PARAMS ((unsigned int));
165 static const char * get_symbol_index_type PARAMS ((unsigned int));
166 static const char * get_dynamic_flags PARAMS ((bfd_vma));
167 static void usage PARAMS ((void));
168 static void parse_args PARAMS ((int, char **));
169 static int process_file_header PARAMS ((void));
170 static int process_program_headers PARAMS ((FILE *));
171 static int process_section_headers PARAMS ((FILE *));
172 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
173 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
174 static int process_dynamic_segment PARAMS ((FILE *));
175 static int process_symbol_table PARAMS ((FILE *));
176 static int process_section_contents PARAMS ((FILE *));
177 static void process_file PARAMS ((char *));
178 static int process_relocs PARAMS ((FILE *));
179 static int process_version_sections PARAMS ((FILE *));
180 static char * get_ver_flags PARAMS ((unsigned int));
181 static int get_32bit_section_headers PARAMS ((FILE *));
182 static int get_64bit_section_headers PARAMS ((FILE *));
183 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
184 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
185 static int get_file_header PARAMS ((FILE *));
186 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
187 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
188 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
189 static int get_32bit_dynamic_segment PARAMS ((FILE *));
190 static int get_64bit_dynamic_segment PARAMS ((FILE *));
191 #ifdef SUPPORT_DISASSEMBLY
192 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
194 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
195 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
196 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
197 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
198 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
199 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
200 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
201 static int display_debug_frames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
202 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
203 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
204 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
205 static void reset_state_machine PARAMS ((int));
206 static char * get_TAG_name PARAMS ((unsigned long));
207 static char * get_AT_name PARAMS ((unsigned long));
208 static char * get_FORM_name PARAMS ((unsigned long));
209 static void free_abbrevs PARAMS ((void));
210 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
211 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
212 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
213 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
214 static void decode_location_expression PARAMS ((unsigned char *, unsigned int, unsigned long));
215 static void request_dump PARAMS ((unsigned int, char));
216 static const char * get_elf_class PARAMS ((unsigned char));
217 static const char * get_data_encoding PARAMS ((unsigned char));
218 static const char * get_osabi_name PARAMS ((unsigned char));
219 static int guess_is_rela PARAMS ((unsigned long));
220 static char * get_note_type PARAMS ((unsigned int));
221 static int process_note PARAMS ((Elf32_Internal_Note *));
222 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
223 static int process_corefile_note_segments PARAMS ((FILE *));
224 static int process_corefile_contents PARAMS ((FILE *));
226 typedef int Elf32_Word;
234 #define SECTION_NAME(X) (string_table + (X)->sh_name)
236 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
238 #define BYTE_GET(field) byte_get (field, sizeof (field))
240 /* If we can support a 64 bit data type then BFD64 should be defined
241 and sizeof (bfd_vma) == 8. In this case when translating from an
242 external 8 byte field to an internal field, we can assume that the
243 internal field is also 8 bytes wide and so we can extact all the data.
244 If, however, BFD64 is not defined, then we must assume that the
245 internal data structure only has 4 byte wide fields that are the
246 equivalent of the 8 byte wide external counterparts, and so we must
247 truncate the data. */
249 #define BYTE_GET8(field) byte_get (field, -8)
251 #define BYTE_GET8(field) byte_get (field, 8)
254 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
256 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
257 if (fseek (file, offset, SEEK_SET)) \
259 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
263 var = (type) malloc (size); \
267 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
271 if (fread (var, size, 1, file) != 1) \
273 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
280 #define GET_DATA(offset, var, reason) \
281 if (fseek (file, offset, SEEK_SET)) \
283 error (_("Unable to seek to %x for %s\n"), offset, reason); \
286 else if (fread (& var, sizeof (var), 1, file) != 1) \
288 error (_("Unable to read data at %x for %s\n"), offset, reason); \
292 #define GET_ELF_SYMBOLS(file, offset, size) \
293 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
294 : get_64bit_elf_symbols (file, offset, size))
297 #ifdef ANSI_PROTOTYPES
299 error (const char * message, ...)
303 fprintf (stderr, _("%s: Error: "), program_name);
304 va_start (args, message);
305 vfprintf (stderr, message, args);
311 warn (const char * message, ...)
315 fprintf (stderr, _("%s: Warning: "), program_name);
316 va_start (args, message);
317 vfprintf (stderr, message, args);
329 fprintf (stderr, _("%s: Error: "), program_name);
331 message = va_arg (args, char *);
332 vfprintf (stderr, message, args);
344 fprintf (stderr, _("%s: Warning: "), program_name);
346 message = va_arg (args, char *);
347 vfprintf (stderr, message, args);
354 byte_get_little_endian (field, size)
355 unsigned char * field;
364 return ((unsigned int) (field [0]))
365 | (((unsigned int) (field [1])) << 8);
368 /* We want to extract data from an 8 byte wide field and
369 place it into a 4 byte wide field. Since this is a little
370 endian source we can juts use the 4 byte extraction code. */
373 return ((unsigned long) (field [0]))
374 | (((unsigned long) (field [1])) << 8)
375 | (((unsigned long) (field [2])) << 16)
376 | (((unsigned long) (field [3])) << 24);
380 /* This is a special case, generated by the BYTE_GET8 macro.
381 It means that we are loading an 8 byte value from a field
382 in an external structure into an 8 byte value in a field
383 in an internal strcuture. */
384 return ((bfd_vma) (field [0]))
385 | (((bfd_vma) (field [1])) << 8)
386 | (((bfd_vma) (field [2])) << 16)
387 | (((bfd_vma) (field [3])) << 24)
388 | (((bfd_vma) (field [4])) << 32)
389 | (((bfd_vma) (field [5])) << 40)
390 | (((bfd_vma) (field [6])) << 48)
391 | (((bfd_vma) (field [7])) << 56);
394 error (_("Unhandled data length: %d\n"), size);
399 /* Print a VMA value. */
401 print_vma (vma, mode)
411 case FULL_HEX: printf ("0x"); /* drop through */
412 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
413 case PREFIX_HEX: printf ("0x"); /* drop through */
414 case HEX: printf ("%lx", (unsigned long) vma); break;
415 case DEC: printf ("%ld", (unsigned long) vma); break;
416 case DEC_5: printf ("%5ld", (long) vma); break;
417 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
438 #if BFD_HOST_64BIT_LONG
441 if (_bfd_int64_high (vma))
442 printf ("%lx%lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
444 printf ("%lx", _bfd_int64_low (vma));
449 #if BFD_HOST_64BIT_LONG
452 if (_bfd_int64_high (vma))
454 printf ("++%ld", _bfd_int64_low (vma));
456 printf ("%ld", _bfd_int64_low (vma));
461 #if BFD_HOST_64BIT_LONG
462 printf ("%5ld", vma);
464 if (_bfd_int64_high (vma))
466 printf ("++%ld", _bfd_int64_low (vma));
468 printf ("%5ld", _bfd_int64_low (vma));
473 #if BFD_HOST_64BIT_LONG
476 if (_bfd_int64_high (vma))
478 printf ("++%lu", _bfd_int64_low (vma));
480 printf ("%lu", _bfd_int64_low (vma));
489 byte_get_big_endian (field, size)
490 unsigned char * field;
499 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
502 return ((unsigned long) (field [3]))
503 | (((unsigned long) (field [2])) << 8)
504 | (((unsigned long) (field [1])) << 16)
505 | (((unsigned long) (field [0])) << 24);
508 /* Although we are extracing data from an 8 byte wide field, we
509 are returning only 4 bytes of data. */
510 return ((unsigned long) (field [7]))
511 | (((unsigned long) (field [6])) << 8)
512 | (((unsigned long) (field [5])) << 16)
513 | (((unsigned long) (field [4])) << 24);
517 /* This is a special case, generated by the BYTE_GET8 macro.
518 It means that we are loading an 8 byte value from a field
519 in an external structure into an 8 byte value in a field
520 in an internal strcuture. */
521 return ((bfd_vma) (field [7]))
522 | (((bfd_vma) (field [6])) << 8)
523 | (((bfd_vma) (field [5])) << 16)
524 | (((bfd_vma) (field [4])) << 24)
525 | (((bfd_vma) (field [3])) << 32)
526 | (((bfd_vma) (field [2])) << 40)
527 | (((bfd_vma) (field [1])) << 48)
528 | (((bfd_vma) (field [0])) << 56);
532 error (_("Unhandled data length: %d\n"), size);
538 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
540 guess_is_rela (e_machine)
541 unsigned long e_machine;
545 /* Targets that use REL relocations. */
556 /* Targets that use RELA relocations. */
564 case EM_CYGNUS_MN10200:
565 case EM_CYGNUS_MN10300:
595 warn (_("Don't know about relocations on this machine architecture\n"));
600 /* Display the contents of the relocation data found at the specified offset. */
602 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
604 unsigned long rel_offset;
605 unsigned long rel_size;
606 Elf_Internal_Sym * symtab;
612 Elf_Internal_Rel * rels;
613 Elf_Internal_Rela * relas;
616 if (is_rela == UNKNOWN)
617 is_rela = guess_is_rela (elf_header.e_machine);
623 Elf32_External_Rela * erelas;
625 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
626 Elf32_External_Rela *, "relocs");
628 rel_size = rel_size / sizeof (Elf32_External_Rela);
630 relas = (Elf_Internal_Rela *)
631 malloc (rel_size * sizeof (Elf_Internal_Rela));
635 error(_("out of memory parsing relocs"));
639 for (i = 0; i < rel_size; i++)
641 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
642 relas[i].r_info = BYTE_GET (erelas[i].r_info);
643 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
648 rels = (Elf_Internal_Rel *) relas;
652 Elf64_External_Rela * erelas;
654 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
655 Elf64_External_Rela *, "relocs");
657 rel_size = rel_size / sizeof (Elf64_External_Rela);
659 relas = (Elf_Internal_Rela *)
660 malloc (rel_size * sizeof (Elf_Internal_Rela));
664 error(_("out of memory parsing relocs"));
668 for (i = 0; i < rel_size; i++)
670 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
671 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
672 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
677 rels = (Elf_Internal_Rel *) relas;
684 Elf32_External_Rel * erels;
686 GET_DATA_ALLOC (rel_offset, rel_size, erels,
687 Elf32_External_Rel *, "relocs");
689 rel_size = rel_size / sizeof (Elf32_External_Rel);
691 rels = (Elf_Internal_Rel *)
692 malloc (rel_size * sizeof (Elf_Internal_Rel));
696 error(_("out of memory parsing relocs"));
700 for (i = 0; i < rel_size; i++)
702 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
703 rels[i].r_info = BYTE_GET (erels[i].r_info);
708 relas = (Elf_Internal_Rela *) rels;
712 Elf64_External_Rel * erels;
714 GET_DATA_ALLOC (rel_offset, rel_size, erels,
715 Elf64_External_Rel *, "relocs");
717 rel_size = rel_size / sizeof (Elf64_External_Rel);
719 rels = (Elf_Internal_Rel *)
720 malloc (rel_size * sizeof (Elf_Internal_Rel));
724 error(_("out of memory parsing relocs"));
728 for (i = 0; i < rel_size; i++)
730 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
731 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
736 relas = (Elf_Internal_Rela *) rels;
742 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
745 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
747 for (i = 0; i < rel_size; i++)
752 bfd_vma symtab_index;
757 offset = relas [i].r_offset;
758 info = relas [i].r_info;
762 offset = rels [i].r_offset;
763 info = rels [i].r_info;
768 type = ELF32_R_TYPE (info);
769 symtab_index = ELF32_R_SYM (info);
773 if (elf_header.e_machine == EM_SPARCV9)
774 type = ELF64_R_TYPE_ID (info);
776 type = ELF64_R_TYPE (info);
777 /* The #ifdef BFD64 below is to prevent a compile time warning.
778 We know that if we do not have a 64 bit data type that we
779 will never execute this code anyway. */
781 symtab_index = ELF64_R_SYM (info);
785 #ifdef _bfd_int64_low
786 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
788 printf (" %8.8lx %5.5lx ", offset, info);
791 switch (elf_header.e_machine)
798 rtype = elf_m32r_reloc_type (type);
803 rtype = elf_i386_reloc_type (type);
807 rtype = elf_m68k_reloc_type (type);
811 rtype = elf_i960_reloc_type (type);
815 rtype = elf_avr_reloc_type (type);
822 rtype = elf_sparc_reloc_type (type);
826 rtype = v850_reloc_type (type);
830 rtype = elf_d10v_reloc_type (type);
834 rtype = elf_d30v_reloc_type (type);
838 rtype = elf_sh_reloc_type (type);
841 case EM_CYGNUS_MN10300:
842 rtype = elf_mn10300_reloc_type (type);
845 case EM_CYGNUS_MN10200:
846 rtype = elf_mn10200_reloc_type (type);
850 rtype = elf_fr30_reloc_type (type);
854 rtype = elf_mcore_reloc_type (type);
858 rtype = elf_ppc_reloc_type (type);
863 rtype = elf_mips_reloc_type (type);
867 rtype = elf_alpha_reloc_type (type);
871 rtype = elf_arm_reloc_type (type);
876 rtype = elf_arc_reloc_type (type);
880 rtype = elf_hppa_reloc_type (type);
884 rtype = elf_pj_reloc_type (type);
887 rtype = elf_ia64_reloc_type (type);
891 rtype = elf_cris_reloc_type (type);
895 rtype = elf_i860_reloc_type (type);
900 #ifdef _bfd_int64_low
901 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
903 printf (_("unrecognised: %-7lx"), type);
906 printf ("%-21.21s", rtype);
912 if (symtab_index >= nsyms)
913 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
916 Elf_Internal_Sym * psym;
918 psym = symtab + symtab_index;
921 print_vma (psym->st_value, LONG_HEX);
924 if (psym->st_name == 0)
926 SECTION_NAME (section_headers + psym->st_shndx));
927 else if (strtab == NULL)
928 printf (_("<string table index %3ld>"), psym->st_name);
930 printf ("%-25.25s", strtab + psym->st_name);
933 printf (" + %lx", (unsigned long) relas [i].r_addend);
939 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
940 print_vma (relas[i].r_addend, LONG_HEX);
943 if (elf_header.e_machine == EM_SPARCV9
944 && !strcmp (rtype, "R_SPARC_OLO10"))
945 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
956 get_mips_dynamic_type (type)
961 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
962 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
963 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
964 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
965 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
966 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
967 case DT_MIPS_MSYM: return "MIPS_MSYM";
968 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
969 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
970 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
971 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
972 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
973 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
974 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
975 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
976 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
977 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
978 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
979 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
980 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
981 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
982 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
983 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
984 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
985 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
986 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
987 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
988 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
989 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
990 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
991 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
992 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
993 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
994 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
995 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
996 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
997 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
998 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
999 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1000 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1001 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1002 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1003 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1010 get_sparc64_dynamic_type (type)
1015 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1022 get_parisc_dynamic_type (type)
1027 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1028 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1029 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1030 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1031 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1032 case DT_HP_PREINIT: return "HP_PREINIT";
1033 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1034 case DT_HP_NEEDED: return "HP_NEEDED";
1035 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1036 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1037 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1038 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1039 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1046 get_dynamic_type (type)
1049 static char buff [32];
1053 case DT_NULL: return "NULL";
1054 case DT_NEEDED: return "NEEDED";
1055 case DT_PLTRELSZ: return "PLTRELSZ";
1056 case DT_PLTGOT: return "PLTGOT";
1057 case DT_HASH: return "HASH";
1058 case DT_STRTAB: return "STRTAB";
1059 case DT_SYMTAB: return "SYMTAB";
1060 case DT_RELA: return "RELA";
1061 case DT_RELASZ: return "RELASZ";
1062 case DT_RELAENT: return "RELAENT";
1063 case DT_STRSZ: return "STRSZ";
1064 case DT_SYMENT: return "SYMENT";
1065 case DT_INIT: return "INIT";
1066 case DT_FINI: return "FINI";
1067 case DT_SONAME: return "SONAME";
1068 case DT_RPATH: return "RPATH";
1069 case DT_SYMBOLIC: return "SYMBOLIC";
1070 case DT_REL: return "REL";
1071 case DT_RELSZ: return "RELSZ";
1072 case DT_RELENT: return "RELENT";
1073 case DT_PLTREL: return "PLTREL";
1074 case DT_DEBUG: return "DEBUG";
1075 case DT_TEXTREL: return "TEXTREL";
1076 case DT_JMPREL: return "JMPREL";
1077 case DT_BIND_NOW: return "BIND_NOW";
1078 case DT_INIT_ARRAY: return "INIT_ARRAY";
1079 case DT_FINI_ARRAY: return "FINI_ARRAY";
1080 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1081 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1082 case DT_RUNPATH: return "RUNPATH";
1083 case DT_FLAGS: return "FLAGS";
1085 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1086 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1088 case DT_CHECKSUM: return "CHECKSUM";
1089 case DT_PLTPADSZ: return "PLTPADSZ";
1090 case DT_MOVEENT: return "MOVEENT";
1091 case DT_MOVESZ: return "MOVESZ";
1092 case DT_FEATURE: return "FEATURE";
1093 case DT_POSFLAG_1: return "POSFLAG_1";
1094 case DT_SYMINSZ: return "SYMINSZ";
1095 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1097 case DT_ADDRRNGLO: return "ADDRRNGLO";
1098 case DT_CONFIG: return "CONFIG";
1099 case DT_DEPAUDIT: return "DEPAUDIT";
1100 case DT_AUDIT: return "AUDIT";
1101 case DT_PLTPAD: return "PLTPAD";
1102 case DT_MOVETAB: return "MOVETAB";
1103 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1105 case DT_VERSYM: return "VERSYM";
1107 case DT_RELACOUNT: return "RELACOUNT";
1108 case DT_RELCOUNT: return "RELCOUNT";
1109 case DT_FLAGS_1: return "FLAGS_1";
1110 case DT_VERDEF: return "VERDEF";
1111 case DT_VERDEFNUM: return "VERDEFNUM";
1112 case DT_VERNEED: return "VERNEED";
1113 case DT_VERNEEDNUM: return "VERNEEDNUM";
1115 case DT_AUXILIARY: return "AUXILIARY";
1116 case DT_USED: return "USED";
1117 case DT_FILTER: return "FILTER";
1120 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1122 const char * result;
1124 switch (elf_header.e_machine)
1127 case EM_MIPS_RS4_BE:
1128 result = get_mips_dynamic_type (type);
1131 result = get_sparc64_dynamic_type (type);
1141 sprintf (buff, _("Processor Specific: %lx"), type);
1143 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1145 const char * result;
1147 switch (elf_header.e_machine)
1150 result = get_parisc_dynamic_type (type);
1160 sprintf (buff, _("Operating System specific: %lx"), type);
1163 sprintf (buff, _("<unknown>: %lx"), type);
1170 get_file_type (e_type)
1173 static char buff [32];
1177 case ET_NONE: return _("NONE (None)");
1178 case ET_REL: return _("REL (Relocatable file)");
1179 case ET_EXEC: return _("EXEC (Executable file)");
1180 case ET_DYN: return _("DYN (Shared object file)");
1181 case ET_CORE: return _("CORE (Core file)");
1184 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1185 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1186 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1187 sprintf (buff, _("OS Specific: (%x)"), e_type);
1189 sprintf (buff, _("<unknown>: %x"), e_type);
1195 get_machine_name (e_machine)
1198 static char buff [64]; /* XXX */
1202 case EM_NONE: return _("None");
1203 case EM_M32: return "WE32100";
1204 case EM_SPARC: return "Sparc";
1205 case EM_386: return "Intel 80386";
1206 case EM_68K: return "MC68000";
1207 case EM_88K: return "MC88000";
1208 case EM_486: return "Intel 80486";
1209 case EM_860: return "Intel 80860";
1210 case EM_MIPS: return "MIPS R3000";
1211 case EM_S370: return "IBM System/370";
1212 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1213 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1214 case EM_PARISC: return "HPPA";
1215 case EM_PPC_OLD: return "Power PC (old)";
1216 case EM_SPARC32PLUS: return "Sparc v8+" ;
1217 case EM_960: return "Intel 90860";
1218 case EM_PPC: return "PowerPC";
1219 case EM_V800: return "NEC V800";
1220 case EM_FR20: return "Fujitsu FR20";
1221 case EM_RH32: return "TRW RH32";
1222 case EM_MCORE: return "MCORE";
1223 case EM_ARM: return "ARM";
1224 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1225 case EM_SH: return "Hitachi SH";
1226 case EM_SPARCV9: return "Sparc v9";
1227 case EM_TRICORE: return "Siemens Tricore";
1228 case EM_ARC: return "ARC";
1229 case EM_H8_300: return "Hitachi H8/300";
1230 case EM_H8_300H: return "Hitachi H8/300H";
1231 case EM_H8S: return "Hitachi H8S";
1232 case EM_H8_500: return "Hitachi H8/500";
1233 case EM_IA_64: return "Intel IA-64";
1234 case EM_MIPS_X: return "Stanford MIPS-X";
1235 case EM_COLDFIRE: return "Motorola Coldfire";
1236 case EM_68HC12: return "Motorola M68HC12";
1237 case EM_ALPHA: return "Alpha";
1238 case EM_CYGNUS_D10V: return "d10v";
1239 case EM_CYGNUS_D30V: return "d30v";
1240 case EM_CYGNUS_ARC: return "ARC";
1241 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1242 case EM_CYGNUS_V850: return "NEC v850";
1243 case EM_CYGNUS_MN10300: return "mn10300";
1244 case EM_CYGNUS_MN10200: return "mn10200";
1245 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1246 case EM_PJ: return "picoJava";
1247 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1248 case EM_PCP: return "Siemens PCP";
1249 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1250 case EM_NDR1: return "Denso NDR1 microprocesspr";
1251 case EM_STARCORE: return "Motorola Star*Core processor";
1252 case EM_ME16: return "Toyota ME16 processor";
1253 case EM_ST100: return "STMicroelectronics ST100 processor";
1254 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1255 case EM_FX66: return "Siemens FX66 microcontroller";
1256 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1257 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1258 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1259 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1260 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1261 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1262 case EM_SVX: return "Silicon Graphics SVx";
1263 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1264 case EM_VAX: return "Digital VAX";
1265 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1266 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1267 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1268 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1269 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1270 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1271 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1272 case EM_PRISM: return "SiTera Prism";
1274 sprintf (buff, _("<unknown>: %x"), e_machine);
1280 decode_ARM_machine_flags (e_flags, buf)
1287 eabi = EF_ARM_EABI_VERSION (e_flags);
1288 e_flags &= ~ EF_ARM_EABIMASK;
1290 /* Handle "generic" ARM flags. */
1291 if (e_flags & EF_ARM_RELEXEC)
1293 strcat (buf, ", relocatable executable");
1294 e_flags &= ~ EF_ARM_RELEXEC;
1297 if (e_flags & EF_ARM_HASENTRY)
1299 strcat (buf, ", has entry point");
1300 e_flags &= ~ EF_ARM_HASENTRY;
1303 /* Now handle EABI specific flags. */
1307 strcat (buf, ", <unknown EABI>");
1312 case EF_ARM_EABI_VER1:
1317 /* Process flags one bit at a time. */
1318 flag = e_flags & - e_flags;
1323 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_INTERWORK. */
1324 strcat (buf, ", sorted symbol tables");
1334 case EF_ARM_EABI_UNKNOWN:
1339 /* Process flags one bit at a time. */
1340 flag = e_flags & - e_flags;
1346 strcat (buf, ", interworking enabled");
1350 strcat (buf, ", uses APCS/26");
1354 strcat (buf, ", uses APCS/float");
1358 strcat (buf, ", position independent");
1362 strcat (buf, ", 8 bit structure alignment");
1366 strcat (buf, ", uses new ABI");
1370 strcat (buf, ", uses old ABI");
1374 strcat (buf, ", software FP");
1385 strcat (buf,", <unknown>");
1389 get_machine_flags (e_flags, e_machine)
1393 static char buf [1024];
1405 decode_ARM_machine_flags (e_flags, buf);
1409 if (e_flags & EF_CPU32)
1410 strcat (buf, ", cpu32");
1414 if (e_flags & EF_PPC_EMB)
1415 strcat (buf, ", emb");
1417 if (e_flags & EF_PPC_RELOCATABLE)
1418 strcat (buf, ", relocatable");
1420 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1421 strcat (buf, ", relocatable-lib");
1424 case EM_CYGNUS_V850:
1425 switch (e_flags & EF_V850_ARCH)
1428 strcat (buf, ", v850e");
1431 strcat (buf, ", v850ea");
1434 strcat (buf, ", v850");
1437 strcat (buf, ", unknown v850 architecture variant");
1442 case EM_CYGNUS_M32R:
1443 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1444 strcat (buf, ", m32r");
1449 case EM_MIPS_RS4_BE:
1450 if (e_flags & EF_MIPS_NOREORDER)
1451 strcat (buf, ", noreorder");
1453 if (e_flags & EF_MIPS_PIC)
1454 strcat (buf, ", pic");
1456 if (e_flags & EF_MIPS_CPIC)
1457 strcat (buf, ", cpic");
1459 if (e_flags & EF_MIPS_ABI2)
1460 strcat (buf, ", abi2");
1462 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1463 strcat (buf, ", mips1");
1465 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1466 strcat (buf, ", mips2");
1468 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1469 strcat (buf, ", mips3");
1471 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1472 strcat (buf, ", mips4");
1474 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
1475 strcat (buf, ", mips5");
1477 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
1478 strcat (buf, ", mips32");
1480 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
1481 strcat (buf, ", mips64");
1483 switch ((e_flags & EF_MIPS_MACH))
1485 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1486 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1487 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1488 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1489 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1490 case E_MIPS_MACH_MIPS32_4K: strcat (buf, ", mips32-4k"); break;
1491 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1492 default: strcat (buf, " UNKNOWN"); break;
1497 if (e_flags & EF_SPARC_32PLUS)
1498 strcat (buf, ", v8+");
1500 if (e_flags & EF_SPARC_SUN_US1)
1501 strcat (buf, ", ultrasparcI");
1503 if (e_flags & EF_SPARC_SUN_US3)
1504 strcat (buf, ", ultrasparcIII");
1506 if (e_flags & EF_SPARC_HAL_R1)
1507 strcat (buf, ", halr1");
1509 if (e_flags & EF_SPARC_LEDATA)
1510 strcat (buf, ", ledata");
1512 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1513 strcat (buf, ", tso");
1515 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1516 strcat (buf, ", pso");
1518 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1519 strcat (buf, ", rmo");
1523 switch (e_flags & EF_PARISC_ARCH)
1525 case EFA_PARISC_1_0:
1526 strcpy (buf, ", PA-RISC 1.0");
1528 case EFA_PARISC_1_1:
1529 strcpy (buf, ", PA-RISC 1.1");
1531 case EFA_PARISC_2_0:
1532 strcpy (buf, ", PA-RISC 2.0");
1537 if (e_flags & EF_PARISC_TRAPNIL)
1538 strcat (buf, ", trapnil");
1539 if (e_flags & EF_PARISC_EXT)
1540 strcat (buf, ", ext");
1541 if (e_flags & EF_PARISC_LSB)
1542 strcat (buf, ", lsb");
1543 if (e_flags & EF_PARISC_WIDE)
1544 strcat (buf, ", wide");
1545 if (e_flags & EF_PARISC_NO_KABP)
1546 strcat (buf, ", no kabp");
1547 if (e_flags & EF_PARISC_LAZYSWAP)
1548 strcat (buf, ", lazyswap");
1552 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1553 strcat (buf, ", new calling convention");
1555 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1556 strcat (buf, ", gnu calling convention");
1565 get_mips_segment_type (type)
1570 case PT_MIPS_REGINFO:
1572 case PT_MIPS_RTPROC:
1574 case PT_MIPS_OPTIONS:
1584 get_parisc_segment_type (type)
1589 case PT_HP_TLS: return "HP_TLS";
1590 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1591 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1592 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1593 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1594 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1595 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1596 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1597 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1598 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1599 case PT_HP_PARALLEL: return "HP_PARALLEL";
1600 case PT_HP_FASTBIND: return "HP_FASTBIND";
1601 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1602 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1611 get_segment_type (p_type)
1612 unsigned long p_type;
1614 static char buff [32];
1618 case PT_NULL: return "NULL";
1619 case PT_LOAD: return "LOAD";
1620 case PT_DYNAMIC: return "DYNAMIC";
1621 case PT_INTERP: return "INTERP";
1622 case PT_NOTE: return "NOTE";
1623 case PT_SHLIB: return "SHLIB";
1624 case PT_PHDR: return "PHDR";
1627 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1629 const char * result;
1631 switch (elf_header.e_machine)
1634 case EM_MIPS_RS4_BE:
1635 result = get_mips_segment_type (p_type);
1638 result = get_parisc_segment_type (p_type);
1648 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1650 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1652 const char * result;
1654 switch (elf_header.e_machine)
1657 result = get_parisc_segment_type (p_type);
1667 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1670 sprintf (buff, _("<unknown>: %lx"), p_type);
1677 get_mips_section_type_name (sh_type)
1678 unsigned int sh_type;
1682 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1683 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1684 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1685 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1686 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1687 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1688 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1689 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1690 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1691 case SHT_MIPS_RELD: return "MIPS_RELD";
1692 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1693 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1694 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1695 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1696 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1697 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1698 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1699 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1700 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1701 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1702 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1703 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1704 case SHT_MIPS_LINE: return "MIPS_LINE";
1705 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1706 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1707 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1708 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1709 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1710 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1711 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1712 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1713 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1714 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1715 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1716 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1717 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1718 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1719 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1720 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1728 get_parisc_section_type_name (sh_type)
1729 unsigned int sh_type;
1733 case SHT_PARISC_EXT: return "PARISC_EXT";
1734 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1735 case SHT_PARISC_DOC: return "PARISC_DOC";
1743 get_section_type_name (sh_type)
1744 unsigned int sh_type;
1746 static char buff [32];
1750 case SHT_NULL: return "NULL";
1751 case SHT_PROGBITS: return "PROGBITS";
1752 case SHT_SYMTAB: return "SYMTAB";
1753 case SHT_STRTAB: return "STRTAB";
1754 case SHT_RELA: return "RELA";
1755 case SHT_HASH: return "HASH";
1756 case SHT_DYNAMIC: return "DYNAMIC";
1757 case SHT_NOTE: return "NOTE";
1758 case SHT_NOBITS: return "NOBITS";
1759 case SHT_REL: return "REL";
1760 case SHT_SHLIB: return "SHLIB";
1761 case SHT_DYNSYM: return "DYNSYM";
1762 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1763 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1764 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1765 case SHT_GROUP: return "GROUP";
1766 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
1767 case SHT_GNU_verdef: return "VERDEF";
1768 case SHT_GNU_verneed: return "VERNEED";
1769 case SHT_GNU_versym: return "VERSYM";
1770 case 0x6ffffff0: return "VERSYM";
1771 case 0x6ffffffc: return "VERDEF";
1772 case 0x7ffffffd: return "AUXILIARY";
1773 case 0x7fffffff: return "FILTER";
1776 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1778 const char * result;
1780 switch (elf_header.e_machine)
1783 case EM_MIPS_RS4_BE:
1784 result = get_mips_section_type_name (sh_type);
1787 result = get_parisc_section_type_name (sh_type);
1797 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1799 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1800 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1801 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1802 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1804 sprintf (buff, _("<unknown>: %x"), sh_type);
1810 struct option options [] =
1812 {"all", no_argument, 0, 'a'},
1813 {"file-header", no_argument, 0, 'h'},
1814 {"program-headers", no_argument, 0, 'l'},
1815 {"headers", no_argument, 0, 'e'},
1816 {"histogram", no_argument, 0, 'I'},
1817 {"segments", no_argument, 0, 'l'},
1818 {"sections", no_argument, 0, 'S'},
1819 {"section-headers", no_argument, 0, 'S'},
1820 {"symbols", no_argument, 0, 's'},
1821 {"syms", no_argument, 0, 's'},
1822 {"relocs", no_argument, 0, 'r'},
1823 {"notes", no_argument, 0, 'n'},
1824 {"dynamic", no_argument, 0, 'd'},
1825 {"arch-specific", no_argument, 0, 'A'},
1826 {"version-info", no_argument, 0, 'V'},
1827 {"use-dynamic", no_argument, 0, 'D'},
1828 {"hex-dump", required_argument, 0, 'x'},
1829 {"debug-dump", optional_argument, 0, 'w'},
1830 #ifdef SUPPORT_DISASSEMBLY
1831 {"instruction-dump", required_argument, 0, 'i'},
1834 {"version", no_argument, 0, 'v'},
1835 {"help", no_argument, 0, 'H'},
1836 {0, no_argument, 0, 0}
1842 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1843 fprintf (stdout, _(" Options are:\n"));
1844 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1845 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1846 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1847 fprintf (stdout, _(" Display the program headers\n"));
1848 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1849 fprintf (stdout, _(" Display the sections' header\n"));
1850 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1851 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1852 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1853 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1854 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1855 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1856 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1857 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1858 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
1859 fprintf (stdout, _(" Dump the contents of section <number>\n"));
1860 fprintf (stdout, _(" -w[liaprf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=frames]\n"));
1861 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
1862 #ifdef SUPPORT_DISASSEMBLY
1863 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
1864 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
1866 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1867 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
1868 fprintf (stdout, _(" -H or --help Display this information\n"));
1869 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
1875 request_dump (section, type)
1876 unsigned int section;
1879 if (section >= num_dump_sects)
1881 char * new_dump_sects;
1883 new_dump_sects = (char *) calloc (section + 1, 1);
1885 if (new_dump_sects == NULL)
1886 error (_("Out of memory allocating dump request table."));
1889 /* Copy current flag settings. */
1890 memcpy (new_dump_sects, dump_sects, num_dump_sects);
1894 dump_sects = new_dump_sects;
1895 num_dump_sects = section + 1;
1900 dump_sects [section] |= type;
1906 parse_args (argc, argv)
1915 while ((c = getopt_long
1916 (argc, argv, "ersahnldSDAIw::x:i:vV", options, NULL)) != EOF)
1951 do_using_dynamic ++;
1979 section = strtoul (optarg, & cp, 0);
1980 if (! * cp && section >= 0)
1982 request_dump (section, HEX_DUMP);
2002 do_debug_abbrevs = 1;
2012 do_debug_pubnames = 1;
2017 do_debug_aranges = 1;
2022 do_debug_frames = 1;
2026 warn (_("Unrecognised debug option '%s'\n"), optarg);
2031 #ifdef SUPPORT_DISASSEMBLY
2034 section = strtoul (optarg, & cp, 0);
2035 if (! * cp && section >= 0)
2037 request_dump (section, DISASS_DUMP);
2043 print_version (program_name);
2050 /* xgettext:c-format */
2051 error (_("Invalid option '-%c'\n"), c);
2058 if (!do_dynamic && !do_syms && !do_reloc && !do_sections
2059 && !do_segments && !do_header && !do_dump && !do_version
2060 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2064 warn (_("Nothing to do.\n"));
2070 get_elf_class (elf_class)
2071 unsigned char elf_class;
2073 static char buff [32];
2077 case ELFCLASSNONE: return _("none");
2078 case ELFCLASS32: return _("ELF32");
2079 case ELFCLASS64: return _("ELF64");
2081 sprintf (buff, _("<unknown: %x>"), elf_class);
2087 get_data_encoding (encoding)
2088 unsigned char encoding;
2090 static char buff [32];
2094 case ELFDATANONE: return _("none");
2095 case ELFDATA2LSB: return _("2's complement, little endian");
2096 case ELFDATA2MSB: return _("2's complement, big endian");
2098 sprintf (buff, _("<unknown: %x>"), encoding);
2104 get_osabi_name (osabi)
2105 unsigned char osabi;
2107 static char buff [32];
2111 case ELFOSABI_NONE: return _("UNIX - System V");
2112 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2113 case ELFOSABI_NETBSD: return _("UNIX - NetBSD");
2114 case ELFOSABI_LINUX: return _("UNIX - Linux");
2115 case ELFOSABI_HURD: return _("GNU/Hurd");
2116 case ELFOSABI_SOLARIS: return _("UNIX - Solaris");
2117 case ELFOSABI_AIX: return _("UNIX - AIX");
2118 case ELFOSABI_IRIX: return _("UNIX - IRIX");
2119 case ELFOSABI_FREEBSD: return _("UNIX - FreeBSD");
2120 case ELFOSABI_TRU64: return _("UNIX - TRU64");
2121 case ELFOSABI_MODESTO: return _("Novell - Modesto");
2122 case ELFOSABI_OPENBSD: return _("UNIX - OpenBSD");
2123 case ELFOSABI_STANDALONE: return _("Standalone App");
2124 case ELFOSABI_ARM: return _("ARM");
2126 sprintf (buff, _("<unknown: %x>"), osabi);
2131 /* Decode the data held in 'elf_header'. */
2133 process_file_header ()
2135 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2136 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2137 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2138 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2141 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2149 printf (_("ELF Header:\n"));
2150 printf (_(" Magic: "));
2151 for (i = 0; i < EI_NIDENT; i ++)
2152 printf ("%2.2x ", elf_header.e_ident [i]);
2154 printf (_(" Class: %s\n"),
2155 get_elf_class (elf_header.e_ident [EI_CLASS]));
2156 printf (_(" Data: %s\n"),
2157 get_data_encoding (elf_header.e_ident [EI_DATA]));
2158 printf (_(" Version: %d %s\n"),
2159 elf_header.e_ident [EI_VERSION],
2160 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2162 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2165 printf (_(" OS/ABI: %s\n"),
2166 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2167 printf (_(" ABI Version: %d\n"),
2168 elf_header.e_ident [EI_ABIVERSION]);
2169 printf (_(" Type: %s\n"),
2170 get_file_type (elf_header.e_type));
2171 printf (_(" Machine: %s\n"),
2172 get_machine_name (elf_header.e_machine));
2173 printf (_(" Version: 0x%lx\n"),
2174 (unsigned long) elf_header.e_version);
2176 printf (_(" Entry point address: "));
2177 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2178 printf (_("\n Start of program headers: "));
2179 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2180 printf (_(" (bytes into file)\n Start of section headers: "));
2181 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2182 printf (_(" (bytes into file)\n"));
2184 printf (_(" Flags: 0x%lx%s\n"),
2185 (unsigned long) elf_header.e_flags,
2186 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2187 printf (_(" Size of this header: %ld (bytes)\n"),
2188 (long) elf_header.e_ehsize);
2189 printf (_(" Size of program headers: %ld (bytes)\n"),
2190 (long) elf_header.e_phentsize);
2191 printf (_(" Number of program headers: %ld\n"),
2192 (long) elf_header.e_phnum);
2193 printf (_(" Size of section headers: %ld (bytes)\n"),
2194 (long) elf_header.e_shentsize);
2195 printf (_(" Number of section headers: %ld\n"),
2196 (long) elf_header.e_shnum);
2197 printf (_(" Section header string table index: %ld\n"),
2198 (long) elf_header.e_shstrndx);
2206 get_32bit_program_headers (file, program_headers)
2208 Elf_Internal_Phdr * program_headers;
2210 Elf32_External_Phdr * phdrs;
2211 Elf32_External_Phdr * external;
2212 Elf32_Internal_Phdr * internal;
2215 GET_DATA_ALLOC (elf_header.e_phoff,
2216 elf_header.e_phentsize * elf_header.e_phnum,
2217 phdrs, Elf32_External_Phdr *, "program headers");
2219 for (i = 0, internal = program_headers, external = phdrs;
2220 i < elf_header.e_phnum;
2221 i ++, internal ++, external ++)
2223 internal->p_type = BYTE_GET (external->p_type);
2224 internal->p_offset = BYTE_GET (external->p_offset);
2225 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2226 internal->p_paddr = BYTE_GET (external->p_paddr);
2227 internal->p_filesz = BYTE_GET (external->p_filesz);
2228 internal->p_memsz = BYTE_GET (external->p_memsz);
2229 internal->p_flags = BYTE_GET (external->p_flags);
2230 internal->p_align = BYTE_GET (external->p_align);
2239 get_64bit_program_headers (file, program_headers)
2241 Elf_Internal_Phdr * program_headers;
2243 Elf64_External_Phdr * phdrs;
2244 Elf64_External_Phdr * external;
2245 Elf64_Internal_Phdr * internal;
2248 GET_DATA_ALLOC (elf_header.e_phoff,
2249 elf_header.e_phentsize * elf_header.e_phnum,
2250 phdrs, Elf64_External_Phdr *, "program headers");
2252 for (i = 0, internal = program_headers, external = phdrs;
2253 i < elf_header.e_phnum;
2254 i ++, internal ++, external ++)
2256 internal->p_type = BYTE_GET (external->p_type);
2257 internal->p_flags = BYTE_GET (external->p_flags);
2258 internal->p_offset = BYTE_GET8 (external->p_offset);
2259 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2260 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2261 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2262 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2263 internal->p_align = BYTE_GET8 (external->p_align);
2272 process_program_headers (file)
2275 Elf_Internal_Phdr * program_headers;
2276 Elf_Internal_Phdr * segment;
2279 if (elf_header.e_phnum == 0)
2282 printf (_("\nThere are no program headers in this file.\n"));
2286 if (do_segments && !do_header)
2288 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2289 printf (_("Entry point "));
2290 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2291 printf (_("\nThere are %d program headers, starting at offset "),
2292 elf_header.e_phnum);
2293 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2297 program_headers = (Elf_Internal_Phdr *) malloc
2298 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2300 if (program_headers == NULL)
2302 error (_("Out of memory\n"));
2307 i = get_32bit_program_headers (file, program_headers);
2309 i = get_64bit_program_headers (file, program_headers);
2313 free (program_headers);
2320 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2324 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2328 (_(" Type Offset VirtAddr PhysAddr\n"));
2330 (_(" FileSiz MemSiz Flags Align\n"));
2338 for (i = 0, segment = program_headers;
2339 i < elf_header.e_phnum;
2344 printf (" %-14.14s ", get_segment_type (segment->p_type));
2348 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2349 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2350 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2351 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2352 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2354 (segment->p_flags & PF_R ? 'R' : ' '),
2355 (segment->p_flags & PF_W ? 'W' : ' '),
2356 (segment->p_flags & PF_X ? 'E' : ' '));
2357 printf ("%#lx", (unsigned long) segment->p_align);
2361 print_vma (segment->p_offset, FULL_HEX);
2363 print_vma (segment->p_vaddr, FULL_HEX);
2365 print_vma (segment->p_paddr, FULL_HEX);
2367 print_vma (segment->p_filesz, FULL_HEX);
2369 print_vma (segment->p_memsz, FULL_HEX);
2371 (segment->p_flags & PF_R ? 'R' : ' '),
2372 (segment->p_flags & PF_W ? 'W' : ' '),
2373 (segment->p_flags & PF_X ? 'E' : ' '));
2374 print_vma (segment->p_align, HEX);
2378 switch (segment->p_type)
2382 loadaddr = (segment->p_vaddr & 0xfffff000)
2383 - (segment->p_offset & 0xfffff000);
2388 error (_("more than one dynamic segment\n"));
2390 dynamic_addr = segment->p_offset;
2391 dynamic_size = segment->p_filesz;
2395 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2396 error (_("Unable to find program interpreter name\n"));
2399 program_interpreter[0] = 0;
2400 fscanf (file, "%63s", program_interpreter);
2403 printf (_("\n [Requesting program interpreter: %s]"),
2404 program_interpreter);
2410 putc ('\n', stdout);
2419 if (do_segments && section_headers != NULL)
2421 printf (_("\n Section to Segment mapping:\n"));
2422 printf (_(" Segment Sections...\n"));
2424 assert (string_table != NULL);
2426 for (i = 0; i < elf_header.e_phnum; i++)
2429 Elf_Internal_Shdr * section;
2431 segment = program_headers + i;
2432 section = section_headers;
2434 printf (" %2.2d ", i);
2436 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2438 if (section->sh_size > 0
2439 /* Compare allocated sections by VMA, unallocated
2440 sections by file offset. */
2441 && (section->sh_flags & SHF_ALLOC
2442 ? (section->sh_addr >= segment->p_vaddr
2443 && section->sh_addr + section->sh_size
2444 <= segment->p_vaddr + segment->p_memsz)
2445 : ((bfd_vma) section->sh_offset >= segment->p_offset
2446 && (section->sh_offset + section->sh_size
2447 <= segment->p_offset + segment->p_filesz))))
2448 printf ("%s ", SECTION_NAME (section));
2455 free (program_headers);
2462 get_32bit_section_headers (file)
2465 Elf32_External_Shdr * shdrs;
2466 Elf32_Internal_Shdr * internal;
2469 GET_DATA_ALLOC (elf_header.e_shoff,
2470 elf_header.e_shentsize * elf_header.e_shnum,
2471 shdrs, Elf32_External_Shdr *, "section headers");
2473 section_headers = (Elf_Internal_Shdr *) malloc
2474 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2476 if (section_headers == NULL)
2478 error (_("Out of memory\n"));
2482 for (i = 0, internal = section_headers;
2483 i < elf_header.e_shnum;
2486 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2487 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2488 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2489 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2490 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2491 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2492 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2493 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2494 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2495 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2504 get_64bit_section_headers (file)
2507 Elf64_External_Shdr * shdrs;
2508 Elf64_Internal_Shdr * internal;
2511 GET_DATA_ALLOC (elf_header.e_shoff,
2512 elf_header.e_shentsize * elf_header.e_shnum,
2513 shdrs, Elf64_External_Shdr *, "section headers");
2515 section_headers = (Elf_Internal_Shdr *) malloc
2516 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2518 if (section_headers == NULL)
2520 error (_("Out of memory\n"));
2524 for (i = 0, internal = section_headers;
2525 i < elf_header.e_shnum;
2528 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2529 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2530 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2531 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2532 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2533 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2534 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2535 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2536 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2537 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2545 static Elf_Internal_Sym *
2546 get_32bit_elf_symbols (file, offset, number)
2548 unsigned long offset;
2549 unsigned long number;
2551 Elf32_External_Sym * esyms;
2552 Elf_Internal_Sym * isyms;
2553 Elf_Internal_Sym * psym;
2556 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2557 esyms, Elf32_External_Sym *, "symbols");
2559 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2563 error (_("Out of memory\n"));
2569 for (j = 0, psym = isyms;
2573 psym->st_name = BYTE_GET (esyms[j].st_name);
2574 psym->st_value = BYTE_GET (esyms[j].st_value);
2575 psym->st_size = BYTE_GET (esyms[j].st_size);
2576 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2577 psym->st_info = BYTE_GET (esyms[j].st_info);
2578 psym->st_other = BYTE_GET (esyms[j].st_other);
2586 static Elf_Internal_Sym *
2587 get_64bit_elf_symbols (file, offset, number)
2589 unsigned long offset;
2590 unsigned long number;
2592 Elf64_External_Sym * esyms;
2593 Elf_Internal_Sym * isyms;
2594 Elf_Internal_Sym * psym;
2597 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2598 esyms, Elf64_External_Sym *, "symbols");
2600 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2604 error (_("Out of memory\n"));
2610 for (j = 0, psym = isyms;
2614 psym->st_name = BYTE_GET (esyms[j].st_name);
2615 psym->st_info = BYTE_GET (esyms[j].st_info);
2616 psym->st_other = BYTE_GET (esyms[j].st_other);
2617 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2618 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2619 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2628 get_elf_section_flags (sh_flags)
2631 static char buff [32];
2639 flag = sh_flags & - sh_flags;
2644 case SHF_WRITE: strcat (buff, "W"); break;
2645 case SHF_ALLOC: strcat (buff, "A"); break;
2646 case SHF_EXECINSTR: strcat (buff, "X"); break;
2647 case SHF_MERGE: strcat (buff, "M"); break;
2648 case SHF_STRINGS: strcat (buff, "S"); break;
2649 case SHF_INFO_LINK: strcat (buff, "I"); break;
2650 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2651 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2652 case SHF_GROUP: strcat (buff, "G"); break;
2655 if (flag & SHF_MASKOS)
2658 sh_flags &= ~ SHF_MASKOS;
2660 else if (flag & SHF_MASKPROC)
2663 sh_flags &= ~ SHF_MASKPROC;
2675 process_section_headers (file)
2678 Elf_Internal_Shdr * section;
2681 section_headers = NULL;
2683 if (elf_header.e_shnum == 0)
2686 printf (_("\nThere are no sections in this file.\n"));
2691 if (do_sections && !do_header)
2692 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2693 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2697 if (! get_32bit_section_headers (file))
2700 else if (! get_64bit_section_headers (file))
2703 /* Read in the string table, so that we have names to display. */
2704 section = section_headers + elf_header.e_shstrndx;
2706 if (section->sh_size != 0)
2708 unsigned long string_table_offset;
2710 string_table_offset = section->sh_offset;
2712 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2713 string_table, char *, "string table");
2716 /* Scan the sections for the dynamic symbol table
2717 and dynamic string table and debug sections. */
2718 dynamic_symbols = NULL;
2719 dynamic_strings = NULL;
2720 dynamic_syminfo = NULL;
2722 for (i = 0, section = section_headers;
2723 i < elf_header.e_shnum;
2726 char * name = SECTION_NAME (section);
2728 if (section->sh_type == SHT_DYNSYM)
2730 if (dynamic_symbols != NULL)
2732 error (_("File contains multiple dynamic symbol tables\n"));
2736 num_dynamic_syms = section->sh_size / section->sh_entsize;
2738 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2740 else if (section->sh_type == SHT_STRTAB
2741 && strcmp (name, ".dynstr") == 0)
2743 if (dynamic_strings != NULL)
2745 error (_("File contains multiple dynamic string tables\n"));
2749 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2750 dynamic_strings, char *, "dynamic strings");
2752 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2753 || do_debug_lines || do_debug_pubnames || do_debug_aranges || do_debug_frames)
2754 && strncmp (name, ".debug_", 7) == 0)
2759 || (do_debug_info && (strcmp (name, "info") == 0))
2760 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2761 || (do_debug_lines && (strcmp (name, "line") == 0))
2762 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2763 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2764 || (do_debug_frames && (strcmp (name, "frame") == 0))
2766 request_dump (i, DEBUG_DUMP);
2768 /* linkonce section to be combined with .debug_info at link time. */
2769 else if ((do_debugging || do_debug_info)
2770 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
2771 request_dump (i, DEBUG_DUMP);
2772 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
2773 request_dump (i, DEBUG_DUMP);
2779 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2783 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2786 printf (_(" [Nr] Name Type Address Offset\n"));
2787 printf (_(" Size EntSize Flags Link Info Align\n"));
2790 for (i = 0, section = section_headers;
2791 i < elf_header.e_shnum;
2794 printf (" [%2d] %-17.17s %-15.15s ",
2796 SECTION_NAME (section),
2797 get_section_type_name (section->sh_type));
2801 print_vma (section->sh_addr, LONG_HEX);
2803 printf ( " %6.6lx %6.6lx %2.2lx",
2804 (unsigned long) section->sh_offset,
2805 (unsigned long) section->sh_size,
2806 (unsigned long) section->sh_entsize);
2808 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2810 printf ("%2ld %3lx %2ld\n",
2811 (unsigned long) section->sh_link,
2812 (unsigned long) section->sh_info,
2813 (unsigned long) section->sh_addralign);
2818 print_vma (section->sh_addr, LONG_HEX);
2819 printf (" %8.8lx", section->sh_offset);
2821 print_vma (section->sh_size, LONG_HEX);
2823 print_vma (section->sh_entsize, LONG_HEX);
2825 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2827 printf (" %2ld %3lx %ld\n",
2828 (unsigned long) section->sh_link,
2829 (unsigned long) section->sh_info,
2830 (unsigned long) section->sh_addralign);
2834 printf (_("Key to Flags:\n"));
2835 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2836 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
2837 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
2842 /* Process the reloc section. */
2844 process_relocs (file)
2847 unsigned long rel_size;
2848 unsigned long rel_offset;
2854 if (do_using_dynamic)
2856 int is_rela = FALSE;
2861 if (dynamic_info[DT_REL])
2863 rel_offset = dynamic_info[DT_REL];
2864 rel_size = dynamic_info[DT_RELSZ];
2867 else if (dynamic_info [DT_RELA])
2869 rel_offset = dynamic_info[DT_RELA];
2870 rel_size = dynamic_info[DT_RELASZ];
2873 else if (dynamic_info[DT_JMPREL])
2875 rel_offset = dynamic_info[DT_JMPREL];
2876 rel_size = dynamic_info[DT_PLTRELSZ];
2878 switch (dynamic_info[DT_PLTREL])
2895 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2896 rel_offset, rel_size);
2898 dump_relocations (file, rel_offset - loadaddr, rel_size,
2899 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2902 printf (_("\nThere are no dynamic relocations in this file.\n"));
2906 Elf32_Internal_Shdr * section;
2910 for (i = 0, section = section_headers;
2911 i < elf_header.e_shnum;
2914 if ( section->sh_type != SHT_RELA
2915 && section->sh_type != SHT_REL)
2918 rel_offset = section->sh_offset;
2919 rel_size = section->sh_size;
2923 Elf32_Internal_Shdr * strsec;
2924 Elf32_Internal_Shdr * symsec;
2925 Elf_Internal_Sym * symtab;
2928 unsigned long nsyms;
2930 printf (_("\nRelocation section "));
2932 if (string_table == NULL)
2933 printf ("%d", section->sh_name);
2935 printf ("'%s'", SECTION_NAME (section));
2937 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2938 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2940 symsec = section_headers + section->sh_link;
2942 nsyms = symsec->sh_size / symsec->sh_entsize;
2943 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2948 strsec = section_headers + symsec->sh_link;
2950 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2951 char *, "string table");
2953 is_rela = section->sh_type == SHT_RELA;
2955 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2965 printf (_("\nThere are no relocations in this file.\n"));
2973 dynamic_segment_mips_val (entry)
2974 Elf_Internal_Dyn * entry;
2976 switch (entry->d_tag)
2979 if (entry->d_un.d_val == 0)
2983 static const char * opts[] =
2985 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2986 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2987 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2988 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2993 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2994 if (entry->d_un.d_val & (1 << cnt))
2996 printf ("%s%s", first ? "" : " ", opts[cnt]);
3003 case DT_MIPS_IVERSION:
3004 if (dynamic_strings != NULL)
3005 printf ("Interface Version: %s\n",
3006 dynamic_strings + entry->d_un.d_val);
3008 printf ("%ld\n", (long) entry->d_un.d_ptr);
3011 case DT_MIPS_TIME_STAMP:
3016 time_t time = entry->d_un.d_val;
3017 tmp = gmtime (&time);
3018 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3019 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3020 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3021 printf ("Time Stamp: %s\n", timebuf);
3025 case DT_MIPS_RLD_VERSION:
3026 case DT_MIPS_LOCAL_GOTNO:
3027 case DT_MIPS_CONFLICTNO:
3028 case DT_MIPS_LIBLISTNO:
3029 case DT_MIPS_SYMTABNO:
3030 case DT_MIPS_UNREFEXTNO:
3031 case DT_MIPS_HIPAGENO:
3032 case DT_MIPS_DELTA_CLASS_NO:
3033 case DT_MIPS_DELTA_INSTANCE_NO:
3034 case DT_MIPS_DELTA_RELOC_NO:
3035 case DT_MIPS_DELTA_SYM_NO:
3036 case DT_MIPS_DELTA_CLASSSYM_NO:
3037 case DT_MIPS_COMPACT_SIZE:
3038 printf ("%ld\n", (long) entry->d_un.d_ptr);
3042 printf ("%#lx\n", (long) entry->d_un.d_ptr);
3048 dynamic_segment_parisc_val (entry)
3049 Elf_Internal_Dyn * entry;
3051 switch (entry->d_tag)
3053 case DT_HP_DLD_FLAGS:
3062 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3063 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3064 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3065 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3066 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3067 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3068 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3069 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3070 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3071 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3072 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3076 bfd_vma val = entry->d_un.d_val;
3078 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3079 if (val & flags[cnt].bit)
3083 fputs (flags[cnt].str, stdout);
3085 val ^= flags[cnt].bit;
3088 if (val != 0 || first)
3092 print_vma (val, HEX);
3098 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3104 get_32bit_dynamic_segment (file)
3107 Elf32_External_Dyn * edyn;
3108 Elf_Internal_Dyn * entry;
3111 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3112 edyn, Elf32_External_Dyn *, "dynamic segment");
3114 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3115 how large this .dynamic is now. We can do this even before the byte
3116 swapping since the DT_NULL tag is recognizable. */
3118 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3121 dynamic_segment = (Elf_Internal_Dyn *)
3122 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3124 if (dynamic_segment == NULL)
3126 error (_("Out of memory\n"));
3131 for (i = 0, entry = dynamic_segment;
3135 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3136 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3145 get_64bit_dynamic_segment (file)
3148 Elf64_External_Dyn * edyn;
3149 Elf_Internal_Dyn * entry;
3152 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3153 edyn, Elf64_External_Dyn *, "dynamic segment");
3155 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3156 how large this .dynamic is now. We can do this even before the byte
3157 swapping since the DT_NULL tag is recognizable. */
3159 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3162 dynamic_segment = (Elf_Internal_Dyn *)
3163 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3165 if (dynamic_segment == NULL)
3167 error (_("Out of memory\n"));
3172 for (i = 0, entry = dynamic_segment;
3176 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3177 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3186 get_dynamic_flags (flags)
3189 static char buff [64];
3194 flag = flags & - flags;
3199 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3200 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3201 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3202 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3203 default: strcat (buff, "unknown "); break;
3209 /* Parse and display the contents of the dynamic segment. */
3211 process_dynamic_segment (file)
3214 Elf_Internal_Dyn * entry;
3217 if (dynamic_size == 0)
3220 printf (_("\nThere is no dynamic segment in this file.\n"));
3227 if (! get_32bit_dynamic_segment (file))
3230 else if (! get_64bit_dynamic_segment (file))
3233 /* Find the appropriate symbol table. */
3234 if (dynamic_symbols == NULL)
3236 for (i = 0, entry = dynamic_segment;
3240 unsigned long offset;
3242 if (entry->d_tag != DT_SYMTAB)
3245 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3247 /* Since we do not know how big the symbol table is,
3248 we default to reading in the entire file (!) and
3249 processing that. This is overkill, I know, but it
3251 offset = entry->d_un.d_val - loadaddr;
3253 if (fseek (file, 0, SEEK_END))
3254 error (_("Unable to seek to end of file!"));
3257 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3259 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3261 if (num_dynamic_syms < 1)
3263 error (_("Unable to determine the number of symbols to load\n"));
3267 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3271 /* Similarly find a string table. */
3272 if (dynamic_strings == NULL)
3274 for (i = 0, entry = dynamic_segment;
3278 unsigned long offset;
3281 if (entry->d_tag != DT_STRTAB)
3284 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3286 /* Since we do not know how big the string table is,
3287 we default to reading in the entire file (!) and
3288 processing that. This is overkill, I know, but it
3291 offset = entry->d_un.d_val - loadaddr;
3292 if (fseek (file, 0, SEEK_END))
3293 error (_("Unable to seek to end of file\n"));
3294 str_tab_len = ftell (file) - offset;
3296 if (str_tab_len < 1)
3299 (_("Unable to determine the length of the dynamic string table\n"));
3303 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3304 "dynamic string table");
3310 /* And find the syminfo section if available. */
3311 if (dynamic_syminfo == NULL)
3313 unsigned int syminsz = 0;
3315 for (i = 0, entry = dynamic_segment;
3319 if (entry->d_tag == DT_SYMINENT)
3321 /* Note: these braces are necessary to avoid a syntax
3322 error from the SunOS4 C compiler. */
3323 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3325 else if (entry->d_tag == DT_SYMINSZ)
3326 syminsz = entry->d_un.d_val;
3327 else if (entry->d_tag == DT_SYMINFO)
3328 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3331 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3333 Elf_External_Syminfo * extsyminfo;
3334 Elf_Internal_Syminfo * syminfo;
3336 /* There is a syminfo section. Read the data. */
3337 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3338 Elf_External_Syminfo *, "symbol information");
3340 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3341 if (dynamic_syminfo == NULL)
3343 error (_("Out of memory\n"));
3347 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3348 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3351 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3352 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3359 if (do_dynamic && dynamic_addr)
3360 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3361 dynamic_addr, (long) dynamic_size);
3363 printf (_(" Tag Type Name/Value\n"));
3365 for (i = 0, entry = dynamic_segment;
3374 print_vma (entry->d_tag, FULL_HEX);
3375 dtype = get_dynamic_type (entry->d_tag);
3376 printf (" (%s)%*s", dtype,
3377 ((is_32bit_elf ? 27 : 19)
3378 - (int) strlen (dtype)),
3382 switch (entry->d_tag)
3386 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3396 switch (entry->d_tag)
3399 printf (_("Auxiliary library"));
3403 printf (_("Filter library"));
3407 printf (_("Configuration file"));
3411 printf (_("Dependency audit library"));
3415 printf (_("Audit library"));
3419 if (dynamic_strings)
3420 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3424 print_vma (entry->d_un.d_val, PREFIX_HEX);
3433 printf (_("Flags:"));
3434 if (entry->d_un.d_val == 0)
3435 printf (_(" None\n"));
3438 unsigned long int val = entry->d_un.d_val;
3439 if (val & DTF_1_PARINIT)
3441 printf (" PARINIT");
3442 val ^= DTF_1_PARINIT;
3444 if (val & DTF_1_CONFEXP)
3446 printf (" CONFEXP");
3447 val ^= DTF_1_CONFEXP;
3450 printf (" %lx", val);
3459 printf (_("Flags:"));
3460 if (entry->d_un.d_val == 0)
3461 printf (_(" None\n"));
3464 unsigned long int val = entry->d_un.d_val;
3465 if (val & DF_P1_LAZYLOAD)
3467 printf (" LAZYLOAD");
3468 val ^= DF_P1_LAZYLOAD;
3470 if (val & DF_P1_GROUPPERM)
3472 printf (" GROUPPERM");
3473 val ^= DF_P1_GROUPPERM;
3476 printf (" %lx", val);
3485 printf (_("Flags:"));
3486 if (entry->d_un.d_val == 0)
3487 printf (_(" None\n"));
3490 unsigned long int val = entry->d_un.d_val;
3496 if (val & DF_1_GLOBAL)
3501 if (val & DF_1_GROUP)
3506 if (val & DF_1_NODELETE)
3508 printf (" NODELETE");
3509 val ^= DF_1_NODELETE;
3511 if (val & DF_1_LOADFLTR)
3513 printf (" LOADFLTR");
3514 val ^= DF_1_LOADFLTR;
3516 if (val & DF_1_INITFIRST)
3518 printf (" INITFIRST");
3519 val ^= DF_1_INITFIRST;
3521 if (val & DF_1_NOOPEN)
3526 if (val & DF_1_ORIGIN)
3531 if (val & DF_1_DIRECT)
3536 if (val & DF_1_TRANS)
3541 if (val & DF_1_INTERPOSE)
3543 printf (" INTERPOSE");
3544 val ^= DF_1_INTERPOSE;
3546 if (val & DF_1_NODEFLIB)
3548 printf (" NODEFLIB");
3549 val ^= DF_1_NODEFLIB;
3551 if (val & DF_1_NODUMP)
3556 if (val & DF_1_CONLFAT)
3558 printf (" CONLFAT");
3559 val ^= DF_1_CONLFAT;
3562 printf (" %lx", val);
3570 puts (get_dynamic_type (entry->d_un.d_val));
3590 dynamic_info[entry->d_tag] = entry->d_un.d_val;
3596 if (dynamic_strings == NULL)
3599 name = dynamic_strings + entry->d_un.d_val;
3603 switch (entry->d_tag)
3606 printf (_("Shared library: [%s]"), name);
3608 if (strcmp (name, program_interpreter) == 0)
3609 printf (_(" program interpreter"));
3613 printf (_("Library soname: [%s]"), name);
3617 printf (_("Library rpath: [%s]"), name);
3621 printf (_("Library runpath: [%s]"), name);
3625 print_vma (entry->d_un.d_val, PREFIX_HEX);
3630 print_vma (entry->d_un.d_val, PREFIX_HEX);
3646 case DT_INIT_ARRAYSZ:
3647 case DT_FINI_ARRAYSZ:
3650 print_vma (entry->d_un.d_val, UNSIGNED);
3651 printf (" (bytes)\n");
3661 print_vma (entry->d_un.d_val, UNSIGNED);
3674 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3678 name = dynamic_strings + entry->d_un.d_val;
3682 printf (_("Not needed object: [%s]\n"), name);
3687 print_vma (entry->d_un.d_val, PREFIX_HEX);
3693 /* The value of this entry is ignored. */
3697 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3698 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3703 switch (elf_header.e_machine)
3706 case EM_MIPS_RS4_BE:
3707 dynamic_segment_mips_val (entry);
3710 dynamic_segment_parisc_val (entry);
3713 print_vma (entry->d_un.d_val, PREFIX_HEX);
3725 get_ver_flags (flags)
3728 static char buff [32];
3735 if (flags & VER_FLG_BASE)
3736 strcat (buff, "BASE ");
3738 if (flags & VER_FLG_WEAK)
3740 if (flags & VER_FLG_BASE)
3741 strcat (buff, "| ");
3743 strcat (buff, "WEAK ");
3746 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3747 strcat (buff, "| <unknown>");
3752 /* Display the contents of the version sections. */
3754 process_version_sections (file)
3757 Elf32_Internal_Shdr * section;
3764 for (i = 0, section = section_headers;
3765 i < elf_header.e_shnum;
3768 switch (section->sh_type)
3770 case SHT_GNU_verdef:
3772 Elf_External_Verdef * edefs;
3779 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3780 SECTION_NAME (section), section->sh_info);
3782 printf (_(" Addr: 0x"));
3783 printf_vma (section->sh_addr);
3784 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3785 (unsigned long) section->sh_offset, section->sh_link,
3786 SECTION_NAME (section_headers + section->sh_link));
3788 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3789 edefs, Elf_External_Verdef *,
3790 "version definition section");
3792 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3795 Elf_External_Verdef * edef;
3796 Elf_Internal_Verdef ent;
3797 Elf_External_Verdaux * eaux;
3798 Elf_Internal_Verdaux aux;
3802 vstart = ((char *) edefs) + idx;
3804 edef = (Elf_External_Verdef *) vstart;
3806 ent.vd_version = BYTE_GET (edef->vd_version);
3807 ent.vd_flags = BYTE_GET (edef->vd_flags);
3808 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
3809 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
3810 ent.vd_hash = BYTE_GET (edef->vd_hash);
3811 ent.vd_aux = BYTE_GET (edef->vd_aux);
3812 ent.vd_next = BYTE_GET (edef->vd_next);
3814 printf (_(" %#06x: Rev: %d Flags: %s"),
3815 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3817 printf (_(" Index: %d Cnt: %d "),
3818 ent.vd_ndx, ent.vd_cnt);
3820 vstart += ent.vd_aux;
3822 eaux = (Elf_External_Verdaux *) vstart;
3824 aux.vda_name = BYTE_GET (eaux->vda_name);
3825 aux.vda_next = BYTE_GET (eaux->vda_next);
3827 if (dynamic_strings)
3828 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3830 printf (_("Name index: %ld\n"), aux.vda_name);
3832 isum = idx + ent.vd_aux;
3834 for (j = 1; j < ent.vd_cnt; j ++)
3836 isum += aux.vda_next;
3837 vstart += aux.vda_next;
3839 eaux = (Elf_External_Verdaux *) vstart;
3841 aux.vda_name = BYTE_GET (eaux->vda_name);
3842 aux.vda_next = BYTE_GET (eaux->vda_next);
3844 if (dynamic_strings)
3845 printf (_(" %#06x: Parent %d: %s\n"),
3846 isum, j, dynamic_strings + aux.vda_name);
3848 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3849 isum, j, aux.vda_name);
3859 case SHT_GNU_verneed:
3861 Elf_External_Verneed * eneed;
3867 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3868 SECTION_NAME (section), section->sh_info);
3870 printf (_(" Addr: 0x"));
3871 printf_vma (section->sh_addr);
3872 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3873 (unsigned long) section->sh_offset, section->sh_link,
3874 SECTION_NAME (section_headers + section->sh_link));
3876 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3877 eneed, Elf_External_Verneed *,
3878 "version need section");
3880 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3882 Elf_External_Verneed * entry;
3883 Elf_Internal_Verneed ent;
3888 vstart = ((char *) eneed) + idx;
3890 entry = (Elf_External_Verneed *) vstart;
3892 ent.vn_version = BYTE_GET (entry->vn_version);
3893 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
3894 ent.vn_file = BYTE_GET (entry->vn_file);
3895 ent.vn_aux = BYTE_GET (entry->vn_aux);
3896 ent.vn_next = BYTE_GET (entry->vn_next);
3898 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
3900 if (dynamic_strings)
3901 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
3903 printf (_(" File: %lx"), ent.vn_file);
3905 printf (_(" Cnt: %d\n"), ent.vn_cnt);
3907 vstart += ent.vn_aux;
3909 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3911 Elf_External_Vernaux * eaux;
3912 Elf_Internal_Vernaux aux;
3914 eaux = (Elf_External_Vernaux *) vstart;
3916 aux.vna_hash = BYTE_GET (eaux->vna_hash);
3917 aux.vna_flags = BYTE_GET (eaux->vna_flags);
3918 aux.vna_other = BYTE_GET (eaux->vna_other);
3919 aux.vna_name = BYTE_GET (eaux->vna_name);
3920 aux.vna_next = BYTE_GET (eaux->vna_next);
3922 if (dynamic_strings)
3923 printf (_(" %#06x: Name: %s"),
3924 isum, dynamic_strings + aux.vna_name);
3926 printf (_(" %#06x: Name index: %lx"),
3927 isum, aux.vna_name);
3929 printf (_(" Flags: %s Version: %d\n"),
3930 get_ver_flags (aux.vna_flags), aux.vna_other);
3932 isum += aux.vna_next;
3933 vstart += aux.vna_next;
3943 case SHT_GNU_versym:
3945 Elf32_Internal_Shdr * link_section;
3948 unsigned char * edata;
3949 unsigned short * data;
3951 Elf_Internal_Sym * symbols;
3952 Elf32_Internal_Shdr * string_sec;
3954 link_section = section_headers + section->sh_link;
3955 total = section->sh_size / section->sh_entsize;
3959 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3960 link_section->sh_size / link_section->sh_entsize);
3962 string_sec = section_headers + link_section->sh_link;
3964 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3965 strtab, char *, "version string table");
3967 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3968 SECTION_NAME (section), total);
3970 printf (_(" Addr: "));
3971 printf_vma (section->sh_addr);
3972 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3973 (unsigned long) section->sh_offset, section->sh_link,
3974 SECTION_NAME (link_section));
3976 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3978 total * sizeof (short), edata,
3979 unsigned char *, "version symbol data");
3981 data = (unsigned short *) malloc (total * sizeof (short));
3983 for (cnt = total; cnt --;)
3984 data [cnt] = byte_get (edata + cnt * sizeof (short),
3989 for (cnt = 0; cnt < total; cnt += 4)
3994 printf (" %03x:", cnt);
3996 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3997 switch (data [cnt + j])
4000 fputs (_(" 0 (*local*) "), stdout);
4004 fputs (_(" 1 (*global*) "), stdout);
4008 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4009 data [cnt + j] & 0x8000 ? 'h' : ' ');
4011 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
4012 && section_headers[symbols [cnt + j].st_shndx].sh_type
4015 /* We must test both. */
4016 Elf_Internal_Verneed ivn;
4017 unsigned long offset;
4019 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4024 Elf_External_Verneed evn;
4025 Elf_External_Vernaux evna;
4026 Elf_Internal_Vernaux ivna;
4027 unsigned long vna_off;
4029 GET_DATA (offset, evn, "version need");
4031 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4032 ivn.vn_next = BYTE_GET (evn.vn_next);
4034 vna_off = offset + ivn.vn_aux;
4038 GET_DATA (vna_off, evna,
4039 "version need aux (1)");
4041 ivna.vna_next = BYTE_GET (evna.vna_next);
4042 ivna.vna_other = BYTE_GET (evna.vna_other);
4044 vna_off += ivna.vna_next;
4046 while (ivna.vna_other != data [cnt + j]
4047 && ivna.vna_next != 0);
4049 if (ivna.vna_other == data [cnt + j])
4051 ivna.vna_name = BYTE_GET (evna.vna_name);
4053 name = strtab + ivna.vna_name;
4054 nn += printf ("(%s%-*s",
4056 12 - (int) strlen (name),
4060 else if (ivn.vn_next == 0)
4062 if (data [cnt + j] != 0x8001)
4064 Elf_Internal_Verdef ivd;
4065 Elf_External_Verdef evd;
4067 offset = version_info
4068 [DT_VERSIONTAGIDX (DT_VERDEF)]
4073 GET_DATA (offset, evd,
4074 "version definition");
4076 ivd.vd_next = BYTE_GET (evd.vd_next);
4077 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4079 offset += ivd.vd_next;
4082 != (data [cnt + j] & 0x7fff)
4083 && ivd.vd_next != 0);
4086 == (data [cnt + j] & 0x7fff))
4088 Elf_External_Verdaux evda;
4089 Elf_Internal_Verdaux ivda;
4091 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4093 GET_DATA (offset + ivd.vd_aux, evda,
4094 "version definition aux");
4097 BYTE_GET (evda.vda_name);
4099 name = strtab + ivda.vda_name;
4103 12 - (int) strlen (name),
4111 offset += ivn.vn_next;
4113 while (ivn.vn_next);
4115 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4117 Elf_Internal_Verneed ivn;
4118 unsigned long offset;
4120 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4125 Elf_Internal_Vernaux ivna;
4126 Elf_External_Verneed evn;
4127 Elf_External_Vernaux evna;
4128 unsigned long a_off;
4130 GET_DATA (offset, evn, "version need");
4132 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4133 ivn.vn_next = BYTE_GET (evn.vn_next);
4135 a_off = offset + ivn.vn_aux;
4139 GET_DATA (a_off, evna,
4140 "version need aux (2)");
4142 ivna.vna_next = BYTE_GET (evna.vna_next);
4143 ivna.vna_other = BYTE_GET (evna.vna_other);
4145 a_off += ivna.vna_next;
4147 while (ivna.vna_other != data [cnt + j]
4148 && ivna.vna_next != 0);
4150 if (ivna.vna_other == data [cnt + j])
4152 ivna.vna_name = BYTE_GET (evna.vna_name);
4154 name = strtab + ivna.vna_name;
4155 nn += printf ("(%s%-*s",
4157 12 - (int) strlen (name),
4162 offset += ivn.vn_next;
4164 while (ivn.vn_next);
4166 else if (data [cnt + j] != 0x8001)
4168 Elf_Internal_Verdef ivd;
4169 Elf_External_Verdef evd;
4170 unsigned long offset;
4172 offset = version_info
4173 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4177 GET_DATA (offset, evd, "version def");
4179 ivd.vd_next = BYTE_GET (evd.vd_next);
4180 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4182 offset += ivd.vd_next;
4184 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4185 && ivd.vd_next != 0);
4187 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4189 Elf_External_Verdaux evda;
4190 Elf_Internal_Verdaux ivda;
4192 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4194 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4195 evda, "version def aux");
4197 ivda.vda_name = BYTE_GET (evda.vda_name);
4199 name = strtab + ivda.vda_name;
4200 nn += printf ("(%s%-*s",
4202 12 - (int) strlen (name),
4208 printf ("%*c", 18 - nn, ' ');
4226 printf (_("\nNo version information found in this file.\n"));
4232 get_symbol_binding (binding)
4233 unsigned int binding;
4235 static char buff [32];
4239 case STB_LOCAL: return "LOCAL";
4240 case STB_GLOBAL: return "GLOBAL";
4241 case STB_WEAK: return "WEAK";
4243 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4244 sprintf (buff, _("<processor specific>: %d"), binding);
4245 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4246 sprintf (buff, _("<OS specific>: %d"), binding);
4248 sprintf (buff, _("<unknown>: %d"), binding);
4254 get_symbol_type (type)
4257 static char buff [32];
4261 case STT_NOTYPE: return "NOTYPE";
4262 case STT_OBJECT: return "OBJECT";
4263 case STT_FUNC: return "FUNC";
4264 case STT_SECTION: return "SECTION";
4265 case STT_FILE: return "FILE";
4266 case STT_COMMON: return "COMMON";
4268 if (type >= STT_LOPROC && type <= STT_HIPROC)
4270 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4271 return "THUMB_FUNC";
4273 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4276 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4277 return "PARISC_MILLI";
4279 sprintf (buff, _("<processor specific>: %d"), type);
4281 else if (type >= STT_LOOS && type <= STT_HIOS)
4283 if (elf_header.e_machine == EM_PARISC)
4285 if (type == STT_HP_OPAQUE)
4287 if (type == STT_HP_STUB)
4291 sprintf (buff, _("<OS specific>: %d"), type);
4294 sprintf (buff, _("<unknown>: %d"), type);
4300 get_symbol_visibility (visibility)
4301 unsigned int visibility;
4305 case STV_DEFAULT: return "DEFAULT";
4306 case STV_INTERNAL: return "INTERNAL";
4307 case STV_HIDDEN: return "HIDDEN";
4308 case STV_PROTECTED: return "PROTECTED";
4314 get_symbol_index_type (type)
4319 case SHN_UNDEF: return "UND";
4320 case SHN_ABS: return "ABS";
4321 case SHN_COMMON: return "COM";
4323 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4325 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4327 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4331 static char buff [32];
4333 sprintf (buff, "%3d", type);
4340 get_dynamic_data (file, number)
4342 unsigned int number;
4344 unsigned char * e_data;
4347 e_data = (unsigned char *) malloc (number * 4);
4351 error (_("Out of memory\n"));
4355 if (fread (e_data, 4, number, file) != number)
4357 error (_("Unable to read in dynamic data\n"));
4361 i_data = (int *) malloc (number * sizeof (* i_data));
4365 error (_("Out of memory\n"));
4371 i_data [number] = byte_get (e_data + number * 4, 4);
4378 /* Dump the symbol table */
4380 process_symbol_table (file)
4383 Elf32_Internal_Shdr * section;
4384 unsigned char nb [4];
4385 unsigned char nc [4];
4388 int * buckets = NULL;
4389 int * chains = NULL;
4391 if (! do_syms && !do_histogram)
4394 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4397 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4399 error (_("Unable to seek to start of dynamic information"));
4403 if (fread (nb, sizeof (nb), 1, file) != 1)
4405 error (_("Failed to read in number of buckets\n"));
4409 if (fread (nc, sizeof (nc), 1, file) != 1)
4411 error (_("Failed to read in number of chains\n"));
4415 nbuckets = byte_get (nb, 4);
4416 nchains = byte_get (nc, 4);
4418 buckets = get_dynamic_data (file, nbuckets);
4419 chains = get_dynamic_data (file, nchains);
4421 if (buckets == NULL || chains == NULL)
4426 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4431 printf (_("\nSymbol table for image:\n"));
4433 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4435 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4437 for (hn = 0; hn < nbuckets; hn++)
4442 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4444 Elf_Internal_Sym * psym;
4446 psym = dynamic_symbols + si;
4448 printf (" %3d %3d: ", si, hn);
4449 print_vma (psym->st_value, LONG_HEX);
4451 print_vma (psym->st_size, DEC_5);
4453 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4454 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4455 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4456 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4457 printf (" %s\n", dynamic_strings + psym->st_name);
4461 else if (do_syms && !do_using_dynamic)
4465 for (i = 0, section = section_headers;
4466 i < elf_header.e_shnum;
4471 Elf_Internal_Sym * symtab;
4472 Elf_Internal_Sym * psym;
4475 if ( section->sh_type != SHT_SYMTAB
4476 && section->sh_type != SHT_DYNSYM)
4479 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4480 SECTION_NAME (section),
4481 (unsigned long) (section->sh_size / section->sh_entsize));
4483 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4485 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4487 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4488 section->sh_size / section->sh_entsize);
4492 if (section->sh_link == elf_header.e_shstrndx)
4493 strtab = string_table;
4496 Elf32_Internal_Shdr * string_sec;
4498 string_sec = section_headers + section->sh_link;
4500 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4501 strtab, char *, "string table");
4504 for (si = 0, psym = symtab;
4505 si < section->sh_size / section->sh_entsize;
4508 printf ("%6d: ", si);
4509 print_vma (psym->st_value, LONG_HEX);
4511 print_vma (psym->st_size, DEC_5);
4512 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4513 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4514 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4515 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4516 printf (" %s", strtab + psym->st_name);
4518 if (section->sh_type == SHT_DYNSYM &&
4519 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4521 unsigned char data[2];
4522 unsigned short vers_data;
4523 unsigned long offset;
4527 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4530 GET_DATA (offset + si * sizeof (vers_data), data,
4533 vers_data = byte_get (data, 2);
4535 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4536 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4539 check_def = (psym->st_shndx != SHN_UNDEF);
4541 if ((vers_data & 0x8000) || vers_data > 1)
4543 if (is_nobits || ! check_def)
4545 Elf_External_Verneed evn;
4546 Elf_Internal_Verneed ivn;
4547 Elf_Internal_Vernaux ivna;
4549 /* We must test both. */
4550 offset = version_info
4551 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4555 unsigned long vna_off;
4557 GET_DATA (offset, evn, "version need");
4559 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4560 ivn.vn_next = BYTE_GET (evn.vn_next);
4562 vna_off = offset + ivn.vn_aux;
4566 Elf_External_Vernaux evna;
4568 GET_DATA (vna_off, evna,
4569 "version need aux (3)");
4571 ivna.vna_other = BYTE_GET (evna.vna_other);
4572 ivna.vna_next = BYTE_GET (evna.vna_next);
4573 ivna.vna_name = BYTE_GET (evna.vna_name);
4575 vna_off += ivna.vna_next;
4577 while (ivna.vna_other != vers_data
4578 && ivna.vna_next != 0);
4580 if (ivna.vna_other == vers_data)
4583 offset += ivn.vn_next;
4585 while (ivn.vn_next != 0);
4587 if (ivna.vna_other == vers_data)
4590 strtab + ivna.vna_name, ivna.vna_other);
4593 else if (! is_nobits)
4594 error (_("bad dynamic symbol"));
4601 if (vers_data != 0x8001)
4603 Elf_Internal_Verdef ivd;
4604 Elf_Internal_Verdaux ivda;
4605 Elf_External_Verdaux evda;
4606 unsigned long offset;
4609 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4614 Elf_External_Verdef evd;
4616 GET_DATA (offset, evd, "version def");
4618 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4619 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4620 ivd.vd_next = BYTE_GET (evd.vd_next);
4622 offset += ivd.vd_next;
4624 while (ivd.vd_ndx != (vers_data & 0x7fff)
4625 && ivd.vd_next != 0);
4627 offset -= ivd.vd_next;
4628 offset += ivd.vd_aux;
4630 GET_DATA (offset, evda, "version def aux");
4632 ivda.vda_name = BYTE_GET (evda.vda_name);
4634 if (psym->st_name != ivda.vda_name)
4635 printf ((vers_data & 0x8000)
4637 strtab + ivda.vda_name);
4647 if (strtab != string_table)
4653 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4655 if (do_histogram && buckets != NULL)
4662 int nzero_counts = 0;
4665 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4667 printf (_(" Length Number %% of total Coverage\n"));
4669 lengths = (int *) calloc (nbuckets, sizeof (int));
4670 if (lengths == NULL)
4672 error (_("Out of memory"));
4675 for (hn = 0; hn < nbuckets; ++hn)
4680 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4683 if (maxlength < ++lengths[hn])
4688 counts = (int *) calloc (maxlength + 1, sizeof (int));
4691 error (_("Out of memory"));
4695 for (hn = 0; hn < nbuckets; ++hn)
4696 ++ counts [lengths [hn]];
4700 printf (" 0 %-10d (%5.1f%%)\n",
4701 counts[0], (counts[0] * 100.0) / nbuckets);
4702 for (si = 1; si <= maxlength; ++si)
4704 nzero_counts += counts[si] * si;
4705 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4706 si, counts[si], (counts[si] * 100.0) / nbuckets,
4707 (nzero_counts * 100.0) / nsyms);
4715 if (buckets != NULL)
4725 process_syminfo (file)
4726 FILE * file ATTRIBUTE_UNUSED;
4730 if (dynamic_syminfo == NULL
4732 /* No syminfo, this is ok. */
4735 /* There better should be a dynamic symbol section. */
4736 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4740 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4741 dynamic_syminfo_offset, dynamic_syminfo_nent);
4743 printf (_(" Num: Name BoundTo Flags\n"));
4744 for (i = 0; i < dynamic_syminfo_nent; ++i)
4746 unsigned short int flags = dynamic_syminfo[i].si_flags;
4748 printf ("%4d: %-30s ", i,
4749 dynamic_strings + dynamic_symbols[i].st_name);
4751 switch (dynamic_syminfo[i].si_boundto)
4753 case SYMINFO_BT_SELF:
4754 fputs ("SELF ", stdout);
4756 case SYMINFO_BT_PARENT:
4757 fputs ("PARENT ", stdout);
4760 if (dynamic_syminfo[i].si_boundto > 0
4761 && dynamic_syminfo[i].si_boundto < dynamic_size)
4764 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4766 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4770 if (flags & SYMINFO_FLG_DIRECT)
4772 if (flags & SYMINFO_FLG_PASSTHRU)
4773 printf (" PASSTHRU");
4774 if (flags & SYMINFO_FLG_COPY)
4776 if (flags & SYMINFO_FLG_LAZYLOAD)
4777 printf (" LAZYLOAD");
4785 #ifdef SUPPORT_DISASSEMBLY
4787 disassemble_section (section, file)
4788 Elf32_Internal_Shdr * section;
4791 printf (_("\nAssembly dump of section %s\n"),
4792 SECTION_NAME (section));
4794 /* XXX -- to be done --- XXX */
4801 dump_section (section, file)
4802 Elf32_Internal_Shdr * section;
4805 bfd_size_type bytes;
4807 unsigned char * data;
4808 unsigned char * start;
4810 bytes = section->sh_size;
4814 printf (_("\nSection '%s' has no data to dump.\n"),
4815 SECTION_NAME (section));
4819 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4821 addr = section->sh_addr;
4823 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4834 lbytes = (bytes > 16 ? 16 : bytes);
4836 printf (" 0x%8.8lx ", (unsigned long) addr);
4838 switch (elf_header.e_ident [EI_DATA])
4842 for (j = 15; j >= 0; j --)
4845 printf ("%2.2x", data [j]);
4855 for (j = 0; j < 16; j++)
4858 printf ("%2.2x", data [j]);
4868 for (j = 0; j < lbytes; j++)
4871 if (k >= ' ' && k < 0x80)
4890 static unsigned long int
4891 read_leb128 (data, length_return, sign)
4892 unsigned char * data;
4893 int * length_return;
4896 unsigned long int result = 0;
4897 unsigned int num_read = 0;
4906 result |= (byte & 0x7f) << shift;
4911 while (byte & 0x80);
4913 if (length_return != NULL)
4914 * length_return = num_read;
4916 if (sign && (shift < 32) && (byte & 0x40))
4917 result |= -1 << shift;
4922 typedef struct State_Machine_Registers
4924 unsigned long address;
4927 unsigned int column;
4931 /* This variable hold the number of the last entry seen
4932 in the File Table. */
4933 unsigned int last_file_entry;
4936 static SMR state_machine_regs;
4939 reset_state_machine (is_stmt)
4942 state_machine_regs.address = 0;
4943 state_machine_regs.file = 1;
4944 state_machine_regs.line = 1;
4945 state_machine_regs.column = 0;
4946 state_machine_regs.is_stmt = is_stmt;
4947 state_machine_regs.basic_block = 0;
4948 state_machine_regs.end_sequence = 0;
4949 state_machine_regs.last_file_entry = 0;
4952 /* Handled an extend line op. Returns true if this is the end
4955 process_extended_line_op (data, is_stmt, pointer_size)
4956 unsigned char * data;
4960 unsigned char op_code;
4963 unsigned char * name;
4966 len = read_leb128 (data, & bytes_read, 0);
4971 warn (_("badly formed extended line op encountered!"));
4976 op_code = * data ++;
4978 printf (_(" Extended opcode %d: "), op_code);
4982 case DW_LNE_end_sequence:
4983 printf (_("End of Sequence\n\n"));
4984 reset_state_machine (is_stmt);
4987 case DW_LNE_set_address:
4988 adr = byte_get (data, pointer_size);
4989 printf (_("set Address to 0x%lx\n"), adr);
4990 state_machine_regs.address = adr;
4993 case DW_LNE_define_file:
4994 printf (_(" define new File Table entry\n"));
4995 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4997 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4999 data += strlen ((char *) data) + 1;
5000 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5002 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5004 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5005 printf (_("%s\n\n"), name);
5009 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5016 /* Size of pointers in the .debug_line section. This information is not
5017 really present in that section. It's obtained before dumping the debug
5018 sections by doing some pre-scan of the .debug_info section. */
5019 static int debug_line_pointer_size = 4;
5022 display_debug_lines (section, start, file)
5023 Elf32_Internal_Shdr * section;
5024 unsigned char * start;
5025 FILE * file ATTRIBUTE_UNUSED;
5027 DWARF2_External_LineInfo * external;
5028 DWARF2_Internal_LineInfo info;
5029 unsigned char * standard_opcodes;
5030 unsigned char * data = start;
5031 unsigned char * end = start + section->sh_size;
5032 unsigned char * end_of_sequence;
5035 printf (_("\nDump of debug contents of section %s:\n\n"),
5036 SECTION_NAME (section));
5040 external = (DWARF2_External_LineInfo *) data;
5042 /* Check the length of the block. */
5043 info.li_length = BYTE_GET (external->li_length);
5044 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5047 (_("The line info appears to be corrupt - the section is too small\n"));
5051 /* Check its version number. */
5052 info.li_version = BYTE_GET (external->li_version);
5053 if (info.li_version != 2)
5055 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5059 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5060 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5061 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5062 info.li_line_base = BYTE_GET (external->li_line_base);
5063 info.li_line_range = BYTE_GET (external->li_line_range);
5064 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5066 /* Sign extend the line base field. */
5067 info.li_line_base <<= 24;
5068 info.li_line_base >>= 24;
5070 printf (_(" Length: %ld\n"), info.li_length);
5071 printf (_(" DWARF Version: %d\n"), info.li_version);
5072 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
5073 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5074 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5075 printf (_(" Line Base: %d\n"), info.li_line_base);
5076 printf (_(" Line Range: %d\n"), info.li_line_range);
5077 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5079 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5081 reset_state_machine (info.li_default_is_stmt);
5083 /* Display the contents of the Opcodes table. */
5084 standard_opcodes = data + sizeof (* external);
5086 printf (_("\n Opcodes:\n"));
5088 for (i = 1; i < info.li_opcode_base; i++)
5089 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5091 /* Display the contents of the Directory table. */
5092 data = standard_opcodes + info.li_opcode_base - 1;
5095 printf (_("\n The Directory Table is empty.\n"));
5098 printf (_("\n The Directory Table:\n"));
5102 printf (_(" %s\n"), data);
5104 data += strlen ((char *) data) + 1;
5108 /* Skip the NUL at the end of the table. */
5111 /* Display the contents of the File Name table. */
5113 printf (_("\n The File Name Table is empty.\n"));
5116 printf (_("\n The File Name Table:\n"));
5117 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5121 unsigned char * name;
5124 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5127 data += strlen ((char *) data) + 1;
5129 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5131 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5133 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5135 printf (_("%s\n"), name);
5139 /* Skip the NUL at the end of the table. */
5142 /* Now display the statements. */
5143 printf (_("\n Line Number Statements:\n"));
5146 while (data < end_of_sequence)
5148 unsigned char op_code;
5152 op_code = * data ++;
5156 case DW_LNS_extended_op:
5157 data += process_extended_line_op (data, info.li_default_is_stmt,
5158 debug_line_pointer_size);
5162 printf (_(" Copy\n"));
5165 case DW_LNS_advance_pc:
5166 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5168 state_machine_regs.address += adv;
5169 printf (_(" Advance PC by %d to %lx\n"), adv,
5170 state_machine_regs.address);
5173 case DW_LNS_advance_line:
5174 adv = read_leb128 (data, & bytes_read, 1);
5176 state_machine_regs.line += adv;
5177 printf (_(" Advance Line by %d to %d\n"), adv,
5178 state_machine_regs.line);
5181 case DW_LNS_set_file:
5182 adv = read_leb128 (data, & bytes_read, 0);
5184 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5186 state_machine_regs.file = adv;
5189 case DW_LNS_set_column:
5190 adv = read_leb128 (data, & bytes_read, 0);
5192 printf (_(" Set column to %d\n"), adv);
5193 state_machine_regs.column = adv;
5196 case DW_LNS_negate_stmt:
5197 adv = state_machine_regs.is_stmt;
5199 printf (_(" Set is_stmt to %d\n"), adv);
5200 state_machine_regs.is_stmt = adv;
5203 case DW_LNS_set_basic_block:
5204 printf (_(" Set basic block\n"));
5205 state_machine_regs.basic_block = 1;
5208 case DW_LNS_const_add_pc:
5209 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5210 * info.li_min_insn_length);
5211 state_machine_regs.address += adv;
5212 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5213 state_machine_regs.address);
5216 case DW_LNS_fixed_advance_pc:
5217 adv = byte_get (data, 2);
5219 state_machine_regs.address += adv;
5220 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5221 adv, state_machine_regs.address);
5225 op_code -= info.li_opcode_base;
5226 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5227 state_machine_regs.address += adv;
5228 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5229 op_code, adv, state_machine_regs.address);
5230 adv = (op_code % info.li_line_range) + info.li_line_base;
5231 state_machine_regs.line += adv;
5232 printf (_(" and Line by %d to %d\n"),
5233 adv, state_machine_regs.line);
5244 display_debug_pubnames (section, start, file)
5245 Elf32_Internal_Shdr * section;
5246 unsigned char * start;
5247 FILE * file ATTRIBUTE_UNUSED;
5249 DWARF2_External_PubNames * external;
5250 DWARF2_Internal_PubNames pubnames;
5251 unsigned char * end;
5253 end = start + section->sh_size;
5255 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5259 unsigned char * data;
5260 unsigned long offset;
5262 external = (DWARF2_External_PubNames *) start;
5264 pubnames.pn_length = BYTE_GET (external->pn_length);
5265 pubnames.pn_version = BYTE_GET (external->pn_version);
5266 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5267 pubnames.pn_size = BYTE_GET (external->pn_size);
5269 data = start + sizeof (* external);
5270 start += pubnames.pn_length + sizeof (external->pn_length);
5272 if (pubnames.pn_version != 2)
5274 static int warned = 0;
5278 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5285 printf (_(" Length: %ld\n"),
5286 pubnames.pn_length);
5287 printf (_(" Version: %d\n"),
5288 pubnames.pn_version);
5289 printf (_(" Offset into .debug_info section: %ld\n"),
5290 pubnames.pn_offset);
5291 printf (_(" Size of area in .debug_info section: %ld\n"),
5294 printf (_("\n Offset\tName\n"));
5298 offset = byte_get (data, 4);
5303 printf (" %ld\t\t%s\n", offset, data);
5304 data += strlen ((char *) data) + 1;
5307 while (offset != 0);
5320 case DW_TAG_padding: return "DW_TAG_padding";
5321 case DW_TAG_array_type: return "DW_TAG_array_type";
5322 case DW_TAG_class_type: return "DW_TAG_class_type";
5323 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5324 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5325 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5326 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5327 case DW_TAG_label: return "DW_TAG_label";
5328 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5329 case DW_TAG_member: return "DW_TAG_member";
5330 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5331 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5332 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5333 case DW_TAG_string_type: return "DW_TAG_string_type";
5334 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5335 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5336 case DW_TAG_typedef: return "DW_TAG_typedef";
5337 case DW_TAG_union_type: return "DW_TAG_union_type";
5338 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5339 case DW_TAG_variant: return "DW_TAG_variant";
5340 case DW_TAG_common_block: return "DW_TAG_common_block";
5341 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5342 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5343 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5344 case DW_TAG_module: return "DW_TAG_module";
5345 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5346 case DW_TAG_set_type: return "DW_TAG_set_type";
5347 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5348 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5349 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5350 case DW_TAG_base_type: return "DW_TAG_base_type";
5351 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5352 case DW_TAG_const_type: return "DW_TAG_const_type";
5353 case DW_TAG_constant: return "DW_TAG_constant";
5354 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5355 case DW_TAG_file_type: return "DW_TAG_file_type";
5356 case DW_TAG_friend: return "DW_TAG_friend";
5357 case DW_TAG_namelist: return "DW_TAG_namelist";
5358 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5359 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5360 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5361 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5362 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5363 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5364 case DW_TAG_try_block: return "DW_TAG_try_block";
5365 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5366 case DW_TAG_variable: return "DW_TAG_variable";
5367 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5368 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5369 case DW_TAG_format_label: return "DW_TAG_format_label";
5370 case DW_TAG_function_template: return "DW_TAG_function_template";
5371 case DW_TAG_class_template: return "DW_TAG_class_template";
5374 static char buffer [100];
5376 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5383 get_AT_name (attribute)
5384 unsigned long attribute;
5388 case DW_AT_sibling: return "DW_AT_sibling";
5389 case DW_AT_location: return "DW_AT_location";
5390 case DW_AT_name: return "DW_AT_name";
5391 case DW_AT_ordering: return "DW_AT_ordering";
5392 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5393 case DW_AT_byte_size: return "DW_AT_byte_size";
5394 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5395 case DW_AT_bit_size: return "DW_AT_bit_size";
5396 case DW_AT_element_list: return "DW_AT_element_list";
5397 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5398 case DW_AT_low_pc: return "DW_AT_low_pc";
5399 case DW_AT_high_pc: return "DW_AT_high_pc";
5400 case DW_AT_language: return "DW_AT_language";
5401 case DW_AT_member: return "DW_AT_member";
5402 case DW_AT_discr: return "DW_AT_discr";
5403 case DW_AT_discr_value: return "DW_AT_discr_value";
5404 case DW_AT_visibility: return "DW_AT_visibility";
5405 case DW_AT_import: return "DW_AT_import";
5406 case DW_AT_string_length: return "DW_AT_string_length";
5407 case DW_AT_common_reference: return "DW_AT_common_reference";
5408 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5409 case DW_AT_const_value: return "DW_AT_const_value";
5410 case DW_AT_containing_type: return "DW_AT_containing_type";
5411 case DW_AT_default_value: return "DW_AT_default_value";
5412 case DW_AT_inline: return "DW_AT_inline";
5413 case DW_AT_is_optional: return "DW_AT_is_optional";
5414 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5415 case DW_AT_producer: return "DW_AT_producer";
5416 case DW_AT_prototyped: return "DW_AT_prototyped";
5417 case DW_AT_return_addr: return "DW_AT_return_addr";
5418 case DW_AT_start_scope: return "DW_AT_start_scope";
5419 case DW_AT_stride_size: return "DW_AT_stride_size";
5420 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5421 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5422 case DW_AT_accessibility: return "DW_AT_accessibility";
5423 case DW_AT_address_class: return "DW_AT_address_class";
5424 case DW_AT_artificial: return "DW_AT_artificial";
5425 case DW_AT_base_types: return "DW_AT_base_types";
5426 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5427 case DW_AT_count: return "DW_AT_count";
5428 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5429 case DW_AT_decl_column: return "DW_AT_decl_column";
5430 case DW_AT_decl_file: return "DW_AT_decl_file";
5431 case DW_AT_decl_line: return "DW_AT_decl_line";
5432 case DW_AT_declaration: return "DW_AT_declaration";
5433 case DW_AT_discr_list: return "DW_AT_discr_list";
5434 case DW_AT_encoding: return "DW_AT_encoding";
5435 case DW_AT_external: return "DW_AT_external";
5436 case DW_AT_frame_base: return "DW_AT_frame_base";
5437 case DW_AT_friend: return "DW_AT_friend";
5438 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5439 case DW_AT_macro_info: return "DW_AT_macro_info";
5440 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5441 case DW_AT_priority: return "DW_AT_priority";
5442 case DW_AT_segment: return "DW_AT_segment";
5443 case DW_AT_specification: return "DW_AT_specification";
5444 case DW_AT_static_link: return "DW_AT_static_link";
5445 case DW_AT_type: return "DW_AT_type";
5446 case DW_AT_use_location: return "DW_AT_use_location";
5447 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5448 case DW_AT_virtuality: return "DW_AT_virtuality";
5449 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5450 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5451 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5452 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5453 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5454 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5455 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5456 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5457 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5458 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5459 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5460 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5461 case DW_AT_sf_names: return "DW_AT_sf_names";
5462 case DW_AT_src_info: return "DW_AT_src_info";
5463 case DW_AT_mac_info: return "DW_AT_mac_info";
5464 case DW_AT_src_coords: return "DW_AT_src_coords";
5465 case DW_AT_body_begin: return "DW_AT_body_begin";
5466 case DW_AT_body_end: return "DW_AT_body_end";
5469 static char buffer [100];
5471 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5478 get_FORM_name (form)
5483 case DW_FORM_addr: return "DW_FORM_addr";
5484 case DW_FORM_block2: return "DW_FORM_block2";
5485 case DW_FORM_block4: return "DW_FORM_block4";
5486 case DW_FORM_data2: return "DW_FORM_data2";
5487 case DW_FORM_data4: return "DW_FORM_data4";
5488 case DW_FORM_data8: return "DW_FORM_data8";
5489 case DW_FORM_string: return "DW_FORM_string";
5490 case DW_FORM_block: return "DW_FORM_block";
5491 case DW_FORM_block1: return "DW_FORM_block1";
5492 case DW_FORM_data1: return "DW_FORM_data1";
5493 case DW_FORM_flag: return "DW_FORM_flag";
5494 case DW_FORM_sdata: return "DW_FORM_sdata";
5495 case DW_FORM_strp: return "DW_FORM_strp";
5496 case DW_FORM_udata: return "DW_FORM_udata";
5497 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5498 case DW_FORM_ref1: return "DW_FORM_ref1";
5499 case DW_FORM_ref2: return "DW_FORM_ref2";
5500 case DW_FORM_ref4: return "DW_FORM_ref4";
5501 case DW_FORM_ref8: return "DW_FORM_ref8";
5502 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5503 case DW_FORM_indirect: return "DW_FORM_indirect";
5506 static char buffer [100];
5508 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5514 /* FIXME: There are better and more effiecint ways to handle
5515 these structures. For now though, I just want something that
5516 is simple to implement. */
5517 typedef struct abbrev_attr
5519 unsigned long attribute;
5521 struct abbrev_attr * next;
5525 typedef struct abbrev_entry
5527 unsigned long entry;
5530 struct abbrev_attr * first_attr;
5531 struct abbrev_attr * last_attr;
5532 struct abbrev_entry * next;
5536 static abbrev_entry * first_abbrev = NULL;
5537 static abbrev_entry * last_abbrev = NULL;
5540 free_abbrevs PARAMS ((void))
5542 abbrev_entry * abbrev;
5544 for (abbrev = first_abbrev; abbrev;)
5546 abbrev_entry * next = abbrev->next;
5549 for (attr = abbrev->first_attr; attr;)
5551 abbrev_attr * next = attr->next;
5561 last_abbrev = first_abbrev = NULL;
5565 add_abbrev (number, tag, children)
5566 unsigned long number;
5570 abbrev_entry * entry;
5572 entry = (abbrev_entry *) malloc (sizeof (* entry));
5578 entry->entry = number;
5580 entry->children = children;
5581 entry->first_attr = NULL;
5582 entry->last_attr = NULL;
5585 if (first_abbrev == NULL)
5586 first_abbrev = entry;
5588 last_abbrev->next = entry;
5590 last_abbrev = entry;
5594 add_abbrev_attr (attribute, form)
5595 unsigned long attribute;
5600 attr = (abbrev_attr *) malloc (sizeof (* attr));
5606 attr->attribute = attribute;
5610 if (last_abbrev->first_attr == NULL)
5611 last_abbrev->first_attr = attr;
5613 last_abbrev->last_attr->next = attr;
5615 last_abbrev->last_attr = attr;
5618 /* Processes the (partial) contents of a .debug_abbrev section.
5619 Returns NULL if the end of the section was encountered.
5620 Returns the address after the last byte read if the end of
5621 an abbreviation set was found. */
5623 static unsigned char *
5624 process_abbrev_section (start, end)
5625 unsigned char * start;
5626 unsigned char * end;
5628 if (first_abbrev != NULL)
5634 unsigned long entry;
5636 unsigned long attribute;
5639 entry = read_leb128 (start, & bytes_read, 0);
5640 start += bytes_read;
5642 /* A single zero is supposed to end the section according
5643 to the standard. If there's more, then signal that to
5646 return start == end ? NULL : start;
5648 tag = read_leb128 (start, & bytes_read, 0);
5649 start += bytes_read;
5651 children = * start ++;
5653 add_abbrev (entry, tag, children);
5659 attribute = read_leb128 (start, & bytes_read, 0);
5660 start += bytes_read;
5662 form = read_leb128 (start, & bytes_read, 0);
5663 start += bytes_read;
5666 add_abbrev_attr (attribute, form);
5668 while (attribute != 0);
5676 display_debug_abbrev (section, start, file)
5677 Elf32_Internal_Shdr * section;
5678 unsigned char * start;
5679 FILE * file ATTRIBUTE_UNUSED;
5681 abbrev_entry * entry;
5682 unsigned char * end = start + section->sh_size;
5684 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5688 start = process_abbrev_section (start, end);
5690 printf (_(" Number TAG\n"));
5692 for (entry = first_abbrev; entry; entry = entry->next)
5696 printf (_(" %ld %s [%s]\n"),
5698 get_TAG_name (entry->tag),
5699 entry->children ? _("has children") : _("no children"));
5701 for (attr = entry->first_attr; attr; attr = attr->next)
5703 printf (_(" %-18s %s\n"),
5704 get_AT_name (attr->attribute),
5705 get_FORM_name (attr->form));
5717 static unsigned char *
5718 display_block (data, length)
5719 unsigned char * data;
5720 unsigned long length;
5722 printf (_(" %lu byte block: "), length);
5725 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5731 decode_location_expression (data, pointer_size, length)
5732 unsigned char * data;
5733 unsigned int pointer_size;
5734 unsigned long length;
5738 unsigned long uvalue;
5739 unsigned char * end = data + length;
5748 printf ("DW_OP_addr: %lx",
5749 (unsigned long) byte_get (data, pointer_size));
5750 data += pointer_size;
5753 printf ("DW_OP_deref");
5756 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
5759 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
5762 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5766 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5770 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5774 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5778 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5779 (unsigned long) byte_get (data + 4, 4));
5783 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5784 (long) byte_get (data + 4, 4));
5788 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
5792 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
5796 printf ("DW_OP_dup");
5799 printf ("DW_OP_drop");
5802 printf ("DW_OP_over");
5805 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
5808 printf ("DW_OP_swap");
5811 printf ("DW_OP_rot");
5814 printf ("DW_OP_xderef");
5817 printf ("DW_OP_abs");
5820 printf ("DW_OP_and");
5823 printf ("DW_OP_div");
5826 printf ("DW_OP_minus");
5829 printf ("DW_OP_mod");
5832 printf ("DW_OP_mul");
5835 printf ("DW_OP_neg");
5838 printf ("DW_OP_not");
5841 printf ("DW_OP_or");
5844 printf ("DW_OP_plus");
5846 case DW_OP_plus_uconst:
5847 printf ("DW_OP_plus_uconst: %lu",
5848 read_leb128 (data, &bytes_read, 0));
5852 printf ("DW_OP_shl");
5855 printf ("DW_OP_shr");
5858 printf ("DW_OP_shra");
5861 printf ("DW_OP_xor");
5864 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5868 printf ("DW_OP_eq");
5871 printf ("DW_OP_ge");
5874 printf ("DW_OP_gt");
5877 printf ("DW_OP_le");
5880 printf ("DW_OP_lt");
5883 printf ("DW_OP_ne");
5886 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5922 printf ("DW_OP_lit%d", op - DW_OP_lit0);
5957 printf ("DW_OP_reg%d", op - DW_OP_reg0);
5992 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
5993 read_leb128 (data, &bytes_read, 1));
5998 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6002 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6006 uvalue = read_leb128 (data, &bytes_read, 0);
6008 printf ("DW_OP_bregx: %lu %ld", uvalue,
6009 read_leb128 (data, &bytes_read, 1));
6013 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6016 case DW_OP_deref_size:
6017 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6019 case DW_OP_xderef_size:
6020 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6023 printf ("DW_OP_nop");
6027 if (op >= DW_OP_lo_user
6028 && op <= DW_OP_hi_user)
6029 printf (_("(User defined location op)"));
6031 printf (_("(Unknown location op)"));
6032 /* No way to tell where the next op is, so just bail. */
6039 static unsigned char *
6040 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6041 unsigned long attribute;
6043 unsigned char * data;
6044 unsigned long cu_offset;
6045 unsigned long pointer_size;
6047 unsigned long uvalue = 0;
6048 unsigned char * block_start = NULL;
6051 printf (" %-18s:", get_AT_name (attribute));
6058 case DW_FORM_ref_addr:
6060 uvalue = byte_get (data, pointer_size);
6061 data += pointer_size;
6067 uvalue = byte_get (data ++, 1);
6072 uvalue = byte_get (data, 2);
6078 uvalue = byte_get (data, 4);
6083 uvalue = read_leb128 (data, & bytes_read, 1);
6087 case DW_FORM_ref_udata:
6089 uvalue = read_leb128 (data, & bytes_read, 0);
6096 case DW_FORM_ref_addr:
6097 printf (" <#%lx>", uvalue);
6103 case DW_FORM_ref_udata:
6104 printf (" <%lx>", uvalue + cu_offset);
6108 printf (" %#lx", uvalue);
6116 printf (" %ld", uvalue);
6121 uvalue = byte_get (data, 4);
6122 printf (" %lx", uvalue);
6123 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6127 case DW_FORM_string:
6128 printf (" %s", data);
6129 data += strlen ((char *) data) + 1;
6133 uvalue = read_leb128 (data, & bytes_read, 0);
6134 block_start = data + bytes_read;
6135 data = display_block (block_start, uvalue);
6138 case DW_FORM_block1:
6139 uvalue = byte_get (data, 1);
6140 block_start = data + 1;
6141 data = display_block (block_start, uvalue);
6144 case DW_FORM_block2:
6145 uvalue = byte_get (data, 2);
6146 block_start = data + 2;
6147 data = display_block (block_start, uvalue);
6150 case DW_FORM_block4:
6151 uvalue = byte_get (data, 4);
6152 block_start = data + 4;
6153 data = display_block (block_start, uvalue);
6157 case DW_FORM_indirect:
6158 warn (_("Unable to handle FORM: %d"), form);
6162 warn (_("Unrecognised form: %d"), form);
6166 /* For some attributes we can display futher information. */
6175 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6176 case DW_INL_inlined: printf (_("(inlined)")); break;
6177 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6178 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6179 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6183 case DW_AT_language:
6186 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6187 case DW_LANG_C89: printf ("(ANSI C)"); break;
6188 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6189 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6190 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6191 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6192 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6193 case DW_LANG_Ada83: printf ("(Ada)"); break;
6194 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6195 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6196 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6197 default: printf ("(Unknown: %lx)", uvalue); break;
6201 case DW_AT_encoding:
6204 case DW_ATE_void: printf ("(void)"); break;
6205 case DW_ATE_address: printf ("(machine address)"); break;
6206 case DW_ATE_boolean: printf ("(boolean)"); break;
6207 case DW_ATE_complex_float: printf ("(complex float)"); break;
6208 case DW_ATE_float: printf ("(float)"); break;
6209 case DW_ATE_signed: printf ("(signed)"); break;
6210 case DW_ATE_signed_char: printf ("(signed char)"); break;
6211 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6212 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6214 if (uvalue >= DW_ATE_lo_user
6215 && uvalue <= DW_ATE_hi_user)
6216 printf ("(user defined type)");
6218 printf ("(unknown type)");
6223 case DW_AT_accessibility:
6226 case DW_ACCESS_public: printf ("(public)"); break;
6227 case DW_ACCESS_protected: printf ("(protected)"); break;
6228 case DW_ACCESS_private: printf ("(private)"); break;
6229 default: printf ("(unknown accessibility)"); break;
6233 case DW_AT_visibility:
6236 case DW_VIS_local: printf ("(local)"); break;
6237 case DW_VIS_exported: printf ("(exported)"); break;
6238 case DW_VIS_qualified: printf ("(qualified)"); break;
6239 default: printf ("(unknown visibility)"); break;
6243 case DW_AT_virtuality:
6246 case DW_VIRTUALITY_none: printf ("(none)"); break;
6247 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6248 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6249 default: printf ("(unknown virtuality)"); break;
6253 case DW_AT_identifier_case:
6256 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6257 case DW_ID_up_case: printf ("(up_case)"); break;
6258 case DW_ID_down_case: printf ("(down_case)"); break;
6259 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6260 default: printf ("(unknown case)"); break;
6264 case DW_AT_calling_convention:
6267 case DW_CC_normal: printf ("(normal)"); break;
6268 case DW_CC_program: printf ("(program)"); break;
6269 case DW_CC_nocall: printf ("(nocall)"); break;
6271 if (uvalue >= DW_CC_lo_user
6272 && uvalue <= DW_CC_hi_user)
6273 printf ("(user defined)");
6275 printf ("(unknown convention)");
6279 case DW_AT_frame_base:
6280 case DW_AT_location:
6281 case DW_AT_data_member_location:
6282 case DW_AT_vtable_elem_location:
6286 decode_location_expression (block_start, pointer_size, uvalue);
6300 display_debug_info (section, start, file)
6301 Elf32_Internal_Shdr * section;
6302 unsigned char * start;
6305 unsigned char * end = start + section->sh_size;
6306 unsigned char * section_begin = start;
6308 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6312 DWARF2_External_CompUnit * external;
6313 DWARF2_Internal_CompUnit compunit;
6314 unsigned char * tags;
6317 unsigned long cu_offset;
6319 external = (DWARF2_External_CompUnit *) start;
6321 compunit.cu_length = BYTE_GET (external->cu_length);
6322 compunit.cu_version = BYTE_GET (external->cu_version);
6323 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6324 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6326 tags = start + sizeof (* external);
6327 cu_offset = start - section_begin;
6328 start += compunit.cu_length + sizeof (external->cu_length);
6330 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
6331 printf (_(" Length: %ld\n"), compunit.cu_length);
6332 printf (_(" Version: %d\n"), compunit.cu_version);
6333 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6334 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6336 if (compunit.cu_version != 2)
6338 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6342 if (first_abbrev != NULL)
6345 /* Read in the abbrevs used by this compilation unit. */
6348 Elf32_Internal_Shdr * sec;
6349 unsigned char * begin;
6351 /* Locate the .debug_abbrev section and process it. */
6352 for (i = 0, sec = section_headers;
6353 i < elf_header.e_shnum;
6355 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6358 if (i == -1 || sec->sh_size == 0)
6360 warn (_("Unable to locate .debug_abbrev section!\n"));
6364 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6365 "debug_abbrev section data");
6367 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6368 begin + sec->sh_size);
6374 while (tags < start)
6377 unsigned long abbrev_number;
6378 abbrev_entry * entry;
6381 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6384 /* A null DIE marks the end of a list of children. */
6385 if (abbrev_number == 0)
6391 /* Scan through the abbreviation list until we reach the
6393 for (entry = first_abbrev;
6394 entry && entry->entry != abbrev_number;
6395 entry = entry->next)
6400 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6405 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6406 level, tags - section_begin - bytes_read,
6408 get_TAG_name (entry->tag));
6410 for (attr = entry->first_attr; attr; attr = attr->next)
6411 tags = read_and_display_attr (attr->attribute,
6414 compunit.cu_pointer_size);
6416 if (entry->children)
6427 display_debug_aranges (section, start, file)
6428 Elf32_Internal_Shdr * section;
6429 unsigned char * start;
6430 FILE * file ATTRIBUTE_UNUSED;
6432 unsigned char * end = start + section->sh_size;
6434 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6438 DWARF2_External_ARange * external;
6439 DWARF2_Internal_ARange arange;
6440 unsigned char * ranges;
6441 unsigned long length;
6442 unsigned long address;
6445 external = (DWARF2_External_ARange *) start;
6447 arange.ar_length = BYTE_GET (external->ar_length);
6448 arange.ar_version = BYTE_GET (external->ar_version);
6449 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6450 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6451 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6453 if (arange.ar_version != 2)
6455 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6459 printf (_(" Length: %ld\n"), arange.ar_length);
6460 printf (_(" Version: %d\n"), arange.ar_version);
6461 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6462 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6463 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6465 printf (_("\n Address Length\n"));
6467 ranges = start + sizeof (* external);
6469 /* Must pad to an alignment boundary that is twice the pointer size. */
6470 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
6472 ranges += (2 * arange.ar_pointer_size) - excess;
6476 address = byte_get (ranges, arange.ar_pointer_size);
6478 ranges += arange.ar_pointer_size;
6480 length = byte_get (ranges, arange.ar_pointer_size);
6482 ranges += arange.ar_pointer_size;
6484 /* A pair of zeros marks the end of the list. */
6485 if (address == 0 && length == 0)
6488 printf (" %8.8lx %lu\n", address, length);
6491 start += arange.ar_length + sizeof (external->ar_length);
6499 typedef struct Frame_Chunk
6501 struct Frame_Chunk * next;
6502 unsigned char * chunk_start;
6504 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6505 short int * col_type;
6507 char * augmentation;
6508 unsigned int code_factor;
6509 unsigned int data_factor;
6510 unsigned long pc_begin;
6511 unsigned long pc_range;
6518 /* A marker for a col_type that means this column was never referenced
6519 in the frame info. */
6520 #define DW_CFA_unreferenced (-1)
6523 frame_need_space (fc, reg)
6527 int prev = fc->ncols;
6529 if (reg < fc->ncols)
6532 fc->ncols = reg + 1;
6533 fc->col_type = (short int *) xrealloc (fc->col_type,
6534 fc->ncols * sizeof (short int));
6535 fc->col_offset = (int *) xrealloc (fc->col_offset,
6536 fc->ncols * sizeof (int));
6538 while (prev < fc->ncols)
6540 fc->col_type[prev] = DW_CFA_unreferenced;
6541 fc->col_offset[prev] = 0;
6547 frame_display_row (fc, need_col_headers, max_regs)
6549 int * need_col_headers;
6555 if (* max_regs < fc->ncols)
6556 * max_regs = fc->ncols;
6558 if (* need_col_headers)
6560 * need_col_headers = 0;
6562 printf (" LOC CFA ");
6564 for (r = 0; r < * max_regs; r++)
6565 if (fc->col_type[r] != DW_CFA_unreferenced)
6570 printf ("r%-4d", r);
6576 printf ("%08x ", (unsigned int) fc->pc_begin);
6577 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
6578 printf ("%-8s ", tmp);
6580 for (r = 0; r < fc->ncols; r++)
6582 if (fc->col_type[r] != DW_CFA_unreferenced)
6584 switch (fc->col_type[r])
6586 case DW_CFA_undefined:
6589 case DW_CFA_same_value:
6593 sprintf (tmp, "c%+d", fc->col_offset[r]);
6595 case DW_CFA_register:
6596 sprintf (tmp, "r%d", fc->col_offset[r]);
6599 strcpy (tmp, "n/a");
6602 printf ("%-5s", tmp);
6608 #define GET(N) byte_get (start, N); start += N
6609 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
6610 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
6613 display_debug_frames (section, start, file)
6614 Elf32_Internal_Shdr * section;
6615 unsigned char * start;
6616 FILE * file ATTRIBUTE_UNUSED;
6618 unsigned char * end = start + section->sh_size;
6619 unsigned char * section_start = start;
6620 Frame_Chunk * chunks = 0;
6621 Frame_Chunk * remembered_state = 0;
6623 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
6627 printf (_("The section %s contains:\n"), SECTION_NAME (section));
6631 unsigned char * saved_start;
6632 unsigned char * block_end;
6633 unsigned long length;
6634 unsigned long cie_id;
6637 int need_col_headers = 1;
6639 saved_start = start;
6640 length = byte_get (start, 4); start += 4;
6645 block_end = saved_start + length + 4;
6646 cie_id = byte_get (start, 4); start += 4;
6648 printf ("\n%08x %08lx %08lx ", saved_start - section_start, length, cie_id);
6650 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
6652 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6653 memset (fc, 0, sizeof (Frame_Chunk));
6657 fc->chunk_start = saved_start;
6659 fc->col_type = (short int *) xmalloc (sizeof (short int));
6660 fc->col_offset = (int *) xmalloc (sizeof (int));
6661 frame_need_space (fc, max_regs-1);
6663 start ++; /* version */
6664 fc->augmentation = start;
6669 start++; /* skip past NUL */
6671 if (fc->augmentation[0] == 'z')
6674 fc->code_factor = LEB ();
6675 fc->data_factor = SLEB ();
6676 fc->ra = byte_get (start, 1); start += 1;
6678 printf ("skipping %d extra bytes\n", xtra);
6681 else if (strcmp (fc->augmentation, "eh") == 0)
6684 fc->code_factor = LEB ();
6685 fc->data_factor = SLEB ();
6686 fc->ra = byte_get (start, 1); start += 1;
6690 fc->code_factor = LEB ();
6691 fc->data_factor = SLEB ();
6692 fc->ra = byte_get (start, 1); start += 1;
6695 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n",
6696 fc->augmentation, fc->code_factor, fc->data_factor, fc->ra);
6698 frame_need_space (fc, fc->ra);
6702 unsigned char * look_for;
6703 static Frame_Chunk fde_fc;
6706 memset (fc, 0, sizeof (Frame_Chunk));
6708 look_for = is_eh ? start-4-cie_id : (unsigned char *) cie_id;
6710 fc->pc_begin = byte_get (start, 4); start += 4;
6711 fc->pc_range = byte_get (start, 4); start += 4;
6713 for (cie=chunks; cie && (cie->chunk_start != look_for); cie = cie->next);
6716 warn ("Invalid CIE pointer %08x in FDE at %08x\n", cie_id, saved_start);
6719 fc->col_type = (short int *) xmalloc (sizeof (short int));
6720 fc->col_offset = (int *) xmalloc (sizeof (int));
6721 frame_need_space (fc, max_regs - 1);
6723 fc->augmentation = "";
6727 fc->ncols = cie->ncols;
6728 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
6729 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
6730 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
6731 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
6732 fc->augmentation = cie->augmentation;
6733 fc->code_factor = cie->code_factor;
6734 fc->data_factor = cie->data_factor;
6735 fc->cfa_reg = cie->cfa_reg;
6736 fc->cfa_offset = cie->cfa_offset;
6738 frame_need_space (fc, max_regs-1);
6741 if (cie->augmentation[0] == 'z')
6743 unsigned long l = LEB ();
6747 printf ("FDE cie=%08x pc=%08lx..%08lx\n",
6748 cie->chunk_start-section_start, fc->pc_begin,
6749 fc->pc_begin + fc->pc_range);
6752 /* At this point, fc is the current chunk, cie (if any) is set, and we're
6753 about to interpret instructions for the chunk. */
6755 /* This exists for readelf maintainers. */
6759 /* Start by making a pass over the chunk, allocating storage
6760 and taking note of what registers are used. */
6761 unsigned char * tmp = start;
6763 while (start < block_end)
6774 /* Warning: if you add any more cases to this switch, be
6775 sure to add them to the corresponding switch below. */
6778 case DW_CFA_advance_loc:
6782 frame_need_space (fc, opa);
6783 fc->col_type[opa] = DW_CFA_undefined;
6785 case DW_CFA_restore:
6786 frame_need_space (fc, opa);
6787 fc->col_type[opa] = DW_CFA_undefined;
6789 case DW_CFA_set_loc:
6790 start += sizeof (vma);
6792 case DW_CFA_advance_loc1:
6795 case DW_CFA_advance_loc2:
6798 case DW_CFA_advance_loc4:
6801 case DW_CFA_offset_extended:
6802 reg = LEB (); LEB ();
6803 frame_need_space (fc, reg);
6804 fc->col_type[reg] = DW_CFA_undefined;
6806 case DW_CFA_restore_extended:
6808 frame_need_space (fc, reg);
6809 fc->col_type[reg] = DW_CFA_undefined;
6811 case DW_CFA_undefined:
6813 frame_need_space (fc, reg);
6814 fc->col_type[reg] = DW_CFA_undefined;
6816 case DW_CFA_same_value:
6818 frame_need_space (fc, reg);
6819 fc->col_type[reg] = DW_CFA_undefined;
6821 case DW_CFA_register:
6822 reg = LEB (); LEB ();
6823 frame_need_space (fc, reg);
6824 fc->col_type[reg] = DW_CFA_undefined;
6826 case DW_CFA_def_cfa:
6829 case DW_CFA_def_cfa_register:
6832 case DW_CFA_def_cfa_offset:
6835 #ifndef DW_CFA_GNU_args_size
6836 #define DW_CFA_GNU_args_size 0x2e
6838 case DW_CFA_GNU_args_size:
6841 #ifndef DW_CFA_GNU_negative_offset_extended
6842 #define DW_CFA_GNU_negative_offset_extended 0x2f
6844 case DW_CFA_GNU_negative_offset_extended:
6845 reg = LEB (); LEB ();
6846 frame_need_space (fc, reg);
6847 fc->col_type[reg] = DW_CFA_undefined;
6856 /* Now we know what registers are used, make a second pass over
6857 the chunk, this time actually printing out the info. */
6859 while (start < block_end)
6862 unsigned long ul, reg, roffs;
6871 /* Warning: if you add any more cases to this switch, be
6872 sure to add them to the corresponding switch above. */
6875 case DW_CFA_advance_loc:
6876 frame_display_row (fc, &need_col_headers, &max_regs);
6878 printf (" DW_CFA_advance_loc: %08x = %08x + %d*%d\n",
6879 fc->pc_begin + opa * fc->code_factor, fc->pc_begin, opa, fc->code_factor);
6881 fc->pc_begin += opa * fc->code_factor;
6887 printf (" DW_CFA_offset: r%d = cfa[%d*%d]\n", opa, roffs, fc->data_factor);
6889 fc->col_type[opa] = DW_CFA_offset;
6890 fc->col_offset[opa] = roffs * fc->data_factor;
6893 case DW_CFA_restore:
6895 printf (" DW_CFA_restore: r%d\n", opa);
6897 fc->col_type[opa] = cie->col_type[opa];
6898 fc->col_offset[opa] = cie->col_offset[opa];
6901 case DW_CFA_set_loc:
6902 frame_display_row (fc, &need_col_headers, &max_regs);
6903 vma = byte_get (start, sizeof (vma)); start += sizeof (vma);
6905 printf (" DW_CFA_set_loc: %08x\n", vma);
6910 case DW_CFA_advance_loc1:
6911 frame_display_row (fc, &need_col_headers, &max_regs);
6912 ofs = byte_get (start, 1); start += 1;
6914 printf (" DW_CFA_advance_loc1: %08x = %08x + %d*%d\n",
6915 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
6917 fc->pc_begin += ofs * fc->code_factor;
6920 case DW_CFA_advance_loc2:
6921 frame_display_row (fc, &need_col_headers, &max_regs);
6922 ofs = byte_get (start, 2); start += 2;
6924 printf (" DW_CFA_advance_loc2: %08x = %08x + %d*%d\n",
6925 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
6927 fc->pc_begin += ofs * fc->code_factor;
6930 case DW_CFA_advance_loc4:
6931 frame_display_row (fc, &need_col_headers, &max_regs);
6932 ofs = byte_get (start, 4); start += 4;
6934 printf (" DW_CFA_advance_loc4: %08x = %08x + %d*%d\n",
6935 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
6937 fc->pc_begin += ofs * fc->code_factor;
6940 case DW_CFA_offset_extended:
6944 printf (" DW_CFA_offset_extended: r%d = cfa[%d*%d]\n", reg, roffs, fc->data_factor);
6946 fc->col_type[reg] = DW_CFA_offset;
6947 fc->col_offset[reg] = roffs * fc->data_factor;
6950 case DW_CFA_restore_extended:
6953 printf (" DW_CFA_restore_extended: r%d\n", reg);
6955 fc->col_type[reg] = cie->col_type[reg];
6956 fc->col_offset[reg] = cie->col_offset[reg];
6959 case DW_CFA_undefined:
6962 printf (" DW_CFA_undefined: r%d\n", reg);
6964 fc->col_type[reg] = DW_CFA_undefined;
6965 fc->col_offset[reg] = 0;
6968 case DW_CFA_same_value:
6971 printf (" DW_CFA_same_value: r%d\n", reg);
6973 fc->col_type[reg] = DW_CFA_same_value;
6974 fc->col_offset[reg] = 0;
6977 case DW_CFA_register:
6981 printf (" DW_CFA_register: r%d\n", reg);
6983 fc->col_type[reg] = DW_CFA_register;
6984 fc->col_offset[reg] = roffs;
6987 case DW_CFA_remember_state:
6989 printf (" DW_CFA_remember_state\n");
6991 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6992 rs->ncols = fc->ncols;
6993 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
6994 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
6995 memcpy (rs->col_type, fc->col_type, rs->ncols);
6996 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
6997 rs->next = remembered_state;
6998 remembered_state = rs;
7001 case DW_CFA_restore_state:
7003 printf (" DW_CFA_restore_state\n");
7005 rs = remembered_state;
7006 remembered_state = rs->next;
7007 frame_need_space (fc, rs->ncols-1);
7008 memcpy (fc->col_type, rs->col_type, rs->ncols);
7009 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
7010 free (rs->col_type);
7011 free (rs->col_offset);
7015 case DW_CFA_def_cfa:
7016 fc->cfa_reg = LEB ();
7017 fc->cfa_offset = LEB ();
7019 printf (" DW_CFA_def_cfa: reg %d ofs %d\n", fc->cfa_reg, fc->cfa_offset);
7023 case DW_CFA_def_cfa_register:
7024 fc->cfa_reg = LEB ();
7026 printf (" DW_CFA_def_cfa_reg: %d\n", fc->cfa_reg);
7030 case DW_CFA_def_cfa_offset:
7031 fc->cfa_offset = LEB ();
7033 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
7039 printf (" DW_CFA_nop\n");
7043 #ifndef DW_CFA_GNU_window_save
7044 #define DW_CFA_GNU_window_save 0x2d
7046 case DW_CFA_GNU_window_save:
7048 printf (" DW_CFA_GNU_window_save\n");
7052 #ifndef DW_CFA_GNU_args_size
7053 #define DW_CFA_GNU_args_size 0x2e
7055 case DW_CFA_GNU_args_size:
7058 printf (" DW_CFA_GNU_args_size: %d\n", ul);
7062 #ifndef DW_CFA_GNU_negative_offset_extended
7063 #define DW_CFA_GNU_negative_offset_extended 0x2f
7065 case DW_CFA_GNU_negative_offset_extended:
7068 frame_need_space (fc, reg);
7070 printf (" DW_CFA_GNU_negative_offset_extended: r%d = cfa[%d*%d]\n", reg, l, fc->data_factor);
7072 fc->col_type[reg] = DW_CFA_offset;
7073 fc->col_offset[reg] = l * fc->data_factor;
7077 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
7082 frame_display_row (fc, &need_col_headers, &max_regs);
7097 display_debug_not_supported (section, start, file)
7098 Elf32_Internal_Shdr * section;
7099 unsigned char * start ATTRIBUTE_UNUSED;
7100 FILE * file ATTRIBUTE_UNUSED;
7102 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7103 SECTION_NAME (section));
7108 /* Pre-scan the .debug_info section to record the size of address.
7109 When dumping the .debug_line, we use that size information, assuming
7110 that all compilation units have the same address size. */
7112 prescan_debug_info (section, start, file)
7113 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
7114 unsigned char * start;
7115 FILE * file ATTRIBUTE_UNUSED;
7117 DWARF2_External_CompUnit * external;
7119 external = (DWARF2_External_CompUnit *) start;
7121 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
7125 /* A structure containing the name of a debug section and a pointer
7126 to a function that can decode it. The third field is a prescan
7127 function to be run over the section before displaying any of the
7132 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7133 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7137 { ".debug_info", display_debug_info, prescan_debug_info },
7138 { ".debug_abbrev", display_debug_abbrev, NULL },
7139 { ".debug_line", display_debug_lines, NULL },
7140 { ".debug_aranges", display_debug_aranges, NULL },
7141 { ".debug_pubnames", display_debug_pubnames, NULL },
7142 { ".debug_frame", display_debug_frames, NULL },
7143 { ".eh_frame", display_debug_frames, NULL },
7144 { ".debug_macinfo", display_debug_not_supported, NULL },
7145 { ".debug_frame", display_debug_not_supported, NULL },
7146 { ".debug_str", display_debug_not_supported, NULL },
7147 { ".debug_static_func", display_debug_not_supported, NULL },
7148 { ".debug_static_vars", display_debug_not_supported, NULL },
7149 { ".debug_types", display_debug_not_supported, NULL },
7150 { ".debug_weaknames", display_debug_not_supported, NULL }
7154 display_debug_section (section, file)
7155 Elf32_Internal_Shdr * section;
7158 char * name = SECTION_NAME (section);
7159 bfd_size_type length;
7160 unsigned char * start;
7163 length = section->sh_size;
7166 printf (_("\nSection '%s' has no debugging data.\n"), name);
7170 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7171 "debug section data");
7173 /* See if we know how to display the contents of this section. */
7174 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
7175 name = ".debug_info";
7177 for (i = NUM_ELEM (debug_displays); i--;)
7178 if (strcmp (debug_displays[i].name, name) == 0)
7180 debug_displays[i].display (section, start, file);
7185 printf (_("Unrecognised debug section: %s\n"), name);
7189 /* If we loaded in the abbrev section at some point,
7190 we must release it here. */
7191 if (first_abbrev != NULL)
7198 process_section_contents (file)
7201 Elf32_Internal_Shdr * section;
7207 /* Pre-scan the debug sections to find some debug information not
7208 present in some of them. For the .debug_line, we must find out the
7209 size of address (specified in .debug_info and .debug_aranges). */
7210 for (i = 0, section = section_headers;
7211 i < elf_header.e_shnum && i < num_dump_sects;
7214 char * name = SECTION_NAME (section);
7217 if (section->sh_size == 0)
7220 /* See if there is some pre-scan operation for this section. */
7221 for (j = NUM_ELEM (debug_displays); j--;)
7222 if (strcmp (debug_displays[j].name, name) == 0)
7224 if (debug_displays[j].prescan != NULL)
7226 bfd_size_type length;
7227 unsigned char * start;
7229 length = section->sh_size;
7230 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7231 "debug section data");
7233 debug_displays[j].prescan (section, start, file);
7241 for (i = 0, section = section_headers;
7242 i < elf_header.e_shnum && i < num_dump_sects;
7245 #ifdef SUPPORT_DISASSEMBLY
7246 if (dump_sects[i] & DISASS_DUMP)
7247 disassemble_section (section, file);
7249 if (dump_sects[i] & HEX_DUMP)
7250 dump_section (section, file);
7252 if (dump_sects[i] & DEBUG_DUMP)
7253 display_debug_section (section, file);
7256 if (i < num_dump_sects)
7257 warn (_("Some sections were not dumped because they do not exist!\n"));
7263 process_mips_fpe_exception (mask)
7269 if (mask & OEX_FPU_INEX)
7270 fputs ("INEX", stdout), first = 0;
7271 if (mask & OEX_FPU_UFLO)
7272 printf ("%sUFLO", first ? "" : "|"), first = 0;
7273 if (mask & OEX_FPU_OFLO)
7274 printf ("%sOFLO", first ? "" : "|"), first = 0;
7275 if (mask & OEX_FPU_DIV0)
7276 printf ("%sDIV0", first ? "" : "|"), first = 0;
7277 if (mask & OEX_FPU_INVAL)
7278 printf ("%sINVAL", first ? "" : "|");
7281 fputs ("0", stdout);
7285 process_mips_specific (file)
7288 Elf_Internal_Dyn * entry;
7289 size_t liblist_offset = 0;
7290 size_t liblistno = 0;
7291 size_t conflictsno = 0;
7292 size_t options_offset = 0;
7293 size_t conflicts_offset = 0;
7295 /* We have a lot of special sections. Thanks SGI! */
7296 if (dynamic_segment == NULL)
7297 /* No information available. */
7300 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
7301 switch (entry->d_tag)
7303 case DT_MIPS_LIBLIST:
7304 liblist_offset = entry->d_un.d_val - loadaddr;
7306 case DT_MIPS_LIBLISTNO:
7307 liblistno = entry->d_un.d_val;
7309 case DT_MIPS_OPTIONS:
7310 options_offset = entry->d_un.d_val - loadaddr;
7312 case DT_MIPS_CONFLICT:
7313 conflicts_offset = entry->d_un.d_val - loadaddr;
7315 case DT_MIPS_CONFLICTNO:
7316 conflictsno = entry->d_un.d_val;
7322 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
7324 Elf32_External_Lib * elib;
7327 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
7328 elib, Elf32_External_Lib *, "liblist");
7330 printf ("\nSection '.liblist' contains %lu entries:\n",
7331 (unsigned long) liblistno);
7332 fputs (" Library Time Stamp Checksum Version Flags\n",
7335 for (cnt = 0; cnt < liblistno; ++cnt)
7342 liblist.l_name = BYTE_GET (elib[cnt].l_name);
7343 time = BYTE_GET (elib[cnt].l_time_stamp);
7344 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
7345 liblist.l_version = BYTE_GET (elib[cnt].l_version);
7346 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
7348 tmp = gmtime (&time);
7349 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
7350 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7351 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7353 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
7354 dynamic_strings + liblist.l_name, timebuf,
7355 liblist.l_checksum, liblist.l_version);
7357 if (liblist.l_flags == 0)
7368 { " EXACT_MATCH", LL_EXACT_MATCH },
7369 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
7370 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
7371 { " EXPORTS", LL_EXPORTS },
7372 { " DELAY_LOAD", LL_DELAY_LOAD },
7373 { " DELTA", LL_DELTA }
7375 int flags = liblist.l_flags;
7379 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
7381 if ((flags & l_flags_vals[fcnt].bit) != 0)
7383 fputs (l_flags_vals[fcnt].name, stdout);
7384 flags ^= l_flags_vals[fcnt].bit;
7387 printf (" %#x", (unsigned int) flags);
7396 if (options_offset != 0)
7398 Elf_External_Options * eopt;
7399 Elf_Internal_Shdr * sect = section_headers;
7400 Elf_Internal_Options * iopt;
7401 Elf_Internal_Options * option;
7405 /* Find the section header so that we get the size. */
7406 while (sect->sh_type != SHT_MIPS_OPTIONS)
7409 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
7410 Elf_External_Options *, "options");
7412 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
7416 error (_("Out of memory"));
7423 while (offset < sect->sh_size)
7425 Elf_External_Options * eoption;
7427 eoption = (Elf_External_Options *) ((char *) eopt + offset);
7429 option->kind = BYTE_GET (eoption->kind);
7430 option->size = BYTE_GET (eoption->size);
7431 option->section = BYTE_GET (eoption->section);
7432 option->info = BYTE_GET (eoption->info);
7434 offset += option->size;
7440 printf (_("\nSection '%s' contains %d entries:\n"),
7441 string_table + sect->sh_name, cnt);
7449 switch (option->kind)
7452 /* This shouldn't happen. */
7453 printf (" NULL %d %lx", option->section, option->info);
7456 printf (" REGINFO ");
7457 if (elf_header.e_machine == EM_MIPS)
7460 Elf32_External_RegInfo * ereg;
7461 Elf32_RegInfo reginfo;
7463 ereg = (Elf32_External_RegInfo *) (option + 1);
7464 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7465 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7466 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7467 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7468 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7469 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
7471 printf ("GPR %08lx GP 0x%lx\n",
7473 (unsigned long) reginfo.ri_gp_value);
7474 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7475 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7476 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7481 Elf64_External_RegInfo * ereg;
7482 Elf64_Internal_RegInfo reginfo;
7484 ereg = (Elf64_External_RegInfo *) (option + 1);
7485 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7486 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7487 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7488 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7489 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7490 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
7492 printf ("GPR %08lx GP 0x",
7493 reginfo.ri_gprmask);
7494 printf_vma (reginfo.ri_gp_value);
7497 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7498 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7499 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7503 case ODK_EXCEPTIONS:
7504 fputs (" EXCEPTIONS fpe_min(", stdout);
7505 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
7506 fputs (") fpe_max(", stdout);
7507 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
7508 fputs (")", stdout);
7510 if (option->info & OEX_PAGE0)
7511 fputs (" PAGE0", stdout);
7512 if (option->info & OEX_SMM)
7513 fputs (" SMM", stdout);
7514 if (option->info & OEX_FPDBUG)
7515 fputs (" FPDBUG", stdout);
7516 if (option->info & OEX_DISMISS)
7517 fputs (" DISMISS", stdout);
7520 fputs (" PAD ", stdout);
7521 if (option->info & OPAD_PREFIX)
7522 fputs (" PREFIX", stdout);
7523 if (option->info & OPAD_POSTFIX)
7524 fputs (" POSTFIX", stdout);
7525 if (option->info & OPAD_SYMBOL)
7526 fputs (" SYMBOL", stdout);
7529 fputs (" HWPATCH ", stdout);
7530 if (option->info & OHW_R4KEOP)
7531 fputs (" R4KEOP", stdout);
7532 if (option->info & OHW_R8KPFETCH)
7533 fputs (" R8KPFETCH", stdout);
7534 if (option->info & OHW_R5KEOP)
7535 fputs (" R5KEOP", stdout);
7536 if (option->info & OHW_R5KCVTL)
7537 fputs (" R5KCVTL", stdout);
7540 fputs (" FILL ", stdout);
7541 /* XXX Print content of info word? */
7544 fputs (" TAGS ", stdout);
7545 /* XXX Print content of info word? */
7548 fputs (" HWAND ", stdout);
7549 if (option->info & OHWA0_R4KEOP_CHECKED)
7550 fputs (" R4KEOP_CHECKED", stdout);
7551 if (option->info & OHWA0_R4KEOP_CLEAN)
7552 fputs (" R4KEOP_CLEAN", stdout);
7555 fputs (" HWOR ", stdout);
7556 if (option->info & OHWA0_R4KEOP_CHECKED)
7557 fputs (" R4KEOP_CHECKED", stdout);
7558 if (option->info & OHWA0_R4KEOP_CLEAN)
7559 fputs (" R4KEOP_CLEAN", stdout);
7562 printf (" GP_GROUP %#06lx self-contained %#06lx",
7563 option->info & OGP_GROUP,
7564 (option->info & OGP_SELF) >> 16);
7567 printf (" IDENT %#06lx self-contained %#06lx",
7568 option->info & OGP_GROUP,
7569 (option->info & OGP_SELF) >> 16);
7572 /* This shouldn't happen. */
7573 printf (" %3d ??? %d %lx",
7574 option->kind, option->section, option->info);
7578 len = sizeof (* eopt);
7579 while (len < option->size)
7580 if (((char *) option)[len] >= ' '
7581 && ((char *) option)[len] < 0x7f)
7582 printf ("%c", ((char *) option)[len++]);
7584 printf ("\\%03o", ((char *) option)[len++]);
7586 fputs ("\n", stdout);
7593 if (conflicts_offset != 0 && conflictsno != 0)
7595 Elf32_External_Conflict * econf32;
7596 Elf64_External_Conflict * econf64;
7597 Elf32_Conflict * iconf;
7600 if (dynamic_symbols == NULL)
7602 error (_("conflict list with without table"));
7606 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
7609 error (_("Out of memory"));
7615 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf32),
7616 econf32, Elf32_External_Conflict *, "conflict");
7618 for (cnt = 0; cnt < conflictsno; ++cnt)
7619 iconf[cnt] = BYTE_GET (econf32[cnt]);
7623 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf64),
7624 econf64, Elf64_External_Conflict *, "conflict");
7626 for (cnt = 0; cnt < conflictsno; ++cnt)
7627 iconf[cnt] = BYTE_GET (econf64[cnt]);
7630 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
7631 puts (_(" Num: Index Value Name"));
7633 for (cnt = 0; cnt < conflictsno; ++cnt)
7635 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
7637 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
7638 print_vma (psym->st_value, FULL_HEX);
7639 printf (" %s\n", dynamic_strings + psym->st_name);
7649 get_note_type (e_type)
7652 static char buff[64];
7656 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
7657 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
7658 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
7659 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
7660 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
7661 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
7662 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
7663 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
7664 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
7665 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7666 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7668 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
7673 /* Note that by the ELF standard, the name field is already null byte
7674 terminated, and namesz includes the terminating null byte.
7675 I.E. the value of namesz for the name "FSF" is 4.
7677 If the value of namesz is zero, there is no name present. */
7679 process_note (pnote)
7680 Elf32_Internal_Note * pnote;
7682 printf (" %s\t\t0x%08lx\t%s\n",
7683 pnote->namesz ? pnote->namedata : "(NONE)",
7684 pnote->descsz, get_note_type (pnote->type));
7690 process_corefile_note_segment (file, offset, length)
7695 Elf_External_Note * pnotes;
7696 Elf_External_Note * external;
7702 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
7706 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7707 (unsigned long) offset, (unsigned long) length);
7708 printf (_(" Owner\t\tData size\tDescription\n"));
7710 while (external < (Elf_External_Note *)((char *) pnotes + length))
7712 Elf32_Internal_Note inote;
7715 inote.type = BYTE_GET (external->type);
7716 inote.namesz = BYTE_GET (external->namesz);
7717 inote.namedata = external->name;
7718 inote.descsz = BYTE_GET (external->descsz);
7719 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
7720 inote.descpos = offset + (inote.descdata - (char *) pnotes);
7722 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7724 /* Verify that name is null terminated. It appears that at least
7725 one version of Linux (RedHat 6.0) generates corefiles that don't
7726 comply with the ELF spec by failing to include the null byte in
7728 if (inote.namedata[inote.namesz] != '\0')
7730 temp = malloc (inote.namesz + 1);
7734 error (_("Out of memory\n"));
7739 strncpy (temp, inote.namedata, inote.namesz);
7740 temp[inote.namesz] = 0;
7742 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7743 inote.namedata = temp;
7746 res &= process_note (& inote);
7761 process_corefile_note_segments (file)
7764 Elf_Internal_Phdr * program_headers;
7765 Elf_Internal_Phdr * segment;
7769 program_headers = (Elf_Internal_Phdr *) malloc
7770 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7772 if (program_headers == NULL)
7774 error (_("Out of memory\n"));
7779 i = get_32bit_program_headers (file, program_headers);
7781 i = get_64bit_program_headers (file, program_headers);
7785 free (program_headers);
7789 for (i = 0, segment = program_headers;
7790 i < elf_header.e_phnum;
7793 if (segment->p_type == PT_NOTE)
7794 res &= process_corefile_note_segment (file,
7795 (bfd_vma) segment->p_offset,
7796 (bfd_vma) segment->p_filesz);
7799 free (program_headers);
7805 process_corefile_contents (file)
7808 /* If we have not been asked to display the notes then do nothing. */
7812 /* If file is not a core file then exit. */
7813 if (elf_header.e_type != ET_CORE)
7816 /* No program headers means no NOTE segment. */
7817 if (elf_header.e_phnum == 0)
7819 printf (_("No note segments present in the core file.\n"));
7823 return process_corefile_note_segments (file);
7827 process_arch_specific (file)
7833 switch (elf_header.e_machine)
7836 case EM_MIPS_RS4_BE:
7837 return process_mips_specific (file);
7846 get_file_header (file)
7849 /* Read in the identity array. */
7850 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7853 /* Determine how to read the rest of the header. */
7854 switch (elf_header.e_ident [EI_DATA])
7856 default: /* fall through */
7857 case ELFDATANONE: /* fall through */
7858 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7859 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7862 /* For now we only support 32 bit and 64 bit ELF files. */
7863 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7865 /* Read in the rest of the header. */
7868 Elf32_External_Ehdr ehdr32;
7870 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7873 elf_header.e_type = BYTE_GET (ehdr32.e_type);
7874 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
7875 elf_header.e_version = BYTE_GET (ehdr32.e_version);
7876 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7877 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7878 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7879 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7880 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7881 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7882 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7883 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7884 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7885 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7889 Elf64_External_Ehdr ehdr64;
7891 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7892 we will not be able to cope with the 64bit data found in
7893 64 ELF files. Detect this now and abort before we start
7894 overwritting things. */
7895 if (sizeof (bfd_vma) < 8)
7897 error (_("This instance of readelf has been built without support for a\n"));
7898 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7902 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7905 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7906 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7907 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7908 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7909 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7910 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7911 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7912 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7913 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7914 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7915 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7916 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7917 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7924 process_file (file_name)
7928 struct stat statbuf;
7931 if (stat (file_name, & statbuf) < 0)
7933 error (_("Cannot stat input file %s.\n"), file_name);
7937 file = fopen (file_name, "rb");
7940 error (_("Input file %s not found.\n"), file_name);
7944 if (! get_file_header (file))
7946 error (_("%s: Failed to read file header\n"), file_name);
7951 /* Initialise per file variables. */
7952 for (i = NUM_ELEM (version_info); i--;)
7953 version_info[i] = 0;
7955 for (i = NUM_ELEM (dynamic_info); i--;)
7956 dynamic_info[i] = 0;
7958 /* Process the file. */
7960 printf (_("\nFile: %s\n"), file_name);
7962 if (! process_file_header ())
7968 process_section_headers (file);
7970 process_program_headers (file);
7972 process_dynamic_segment (file);
7974 process_relocs (file);
7976 process_symbol_table (file);
7978 process_syminfo (file);
7980 process_version_sections (file);
7982 process_section_contents (file);
7984 process_corefile_contents (file);
7986 process_arch_specific (file);
7990 if (section_headers)
7992 free (section_headers);
7993 section_headers = NULL;
7998 free (string_table);
7999 string_table = NULL;
8002 if (dynamic_strings)
8004 free (dynamic_strings);
8005 dynamic_strings = NULL;
8008 if (dynamic_symbols)
8010 free (dynamic_symbols);
8011 dynamic_symbols = NULL;
8012 num_dynamic_syms = 0;
8015 if (dynamic_syminfo)
8017 free (dynamic_syminfo);
8018 dynamic_syminfo = NULL;
8022 #ifdef SUPPORT_DISASSEMBLY
8023 /* Needed by the i386 disassembler. For extra credit, someone could
8024 fix this so that we insert symbolic addresses here, esp for GOT/PLT
8028 print_address (unsigned int addr, FILE * outfile)
8030 fprintf (outfile,"0x%8.8x", addr);
8033 /* Needed by the i386 disassembler. */
8035 db_task_printsym (unsigned int addr)
8037 print_address (addr, stderr);
8046 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
8047 setlocale (LC_MESSAGES, "");
8049 bindtextdomain (PACKAGE, LOCALEDIR);
8050 textdomain (PACKAGE);
8052 parse_args (argc, argv);
8054 if (optind < (argc - 1))
8057 while (optind < argc)
8058 process_file (argv [optind ++]);
8060 if (dump_sects != NULL)