1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001 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"
76 #include "elf/x86-64.h"
82 char * program_name = "readelf";
83 unsigned int dynamic_addr;
84 bfd_size_type dynamic_size;
85 unsigned int rela_addr;
86 unsigned int rela_size;
87 char * dynamic_strings;
89 unsigned long string_table_length;
90 unsigned long num_dynamic_syms;
91 Elf_Internal_Sym * dynamic_symbols;
92 Elf_Internal_Syminfo * dynamic_syminfo;
93 unsigned long dynamic_syminfo_offset;
94 unsigned int dynamic_syminfo_nent;
95 char program_interpreter [64];
96 int dynamic_info[DT_JMPREL + 1];
99 Elf_Internal_Ehdr elf_header;
100 Elf_Internal_Shdr * section_headers;
101 Elf_Internal_Dyn * dynamic_segment;
109 int do_using_dynamic;
116 int do_debug_abbrevs;
118 int do_debug_pubnames;
119 int do_debug_aranges;
125 /* A dynamic array of flags indicating which sections require dumping. */
126 char * dump_sects = NULL;
127 unsigned int num_dump_sects = 0;
129 #define HEX_DUMP (1 << 0)
130 #define DISASS_DUMP (1 << 1)
131 #define DEBUG_DUMP (1 << 2)
133 /* How to rpint a vma value. */
134 typedef enum print_mode
146 /* Forward declarations for dumb compilers. */
147 static void print_vma PARAMS ((bfd_vma, print_mode));
148 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
149 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
150 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
151 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
152 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
153 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
154 static const char * get_dynamic_type PARAMS ((unsigned long));
155 static int slurp_rela_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **, unsigned long *));
156 static int slurp_rel_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel **, unsigned long *));
157 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
158 static char * get_file_type PARAMS ((unsigned));
159 static char * get_machine_name PARAMS ((unsigned));
160 static void decode_ARM_machine_flags PARAMS ((unsigned, char []));
161 static char * get_machine_flags PARAMS ((unsigned, unsigned));
162 static const char * get_mips_segment_type PARAMS ((unsigned long));
163 static const char * get_parisc_segment_type PARAMS ((unsigned long));
164 static const char * get_ia64_segment_type PARAMS ((unsigned long));
165 static const char * get_segment_type PARAMS ((unsigned long));
166 static const char * get_mips_section_type_name PARAMS ((unsigned int));
167 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
168 static const char * get_ia64_section_type_name PARAMS ((unsigned int));
169 static const char * get_section_type_name PARAMS ((unsigned int));
170 static const char * get_symbol_binding PARAMS ((unsigned int));
171 static const char * get_symbol_type PARAMS ((unsigned int));
172 static const char * get_symbol_visibility PARAMS ((unsigned int));
173 static const char * get_symbol_index_type PARAMS ((unsigned int));
174 static const char * get_dynamic_flags PARAMS ((bfd_vma));
175 static void usage PARAMS ((void));
176 static void parse_args PARAMS ((int, char **));
177 static int process_file_header PARAMS ((void));
178 static int process_program_headers PARAMS ((FILE *));
179 static int process_section_headers PARAMS ((FILE *));
180 static int process_unwind PARAMS ((FILE *));
181 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
182 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
183 static int process_dynamic_segment PARAMS ((FILE *));
184 static int process_symbol_table PARAMS ((FILE *));
185 static int process_section_contents PARAMS ((FILE *));
186 static void process_file PARAMS ((char *));
187 static int process_relocs PARAMS ((FILE *));
188 static int process_version_sections PARAMS ((FILE *));
189 static char * get_ver_flags PARAMS ((unsigned int));
190 static int get_32bit_section_headers PARAMS ((FILE *));
191 static int get_64bit_section_headers PARAMS ((FILE *));
192 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
193 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
194 static int get_file_header PARAMS ((FILE *));
195 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
196 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, unsigned long, unsigned long));
197 static const char * get_elf_section_flags PARAMS ((bfd_vma));
198 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
199 static int get_32bit_dynamic_segment PARAMS ((FILE *));
200 static int get_64bit_dynamic_segment PARAMS ((FILE *));
201 #ifdef SUPPORT_DISASSEMBLY
202 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
204 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
205 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
206 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
207 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
208 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
209 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
210 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
211 static int display_debug_frames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
212 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
213 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
214 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
215 static void reset_state_machine PARAMS ((int));
216 static char * get_TAG_name PARAMS ((unsigned long));
217 static char * get_AT_name PARAMS ((unsigned long));
218 static char * get_FORM_name PARAMS ((unsigned long));
219 static void free_abbrevs PARAMS ((void));
220 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
221 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
222 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
223 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
224 static void decode_location_expression PARAMS ((unsigned char *, unsigned int, unsigned long));
225 static void request_dump PARAMS ((unsigned int, char));
226 static const char * get_elf_class PARAMS ((unsigned char));
227 static const char * get_data_encoding PARAMS ((unsigned char));
228 static const char * get_osabi_name PARAMS ((unsigned char));
229 static int guess_is_rela PARAMS ((unsigned long));
230 static char * get_note_type PARAMS ((unsigned int));
231 static int process_note PARAMS ((Elf32_Internal_Note *));
232 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
233 static int process_corefile_note_segments PARAMS ((FILE *));
234 static int process_corefile_contents PARAMS ((FILE *));
236 typedef int Elf32_Word;
244 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
245 ((X)->sh_name >= string_table_length \
246 ? "<corrupt>" : string_table + (X)->sh_name))
248 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
250 #define BYTE_GET(field) byte_get (field, sizeof (field))
252 /* If we can support a 64 bit data type then BFD64 should be defined
253 and sizeof (bfd_vma) == 8. In this case when translating from an
254 external 8 byte field to an internal field, we can assume that the
255 internal field is also 8 bytes wide and so we can extract all the data.
256 If, however, BFD64 is not defined, then we must assume that the
257 internal data structure only has 4 byte wide fields that are the
258 equivalent of the 8 byte wide external counterparts, and so we must
259 truncate the data. */
261 #define BYTE_GET8(field) byte_get (field, -8)
263 #define BYTE_GET8(field) byte_get (field, 8)
266 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
268 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
269 if (fseek (file, offset, SEEK_SET)) \
271 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
275 var = (type) malloc (size); \
279 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
283 if (fread (var, size, 1, file) != 1) \
285 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
292 #define GET_DATA(offset, var, reason) \
293 if (fseek (file, offset, SEEK_SET)) \
295 error (_("Unable to seek to %x for %s\n"), offset, reason); \
298 else if (fread (& var, sizeof (var), 1, file) != 1) \
300 error (_("Unable to read data at %x for %s\n"), offset, reason); \
304 #define GET_ELF_SYMBOLS(file, offset, size) \
305 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
306 : get_64bit_elf_symbols (file, offset, size))
309 #ifdef ANSI_PROTOTYPES
311 error (const char * message, ...)
315 fprintf (stderr, _("%s: Error: "), program_name);
316 va_start (args, message);
317 vfprintf (stderr, message, args);
323 warn (const char * message, ...)
327 fprintf (stderr, _("%s: Warning: "), program_name);
328 va_start (args, message);
329 vfprintf (stderr, message, args);
341 fprintf (stderr, _("%s: Error: "), program_name);
343 message = va_arg (args, char *);
344 vfprintf (stderr, message, args);
356 fprintf (stderr, _("%s: Warning: "), program_name);
358 message = va_arg (args, char *);
359 vfprintf (stderr, message, args);
366 byte_get_little_endian (field, size)
367 unsigned char * field;
376 return ((unsigned int) (field [0]))
377 | (((unsigned int) (field [1])) << 8);
380 /* We want to extract data from an 8 byte wide field and
381 place it into a 4 byte wide field. Since this is a little
382 endian source we can juts use the 4 byte extraction code. */
385 return ((unsigned long) (field [0]))
386 | (((unsigned long) (field [1])) << 8)
387 | (((unsigned long) (field [2])) << 16)
388 | (((unsigned long) (field [3])) << 24);
392 /* This is a special case, generated by the BYTE_GET8 macro.
393 It means that we are loading an 8 byte value from a field
394 in an external structure into an 8 byte value in a field
395 in an internal strcuture. */
396 return ((bfd_vma) (field [0]))
397 | (((bfd_vma) (field [1])) << 8)
398 | (((bfd_vma) (field [2])) << 16)
399 | (((bfd_vma) (field [3])) << 24)
400 | (((bfd_vma) (field [4])) << 32)
401 | (((bfd_vma) (field [5])) << 40)
402 | (((bfd_vma) (field [6])) << 48)
403 | (((bfd_vma) (field [7])) << 56);
406 error (_("Unhandled data length: %d\n"), size);
411 /* Print a VMA value. */
413 print_vma (vma, mode)
423 case FULL_HEX: printf ("0x"); /* drop through */
424 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
425 case PREFIX_HEX: printf ("0x"); /* drop through */
426 case HEX: printf ("%lx", (unsigned long) vma); break;
427 case DEC: printf ("%ld", (unsigned long) vma); break;
428 case DEC_5: printf ("%5ld", (long) vma); break;
429 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
450 #if BFD_HOST_64BIT_LONG
453 if (_bfd_int64_high (vma))
454 printf ("%lx%lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
456 printf ("%lx", _bfd_int64_low (vma));
461 #if BFD_HOST_64BIT_LONG
464 if (_bfd_int64_high (vma))
466 printf ("++%ld", _bfd_int64_low (vma));
468 printf ("%ld", _bfd_int64_low (vma));
473 #if BFD_HOST_64BIT_LONG
474 printf ("%5ld", vma);
476 if (_bfd_int64_high (vma))
478 printf ("++%ld", _bfd_int64_low (vma));
480 printf ("%5ld", _bfd_int64_low (vma));
485 #if BFD_HOST_64BIT_LONG
488 if (_bfd_int64_high (vma))
490 printf ("++%lu", _bfd_int64_low (vma));
492 printf ("%lu", _bfd_int64_low (vma));
501 byte_get_big_endian (field, size)
502 unsigned char * field;
511 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
514 return ((unsigned long) (field [3]))
515 | (((unsigned long) (field [2])) << 8)
516 | (((unsigned long) (field [1])) << 16)
517 | (((unsigned long) (field [0])) << 24);
520 /* Although we are extracing data from an 8 byte wide field, we
521 are returning only 4 bytes of data. */
522 return ((unsigned long) (field [7]))
523 | (((unsigned long) (field [6])) << 8)
524 | (((unsigned long) (field [5])) << 16)
525 | (((unsigned long) (field [4])) << 24);
529 /* This is a special case, generated by the BYTE_GET8 macro.
530 It means that we are loading an 8 byte value from a field
531 in an external structure into an 8 byte value in a field
532 in an internal strcuture. */
533 return ((bfd_vma) (field [7]))
534 | (((bfd_vma) (field [6])) << 8)
535 | (((bfd_vma) (field [5])) << 16)
536 | (((bfd_vma) (field [4])) << 24)
537 | (((bfd_vma) (field [3])) << 32)
538 | (((bfd_vma) (field [2])) << 40)
539 | (((bfd_vma) (field [1])) << 48)
540 | (((bfd_vma) (field [0])) << 56);
544 error (_("Unhandled data length: %d\n"), size);
549 /* Guess the relocation size commonly used by the specific machines. */
552 guess_is_rela (e_machine)
553 unsigned long e_machine;
557 /* Targets that use REL relocations. */
568 /* Targets that use RELA relocations. */
576 case EM_CYGNUS_MN10200:
577 case EM_CYGNUS_MN10300:
610 warn (_("Don't know about relocations on this machine architecture\n"));
616 slurp_rela_relocs (file, rel_offset, rel_size, relasp, nrelasp)
618 unsigned long rel_offset;
619 unsigned long rel_size;
620 Elf_Internal_Rela **relasp;
621 unsigned long *nrelasp;
623 Elf_Internal_Rela *relas;
624 unsigned long nrelas;
629 Elf32_External_Rela * erelas;
631 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
632 Elf32_External_Rela *, "relocs");
634 nrelas = rel_size / sizeof (Elf32_External_Rela);
636 relas = (Elf_Internal_Rela *)
637 malloc (nrelas * sizeof (Elf_Internal_Rela));
641 error(_("out of memory parsing relocs"));
645 for (i = 0; i < nrelas; i++)
647 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
648 relas[i].r_info = BYTE_GET (erelas[i].r_info);
649 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
656 Elf64_External_Rela * erelas;
658 GET_DATA_ALLOC (rel_offset, rel_size, erelas,
659 Elf64_External_Rela *, "relocs");
661 nrelas = rel_size / sizeof (Elf64_External_Rela);
663 relas = (Elf_Internal_Rela *)
664 malloc (nrelas * sizeof (Elf_Internal_Rela));
668 error(_("out of memory parsing relocs"));
672 for (i = 0; i < nrelas; i++)
674 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
675 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
676 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
687 slurp_rel_relocs (file, rel_offset, rel_size, relsp, nrelsp)
689 unsigned long rel_offset;
690 unsigned long rel_size;
691 Elf_Internal_Rel **relsp;
692 unsigned long *nrelsp;
694 Elf_Internal_Rel *rels;
700 Elf32_External_Rel * erels;
702 GET_DATA_ALLOC (rel_offset, rel_size, erels,
703 Elf32_External_Rel *, "relocs");
705 nrels = rel_size / sizeof (Elf32_External_Rel);
707 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
711 error(_("out of memory parsing relocs"));
715 for (i = 0; i < nrels; i++)
717 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
718 rels[i].r_info = BYTE_GET (erels[i].r_info);
725 Elf64_External_Rel * erels;
727 GET_DATA_ALLOC (rel_offset, rel_size, erels,
728 Elf64_External_Rel *, "relocs");
730 nrels = rel_size / sizeof (Elf64_External_Rel);
732 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
736 error(_("out of memory parsing relocs"));
740 for (i = 0; i < nrels; i++)
742 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
743 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
753 /* Display the contents of the relocation data found at the specified offset. */
755 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
757 unsigned long rel_offset;
758 unsigned long rel_size;
759 Elf_Internal_Sym * symtab;
765 Elf_Internal_Rel * rels;
766 Elf_Internal_Rela * relas;
769 if (is_rela == UNKNOWN)
770 is_rela = guess_is_rela (elf_header.e_machine);
774 if (!slurp_rela_relocs (file, rel_offset, rel_size, &relas, &rel_size))
779 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
785 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
788 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
790 for (i = 0; i < rel_size; i++)
795 bfd_vma symtab_index;
800 offset = relas [i].r_offset;
801 info = relas [i].r_info;
805 offset = rels [i].r_offset;
806 info = rels [i].r_info;
811 type = ELF32_R_TYPE (info);
812 symtab_index = ELF32_R_SYM (info);
816 if (elf_header.e_machine == EM_SPARCV9)
817 type = ELF64_R_TYPE_ID (info);
819 type = ELF64_R_TYPE (info);
820 /* The #ifdef BFD64 below is to prevent a compile time warning.
821 We know that if we do not have a 64 bit data type that we
822 will never execute this code anyway. */
824 symtab_index = ELF64_R_SYM (info);
828 #ifdef _bfd_int64_low
829 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
831 printf (" %8.8lx %5.5lx ", offset, info);
834 switch (elf_header.e_machine)
841 rtype = elf_m32r_reloc_type (type);
846 rtype = elf_i386_reloc_type (type);
850 rtype = elf_m68k_reloc_type (type);
854 rtype = elf_i960_reloc_type (type);
858 rtype = elf_avr_reloc_type (type);
865 rtype = elf_sparc_reloc_type (type);
869 rtype = v850_reloc_type (type);
873 rtype = elf_d10v_reloc_type (type);
877 rtype = elf_d30v_reloc_type (type);
881 rtype = elf_sh_reloc_type (type);
884 case EM_CYGNUS_MN10300:
885 rtype = elf_mn10300_reloc_type (type);
888 case EM_CYGNUS_MN10200:
889 rtype = elf_mn10200_reloc_type (type);
893 rtype = elf_fr30_reloc_type (type);
897 rtype = elf_mcore_reloc_type (type);
901 rtype = elf_ppc_reloc_type (type);
906 rtype = elf_mips_reloc_type (type);
910 rtype = elf_alpha_reloc_type (type);
914 rtype = elf_arm_reloc_type (type);
919 rtype = elf_arc_reloc_type (type);
923 rtype = elf_hppa_reloc_type (type);
927 rtype = elf_pj_reloc_type (type);
930 rtype = elf_ia64_reloc_type (type);
934 rtype = elf_cris_reloc_type (type);
938 rtype = elf_i860_reloc_type (type);
942 rtype = elf_x86_64_reloc_type (type);
947 rtype = elf_s390_reloc_type (type);
952 #ifdef _bfd_int64_low
953 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type));
955 printf (_("unrecognised: %-7lx"), type);
958 printf ("%-21.21s", rtype);
964 if (symtab_index >= nsyms)
965 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
968 Elf_Internal_Sym * psym;
970 psym = symtab + symtab_index;
973 print_vma (psym->st_value, LONG_HEX);
976 if (psym->st_name == 0)
978 SECTION_NAME (section_headers + psym->st_shndx));
979 else if (strtab == NULL)
980 printf (_("<string table index %3ld>"), psym->st_name);
982 printf ("%-25.25s", strtab + psym->st_name);
985 printf (" + %lx", (unsigned long) relas [i].r_addend);
991 printf ("%*c", is_32bit_elf ? 34 : 26, ' ');
992 print_vma (relas[i].r_addend, LONG_HEX);
995 if (elf_header.e_machine == EM_SPARCV9
996 && !strcmp (rtype, "R_SPARC_OLO10"))
997 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1011 get_mips_dynamic_type (type)
1016 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1017 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1018 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1019 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1020 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1021 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1022 case DT_MIPS_MSYM: return "MIPS_MSYM";
1023 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1024 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1025 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1026 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1027 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1028 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1029 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1030 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1031 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1032 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1033 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1034 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1035 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1036 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1037 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1038 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1039 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1040 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1041 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1042 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1043 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1044 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1045 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1046 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1047 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1048 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1049 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1050 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1051 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1052 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1053 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1054 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1055 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1056 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1057 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1058 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1065 get_sparc64_dynamic_type (type)
1070 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1077 get_parisc_dynamic_type (type)
1082 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1083 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1084 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1085 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1086 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1087 case DT_HP_PREINIT: return "HP_PREINIT";
1088 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1089 case DT_HP_NEEDED: return "HP_NEEDED";
1090 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1091 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1092 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1093 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1094 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1101 get_dynamic_type (type)
1104 static char buff [32];
1108 case DT_NULL: return "NULL";
1109 case DT_NEEDED: return "NEEDED";
1110 case DT_PLTRELSZ: return "PLTRELSZ";
1111 case DT_PLTGOT: return "PLTGOT";
1112 case DT_HASH: return "HASH";
1113 case DT_STRTAB: return "STRTAB";
1114 case DT_SYMTAB: return "SYMTAB";
1115 case DT_RELA: return "RELA";
1116 case DT_RELASZ: return "RELASZ";
1117 case DT_RELAENT: return "RELAENT";
1118 case DT_STRSZ: return "STRSZ";
1119 case DT_SYMENT: return "SYMENT";
1120 case DT_INIT: return "INIT";
1121 case DT_FINI: return "FINI";
1122 case DT_SONAME: return "SONAME";
1123 case DT_RPATH: return "RPATH";
1124 case DT_SYMBOLIC: return "SYMBOLIC";
1125 case DT_REL: return "REL";
1126 case DT_RELSZ: return "RELSZ";
1127 case DT_RELENT: return "RELENT";
1128 case DT_PLTREL: return "PLTREL";
1129 case DT_DEBUG: return "DEBUG";
1130 case DT_TEXTREL: return "TEXTREL";
1131 case DT_JMPREL: return "JMPREL";
1132 case DT_BIND_NOW: return "BIND_NOW";
1133 case DT_INIT_ARRAY: return "INIT_ARRAY";
1134 case DT_FINI_ARRAY: return "FINI_ARRAY";
1135 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1136 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1137 case DT_RUNPATH: return "RUNPATH";
1138 case DT_FLAGS: return "FLAGS";
1140 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1141 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1143 case DT_CHECKSUM: return "CHECKSUM";
1144 case DT_PLTPADSZ: return "PLTPADSZ";
1145 case DT_MOVEENT: return "MOVEENT";
1146 case DT_MOVESZ: return "MOVESZ";
1147 case DT_FEATURE: return "FEATURE";
1148 case DT_POSFLAG_1: return "POSFLAG_1";
1149 case DT_SYMINSZ: return "SYMINSZ";
1150 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1152 case DT_ADDRRNGLO: return "ADDRRNGLO";
1153 case DT_CONFIG: return "CONFIG";
1154 case DT_DEPAUDIT: return "DEPAUDIT";
1155 case DT_AUDIT: return "AUDIT";
1156 case DT_PLTPAD: return "PLTPAD";
1157 case DT_MOVETAB: return "MOVETAB";
1158 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1160 case DT_VERSYM: return "VERSYM";
1162 case DT_RELACOUNT: return "RELACOUNT";
1163 case DT_RELCOUNT: return "RELCOUNT";
1164 case DT_FLAGS_1: return "FLAGS_1";
1165 case DT_VERDEF: return "VERDEF";
1166 case DT_VERDEFNUM: return "VERDEFNUM";
1167 case DT_VERNEED: return "VERNEED";
1168 case DT_VERNEEDNUM: return "VERNEEDNUM";
1170 case DT_AUXILIARY: return "AUXILIARY";
1171 case DT_USED: return "USED";
1172 case DT_FILTER: return "FILTER";
1175 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1177 const char * result;
1179 switch (elf_header.e_machine)
1182 case EM_MIPS_RS4_BE:
1183 result = get_mips_dynamic_type (type);
1186 result = get_sparc64_dynamic_type (type);
1196 sprintf (buff, _("Processor Specific: %lx"), type);
1198 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1200 const char * result;
1202 switch (elf_header.e_machine)
1205 result = get_parisc_dynamic_type (type);
1215 sprintf (buff, _("Operating System specific: %lx"), type);
1218 sprintf (buff, _("<unknown>: %lx"), type);
1225 get_file_type (e_type)
1228 static char buff [32];
1232 case ET_NONE: return _("NONE (None)");
1233 case ET_REL: return _("REL (Relocatable file)");
1234 case ET_EXEC: return _("EXEC (Executable file)");
1235 case ET_DYN: return _("DYN (Shared object file)");
1236 case ET_CORE: return _("CORE (Core file)");
1239 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1240 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1241 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1242 sprintf (buff, _("OS Specific: (%x)"), e_type);
1244 sprintf (buff, _("<unknown>: %x"), e_type);
1250 get_machine_name (e_machine)
1253 static char buff [64]; /* XXX */
1257 case EM_NONE: return _("None");
1258 case EM_M32: return "WE32100";
1259 case EM_SPARC: return "Sparc";
1260 case EM_386: return "Intel 80386";
1261 case EM_68K: return "MC68000";
1262 case EM_88K: return "MC88000";
1263 case EM_486: return "Intel 80486";
1264 case EM_860: return "Intel 80860";
1265 case EM_MIPS: return "MIPS R3000";
1266 case EM_S370: return "IBM System/370";
1267 case EM_MIPS_RS4_BE: return "MIPS R4000 big-endian";
1268 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1269 case EM_PARISC: return "HPPA";
1270 case EM_PPC_OLD: return "Power PC (old)";
1271 case EM_SPARC32PLUS: return "Sparc v8+" ;
1272 case EM_960: return "Intel 90860";
1273 case EM_PPC: return "PowerPC";
1274 case EM_V800: return "NEC V800";
1275 case EM_FR20: return "Fujitsu FR20";
1276 case EM_RH32: return "TRW RH32";
1277 case EM_MCORE: return "MCORE";
1278 case EM_ARM: return "ARM";
1279 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1280 case EM_SH: return "Hitachi SH";
1281 case EM_SPARCV9: return "Sparc v9";
1282 case EM_TRICORE: return "Siemens Tricore";
1283 case EM_ARC: return "ARC";
1284 case EM_H8_300: return "Hitachi H8/300";
1285 case EM_H8_300H: return "Hitachi H8/300H";
1286 case EM_H8S: return "Hitachi H8S";
1287 case EM_H8_500: return "Hitachi H8/500";
1288 case EM_IA_64: return "Intel IA-64";
1289 case EM_MIPS_X: return "Stanford MIPS-X";
1290 case EM_COLDFIRE: return "Motorola Coldfire";
1291 case EM_68HC12: return "Motorola M68HC12";
1292 case EM_ALPHA: return "Alpha";
1293 case EM_CYGNUS_D10V: return "d10v";
1294 case EM_CYGNUS_D30V: return "d30v";
1295 case EM_CYGNUS_ARC: return "ARC";
1296 case EM_CYGNUS_M32R: return "Mitsubishi M32r";
1297 case EM_CYGNUS_V850: return "NEC v850";
1298 case EM_CYGNUS_MN10300: return "mn10300";
1299 case EM_CYGNUS_MN10200: return "mn10200";
1300 case EM_CYGNUS_FR30: return "Fujitsu FR30";
1301 case EM_PJ: return "picoJava";
1302 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1303 case EM_PCP: return "Siemens PCP";
1304 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1305 case EM_NDR1: return "Denso NDR1 microprocesspr";
1306 case EM_STARCORE: return "Motorola Star*Core processor";
1307 case EM_ME16: return "Toyota ME16 processor";
1308 case EM_ST100: return "STMicroelectronics ST100 processor";
1309 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1310 case EM_FX66: return "Siemens FX66 microcontroller";
1311 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1312 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1313 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1314 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1315 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1316 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1317 case EM_SVX: return "Silicon Graphics SVx";
1318 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1319 case EM_VAX: return "Digital VAX";
1320 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1321 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1322 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1323 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1324 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1325 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1326 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1327 case EM_PRISM: return "SiTera Prism";
1328 case EM_X86_64: return "Advanced Micro Devices X86-64";
1330 case EM_S390: return "IBM S/390";
1332 sprintf (buff, _("<unknown>: %x"), e_machine);
1338 decode_ARM_machine_flags (e_flags, buf)
1345 eabi = EF_ARM_EABI_VERSION (e_flags);
1346 e_flags &= ~ EF_ARM_EABIMASK;
1348 /* Handle "generic" ARM flags. */
1349 if (e_flags & EF_ARM_RELEXEC)
1351 strcat (buf, ", relocatable executable");
1352 e_flags &= ~ EF_ARM_RELEXEC;
1355 if (e_flags & EF_ARM_HASENTRY)
1357 strcat (buf, ", has entry point");
1358 e_flags &= ~ EF_ARM_HASENTRY;
1361 /* Now handle EABI specific flags. */
1365 strcat (buf, ", <unrecognised EABI>");
1370 case EF_ARM_EABI_VER1:
1371 strcat (buf, ", Version1 EABI");
1376 /* Process flags one bit at a time. */
1377 flag = e_flags & - e_flags;
1382 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1383 strcat (buf, ", sorted symbol tables");
1393 case EF_ARM_EABI_VER2:
1394 strcat (buf, ", Version2 EABI");
1399 /* Process flags one bit at a time. */
1400 flag = e_flags & - e_flags;
1405 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1406 strcat (buf, ", sorted symbol tables");
1409 case EF_ARM_DYNSYMSUSESEGIDX:
1410 strcat (buf, ", dynamic symbols use segment index");
1413 case EF_ARM_MAPSYMSFIRST:
1414 strcat (buf, ", mapping symbols precede others");
1424 case EF_ARM_EABI_UNKNOWN:
1425 strcat (buf, ", GNU EABI");
1430 /* Process flags one bit at a time. */
1431 flag = e_flags & - e_flags;
1436 case EF_ARM_INTERWORK:
1437 strcat (buf, ", interworking enabled");
1440 case EF_ARM_APCS_26:
1441 strcat (buf, ", uses APCS/26");
1444 case EF_ARM_APCS_FLOAT:
1445 strcat (buf, ", uses APCS/float");
1449 strcat (buf, ", position independent");
1453 strcat (buf, ", 8 bit structure alignment");
1456 case EF_ARM_NEW_ABI:
1457 strcat (buf, ", uses new ABI");
1460 case EF_ARM_OLD_ABI:
1461 strcat (buf, ", uses old ABI");
1464 case EF_ARM_SOFT_FLOAT:
1465 strcat (buf, ", software FP");
1476 strcat (buf,", <unknown>");
1480 get_machine_flags (e_flags, e_machine)
1484 static char buf [1024];
1496 decode_ARM_machine_flags (e_flags, buf);
1500 if (e_flags & EF_CPU32)
1501 strcat (buf, ", cpu32");
1505 if (e_flags & EF_PPC_EMB)
1506 strcat (buf, ", emb");
1508 if (e_flags & EF_PPC_RELOCATABLE)
1509 strcat (buf, ", relocatable");
1511 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1512 strcat (buf, ", relocatable-lib");
1515 case EM_CYGNUS_V850:
1516 switch (e_flags & EF_V850_ARCH)
1519 strcat (buf, ", v850e");
1522 strcat (buf, ", v850ea");
1525 strcat (buf, ", v850");
1528 strcat (buf, ", unknown v850 architecture variant");
1533 case EM_CYGNUS_M32R:
1534 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1535 strcat (buf, ", m32r");
1540 case EM_MIPS_RS4_BE:
1541 if (e_flags & EF_MIPS_NOREORDER)
1542 strcat (buf, ", noreorder");
1544 if (e_flags & EF_MIPS_PIC)
1545 strcat (buf, ", pic");
1547 if (e_flags & EF_MIPS_CPIC)
1548 strcat (buf, ", cpic");
1550 if (e_flags & EF_MIPS_ABI2)
1551 strcat (buf, ", abi2");
1553 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
1554 strcat (buf, ", mips1");
1556 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
1557 strcat (buf, ", mips2");
1559 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
1560 strcat (buf, ", mips3");
1562 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
1563 strcat (buf, ", mips4");
1565 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
1566 strcat (buf, ", mips5");
1568 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
1569 strcat (buf, ", mips32");
1571 if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
1572 strcat (buf, ", mips64");
1574 switch ((e_flags & EF_MIPS_MACH))
1576 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1577 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1578 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1579 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1580 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1581 case E_MIPS_MACH_MIPS32_4K: strcat (buf, ", mips32-4k"); break;
1582 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1583 default: strcat (buf, " UNKNOWN"); break;
1588 if (e_flags & EF_SPARC_32PLUS)
1589 strcat (buf, ", v8+");
1591 if (e_flags & EF_SPARC_SUN_US1)
1592 strcat (buf, ", ultrasparcI");
1594 if (e_flags & EF_SPARC_SUN_US3)
1595 strcat (buf, ", ultrasparcIII");
1597 if (e_flags & EF_SPARC_HAL_R1)
1598 strcat (buf, ", halr1");
1600 if (e_flags & EF_SPARC_LEDATA)
1601 strcat (buf, ", ledata");
1603 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1604 strcat (buf, ", tso");
1606 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1607 strcat (buf, ", pso");
1609 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1610 strcat (buf, ", rmo");
1614 switch (e_flags & EF_PARISC_ARCH)
1616 case EFA_PARISC_1_0:
1617 strcpy (buf, ", PA-RISC 1.0");
1619 case EFA_PARISC_1_1:
1620 strcpy (buf, ", PA-RISC 1.1");
1622 case EFA_PARISC_2_0:
1623 strcpy (buf, ", PA-RISC 2.0");
1628 if (e_flags & EF_PARISC_TRAPNIL)
1629 strcat (buf, ", trapnil");
1630 if (e_flags & EF_PARISC_EXT)
1631 strcat (buf, ", ext");
1632 if (e_flags & EF_PARISC_LSB)
1633 strcat (buf, ", lsb");
1634 if (e_flags & EF_PARISC_WIDE)
1635 strcat (buf, ", wide");
1636 if (e_flags & EF_PARISC_NO_KABP)
1637 strcat (buf, ", no kabp");
1638 if (e_flags & EF_PARISC_LAZYSWAP)
1639 strcat (buf, ", lazyswap");
1643 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1644 strcat (buf, ", new calling convention");
1646 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1647 strcat (buf, ", gnu calling convention");
1651 if ((e_flags & EF_IA_64_ABI64))
1652 strcat (buf, ", 64-bit");
1654 strcat (buf, ", 32-bit");
1655 if ((e_flags & EF_IA_64_REDUCEDFP))
1656 strcat (buf, ", reduced fp model");
1657 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
1658 strcat (buf, ", no function descriptors, constant gp");
1659 else if ((e_flags & EF_IA_64_CONS_GP))
1660 strcat (buf, ", constant gp");
1661 if ((e_flags & EF_IA_64_ABSOLUTE))
1662 strcat (buf, ", absolute");
1671 get_mips_segment_type (type)
1676 case PT_MIPS_REGINFO:
1678 case PT_MIPS_RTPROC:
1680 case PT_MIPS_OPTIONS:
1690 get_parisc_segment_type (type)
1695 case PT_HP_TLS: return "HP_TLS";
1696 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1697 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1698 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1699 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1700 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1701 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1702 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1703 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1704 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1705 case PT_HP_PARALLEL: return "HP_PARALLEL";
1706 case PT_HP_FASTBIND: return "HP_FASTBIND";
1707 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1708 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
1717 get_ia64_segment_type (type)
1722 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
1723 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
1732 get_segment_type (p_type)
1733 unsigned long p_type;
1735 static char buff [32];
1739 case PT_NULL: return "NULL";
1740 case PT_LOAD: return "LOAD";
1741 case PT_DYNAMIC: return "DYNAMIC";
1742 case PT_INTERP: return "INTERP";
1743 case PT_NOTE: return "NOTE";
1744 case PT_SHLIB: return "SHLIB";
1745 case PT_PHDR: return "PHDR";
1748 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
1750 const char * result;
1752 switch (elf_header.e_machine)
1755 case EM_MIPS_RS4_BE:
1756 result = get_mips_segment_type (p_type);
1759 result = get_parisc_segment_type (p_type);
1762 result = get_ia64_segment_type (p_type);
1772 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
1774 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
1776 const char * result;
1778 switch (elf_header.e_machine)
1781 result = get_parisc_segment_type (p_type);
1791 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
1794 sprintf (buff, _("<unknown>: %lx"), p_type);
1801 get_mips_section_type_name (sh_type)
1802 unsigned int sh_type;
1806 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1807 case SHT_MIPS_MSYM: return "MIPS_MSYM";
1808 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1809 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
1810 case SHT_MIPS_UCODE: return "MIPS_UCODE";
1811 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
1812 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
1813 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
1814 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
1815 case SHT_MIPS_RELD: return "MIPS_RELD";
1816 case SHT_MIPS_IFACE: return "MIPS_IFACE";
1817 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
1818 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1819 case SHT_MIPS_SHDR: return "MIPS_SHDR";
1820 case SHT_MIPS_FDESC: return "MIPS_FDESC";
1821 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
1822 case SHT_MIPS_DENSE: return "MIPS_DENSE";
1823 case SHT_MIPS_PDESC: return "MIPS_PDESC";
1824 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
1825 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
1826 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
1827 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
1828 case SHT_MIPS_LINE: return "MIPS_LINE";
1829 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
1830 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
1831 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
1832 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
1833 case SHT_MIPS_DWARF: return "MIPS_DWARF";
1834 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
1835 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1836 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
1837 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
1838 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
1839 case SHT_MIPS_XLATE: return "MIPS_XLATE";
1840 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
1841 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
1842 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
1843 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
1844 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
1852 get_parisc_section_type_name (sh_type)
1853 unsigned int sh_type;
1857 case SHT_PARISC_EXT: return "PARISC_EXT";
1858 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
1859 case SHT_PARISC_DOC: return "PARISC_DOC";
1867 get_ia64_section_type_name (sh_type)
1868 unsigned int sh_type;
1872 case SHT_IA_64_EXT: return "IA_64_EXT";
1873 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
1881 get_section_type_name (sh_type)
1882 unsigned int sh_type;
1884 static char buff [32];
1888 case SHT_NULL: return "NULL";
1889 case SHT_PROGBITS: return "PROGBITS";
1890 case SHT_SYMTAB: return "SYMTAB";
1891 case SHT_STRTAB: return "STRTAB";
1892 case SHT_RELA: return "RELA";
1893 case SHT_HASH: return "HASH";
1894 case SHT_DYNAMIC: return "DYNAMIC";
1895 case SHT_NOTE: return "NOTE";
1896 case SHT_NOBITS: return "NOBITS";
1897 case SHT_REL: return "REL";
1898 case SHT_SHLIB: return "SHLIB";
1899 case SHT_DYNSYM: return "DYNSYM";
1900 case SHT_INIT_ARRAY: return "INIT_ARRAY";
1901 case SHT_FINI_ARRAY: return "FINI_ARRAY";
1902 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1903 case SHT_GROUP: return "GROUP";
1904 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
1905 case SHT_GNU_verdef: return "VERDEF";
1906 case SHT_GNU_verneed: return "VERNEED";
1907 case SHT_GNU_versym: return "VERSYM";
1908 case 0x6ffffff0: return "VERSYM";
1909 case 0x6ffffffc: return "VERDEF";
1910 case 0x7ffffffd: return "AUXILIARY";
1911 case 0x7fffffff: return "FILTER";
1914 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
1916 const char * result;
1918 switch (elf_header.e_machine)
1921 case EM_MIPS_RS4_BE:
1922 result = get_mips_section_type_name (sh_type);
1925 result = get_parisc_section_type_name (sh_type);
1928 result = get_ia64_section_type_name (sh_type);
1938 sprintf (buff, "SHT_LOPROC+%x", sh_type - SHT_LOPROC);
1940 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
1941 sprintf (buff, "SHT_LOOS+%x", sh_type - SHT_LOOS);
1942 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
1943 sprintf (buff, "SHT_LOUSER+%x", sh_type - SHT_LOUSER);
1945 sprintf (buff, _("<unknown>: %x"), sh_type);
1951 struct option options [] =
1953 {"all", no_argument, 0, 'a'},
1954 {"file-header", no_argument, 0, 'h'},
1955 {"program-headers", no_argument, 0, 'l'},
1956 {"headers", no_argument, 0, 'e'},
1957 {"histogram", no_argument, 0, 'I'},
1958 {"segments", no_argument, 0, 'l'},
1959 {"sections", no_argument, 0, 'S'},
1960 {"section-headers", no_argument, 0, 'S'},
1961 {"symbols", no_argument, 0, 's'},
1962 {"syms", no_argument, 0, 's'},
1963 {"relocs", no_argument, 0, 'r'},
1964 {"notes", no_argument, 0, 'n'},
1965 {"dynamic", no_argument, 0, 'd'},
1966 {"arch-specific", no_argument, 0, 'A'},
1967 {"version-info", no_argument, 0, 'V'},
1968 {"use-dynamic", no_argument, 0, 'D'},
1969 {"hex-dump", required_argument, 0, 'x'},
1970 {"debug-dump", optional_argument, 0, 'w'},
1971 {"unwind", no_argument, 0, 'u'},
1972 #ifdef SUPPORT_DISASSEMBLY
1973 {"instruction-dump", required_argument, 0, 'i'},
1976 {"version", no_argument, 0, 'v'},
1977 {"help", no_argument, 0, 'H'},
1978 {0, no_argument, 0, 0}
1984 fprintf (stdout, _("Usage: readelf {options} elf-file(s)\n"));
1985 fprintf (stdout, _(" Options are:\n"));
1986 fprintf (stdout, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1987 fprintf (stdout, _(" -h or --file-header Display the ELF file header\n"));
1988 fprintf (stdout, _(" -l or --program-headers or --segments\n"));
1989 fprintf (stdout, _(" Display the program headers\n"));
1990 fprintf (stdout, _(" -S or --section-headers or --sections\n"));
1991 fprintf (stdout, _(" Display the sections' header\n"));
1992 fprintf (stdout, _(" -e or --headers Equivalent to: -h -l -S\n"));
1993 fprintf (stdout, _(" -s or --syms or --symbols Display the symbol table\n"));
1994 fprintf (stdout, _(" -n or --notes Display the core notes (if present)\n"));
1995 fprintf (stdout, _(" -r or --relocs Display the relocations (if present)\n"));
1996 fprintf (stdout, _(" -u or --unwind Display the unwind info (if present)\n"));
1997 fprintf (stdout, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1998 fprintf (stdout, _(" -V or --version-info Display the version sections (if present)\n"));
1999 fprintf (stdout, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
2000 fprintf (stdout, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
2001 fprintf (stdout, _(" -x <number> or --hex-dump=<number>\n"));
2002 fprintf (stdout, _(" Dump the contents of section <number>\n"));
2003 fprintf (stdout, _(" -w[liaprf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=frames]\n"));
2004 fprintf (stdout, _(" Display the contents of DWARF2 debug sections\n"));
2005 #ifdef SUPPORT_DISASSEMBLY
2006 fprintf (stdout, _(" -i <number> or --instruction-dump=<number>\n"));
2007 fprintf (stdout, _(" Disassemble the contents of section <number>\n"));
2009 fprintf (stdout, _(" -I or --histogram Display histogram of bucket list lengths\n"));
2010 fprintf (stdout, _(" -v or --version Display the version number of readelf\n"));
2011 fprintf (stdout, _(" -H or --help Display this information\n"));
2012 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2018 request_dump (section, type)
2019 unsigned int section;
2022 if (section >= num_dump_sects)
2024 char * new_dump_sects;
2026 new_dump_sects = (char *) calloc (section + 1, 1);
2028 if (new_dump_sects == NULL)
2029 error (_("Out of memory allocating dump request table."));
2032 /* Copy current flag settings. */
2033 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2037 dump_sects = new_dump_sects;
2038 num_dump_sects = section + 1;
2043 dump_sects [section] |= type;
2049 parse_args (argc, argv)
2058 while ((c = getopt_long
2059 (argc, argv, "ersuahnldSDAIw::x:i:vV", options, NULL)) != EOF)
2095 do_using_dynamic ++;
2126 section = strtoul (optarg, & cp, 0);
2127 if (! * cp && section >= 0)
2129 request_dump (section, HEX_DUMP);
2149 do_debug_abbrevs = 1;
2159 do_debug_pubnames = 1;
2164 do_debug_aranges = 1;
2169 do_debug_frames = 1;
2173 warn (_("Unrecognised debug option '%s'\n"), optarg);
2178 #ifdef SUPPORT_DISASSEMBLY
2181 section = strtoul (optarg, & cp, 0);
2182 if (! * cp && section >= 0)
2184 request_dump (section, DISASS_DUMP);
2190 print_version (program_name);
2197 /* xgettext:c-format */
2198 error (_("Invalid option '-%c'\n"), c);
2205 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2206 && !do_segments && !do_header && !do_dump && !do_version
2207 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2211 warn (_("Nothing to do.\n"));
2217 get_elf_class (elf_class)
2218 unsigned char elf_class;
2220 static char buff [32];
2224 case ELFCLASSNONE: return _("none");
2225 case ELFCLASS32: return _("ELF32");
2226 case ELFCLASS64: return _("ELF64");
2228 sprintf (buff, _("<unknown: %x>"), elf_class);
2234 get_data_encoding (encoding)
2235 unsigned char encoding;
2237 static char buff [32];
2241 case ELFDATANONE: return _("none");
2242 case ELFDATA2LSB: return _("2's complement, little endian");
2243 case ELFDATA2MSB: return _("2's complement, big endian");
2245 sprintf (buff, _("<unknown: %x>"), encoding);
2251 get_osabi_name (osabi)
2252 unsigned char osabi;
2254 static char buff [32];
2258 case ELFOSABI_NONE: return _("UNIX - System V");
2259 case ELFOSABI_HPUX: return _("UNIX - HP-UX");
2260 case ELFOSABI_NETBSD: return _("UNIX - NetBSD");
2261 case ELFOSABI_LINUX: return _("UNIX - Linux");
2262 case ELFOSABI_HURD: return _("GNU/Hurd");
2263 case ELFOSABI_SOLARIS: return _("UNIX - Solaris");
2264 case ELFOSABI_AIX: return _("UNIX - AIX");
2265 case ELFOSABI_IRIX: return _("UNIX - IRIX");
2266 case ELFOSABI_FREEBSD: return _("UNIX - FreeBSD");
2267 case ELFOSABI_TRU64: return _("UNIX - TRU64");
2268 case ELFOSABI_MODESTO: return _("Novell - Modesto");
2269 case ELFOSABI_OPENBSD: return _("UNIX - OpenBSD");
2270 case ELFOSABI_STANDALONE: return _("Standalone App");
2271 case ELFOSABI_ARM: return _("ARM");
2273 sprintf (buff, _("<unknown: %x>"), osabi);
2278 /* Decode the data held in 'elf_header'. */
2280 process_file_header ()
2282 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2283 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2284 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2285 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2288 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2296 printf (_("ELF Header:\n"));
2297 printf (_(" Magic: "));
2298 for (i = 0; i < EI_NIDENT; i ++)
2299 printf ("%2.2x ", elf_header.e_ident [i]);
2301 printf (_(" Class: %s\n"),
2302 get_elf_class (elf_header.e_ident [EI_CLASS]));
2303 printf (_(" Data: %s\n"),
2304 get_data_encoding (elf_header.e_ident [EI_DATA]));
2305 printf (_(" Version: %d %s\n"),
2306 elf_header.e_ident [EI_VERSION],
2307 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2309 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2312 printf (_(" OS/ABI: %s\n"),
2313 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2314 printf (_(" ABI Version: %d\n"),
2315 elf_header.e_ident [EI_ABIVERSION]);
2316 printf (_(" Type: %s\n"),
2317 get_file_type (elf_header.e_type));
2318 printf (_(" Machine: %s\n"),
2319 get_machine_name (elf_header.e_machine));
2320 printf (_(" Version: 0x%lx\n"),
2321 (unsigned long) elf_header.e_version);
2323 printf (_(" Entry point address: "));
2324 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2325 printf (_("\n Start of program headers: "));
2326 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2327 printf (_(" (bytes into file)\n Start of section headers: "));
2328 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2329 printf (_(" (bytes into file)\n"));
2331 printf (_(" Flags: 0x%lx%s\n"),
2332 (unsigned long) elf_header.e_flags,
2333 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2334 printf (_(" Size of this header: %ld (bytes)\n"),
2335 (long) elf_header.e_ehsize);
2336 printf (_(" Size of program headers: %ld (bytes)\n"),
2337 (long) elf_header.e_phentsize);
2338 printf (_(" Number of program headers: %ld\n"),
2339 (long) elf_header.e_phnum);
2340 printf (_(" Size of section headers: %ld (bytes)\n"),
2341 (long) elf_header.e_shentsize);
2342 printf (_(" Number of section headers: %ld\n"),
2343 (long) elf_header.e_shnum);
2344 printf (_(" Section header string table index: %ld\n"),
2345 (long) elf_header.e_shstrndx);
2353 get_32bit_program_headers (file, program_headers)
2355 Elf_Internal_Phdr * program_headers;
2357 Elf32_External_Phdr * phdrs;
2358 Elf32_External_Phdr * external;
2359 Elf32_Internal_Phdr * internal;
2362 GET_DATA_ALLOC (elf_header.e_phoff,
2363 elf_header.e_phentsize * elf_header.e_phnum,
2364 phdrs, Elf32_External_Phdr *, "program headers");
2366 for (i = 0, internal = program_headers, external = phdrs;
2367 i < elf_header.e_phnum;
2368 i ++, internal ++, external ++)
2370 internal->p_type = BYTE_GET (external->p_type);
2371 internal->p_offset = BYTE_GET (external->p_offset);
2372 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2373 internal->p_paddr = BYTE_GET (external->p_paddr);
2374 internal->p_filesz = BYTE_GET (external->p_filesz);
2375 internal->p_memsz = BYTE_GET (external->p_memsz);
2376 internal->p_flags = BYTE_GET (external->p_flags);
2377 internal->p_align = BYTE_GET (external->p_align);
2386 get_64bit_program_headers (file, program_headers)
2388 Elf_Internal_Phdr * program_headers;
2390 Elf64_External_Phdr * phdrs;
2391 Elf64_External_Phdr * external;
2392 Elf64_Internal_Phdr * internal;
2395 GET_DATA_ALLOC (elf_header.e_phoff,
2396 elf_header.e_phentsize * elf_header.e_phnum,
2397 phdrs, Elf64_External_Phdr *, "program headers");
2399 for (i = 0, internal = program_headers, external = phdrs;
2400 i < elf_header.e_phnum;
2401 i ++, internal ++, external ++)
2403 internal->p_type = BYTE_GET (external->p_type);
2404 internal->p_flags = BYTE_GET (external->p_flags);
2405 internal->p_offset = BYTE_GET8 (external->p_offset);
2406 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2407 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2408 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2409 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2410 internal->p_align = BYTE_GET8 (external->p_align);
2419 process_program_headers (file)
2422 Elf_Internal_Phdr * program_headers;
2423 Elf_Internal_Phdr * segment;
2426 if (elf_header.e_phnum == 0)
2429 printf (_("\nThere are no program headers in this file.\n"));
2433 if (do_segments && !do_header)
2435 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2436 printf (_("Entry point "));
2437 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2438 printf (_("\nThere are %d program headers, starting at offset "),
2439 elf_header.e_phnum);
2440 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2444 program_headers = (Elf_Internal_Phdr *) malloc
2445 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2447 if (program_headers == NULL)
2449 error (_("Out of memory\n"));
2454 i = get_32bit_program_headers (file, program_headers);
2456 i = get_64bit_program_headers (file, program_headers);
2460 free (program_headers);
2467 (_("\nProgram Header%s:\n"), elf_header.e_phnum > 1 ? "s" : "");
2471 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2475 (_(" Type Offset VirtAddr PhysAddr\n"));
2477 (_(" FileSiz MemSiz Flags Align\n"));
2485 for (i = 0, segment = program_headers;
2486 i < elf_header.e_phnum;
2491 printf (" %-14.14s ", get_segment_type (segment->p_type));
2495 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2496 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2497 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2498 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2499 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2501 (segment->p_flags & PF_R ? 'R' : ' '),
2502 (segment->p_flags & PF_W ? 'W' : ' '),
2503 (segment->p_flags & PF_X ? 'E' : ' '));
2504 printf ("%#lx", (unsigned long) segment->p_align);
2508 print_vma (segment->p_offset, FULL_HEX);
2510 print_vma (segment->p_vaddr, FULL_HEX);
2512 print_vma (segment->p_paddr, FULL_HEX);
2514 print_vma (segment->p_filesz, FULL_HEX);
2516 print_vma (segment->p_memsz, FULL_HEX);
2518 (segment->p_flags & PF_R ? 'R' : ' '),
2519 (segment->p_flags & PF_W ? 'W' : ' '),
2520 (segment->p_flags & PF_X ? 'E' : ' '));
2521 print_vma (segment->p_align, HEX);
2525 switch (segment->p_type)
2529 loadaddr = (segment->p_vaddr & 0xfffff000)
2530 - (segment->p_offset & 0xfffff000);
2535 error (_("more than one dynamic segment\n"));
2537 dynamic_addr = segment->p_offset;
2538 dynamic_size = segment->p_filesz;
2542 if (fseek (file, (long) segment->p_offset, SEEK_SET))
2543 error (_("Unable to find program interpreter name\n"));
2546 program_interpreter[0] = 0;
2547 fscanf (file, "%63s", program_interpreter);
2550 printf (_("\n [Requesting program interpreter: %s]"),
2551 program_interpreter);
2557 putc ('\n', stdout);
2566 if (do_segments && section_headers != NULL)
2568 printf (_("\n Section to Segment mapping:\n"));
2569 printf (_(" Segment Sections...\n"));
2571 assert (string_table != NULL);
2573 for (i = 0; i < elf_header.e_phnum; i++)
2576 Elf_Internal_Shdr * section;
2578 segment = program_headers + i;
2579 section = section_headers;
2581 printf (" %2.2d ", i);
2583 for (j = 0; j < elf_header.e_shnum; j++, section ++)
2585 if (section->sh_size > 0
2586 /* Compare allocated sections by VMA, unallocated
2587 sections by file offset. */
2588 && (section->sh_flags & SHF_ALLOC
2589 ? (section->sh_addr >= segment->p_vaddr
2590 && section->sh_addr + section->sh_size
2591 <= segment->p_vaddr + segment->p_memsz)
2592 : ((bfd_vma) section->sh_offset >= segment->p_offset
2593 && (section->sh_offset + section->sh_size
2594 <= segment->p_offset + segment->p_filesz))))
2595 printf ("%s ", SECTION_NAME (section));
2602 free (program_headers);
2609 get_32bit_section_headers (file)
2612 Elf32_External_Shdr * shdrs;
2613 Elf32_Internal_Shdr * internal;
2616 GET_DATA_ALLOC (elf_header.e_shoff,
2617 elf_header.e_shentsize * elf_header.e_shnum,
2618 shdrs, Elf32_External_Shdr *, "section headers");
2620 section_headers = (Elf_Internal_Shdr *) malloc
2621 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2623 if (section_headers == NULL)
2625 error (_("Out of memory\n"));
2629 for (i = 0, internal = section_headers;
2630 i < elf_header.e_shnum;
2633 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2634 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2635 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
2636 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
2637 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2638 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
2639 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2640 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2641 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2642 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
2651 get_64bit_section_headers (file)
2654 Elf64_External_Shdr * shdrs;
2655 Elf64_Internal_Shdr * internal;
2658 GET_DATA_ALLOC (elf_header.e_shoff,
2659 elf_header.e_shentsize * elf_header.e_shnum,
2660 shdrs, Elf64_External_Shdr *, "section headers");
2662 section_headers = (Elf_Internal_Shdr *) malloc
2663 (elf_header.e_shnum * sizeof (Elf_Internal_Shdr));
2665 if (section_headers == NULL)
2667 error (_("Out of memory\n"));
2671 for (i = 0, internal = section_headers;
2672 i < elf_header.e_shnum;
2675 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
2676 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
2677 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
2678 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
2679 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
2680 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
2681 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
2682 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
2683 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
2684 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
2692 static Elf_Internal_Sym *
2693 get_32bit_elf_symbols (file, offset, number)
2695 unsigned long offset;
2696 unsigned long number;
2698 Elf32_External_Sym * esyms;
2699 Elf_Internal_Sym * isyms;
2700 Elf_Internal_Sym * psym;
2703 GET_DATA_ALLOC (offset, number * sizeof (Elf32_External_Sym),
2704 esyms, Elf32_External_Sym *, "symbols");
2706 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2710 error (_("Out of memory\n"));
2716 for (j = 0, psym = isyms;
2720 psym->st_name = BYTE_GET (esyms[j].st_name);
2721 psym->st_value = BYTE_GET (esyms[j].st_value);
2722 psym->st_size = BYTE_GET (esyms[j].st_size);
2723 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2724 psym->st_info = BYTE_GET (esyms[j].st_info);
2725 psym->st_other = BYTE_GET (esyms[j].st_other);
2733 static Elf_Internal_Sym *
2734 get_64bit_elf_symbols (file, offset, number)
2736 unsigned long offset;
2737 unsigned long number;
2739 Elf64_External_Sym * esyms;
2740 Elf_Internal_Sym * isyms;
2741 Elf_Internal_Sym * psym;
2744 GET_DATA_ALLOC (offset, number * sizeof (Elf64_External_Sym),
2745 esyms, Elf64_External_Sym *, "symbols");
2747 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
2751 error (_("Out of memory\n"));
2757 for (j = 0, psym = isyms;
2761 psym->st_name = BYTE_GET (esyms[j].st_name);
2762 psym->st_info = BYTE_GET (esyms[j].st_info);
2763 psym->st_other = BYTE_GET (esyms[j].st_other);
2764 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
2765 psym->st_value = BYTE_GET8 (esyms[j].st_value);
2766 psym->st_size = BYTE_GET8 (esyms[j].st_size);
2775 get_elf_section_flags (sh_flags)
2778 static char buff [32];
2786 flag = sh_flags & - sh_flags;
2791 case SHF_WRITE: strcat (buff, "W"); break;
2792 case SHF_ALLOC: strcat (buff, "A"); break;
2793 case SHF_EXECINSTR: strcat (buff, "X"); break;
2794 case SHF_MERGE: strcat (buff, "M"); break;
2795 case SHF_STRINGS: strcat (buff, "S"); break;
2796 case SHF_INFO_LINK: strcat (buff, "I"); break;
2797 case SHF_LINK_ORDER: strcat (buff, "L"); break;
2798 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
2799 case SHF_GROUP: strcat (buff, "G"); break;
2802 if (flag & SHF_MASKOS)
2805 sh_flags &= ~ SHF_MASKOS;
2807 else if (flag & SHF_MASKPROC)
2810 sh_flags &= ~ SHF_MASKPROC;
2822 process_section_headers (file)
2825 Elf_Internal_Shdr * section;
2828 section_headers = NULL;
2830 if (elf_header.e_shnum == 0)
2833 printf (_("\nThere are no sections in this file.\n"));
2838 if (do_sections && !do_header)
2839 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2840 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
2844 if (! get_32bit_section_headers (file))
2847 else if (! get_64bit_section_headers (file))
2850 /* Read in the string table, so that we have names to display. */
2851 section = section_headers + elf_header.e_shstrndx;
2853 if (section->sh_size != 0)
2855 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2856 string_table, char *, "string table");
2858 string_table_length = section->sh_size;
2861 /* Scan the sections for the dynamic symbol table
2862 and dynamic string table and debug sections. */
2863 dynamic_symbols = NULL;
2864 dynamic_strings = NULL;
2865 dynamic_syminfo = NULL;
2867 for (i = 0, section = section_headers;
2868 i < elf_header.e_shnum;
2871 char * name = SECTION_NAME (section);
2873 if (section->sh_type == SHT_DYNSYM)
2875 if (dynamic_symbols != NULL)
2877 error (_("File contains multiple dynamic symbol tables\n"));
2881 num_dynamic_syms = section->sh_size / section->sh_entsize;
2883 GET_ELF_SYMBOLS (file, section->sh_offset, num_dynamic_syms);
2885 else if (section->sh_type == SHT_STRTAB
2886 && strcmp (name, ".dynstr") == 0)
2888 if (dynamic_strings != NULL)
2890 error (_("File contains multiple dynamic string tables\n"));
2894 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
2895 dynamic_strings, char *, "dynamic strings");
2897 else if ((do_debugging || do_debug_info || do_debug_abbrevs
2898 || do_debug_lines || do_debug_pubnames || do_debug_aranges || do_debug_frames)
2899 && strncmp (name, ".debug_", 7) == 0)
2904 || (do_debug_info && (strcmp (name, "info") == 0))
2905 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
2906 || (do_debug_lines && (strcmp (name, "line") == 0))
2907 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
2908 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
2909 || (do_debug_frames && (strcmp (name, "frame") == 0))
2911 request_dump (i, DEBUG_DUMP);
2913 /* linkonce section to be combined with .debug_info at link time. */
2914 else if ((do_debugging || do_debug_info)
2915 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
2916 request_dump (i, DEBUG_DUMP);
2917 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
2918 request_dump (i, DEBUG_DUMP);
2924 printf (_("\nSection Header%s:\n"), elf_header.e_shnum > 1 ? "s" : "");
2928 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2931 printf (_(" [Nr] Name Type Address Offset\n"));
2932 printf (_(" Size EntSize Flags Link Info Align\n"));
2935 for (i = 0, section = section_headers;
2936 i < elf_header.e_shnum;
2939 printf (" [%2d] %-17.17s %-15.15s ",
2941 SECTION_NAME (section),
2942 get_section_type_name (section->sh_type));
2946 print_vma (section->sh_addr, LONG_HEX);
2948 printf ( " %6.6lx %6.6lx %2.2lx",
2949 (unsigned long) section->sh_offset,
2950 (unsigned long) section->sh_size,
2951 (unsigned long) section->sh_entsize);
2953 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2955 printf ("%2ld %3lx %2ld\n",
2956 (unsigned long) section->sh_link,
2957 (unsigned long) section->sh_info,
2958 (unsigned long) section->sh_addralign);
2963 print_vma (section->sh_addr, LONG_HEX);
2964 printf (" %8.8lx", section->sh_offset);
2966 print_vma (section->sh_size, LONG_HEX);
2968 print_vma (section->sh_entsize, LONG_HEX);
2970 printf (" %3s ", get_elf_section_flags (section->sh_flags));
2972 printf (" %2ld %3lx %ld\n",
2973 (unsigned long) section->sh_link,
2974 (unsigned long) section->sh_info,
2975 (unsigned long) section->sh_addralign);
2979 printf (_("Key to Flags:\n"));
2980 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2981 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
2982 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
2987 /* Process the reloc section. */
2989 process_relocs (file)
2992 unsigned long rel_size;
2993 unsigned long rel_offset;
2999 if (do_using_dynamic)
3001 int is_rela = FALSE;
3006 if (dynamic_info[DT_REL])
3008 rel_offset = dynamic_info[DT_REL];
3009 rel_size = dynamic_info[DT_RELSZ];
3012 else if (dynamic_info [DT_RELA])
3014 rel_offset = dynamic_info[DT_RELA];
3015 rel_size = dynamic_info[DT_RELASZ];
3018 else if (dynamic_info[DT_JMPREL])
3020 rel_offset = dynamic_info[DT_JMPREL];
3021 rel_size = dynamic_info[DT_PLTRELSZ];
3023 switch (dynamic_info[DT_PLTREL])
3040 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3041 rel_offset, rel_size);
3043 dump_relocations (file, rel_offset - loadaddr, rel_size,
3044 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3047 printf (_("\nThere are no dynamic relocations in this file.\n"));
3051 Elf32_Internal_Shdr * section;
3055 for (i = 0, section = section_headers;
3056 i < elf_header.e_shnum;
3059 if ( section->sh_type != SHT_RELA
3060 && section->sh_type != SHT_REL)
3063 rel_offset = section->sh_offset;
3064 rel_size = section->sh_size;
3068 Elf32_Internal_Shdr * strsec;
3069 Elf32_Internal_Shdr * symsec;
3070 Elf_Internal_Sym * symtab;
3073 unsigned long nsyms;
3075 printf (_("\nRelocation section "));
3077 if (string_table == NULL)
3078 printf ("%d", section->sh_name);
3080 printf ("'%s'", SECTION_NAME (section));
3082 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3083 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3085 symsec = section_headers + section->sh_link;
3087 nsyms = symsec->sh_size / symsec->sh_entsize;
3088 symtab = GET_ELF_SYMBOLS (file, symsec->sh_offset, nsyms);
3093 strsec = section_headers + symsec->sh_link;
3095 GET_DATA_ALLOC (strsec->sh_offset, strsec->sh_size, strtab,
3096 char *, "string table");
3098 is_rela = section->sh_type == SHT_RELA;
3100 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela);
3110 printf (_("\nThere are no relocations in this file.\n"));
3116 #include "unwind-ia64.h"
3118 /* An absolute address consists of a section and an offset. If the
3119 section is NULL, the offset itself is the address, otherwise, the
3120 address equals to LOAD_ADDRESS(section) + offset. */
3124 unsigned short section;
3130 struct unw_table_entry
3132 struct absaddr start;
3134 struct absaddr info;
3136 *table; /* Unwind table. */
3137 unsigned long table_len; /* Length of unwind table. */
3138 unsigned char * info; /* Unwind info. */
3139 unsigned long info_size; /* Size of unwind info. */
3140 bfd_vma info_addr; /* starting address of unwind info. */
3141 bfd_vma seg_base; /* Starting address of segment. */
3142 Elf_Internal_Sym * symtab; /* The symbol table. */
3143 unsigned long nsyms; /* Number of symbols. */
3144 char * strtab; /* The string table. */
3145 unsigned long strtab_size; /* Size of string table. */
3148 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3149 struct absaddr, const char **,
3151 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3152 static int slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3153 Elf32_Internal_Shdr *));
3156 find_symbol_for_address (aux, addr, symname, offset)
3157 struct unw_aux_info *aux;
3158 struct absaddr addr;
3159 const char **symname;
3162 bfd_vma dist = (bfd_vma) 0x100000;
3163 Elf_Internal_Sym *sym, *best = NULL;
3166 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3168 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3169 && sym->st_name != 0
3170 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3171 && addr.offset >= sym->st_value
3172 && addr.offset - sym->st_value < dist)
3175 dist = addr.offset - sym->st_value;
3182 *symname = (best->st_name >= aux->strtab_size
3183 ? "<corrupt>" : aux->strtab + best->st_name);
3188 *offset = addr.offset;
3192 dump_ia64_unwind (aux)
3193 struct unw_aux_info *aux;
3196 struct unw_table_entry * tp;
3199 addr_size = is_32bit_elf ? 4 : 8;
3201 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3205 const unsigned char * dp;
3206 const unsigned char * head;
3207 const char * procname;
3209 find_symbol_for_address (aux, tp->start, &procname, &offset);
3211 fputs ("\n<", stdout);
3215 fputs (procname, stdout);
3218 printf ("+%lx", (unsigned long) offset);
3221 fputs (">: [", stdout);
3222 print_vma (tp->start.offset, PREFIX_HEX);
3223 fputc ('-', stdout);
3224 print_vma (tp->end.offset, PREFIX_HEX);
3225 printf ("), info at +0x%lx\n",
3226 (unsigned long) (tp->info.offset - aux->seg_base));
3228 head = aux->info + (tp->info.offset - aux->info_addr);
3229 stamp = BYTE_GET8 ((unsigned char *) head);
3231 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3232 (unsigned) UNW_VER (stamp),
3233 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3234 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3235 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3236 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3238 if (UNW_VER (stamp) != 1)
3240 printf ("\tUnknown version.\n");
3245 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3246 dp = unw_decode (dp, in_body, & in_body);
3251 slurp_ia64_unwind_table (file, aux, sec)
3253 struct unw_aux_info *aux;
3254 Elf32_Internal_Shdr *sec;
3256 unsigned long size, addr_size, nrelas, i;
3257 Elf_Internal_Phdr *prog_hdrs, *seg;
3258 struct unw_table_entry *tep;
3259 Elf32_Internal_Shdr *relsec;
3260 Elf_Internal_Rela *rela, *rp;
3261 unsigned char *table, *tp;
3262 Elf_Internal_Sym *sym;
3263 const char *relname;
3266 addr_size = is_32bit_elf ? 4 : 8;
3268 /* First, find the starting address of the segment that includes
3271 if (elf_header.e_phnum)
3273 prog_hdrs = (Elf_Internal_Phdr *)
3274 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3277 result = get_32bit_program_headers (file, prog_hdrs);
3279 result = get_64bit_program_headers (file, prog_hdrs);
3287 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3289 if (seg->p_type != PT_LOAD)
3292 if (sec->sh_addr >= seg->p_vaddr
3293 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3295 aux->seg_base = seg->p_vaddr;
3303 /* Second, build the unwind table from the contents of the unwind section: */
3304 size = sec->sh_size;
3305 GET_DATA_ALLOC (sec->sh_offset, size, table, char *, "unwind table");
3307 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3308 for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3310 tep->start.section = SHN_UNDEF;
3311 tep->end.section = SHN_UNDEF;
3312 tep->info.section = SHN_UNDEF;
3315 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3316 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
3317 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
3321 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
3322 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
3323 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
3325 tep->start.offset += aux->seg_base;
3326 tep->end.offset += aux->seg_base;
3327 tep->info.offset += aux->seg_base;
3331 /* Third, apply any relocations to the unwind table: */
3333 for (relsec = section_headers;
3334 relsec < section_headers + elf_header.e_shnum;
3337 if (relsec->sh_type != SHT_RELA
3338 || section_headers + relsec->sh_info != sec)
3341 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3345 for (rp = rela; rp < rela + nrelas; ++rp)
3349 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3350 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3352 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3354 warn (_("Skipping unexpected symbol type %u"),
3355 ELF32_ST_TYPE (sym->st_info));
3361 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3362 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3364 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3366 warn (_("Skipping unexpected symbol type %u"),
3367 ELF64_ST_TYPE (sym->st_info));
3372 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
3374 warn (_("Skipping unexpected relocation type %s"), relname);
3378 i = rp->r_offset / (3 * addr_size);
3380 switch (rp->r_offset/addr_size % 3)
3383 aux->table[i].start.section = sym->st_shndx;
3384 aux->table[i].start.offset += rp->r_addend;
3387 aux->table[i].end.section = sym->st_shndx;
3388 aux->table[i].end.offset += rp->r_addend;
3391 aux->table[i].info.section = sym->st_shndx;
3392 aux->table[i].info.offset += rp->r_addend;
3402 aux->table_len = size / (3 * addr_size);
3407 process_unwind (file)
3410 Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
3411 unsigned long i, addr_size;
3412 struct unw_aux_info aux;
3417 if (elf_header.e_machine != EM_IA_64)
3419 printf (_("\nThere are no unwind sections in this file.\n"));
3423 memset (& aux, 0, sizeof (aux));
3425 addr_size = is_32bit_elf ? 4 : 8;
3427 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
3429 if (sec->sh_type == SHT_SYMTAB)
3431 aux.nsyms = sec->sh_size / sec->sh_entsize;
3432 aux.symtab = GET_ELF_SYMBOLS (file, sec->sh_offset, aux.nsyms);
3434 strsec = section_headers + sec->sh_link;
3435 aux.strtab_size = strsec->sh_size;
3436 GET_DATA_ALLOC (strsec->sh_offset, aux.strtab_size,
3437 aux.strtab, char *, "string table");
3439 else if (sec->sh_type == SHT_IA_64_UNWIND)
3441 else if (strcmp (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info) == 0)
3443 aux.info_size = sec->sh_size;
3444 aux.info_addr = sec->sh_addr;
3445 GET_DATA_ALLOC (sec->sh_offset, aux.info_size, aux.info,
3446 char *, "unwind info");
3452 printf (_("\nUnwind section "));
3454 if (string_table == NULL)
3455 printf ("%d", unwsec->sh_name);
3457 printf ("'%s'", SECTION_NAME (unwsec));
3459 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3460 unwsec->sh_offset, (unsigned long) (unwsec->sh_size / (3 * addr_size)));
3462 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
3464 if (aux.table_len > 0)
3465 dump_ia64_unwind (& aux);
3468 printf (_("\nThere are no unwind sections in this file.\n"));
3471 free ((char *) aux.table);
3473 free ((char *) aux.info);
3477 free ((char *) aux.strtab);
3483 dynamic_segment_mips_val (entry)
3484 Elf_Internal_Dyn * entry;
3486 switch (entry->d_tag)
3489 if (entry->d_un.d_val == 0)
3493 static const char * opts[] =
3495 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3496 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3497 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3498 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3503 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
3504 if (entry->d_un.d_val & (1 << cnt))
3506 printf ("%s%s", first ? "" : " ", opts[cnt]);
3513 case DT_MIPS_IVERSION:
3514 if (dynamic_strings != NULL)
3515 printf ("Interface Version: %s\n",
3516 dynamic_strings + entry->d_un.d_val);
3518 printf ("%ld\n", (long) entry->d_un.d_ptr);
3521 case DT_MIPS_TIME_STAMP:
3526 time_t time = entry->d_un.d_val;
3527 tmp = gmtime (&time);
3528 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3529 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3530 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3531 printf ("Time Stamp: %s\n", timebuf);
3535 case DT_MIPS_RLD_VERSION:
3536 case DT_MIPS_LOCAL_GOTNO:
3537 case DT_MIPS_CONFLICTNO:
3538 case DT_MIPS_LIBLISTNO:
3539 case DT_MIPS_SYMTABNO:
3540 case DT_MIPS_UNREFEXTNO:
3541 case DT_MIPS_HIPAGENO:
3542 case DT_MIPS_DELTA_CLASS_NO:
3543 case DT_MIPS_DELTA_INSTANCE_NO:
3544 case DT_MIPS_DELTA_RELOC_NO:
3545 case DT_MIPS_DELTA_SYM_NO:
3546 case DT_MIPS_DELTA_CLASSSYM_NO:
3547 case DT_MIPS_COMPACT_SIZE:
3548 printf ("%ld\n", (long) entry->d_un.d_ptr);
3552 printf ("%#lx\n", (long) entry->d_un.d_ptr);
3558 dynamic_segment_parisc_val (entry)
3559 Elf_Internal_Dyn * entry;
3561 switch (entry->d_tag)
3563 case DT_HP_DLD_FLAGS:
3572 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3573 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3574 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3575 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3576 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3577 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3578 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3579 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3580 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3581 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3582 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3586 bfd_vma val = entry->d_un.d_val;
3588 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3589 if (val & flags[cnt].bit)
3593 fputs (flags[cnt].str, stdout);
3595 val ^= flags[cnt].bit;
3598 if (val != 0 || first)
3602 print_vma (val, HEX);
3608 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3614 get_32bit_dynamic_segment (file)
3617 Elf32_External_Dyn * edyn;
3618 Elf_Internal_Dyn * entry;
3621 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3622 edyn, Elf32_External_Dyn *, "dynamic segment");
3624 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3625 how large this .dynamic is now. We can do this even before the byte
3626 swapping since the DT_NULL tag is recognizable. */
3628 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3631 dynamic_segment = (Elf_Internal_Dyn *)
3632 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3634 if (dynamic_segment == NULL)
3636 error (_("Out of memory\n"));
3641 for (i = 0, entry = dynamic_segment;
3645 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3646 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3655 get_64bit_dynamic_segment (file)
3658 Elf64_External_Dyn * edyn;
3659 Elf_Internal_Dyn * entry;
3662 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3663 edyn, Elf64_External_Dyn *, "dynamic segment");
3665 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3666 how large this .dynamic is now. We can do this even before the byte
3667 swapping since the DT_NULL tag is recognizable. */
3669 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3672 dynamic_segment = (Elf_Internal_Dyn *)
3673 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3675 if (dynamic_segment == NULL)
3677 error (_("Out of memory\n"));
3682 for (i = 0, entry = dynamic_segment;
3686 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3687 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3696 get_dynamic_flags (flags)
3699 static char buff [64];
3704 flag = flags & - flags;
3709 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3710 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3711 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3712 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3713 default: strcat (buff, "unknown "); break;
3719 /* Parse and display the contents of the dynamic segment. */
3721 process_dynamic_segment (file)
3724 Elf_Internal_Dyn * entry;
3727 if (dynamic_size == 0)
3730 printf (_("\nThere is no dynamic segment in this file.\n"));
3737 if (! get_32bit_dynamic_segment (file))
3740 else if (! get_64bit_dynamic_segment (file))
3743 /* Find the appropriate symbol table. */
3744 if (dynamic_symbols == NULL)
3746 for (i = 0, entry = dynamic_segment;
3750 unsigned long offset;
3752 if (entry->d_tag != DT_SYMTAB)
3755 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3757 /* Since we do not know how big the symbol table is,
3758 we default to reading in the entire file (!) and
3759 processing that. This is overkill, I know, but it
3761 offset = entry->d_un.d_val - loadaddr;
3763 if (fseek (file, 0, SEEK_END))
3764 error (_("Unable to seek to end of file!"));
3767 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3769 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3771 if (num_dynamic_syms < 1)
3773 error (_("Unable to determine the number of symbols to load\n"));
3777 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3781 /* Similarly find a string table. */
3782 if (dynamic_strings == NULL)
3784 for (i = 0, entry = dynamic_segment;
3788 unsigned long offset;
3791 if (entry->d_tag != DT_STRTAB)
3794 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3796 /* Since we do not know how big the string table is,
3797 we default to reading in the entire file (!) and
3798 processing that. This is overkill, I know, but it
3801 offset = entry->d_un.d_val - loadaddr;
3802 if (fseek (file, 0, SEEK_END))
3803 error (_("Unable to seek to end of file\n"));
3804 str_tab_len = ftell (file) - offset;
3806 if (str_tab_len < 1)
3809 (_("Unable to determine the length of the dynamic string table\n"));
3813 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3814 "dynamic string table");
3820 /* And find the syminfo section if available. */
3821 if (dynamic_syminfo == NULL)
3823 unsigned int syminsz = 0;
3825 for (i = 0, entry = dynamic_segment;
3829 if (entry->d_tag == DT_SYMINENT)
3831 /* Note: these braces are necessary to avoid a syntax
3832 error from the SunOS4 C compiler. */
3833 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3835 else if (entry->d_tag == DT_SYMINSZ)
3836 syminsz = entry->d_un.d_val;
3837 else if (entry->d_tag == DT_SYMINFO)
3838 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3841 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3843 Elf_External_Syminfo * extsyminfo;
3844 Elf_Internal_Syminfo * syminfo;
3846 /* There is a syminfo section. Read the data. */
3847 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3848 Elf_External_Syminfo *, "symbol information");
3850 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3851 if (dynamic_syminfo == NULL)
3853 error (_("Out of memory\n"));
3857 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3858 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3861 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3862 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3869 if (do_dynamic && dynamic_addr)
3870 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3871 dynamic_addr, (long) dynamic_size);
3873 printf (_(" Tag Type Name/Value\n"));
3875 for (i = 0, entry = dynamic_segment;
3884 print_vma (entry->d_tag, FULL_HEX);
3885 dtype = get_dynamic_type (entry->d_tag);
3886 printf (" (%s)%*s", dtype,
3887 ((is_32bit_elf ? 27 : 19)
3888 - (int) strlen (dtype)),
3892 switch (entry->d_tag)
3896 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3906 switch (entry->d_tag)
3909 printf (_("Auxiliary library"));
3913 printf (_("Filter library"));
3917 printf (_("Configuration file"));
3921 printf (_("Dependency audit library"));
3925 printf (_("Audit library"));
3929 if (dynamic_strings)
3930 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3934 print_vma (entry->d_un.d_val, PREFIX_HEX);
3943 printf (_("Flags:"));
3944 if (entry->d_un.d_val == 0)
3945 printf (_(" None\n"));
3948 unsigned long int val = entry->d_un.d_val;
3949 if (val & DTF_1_PARINIT)
3951 printf (" PARINIT");
3952 val ^= DTF_1_PARINIT;
3954 if (val & DTF_1_CONFEXP)
3956 printf (" CONFEXP");
3957 val ^= DTF_1_CONFEXP;
3960 printf (" %lx", val);
3969 printf (_("Flags:"));
3970 if (entry->d_un.d_val == 0)
3971 printf (_(" None\n"));
3974 unsigned long int val = entry->d_un.d_val;
3975 if (val & DF_P1_LAZYLOAD)
3977 printf (" LAZYLOAD");
3978 val ^= DF_P1_LAZYLOAD;
3980 if (val & DF_P1_GROUPPERM)
3982 printf (" GROUPPERM");
3983 val ^= DF_P1_GROUPPERM;
3986 printf (" %lx", val);
3995 printf (_("Flags:"));
3996 if (entry->d_un.d_val == 0)
3997 printf (_(" None\n"));
4000 unsigned long int val = entry->d_un.d_val;
4006 if (val & DF_1_GLOBAL)
4011 if (val & DF_1_GROUP)
4016 if (val & DF_1_NODELETE)
4018 printf (" NODELETE");
4019 val ^= DF_1_NODELETE;
4021 if (val & DF_1_LOADFLTR)
4023 printf (" LOADFLTR");
4024 val ^= DF_1_LOADFLTR;
4026 if (val & DF_1_INITFIRST)
4028 printf (" INITFIRST");
4029 val ^= DF_1_INITFIRST;
4031 if (val & DF_1_NOOPEN)
4036 if (val & DF_1_ORIGIN)
4041 if (val & DF_1_DIRECT)
4046 if (val & DF_1_TRANS)
4051 if (val & DF_1_INTERPOSE)
4053 printf (" INTERPOSE");
4054 val ^= DF_1_INTERPOSE;
4056 if (val & DF_1_NODEFLIB)
4058 printf (" NODEFLIB");
4059 val ^= DF_1_NODEFLIB;
4061 if (val & DF_1_NODUMP)
4066 if (val & DF_1_CONLFAT)
4068 printf (" CONLFAT");
4069 val ^= DF_1_CONLFAT;
4072 printf (" %lx", val);
4080 puts (get_dynamic_type (entry->d_un.d_val));
4100 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4106 if (dynamic_strings == NULL)
4109 name = dynamic_strings + entry->d_un.d_val;
4113 switch (entry->d_tag)
4116 printf (_("Shared library: [%s]"), name);
4118 if (strcmp (name, program_interpreter) == 0)
4119 printf (_(" program interpreter"));
4123 printf (_("Library soname: [%s]"), name);
4127 printf (_("Library rpath: [%s]"), name);
4131 printf (_("Library runpath: [%s]"), name);
4135 print_vma (entry->d_un.d_val, PREFIX_HEX);
4140 print_vma (entry->d_un.d_val, PREFIX_HEX);
4156 case DT_INIT_ARRAYSZ:
4157 case DT_FINI_ARRAYSZ:
4160 print_vma (entry->d_un.d_val, UNSIGNED);
4161 printf (" (bytes)\n");
4171 print_vma (entry->d_un.d_val, UNSIGNED);
4184 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4188 name = dynamic_strings + entry->d_un.d_val;
4192 printf (_("Not needed object: [%s]\n"), name);
4197 print_vma (entry->d_un.d_val, PREFIX_HEX);
4203 /* The value of this entry is ignored. */
4207 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4208 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4213 switch (elf_header.e_machine)
4216 case EM_MIPS_RS4_BE:
4217 dynamic_segment_mips_val (entry);
4220 dynamic_segment_parisc_val (entry);
4223 print_vma (entry->d_un.d_val, PREFIX_HEX);
4235 get_ver_flags (flags)
4238 static char buff [32];
4245 if (flags & VER_FLG_BASE)
4246 strcat (buff, "BASE ");
4248 if (flags & VER_FLG_WEAK)
4250 if (flags & VER_FLG_BASE)
4251 strcat (buff, "| ");
4253 strcat (buff, "WEAK ");
4256 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4257 strcat (buff, "| <unknown>");
4262 /* Display the contents of the version sections. */
4264 process_version_sections (file)
4267 Elf32_Internal_Shdr * section;
4274 for (i = 0, section = section_headers;
4275 i < elf_header.e_shnum;
4278 switch (section->sh_type)
4280 case SHT_GNU_verdef:
4282 Elf_External_Verdef * edefs;
4289 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4290 SECTION_NAME (section), section->sh_info);
4292 printf (_(" Addr: 0x"));
4293 printf_vma (section->sh_addr);
4294 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4295 (unsigned long) section->sh_offset, section->sh_link,
4296 SECTION_NAME (section_headers + section->sh_link));
4298 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
4299 edefs, Elf_External_Verdef *,
4300 "version definition section");
4302 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
4305 Elf_External_Verdef * edef;
4306 Elf_Internal_Verdef ent;
4307 Elf_External_Verdaux * eaux;
4308 Elf_Internal_Verdaux aux;
4312 vstart = ((char *) edefs) + idx;
4314 edef = (Elf_External_Verdef *) vstart;
4316 ent.vd_version = BYTE_GET (edef->vd_version);
4317 ent.vd_flags = BYTE_GET (edef->vd_flags);
4318 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
4319 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
4320 ent.vd_hash = BYTE_GET (edef->vd_hash);
4321 ent.vd_aux = BYTE_GET (edef->vd_aux);
4322 ent.vd_next = BYTE_GET (edef->vd_next);
4324 printf (_(" %#06x: Rev: %d Flags: %s"),
4325 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
4327 printf (_(" Index: %d Cnt: %d "),
4328 ent.vd_ndx, ent.vd_cnt);
4330 vstart += ent.vd_aux;
4332 eaux = (Elf_External_Verdaux *) vstart;
4334 aux.vda_name = BYTE_GET (eaux->vda_name);
4335 aux.vda_next = BYTE_GET (eaux->vda_next);
4337 if (dynamic_strings)
4338 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
4340 printf (_("Name index: %ld\n"), aux.vda_name);
4342 isum = idx + ent.vd_aux;
4344 for (j = 1; j < ent.vd_cnt; j ++)
4346 isum += aux.vda_next;
4347 vstart += aux.vda_next;
4349 eaux = (Elf_External_Verdaux *) vstart;
4351 aux.vda_name = BYTE_GET (eaux->vda_name);
4352 aux.vda_next = BYTE_GET (eaux->vda_next);
4354 if (dynamic_strings)
4355 printf (_(" %#06x: Parent %d: %s\n"),
4356 isum, j, dynamic_strings + aux.vda_name);
4358 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4359 isum, j, aux.vda_name);
4369 case SHT_GNU_verneed:
4371 Elf_External_Verneed * eneed;
4377 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4378 SECTION_NAME (section), section->sh_info);
4380 printf (_(" Addr: 0x"));
4381 printf_vma (section->sh_addr);
4382 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4383 (unsigned long) section->sh_offset, section->sh_link,
4384 SECTION_NAME (section_headers + section->sh_link));
4386 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
4387 eneed, Elf_External_Verneed *,
4388 "version need section");
4390 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
4392 Elf_External_Verneed * entry;
4393 Elf_Internal_Verneed ent;
4398 vstart = ((char *) eneed) + idx;
4400 entry = (Elf_External_Verneed *) vstart;
4402 ent.vn_version = BYTE_GET (entry->vn_version);
4403 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
4404 ent.vn_file = BYTE_GET (entry->vn_file);
4405 ent.vn_aux = BYTE_GET (entry->vn_aux);
4406 ent.vn_next = BYTE_GET (entry->vn_next);
4408 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
4410 if (dynamic_strings)
4411 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
4413 printf (_(" File: %lx"), ent.vn_file);
4415 printf (_(" Cnt: %d\n"), ent.vn_cnt);
4417 vstart += ent.vn_aux;
4419 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
4421 Elf_External_Vernaux * eaux;
4422 Elf_Internal_Vernaux aux;
4424 eaux = (Elf_External_Vernaux *) vstart;
4426 aux.vna_hash = BYTE_GET (eaux->vna_hash);
4427 aux.vna_flags = BYTE_GET (eaux->vna_flags);
4428 aux.vna_other = BYTE_GET (eaux->vna_other);
4429 aux.vna_name = BYTE_GET (eaux->vna_name);
4430 aux.vna_next = BYTE_GET (eaux->vna_next);
4432 if (dynamic_strings)
4433 printf (_(" %#06x: Name: %s"),
4434 isum, dynamic_strings + aux.vna_name);
4436 printf (_(" %#06x: Name index: %lx"),
4437 isum, aux.vna_name);
4439 printf (_(" Flags: %s Version: %d\n"),
4440 get_ver_flags (aux.vna_flags), aux.vna_other);
4442 isum += aux.vna_next;
4443 vstart += aux.vna_next;
4453 case SHT_GNU_versym:
4455 Elf32_Internal_Shdr * link_section;
4458 unsigned char * edata;
4459 unsigned short * data;
4461 Elf_Internal_Sym * symbols;
4462 Elf32_Internal_Shdr * string_sec;
4464 link_section = section_headers + section->sh_link;
4465 total = section->sh_size / section->sh_entsize;
4469 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
4470 link_section->sh_size / link_section->sh_entsize);
4472 string_sec = section_headers + link_section->sh_link;
4474 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4475 strtab, char *, "version string table");
4477 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4478 SECTION_NAME (section), total);
4480 printf (_(" Addr: "));
4481 printf_vma (section->sh_addr);
4482 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4483 (unsigned long) section->sh_offset, section->sh_link,
4484 SECTION_NAME (link_section));
4486 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4488 total * sizeof (short), edata,
4489 unsigned char *, "version symbol data");
4491 data = (unsigned short *) malloc (total * sizeof (short));
4493 for (cnt = total; cnt --;)
4494 data [cnt] = byte_get (edata + cnt * sizeof (short),
4499 for (cnt = 0; cnt < total; cnt += 4)
4502 int check_def, check_need;
4505 printf (" %03x:", cnt);
4507 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
4508 switch (data [cnt + j])
4511 fputs (_(" 0 (*local*) "), stdout);
4515 fputs (_(" 1 (*global*) "), stdout);
4519 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4520 data [cnt + j] & 0x8000 ? 'h' : ' ');
4524 if (symbols [cnt + j].st_shndx >= SHN_LORESERVE
4525 || section_headers[symbols [cnt + j].st_shndx].sh_type
4528 if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4535 && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
4537 Elf_Internal_Verneed ivn;
4538 unsigned long offset;
4540 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4545 Elf_Internal_Vernaux ivna;
4546 Elf_External_Verneed evn;
4547 Elf_External_Vernaux evna;
4548 unsigned long a_off;
4550 GET_DATA (offset, evn, "version need");
4552 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4553 ivn.vn_next = BYTE_GET (evn.vn_next);
4555 a_off = offset + ivn.vn_aux;
4559 GET_DATA (a_off, evna,
4560 "version need aux (2)");
4562 ivna.vna_next = BYTE_GET (evna.vna_next);
4563 ivna.vna_other = BYTE_GET (evna.vna_other);
4565 a_off += ivna.vna_next;
4567 while (ivna.vna_other != data [cnt + j]
4568 && ivna.vna_next != 0);
4570 if (ivna.vna_other == data [cnt + j])
4572 ivna.vna_name = BYTE_GET (evna.vna_name);
4574 name = strtab + ivna.vna_name;
4575 nn += printf ("(%s%-*s",
4577 12 - (int) strlen (name),
4583 offset += ivn.vn_next;
4585 while (ivn.vn_next);
4588 if (check_def && data [cnt + j] != 0x8001
4589 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
4591 Elf_Internal_Verdef ivd;
4592 Elf_External_Verdef evd;
4593 unsigned long offset;
4595 offset = version_info
4596 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4600 GET_DATA (offset, evd, "version def");
4602 ivd.vd_next = BYTE_GET (evd.vd_next);
4603 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4605 offset += ivd.vd_next;
4607 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4608 && ivd.vd_next != 0);
4610 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4612 Elf_External_Verdaux evda;
4613 Elf_Internal_Verdaux ivda;
4615 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4617 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4618 evda, "version def aux");
4620 ivda.vda_name = BYTE_GET (evda.vda_name);
4622 name = strtab + ivda.vda_name;
4623 nn += printf ("(%s%-*s",
4625 12 - (int) strlen (name),
4631 printf ("%*c", 18 - nn, ' ');
4649 printf (_("\nNo version information found in this file.\n"));
4655 get_symbol_binding (binding)
4656 unsigned int binding;
4658 static char buff [32];
4662 case STB_LOCAL: return "LOCAL";
4663 case STB_GLOBAL: return "GLOBAL";
4664 case STB_WEAK: return "WEAK";
4666 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4667 sprintf (buff, _("<processor specific>: %d"), binding);
4668 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4669 sprintf (buff, _("<OS specific>: %d"), binding);
4671 sprintf (buff, _("<unknown>: %d"), binding);
4677 get_symbol_type (type)
4680 static char buff [32];
4684 case STT_NOTYPE: return "NOTYPE";
4685 case STT_OBJECT: return "OBJECT";
4686 case STT_FUNC: return "FUNC";
4687 case STT_SECTION: return "SECTION";
4688 case STT_FILE: return "FILE";
4689 case STT_COMMON: return "COMMON";
4691 if (type >= STT_LOPROC && type <= STT_HIPROC)
4693 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4694 return "THUMB_FUNC";
4696 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4699 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4700 return "PARISC_MILLI";
4702 sprintf (buff, _("<processor specific>: %d"), type);
4704 else if (type >= STT_LOOS && type <= STT_HIOS)
4706 if (elf_header.e_machine == EM_PARISC)
4708 if (type == STT_HP_OPAQUE)
4710 if (type == STT_HP_STUB)
4714 sprintf (buff, _("<OS specific>: %d"), type);
4717 sprintf (buff, _("<unknown>: %d"), type);
4723 get_symbol_visibility (visibility)
4724 unsigned int visibility;
4728 case STV_DEFAULT: return "DEFAULT";
4729 case STV_INTERNAL: return "INTERNAL";
4730 case STV_HIDDEN: return "HIDDEN";
4731 case STV_PROTECTED: return "PROTECTED";
4737 get_symbol_index_type (type)
4742 case SHN_UNDEF: return "UND";
4743 case SHN_ABS: return "ABS";
4744 case SHN_COMMON: return "COM";
4746 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4748 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4750 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4754 static char buff [32];
4756 sprintf (buff, "%3d", type);
4763 get_dynamic_data (file, number)
4765 unsigned int number;
4767 unsigned char * e_data;
4770 e_data = (unsigned char *) malloc (number * 4);
4774 error (_("Out of memory\n"));
4778 if (fread (e_data, 4, number, file) != number)
4780 error (_("Unable to read in dynamic data\n"));
4784 i_data = (int *) malloc (number * sizeof (* i_data));
4788 error (_("Out of memory\n"));
4794 i_data [number] = byte_get (e_data + number * 4, 4);
4801 /* Dump the symbol table */
4803 process_symbol_table (file)
4806 Elf32_Internal_Shdr * section;
4807 unsigned char nb [4];
4808 unsigned char nc [4];
4811 int * buckets = NULL;
4812 int * chains = NULL;
4814 if (! do_syms && !do_histogram)
4817 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4820 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4822 error (_("Unable to seek to start of dynamic information"));
4826 if (fread (nb, sizeof (nb), 1, file) != 1)
4828 error (_("Failed to read in number of buckets\n"));
4832 if (fread (nc, sizeof (nc), 1, file) != 1)
4834 error (_("Failed to read in number of chains\n"));
4838 nbuckets = byte_get (nb, 4);
4839 nchains = byte_get (nc, 4);
4841 buckets = get_dynamic_data (file, nbuckets);
4842 chains = get_dynamic_data (file, nchains);
4844 if (buckets == NULL || chains == NULL)
4849 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4854 printf (_("\nSymbol table for image:\n"));
4856 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4858 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4860 for (hn = 0; hn < nbuckets; hn++)
4865 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4867 Elf_Internal_Sym * psym;
4869 psym = dynamic_symbols + si;
4871 printf (" %3d %3d: ", si, hn);
4872 print_vma (psym->st_value, LONG_HEX);
4874 print_vma (psym->st_size, DEC_5);
4876 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4877 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4878 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4879 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4880 printf (" %s\n", dynamic_strings + psym->st_name);
4884 else if (do_syms && !do_using_dynamic)
4888 for (i = 0, section = section_headers;
4889 i < elf_header.e_shnum;
4894 Elf_Internal_Sym * symtab;
4895 Elf_Internal_Sym * psym;
4898 if ( section->sh_type != SHT_SYMTAB
4899 && section->sh_type != SHT_DYNSYM)
4902 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4903 SECTION_NAME (section),
4904 (unsigned long) (section->sh_size / section->sh_entsize));
4906 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4908 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4910 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4911 section->sh_size / section->sh_entsize);
4915 if (section->sh_link == elf_header.e_shstrndx)
4916 strtab = string_table;
4919 Elf32_Internal_Shdr * string_sec;
4921 string_sec = section_headers + section->sh_link;
4923 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4924 strtab, char *, "string table");
4927 for (si = 0, psym = symtab;
4928 si < section->sh_size / section->sh_entsize;
4931 printf ("%6d: ", si);
4932 print_vma (psym->st_value, LONG_HEX);
4934 print_vma (psym->st_size, DEC_5);
4935 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4936 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4937 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4938 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4939 printf (" %s", strtab + psym->st_name);
4941 if (section->sh_type == SHT_DYNSYM &&
4942 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4944 unsigned char data[2];
4945 unsigned short vers_data;
4946 unsigned long offset;
4950 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4953 GET_DATA (offset + si * sizeof (vers_data), data,
4956 vers_data = byte_get (data, 2);
4958 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4959 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4962 check_def = (psym->st_shndx != SHN_UNDEF);
4964 if ((vers_data & 0x8000) || vers_data > 1)
4966 if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4967 && (is_nobits || ! check_def))
4969 Elf_External_Verneed evn;
4970 Elf_Internal_Verneed ivn;
4971 Elf_Internal_Vernaux ivna;
4973 /* We must test both. */
4974 offset = version_info
4975 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4979 unsigned long vna_off;
4981 GET_DATA (offset, evn, "version need");
4983 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4984 ivn.vn_next = BYTE_GET (evn.vn_next);
4986 vna_off = offset + ivn.vn_aux;
4990 Elf_External_Vernaux evna;
4992 GET_DATA (vna_off, evna,
4993 "version need aux (3)");
4995 ivna.vna_other = BYTE_GET (evna.vna_other);
4996 ivna.vna_next = BYTE_GET (evna.vna_next);
4997 ivna.vna_name = BYTE_GET (evna.vna_name);
4999 vna_off += ivna.vna_next;
5001 while (ivna.vna_other != vers_data
5002 && ivna.vna_next != 0);
5004 if (ivna.vna_other == vers_data)
5007 offset += ivn.vn_next;
5009 while (ivn.vn_next != 0);
5011 if (ivna.vna_other == vers_data)
5014 strtab + ivna.vna_name, ivna.vna_other);
5017 else if (! is_nobits)
5018 error (_("bad dynamic symbol"));
5025 if (vers_data != 0x8001
5026 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5028 Elf_Internal_Verdef ivd;
5029 Elf_Internal_Verdaux ivda;
5030 Elf_External_Verdaux evda;
5031 unsigned long offset;
5034 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5039 Elf_External_Verdef evd;
5041 GET_DATA (offset, evd, "version def");
5043 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5044 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5045 ivd.vd_next = BYTE_GET (evd.vd_next);
5047 offset += ivd.vd_next;
5049 while (ivd.vd_ndx != (vers_data & 0x7fff)
5050 && ivd.vd_next != 0);
5052 offset -= ivd.vd_next;
5053 offset += ivd.vd_aux;
5055 GET_DATA (offset, evda, "version def aux");
5057 ivda.vda_name = BYTE_GET (evda.vda_name);
5059 if (psym->st_name != ivda.vda_name)
5060 printf ((vers_data & 0x8000)
5062 strtab + ivda.vda_name);
5072 if (strtab != string_table)
5078 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5080 if (do_histogram && buckets != NULL)
5087 int nzero_counts = 0;
5090 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5092 printf (_(" Length Number %% of total Coverage\n"));
5094 lengths = (int *) calloc (nbuckets, sizeof (int));
5095 if (lengths == NULL)
5097 error (_("Out of memory"));
5100 for (hn = 0; hn < nbuckets; ++hn)
5105 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5108 if (maxlength < ++lengths[hn])
5113 counts = (int *) calloc (maxlength + 1, sizeof (int));
5116 error (_("Out of memory"));
5120 for (hn = 0; hn < nbuckets; ++hn)
5121 ++ counts [lengths [hn]];
5125 printf (" 0 %-10d (%5.1f%%)\n",
5126 counts[0], (counts[0] * 100.0) / nbuckets);
5127 for (si = 1; si <= maxlength; ++si)
5129 nzero_counts += counts[si] * si;
5130 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5131 si, counts[si], (counts[si] * 100.0) / nbuckets,
5132 (nzero_counts * 100.0) / nsyms);
5140 if (buckets != NULL)
5150 process_syminfo (file)
5151 FILE * file ATTRIBUTE_UNUSED;
5155 if (dynamic_syminfo == NULL
5157 /* No syminfo, this is ok. */
5160 /* There better should be a dynamic symbol section. */
5161 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5165 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5166 dynamic_syminfo_offset, dynamic_syminfo_nent);
5168 printf (_(" Num: Name BoundTo Flags\n"));
5169 for (i = 0; i < dynamic_syminfo_nent; ++i)
5171 unsigned short int flags = dynamic_syminfo[i].si_flags;
5173 printf ("%4d: %-30s ", i,
5174 dynamic_strings + dynamic_symbols[i].st_name);
5176 switch (dynamic_syminfo[i].si_boundto)
5178 case SYMINFO_BT_SELF:
5179 fputs ("SELF ", stdout);
5181 case SYMINFO_BT_PARENT:
5182 fputs ("PARENT ", stdout);
5185 if (dynamic_syminfo[i].si_boundto > 0
5186 && dynamic_syminfo[i].si_boundto < dynamic_size)
5189 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
5191 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5195 if (flags & SYMINFO_FLG_DIRECT)
5197 if (flags & SYMINFO_FLG_PASSTHRU)
5198 printf (" PASSTHRU");
5199 if (flags & SYMINFO_FLG_COPY)
5201 if (flags & SYMINFO_FLG_LAZYLOAD)
5202 printf (" LAZYLOAD");
5210 #ifdef SUPPORT_DISASSEMBLY
5212 disassemble_section (section, file)
5213 Elf32_Internal_Shdr * section;
5216 printf (_("\nAssembly dump of section %s\n"),
5217 SECTION_NAME (section));
5219 /* XXX -- to be done --- XXX */
5226 dump_section (section, file)
5227 Elf32_Internal_Shdr * section;
5230 bfd_size_type bytes;
5232 unsigned char * data;
5233 unsigned char * start;
5235 bytes = section->sh_size;
5239 printf (_("\nSection '%s' has no data to dump.\n"),
5240 SECTION_NAME (section));
5244 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5246 addr = section->sh_addr;
5248 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
5259 lbytes = (bytes > 16 ? 16 : bytes);
5261 printf (" 0x%8.8lx ", (unsigned long) addr);
5263 switch (elf_header.e_ident [EI_DATA])
5267 for (j = 15; j >= 0; j --)
5270 printf ("%2.2x", data [j]);
5280 for (j = 0; j < 16; j++)
5283 printf ("%2.2x", data [j]);
5293 for (j = 0; j < lbytes; j++)
5296 if (k >= ' ' && k < 0x80)
5315 static unsigned long int
5316 read_leb128 (data, length_return, sign)
5317 unsigned char * data;
5318 int * length_return;
5321 unsigned long int result = 0;
5322 unsigned int num_read = 0;
5331 result |= (byte & 0x7f) << shift;
5336 while (byte & 0x80);
5338 if (length_return != NULL)
5339 * length_return = num_read;
5341 if (sign && (shift < 32) && (byte & 0x40))
5342 result |= -1 << shift;
5347 typedef struct State_Machine_Registers
5349 unsigned long address;
5352 unsigned int column;
5356 /* This variable hold the number of the last entry seen
5357 in the File Table. */
5358 unsigned int last_file_entry;
5361 static SMR state_machine_regs;
5364 reset_state_machine (is_stmt)
5367 state_machine_regs.address = 0;
5368 state_machine_regs.file = 1;
5369 state_machine_regs.line = 1;
5370 state_machine_regs.column = 0;
5371 state_machine_regs.is_stmt = is_stmt;
5372 state_machine_regs.basic_block = 0;
5373 state_machine_regs.end_sequence = 0;
5374 state_machine_regs.last_file_entry = 0;
5377 /* Handled an extend line op. Returns true if this is the end
5380 process_extended_line_op (data, is_stmt, pointer_size)
5381 unsigned char * data;
5385 unsigned char op_code;
5388 unsigned char * name;
5391 len = read_leb128 (data, & bytes_read, 0);
5396 warn (_("badly formed extended line op encountered!"));
5401 op_code = * data ++;
5403 printf (_(" Extended opcode %d: "), op_code);
5407 case DW_LNE_end_sequence:
5408 printf (_("End of Sequence\n\n"));
5409 reset_state_machine (is_stmt);
5412 case DW_LNE_set_address:
5413 adr = byte_get (data, pointer_size);
5414 printf (_("set Address to 0x%lx\n"), adr);
5415 state_machine_regs.address = adr;
5418 case DW_LNE_define_file:
5419 printf (_(" define new File Table entry\n"));
5420 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5422 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5424 data += strlen ((char *) data) + 1;
5425 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5427 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5429 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5430 printf (_("%s\n\n"), name);
5434 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5441 /* Size of pointers in the .debug_line section. This information is not
5442 really present in that section. It's obtained before dumping the debug
5443 sections by doing some pre-scan of the .debug_info section. */
5444 static int debug_line_pointer_size = 4;
5447 display_debug_lines (section, start, file)
5448 Elf32_Internal_Shdr * section;
5449 unsigned char * start;
5450 FILE * file ATTRIBUTE_UNUSED;
5452 DWARF2_External_LineInfo * external;
5453 DWARF2_Internal_LineInfo info;
5454 unsigned char * standard_opcodes;
5455 unsigned char * data = start;
5456 unsigned char * end = start + section->sh_size;
5457 unsigned char * end_of_sequence;
5460 printf (_("\nDump of debug contents of section %s:\n\n"),
5461 SECTION_NAME (section));
5465 external = (DWARF2_External_LineInfo *) data;
5467 /* Check the length of the block. */
5468 info.li_length = BYTE_GET (external->li_length);
5469 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5472 (_("The line info appears to be corrupt - the section is too small\n"));
5476 /* Check its version number. */
5477 info.li_version = BYTE_GET (external->li_version);
5478 if (info.li_version != 2)
5480 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5484 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5485 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5486 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5487 info.li_line_base = BYTE_GET (external->li_line_base);
5488 info.li_line_range = BYTE_GET (external->li_line_range);
5489 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5491 /* Sign extend the line base field. */
5492 info.li_line_base <<= 24;
5493 info.li_line_base >>= 24;
5495 printf (_(" Length: %ld\n"), info.li_length);
5496 printf (_(" DWARF Version: %d\n"), info.li_version);
5497 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
5498 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5499 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5500 printf (_(" Line Base: %d\n"), info.li_line_base);
5501 printf (_(" Line Range: %d\n"), info.li_line_range);
5502 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5504 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5506 reset_state_machine (info.li_default_is_stmt);
5508 /* Display the contents of the Opcodes table. */
5509 standard_opcodes = data + sizeof (* external);
5511 printf (_("\n Opcodes:\n"));
5513 for (i = 1; i < info.li_opcode_base; i++)
5514 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5516 /* Display the contents of the Directory table. */
5517 data = standard_opcodes + info.li_opcode_base - 1;
5520 printf (_("\n The Directory Table is empty.\n"));
5523 printf (_("\n The Directory Table:\n"));
5527 printf (_(" %s\n"), data);
5529 data += strlen ((char *) data) + 1;
5533 /* Skip the NUL at the end of the table. */
5536 /* Display the contents of the File Name table. */
5538 printf (_("\n The File Name Table is empty.\n"));
5541 printf (_("\n The File Name Table:\n"));
5542 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5546 unsigned char * name;
5549 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5552 data += strlen ((char *) data) + 1;
5554 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5556 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5558 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5560 printf (_("%s\n"), name);
5564 /* Skip the NUL at the end of the table. */
5567 /* Now display the statements. */
5568 printf (_("\n Line Number Statements:\n"));
5571 while (data < end_of_sequence)
5573 unsigned char op_code;
5577 op_code = * data ++;
5581 case DW_LNS_extended_op:
5582 data += process_extended_line_op (data, info.li_default_is_stmt,
5583 debug_line_pointer_size);
5587 printf (_(" Copy\n"));
5590 case DW_LNS_advance_pc:
5591 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5593 state_machine_regs.address += adv;
5594 printf (_(" Advance PC by %d to %lx\n"), adv,
5595 state_machine_regs.address);
5598 case DW_LNS_advance_line:
5599 adv = read_leb128 (data, & bytes_read, 1);
5601 state_machine_regs.line += adv;
5602 printf (_(" Advance Line by %d to %d\n"), adv,
5603 state_machine_regs.line);
5606 case DW_LNS_set_file:
5607 adv = read_leb128 (data, & bytes_read, 0);
5609 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5611 state_machine_regs.file = adv;
5614 case DW_LNS_set_column:
5615 adv = read_leb128 (data, & bytes_read, 0);
5617 printf (_(" Set column to %d\n"), adv);
5618 state_machine_regs.column = adv;
5621 case DW_LNS_negate_stmt:
5622 adv = state_machine_regs.is_stmt;
5624 printf (_(" Set is_stmt to %d\n"), adv);
5625 state_machine_regs.is_stmt = adv;
5628 case DW_LNS_set_basic_block:
5629 printf (_(" Set basic block\n"));
5630 state_machine_regs.basic_block = 1;
5633 case DW_LNS_const_add_pc:
5634 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5635 * info.li_min_insn_length);
5636 state_machine_regs.address += adv;
5637 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5638 state_machine_regs.address);
5641 case DW_LNS_fixed_advance_pc:
5642 adv = byte_get (data, 2);
5644 state_machine_regs.address += adv;
5645 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5646 adv, state_machine_regs.address);
5650 op_code -= info.li_opcode_base;
5651 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5652 state_machine_regs.address += adv;
5653 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5654 op_code, adv, state_machine_regs.address);
5655 adv = (op_code % info.li_line_range) + info.li_line_base;
5656 state_machine_regs.line += adv;
5657 printf (_(" and Line by %d to %d\n"),
5658 adv, state_machine_regs.line);
5669 display_debug_pubnames (section, start, file)
5670 Elf32_Internal_Shdr * section;
5671 unsigned char * start;
5672 FILE * file ATTRIBUTE_UNUSED;
5674 DWARF2_External_PubNames * external;
5675 DWARF2_Internal_PubNames pubnames;
5676 unsigned char * end;
5678 end = start + section->sh_size;
5680 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5684 unsigned char * data;
5685 unsigned long offset;
5687 external = (DWARF2_External_PubNames *) start;
5689 pubnames.pn_length = BYTE_GET (external->pn_length);
5690 pubnames.pn_version = BYTE_GET (external->pn_version);
5691 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5692 pubnames.pn_size = BYTE_GET (external->pn_size);
5694 data = start + sizeof (* external);
5695 start += pubnames.pn_length + sizeof (external->pn_length);
5697 if (pubnames.pn_version != 2)
5699 static int warned = 0;
5703 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5710 printf (_(" Length: %ld\n"),
5711 pubnames.pn_length);
5712 printf (_(" Version: %d\n"),
5713 pubnames.pn_version);
5714 printf (_(" Offset into .debug_info section: %ld\n"),
5715 pubnames.pn_offset);
5716 printf (_(" Size of area in .debug_info section: %ld\n"),
5719 printf (_("\n Offset\tName\n"));
5723 offset = byte_get (data, 4);
5728 printf (" %ld\t\t%s\n", offset, data);
5729 data += strlen ((char *) data) + 1;
5732 while (offset != 0);
5745 case DW_TAG_padding: return "DW_TAG_padding";
5746 case DW_TAG_array_type: return "DW_TAG_array_type";
5747 case DW_TAG_class_type: return "DW_TAG_class_type";
5748 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5749 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5750 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5751 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5752 case DW_TAG_label: return "DW_TAG_label";
5753 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5754 case DW_TAG_member: return "DW_TAG_member";
5755 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5756 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5757 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5758 case DW_TAG_string_type: return "DW_TAG_string_type";
5759 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5760 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5761 case DW_TAG_typedef: return "DW_TAG_typedef";
5762 case DW_TAG_union_type: return "DW_TAG_union_type";
5763 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5764 case DW_TAG_variant: return "DW_TAG_variant";
5765 case DW_TAG_common_block: return "DW_TAG_common_block";
5766 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5767 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5768 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5769 case DW_TAG_module: return "DW_TAG_module";
5770 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5771 case DW_TAG_set_type: return "DW_TAG_set_type";
5772 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5773 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5774 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5775 case DW_TAG_base_type: return "DW_TAG_base_type";
5776 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5777 case DW_TAG_const_type: return "DW_TAG_const_type";
5778 case DW_TAG_constant: return "DW_TAG_constant";
5779 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5780 case DW_TAG_file_type: return "DW_TAG_file_type";
5781 case DW_TAG_friend: return "DW_TAG_friend";
5782 case DW_TAG_namelist: return "DW_TAG_namelist";
5783 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5784 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5785 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5786 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5787 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5788 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5789 case DW_TAG_try_block: return "DW_TAG_try_block";
5790 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5791 case DW_TAG_variable: return "DW_TAG_variable";
5792 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5793 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5794 case DW_TAG_format_label: return "DW_TAG_format_label";
5795 case DW_TAG_function_template: return "DW_TAG_function_template";
5796 case DW_TAG_class_template: return "DW_TAG_class_template";
5799 static char buffer [100];
5801 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5808 get_AT_name (attribute)
5809 unsigned long attribute;
5813 case DW_AT_sibling: return "DW_AT_sibling";
5814 case DW_AT_location: return "DW_AT_location";
5815 case DW_AT_name: return "DW_AT_name";
5816 case DW_AT_ordering: return "DW_AT_ordering";
5817 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5818 case DW_AT_byte_size: return "DW_AT_byte_size";
5819 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5820 case DW_AT_bit_size: return "DW_AT_bit_size";
5821 case DW_AT_element_list: return "DW_AT_element_list";
5822 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5823 case DW_AT_low_pc: return "DW_AT_low_pc";
5824 case DW_AT_high_pc: return "DW_AT_high_pc";
5825 case DW_AT_language: return "DW_AT_language";
5826 case DW_AT_member: return "DW_AT_member";
5827 case DW_AT_discr: return "DW_AT_discr";
5828 case DW_AT_discr_value: return "DW_AT_discr_value";
5829 case DW_AT_visibility: return "DW_AT_visibility";
5830 case DW_AT_import: return "DW_AT_import";
5831 case DW_AT_string_length: return "DW_AT_string_length";
5832 case DW_AT_common_reference: return "DW_AT_common_reference";
5833 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5834 case DW_AT_const_value: return "DW_AT_const_value";
5835 case DW_AT_containing_type: return "DW_AT_containing_type";
5836 case DW_AT_default_value: return "DW_AT_default_value";
5837 case DW_AT_inline: return "DW_AT_inline";
5838 case DW_AT_is_optional: return "DW_AT_is_optional";
5839 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5840 case DW_AT_producer: return "DW_AT_producer";
5841 case DW_AT_prototyped: return "DW_AT_prototyped";
5842 case DW_AT_return_addr: return "DW_AT_return_addr";
5843 case DW_AT_start_scope: return "DW_AT_start_scope";
5844 case DW_AT_stride_size: return "DW_AT_stride_size";
5845 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5846 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5847 case DW_AT_accessibility: return "DW_AT_accessibility";
5848 case DW_AT_address_class: return "DW_AT_address_class";
5849 case DW_AT_artificial: return "DW_AT_artificial";
5850 case DW_AT_base_types: return "DW_AT_base_types";
5851 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5852 case DW_AT_count: return "DW_AT_count";
5853 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5854 case DW_AT_decl_column: return "DW_AT_decl_column";
5855 case DW_AT_decl_file: return "DW_AT_decl_file";
5856 case DW_AT_decl_line: return "DW_AT_decl_line";
5857 case DW_AT_declaration: return "DW_AT_declaration";
5858 case DW_AT_discr_list: return "DW_AT_discr_list";
5859 case DW_AT_encoding: return "DW_AT_encoding";
5860 case DW_AT_external: return "DW_AT_external";
5861 case DW_AT_frame_base: return "DW_AT_frame_base";
5862 case DW_AT_friend: return "DW_AT_friend";
5863 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5864 case DW_AT_macro_info: return "DW_AT_macro_info";
5865 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5866 case DW_AT_priority: return "DW_AT_priority";
5867 case DW_AT_segment: return "DW_AT_segment";
5868 case DW_AT_specification: return "DW_AT_specification";
5869 case DW_AT_static_link: return "DW_AT_static_link";
5870 case DW_AT_type: return "DW_AT_type";
5871 case DW_AT_use_location: return "DW_AT_use_location";
5872 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5873 case DW_AT_virtuality: return "DW_AT_virtuality";
5874 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5875 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5876 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5877 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5878 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5879 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5880 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5881 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5882 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5883 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5884 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5885 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5886 case DW_AT_sf_names: return "DW_AT_sf_names";
5887 case DW_AT_src_info: return "DW_AT_src_info";
5888 case DW_AT_mac_info: return "DW_AT_mac_info";
5889 case DW_AT_src_coords: return "DW_AT_src_coords";
5890 case DW_AT_body_begin: return "DW_AT_body_begin";
5891 case DW_AT_body_end: return "DW_AT_body_end";
5894 static char buffer [100];
5896 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5903 get_FORM_name (form)
5908 case DW_FORM_addr: return "DW_FORM_addr";
5909 case DW_FORM_block2: return "DW_FORM_block2";
5910 case DW_FORM_block4: return "DW_FORM_block4";
5911 case DW_FORM_data2: return "DW_FORM_data2";
5912 case DW_FORM_data4: return "DW_FORM_data4";
5913 case DW_FORM_data8: return "DW_FORM_data8";
5914 case DW_FORM_string: return "DW_FORM_string";
5915 case DW_FORM_block: return "DW_FORM_block";
5916 case DW_FORM_block1: return "DW_FORM_block1";
5917 case DW_FORM_data1: return "DW_FORM_data1";
5918 case DW_FORM_flag: return "DW_FORM_flag";
5919 case DW_FORM_sdata: return "DW_FORM_sdata";
5920 case DW_FORM_strp: return "DW_FORM_strp";
5921 case DW_FORM_udata: return "DW_FORM_udata";
5922 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5923 case DW_FORM_ref1: return "DW_FORM_ref1";
5924 case DW_FORM_ref2: return "DW_FORM_ref2";
5925 case DW_FORM_ref4: return "DW_FORM_ref4";
5926 case DW_FORM_ref8: return "DW_FORM_ref8";
5927 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5928 case DW_FORM_indirect: return "DW_FORM_indirect";
5931 static char buffer [100];
5933 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5939 /* FIXME: There are better and more effiecint ways to handle
5940 these structures. For now though, I just want something that
5941 is simple to implement. */
5942 typedef struct abbrev_attr
5944 unsigned long attribute;
5946 struct abbrev_attr * next;
5950 typedef struct abbrev_entry
5952 unsigned long entry;
5955 struct abbrev_attr * first_attr;
5956 struct abbrev_attr * last_attr;
5957 struct abbrev_entry * next;
5961 static abbrev_entry * first_abbrev = NULL;
5962 static abbrev_entry * last_abbrev = NULL;
5965 free_abbrevs PARAMS ((void))
5967 abbrev_entry * abbrev;
5969 for (abbrev = first_abbrev; abbrev;)
5971 abbrev_entry * next = abbrev->next;
5974 for (attr = abbrev->first_attr; attr;)
5976 abbrev_attr * next = attr->next;
5986 last_abbrev = first_abbrev = NULL;
5990 add_abbrev (number, tag, children)
5991 unsigned long number;
5995 abbrev_entry * entry;
5997 entry = (abbrev_entry *) malloc (sizeof (* entry));
6003 entry->entry = number;
6005 entry->children = children;
6006 entry->first_attr = NULL;
6007 entry->last_attr = NULL;
6010 if (first_abbrev == NULL)
6011 first_abbrev = entry;
6013 last_abbrev->next = entry;
6015 last_abbrev = entry;
6019 add_abbrev_attr (attribute, form)
6020 unsigned long attribute;
6025 attr = (abbrev_attr *) malloc (sizeof (* attr));
6031 attr->attribute = attribute;
6035 if (last_abbrev->first_attr == NULL)
6036 last_abbrev->first_attr = attr;
6038 last_abbrev->last_attr->next = attr;
6040 last_abbrev->last_attr = attr;
6043 /* Processes the (partial) contents of a .debug_abbrev section.
6044 Returns NULL if the end of the section was encountered.
6045 Returns the address after the last byte read if the end of
6046 an abbreviation set was found. */
6048 static unsigned char *
6049 process_abbrev_section (start, end)
6050 unsigned char * start;
6051 unsigned char * end;
6053 if (first_abbrev != NULL)
6059 unsigned long entry;
6061 unsigned long attribute;
6064 entry = read_leb128 (start, & bytes_read, 0);
6065 start += bytes_read;
6067 /* A single zero is supposed to end the section according
6068 to the standard. If there's more, then signal that to
6071 return start == end ? NULL : start;
6073 tag = read_leb128 (start, & bytes_read, 0);
6074 start += bytes_read;
6076 children = * start ++;
6078 add_abbrev (entry, tag, children);
6084 attribute = read_leb128 (start, & bytes_read, 0);
6085 start += bytes_read;
6087 form = read_leb128 (start, & bytes_read, 0);
6088 start += bytes_read;
6091 add_abbrev_attr (attribute, form);
6093 while (attribute != 0);
6101 display_debug_abbrev (section, start, file)
6102 Elf32_Internal_Shdr * section;
6103 unsigned char * start;
6104 FILE * file ATTRIBUTE_UNUSED;
6106 abbrev_entry * entry;
6107 unsigned char * end = start + section->sh_size;
6109 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6113 start = process_abbrev_section (start, end);
6115 printf (_(" Number TAG\n"));
6117 for (entry = first_abbrev; entry; entry = entry->next)
6121 printf (_(" %ld %s [%s]\n"),
6123 get_TAG_name (entry->tag),
6124 entry->children ? _("has children") : _("no children"));
6126 for (attr = entry->first_attr; attr; attr = attr->next)
6128 printf (_(" %-18s %s\n"),
6129 get_AT_name (attr->attribute),
6130 get_FORM_name (attr->form));
6142 static unsigned char *
6143 display_block (data, length)
6144 unsigned char * data;
6145 unsigned long length;
6147 printf (_(" %lu byte block: "), length);
6150 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6156 decode_location_expression (data, pointer_size, length)
6157 unsigned char * data;
6158 unsigned int pointer_size;
6159 unsigned long length;
6163 unsigned long uvalue;
6164 unsigned char * end = data + length;
6173 printf ("DW_OP_addr: %lx",
6174 (unsigned long) byte_get (data, pointer_size));
6175 data += pointer_size;
6178 printf ("DW_OP_deref");
6181 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6184 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6187 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6191 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6195 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6199 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6203 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6204 (unsigned long) byte_get (data + 4, 4));
6208 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6209 (long) byte_get (data + 4, 4));
6213 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6217 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6221 printf ("DW_OP_dup");
6224 printf ("DW_OP_drop");
6227 printf ("DW_OP_over");
6230 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6233 printf ("DW_OP_swap");
6236 printf ("DW_OP_rot");
6239 printf ("DW_OP_xderef");
6242 printf ("DW_OP_abs");
6245 printf ("DW_OP_and");
6248 printf ("DW_OP_div");
6251 printf ("DW_OP_minus");
6254 printf ("DW_OP_mod");
6257 printf ("DW_OP_mul");
6260 printf ("DW_OP_neg");
6263 printf ("DW_OP_not");
6266 printf ("DW_OP_or");
6269 printf ("DW_OP_plus");
6271 case DW_OP_plus_uconst:
6272 printf ("DW_OP_plus_uconst: %lu",
6273 read_leb128 (data, &bytes_read, 0));
6277 printf ("DW_OP_shl");
6280 printf ("DW_OP_shr");
6283 printf ("DW_OP_shra");
6286 printf ("DW_OP_xor");
6289 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
6293 printf ("DW_OP_eq");
6296 printf ("DW_OP_ge");
6299 printf ("DW_OP_gt");
6302 printf ("DW_OP_le");
6305 printf ("DW_OP_lt");
6308 printf ("DW_OP_ne");
6311 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
6347 printf ("DW_OP_lit%d", op - DW_OP_lit0);
6382 printf ("DW_OP_reg%d", op - DW_OP_reg0);
6417 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
6418 read_leb128 (data, &bytes_read, 1));
6423 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6427 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6431 uvalue = read_leb128 (data, &bytes_read, 0);
6433 printf ("DW_OP_bregx: %lu %ld", uvalue,
6434 read_leb128 (data, &bytes_read, 1));
6438 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6441 case DW_OP_deref_size:
6442 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6444 case DW_OP_xderef_size:
6445 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6448 printf ("DW_OP_nop");
6452 if (op >= DW_OP_lo_user
6453 && op <= DW_OP_hi_user)
6454 printf (_("(User defined location op)"));
6456 printf (_("(Unknown location op)"));
6457 /* No way to tell where the next op is, so just bail. */
6464 static unsigned char *
6465 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6466 unsigned long attribute;
6468 unsigned char * data;
6469 unsigned long cu_offset;
6470 unsigned long pointer_size;
6472 unsigned long uvalue = 0;
6473 unsigned char * block_start = NULL;
6476 printf (" %-18s:", get_AT_name (attribute));
6483 case DW_FORM_ref_addr:
6485 uvalue = byte_get (data, pointer_size);
6486 data += pointer_size;
6492 uvalue = byte_get (data ++, 1);
6497 uvalue = byte_get (data, 2);
6503 uvalue = byte_get (data, 4);
6508 uvalue = read_leb128 (data, & bytes_read, 1);
6512 case DW_FORM_ref_udata:
6514 uvalue = read_leb128 (data, & bytes_read, 0);
6521 case DW_FORM_ref_addr:
6522 printf (" <#%lx>", uvalue);
6528 case DW_FORM_ref_udata:
6529 printf (" <%lx>", uvalue + cu_offset);
6533 printf (" %#lx", uvalue);
6541 printf (" %ld", uvalue);
6546 uvalue = byte_get (data, 4);
6547 printf (" %lx", uvalue);
6548 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6552 case DW_FORM_string:
6553 printf (" %s", data);
6554 data += strlen ((char *) data) + 1;
6558 uvalue = read_leb128 (data, & bytes_read, 0);
6559 block_start = data + bytes_read;
6560 data = display_block (block_start, uvalue);
6563 case DW_FORM_block1:
6564 uvalue = byte_get (data, 1);
6565 block_start = data + 1;
6566 data = display_block (block_start, uvalue);
6569 case DW_FORM_block2:
6570 uvalue = byte_get (data, 2);
6571 block_start = data + 2;
6572 data = display_block (block_start, uvalue);
6575 case DW_FORM_block4:
6576 uvalue = byte_get (data, 4);
6577 block_start = data + 4;
6578 data = display_block (block_start, uvalue);
6582 case DW_FORM_indirect:
6583 warn (_("Unable to handle FORM: %d"), form);
6587 warn (_("Unrecognised form: %d"), form);
6591 /* For some attributes we can display futher information. */
6600 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6601 case DW_INL_inlined: printf (_("(inlined)")); break;
6602 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6603 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6604 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6608 case DW_AT_language:
6611 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6612 case DW_LANG_C89: printf ("(ANSI C)"); break;
6613 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6614 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6615 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6616 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6617 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6618 case DW_LANG_Ada83: printf ("(Ada)"); break;
6619 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6620 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6621 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6622 default: printf ("(Unknown: %lx)", uvalue); break;
6626 case DW_AT_encoding:
6629 case DW_ATE_void: printf ("(void)"); break;
6630 case DW_ATE_address: printf ("(machine address)"); break;
6631 case DW_ATE_boolean: printf ("(boolean)"); break;
6632 case DW_ATE_complex_float: printf ("(complex float)"); break;
6633 case DW_ATE_float: printf ("(float)"); break;
6634 case DW_ATE_signed: printf ("(signed)"); break;
6635 case DW_ATE_signed_char: printf ("(signed char)"); break;
6636 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6637 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6639 if (uvalue >= DW_ATE_lo_user
6640 && uvalue <= DW_ATE_hi_user)
6641 printf ("(user defined type)");
6643 printf ("(unknown type)");
6648 case DW_AT_accessibility:
6651 case DW_ACCESS_public: printf ("(public)"); break;
6652 case DW_ACCESS_protected: printf ("(protected)"); break;
6653 case DW_ACCESS_private: printf ("(private)"); break;
6654 default: printf ("(unknown accessibility)"); break;
6658 case DW_AT_visibility:
6661 case DW_VIS_local: printf ("(local)"); break;
6662 case DW_VIS_exported: printf ("(exported)"); break;
6663 case DW_VIS_qualified: printf ("(qualified)"); break;
6664 default: printf ("(unknown visibility)"); break;
6668 case DW_AT_virtuality:
6671 case DW_VIRTUALITY_none: printf ("(none)"); break;
6672 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6673 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6674 default: printf ("(unknown virtuality)"); break;
6678 case DW_AT_identifier_case:
6681 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6682 case DW_ID_up_case: printf ("(up_case)"); break;
6683 case DW_ID_down_case: printf ("(down_case)"); break;
6684 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6685 default: printf ("(unknown case)"); break;
6689 case DW_AT_calling_convention:
6692 case DW_CC_normal: printf ("(normal)"); break;
6693 case DW_CC_program: printf ("(program)"); break;
6694 case DW_CC_nocall: printf ("(nocall)"); break;
6696 if (uvalue >= DW_CC_lo_user
6697 && uvalue <= DW_CC_hi_user)
6698 printf ("(user defined)");
6700 printf ("(unknown convention)");
6704 case DW_AT_frame_base:
6705 case DW_AT_location:
6706 case DW_AT_data_member_location:
6707 case DW_AT_vtable_elem_location:
6711 decode_location_expression (block_start, pointer_size, uvalue);
6725 display_debug_info (section, start, file)
6726 Elf32_Internal_Shdr * section;
6727 unsigned char * start;
6730 unsigned char * end = start + section->sh_size;
6731 unsigned char * section_begin = start;
6733 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6737 DWARF2_External_CompUnit * external;
6738 DWARF2_Internal_CompUnit compunit;
6739 unsigned char * tags;
6742 unsigned long cu_offset;
6744 external = (DWARF2_External_CompUnit *) start;
6746 compunit.cu_length = BYTE_GET (external->cu_length);
6747 compunit.cu_version = BYTE_GET (external->cu_version);
6748 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6749 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6751 tags = start + sizeof (* external);
6752 cu_offset = start - section_begin;
6753 start += compunit.cu_length + sizeof (external->cu_length);
6755 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
6756 printf (_(" Length: %ld\n"), compunit.cu_length);
6757 printf (_(" Version: %d\n"), compunit.cu_version);
6758 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6759 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6761 if (compunit.cu_version != 2)
6763 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6767 if (first_abbrev != NULL)
6770 /* Read in the abbrevs used by this compilation unit. */
6773 Elf32_Internal_Shdr * sec;
6774 unsigned char * begin;
6776 /* Locate the .debug_abbrev section and process it. */
6777 for (i = 0, sec = section_headers;
6778 i < elf_header.e_shnum;
6780 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6783 if (i == -1 || sec->sh_size == 0)
6785 warn (_("Unable to locate .debug_abbrev section!\n"));
6789 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6790 "debug_abbrev section data");
6792 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6793 begin + sec->sh_size);
6799 while (tags < start)
6802 unsigned long abbrev_number;
6803 abbrev_entry * entry;
6806 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6809 /* A null DIE marks the end of a list of children. */
6810 if (abbrev_number == 0)
6816 /* Scan through the abbreviation list until we reach the
6818 for (entry = first_abbrev;
6819 entry && entry->entry != abbrev_number;
6820 entry = entry->next)
6825 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6830 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6831 level, tags - section_begin - bytes_read,
6833 get_TAG_name (entry->tag));
6835 for (attr = entry->first_attr; attr; attr = attr->next)
6836 tags = read_and_display_attr (attr->attribute,
6839 compunit.cu_pointer_size);
6841 if (entry->children)
6852 display_debug_aranges (section, start, file)
6853 Elf32_Internal_Shdr * section;
6854 unsigned char * start;
6855 FILE * file ATTRIBUTE_UNUSED;
6857 unsigned char * end = start + section->sh_size;
6859 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6863 DWARF2_External_ARange * external;
6864 DWARF2_Internal_ARange arange;
6865 unsigned char * ranges;
6866 unsigned long length;
6867 unsigned long address;
6870 external = (DWARF2_External_ARange *) start;
6872 arange.ar_length = BYTE_GET (external->ar_length);
6873 arange.ar_version = BYTE_GET (external->ar_version);
6874 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6875 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6876 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6878 if (arange.ar_version != 2)
6880 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6884 printf (_(" Length: %ld\n"), arange.ar_length);
6885 printf (_(" Version: %d\n"), arange.ar_version);
6886 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6887 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6888 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6890 printf (_("\n Address Length\n"));
6892 ranges = start + sizeof (* external);
6894 /* Must pad to an alignment boundary that is twice the pointer size. */
6895 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
6897 ranges += (2 * arange.ar_pointer_size) - excess;
6901 address = byte_get (ranges, arange.ar_pointer_size);
6903 ranges += arange.ar_pointer_size;
6905 length = byte_get (ranges, arange.ar_pointer_size);
6907 ranges += arange.ar_pointer_size;
6909 /* A pair of zeros marks the end of the list. */
6910 if (address == 0 && length == 0)
6913 printf (" %8.8lx %lu\n", address, length);
6916 start += arange.ar_length + sizeof (external->ar_length);
6924 typedef struct Frame_Chunk
6926 struct Frame_Chunk * next;
6927 unsigned char * chunk_start;
6929 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6930 short int * col_type;
6932 char * augmentation;
6933 unsigned int code_factor;
6934 unsigned int data_factor;
6935 unsigned long pc_begin;
6936 unsigned long pc_range;
6943 /* A marker for a col_type that means this column was never referenced
6944 in the frame info. */
6945 #define DW_CFA_unreferenced (-1)
6948 frame_need_space (fc, reg)
6952 int prev = fc->ncols;
6954 if (reg < fc->ncols)
6957 fc->ncols = reg + 1;
6958 fc->col_type = (short int *) xrealloc (fc->col_type,
6959 fc->ncols * sizeof (short int));
6960 fc->col_offset = (int *) xrealloc (fc->col_offset,
6961 fc->ncols * sizeof (int));
6963 while (prev < fc->ncols)
6965 fc->col_type[prev] = DW_CFA_unreferenced;
6966 fc->col_offset[prev] = 0;
6972 frame_display_row (fc, need_col_headers, max_regs)
6974 int * need_col_headers;
6980 if (* max_regs < fc->ncols)
6981 * max_regs = fc->ncols;
6983 if (* need_col_headers)
6985 * need_col_headers = 0;
6987 printf (" LOC CFA ");
6989 for (r = 0; r < * max_regs; r++)
6990 if (fc->col_type[r] != DW_CFA_unreferenced)
6995 printf ("r%-4d", r);
7001 printf ("%08x ", (unsigned int) fc->pc_begin);
7002 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
7003 printf ("%-8s ", tmp);
7005 for (r = 0; r < fc->ncols; r++)
7007 if (fc->col_type[r] != DW_CFA_unreferenced)
7009 switch (fc->col_type[r])
7011 case DW_CFA_undefined:
7014 case DW_CFA_same_value:
7018 sprintf (tmp, "c%+d", fc->col_offset[r]);
7020 case DW_CFA_register:
7021 sprintf (tmp, "r%d", fc->col_offset[r]);
7024 strcpy (tmp, "n/a");
7027 printf ("%-5s", tmp);
7033 #define GET(N) byte_get (start, N); start += N
7034 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
7035 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
7038 display_debug_frames (section, start, file)
7039 Elf32_Internal_Shdr * section;
7040 unsigned char * start;
7041 FILE * file ATTRIBUTE_UNUSED;
7043 unsigned char * end = start + section->sh_size;
7044 unsigned char * section_start = start;
7045 Frame_Chunk * chunks = 0;
7046 Frame_Chunk * remembered_state = 0;
7048 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
7052 printf (_("The section %s contains:\n"), SECTION_NAME (section));
7056 unsigned char * saved_start;
7057 unsigned char * block_end;
7058 unsigned long length;
7059 unsigned long cie_id;
7062 int need_col_headers = 1;
7064 saved_start = start;
7065 length = byte_get (start, 4); start += 4;
7070 block_end = saved_start + length + 4;
7071 cie_id = byte_get (start, 4); start += 4;
7073 printf ("\n%08x %08lx %08lx ", saved_start - section_start, length, cie_id);
7075 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
7077 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7078 memset (fc, 0, sizeof (Frame_Chunk));
7082 fc->chunk_start = saved_start;
7084 fc->col_type = (short int *) xmalloc (sizeof (short int));
7085 fc->col_offset = (int *) xmalloc (sizeof (int));
7086 frame_need_space (fc, max_regs-1);
7088 start ++; /* version */
7089 fc->augmentation = start;
7094 start++; /* skip past NUL */
7096 if (fc->augmentation[0] == 'z')
7099 fc->code_factor = LEB ();
7100 fc->data_factor = SLEB ();
7101 fc->ra = byte_get (start, 1); start += 1;
7103 printf ("skipping %d extra bytes\n", xtra);
7106 else if (strcmp (fc->augmentation, "eh") == 0)
7109 fc->code_factor = LEB ();
7110 fc->data_factor = SLEB ();
7111 fc->ra = byte_get (start, 1); start += 1;
7115 fc->code_factor = LEB ();
7116 fc->data_factor = SLEB ();
7117 fc->ra = byte_get (start, 1); start += 1;
7120 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n",
7121 fc->augmentation, fc->code_factor, fc->data_factor, fc->ra);
7123 frame_need_space (fc, fc->ra);
7127 unsigned char * look_for;
7128 static Frame_Chunk fde_fc;
7131 memset (fc, 0, sizeof (Frame_Chunk));
7133 look_for = is_eh ? start-4-cie_id : (unsigned char *) cie_id;
7135 fc->pc_begin = byte_get (start, 4); start += 4;
7136 fc->pc_range = byte_get (start, 4); start += 4;
7138 for (cie=chunks; cie && (cie->chunk_start != look_for); cie = cie->next);
7141 warn ("Invalid CIE pointer %08x in FDE at %08x\n", cie_id, saved_start);
7144 fc->col_type = (short int *) xmalloc (sizeof (short int));
7145 fc->col_offset = (int *) xmalloc (sizeof (int));
7146 frame_need_space (fc, max_regs - 1);
7148 fc->augmentation = "";
7152 fc->ncols = cie->ncols;
7153 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
7154 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
7155 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7156 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7157 fc->augmentation = cie->augmentation;
7158 fc->code_factor = cie->code_factor;
7159 fc->data_factor = cie->data_factor;
7160 fc->cfa_reg = cie->cfa_reg;
7161 fc->cfa_offset = cie->cfa_offset;
7163 frame_need_space (fc, max_regs-1);
7166 if (cie->augmentation[0] == 'z')
7168 unsigned long l = LEB ();
7172 printf ("FDE cie=%08x pc=%08lx..%08lx\n",
7173 cie->chunk_start-section_start, fc->pc_begin,
7174 fc->pc_begin + fc->pc_range);
7177 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7178 about to interpret instructions for the chunk. */
7180 /* This exists for readelf maintainers. */
7184 /* Start by making a pass over the chunk, allocating storage
7185 and taking note of what registers are used. */
7186 unsigned char * tmp = start;
7188 while (start < block_end)
7199 /* Warning: if you add any more cases to this switch, be
7200 sure to add them to the corresponding switch below. */
7203 case DW_CFA_advance_loc:
7207 frame_need_space (fc, opa);
7208 fc->col_type[opa] = DW_CFA_undefined;
7210 case DW_CFA_restore:
7211 frame_need_space (fc, opa);
7212 fc->col_type[opa] = DW_CFA_undefined;
7214 case DW_CFA_set_loc:
7215 start += sizeof (vma);
7217 case DW_CFA_advance_loc1:
7220 case DW_CFA_advance_loc2:
7223 case DW_CFA_advance_loc4:
7226 case DW_CFA_offset_extended:
7227 reg = LEB (); LEB ();
7228 frame_need_space (fc, reg);
7229 fc->col_type[reg] = DW_CFA_undefined;
7231 case DW_CFA_restore_extended:
7233 frame_need_space (fc, reg);
7234 fc->col_type[reg] = DW_CFA_undefined;
7236 case DW_CFA_undefined:
7238 frame_need_space (fc, reg);
7239 fc->col_type[reg] = DW_CFA_undefined;
7241 case DW_CFA_same_value:
7243 frame_need_space (fc, reg);
7244 fc->col_type[reg] = DW_CFA_undefined;
7246 case DW_CFA_register:
7247 reg = LEB (); LEB ();
7248 frame_need_space (fc, reg);
7249 fc->col_type[reg] = DW_CFA_undefined;
7251 case DW_CFA_def_cfa:
7254 case DW_CFA_def_cfa_register:
7257 case DW_CFA_def_cfa_offset:
7260 #ifndef DW_CFA_GNU_args_size
7261 #define DW_CFA_GNU_args_size 0x2e
7263 case DW_CFA_GNU_args_size:
7266 #ifndef DW_CFA_GNU_negative_offset_extended
7267 #define DW_CFA_GNU_negative_offset_extended 0x2f
7269 case DW_CFA_GNU_negative_offset_extended:
7270 reg = LEB (); LEB ();
7271 frame_need_space (fc, reg);
7272 fc->col_type[reg] = DW_CFA_undefined;
7281 /* Now we know what registers are used, make a second pass over
7282 the chunk, this time actually printing out the info. */
7284 while (start < block_end)
7287 unsigned long ul, reg, roffs;
7296 /* Warning: if you add any more cases to this switch, be
7297 sure to add them to the corresponding switch above. */
7300 case DW_CFA_advance_loc:
7301 frame_display_row (fc, &need_col_headers, &max_regs);
7303 printf (" DW_CFA_advance_loc: %08x = %08x + %d*%d\n",
7304 fc->pc_begin + opa * fc->code_factor, fc->pc_begin, opa, fc->code_factor);
7306 fc->pc_begin += opa * fc->code_factor;
7312 printf (" DW_CFA_offset: r%d = cfa[%d*%d]\n", opa, roffs, fc->data_factor);
7314 fc->col_type[opa] = DW_CFA_offset;
7315 fc->col_offset[opa] = roffs * fc->data_factor;
7318 case DW_CFA_restore:
7320 printf (" DW_CFA_restore: r%d\n", opa);
7322 fc->col_type[opa] = cie->col_type[opa];
7323 fc->col_offset[opa] = cie->col_offset[opa];
7326 case DW_CFA_set_loc:
7327 frame_display_row (fc, &need_col_headers, &max_regs);
7328 vma = byte_get (start, sizeof (vma)); start += sizeof (vma);
7330 printf (" DW_CFA_set_loc: %08x\n", vma);
7335 case DW_CFA_advance_loc1:
7336 frame_display_row (fc, &need_col_headers, &max_regs);
7337 ofs = byte_get (start, 1); start += 1;
7339 printf (" DW_CFA_advance_loc1: %08x = %08x + %d*%d\n",
7340 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7342 fc->pc_begin += ofs * fc->code_factor;
7345 case DW_CFA_advance_loc2:
7346 frame_display_row (fc, &need_col_headers, &max_regs);
7347 ofs = byte_get (start, 2); start += 2;
7349 printf (" DW_CFA_advance_loc2: %08x = %08x + %d*%d\n",
7350 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7352 fc->pc_begin += ofs * fc->code_factor;
7355 case DW_CFA_advance_loc4:
7356 frame_display_row (fc, &need_col_headers, &max_regs);
7357 ofs = byte_get (start, 4); start += 4;
7359 printf (" DW_CFA_advance_loc4: %08x = %08x + %d*%d\n",
7360 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7362 fc->pc_begin += ofs * fc->code_factor;
7365 case DW_CFA_offset_extended:
7369 printf (" DW_CFA_offset_extended: r%d = cfa[%d*%d]\n", reg, roffs, fc->data_factor);
7371 fc->col_type[reg] = DW_CFA_offset;
7372 fc->col_offset[reg] = roffs * fc->data_factor;
7375 case DW_CFA_restore_extended:
7378 printf (" DW_CFA_restore_extended: r%d\n", reg);
7380 fc->col_type[reg] = cie->col_type[reg];
7381 fc->col_offset[reg] = cie->col_offset[reg];
7384 case DW_CFA_undefined:
7387 printf (" DW_CFA_undefined: r%d\n", reg);
7389 fc->col_type[reg] = DW_CFA_undefined;
7390 fc->col_offset[reg] = 0;
7393 case DW_CFA_same_value:
7396 printf (" DW_CFA_same_value: r%d\n", reg);
7398 fc->col_type[reg] = DW_CFA_same_value;
7399 fc->col_offset[reg] = 0;
7402 case DW_CFA_register:
7406 printf (" DW_CFA_register: r%d\n", reg);
7408 fc->col_type[reg] = DW_CFA_register;
7409 fc->col_offset[reg] = roffs;
7412 case DW_CFA_remember_state:
7414 printf (" DW_CFA_remember_state\n");
7416 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7417 rs->ncols = fc->ncols;
7418 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
7419 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
7420 memcpy (rs->col_type, fc->col_type, rs->ncols);
7421 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
7422 rs->next = remembered_state;
7423 remembered_state = rs;
7426 case DW_CFA_restore_state:
7428 printf (" DW_CFA_restore_state\n");
7430 rs = remembered_state;
7431 remembered_state = rs->next;
7432 frame_need_space (fc, rs->ncols-1);
7433 memcpy (fc->col_type, rs->col_type, rs->ncols);
7434 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
7435 free (rs->col_type);
7436 free (rs->col_offset);
7440 case DW_CFA_def_cfa:
7441 fc->cfa_reg = LEB ();
7442 fc->cfa_offset = LEB ();
7444 printf (" DW_CFA_def_cfa: reg %d ofs %d\n", fc->cfa_reg, fc->cfa_offset);
7448 case DW_CFA_def_cfa_register:
7449 fc->cfa_reg = LEB ();
7451 printf (" DW_CFA_def_cfa_reg: %d\n", fc->cfa_reg);
7455 case DW_CFA_def_cfa_offset:
7456 fc->cfa_offset = LEB ();
7458 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
7464 printf (" DW_CFA_nop\n");
7468 #ifndef DW_CFA_GNU_window_save
7469 #define DW_CFA_GNU_window_save 0x2d
7471 case DW_CFA_GNU_window_save:
7473 printf (" DW_CFA_GNU_window_save\n");
7477 #ifndef DW_CFA_GNU_args_size
7478 #define DW_CFA_GNU_args_size 0x2e
7480 case DW_CFA_GNU_args_size:
7483 printf (" DW_CFA_GNU_args_size: %d\n", ul);
7487 #ifndef DW_CFA_GNU_negative_offset_extended
7488 #define DW_CFA_GNU_negative_offset_extended 0x2f
7490 case DW_CFA_GNU_negative_offset_extended:
7493 frame_need_space (fc, reg);
7495 printf (" DW_CFA_GNU_negative_offset_extended: r%d = cfa[%d*%d]\n", reg, l, fc->data_factor);
7497 fc->col_type[reg] = DW_CFA_offset;
7498 fc->col_offset[reg] = l * fc->data_factor;
7502 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
7507 frame_display_row (fc, &need_col_headers, &max_regs);
7522 display_debug_not_supported (section, start, file)
7523 Elf32_Internal_Shdr * section;
7524 unsigned char * start ATTRIBUTE_UNUSED;
7525 FILE * file ATTRIBUTE_UNUSED;
7527 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7528 SECTION_NAME (section));
7533 /* Pre-scan the .debug_info section to record the size of address.
7534 When dumping the .debug_line, we use that size information, assuming
7535 that all compilation units have the same address size. */
7537 prescan_debug_info (section, start, file)
7538 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
7539 unsigned char * start;
7540 FILE * file ATTRIBUTE_UNUSED;
7542 DWARF2_External_CompUnit * external;
7544 external = (DWARF2_External_CompUnit *) start;
7546 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
7550 /* A structure containing the name of a debug section and a pointer
7551 to a function that can decode it. The third field is a prescan
7552 function to be run over the section before displaying any of the
7557 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7558 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7562 { ".debug_info", display_debug_info, prescan_debug_info },
7563 { ".debug_abbrev", display_debug_abbrev, NULL },
7564 { ".debug_line", display_debug_lines, NULL },
7565 { ".debug_aranges", display_debug_aranges, NULL },
7566 { ".debug_pubnames", display_debug_pubnames, NULL },
7567 { ".debug_frame", display_debug_frames, NULL },
7568 { ".eh_frame", display_debug_frames, NULL },
7569 { ".debug_macinfo", display_debug_not_supported, NULL },
7570 { ".debug_frame", display_debug_not_supported, NULL },
7571 { ".debug_str", display_debug_not_supported, NULL },
7572 { ".debug_static_func", display_debug_not_supported, NULL },
7573 { ".debug_static_vars", display_debug_not_supported, NULL },
7574 { ".debug_types", display_debug_not_supported, NULL },
7575 { ".debug_weaknames", display_debug_not_supported, NULL }
7579 display_debug_section (section, file)
7580 Elf32_Internal_Shdr * section;
7583 char * name = SECTION_NAME (section);
7584 bfd_size_type length;
7585 unsigned char * start;
7588 length = section->sh_size;
7591 printf (_("\nSection '%s' has no debugging data.\n"), name);
7595 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7596 "debug section data");
7598 /* See if we know how to display the contents of this section. */
7599 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
7600 name = ".debug_info";
7602 for (i = NUM_ELEM (debug_displays); i--;)
7603 if (strcmp (debug_displays[i].name, name) == 0)
7605 debug_displays[i].display (section, start, file);
7610 printf (_("Unrecognised debug section: %s\n"), name);
7614 /* If we loaded in the abbrev section at some point,
7615 we must release it here. */
7616 if (first_abbrev != NULL)
7623 process_section_contents (file)
7626 Elf32_Internal_Shdr * section;
7632 /* Pre-scan the debug sections to find some debug information not
7633 present in some of them. For the .debug_line, we must find out the
7634 size of address (specified in .debug_info and .debug_aranges). */
7635 for (i = 0, section = section_headers;
7636 i < elf_header.e_shnum && i < num_dump_sects;
7639 char * name = SECTION_NAME (section);
7642 if (section->sh_size == 0)
7645 /* See if there is some pre-scan operation for this section. */
7646 for (j = NUM_ELEM (debug_displays); j--;)
7647 if (strcmp (debug_displays[j].name, name) == 0)
7649 if (debug_displays[j].prescan != NULL)
7651 bfd_size_type length;
7652 unsigned char * start;
7654 length = section->sh_size;
7655 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7656 "debug section data");
7658 debug_displays[j].prescan (section, start, file);
7666 for (i = 0, section = section_headers;
7667 i < elf_header.e_shnum && i < num_dump_sects;
7670 #ifdef SUPPORT_DISASSEMBLY
7671 if (dump_sects[i] & DISASS_DUMP)
7672 disassemble_section (section, file);
7674 if (dump_sects[i] & HEX_DUMP)
7675 dump_section (section, file);
7677 if (dump_sects[i] & DEBUG_DUMP)
7678 display_debug_section (section, file);
7681 if (i < num_dump_sects)
7682 warn (_("Some sections were not dumped because they do not exist!\n"));
7688 process_mips_fpe_exception (mask)
7694 if (mask & OEX_FPU_INEX)
7695 fputs ("INEX", stdout), first = 0;
7696 if (mask & OEX_FPU_UFLO)
7697 printf ("%sUFLO", first ? "" : "|"), first = 0;
7698 if (mask & OEX_FPU_OFLO)
7699 printf ("%sOFLO", first ? "" : "|"), first = 0;
7700 if (mask & OEX_FPU_DIV0)
7701 printf ("%sDIV0", first ? "" : "|"), first = 0;
7702 if (mask & OEX_FPU_INVAL)
7703 printf ("%sINVAL", first ? "" : "|");
7706 fputs ("0", stdout);
7710 process_mips_specific (file)
7713 Elf_Internal_Dyn * entry;
7714 size_t liblist_offset = 0;
7715 size_t liblistno = 0;
7716 size_t conflictsno = 0;
7717 size_t options_offset = 0;
7718 size_t conflicts_offset = 0;
7720 /* We have a lot of special sections. Thanks SGI! */
7721 if (dynamic_segment == NULL)
7722 /* No information available. */
7725 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
7726 switch (entry->d_tag)
7728 case DT_MIPS_LIBLIST:
7729 liblist_offset = entry->d_un.d_val - loadaddr;
7731 case DT_MIPS_LIBLISTNO:
7732 liblistno = entry->d_un.d_val;
7734 case DT_MIPS_OPTIONS:
7735 options_offset = entry->d_un.d_val - loadaddr;
7737 case DT_MIPS_CONFLICT:
7738 conflicts_offset = entry->d_un.d_val - loadaddr;
7740 case DT_MIPS_CONFLICTNO:
7741 conflictsno = entry->d_un.d_val;
7747 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
7749 Elf32_External_Lib * elib;
7752 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
7753 elib, Elf32_External_Lib *, "liblist");
7755 printf ("\nSection '.liblist' contains %lu entries:\n",
7756 (unsigned long) liblistno);
7757 fputs (" Library Time Stamp Checksum Version Flags\n",
7760 for (cnt = 0; cnt < liblistno; ++cnt)
7767 liblist.l_name = BYTE_GET (elib[cnt].l_name);
7768 time = BYTE_GET (elib[cnt].l_time_stamp);
7769 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
7770 liblist.l_version = BYTE_GET (elib[cnt].l_version);
7771 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
7773 tmp = gmtime (&time);
7774 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
7775 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7776 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7778 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
7779 dynamic_strings + liblist.l_name, timebuf,
7780 liblist.l_checksum, liblist.l_version);
7782 if (liblist.l_flags == 0)
7793 { " EXACT_MATCH", LL_EXACT_MATCH },
7794 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
7795 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
7796 { " EXPORTS", LL_EXPORTS },
7797 { " DELAY_LOAD", LL_DELAY_LOAD },
7798 { " DELTA", LL_DELTA }
7800 int flags = liblist.l_flags;
7804 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
7806 if ((flags & l_flags_vals[fcnt].bit) != 0)
7808 fputs (l_flags_vals[fcnt].name, stdout);
7809 flags ^= l_flags_vals[fcnt].bit;
7812 printf (" %#x", (unsigned int) flags);
7821 if (options_offset != 0)
7823 Elf_External_Options * eopt;
7824 Elf_Internal_Shdr * sect = section_headers;
7825 Elf_Internal_Options * iopt;
7826 Elf_Internal_Options * option;
7830 /* Find the section header so that we get the size. */
7831 while (sect->sh_type != SHT_MIPS_OPTIONS)
7834 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
7835 Elf_External_Options *, "options");
7837 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
7841 error (_("Out of memory"));
7848 while (offset < sect->sh_size)
7850 Elf_External_Options * eoption;
7852 eoption = (Elf_External_Options *) ((char *) eopt + offset);
7854 option->kind = BYTE_GET (eoption->kind);
7855 option->size = BYTE_GET (eoption->size);
7856 option->section = BYTE_GET (eoption->section);
7857 option->info = BYTE_GET (eoption->info);
7859 offset += option->size;
7865 printf (_("\nSection '%s' contains %d entries:\n"),
7866 SECTION_NAME (sect), cnt);
7874 switch (option->kind)
7877 /* This shouldn't happen. */
7878 printf (" NULL %d %lx", option->section, option->info);
7881 printf (" REGINFO ");
7882 if (elf_header.e_machine == EM_MIPS)
7885 Elf32_External_RegInfo * ereg;
7886 Elf32_RegInfo reginfo;
7888 ereg = (Elf32_External_RegInfo *) (option + 1);
7889 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7890 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7891 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7892 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7893 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7894 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
7896 printf ("GPR %08lx GP 0x%lx\n",
7898 (unsigned long) reginfo.ri_gp_value);
7899 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7900 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7901 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7906 Elf64_External_RegInfo * ereg;
7907 Elf64_Internal_RegInfo reginfo;
7909 ereg = (Elf64_External_RegInfo *) (option + 1);
7910 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7911 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7912 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7913 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7914 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7915 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
7917 printf ("GPR %08lx GP 0x",
7918 reginfo.ri_gprmask);
7919 printf_vma (reginfo.ri_gp_value);
7922 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7923 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7924 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7928 case ODK_EXCEPTIONS:
7929 fputs (" EXCEPTIONS fpe_min(", stdout);
7930 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
7931 fputs (") fpe_max(", stdout);
7932 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
7933 fputs (")", stdout);
7935 if (option->info & OEX_PAGE0)
7936 fputs (" PAGE0", stdout);
7937 if (option->info & OEX_SMM)
7938 fputs (" SMM", stdout);
7939 if (option->info & OEX_FPDBUG)
7940 fputs (" FPDBUG", stdout);
7941 if (option->info & OEX_DISMISS)
7942 fputs (" DISMISS", stdout);
7945 fputs (" PAD ", stdout);
7946 if (option->info & OPAD_PREFIX)
7947 fputs (" PREFIX", stdout);
7948 if (option->info & OPAD_POSTFIX)
7949 fputs (" POSTFIX", stdout);
7950 if (option->info & OPAD_SYMBOL)
7951 fputs (" SYMBOL", stdout);
7954 fputs (" HWPATCH ", stdout);
7955 if (option->info & OHW_R4KEOP)
7956 fputs (" R4KEOP", stdout);
7957 if (option->info & OHW_R8KPFETCH)
7958 fputs (" R8KPFETCH", stdout);
7959 if (option->info & OHW_R5KEOP)
7960 fputs (" R5KEOP", stdout);
7961 if (option->info & OHW_R5KCVTL)
7962 fputs (" R5KCVTL", stdout);
7965 fputs (" FILL ", stdout);
7966 /* XXX Print content of info word? */
7969 fputs (" TAGS ", stdout);
7970 /* XXX Print content of info word? */
7973 fputs (" HWAND ", stdout);
7974 if (option->info & OHWA0_R4KEOP_CHECKED)
7975 fputs (" R4KEOP_CHECKED", stdout);
7976 if (option->info & OHWA0_R4KEOP_CLEAN)
7977 fputs (" R4KEOP_CLEAN", stdout);
7980 fputs (" HWOR ", stdout);
7981 if (option->info & OHWA0_R4KEOP_CHECKED)
7982 fputs (" R4KEOP_CHECKED", stdout);
7983 if (option->info & OHWA0_R4KEOP_CLEAN)
7984 fputs (" R4KEOP_CLEAN", stdout);
7987 printf (" GP_GROUP %#06lx self-contained %#06lx",
7988 option->info & OGP_GROUP,
7989 (option->info & OGP_SELF) >> 16);
7992 printf (" IDENT %#06lx self-contained %#06lx",
7993 option->info & OGP_GROUP,
7994 (option->info & OGP_SELF) >> 16);
7997 /* This shouldn't happen. */
7998 printf (" %3d ??? %d %lx",
7999 option->kind, option->section, option->info);
8003 len = sizeof (* eopt);
8004 while (len < option->size)
8005 if (((char *) option)[len] >= ' '
8006 && ((char *) option)[len] < 0x7f)
8007 printf ("%c", ((char *) option)[len++]);
8009 printf ("\\%03o", ((char *) option)[len++]);
8011 fputs ("\n", stdout);
8018 if (conflicts_offset != 0 && conflictsno != 0)
8020 Elf32_External_Conflict * econf32;
8021 Elf64_External_Conflict * econf64;
8022 Elf32_Conflict * iconf;
8025 if (dynamic_symbols == NULL)
8027 error (_("conflict list with without table"));
8031 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
8034 error (_("Out of memory"));
8040 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf32),
8041 econf32, Elf32_External_Conflict *, "conflict");
8043 for (cnt = 0; cnt < conflictsno; ++cnt)
8044 iconf[cnt] = BYTE_GET (econf32[cnt]);
8048 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf64),
8049 econf64, Elf64_External_Conflict *, "conflict");
8051 for (cnt = 0; cnt < conflictsno; ++cnt)
8052 iconf[cnt] = BYTE_GET (econf64[cnt]);
8055 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
8056 puts (_(" Num: Index Value Name"));
8058 for (cnt = 0; cnt < conflictsno; ++cnt)
8060 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
8062 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
8063 print_vma (psym->st_value, FULL_HEX);
8064 printf (" %s\n", dynamic_strings + psym->st_name);
8074 get_note_type (e_type)
8077 static char buff[64];
8081 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
8082 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
8083 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
8084 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
8085 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
8086 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
8087 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
8088 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
8089 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8090 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8091 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8093 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
8098 /* Note that by the ELF standard, the name field is already null byte
8099 terminated, and namesz includes the terminating null byte.
8100 I.E. the value of namesz for the name "FSF" is 4.
8102 If the value of namesz is zero, there is no name present. */
8104 process_note (pnote)
8105 Elf32_Internal_Note * pnote;
8107 printf (" %s\t\t0x%08lx\t%s\n",
8108 pnote->namesz ? pnote->namedata : "(NONE)",
8109 pnote->descsz, get_note_type (pnote->type));
8115 process_corefile_note_segment (file, offset, length)
8120 Elf_External_Note * pnotes;
8121 Elf_External_Note * external;
8127 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
8131 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8132 (unsigned long) offset, (unsigned long) length);
8133 printf (_(" Owner\t\tData size\tDescription\n"));
8135 while (external < (Elf_External_Note *)((char *) pnotes + length))
8137 Elf32_Internal_Note inote;
8140 inote.type = BYTE_GET (external->type);
8141 inote.namesz = BYTE_GET (external->namesz);
8142 inote.namedata = external->name;
8143 inote.descsz = BYTE_GET (external->descsz);
8144 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8145 inote.descpos = offset + (inote.descdata - (char *) pnotes);
8147 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8149 /* Verify that name is null terminated. It appears that at least
8150 one version of Linux (RedHat 6.0) generates corefiles that don't
8151 comply with the ELF spec by failing to include the null byte in
8153 if (inote.namedata[inote.namesz] != '\0')
8155 temp = malloc (inote.namesz + 1);
8159 error (_("Out of memory\n"));
8164 strncpy (temp, inote.namedata, inote.namesz);
8165 temp[inote.namesz] = 0;
8167 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8168 inote.namedata = temp;
8171 res &= process_note (& inote);
8186 process_corefile_note_segments (file)
8189 Elf_Internal_Phdr * program_headers;
8190 Elf_Internal_Phdr * segment;
8194 program_headers = (Elf_Internal_Phdr *) malloc
8195 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
8197 if (program_headers == NULL)
8199 error (_("Out of memory\n"));
8204 i = get_32bit_program_headers (file, program_headers);
8206 i = get_64bit_program_headers (file, program_headers);
8210 free (program_headers);
8214 for (i = 0, segment = program_headers;
8215 i < elf_header.e_phnum;
8218 if (segment->p_type == PT_NOTE)
8219 res &= process_corefile_note_segment (file,
8220 (bfd_vma) segment->p_offset,
8221 (bfd_vma) segment->p_filesz);
8224 free (program_headers);
8230 process_corefile_contents (file)
8233 /* If we have not been asked to display the notes then do nothing. */
8237 /* If file is not a core file then exit. */
8238 if (elf_header.e_type != ET_CORE)
8241 /* No program headers means no NOTE segment. */
8242 if (elf_header.e_phnum == 0)
8244 printf (_("No note segments present in the core file.\n"));
8248 return process_corefile_note_segments (file);
8252 process_arch_specific (file)
8258 switch (elf_header.e_machine)
8261 case EM_MIPS_RS4_BE:
8262 return process_mips_specific (file);
8271 get_file_header (file)
8274 /* Read in the identity array. */
8275 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8278 /* Determine how to read the rest of the header. */
8279 switch (elf_header.e_ident [EI_DATA])
8281 default: /* fall through */
8282 case ELFDATANONE: /* fall through */
8283 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
8284 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
8287 /* For now we only support 32 bit and 64 bit ELF files. */
8288 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
8290 /* Read in the rest of the header. */
8293 Elf32_External_Ehdr ehdr32;
8295 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8298 elf_header.e_type = BYTE_GET (ehdr32.e_type);
8299 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
8300 elf_header.e_version = BYTE_GET (ehdr32.e_version);
8301 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
8302 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
8303 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
8304 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
8305 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
8306 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8307 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
8308 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8309 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
8310 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
8314 Elf64_External_Ehdr ehdr64;
8316 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8317 we will not be able to cope with the 64bit data found in
8318 64 ELF files. Detect this now and abort before we start
8319 overwritting things. */
8320 if (sizeof (bfd_vma) < 8)
8322 error (_("This instance of readelf has been built without support for a\n"));
8323 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
8327 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
8330 elf_header.e_type = BYTE_GET (ehdr64.e_type);
8331 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
8332 elf_header.e_version = BYTE_GET (ehdr64.e_version);
8333 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
8334 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
8335 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
8336 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
8337 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
8338 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
8339 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
8340 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
8341 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
8342 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
8349 process_file (file_name)
8353 struct stat statbuf;
8356 if (stat (file_name, & statbuf) < 0)
8358 error (_("Cannot stat input file %s.\n"), file_name);
8362 file = fopen (file_name, "rb");
8365 error (_("Input file %s not found.\n"), file_name);
8369 if (! get_file_header (file))
8371 error (_("%s: Failed to read file header\n"), file_name);
8376 /* Initialise per file variables. */
8377 for (i = NUM_ELEM (version_info); i--;)
8378 version_info[i] = 0;
8380 for (i = NUM_ELEM (dynamic_info); i--;)
8381 dynamic_info[i] = 0;
8383 /* Process the file. */
8385 printf (_("\nFile: %s\n"), file_name);
8387 if (! process_file_header ())
8393 process_section_headers (file);
8395 process_program_headers (file);
8397 process_dynamic_segment (file);
8399 process_relocs (file);
8401 process_unwind (file);
8403 process_symbol_table (file);
8405 process_syminfo (file);
8407 process_version_sections (file);
8409 process_section_contents (file);
8411 process_corefile_contents (file);
8413 process_arch_specific (file);
8417 if (section_headers)
8419 free (section_headers);
8420 section_headers = NULL;
8425 free (string_table);
8426 string_table = NULL;
8427 string_table_length = 0;
8430 if (dynamic_strings)
8432 free (dynamic_strings);
8433 dynamic_strings = NULL;
8436 if (dynamic_symbols)
8438 free (dynamic_symbols);
8439 dynamic_symbols = NULL;
8440 num_dynamic_syms = 0;
8443 if (dynamic_syminfo)
8445 free (dynamic_syminfo);
8446 dynamic_syminfo = NULL;
8450 #ifdef SUPPORT_DISASSEMBLY
8451 /* Needed by the i386 disassembler. For extra credit, someone could
8452 fix this so that we insert symbolic addresses here, esp for GOT/PLT
8456 print_address (unsigned int addr, FILE * outfile)
8458 fprintf (outfile,"0x%8.8x", addr);
8461 /* Needed by the i386 disassembler. */
8463 db_task_printsym (unsigned int addr)
8465 print_address (addr, stderr);
8474 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
8475 setlocale (LC_MESSAGES, "");
8477 bindtextdomain (PACKAGE, LOCALEDIR);
8478 textdomain (PACKAGE);
8480 parse_args (argc, argv);
8482 if (optind < (argc - 1))
8485 while (optind < argc)
8486 process_file (argv [optind ++]);
8488 if (dump_sects != NULL)