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);
875 rtype = elf_arc_reloc_type (type);
879 rtype = elf_hppa_reloc_type (type);
883 rtype = elf_pj_reloc_type (type);
886 rtype = elf_ia64_reloc_type (type);
890 rtype = elf_cris_reloc_type (type);
894 rtype = elf_i860_reloc_type (type);
899 #ifdef _bfd_int64_low
900 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
902 printf (_("unrecognised: %-7lx"), type);
905 printf ("%-21.21s", rtype);
911 if (symtab_index >= nsyms)
912 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
915 Elf_Internal_Sym * psym;
917 psym = symtab + symtab_index;
920 print_vma (psym->st_value, LONG_HEX);
923 if (psym->st_name == 0)
925 SECTION_NAME (section_headers + psym->st_shndx));
926 else if (strtab == NULL)
927 printf (_("<string table index %3ld>"), psym->st_name);
929 printf ("%-25.25s", strtab + psym->st_name);
932 printf (" + %lx", (unsigned long) relas [i].r_addend);
938 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
939 print_vma (relas[i].r_addend, LONG_HEX);
942 if (elf_header.e_machine == EM_SPARCV9
943 && !strcmp (rtype, "R_SPARC_OLO10"))
944 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
955 get_mips_dynamic_type (type)
960 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
961 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
962 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
963 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
964 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
965 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
966 case DT_MIPS_MSYM: return "MIPS_MSYM";
967 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
968 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
969 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
970 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
971 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
972 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
973 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
974 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
975 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
976 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
977 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
978 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
979 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
980 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
981 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
982 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
983 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
984 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
985 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
986 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
987 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
988 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
989 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
990 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
991 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
992 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
993 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
994 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
995 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
996 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
997 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
998 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
999 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1000 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1001 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1002 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1009 get_sparc64_dynamic_type (type)
1014 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1021 get_parisc_dynamic_type (type)
1026 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1027 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1028 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1029 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1030 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1031 case DT_HP_PREINIT: return "HP_PREINIT";
1032 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1033 case DT_HP_NEEDED: return "HP_NEEDED";
1034 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1035 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1036 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1037 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1038 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1045 get_dynamic_type (type)
1048 static char buff [32];
1052 case DT_NULL: return "NULL";
1053 case DT_NEEDED: return "NEEDED";
1054 case DT_PLTRELSZ: return "PLTRELSZ";
1055 case DT_PLTGOT: return "PLTGOT";
1056 case DT_HASH: return "HASH";
1057 case DT_STRTAB: return "STRTAB";
1058 case DT_SYMTAB: return "SYMTAB";
1059 case DT_RELA: return "RELA";
1060 case DT_RELASZ: return "RELASZ";
1061 case DT_RELAENT: return "RELAENT";
1062 case DT_STRSZ: return "STRSZ";
1063 case DT_SYMENT: return "SYMENT";
1064 case DT_INIT: return "INIT";
1065 case DT_FINI: return "FINI";
1066 case DT_SONAME: return "SONAME";
1067 case DT_RPATH: return "RPATH";
1068 case DT_SYMBOLIC: return "SYMBOLIC";
1069 case DT_REL: return "REL";
1070 case DT_RELSZ: return "RELSZ";
1071 case DT_RELENT: return "RELENT";
1072 case DT_PLTREL: return "PLTREL";
1073 case DT_DEBUG: return "DEBUG";
1074 case DT_TEXTREL: return "TEXTREL";
1075 case DT_JMPREL: return "JMPREL";
1076 case DT_BIND_NOW: return "BIND_NOW";
1077 case DT_INIT_ARRAY: return "INIT_ARRAY";
1078 case DT_FINI_ARRAY: return "FINI_ARRAY";
1079 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1080 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1081 case DT_RUNPATH: return "RUNPATH";
1082 case DT_FLAGS: return "FLAGS";
1084 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1085 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1087 case DT_CHECKSUM: return "CHECKSUM";
1088 case DT_PLTPADSZ: return "PLTPADSZ";
1089 case DT_MOVEENT: return "MOVEENT";
1090 case DT_MOVESZ: return "MOVESZ";
1091 case DT_FEATURE: return "FEATURE";
1092 case DT_POSFLAG_1: return "POSFLAG_1";
1093 case DT_SYMINSZ: return "SYMINSZ";
1094 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1096 case DT_ADDRRNGLO: return "ADDRRNGLO";
1097 case DT_CONFIG: return "CONFIG";
1098 case DT_DEPAUDIT: return "DEPAUDIT";
1099 case DT_AUDIT: return "AUDIT";
1100 case DT_PLTPAD: return "PLTPAD";
1101 case DT_MOVETAB: return "MOVETAB";
1102 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1104 case DT_VERSYM: return "VERSYM";
1106 case DT_RELACOUNT: return "RELACOUNT";
1107 case DT_RELCOUNT: return "RELCOUNT";
1108 case DT_FLAGS_1: return "FLAGS_1";
1109 case DT_VERDEF: return "VERDEF";
1110 case DT_VERDEFNUM: return "VERDEFNUM";
1111 case DT_VERNEED: return "VERNEED";
1112 case DT_VERNEEDNUM: return "VERNEEDNUM";
1114 case DT_AUXILIARY: return "AUXILIARY";
1115 case DT_USED: return "USED";
1116 case DT_FILTER: return "FILTER";
1119 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1121 const char * result;
1123 switch (elf_header.e_machine)
1126 case EM_MIPS_RS4_BE:
1127 result = get_mips_dynamic_type (type);
1130 result = get_sparc64_dynamic_type (type);
1140 sprintf (buff, _("Processor Specific: %lx"), type);
1142 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1144 const char * result;
1146 switch (elf_header.e_machine)
1149 result = get_parisc_dynamic_type (type);
1159 sprintf (buff, _("Operating System specific: %lx"), type);
1162 sprintf (buff, _("<unknown>: %lx"), type);
1169 get_file_type (e_type)
1172 static char buff [32];
1176 case ET_NONE: return _("NONE (None)");
1177 case ET_REL: return _("REL (Relocatable file)");
1178 case ET_EXEC: return _("EXEC (Executable file)");
1179 case ET_DYN: return _("DYN (Shared object file)");
1180 case ET_CORE: return _("CORE (Core file)");
1183 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1184 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1185 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1186 sprintf (buff, _("OS Specific: (%x)"), e_type);
1188 sprintf (buff, _("<unknown>: %x"), e_type);
1194 get_machine_name (e_machine)
1197 static char buff [64]; /* XXX */
1201 case EM_NONE: return _("None");
1202 case EM_M32: return "WE32100";
1203 case EM_SPARC: return "Sparc";
1204 case EM_386: return "Intel 80386";
1205 case EM_68K: return "MC68000";
1206 case EM_88K: return "MC88000";
1207 case EM_486: return "Intel 80486";
1208 case EM_860: return "Intel 80860";
1209 case EM_MIPS: return "MIPS R3000";
1210 case EM_S370: return "IBM System/370";
1211 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1212 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1213 case EM_PARISC: return "HPPA";
1214 case EM_PPC_OLD: return "Power PC (old)";
1215 case EM_SPARC32PLUS: return "Sparc v8+" ;
1216 case EM_960: return "Intel 90860";
1217 case EM_PPC: return "PowerPC";
1218 case EM_V800: return "NEC V800";
1219 case EM_FR20: return "Fujitsu FR20";
1220 case EM_RH32: return "TRW RH32";
1221 case EM_MCORE: return "MCORE";
1222 case EM_ARM: return "ARM";
1223 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1224 case EM_SH: return "Hitachi SH";
1225 case EM_SPARCV9: return "Sparc v9";
1226 case EM_TRICORE: return "Siemens Tricore";
1227 case EM_ARC: return "Argonaut RISC Core";
1228 case EM_H8_300: return "Hitachi H8/300";
1229 case EM_H8_300H: return "Hitachi H8/300H";
1230 case EM_H8S: return "Hitachi H8S";
1231 case EM_H8_500: return "Hitachi H8/500";
1232 case EM_IA_64: return "Intel IA-64";
1233 case EM_MIPS_X: return "Stanford MIPS-X";
1234 case EM_COLDFIRE: return "Motorola Coldfire";
1235 case EM_68HC12: return "Motorola M68HC12";
1236 case EM_ALPHA: return "Alpha";
1237 case EM_CYGNUS_D10V: return "d10v";
1238 case EM_CYGNUS_D30V: return "d30v";
1239 case EM_CYGNUS_ARC: return "Arc";
1240 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1241 case EM_CYGNUS_V850: return "NEC v850";
1242 case EM_CYGNUS_MN10300: return "mn10300";
1243 case EM_CYGNUS_MN10200: return "mn10200";
1244 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1245 case EM_PJ: return "picoJava";
1246 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1247 case EM_PCP: return "Siemens PCP";
1248 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1249 case EM_NDR1: return "Denso NDR1 microprocesspr";
1250 case EM_STARCORE: return "Motorola Star*Core processor";
1251 case EM_ME16: return "Toyota ME16 processor";
1252 case EM_ST100: return "STMicroelectronics ST100 processor";
1253 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1254 case EM_FX66: return "Siemens FX66 microcontroller";
1255 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1256 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1257 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1258 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1259 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1260 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1261 case EM_SVX: return "Silicon Graphics SVx";
1262 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1263 case EM_VAX: return "Digital VAX";
1264 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1265 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1266 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1267 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1268 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1269 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1270 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1271 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 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
2769 request_dump (i, DEBUG_DUMP);
2775 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2779 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2782 printf (_(" [Nr] Name Type Address Offset\n"));
2783 printf (_(" Size EntSize Flags Link Info Align\n"));
2786 for (i = 0, section = section_headers;
2787 i < elf_header.e_shnum;
2790 printf (" [%2d] %-17.17s %-15.15s ",
2792 SECTION_NAME (section),
2793 get_section_type_name (section->sh_type));
2797 print_vma (section->sh_addr, LONG_HEX);
2799 printf ( " %6.6lx %6.6lx %2.2lx",
2800 (unsigned long) section->sh_offset,
2801 (unsigned long) section->sh_size,
2802 (unsigned long) section->sh_entsize);
2804 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2806 printf ("%2ld %3lx %2ld\n",
2807 (unsigned long) section->sh_link,
2808 (unsigned long) section->sh_info,
2809 (unsigned long) section->sh_addralign);
2814 print_vma (section->sh_addr, LONG_HEX);
2815 printf (" %8.8lx", section->sh_offset);
2817 print_vma (section->sh_size, LONG_HEX);
2819 print_vma (section->sh_entsize, LONG_HEX);
2821 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2823 printf (" %2ld %3lx %ld\n",
2824 (unsigned long) section->sh_link,
2825 (unsigned long) section->sh_info,
2826 (unsigned long) section->sh_addralign);
2830 printf (_("Key to Flags:\n"));
2831 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2832 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
2833 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
2838 /* Process the reloc section. */
2840 process_relocs (file)
2843 unsigned long rel_size;
2844 unsigned long rel_offset;
2850 if (do_using_dynamic)
2852 int is_rela = FALSE;
2857 if (dynamic_info[DT_REL])
2859 rel_offset = dynamic_info[DT_REL];
2860 rel_size = dynamic_info[DT_RELSZ];
2863 else if (dynamic_info [DT_RELA])
2865 rel_offset = dynamic_info[DT_RELA];
2866 rel_size = dynamic_info[DT_RELASZ];
2869 else if (dynamic_info[DT_JMPREL])
2871 rel_offset = dynamic_info[DT_JMPREL];
2872 rel_size = dynamic_info[DT_PLTRELSZ];
2874 switch (dynamic_info[DT_PLTREL])
2891 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2892 rel_offset, rel_size);
2894 dump_relocations (file, rel_offset - loadaddr, rel_size,
2895 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
2898 printf (_("\nThere are no dynamic relocations in this file.\n"));
2902 Elf32_Internal_Shdr * section;
2906 for (i = 0, section = section_headers;
2907 i < elf_header.e_shnum;
2910 if ( section->sh_type != SHT_RELA
2911 && section->sh_type != SHT_REL)
2914 rel_offset = section->sh_offset;
2915 rel_size = section->sh_size;
2919 Elf32_Internal_Shdr * strsec;
2920 Elf32_Internal_Shdr * symsec;
2921 Elf_Internal_Sym * symtab;
2924 unsigned long nsyms;
2926 printf (_("\nRelocation section "));
2928 if (string_table == NULL)
2929 printf ("%d", section->sh_name);
2931 printf ("'%s'", SECTION_NAME (section));
2933 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2934 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
2936 symsec = section_headers + section->sh_link;
2938 nsyms = symsec->sh_size / symsec->sh_entsize;
2939 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
2944 strsec = section_headers + symsec->sh_link;
2946 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
2947 char *, "string table");
2949 is_rela = section->sh_type == SHT_RELA;
2951 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
2961 printf (_("\nThere are no relocations in this file.\n"));
2969 dynamic_segment_mips_val (entry)
2970 Elf_Internal_Dyn * entry;
2972 switch (entry->d_tag)
2975 if (entry->d_un.d_val == 0)
2979 static const char * opts[] =
2981 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2982 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2983 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2984 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2989 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
2990 if (entry->d_un.d_val & (1 << cnt))
2992 printf ("%s%s", first ? "" : " ", opts[cnt]);
2999 case DT_MIPS_IVERSION:
3000 if (dynamic_strings != NULL)
3001 printf ("Interface Version: %s\n",
3002 dynamic_strings + entry->d_un.d_val);
3004 printf ("%ld\n", (long) entry->d_un.d_ptr);
3007 case DT_MIPS_TIME_STAMP:
3012 time_t time = entry->d_un.d_val;
3013 tmp = gmtime (&time);
3014 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3015 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3016 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3017 printf ("Time Stamp: %s\n", timebuf);
3021 case DT_MIPS_RLD_VERSION:
3022 case DT_MIPS_LOCAL_GOTNO:
3023 case DT_MIPS_CONFLICTNO:
3024 case DT_MIPS_LIBLISTNO:
3025 case DT_MIPS_SYMTABNO:
3026 case DT_MIPS_UNREFEXTNO:
3027 case DT_MIPS_HIPAGENO:
3028 case DT_MIPS_DELTA_CLASS_NO:
3029 case DT_MIPS_DELTA_INSTANCE_NO:
3030 case DT_MIPS_DELTA_RELOC_NO:
3031 case DT_MIPS_DELTA_SYM_NO:
3032 case DT_MIPS_DELTA_CLASSSYM_NO:
3033 case DT_MIPS_COMPACT_SIZE:
3034 printf ("%ld\n", (long) entry->d_un.d_ptr);
3038 printf ("%#lx\n", (long) entry->d_un.d_ptr);
3044 dynamic_segment_parisc_val (entry)
3045 Elf_Internal_Dyn * entry;
3047 switch (entry->d_tag)
3049 case DT_HP_DLD_FLAGS:
3058 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3059 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3060 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3061 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3062 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3063 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3064 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3065 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3066 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3067 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3068 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3072 bfd_vma val = entry->d_un.d_val;
3074 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3075 if (val & flags[cnt].bit)
3079 fputs (flags[cnt].str, stdout);
3081 val ^= flags[cnt].bit;
3084 if (val != 0 || first)
3088 print_vma (val, HEX);
3094 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3100 get_32bit_dynamic_segment (file)
3103 Elf32_External_Dyn * edyn;
3104 Elf_Internal_Dyn * entry;
3107 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3108 edyn, Elf32_External_Dyn *, "dynamic segment");
3110 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3111 how large this .dynamic is now. We can do this even before the byte
3112 swapping since the DT_NULL tag is recognizable. */
3114 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3117 dynamic_segment = (Elf_Internal_Dyn *)
3118 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3120 if (dynamic_segment == NULL)
3122 error (_("Out of memory\n"));
3127 for (i = 0, entry = dynamic_segment;
3131 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3132 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3141 get_64bit_dynamic_segment (file)
3144 Elf64_External_Dyn * edyn;
3145 Elf_Internal_Dyn * entry;
3148 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3149 edyn, Elf64_External_Dyn *, "dynamic segment");
3151 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3152 how large this .dynamic is now. We can do this even before the byte
3153 swapping since the DT_NULL tag is recognizable. */
3155 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3158 dynamic_segment = (Elf_Internal_Dyn *)
3159 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3161 if (dynamic_segment == NULL)
3163 error (_("Out of memory\n"));
3168 for (i = 0, entry = dynamic_segment;
3172 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3173 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3182 get_dynamic_flags (flags)
3185 static char buff [64];
3190 flag = flags & - flags;
3195 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3196 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3197 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3198 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3199 default: strcat (buff, "unknown "); break;
3205 /* Parse and display the contents of the dynamic segment. */
3207 process_dynamic_segment (file)
3210 Elf_Internal_Dyn * entry;
3213 if (dynamic_size == 0)
3216 printf (_("\nThere is no dynamic segment in this file.\n"));
3223 if (! get_32bit_dynamic_segment (file))
3226 else if (! get_64bit_dynamic_segment (file))
3229 /* Find the appropriate symbol table. */
3230 if (dynamic_symbols == NULL)
3232 for (i = 0, entry = dynamic_segment;
3236 unsigned long offset;
3238 if (entry->d_tag != DT_SYMTAB)
3241 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3243 /* Since we do not know how big the symbol table is,
3244 we default to reading in the entire file (!) and
3245 processing that. This is overkill, I know, but it
3247 offset = entry->d_un.d_val - loadaddr;
3249 if (fseek (file, 0, SEEK_END))
3250 error (_("Unable to seek to end of file!"));
3253 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3255 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3257 if (num_dynamic_syms < 1)
3259 error (_("Unable to determine the number of symbols to load\n"));
3263 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3267 /* Similarly find a string table. */
3268 if (dynamic_strings == NULL)
3270 for (i = 0, entry = dynamic_segment;
3274 unsigned long offset;
3277 if (entry->d_tag != DT_STRTAB)
3280 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3282 /* Since we do not know how big the string table is,
3283 we default to reading in the entire file (!) and
3284 processing that. This is overkill, I know, but it
3287 offset = entry->d_un.d_val - loadaddr;
3288 if (fseek (file, 0, SEEK_END))
3289 error (_("Unable to seek to end of file\n"));
3290 str_tab_len = ftell (file) - offset;
3292 if (str_tab_len < 1)
3295 (_("Unable to determine the length of the dynamic string table\n"));
3299 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3300 "dynamic string table");
3306 /* And find the syminfo section if available. */
3307 if (dynamic_syminfo == NULL)
3309 unsigned int syminsz = 0;
3311 for (i = 0, entry = dynamic_segment;
3315 if (entry->d_tag == DT_SYMINENT)
3317 /* Note: these braces are necessary to avoid a syntax
3318 error from the SunOS4 C compiler. */
3319 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3321 else if (entry->d_tag == DT_SYMINSZ)
3322 syminsz = entry->d_un.d_val;
3323 else if (entry->d_tag == DT_SYMINFO)
3324 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3327 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3329 Elf_External_Syminfo * extsyminfo;
3330 Elf_Internal_Syminfo * syminfo;
3332 /* There is a syminfo section. Read the data. */
3333 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3334 Elf_External_Syminfo *, "symbol information");
3336 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3337 if (dynamic_syminfo == NULL)
3339 error (_("Out of memory\n"));
3343 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3344 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3347 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3348 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3355 if (do_dynamic && dynamic_addr)
3356 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3357 dynamic_addr, (long) dynamic_size);
3359 printf (_(" Tag Type Name/Value\n"));
3361 for (i = 0, entry = dynamic_segment;
3370 print_vma (entry->d_tag, FULL_HEX);
3371 dtype = get_dynamic_type (entry->d_tag);
3372 printf (" (%s)%*s", dtype,
3373 ((is_32bit_elf ? 27 : 19)
3374 - (int) strlen (dtype)),
3378 switch (entry->d_tag)
3382 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3392 switch (entry->d_tag)
3395 printf (_("Auxiliary library"));
3399 printf (_("Filter library"));
3403 printf (_("Configuration file"));
3407 printf (_("Dependency audit library"));
3411 printf (_("Audit library"));
3415 if (dynamic_strings)
3416 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3420 print_vma (entry->d_un.d_val, PREFIX_HEX);
3429 printf (_("Flags:"));
3430 if (entry->d_un.d_val == 0)
3431 printf (_(" None\n"));
3434 unsigned long int val = entry->d_un.d_val;
3435 if (val & DTF_1_PARINIT)
3437 printf (" PARINIT");
3438 val ^= DTF_1_PARINIT;
3440 if (val & DTF_1_CONFEXP)
3442 printf (" CONFEXP");
3443 val ^= DTF_1_CONFEXP;
3446 printf (" %lx", val);
3455 printf (_("Flags:"));
3456 if (entry->d_un.d_val == 0)
3457 printf (_(" None\n"));
3460 unsigned long int val = entry->d_un.d_val;
3461 if (val & DF_P1_LAZYLOAD)
3463 printf (" LAZYLOAD");
3464 val ^= DF_P1_LAZYLOAD;
3466 if (val & DF_P1_GROUPPERM)
3468 printf (" GROUPPERM");
3469 val ^= DF_P1_GROUPPERM;
3472 printf (" %lx", val);
3481 printf (_("Flags:"));
3482 if (entry->d_un.d_val == 0)
3483 printf (_(" None\n"));
3486 unsigned long int val = entry->d_un.d_val;
3492 if (val & DF_1_GLOBAL)
3497 if (val & DF_1_GROUP)
3502 if (val & DF_1_NODELETE)
3504 printf (" NODELETE");
3505 val ^= DF_1_NODELETE;
3507 if (val & DF_1_LOADFLTR)
3509 printf (" LOADFLTR");
3510 val ^= DF_1_LOADFLTR;
3512 if (val & DF_1_INITFIRST)
3514 printf (" INITFIRST");
3515 val ^= DF_1_INITFIRST;
3517 if (val & DF_1_NOOPEN)
3522 if (val & DF_1_ORIGIN)
3527 if (val & DF_1_DIRECT)
3532 if (val & DF_1_TRANS)
3537 if (val & DF_1_INTERPOSE)
3539 printf (" INTERPOSE");
3540 val ^= DF_1_INTERPOSE;
3542 if (val & DF_1_NODEFLIB)
3544 printf (" NODEFLIB");
3545 val ^= DF_1_NODEFLIB;
3547 if (val & DF_1_NODUMP)
3552 if (val & DF_1_CONLFAT)
3554 printf (" CONLFAT");
3555 val ^= DF_1_CONLFAT;
3558 printf (" %lx", val);
3566 puts (get_dynamic_type (entry->d_un.d_val));
3586 dynamic_info[entry->d_tag] = entry->d_un.d_val;
3592 if (dynamic_strings == NULL)
3595 name = dynamic_strings + entry->d_un.d_val;
3599 switch (entry->d_tag)
3602 printf (_("Shared library: [%s]"), name);
3604 if (strcmp (name, program_interpreter) == 0)
3605 printf (_(" program interpreter"));
3609 printf (_("Library soname: [%s]"), name);
3613 printf (_("Library rpath: [%s]"), name);
3617 printf (_("Library runpath: [%s]"), name);
3621 print_vma (entry->d_un.d_val, PREFIX_HEX);
3626 print_vma (entry->d_un.d_val, PREFIX_HEX);
3642 case DT_INIT_ARRAYSZ:
3643 case DT_FINI_ARRAYSZ:
3646 print_vma (entry->d_un.d_val, UNSIGNED);
3647 printf (" (bytes)\n");
3657 print_vma (entry->d_un.d_val, UNSIGNED);
3670 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
3674 name = dynamic_strings + entry->d_un.d_val;
3678 printf (_("Not needed object: [%s]\n"), name);
3683 print_vma (entry->d_un.d_val, PREFIX_HEX);
3689 /* The value of this entry is ignored. */
3693 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
3694 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
3699 switch (elf_header.e_machine)
3702 case EM_MIPS_RS4_BE:
3703 dynamic_segment_mips_val (entry);
3706 dynamic_segment_parisc_val (entry);
3709 print_vma (entry->d_un.d_val, PREFIX_HEX);
3721 get_ver_flags (flags)
3724 static char buff [32];
3731 if (flags & VER_FLG_BASE)
3732 strcat (buff, "BASE ");
3734 if (flags & VER_FLG_WEAK)
3736 if (flags & VER_FLG_BASE)
3737 strcat (buff, "| ");
3739 strcat (buff, "WEAK ");
3742 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
3743 strcat (buff, "| <unknown>");
3748 /* Display the contents of the version sections. */
3750 process_version_sections (file)
3753 Elf32_Internal_Shdr * section;
3760 for (i = 0, section = section_headers;
3761 i < elf_header.e_shnum;
3764 switch (section->sh_type)
3766 case SHT_GNU_verdef:
3768 Elf_External_Verdef * edefs;
3775 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3776 SECTION_NAME (section), section->sh_info);
3778 printf (_(" Addr: 0x"));
3779 printf_vma (section->sh_addr);
3780 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3781 (unsigned long) section->sh_offset, section->sh_link,
3782 SECTION_NAME (section_headers + section->sh_link));
3784 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3785 edefs, Elf_External_Verdef *,
3786 "version definition section");
3788 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
3791 Elf_External_Verdef * edef;
3792 Elf_Internal_Verdef ent;
3793 Elf_External_Verdaux * eaux;
3794 Elf_Internal_Verdaux aux;
3798 vstart = ((char *) edefs) + idx;
3800 edef = (Elf_External_Verdef *) vstart;
3802 ent.vd_version = BYTE_GET (edef->vd_version);
3803 ent.vd_flags = BYTE_GET (edef->vd_flags);
3804 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
3805 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
3806 ent.vd_hash = BYTE_GET (edef->vd_hash);
3807 ent.vd_aux = BYTE_GET (edef->vd_aux);
3808 ent.vd_next = BYTE_GET (edef->vd_next);
3810 printf (_(" %#06x: Rev: %d Flags: %s"),
3811 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
3813 printf (_(" Index: %d Cnt: %d "),
3814 ent.vd_ndx, ent.vd_cnt);
3816 vstart += ent.vd_aux;
3818 eaux = (Elf_External_Verdaux *) vstart;
3820 aux.vda_name = BYTE_GET (eaux->vda_name);
3821 aux.vda_next = BYTE_GET (eaux->vda_next);
3823 if (dynamic_strings)
3824 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
3826 printf (_("Name index: %ld\n"), aux.vda_name);
3828 isum = idx + ent.vd_aux;
3830 for (j = 1; j < ent.vd_cnt; j ++)
3832 isum += aux.vda_next;
3833 vstart += aux.vda_next;
3835 eaux = (Elf_External_Verdaux *) vstart;
3837 aux.vda_name = BYTE_GET (eaux->vda_name);
3838 aux.vda_next = BYTE_GET (eaux->vda_next);
3840 if (dynamic_strings)
3841 printf (_(" %#06x: Parent %d: %s\n"),
3842 isum, j, dynamic_strings + aux.vda_name);
3844 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3845 isum, j, aux.vda_name);
3855 case SHT_GNU_verneed:
3857 Elf_External_Verneed * eneed;
3863 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3864 SECTION_NAME (section), section->sh_info);
3866 printf (_(" Addr: 0x"));
3867 printf_vma (section->sh_addr);
3868 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3869 (unsigned long) section->sh_offset, section->sh_link,
3870 SECTION_NAME (section_headers + section->sh_link));
3872 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
3873 eneed, Elf_External_Verneed *,
3874 "version need section");
3876 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
3878 Elf_External_Verneed * entry;
3879 Elf_Internal_Verneed ent;
3884 vstart = ((char *) eneed) + idx;
3886 entry = (Elf_External_Verneed *) vstart;
3888 ent.vn_version = BYTE_GET (entry->vn_version);
3889 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
3890 ent.vn_file = BYTE_GET (entry->vn_file);
3891 ent.vn_aux = BYTE_GET (entry->vn_aux);
3892 ent.vn_next = BYTE_GET (entry->vn_next);
3894 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
3896 if (dynamic_strings)
3897 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
3899 printf (_(" File: %lx"), ent.vn_file);
3901 printf (_(" Cnt: %d\n"), ent.vn_cnt);
3903 vstart += ent.vn_aux;
3905 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
3907 Elf_External_Vernaux * eaux;
3908 Elf_Internal_Vernaux aux;
3910 eaux = (Elf_External_Vernaux *) vstart;
3912 aux.vna_hash = BYTE_GET (eaux->vna_hash);
3913 aux.vna_flags = BYTE_GET (eaux->vna_flags);
3914 aux.vna_other = BYTE_GET (eaux->vna_other);
3915 aux.vna_name = BYTE_GET (eaux->vna_name);
3916 aux.vna_next = BYTE_GET (eaux->vna_next);
3918 if (dynamic_strings)
3919 printf (_(" %#06x: Name: %s"),
3920 isum, dynamic_strings + aux.vna_name);
3922 printf (_(" %#06x: Name index: %lx"),
3923 isum, aux.vna_name);
3925 printf (_(" Flags: %s Version: %d\n"),
3926 get_ver_flags (aux.vna_flags), aux.vna_other);
3928 isum += aux.vna_next;
3929 vstart += aux.vna_next;
3939 case SHT_GNU_versym:
3941 Elf32_Internal_Shdr * link_section;
3944 unsigned char * edata;
3945 unsigned short * data;
3947 Elf_Internal_Sym * symbols;
3948 Elf32_Internal_Shdr * string_sec;
3950 link_section = section_headers + section->sh_link;
3951 total = section->sh_size / section->sh_entsize;
3955 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
3956 link_section->sh_size / link_section->sh_entsize);
3958 string_sec = section_headers + link_section->sh_link;
3960 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
3961 strtab, char *, "version string table");
3963 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3964 SECTION_NAME (section), total);
3966 printf (_(" Addr: "));
3967 printf_vma (section->sh_addr);
3968 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3969 (unsigned long) section->sh_offset, section->sh_link,
3970 SECTION_NAME (link_section));
3972 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
3974 total * sizeof (short), edata,
3975 unsigned char *, "version symbol data");
3977 data = (unsigned short *) malloc (total * sizeof (short));
3979 for (cnt = total; cnt --;)
3980 data [cnt] = byte_get (edata + cnt * sizeof (short),
3985 for (cnt = 0; cnt < total; cnt += 4)
3990 printf (" %03x:", cnt);
3992 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
3993 switch (data [cnt + j])
3996 fputs (_(" 0 (*local*) "), stdout);
4000 fputs (_(" 1 (*global*) "), stdout);
4004 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4005 data [cnt + j] & 0x8000 ? 'h' : ' ');
4007 if (symbols [cnt + j].st_shndx < SHN_LORESERVE
4008 && section_headers[symbols [cnt + j].st_shndx].sh_type
4011 /* We must test both. */
4012 Elf_Internal_Verneed ivn;
4013 unsigned long offset;
4015 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4020 Elf_External_Verneed evn;
4021 Elf_External_Vernaux evna;
4022 Elf_Internal_Vernaux ivna;
4023 unsigned long vna_off;
4025 GET_DATA (offset, evn, "version need");
4027 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4028 ivn.vn_next = BYTE_GET (evn.vn_next);
4030 vna_off = offset + ivn.vn_aux;
4034 GET_DATA (vna_off, evna,
4035 "version need aux (1)");
4037 ivna.vna_next = BYTE_GET (evna.vna_next);
4038 ivna.vna_other = BYTE_GET (evna.vna_other);
4040 vna_off += ivna.vna_next;
4042 while (ivna.vna_other != data [cnt + j]
4043 && ivna.vna_next != 0);
4045 if (ivna.vna_other == data [cnt + j])
4047 ivna.vna_name = BYTE_GET (evna.vna_name);
4049 name = strtab + ivna.vna_name;
4050 nn += printf ("(%s%-*s",
4052 12 - (int) strlen (name),
4056 else if (ivn.vn_next == 0)
4058 if (data [cnt + j] != 0x8001)
4060 Elf_Internal_Verdef ivd;
4061 Elf_External_Verdef evd;
4063 offset = version_info
4064 [DT_VERSIONTAGIDX (DT_VERDEF)]
4069 GET_DATA (offset, evd,
4070 "version definition");
4072 ivd.vd_next = BYTE_GET (evd.vd_next);
4073 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4075 offset += ivd.vd_next;
4078 != (data [cnt + j] & 0x7fff)
4079 && ivd.vd_next != 0);
4082 == (data [cnt + j] & 0x7fff))
4084 Elf_External_Verdaux evda;
4085 Elf_Internal_Verdaux ivda;
4087 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4089 GET_DATA (offset + ivd.vd_aux, evda,
4090 "version definition aux");
4093 BYTE_GET (evda.vda_name);
4095 name = strtab + ivda.vda_name;
4099 12 - (int) strlen (name),
4107 offset += ivn.vn_next;
4109 while (ivn.vn_next);
4111 else if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4113 Elf_Internal_Verneed ivn;
4114 unsigned long offset;
4116 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4121 Elf_Internal_Vernaux ivna;
4122 Elf_External_Verneed evn;
4123 Elf_External_Vernaux evna;
4124 unsigned long a_off;
4126 GET_DATA (offset, evn, "version need");
4128 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4129 ivn.vn_next = BYTE_GET (evn.vn_next);
4131 a_off = offset + ivn.vn_aux;
4135 GET_DATA (a_off, evna,
4136 "version need aux (2)");
4138 ivna.vna_next = BYTE_GET (evna.vna_next);
4139 ivna.vna_other = BYTE_GET (evna.vna_other);
4141 a_off += ivna.vna_next;
4143 while (ivna.vna_other != data [cnt + j]
4144 && ivna.vna_next != 0);
4146 if (ivna.vna_other == data [cnt + j])
4148 ivna.vna_name = BYTE_GET (evna.vna_name);
4150 name = strtab + ivna.vna_name;
4151 nn += printf ("(%s%-*s",
4153 12 - (int) strlen (name),
4158 offset += ivn.vn_next;
4160 while (ivn.vn_next);
4162 else if (data [cnt + j] != 0x8001)
4164 Elf_Internal_Verdef ivd;
4165 Elf_External_Verdef evd;
4166 unsigned long offset;
4168 offset = version_info
4169 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4173 GET_DATA (offset, evd, "version def");
4175 ivd.vd_next = BYTE_GET (evd.vd_next);
4176 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4178 offset += ivd.vd_next;
4180 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4181 && ivd.vd_next != 0);
4183 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4185 Elf_External_Verdaux evda;
4186 Elf_Internal_Verdaux ivda;
4188 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4190 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4191 evda, "version def aux");
4193 ivda.vda_name = BYTE_GET (evda.vda_name);
4195 name = strtab + ivda.vda_name;
4196 nn += printf ("(%s%-*s",
4198 12 - (int) strlen (name),
4204 printf ("%*c", 18 - nn, ' ');
4222 printf (_("\nNo version information found in this file.\n"));
4228 get_symbol_binding (binding)
4229 unsigned int binding;
4231 static char buff [32];
4235 case STB_LOCAL: return "LOCAL";
4236 case STB_GLOBAL: return "GLOBAL";
4237 case STB_WEAK: return "WEAK";
4239 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4240 sprintf (buff, _("<processor specific>: %d"), binding);
4241 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4242 sprintf (buff, _("<OS specific>: %d"), binding);
4244 sprintf (buff, _("<unknown>: %d"), binding);
4250 get_symbol_type (type)
4253 static char buff [32];
4257 case STT_NOTYPE: return "NOTYPE";
4258 case STT_OBJECT: return "OBJECT";
4259 case STT_FUNC: return "FUNC";
4260 case STT_SECTION: return "SECTION";
4261 case STT_FILE: return "FILE";
4262 case STT_COMMON: return "COMMON";
4264 if (type >= STT_LOPROC && type <= STT_HIPROC)
4266 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4267 return "THUMB_FUNC";
4269 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4272 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4273 return "PARISC_MILLI";
4275 sprintf (buff, _("<processor specific>: %d"), type);
4277 else if (type >= STT_LOOS && type <= STT_HIOS)
4279 if (elf_header.e_machine == EM_PARISC)
4281 if (type == STT_HP_OPAQUE)
4283 if (type == STT_HP_STUB)
4287 sprintf (buff, _("<OS specific>: %d"), type);
4290 sprintf (buff, _("<unknown>: %d"), type);
4296 get_symbol_visibility (visibility)
4297 unsigned int visibility;
4301 case STV_DEFAULT: return "DEFAULT";
4302 case STV_INTERNAL: return "INTERNAL";
4303 case STV_HIDDEN: return "HIDDEN";
4304 case STV_PROTECTED: return "PROTECTED";
4310 get_symbol_index_type (type)
4315 case SHN_UNDEF: return "UND";
4316 case SHN_ABS: return "ABS";
4317 case SHN_COMMON: return "COM";
4319 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4321 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4323 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4327 static char buff [32];
4329 sprintf (buff, "%3d", type);
4336 get_dynamic_data (file, number)
4338 unsigned int number;
4340 unsigned char * e_data;
4343 e_data = (unsigned char *) malloc (number * 4);
4347 error (_("Out of memory\n"));
4351 if (fread (e_data, 4, number, file) != number)
4353 error (_("Unable to read in dynamic data\n"));
4357 i_data = (int *) malloc (number * sizeof (* i_data));
4361 error (_("Out of memory\n"));
4367 i_data [number] = byte_get (e_data + number * 4, 4);
4374 /* Dump the symbol table */
4376 process_symbol_table (file)
4379 Elf32_Internal_Shdr * section;
4380 unsigned char nb [4];
4381 unsigned char nc [4];
4384 int * buckets = NULL;
4385 int * chains = NULL;
4387 if (! do_syms && !do_histogram)
4390 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4393 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4395 error (_("Unable to seek to start of dynamic information"));
4399 if (fread (nb, sizeof (nb), 1, file) != 1)
4401 error (_("Failed to read in number of buckets\n"));
4405 if (fread (nc, sizeof (nc), 1, file) != 1)
4407 error (_("Failed to read in number of chains\n"));
4411 nbuckets = byte_get (nb, 4);
4412 nchains = byte_get (nc, 4);
4414 buckets = get_dynamic_data (file, nbuckets);
4415 chains = get_dynamic_data (file, nchains);
4417 if (buckets == NULL || chains == NULL)
4422 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4427 printf (_("\nSymbol table for image:\n"));
4429 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4431 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4433 for (hn = 0; hn < nbuckets; hn++)
4438 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4440 Elf_Internal_Sym * psym;
4442 psym = dynamic_symbols + si;
4444 printf (" %3d %3d: ", si, hn);
4445 print_vma (psym->st_value, LONG_HEX);
4447 print_vma (psym->st_size, DEC_5);
4449 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4450 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4451 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4452 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4453 printf (" %s\n", dynamic_strings + psym->st_name);
4457 else if (do_syms && !do_using_dynamic)
4461 for (i = 0, section = section_headers;
4462 i < elf_header.e_shnum;
4467 Elf_Internal_Sym * symtab;
4468 Elf_Internal_Sym * psym;
4471 if ( section->sh_type != SHT_SYMTAB
4472 && section->sh_type != SHT_DYNSYM)
4475 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4476 SECTION_NAME (section),
4477 (unsigned long) (section->sh_size / section->sh_entsize));
4479 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4481 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4483 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4484 section->sh_size / section->sh_entsize);
4488 if (section->sh_link == elf_header.e_shstrndx)
4489 strtab = string_table;
4492 Elf32_Internal_Shdr * string_sec;
4494 string_sec = section_headers + section->sh_link;
4496 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4497 strtab, char *, "string table");
4500 for (si = 0, psym = symtab;
4501 si < section->sh_size / section->sh_entsize;
4504 printf ("%6d: ", si);
4505 print_vma (psym->st_value, LONG_HEX);
4507 print_vma (psym->st_size, DEC_5);
4508 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4509 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4510 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4511 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4512 printf (" %s", strtab + psym->st_name);
4514 if (section->sh_type == SHT_DYNSYM &&
4515 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4517 unsigned char data[2];
4518 unsigned short vers_data;
4519 unsigned long offset;
4523 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4526 GET_DATA (offset + si * sizeof (vers_data), data,
4529 vers_data = byte_get (data, 2);
4531 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4532 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4535 check_def = (psym->st_shndx != SHN_UNDEF);
4537 if ((vers_data & 0x8000) || vers_data > 1)
4539 if (is_nobits || ! check_def)
4541 Elf_External_Verneed evn;
4542 Elf_Internal_Verneed ivn;
4543 Elf_Internal_Vernaux ivna;
4545 /* We must test both. */
4546 offset = version_info
4547 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4551 unsigned long vna_off;
4553 GET_DATA (offset, evn, "version need");
4555 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4556 ivn.vn_next = BYTE_GET (evn.vn_next);
4558 vna_off = offset + ivn.vn_aux;
4562 Elf_External_Vernaux evna;
4564 GET_DATA (vna_off, evna,
4565 "version need aux (3)");
4567 ivna.vna_other = BYTE_GET (evna.vna_other);
4568 ivna.vna_next = BYTE_GET (evna.vna_next);
4569 ivna.vna_name = BYTE_GET (evna.vna_name);
4571 vna_off += ivna.vna_next;
4573 while (ivna.vna_other != vers_data
4574 && ivna.vna_next != 0);
4576 if (ivna.vna_other == vers_data)
4579 offset += ivn.vn_next;
4581 while (ivn.vn_next != 0);
4583 if (ivna.vna_other == vers_data)
4586 strtab + ivna.vna_name, ivna.vna_other);
4589 else if (! is_nobits)
4590 error (_("bad dynamic symbol"));
4597 if (vers_data != 0x8001)
4599 Elf_Internal_Verdef ivd;
4600 Elf_Internal_Verdaux ivda;
4601 Elf_External_Verdaux evda;
4602 unsigned long offset;
4605 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
4610 Elf_External_Verdef evd;
4612 GET_DATA (offset, evd, "version def");
4614 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4615 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4616 ivd.vd_next = BYTE_GET (evd.vd_next);
4618 offset += ivd.vd_next;
4620 while (ivd.vd_ndx != (vers_data & 0x7fff)
4621 && ivd.vd_next != 0);
4623 offset -= ivd.vd_next;
4624 offset += ivd.vd_aux;
4626 GET_DATA (offset, evda, "version def aux");
4628 ivda.vda_name = BYTE_GET (evda.vda_name);
4630 if (psym->st_name != ivda.vda_name)
4631 printf ((vers_data & 0x8000)
4633 strtab + ivda.vda_name);
4643 if (strtab != string_table)
4649 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4651 if (do_histogram && buckets != NULL)
4658 int nzero_counts = 0;
4661 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4663 printf (_(" Length Number %% of total Coverage\n"));
4665 lengths = (int *) calloc (nbuckets, sizeof (int));
4666 if (lengths == NULL)
4668 error (_("Out of memory"));
4671 for (hn = 0; hn < nbuckets; ++hn)
4676 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
4679 if (maxlength < ++lengths[hn])
4684 counts = (int *) calloc (maxlength + 1, sizeof (int));
4687 error (_("Out of memory"));
4691 for (hn = 0; hn < nbuckets; ++hn)
4692 ++ counts [lengths [hn]];
4696 printf (" 0 %-10d (%5.1f%%)\n",
4697 counts[0], (counts[0] * 100.0) / nbuckets);
4698 for (si = 1; si <= maxlength; ++si)
4700 nzero_counts += counts[si] * si;
4701 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4702 si, counts[si], (counts[si] * 100.0) / nbuckets,
4703 (nzero_counts * 100.0) / nsyms);
4711 if (buckets != NULL)
4721 process_syminfo (file)
4722 FILE * file ATTRIBUTE_UNUSED;
4726 if (dynamic_syminfo == NULL
4728 /* No syminfo, this is ok. */
4731 /* There better should be a dynamic symbol section. */
4732 if (dynamic_symbols == NULL || dynamic_strings == NULL)
4736 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4737 dynamic_syminfo_offset, dynamic_syminfo_nent);
4739 printf (_(" Num: Name BoundTo Flags\n"));
4740 for (i = 0; i < dynamic_syminfo_nent; ++i)
4742 unsigned short int flags = dynamic_syminfo[i].si_flags;
4744 printf ("%4d: %-30s ", i,
4745 dynamic_strings + dynamic_symbols[i].st_name);
4747 switch (dynamic_syminfo[i].si_boundto)
4749 case SYMINFO_BT_SELF:
4750 fputs ("SELF ", stdout);
4752 case SYMINFO_BT_PARENT:
4753 fputs ("PARENT ", stdout);
4756 if (dynamic_syminfo[i].si_boundto > 0
4757 && dynamic_syminfo[i].si_boundto < dynamic_size)
4760 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
4762 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
4766 if (flags & SYMINFO_FLG_DIRECT)
4768 if (flags & SYMINFO_FLG_PASSTHRU)
4769 printf (" PASSTHRU");
4770 if (flags & SYMINFO_FLG_COPY)
4772 if (flags & SYMINFO_FLG_LAZYLOAD)
4773 printf (" LAZYLOAD");
4781 #ifdef SUPPORT_DISASSEMBLY
4783 disassemble_section (section, file)
4784 Elf32_Internal_Shdr * section;
4787 printf (_("\nAssembly dump of section %s\n"),
4788 SECTION_NAME (section));
4790 /* XXX -- to be done --- XXX */
4797 dump_section (section, file)
4798 Elf32_Internal_Shdr * section;
4801 bfd_size_type bytes;
4803 unsigned char * data;
4804 unsigned char * start;
4806 bytes = section->sh_size;
4810 printf (_("\nSection '%s' has no data to dump.\n"),
4811 SECTION_NAME (section));
4815 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
4817 addr = section->sh_addr;
4819 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
4830 lbytes = (bytes > 16 ? 16 : bytes);
4832 printf (" 0x%8.8lx ", (unsigned long) addr);
4834 switch (elf_header.e_ident [EI_DATA])
4838 for (j = 15; j >= 0; j --)
4841 printf ("%2.2x", data [j]);
4851 for (j = 0; j < 16; j++)
4854 printf ("%2.2x", data [j]);
4864 for (j = 0; j < lbytes; j++)
4867 if (k >= ' ' && k < 0x80)
4886 static unsigned long int
4887 read_leb128 (data, length_return, sign)
4888 unsigned char * data;
4889 int * length_return;
4892 unsigned long int result = 0;
4893 unsigned int num_read = 0;
4902 result |= (byte & 0x7f) << shift;
4907 while (byte & 0x80);
4909 if (length_return != NULL)
4910 * length_return = num_read;
4912 if (sign && (shift < 32) && (byte & 0x40))
4913 result |= -1 << shift;
4918 typedef struct State_Machine_Registers
4920 unsigned long address;
4923 unsigned int column;
4927 /* This variable hold the number of the last entry seen
4928 in the File Table. */
4929 unsigned int last_file_entry;
4932 static SMR state_machine_regs;
4935 reset_state_machine (is_stmt)
4938 state_machine_regs.address = 0;
4939 state_machine_regs.file = 1;
4940 state_machine_regs.line = 1;
4941 state_machine_regs.column = 0;
4942 state_machine_regs.is_stmt = is_stmt;
4943 state_machine_regs.basic_block = 0;
4944 state_machine_regs.end_sequence = 0;
4945 state_machine_regs.last_file_entry = 0;
4948 /* Handled an extend line op. Returns true if this is the end
4951 process_extended_line_op (data, is_stmt, pointer_size)
4952 unsigned char * data;
4956 unsigned char op_code;
4959 unsigned char * name;
4962 len = read_leb128 (data, & bytes_read, 0);
4967 warn (_("badly formed extended line op encountered!"));
4972 op_code = * data ++;
4974 printf (_(" Extended opcode %d: "), op_code);
4978 case DW_LNE_end_sequence:
4979 printf (_("End of Sequence\n\n"));
4980 reset_state_machine (is_stmt);
4983 case DW_LNE_set_address:
4984 adr = byte_get (data, pointer_size);
4985 printf (_("set Address to 0x%lx\n"), adr);
4986 state_machine_regs.address = adr;
4989 case DW_LNE_define_file:
4990 printf (_(" define new File Table entry\n"));
4991 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4993 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
4995 data += strlen ((char *) data) + 1;
4996 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
4998 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5000 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5001 printf (_("%s\n\n"), name);
5005 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5012 /* Size of pointers in the .debug_line section. This information is not
5013 really present in that section. It's obtained before dumping the debug
5014 sections by doing some pre-scan of the .debug_info section. */
5015 static int debug_line_pointer_size = 4;
5018 display_debug_lines (section, start, file)
5019 Elf32_Internal_Shdr * section;
5020 unsigned char * start;
5021 FILE * file ATTRIBUTE_UNUSED;
5023 DWARF2_External_LineInfo * external;
5024 DWARF2_Internal_LineInfo info;
5025 unsigned char * standard_opcodes;
5026 unsigned char * data = start;
5027 unsigned char * end = start + section->sh_size;
5028 unsigned char * end_of_sequence;
5031 printf (_("\nDump of debug contents of section %s:\n\n"),
5032 SECTION_NAME (section));
5036 external = (DWARF2_External_LineInfo *) data;
5038 /* Check the length of the block. */
5039 info.li_length = BYTE_GET (external->li_length);
5040 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5043 (_("The line info appears to be corrupt - the section is too small\n"));
5047 /* Check its version number. */
5048 info.li_version = BYTE_GET (external->li_version);
5049 if (info.li_version != 2)
5051 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5055 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5056 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5057 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5058 info.li_line_base = BYTE_GET (external->li_line_base);
5059 info.li_line_range = BYTE_GET (external->li_line_range);
5060 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5062 /* Sign extend the line base field. */
5063 info.li_line_base <<= 24;
5064 info.li_line_base >>= 24;
5066 printf (_(" Length: %ld\n"), info.li_length);
5067 printf (_(" DWARF Version: %d\n"), info.li_version);
5068 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
5069 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5070 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5071 printf (_(" Line Base: %d\n"), info.li_line_base);
5072 printf (_(" Line Range: %d\n"), info.li_line_range);
5073 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5075 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5077 reset_state_machine (info.li_default_is_stmt);
5079 /* Display the contents of the Opcodes table. */
5080 standard_opcodes = data + sizeof (* external);
5082 printf (_("\n Opcodes:\n"));
5084 for (i = 1; i < info.li_opcode_base; i++)
5085 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5087 /* Display the contents of the Directory table. */
5088 data = standard_opcodes + info.li_opcode_base - 1;
5091 printf (_("\n The Directory Table is empty.\n"));
5094 printf (_("\n The Directory Table:\n"));
5098 printf (_(" %s\n"), data);
5100 data += strlen ((char *) data) + 1;
5104 /* Skip the NUL at the end of the table. */
5107 /* Display the contents of the File Name table. */
5109 printf (_("\n The File Name Table is empty.\n"));
5112 printf (_("\n The File Name Table:\n"));
5113 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5117 unsigned char * name;
5120 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5123 data += strlen ((char *) data) + 1;
5125 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5127 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5129 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5131 printf (_("%s\n"), name);
5135 /* Skip the NUL at the end of the table. */
5138 /* Now display the statements. */
5139 printf (_("\n Line Number Statements:\n"));
5142 while (data < end_of_sequence)
5144 unsigned char op_code;
5148 op_code = * data ++;
5152 case DW_LNS_extended_op:
5153 data += process_extended_line_op (data, info.li_default_is_stmt,
5154 debug_line_pointer_size);
5158 printf (_(" Copy\n"));
5161 case DW_LNS_advance_pc:
5162 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5164 state_machine_regs.address += adv;
5165 printf (_(" Advance PC by %d to %lx\n"), adv,
5166 state_machine_regs.address);
5169 case DW_LNS_advance_line:
5170 adv = read_leb128 (data, & bytes_read, 1);
5172 state_machine_regs.line += adv;
5173 printf (_(" Advance Line by %d to %d\n"), adv,
5174 state_machine_regs.line);
5177 case DW_LNS_set_file:
5178 adv = read_leb128 (data, & bytes_read, 0);
5180 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5182 state_machine_regs.file = adv;
5185 case DW_LNS_set_column:
5186 adv = read_leb128 (data, & bytes_read, 0);
5188 printf (_(" Set column to %d\n"), adv);
5189 state_machine_regs.column = adv;
5192 case DW_LNS_negate_stmt:
5193 adv = state_machine_regs.is_stmt;
5195 printf (_(" Set is_stmt to %d\n"), adv);
5196 state_machine_regs.is_stmt = adv;
5199 case DW_LNS_set_basic_block:
5200 printf (_(" Set basic block\n"));
5201 state_machine_regs.basic_block = 1;
5204 case DW_LNS_const_add_pc:
5205 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5206 * info.li_min_insn_length);
5207 state_machine_regs.address += adv;
5208 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5209 state_machine_regs.address);
5212 case DW_LNS_fixed_advance_pc:
5213 adv = byte_get (data, 2);
5215 state_machine_regs.address += adv;
5216 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5217 adv, state_machine_regs.address);
5221 op_code -= info.li_opcode_base;
5222 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5223 state_machine_regs.address += adv;
5224 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5225 op_code, adv, state_machine_regs.address);
5226 adv = (op_code % info.li_line_range) + info.li_line_base;
5227 state_machine_regs.line += adv;
5228 printf (_(" and Line by %d to %d\n"),
5229 adv, state_machine_regs.line);
5240 display_debug_pubnames (section, start, file)
5241 Elf32_Internal_Shdr * section;
5242 unsigned char * start;
5243 FILE * file ATTRIBUTE_UNUSED;
5245 DWARF2_External_PubNames * external;
5246 DWARF2_Internal_PubNames pubnames;
5247 unsigned char * end;
5249 end = start + section->sh_size;
5251 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5255 unsigned char * data;
5256 unsigned long offset;
5258 external = (DWARF2_External_PubNames *) start;
5260 pubnames.pn_length = BYTE_GET (external->pn_length);
5261 pubnames.pn_version = BYTE_GET (external->pn_version);
5262 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5263 pubnames.pn_size = BYTE_GET (external->pn_size);
5265 data = start + sizeof (* external);
5266 start += pubnames.pn_length + sizeof (external->pn_length);
5268 if (pubnames.pn_version != 2)
5270 static int warned = 0;
5274 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5281 printf (_(" Length: %ld\n"),
5282 pubnames.pn_length);
5283 printf (_(" Version: %d\n"),
5284 pubnames.pn_version);
5285 printf (_(" Offset into .debug_info section: %ld\n"),
5286 pubnames.pn_offset);
5287 printf (_(" Size of area in .debug_info section: %ld\n"),
5290 printf (_("\n Offset\tName\n"));
5294 offset = byte_get (data, 4);
5299 printf (" %ld\t\t%s\n", offset, data);
5300 data += strlen ((char *) data) + 1;
5303 while (offset != 0);
5316 case DW_TAG_padding: return "DW_TAG_padding";
5317 case DW_TAG_array_type: return "DW_TAG_array_type";
5318 case DW_TAG_class_type: return "DW_TAG_class_type";
5319 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5320 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5321 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5322 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5323 case DW_TAG_label: return "DW_TAG_label";
5324 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5325 case DW_TAG_member: return "DW_TAG_member";
5326 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5327 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5328 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5329 case DW_TAG_string_type: return "DW_TAG_string_type";
5330 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5331 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5332 case DW_TAG_typedef: return "DW_TAG_typedef";
5333 case DW_TAG_union_type: return "DW_TAG_union_type";
5334 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5335 case DW_TAG_variant: return "DW_TAG_variant";
5336 case DW_TAG_common_block: return "DW_TAG_common_block";
5337 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5338 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5339 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5340 case DW_TAG_module: return "DW_TAG_module";
5341 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5342 case DW_TAG_set_type: return "DW_TAG_set_type";
5343 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5344 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5345 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5346 case DW_TAG_base_type: return "DW_TAG_base_type";
5347 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5348 case DW_TAG_const_type: return "DW_TAG_const_type";
5349 case DW_TAG_constant: return "DW_TAG_constant";
5350 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5351 case DW_TAG_file_type: return "DW_TAG_file_type";
5352 case DW_TAG_friend: return "DW_TAG_friend";
5353 case DW_TAG_namelist: return "DW_TAG_namelist";
5354 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5355 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5356 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5357 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5358 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5359 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5360 case DW_TAG_try_block: return "DW_TAG_try_block";
5361 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5362 case DW_TAG_variable: return "DW_TAG_variable";
5363 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5364 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5365 case DW_TAG_format_label: return "DW_TAG_format_label";
5366 case DW_TAG_function_template: return "DW_TAG_function_template";
5367 case DW_TAG_class_template: return "DW_TAG_class_template";
5370 static char buffer [100];
5372 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5379 get_AT_name (attribute)
5380 unsigned long attribute;
5384 case DW_AT_sibling: return "DW_AT_sibling";
5385 case DW_AT_location: return "DW_AT_location";
5386 case DW_AT_name: return "DW_AT_name";
5387 case DW_AT_ordering: return "DW_AT_ordering";
5388 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5389 case DW_AT_byte_size: return "DW_AT_byte_size";
5390 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5391 case DW_AT_bit_size: return "DW_AT_bit_size";
5392 case DW_AT_element_list: return "DW_AT_element_list";
5393 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5394 case DW_AT_low_pc: return "DW_AT_low_pc";
5395 case DW_AT_high_pc: return "DW_AT_high_pc";
5396 case DW_AT_language: return "DW_AT_language";
5397 case DW_AT_member: return "DW_AT_member";
5398 case DW_AT_discr: return "DW_AT_discr";
5399 case DW_AT_discr_value: return "DW_AT_discr_value";
5400 case DW_AT_visibility: return "DW_AT_visibility";
5401 case DW_AT_import: return "DW_AT_import";
5402 case DW_AT_string_length: return "DW_AT_string_length";
5403 case DW_AT_common_reference: return "DW_AT_common_reference";
5404 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5405 case DW_AT_const_value: return "DW_AT_const_value";
5406 case DW_AT_containing_type: return "DW_AT_containing_type";
5407 case DW_AT_default_value: return "DW_AT_default_value";
5408 case DW_AT_inline: return "DW_AT_inline";
5409 case DW_AT_is_optional: return "DW_AT_is_optional";
5410 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5411 case DW_AT_producer: return "DW_AT_producer";
5412 case DW_AT_prototyped: return "DW_AT_prototyped";
5413 case DW_AT_return_addr: return "DW_AT_return_addr";
5414 case DW_AT_start_scope: return "DW_AT_start_scope";
5415 case DW_AT_stride_size: return "DW_AT_stride_size";
5416 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5417 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5418 case DW_AT_accessibility: return "DW_AT_accessibility";
5419 case DW_AT_address_class: return "DW_AT_address_class";
5420 case DW_AT_artificial: return "DW_AT_artificial";
5421 case DW_AT_base_types: return "DW_AT_base_types";
5422 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5423 case DW_AT_count: return "DW_AT_count";
5424 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5425 case DW_AT_decl_column: return "DW_AT_decl_column";
5426 case DW_AT_decl_file: return "DW_AT_decl_file";
5427 case DW_AT_decl_line: return "DW_AT_decl_line";
5428 case DW_AT_declaration: return "DW_AT_declaration";
5429 case DW_AT_discr_list: return "DW_AT_discr_list";
5430 case DW_AT_encoding: return "DW_AT_encoding";
5431 case DW_AT_external: return "DW_AT_external";
5432 case DW_AT_frame_base: return "DW_AT_frame_base";
5433 case DW_AT_friend: return "DW_AT_friend";
5434 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5435 case DW_AT_macro_info: return "DW_AT_macro_info";
5436 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5437 case DW_AT_priority: return "DW_AT_priority";
5438 case DW_AT_segment: return "DW_AT_segment";
5439 case DW_AT_specification: return "DW_AT_specification";
5440 case DW_AT_static_link: return "DW_AT_static_link";
5441 case DW_AT_type: return "DW_AT_type";
5442 case DW_AT_use_location: return "DW_AT_use_location";
5443 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5444 case DW_AT_virtuality: return "DW_AT_virtuality";
5445 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5446 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5447 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5448 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5449 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5450 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5451 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5452 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5453 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5454 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5455 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5456 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5457 case DW_AT_sf_names: return "DW_AT_sf_names";
5458 case DW_AT_src_info: return "DW_AT_src_info";
5459 case DW_AT_mac_info: return "DW_AT_mac_info";
5460 case DW_AT_src_coords: return "DW_AT_src_coords";
5461 case DW_AT_body_begin: return "DW_AT_body_begin";
5462 case DW_AT_body_end: return "DW_AT_body_end";
5465 static char buffer [100];
5467 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5474 get_FORM_name (form)
5479 case DW_FORM_addr: return "DW_FORM_addr";
5480 case DW_FORM_block2: return "DW_FORM_block2";
5481 case DW_FORM_block4: return "DW_FORM_block4";
5482 case DW_FORM_data2: return "DW_FORM_data2";
5483 case DW_FORM_data4: return "DW_FORM_data4";
5484 case DW_FORM_data8: return "DW_FORM_data8";
5485 case DW_FORM_string: return "DW_FORM_string";
5486 case DW_FORM_block: return "DW_FORM_block";
5487 case DW_FORM_block1: return "DW_FORM_block1";
5488 case DW_FORM_data1: return "DW_FORM_data1";
5489 case DW_FORM_flag: return "DW_FORM_flag";
5490 case DW_FORM_sdata: return "DW_FORM_sdata";
5491 case DW_FORM_strp: return "DW_FORM_strp";
5492 case DW_FORM_udata: return "DW_FORM_udata";
5493 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5494 case DW_FORM_ref1: return "DW_FORM_ref1";
5495 case DW_FORM_ref2: return "DW_FORM_ref2";
5496 case DW_FORM_ref4: return "DW_FORM_ref4";
5497 case DW_FORM_ref8: return "DW_FORM_ref8";
5498 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5499 case DW_FORM_indirect: return "DW_FORM_indirect";
5502 static char buffer [100];
5504 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5510 /* FIXME: There are better and more effiecint ways to handle
5511 these structures. For now though, I just want something that
5512 is simple to implement. */
5513 typedef struct abbrev_attr
5515 unsigned long attribute;
5517 struct abbrev_attr * next;
5521 typedef struct abbrev_entry
5523 unsigned long entry;
5526 struct abbrev_attr * first_attr;
5527 struct abbrev_attr * last_attr;
5528 struct abbrev_entry * next;
5532 static abbrev_entry * first_abbrev = NULL;
5533 static abbrev_entry * last_abbrev = NULL;
5536 free_abbrevs PARAMS ((void))
5538 abbrev_entry * abbrev;
5540 for (abbrev = first_abbrev; abbrev;)
5542 abbrev_entry * next = abbrev->next;
5545 for (attr = abbrev->first_attr; attr;)
5547 abbrev_attr * next = attr->next;
5557 last_abbrev = first_abbrev = NULL;
5561 add_abbrev (number, tag, children)
5562 unsigned long number;
5566 abbrev_entry * entry;
5568 entry = (abbrev_entry *) malloc (sizeof (* entry));
5574 entry->entry = number;
5576 entry->children = children;
5577 entry->first_attr = NULL;
5578 entry->last_attr = NULL;
5581 if (first_abbrev == NULL)
5582 first_abbrev = entry;
5584 last_abbrev->next = entry;
5586 last_abbrev = entry;
5590 add_abbrev_attr (attribute, form)
5591 unsigned long attribute;
5596 attr = (abbrev_attr *) malloc (sizeof (* attr));
5602 attr->attribute = attribute;
5606 if (last_abbrev->first_attr == NULL)
5607 last_abbrev->first_attr = attr;
5609 last_abbrev->last_attr->next = attr;
5611 last_abbrev->last_attr = attr;
5614 /* Processes the (partial) contents of a .debug_abbrev section.
5615 Returns NULL if the end of the section was encountered.
5616 Returns the address after the last byte read if the end of
5617 an abbreviation set was found. */
5619 static unsigned char *
5620 process_abbrev_section (start, end)
5621 unsigned char * start;
5622 unsigned char * end;
5624 if (first_abbrev != NULL)
5630 unsigned long entry;
5632 unsigned long attribute;
5635 entry = read_leb128 (start, & bytes_read, 0);
5636 start += bytes_read;
5638 /* A single zero is supposed to end the section according
5639 to the standard. If there's more, then signal that to
5642 return start == end ? NULL : start;
5644 tag = read_leb128 (start, & bytes_read, 0);
5645 start += bytes_read;
5647 children = * start ++;
5649 add_abbrev (entry, tag, children);
5655 attribute = read_leb128 (start, & bytes_read, 0);
5656 start += bytes_read;
5658 form = read_leb128 (start, & bytes_read, 0);
5659 start += bytes_read;
5662 add_abbrev_attr (attribute, form);
5664 while (attribute != 0);
5672 display_debug_abbrev (section, start, file)
5673 Elf32_Internal_Shdr * section;
5674 unsigned char * start;
5675 FILE * file ATTRIBUTE_UNUSED;
5677 abbrev_entry * entry;
5678 unsigned char * end = start + section->sh_size;
5680 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5684 start = process_abbrev_section (start, end);
5686 printf (_(" Number TAG\n"));
5688 for (entry = first_abbrev; entry; entry = entry->next)
5692 printf (_(" %ld %s [%s]\n"),
5694 get_TAG_name (entry->tag),
5695 entry->children ? _("has children") : _("no children"));
5697 for (attr = entry->first_attr; attr; attr = attr->next)
5699 printf (_(" %-18s %s\n"),
5700 get_AT_name (attr->attribute),
5701 get_FORM_name (attr->form));
5713 static unsigned char *
5714 display_block (data, length)
5715 unsigned char * data;
5716 unsigned long length;
5718 printf (_(" %lu byte block: "), length);
5721 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
5727 decode_location_expression (data, pointer_size, length)
5728 unsigned char * data;
5729 unsigned int pointer_size;
5730 unsigned long length;
5734 unsigned long uvalue;
5735 unsigned char *end = data + length;
5744 printf ("DW_OP_addr: %lx",
5745 (unsigned long) byte_get (data, pointer_size));
5746 data += pointer_size;
5749 printf ("DW_OP_deref");
5752 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
5755 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
5758 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
5762 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
5766 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
5770 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
5774 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
5775 (unsigned long) byte_get (data + 4, 4));
5779 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
5780 (long) byte_get (data + 4, 4));
5784 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
5788 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
5792 printf ("DW_OP_dup");
5795 printf ("DW_OP_drop");
5798 printf ("DW_OP_over");
5801 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
5804 printf ("DW_OP_swap");
5807 printf ("DW_OP_rot");
5810 printf ("DW_OP_xderef");
5813 printf ("DW_OP_abs");
5816 printf ("DW_OP_and");
5819 printf ("DW_OP_div");
5822 printf ("DW_OP_minus");
5825 printf ("DW_OP_mod");
5828 printf ("DW_OP_mul");
5831 printf ("DW_OP_neg");
5834 printf ("DW_OP_not");
5837 printf ("DW_OP_or");
5840 printf ("DW_OP_plus");
5842 case DW_OP_plus_uconst:
5843 printf ("DW_OP_plus_uconst: %lu",
5844 read_leb128 (data, &bytes_read, 0));
5848 printf ("DW_OP_shl");
5851 printf ("DW_OP_shr");
5854 printf ("DW_OP_shra");
5857 printf ("DW_OP_xor");
5860 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
5864 printf ("DW_OP_eq");
5867 printf ("DW_OP_ge");
5870 printf ("DW_OP_gt");
5873 printf ("DW_OP_le");
5876 printf ("DW_OP_lt");
5879 printf ("DW_OP_ne");
5882 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
5918 printf ("DW_OP_lit%d", op - DW_OP_lit0);
5953 printf ("DW_OP_reg%d", op - DW_OP_reg0);
5988 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
5989 read_leb128 (data, &bytes_read, 1));
5994 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
5998 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6002 uvalue = read_leb128 (data, &bytes_read, 0);
6004 printf ("DW_OP_bregx: %lu %ld", uvalue,
6005 read_leb128 (data, &bytes_read, 1));
6009 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6012 case DW_OP_deref_size:
6013 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6015 case DW_OP_xderef_size:
6016 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6019 printf ("DW_OP_nop");
6023 if (op >= DW_OP_lo_user
6024 && op <= DW_OP_hi_user)
6025 printf (_("(User defined location op)"));
6027 printf (_("(Unknown location op)"));
6028 /* No way to tell where the next op is, so just bail. */
6035 static unsigned char *
6036 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6037 unsigned long attribute;
6039 unsigned char * data;
6040 unsigned long cu_offset;
6041 unsigned long pointer_size;
6043 unsigned long uvalue = 0;
6044 unsigned char * block_start = NULL;
6047 printf (" %-18s:", get_AT_name (attribute));
6054 case DW_FORM_ref_addr:
6056 uvalue = byte_get (data, pointer_size);
6057 data += pointer_size;
6063 uvalue = byte_get (data ++, 1);
6068 uvalue = byte_get (data, 2);
6074 uvalue = byte_get (data, 4);
6079 uvalue = read_leb128 (data, & bytes_read, 1);
6083 case DW_FORM_ref_udata:
6085 uvalue = read_leb128 (data, & bytes_read, 0);
6092 case DW_FORM_ref_addr:
6093 printf (" <#%lx>", uvalue);
6099 case DW_FORM_ref_udata:
6100 printf (" <%lx>", uvalue + cu_offset);
6104 printf (" %#lx", uvalue);
6112 printf (" %ld", uvalue);
6117 uvalue = byte_get (data, 4);
6118 printf (" %lx", uvalue);
6119 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6123 case DW_FORM_string:
6124 printf (" %s", data);
6125 data += strlen ((char *) data) + 1;
6129 uvalue = read_leb128 (data, & bytes_read, 0);
6130 block_start = data + bytes_read;
6131 data = display_block (block_start, uvalue);
6134 case DW_FORM_block1:
6135 uvalue = byte_get (data, 1);
6136 block_start = data + 1;
6137 data = display_block (block_start, uvalue);
6140 case DW_FORM_block2:
6141 uvalue = byte_get (data, 2);
6142 block_start = data + 2;
6143 data = display_block (block_start, uvalue);
6146 case DW_FORM_block4:
6147 uvalue = byte_get (data, 4);
6148 block_start = data + 4;
6149 data = display_block (block_start, uvalue);
6153 case DW_FORM_indirect:
6154 warn (_("Unable to handle FORM: %d"), form);
6158 warn (_("Unrecognised form: %d"), form);
6162 /* For some attributes we can display futher information. */
6171 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6172 case DW_INL_inlined: printf (_("(inlined)")); break;
6173 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6174 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6175 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6179 case DW_AT_language:
6182 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6183 case DW_LANG_C89: printf ("(ANSI C)"); break;
6184 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6185 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6186 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6187 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6188 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6189 case DW_LANG_Ada83: printf ("(Ada)"); break;
6190 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6191 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6192 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6193 default: printf ("(Unknown: %lx)", uvalue); break;
6197 case DW_AT_encoding:
6200 case DW_ATE_void: printf ("(void)"); break;
6201 case DW_ATE_address: printf ("(machine address)"); break;
6202 case DW_ATE_boolean: printf ("(boolean)"); break;
6203 case DW_ATE_complex_float: printf ("(complex float)"); break;
6204 case DW_ATE_float: printf ("(float)"); break;
6205 case DW_ATE_signed: printf ("(signed)"); break;
6206 case DW_ATE_signed_char: printf ("(signed char)"); break;
6207 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6208 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6210 if (uvalue >= DW_ATE_lo_user
6211 && uvalue <= DW_ATE_hi_user)
6212 printf ("(user defined type)");
6214 printf ("(unknown type)");
6219 case DW_AT_accessibility:
6222 case DW_ACCESS_public: printf ("(public)"); break;
6223 case DW_ACCESS_protected: printf ("(protected)"); break;
6224 case DW_ACCESS_private: printf ("(private)"); break;
6225 default: printf ("(unknown accessibility)"); break;
6229 case DW_AT_visibility:
6232 case DW_VIS_local: printf ("(local)"); break;
6233 case DW_VIS_exported: printf ("(exported)"); break;
6234 case DW_VIS_qualified: printf ("(qualified)"); break;
6235 default: printf ("(unknown visibility)"); break;
6239 case DW_AT_virtuality:
6242 case DW_VIRTUALITY_none: printf ("(none)"); break;
6243 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6244 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6245 default: printf ("(unknown virtuality)"); break;
6249 case DW_AT_identifier_case:
6252 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6253 case DW_ID_up_case: printf ("(up_case)"); break;
6254 case DW_ID_down_case: printf ("(down_case)"); break;
6255 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6256 default: printf ("(unknown case)"); break;
6260 case DW_AT_calling_convention:
6263 case DW_CC_normal: printf ("(normal)"); break;
6264 case DW_CC_program: printf ("(program)"); break;
6265 case DW_CC_nocall: printf ("(nocall)"); break;
6267 if (uvalue >= DW_CC_lo_user
6268 && uvalue <= DW_CC_hi_user)
6269 printf ("(user defined)");
6271 printf ("(unknown convention)");
6275 case DW_AT_frame_base:
6276 case DW_AT_location:
6277 case DW_AT_data_member_location:
6278 case DW_AT_vtable_elem_location:
6282 decode_location_expression (block_start, pointer_size, uvalue);
6296 display_debug_info (section, start, file)
6297 Elf32_Internal_Shdr * section;
6298 unsigned char * start;
6301 unsigned char * end = start + section->sh_size;
6302 unsigned char * section_begin = start;
6304 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6308 DWARF2_External_CompUnit * external;
6309 DWARF2_Internal_CompUnit compunit;
6310 unsigned char * tags;
6313 unsigned long cu_offset;
6315 external = (DWARF2_External_CompUnit *) start;
6317 compunit.cu_length = BYTE_GET (external->cu_length);
6318 compunit.cu_version = BYTE_GET (external->cu_version);
6319 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6320 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6322 tags = start + sizeof (* external);
6323 cu_offset = start - section_begin;
6324 start += compunit.cu_length + sizeof (external->cu_length);
6326 if (compunit.cu_version != 2)
6328 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6332 printf (_(" Compilation Unit:\n"));
6333 printf (_(" Length: %ld\n"), compunit.cu_length);
6334 printf (_(" Version: %d\n"), compunit.cu_version);
6335 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6336 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6338 if (first_abbrev != NULL)
6341 /* Read in the abbrevs used by this compilation unit. */
6344 Elf32_Internal_Shdr * sec;
6345 unsigned char * begin;
6347 /* Locate the .debug_abbrev section and process it. */
6348 for (i = 0, sec = section_headers;
6349 i < elf_header.e_shnum;
6351 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6354 if (i == -1 || sec->sh_size == 0)
6356 warn (_("Unable to locate .debug_abbrev section!\n"));
6360 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6361 "debug_abbrev section data");
6363 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6364 begin + sec->sh_size);
6370 while (tags < start)
6373 unsigned long abbrev_number;
6374 abbrev_entry * entry;
6377 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6380 /* A null DIE marks the end of a list of children. */
6381 if (abbrev_number == 0)
6387 /* Scan through the abbreviation list until we reach the
6389 for (entry = first_abbrev;
6390 entry && entry->entry != abbrev_number;
6391 entry = entry->next)
6396 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6401 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6402 level, tags - section_begin - bytes_read,
6404 get_TAG_name (entry->tag));
6406 for (attr = entry->first_attr; attr; attr = attr->next)
6407 tags = read_and_display_attr (attr->attribute,
6410 compunit.cu_pointer_size);
6412 if (entry->children)
6423 display_debug_aranges (section, start, file)
6424 Elf32_Internal_Shdr * section;
6425 unsigned char * start;
6426 FILE * file ATTRIBUTE_UNUSED;
6428 unsigned char * end = start + section->sh_size;
6430 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6434 DWARF2_External_ARange * external;
6435 DWARF2_Internal_ARange arange;
6436 unsigned char * ranges;
6437 unsigned long length;
6438 unsigned long address;
6441 external = (DWARF2_External_ARange *) start;
6443 arange.ar_length = BYTE_GET (external->ar_length);
6444 arange.ar_version = BYTE_GET (external->ar_version);
6445 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6446 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6447 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6449 if (arange.ar_version != 2)
6451 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6455 printf (_(" Length: %ld\n"), arange.ar_length);
6456 printf (_(" Version: %d\n"), arange.ar_version);
6457 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6458 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6459 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6461 printf (_("\n Address Length\n"));
6463 ranges = start + sizeof (* external);
6465 /* Must pad to an alignment boundary that is twice the pointer size. */
6466 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
6468 ranges += (2 * arange.ar_pointer_size) - excess;
6472 address = byte_get (ranges, arange.ar_pointer_size);
6474 ranges += arange.ar_pointer_size;
6476 length = byte_get (ranges, arange.ar_pointer_size);
6478 ranges += arange.ar_pointer_size;
6480 /* A pair of zeros marks the end of the list. */
6481 if (address == 0 && length == 0)
6484 printf (" %8.8lx %lu\n", address, length);
6487 start += arange.ar_length + sizeof (external->ar_length);
6495 typedef struct Frame_Chunk
6497 struct Frame_Chunk *next;
6498 unsigned char *chunk_start;
6500 /* DW_CFA_{undefined,same_value,offset,register} */
6501 unsigned char *col_type;
6504 unsigned int code_factor;
6505 unsigned int data_factor;
6506 unsigned long pc_begin;
6507 unsigned long pc_range;
6515 frame_need_space (fc, reg)
6519 int prev = fc->ncols;
6521 if (reg < fc->ncols)
6523 fc->ncols = reg + 1;
6524 fc->col_type = (unsigned char *) xrealloc (fc->col_type,
6525 fc->ncols * sizeof (unsigned char));
6526 fc->col_offset = (int *) xrealloc (fc->col_offset,
6527 fc->ncols * sizeof (int));
6529 while (prev < fc->ncols)
6531 fc->col_type[prev] = DW_CFA_undefined;
6532 fc->col_offset[prev] = 0;
6538 frame_display_row (fc, need_col_headers, max_regs)
6540 int *need_col_headers;
6546 if (*max_regs < fc->ncols)
6547 *max_regs = fc->ncols;
6548 if (*need_col_headers)
6550 *need_col_headers = 0;
6551 printf (" LOC CFA ");
6552 for (r=0; r<*max_regs; r++)
6556 printf ("r%-4d", r);
6559 printf ("%08x ", (unsigned int) fc->pc_begin);
6560 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
6561 printf ("%-8s ", tmp);
6562 for (r=0; r<fc->ncols; r++)
6564 switch (fc->col_type[r])
6566 case DW_CFA_undefined:
6569 case DW_CFA_same_value:
6573 sprintf (tmp, "c%+d", fc->col_offset[r]);
6575 case DW_CFA_register:
6576 sprintf (tmp, "r%d", fc->col_offset[r]);
6579 strcpy (tmp, "n/a");
6582 printf ("%-5s", tmp);
6587 #define GET(N) byte_get (start, N); start += N
6588 #define LEB() read_leb128 (start, &length_return, 0); start += length_return
6589 #define SLEB() read_leb128 (start, &length_return, 1); start += length_return
6592 display_debug_frames (section, start, file)
6593 Elf32_Internal_Shdr * section;
6594 unsigned char * start;
6595 FILE * file ATTRIBUTE_UNUSED;
6597 unsigned char * end = start + section->sh_size;
6598 unsigned char *section_start = start;
6599 Frame_Chunk *chunks = 0;
6600 Frame_Chunk *remembered_state = 0, *rs;
6601 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
6605 printf (_("The section %s contains:\n"), SECTION_NAME (section));
6609 unsigned char *saved_start, *block_end;
6610 unsigned long length, cie_id;
6611 Frame_Chunk *fc, *cie;
6612 int need_col_headers = 1;
6614 saved_start = start;
6615 length = byte_get (start, 4); start += 4;
6620 block_end = saved_start + length + 4;
6621 cie_id = byte_get (start, 4); start += 4;
6623 printf ("\n%08x %08lx %08lx ", saved_start - section_start, length, cie_id);
6625 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
6627 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6628 memset (fc, 0, sizeof (Frame_Chunk));
6632 fc->chunk_start = saved_start;
6634 fc->col_type = (unsigned char *) xmalloc (sizeof (unsigned char));
6635 fc->col_offset = (int *) xmalloc (sizeof (int));
6636 frame_need_space (fc, max_regs-1);
6638 start ++; /* version */
6639 fc->augmentation = start;
6640 while (*start) start++; start++; /* skip past NUL */
6641 if (fc->augmentation[0] == 'z')
6644 fc->code_factor = LEB ();
6645 fc->data_factor = SLEB ();
6646 fc->ra = byte_get (start, 1); start += 1;
6648 printf ("skipping %d extra bytes\n", xtra);
6651 else if (strcmp (fc->augmentation, "eh") == 0)
6654 fc->code_factor = LEB ();
6655 fc->data_factor = SLEB ();
6656 fc->ra = byte_get (start, 1); start += 1;
6660 fc->code_factor = LEB ();
6661 fc->data_factor = SLEB ();
6662 fc->ra = byte_get (start, 1); start += 1;
6665 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n",
6666 fc->augmentation, fc->code_factor, fc->data_factor, fc->ra);
6668 frame_need_space (fc, fc->ra);
6672 unsigned char *look_for;
6673 static Frame_Chunk fde_fc;
6675 memset (fc, 0, sizeof (Frame_Chunk));
6677 look_for = is_eh ? start-4-cie_id : (unsigned char *) cie_id;
6679 fc->pc_begin = byte_get (start, 4); start += 4;
6680 fc->pc_range = byte_get (start, 4); start += 4;
6682 for (cie=chunks; cie && (cie->chunk_start != look_for); cie = cie->next);
6685 warn ("Invalid CIE pointer %08x in FDE at %08x\n", cie_id, saved_start);
6688 fc->col_type = (unsigned char *) xmalloc (sizeof (unsigned char));
6689 fc->col_offset = (int *) xmalloc (sizeof (int));
6690 frame_need_space (fc, max_regs-1);
6692 fc->augmentation = "";
6696 fc->ncols = cie->ncols;
6697 fc->col_type = (unsigned char *) xmalloc (fc->ncols * sizeof (unsigned char));
6698 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
6699 memcpy (fc->col_type, cie->col_type, fc->ncols);
6700 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
6701 fc->augmentation = cie->augmentation;
6702 fc->code_factor = cie->code_factor;
6703 fc->data_factor = cie->data_factor;
6704 fc->cfa_reg = cie->cfa_reg;
6705 fc->cfa_offset = cie->cfa_offset;
6707 frame_need_space (fc, max_regs-1);
6710 if (cie->augmentation[0] == 'z')
6712 unsigned long l = LEB ();
6716 printf ("FDE cie=%08x pc=%08lx..%08lx\n",
6717 cie->chunk_start-section_start, fc->pc_begin,
6718 fc->pc_begin + fc->pc_range);
6721 /* At this point, fc is the current chunk, cie (if any) is set, and we're
6722 about to interpret instructions for the chunk. */
6724 /* This exists for readelf maintainers. */
6727 while (start < block_end)
6730 unsigned long ul, reg, roffs;
6741 case DW_CFA_advance_loc:
6742 frame_display_row (fc, &need_col_headers, &max_regs);
6744 printf (" DW_CFA_advance_loc: %08x = %08x + %d*%d\n",
6745 fc->pc_begin + opa * fc->code_factor, fc->pc_begin, opa, fc->code_factor);
6747 fc->pc_begin += opa * fc->code_factor;
6751 frame_need_space (fc, opa);
6754 printf (" DW_CFA_offset: r%d = cfa[%d*%d]\n", opa, roffs, fc->data_factor);
6756 fc->col_type[opa] = DW_CFA_offset;
6757 fc->col_offset[opa] = roffs * fc->data_factor;
6760 case DW_CFA_restore:
6761 frame_need_space (fc, opa);
6763 printf (" DW_CFA_restore: r%d\n", opa);
6765 fc->col_type[opa] = cie->col_type[opa];
6766 fc->col_offset[opa] = cie->col_offset[opa];
6769 case DW_CFA_set_loc:
6770 frame_display_row (fc, &need_col_headers, &max_regs);
6771 vma = byte_get (start, sizeof (vma)); start += sizeof (vma);
6773 printf (" DW_CFA_set_loc: %08x\n", vma);
6778 case DW_CFA_advance_loc1:
6779 frame_display_row (fc, &need_col_headers, &max_regs);
6780 ofs = byte_get (start, 1); start += 1;
6782 printf (" DW_CFA_advance_loc1: %08x = %08x + %d*%d\n",
6783 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
6785 fc->pc_begin += ofs * fc->code_factor;
6788 case DW_CFA_advance_loc2:
6789 frame_display_row (fc, &need_col_headers, &max_regs);
6790 ofs = byte_get (start, 2); start += 2;
6792 printf (" DW_CFA_advance_loc2: %08x = %08x + %d*%d\n",
6793 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
6795 fc->pc_begin += ofs * fc->code_factor;
6798 case DW_CFA_advance_loc4:
6799 frame_display_row (fc, &need_col_headers, &max_regs);
6800 ofs = byte_get (start, 4); start += 4;
6802 printf (" DW_CFA_advance_loc4: %08x = %08x + %d*%d\n",
6803 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
6805 fc->pc_begin += ofs * fc->code_factor;
6808 case DW_CFA_offset_extended:
6811 frame_need_space (fc, reg);
6813 printf (" DW_CFA_offset_extended: r%d = cfa[%d*%d]\n", reg, roffs, fc->data_factor);
6815 fc->col_type[reg] = DW_CFA_offset;
6816 fc->col_offset[reg] = roffs * fc->data_factor;
6819 case DW_CFA_restore_extended:
6821 frame_need_space (fc, reg);
6823 printf (" DW_CFA_restore_extended: r%d\n", reg);
6825 fc->col_type[reg] = cie->col_type[reg];
6826 fc->col_offset[reg] = cie->col_offset[reg];
6829 case DW_CFA_undefined:
6831 frame_need_space (fc, reg);
6833 printf (" DW_CFA_undefined: r%d\n", reg);
6835 fc->col_type[reg] = DW_CFA_undefined;
6836 fc->col_offset[reg] = 0;
6839 case DW_CFA_same_value:
6841 frame_need_space (fc, reg);
6843 printf (" DW_CFA_same_value: r%d\n", reg);
6845 fc->col_type[reg] = DW_CFA_same_value;
6846 fc->col_offset[reg] = 0;
6849 case DW_CFA_register:
6852 frame_need_space (fc, reg);
6854 printf (" DW_CFA_ame_value: r%d\n", reg);
6856 fc->col_type[reg] = DW_CFA_register;
6857 fc->col_offset[reg] = roffs;
6860 case DW_CFA_remember_state:
6862 printf (" DW_CFA_remember_state\n");
6864 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
6865 rs->ncols = fc->ncols;
6866 rs->col_type = (unsigned char *) xmalloc (rs->ncols);
6867 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
6868 memcpy (rs->col_type, fc->col_type, rs->ncols);
6869 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
6870 rs->next = remembered_state;
6871 remembered_state = rs;
6874 case DW_CFA_restore_state:
6876 printf (" DW_CFA_restore_state\n");
6878 rs = remembered_state;
6879 remembered_state = rs->next;
6880 frame_need_space (fc, rs->ncols-1);
6881 memcpy (fc->col_type, rs->col_type, rs->ncols);
6882 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
6883 free (rs->col_type);
6884 free (rs->col_offset);
6888 case DW_CFA_def_cfa:
6889 fc->cfa_reg = LEB ();
6890 fc->cfa_offset = LEB ();
6892 printf (" DW_CFA_def_cfa: reg %d ofs %d\n", fc->cfa_reg, fc->cfa_offset);
6896 case DW_CFA_def_cfa_register:
6897 fc->cfa_reg = LEB ();
6899 printf (" DW_CFA_def_cfa_reg: %d\n", fc->cfa_reg);
6903 case DW_CFA_def_cfa_offset:
6904 fc->cfa_offset = LEB ();
6906 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
6912 printf (" DW_CFA_nop\n");
6916 #ifndef DW_CFA_GNU_window_save
6917 #define DW_CFA_GNU_window_save 0x2d
6919 case DW_CFA_GNU_window_save:
6921 printf (" DW_CFA_GNU_window_save\n");
6925 #ifndef DW_CFA_GNU_args_size
6926 #define DW_CFA_GNU_args_size 0x2e
6928 case DW_CFA_GNU_args_size:
6931 printf (" DW_CFA_GNU_args_size: %d\n", ul);
6935 #ifndef DW_CFA_GNU_negative_offset_extended
6936 #define DW_CFA_GNU_negative_offset_extended 0x2f
6938 case DW_CFA_GNU_negative_offset_extended:
6941 frame_need_space (fc, reg);
6943 printf (" DW_CFA_GNU_negative_offset_extended: r%d = cfa[%d*%d]\n", reg, l, fc->data_factor);
6945 fc->col_type[reg] = DW_CFA_offset;
6946 fc->col_offset[reg] = l * fc->data_factor;
6950 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
6955 frame_display_row (fc, &need_col_headers, &max_regs);
6970 display_debug_not_supported (section, start, file)
6971 Elf32_Internal_Shdr * section;
6972 unsigned char * start ATTRIBUTE_UNUSED;
6973 FILE * file ATTRIBUTE_UNUSED;
6975 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6976 SECTION_NAME (section));
6981 /* Pre-scan the .debug_info section to record the size of address.
6982 When dumping the .debug_line, we use that size information, assuming
6983 that all compilation units have the same address size. */
6985 prescan_debug_info (section, start, file)
6986 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
6987 unsigned char * start;
6988 FILE * file ATTRIBUTE_UNUSED;
6990 DWARF2_External_CompUnit * external;
6992 external = (DWARF2_External_CompUnit *) start;
6994 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
6998 /* A structure containing the name of a debug section and a pointer
6999 to a function that can decode it. The third field is a prescan
7000 function to be run over the section before displaying any of the
7005 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7006 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7010 { ".debug_info", display_debug_info, prescan_debug_info },
7011 { ".debug_abbrev", display_debug_abbrev, NULL },
7012 { ".debug_line", display_debug_lines, NULL },
7013 { ".debug_aranges", display_debug_aranges, NULL },
7014 { ".debug_pubnames", display_debug_pubnames, NULL },
7015 { ".debug_frame", display_debug_frames, NULL },
7016 { ".eh_frame", display_debug_frames, NULL },
7017 { ".debug_macinfo", display_debug_not_supported, NULL },
7018 { ".debug_frame", display_debug_not_supported, NULL },
7019 { ".debug_str", display_debug_not_supported, NULL },
7020 { ".debug_static_func", display_debug_not_supported, NULL },
7021 { ".debug_static_vars", display_debug_not_supported, NULL },
7022 { ".debug_types", display_debug_not_supported, NULL },
7023 { ".debug_weaknames", display_debug_not_supported, NULL }
7027 display_debug_section (section, file)
7028 Elf32_Internal_Shdr * section;
7031 char * name = SECTION_NAME (section);
7032 bfd_size_type length;
7033 unsigned char * start;
7036 length = section->sh_size;
7039 printf (_("\nSection '%s' has no debugging data.\n"), name);
7043 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7044 "debug section data");
7046 /* See if we know how to display the contents of this section. */
7047 for (i = NUM_ELEM (debug_displays); i--;)
7048 if (strcmp (debug_displays[i].name, name) == 0)
7050 debug_displays[i].display (section, start, file);
7055 printf (_("Unrecognised debug section: %s\n"), name);
7059 /* If we loaded in the abbrev section at some point,
7060 we must release it here. */
7061 if (first_abbrev != NULL)
7068 process_section_contents (file)
7071 Elf32_Internal_Shdr * section;
7077 /* Pre-scan the debug sections to find some debug information not
7078 present in some of them. For the .debug_line, we must find out the
7079 size of address (specified in .debug_info and .debug_aranges). */
7080 for (i = 0, section = section_headers;
7081 i < elf_header.e_shnum && i < num_dump_sects;
7084 char * name = SECTION_NAME (section);
7087 if (section->sh_size == 0)
7090 /* See if there is some pre-scan operation for this section. */
7091 for (j = NUM_ELEM (debug_displays); j--;)
7092 if (strcmp (debug_displays[j].name, name) == 0)
7094 if (debug_displays[j].prescan != NULL)
7096 bfd_size_type length;
7097 unsigned char * start;
7099 length = section->sh_size;
7100 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7101 "debug section data");
7103 debug_displays[j].prescan (section, start, file);
7111 for (i = 0, section = section_headers;
7112 i < elf_header.e_shnum && i < num_dump_sects;
7115 #ifdef SUPPORT_DISASSEMBLY
7116 if (dump_sects[i] & DISASS_DUMP)
7117 disassemble_section (section, file);
7119 if (dump_sects[i] & HEX_DUMP)
7120 dump_section (section, file);
7122 if (dump_sects[i] & DEBUG_DUMP)
7123 display_debug_section (section, file);
7126 if (i < num_dump_sects)
7127 warn (_("Some sections were not dumped because they do not exist!\n"));
7133 process_mips_fpe_exception (mask)
7139 if (mask & OEX_FPU_INEX)
7140 fputs ("INEX", stdout), first = 0;
7141 if (mask & OEX_FPU_UFLO)
7142 printf ("%sUFLO", first ? "" : "|"), first = 0;
7143 if (mask & OEX_FPU_OFLO)
7144 printf ("%sOFLO", first ? "" : "|"), first = 0;
7145 if (mask & OEX_FPU_DIV0)
7146 printf ("%sDIV0", first ? "" : "|"), first = 0;
7147 if (mask & OEX_FPU_INVAL)
7148 printf ("%sINVAL", first ? "" : "|");
7151 fputs ("0", stdout);
7155 process_mips_specific (file)
7158 Elf_Internal_Dyn * entry;
7159 size_t liblist_offset = 0;
7160 size_t liblistno = 0;
7161 size_t conflictsno = 0;
7162 size_t options_offset = 0;
7163 size_t conflicts_offset = 0;
7165 /* We have a lot of special sections. Thanks SGI! */
7166 if (dynamic_segment == NULL)
7167 /* No information available. */
7170 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
7171 switch (entry->d_tag)
7173 case DT_MIPS_LIBLIST:
7174 liblist_offset = entry->d_un.d_val - loadaddr;
7176 case DT_MIPS_LIBLISTNO:
7177 liblistno = entry->d_un.d_val;
7179 case DT_MIPS_OPTIONS:
7180 options_offset = entry->d_un.d_val - loadaddr;
7182 case DT_MIPS_CONFLICT:
7183 conflicts_offset = entry->d_un.d_val - loadaddr;
7185 case DT_MIPS_CONFLICTNO:
7186 conflictsno = entry->d_un.d_val;
7192 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
7194 Elf32_External_Lib * elib;
7197 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
7198 elib, Elf32_External_Lib *, "liblist");
7200 printf ("\nSection '.liblist' contains %lu entries:\n",
7201 (unsigned long) liblistno);
7202 fputs (" Library Time Stamp Checksum Version Flags\n",
7205 for (cnt = 0; cnt < liblistno; ++cnt)
7212 liblist.l_name = BYTE_GET (elib[cnt].l_name);
7213 time = BYTE_GET (elib[cnt].l_time_stamp);
7214 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
7215 liblist.l_version = BYTE_GET (elib[cnt].l_version);
7216 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
7218 tmp = gmtime (&time);
7219 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
7220 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7221 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7223 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
7224 dynamic_strings + liblist.l_name, timebuf,
7225 liblist.l_checksum, liblist.l_version);
7227 if (liblist.l_flags == 0)
7238 { " EXACT_MATCH", LL_EXACT_MATCH },
7239 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
7240 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
7241 { " EXPORTS", LL_EXPORTS },
7242 { " DELAY_LOAD", LL_DELAY_LOAD },
7243 { " DELTA", LL_DELTA }
7245 int flags = liblist.l_flags;
7249 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
7251 if ((flags & l_flags_vals[fcnt].bit) != 0)
7253 fputs (l_flags_vals[fcnt].name, stdout);
7254 flags ^= l_flags_vals[fcnt].bit;
7257 printf (" %#x", (unsigned int) flags);
7266 if (options_offset != 0)
7268 Elf_External_Options * eopt;
7269 Elf_Internal_Shdr * sect = section_headers;
7270 Elf_Internal_Options * iopt;
7271 Elf_Internal_Options * option;
7275 /* Find the section header so that we get the size. */
7276 while (sect->sh_type != SHT_MIPS_OPTIONS)
7279 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
7280 Elf_External_Options *, "options");
7282 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
7286 error (_("Out of memory"));
7293 while (offset < sect->sh_size)
7295 Elf_External_Options * eoption;
7297 eoption = (Elf_External_Options *) ((char *) eopt + offset);
7299 option->kind = BYTE_GET (eoption->kind);
7300 option->size = BYTE_GET (eoption->size);
7301 option->section = BYTE_GET (eoption->section);
7302 option->info = BYTE_GET (eoption->info);
7304 offset += option->size;
7310 printf (_("\nSection '%s' contains %d entries:\n"),
7311 string_table + sect->sh_name, cnt);
7319 switch (option->kind)
7322 /* This shouldn't happen. */
7323 printf (" NULL %d %lx", option->section, option->info);
7326 printf (" REGINFO ");
7327 if (elf_header.e_machine == EM_MIPS)
7330 Elf32_External_RegInfo *ereg;
7331 Elf32_RegInfo reginfo;
7333 ereg = (Elf32_External_RegInfo *) (option + 1);
7334 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7335 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7336 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7337 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7338 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7339 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
7341 printf ("GPR %08lx GP 0x%lx\n",
7343 (unsigned long) reginfo.ri_gp_value);
7344 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7345 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7346 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7351 Elf64_External_RegInfo * ereg;
7352 Elf64_Internal_RegInfo reginfo;
7354 ereg = (Elf64_External_RegInfo *) (option + 1);
7355 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7356 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7357 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7358 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7359 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7360 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
7362 printf ("GPR %08lx GP 0x",
7363 reginfo.ri_gprmask);
7364 printf_vma (reginfo.ri_gp_value);
7367 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7368 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7369 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7373 case ODK_EXCEPTIONS:
7374 fputs (" EXCEPTIONS fpe_min(", stdout);
7375 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
7376 fputs (") fpe_max(", stdout);
7377 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
7378 fputs (")", stdout);
7380 if (option->info & OEX_PAGE0)
7381 fputs (" PAGE0", stdout);
7382 if (option->info & OEX_SMM)
7383 fputs (" SMM", stdout);
7384 if (option->info & OEX_FPDBUG)
7385 fputs (" FPDBUG", stdout);
7386 if (option->info & OEX_DISMISS)
7387 fputs (" DISMISS", stdout);
7390 fputs (" PAD ", stdout);
7391 if (option->info & OPAD_PREFIX)
7392 fputs (" PREFIX", stdout);
7393 if (option->info & OPAD_POSTFIX)
7394 fputs (" POSTFIX", stdout);
7395 if (option->info & OPAD_SYMBOL)
7396 fputs (" SYMBOL", stdout);
7399 fputs (" HWPATCH ", stdout);
7400 if (option->info & OHW_R4KEOP)
7401 fputs (" R4KEOP", stdout);
7402 if (option->info & OHW_R8KPFETCH)
7403 fputs (" R8KPFETCH", stdout);
7404 if (option->info & OHW_R5KEOP)
7405 fputs (" R5KEOP", stdout);
7406 if (option->info & OHW_R5KCVTL)
7407 fputs (" R5KCVTL", stdout);
7410 fputs (" FILL ", stdout);
7411 /* XXX Print content of info word? */
7414 fputs (" TAGS ", stdout);
7415 /* XXX Print content of info word? */
7418 fputs (" HWAND ", stdout);
7419 if (option->info & OHWA0_R4KEOP_CHECKED)
7420 fputs (" R4KEOP_CHECKED", stdout);
7421 if (option->info & OHWA0_R4KEOP_CLEAN)
7422 fputs (" R4KEOP_CLEAN", stdout);
7425 fputs (" HWOR ", stdout);
7426 if (option->info & OHWA0_R4KEOP_CHECKED)
7427 fputs (" R4KEOP_CHECKED", stdout);
7428 if (option->info & OHWA0_R4KEOP_CLEAN)
7429 fputs (" R4KEOP_CLEAN", stdout);
7432 printf (" GP_GROUP %#06lx self-contained %#06lx",
7433 option->info & OGP_GROUP,
7434 (option->info & OGP_SELF) >> 16);
7437 printf (" IDENT %#06lx self-contained %#06lx",
7438 option->info & OGP_GROUP,
7439 (option->info & OGP_SELF) >> 16);
7442 /* This shouldn't happen. */
7443 printf (" %3d ??? %d %lx",
7444 option->kind, option->section, option->info);
7448 len = sizeof (*eopt);
7449 while (len < option->size)
7450 if (((char *) option)[len] >= ' '
7451 && ((char *) option)[len] < 0x7f)
7452 printf ("%c", ((char *) option)[len++]);
7454 printf ("\\%03o", ((char *) option)[len++]);
7456 fputs ("\n", stdout);
7463 if (conflicts_offset != 0 && conflictsno != 0)
7465 Elf32_External_Conflict * econf32;
7466 Elf64_External_Conflict * econf64;
7467 Elf32_Conflict * iconf;
7470 if (dynamic_symbols == NULL)
7472 error (_("conflict list with without table"));
7476 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
7479 error (_("Out of memory"));
7485 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf32),
7486 econf32, Elf32_External_Conflict *, "conflict");
7488 for (cnt = 0; cnt < conflictsno; ++cnt)
7489 iconf[cnt] = BYTE_GET (econf32[cnt]);
7493 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (*econf64),
7494 econf64, Elf64_External_Conflict *, "conflict");
7496 for (cnt = 0; cnt < conflictsno; ++cnt)
7497 iconf[cnt] = BYTE_GET (econf64[cnt]);
7500 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
7501 puts (_(" Num: Index Value Name"));
7503 for (cnt = 0; cnt < conflictsno; ++cnt)
7505 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
7507 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
7508 print_vma (psym->st_value, FULL_HEX);
7509 printf (" %s\n", dynamic_strings + psym->st_name);
7519 get_note_type (e_type)
7522 static char buff[64];
7526 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
7527 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
7528 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
7529 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
7530 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
7531 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
7532 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
7533 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
7534 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
7535 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7536 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7538 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
7543 /* Note that by the ELF standard, the name field is already null byte
7544 terminated, and namesz includes the terminating null byte.
7545 I.E. the value of namesz for the name "FSF" is 4.
7547 If the value of namesz is zero, there is no name present. */
7549 process_note (pnote)
7550 Elf32_Internal_Note * pnote;
7552 printf (" %s\t\t0x%08lx\t%s\n",
7553 pnote->namesz ? pnote->namedata : "(NONE)",
7554 pnote->descsz, get_note_type (pnote->type));
7560 process_corefile_note_segment (file, offset, length)
7565 Elf_External_Note * pnotes;
7566 Elf_External_Note * external;
7572 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
7576 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7577 (unsigned long) offset, (unsigned long) length);
7578 printf (_(" Owner\t\tData size\tDescription\n"));
7580 while (external < (Elf_External_Note *)((char *) pnotes + length))
7582 Elf32_Internal_Note inote;
7585 inote.type = BYTE_GET (external->type);
7586 inote.namesz = BYTE_GET (external->namesz);
7587 inote.namedata = external->name;
7588 inote.descsz = BYTE_GET (external->descsz);
7589 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
7590 inote.descpos = offset + (inote.descdata - (char *) pnotes);
7592 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
7594 /* Verify that name is null terminated. It appears that at least
7595 one version of Linux (RedHat 6.0) generates corefiles that don't
7596 comply with the ELF spec by failing to include the null byte in
7598 if (inote.namedata[inote.namesz] != '\0')
7600 temp = malloc (inote.namesz + 1);
7604 error (_("Out of memory\n"));
7609 strncpy (temp, inote.namedata, inote.namesz);
7610 temp[inote.namesz] = 0;
7612 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7613 inote.namedata = temp;
7616 res &= process_note (& inote);
7631 process_corefile_note_segments (file)
7634 Elf_Internal_Phdr * program_headers;
7635 Elf_Internal_Phdr * segment;
7639 program_headers = (Elf_Internal_Phdr *) malloc
7640 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
7642 if (program_headers == NULL)
7644 error (_("Out of memory\n"));
7649 i = get_32bit_program_headers (file, program_headers);
7651 i = get_64bit_program_headers (file, program_headers);
7655 free (program_headers);
7659 for (i = 0, segment = program_headers;
7660 i < elf_header.e_phnum;
7663 if (segment->p_type == PT_NOTE)
7664 res &= process_corefile_note_segment (file,
7665 (bfd_vma) segment->p_offset,
7666 (bfd_vma) segment->p_filesz);
7669 free (program_headers);
7675 process_corefile_contents (file)
7678 /* If we have not been asked to display the notes then do nothing. */
7682 /* If file is not a core file then exit. */
7683 if (elf_header.e_type != ET_CORE)
7686 /* No program headers means no NOTE segment. */
7687 if (elf_header.e_phnum == 0)
7689 printf (_("No note segments present in the core file.\n"));
7693 return process_corefile_note_segments (file);
7697 process_arch_specific (file)
7703 switch (elf_header.e_machine)
7706 case EM_MIPS_RS4_BE:
7707 return process_mips_specific (file);
7716 get_file_header (file)
7719 /* Read in the identity array. */
7720 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
7723 /* Determine how to read the rest of the header. */
7724 switch (elf_header.e_ident [EI_DATA])
7726 default: /* fall through */
7727 case ELFDATANONE: /* fall through */
7728 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
7729 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
7732 /* For now we only support 32 bit and 64 bit ELF files. */
7733 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
7735 /* Read in the rest of the header. */
7738 Elf32_External_Ehdr ehdr32;
7740 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
7743 elf_header.e_type = BYTE_GET (ehdr32.e_type);
7744 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
7745 elf_header.e_version = BYTE_GET (ehdr32.e_version);
7746 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
7747 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
7748 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
7749 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
7750 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
7751 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
7752 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
7753 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
7754 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
7755 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
7759 Elf64_External_Ehdr ehdr64;
7761 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7762 we will not be able to cope with the 64bit data found in
7763 64 ELF files. Detect this now and abort before we start
7764 overwritting things. */
7765 if (sizeof (bfd_vma) < 8)
7767 error (_("This instance of readelf has been built without support for a\n"));
7768 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7772 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
7775 elf_header.e_type = BYTE_GET (ehdr64.e_type);
7776 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
7777 elf_header.e_version = BYTE_GET (ehdr64.e_version);
7778 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
7779 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
7780 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
7781 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
7782 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
7783 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
7784 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
7785 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
7786 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
7787 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
7794 process_file (file_name)
7798 struct stat statbuf;
7801 if (stat (file_name, & statbuf) < 0)
7803 error (_("Cannot stat input file %s.\n"), file_name);
7807 file = fopen (file_name, "rb");
7810 error (_("Input file %s not found.\n"), file_name);
7814 if (! get_file_header (file))
7816 error (_("%s: Failed to read file header\n"), file_name);
7821 /* Initialise per file variables. */
7822 for (i = NUM_ELEM (version_info); i--;)
7823 version_info[i] = 0;
7825 for (i = NUM_ELEM (dynamic_info); i--;)
7826 dynamic_info[i] = 0;
7828 /* Process the file. */
7830 printf (_("\nFile: %s\n"), file_name);
7832 if (! process_file_header ())
7838 process_section_headers (file);
7840 process_program_headers (file);
7842 process_dynamic_segment (file);
7844 process_relocs (file);
7846 process_symbol_table (file);
7848 process_syminfo (file);
7850 process_version_sections (file);
7852 process_section_contents (file);
7854 process_corefile_contents (file);
7856 process_arch_specific (file);
7860 if (section_headers)
7862 free (section_headers);
7863 section_headers = NULL;
7868 free (string_table);
7869 string_table = NULL;
7872 if (dynamic_strings)
7874 free (dynamic_strings);
7875 dynamic_strings = NULL;
7878 if (dynamic_symbols)
7880 free (dynamic_symbols);
7881 dynamic_symbols = NULL;
7882 num_dynamic_syms = 0;
7885 if (dynamic_syminfo)
7887 free (dynamic_syminfo);
7888 dynamic_syminfo = NULL;
7892 #ifdef SUPPORT_DISASSEMBLY
7893 /* Needed by the i386 disassembler. For extra credit, someone could
7894 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7898 print_address (unsigned int addr, FILE * outfile)
7900 fprintf (outfile,"0x%8.8x", addr);
7903 /* Needed by the i386 disassembler. */
7905 db_task_printsym (unsigned int addr)
7907 print_address (addr, stderr);
7916 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7917 setlocale (LC_MESSAGES, "");
7919 bindtextdomain (PACKAGE, LOCALEDIR);
7920 textdomain (PACKAGE);
7922 parse_args (argc, argv);
7924 if (optind < (argc - 1))
7927 while (optind < argc)
7928 process_file (argv [optind ++]);
7930 if (dump_sects != NULL)