1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 99, 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;
3414 memset (& aux, 0, sizeof (aux));
3416 addr_size = is_32bit_elf ? 4 : 8;
3421 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
3423 if (sec->sh_type == SHT_SYMTAB)
3425 aux.nsyms = sec->sh_size / sec->sh_entsize;
3426 aux.symtab = GET_ELF_SYMBOLS (file, sec->sh_offset, aux.nsyms);
3428 strsec = section_headers + sec->sh_link;
3429 aux.strtab_size = strsec->sh_size;
3430 GET_DATA_ALLOC (strsec->sh_offset, aux.strtab_size,
3431 aux.strtab, const char *, "string table");
3433 else if (sec->sh_type == SHT_IA_64_UNWIND)
3435 else if (strcmp (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info) == 0)
3437 aux.info_size = sec->sh_size;
3438 aux.info_addr = sec->sh_addr;
3439 GET_DATA_ALLOC (sec->sh_offset, aux.info_size, aux.info,
3440 char *, "unwind info");
3446 printf (_("\nUnwind section "));
3448 if (string_table == NULL)
3449 printf ("%d", unwsec->sh_name);
3451 printf ("'%s'", SECTION_NAME (unwsec));
3453 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3454 unwsec->sh_offset, (unsigned long) (unwsec->sh_size / (3 * addr_size)));
3456 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
3458 if (aux.table_len > 0)
3459 dump_ia64_unwind (& aux);
3462 printf (_("\nThere are no unwind sections in this file.\n"));
3465 free ((char *) aux.table);
3467 free ((char *) aux.info);
3471 free ((char *) aux.strtab);
3477 dynamic_segment_mips_val (entry)
3478 Elf_Internal_Dyn * entry;
3480 switch (entry->d_tag)
3483 if (entry->d_un.d_val == 0)
3487 static const char * opts[] =
3489 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3490 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3491 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3492 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3497 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
3498 if (entry->d_un.d_val & (1 << cnt))
3500 printf ("%s%s", first ? "" : " ", opts[cnt]);
3507 case DT_MIPS_IVERSION:
3508 if (dynamic_strings != NULL)
3509 printf ("Interface Version: %s\n",
3510 dynamic_strings + entry->d_un.d_val);
3512 printf ("%ld\n", (long) entry->d_un.d_ptr);
3515 case DT_MIPS_TIME_STAMP:
3520 time_t time = entry->d_un.d_val;
3521 tmp = gmtime (&time);
3522 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
3523 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
3524 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
3525 printf ("Time Stamp: %s\n", timebuf);
3529 case DT_MIPS_RLD_VERSION:
3530 case DT_MIPS_LOCAL_GOTNO:
3531 case DT_MIPS_CONFLICTNO:
3532 case DT_MIPS_LIBLISTNO:
3533 case DT_MIPS_SYMTABNO:
3534 case DT_MIPS_UNREFEXTNO:
3535 case DT_MIPS_HIPAGENO:
3536 case DT_MIPS_DELTA_CLASS_NO:
3537 case DT_MIPS_DELTA_INSTANCE_NO:
3538 case DT_MIPS_DELTA_RELOC_NO:
3539 case DT_MIPS_DELTA_SYM_NO:
3540 case DT_MIPS_DELTA_CLASSSYM_NO:
3541 case DT_MIPS_COMPACT_SIZE:
3542 printf ("%ld\n", (long) entry->d_un.d_ptr);
3546 printf ("%#lx\n", (long) entry->d_un.d_ptr);
3552 dynamic_segment_parisc_val (entry)
3553 Elf_Internal_Dyn * entry;
3555 switch (entry->d_tag)
3557 case DT_HP_DLD_FLAGS:
3566 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
3567 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
3568 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
3569 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
3570 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
3571 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
3572 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
3573 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
3574 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
3575 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
3576 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
3580 bfd_vma val = entry->d_un.d_val;
3582 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
3583 if (val & flags[cnt].bit)
3587 fputs (flags[cnt].str, stdout);
3589 val ^= flags[cnt].bit;
3592 if (val != 0 || first)
3596 print_vma (val, HEX);
3602 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
3608 get_32bit_dynamic_segment (file)
3611 Elf32_External_Dyn * edyn;
3612 Elf_Internal_Dyn * entry;
3615 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3616 edyn, Elf32_External_Dyn *, "dynamic segment");
3618 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3619 how large this .dynamic is now. We can do this even before the byte
3620 swapping since the DT_NULL tag is recognizable. */
3622 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
3625 dynamic_segment = (Elf_Internal_Dyn *)
3626 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3628 if (dynamic_segment == NULL)
3630 error (_("Out of memory\n"));
3635 for (i = 0, entry = dynamic_segment;
3639 entry->d_tag = BYTE_GET (edyn [i].d_tag);
3640 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
3649 get_64bit_dynamic_segment (file)
3652 Elf64_External_Dyn * edyn;
3653 Elf_Internal_Dyn * entry;
3656 GET_DATA_ALLOC (dynamic_addr, dynamic_size,
3657 edyn, Elf64_External_Dyn *, "dynamic segment");
3659 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3660 how large this .dynamic is now. We can do this even before the byte
3661 swapping since the DT_NULL tag is recognizable. */
3663 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
3666 dynamic_segment = (Elf_Internal_Dyn *)
3667 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
3669 if (dynamic_segment == NULL)
3671 error (_("Out of memory\n"));
3676 for (i = 0, entry = dynamic_segment;
3680 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
3681 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
3690 get_dynamic_flags (flags)
3693 static char buff [64];
3698 flag = flags & - flags;
3703 case DF_ORIGIN: strcat (buff, "ORIGIN "); break;
3704 case DF_SYMBOLIC: strcat (buff, "SYMBOLIC "); break;
3705 case DF_TEXTREL: strcat (buff, "TEXTREL "); break;
3706 case DF_BIND_NOW: strcat (buff, "BIND_NOW "); break;
3707 default: strcat (buff, "unknown "); break;
3713 /* Parse and display the contents of the dynamic segment. */
3715 process_dynamic_segment (file)
3718 Elf_Internal_Dyn * entry;
3721 if (dynamic_size == 0)
3724 printf (_("\nThere is no dynamic segment in this file.\n"));
3731 if (! get_32bit_dynamic_segment (file))
3734 else if (! get_64bit_dynamic_segment (file))
3737 /* Find the appropriate symbol table. */
3738 if (dynamic_symbols == NULL)
3740 for (i = 0, entry = dynamic_segment;
3744 unsigned long offset;
3746 if (entry->d_tag != DT_SYMTAB)
3749 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
3751 /* Since we do not know how big the symbol table is,
3752 we default to reading in the entire file (!) and
3753 processing that. This is overkill, I know, but it
3755 offset = entry->d_un.d_val - loadaddr;
3757 if (fseek (file, 0, SEEK_END))
3758 error (_("Unable to seek to end of file!"));
3761 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf32_External_Sym);
3763 num_dynamic_syms = (ftell (file) - offset) / sizeof (Elf64_External_Sym);
3765 if (num_dynamic_syms < 1)
3767 error (_("Unable to determine the number of symbols to load\n"));
3771 dynamic_symbols = GET_ELF_SYMBOLS (file, offset, num_dynamic_syms);
3775 /* Similarly find a string table. */
3776 if (dynamic_strings == NULL)
3778 for (i = 0, entry = dynamic_segment;
3782 unsigned long offset;
3785 if (entry->d_tag != DT_STRTAB)
3788 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
3790 /* Since we do not know how big the string table is,
3791 we default to reading in the entire file (!) and
3792 processing that. This is overkill, I know, but it
3795 offset = entry->d_un.d_val - loadaddr;
3796 if (fseek (file, 0, SEEK_END))
3797 error (_("Unable to seek to end of file\n"));
3798 str_tab_len = ftell (file) - offset;
3800 if (str_tab_len < 1)
3803 (_("Unable to determine the length of the dynamic string table\n"));
3807 GET_DATA_ALLOC (offset, str_tab_len, dynamic_strings, char *,
3808 "dynamic string table");
3814 /* And find the syminfo section if available. */
3815 if (dynamic_syminfo == NULL)
3817 unsigned int syminsz = 0;
3819 for (i = 0, entry = dynamic_segment;
3823 if (entry->d_tag == DT_SYMINENT)
3825 /* Note: these braces are necessary to avoid a syntax
3826 error from the SunOS4 C compiler. */
3827 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
3829 else if (entry->d_tag == DT_SYMINSZ)
3830 syminsz = entry->d_un.d_val;
3831 else if (entry->d_tag == DT_SYMINFO)
3832 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
3835 if (dynamic_syminfo_offset != 0 && syminsz != 0)
3837 Elf_External_Syminfo * extsyminfo;
3838 Elf_Internal_Syminfo * syminfo;
3840 /* There is a syminfo section. Read the data. */
3841 GET_DATA_ALLOC (dynamic_syminfo_offset, syminsz, extsyminfo,
3842 Elf_External_Syminfo *, "symbol information");
3844 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
3845 if (dynamic_syminfo == NULL)
3847 error (_("Out of memory\n"));
3851 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
3852 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
3855 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
3856 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
3863 if (do_dynamic && dynamic_addr)
3864 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3865 dynamic_addr, (long) dynamic_size);
3867 printf (_(" Tag Type Name/Value\n"));
3869 for (i = 0, entry = dynamic_segment;
3878 print_vma (entry->d_tag, FULL_HEX);
3879 dtype = get_dynamic_type (entry->d_tag);
3880 printf (" (%s)%*s", dtype,
3881 ((is_32bit_elf ? 27 : 19)
3882 - (int) strlen (dtype)),
3886 switch (entry->d_tag)
3890 printf ("%s", get_dynamic_flags (entry->d_un.d_val));
3900 switch (entry->d_tag)
3903 printf (_("Auxiliary library"));
3907 printf (_("Filter library"));
3911 printf (_("Configuration file"));
3915 printf (_("Dependency audit library"));
3919 printf (_("Audit library"));
3923 if (dynamic_strings)
3924 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
3928 print_vma (entry->d_un.d_val, PREFIX_HEX);
3937 printf (_("Flags:"));
3938 if (entry->d_un.d_val == 0)
3939 printf (_(" None\n"));
3942 unsigned long int val = entry->d_un.d_val;
3943 if (val & DTF_1_PARINIT)
3945 printf (" PARINIT");
3946 val ^= DTF_1_PARINIT;
3948 if (val & DTF_1_CONFEXP)
3950 printf (" CONFEXP");
3951 val ^= DTF_1_CONFEXP;
3954 printf (" %lx", val);
3963 printf (_("Flags:"));
3964 if (entry->d_un.d_val == 0)
3965 printf (_(" None\n"));
3968 unsigned long int val = entry->d_un.d_val;
3969 if (val & DF_P1_LAZYLOAD)
3971 printf (" LAZYLOAD");
3972 val ^= DF_P1_LAZYLOAD;
3974 if (val & DF_P1_GROUPPERM)
3976 printf (" GROUPPERM");
3977 val ^= DF_P1_GROUPPERM;
3980 printf (" %lx", val);
3989 printf (_("Flags:"));
3990 if (entry->d_un.d_val == 0)
3991 printf (_(" None\n"));
3994 unsigned long int val = entry->d_un.d_val;
4000 if (val & DF_1_GLOBAL)
4005 if (val & DF_1_GROUP)
4010 if (val & DF_1_NODELETE)
4012 printf (" NODELETE");
4013 val ^= DF_1_NODELETE;
4015 if (val & DF_1_LOADFLTR)
4017 printf (" LOADFLTR");
4018 val ^= DF_1_LOADFLTR;
4020 if (val & DF_1_INITFIRST)
4022 printf (" INITFIRST");
4023 val ^= DF_1_INITFIRST;
4025 if (val & DF_1_NOOPEN)
4030 if (val & DF_1_ORIGIN)
4035 if (val & DF_1_DIRECT)
4040 if (val & DF_1_TRANS)
4045 if (val & DF_1_INTERPOSE)
4047 printf (" INTERPOSE");
4048 val ^= DF_1_INTERPOSE;
4050 if (val & DF_1_NODEFLIB)
4052 printf (" NODEFLIB");
4053 val ^= DF_1_NODEFLIB;
4055 if (val & DF_1_NODUMP)
4060 if (val & DF_1_CONLFAT)
4062 printf (" CONLFAT");
4063 val ^= DF_1_CONLFAT;
4066 printf (" %lx", val);
4074 puts (get_dynamic_type (entry->d_un.d_val));
4094 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4100 if (dynamic_strings == NULL)
4103 name = dynamic_strings + entry->d_un.d_val;
4107 switch (entry->d_tag)
4110 printf (_("Shared library: [%s]"), name);
4112 if (strcmp (name, program_interpreter) == 0)
4113 printf (_(" program interpreter"));
4117 printf (_("Library soname: [%s]"), name);
4121 printf (_("Library rpath: [%s]"), name);
4125 printf (_("Library runpath: [%s]"), name);
4129 print_vma (entry->d_un.d_val, PREFIX_HEX);
4134 print_vma (entry->d_un.d_val, PREFIX_HEX);
4150 case DT_INIT_ARRAYSZ:
4151 case DT_FINI_ARRAYSZ:
4154 print_vma (entry->d_un.d_val, UNSIGNED);
4155 printf (" (bytes)\n");
4165 print_vma (entry->d_un.d_val, UNSIGNED);
4178 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4182 name = dynamic_strings + entry->d_un.d_val;
4186 printf (_("Not needed object: [%s]\n"), name);
4191 print_vma (entry->d_un.d_val, PREFIX_HEX);
4197 /* The value of this entry is ignored. */
4201 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4202 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4207 switch (elf_header.e_machine)
4210 case EM_MIPS_RS4_BE:
4211 dynamic_segment_mips_val (entry);
4214 dynamic_segment_parisc_val (entry);
4217 print_vma (entry->d_un.d_val, PREFIX_HEX);
4229 get_ver_flags (flags)
4232 static char buff [32];
4239 if (flags & VER_FLG_BASE)
4240 strcat (buff, "BASE ");
4242 if (flags & VER_FLG_WEAK)
4244 if (flags & VER_FLG_BASE)
4245 strcat (buff, "| ");
4247 strcat (buff, "WEAK ");
4250 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4251 strcat (buff, "| <unknown>");
4256 /* Display the contents of the version sections. */
4258 process_version_sections (file)
4261 Elf32_Internal_Shdr * section;
4268 for (i = 0, section = section_headers;
4269 i < elf_header.e_shnum;
4272 switch (section->sh_type)
4274 case SHT_GNU_verdef:
4276 Elf_External_Verdef * edefs;
4283 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4284 SECTION_NAME (section), section->sh_info);
4286 printf (_(" Addr: 0x"));
4287 printf_vma (section->sh_addr);
4288 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4289 (unsigned long) section->sh_offset, section->sh_link,
4290 SECTION_NAME (section_headers + section->sh_link));
4292 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
4293 edefs, Elf_External_Verdef *,
4294 "version definition section");
4296 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
4299 Elf_External_Verdef * edef;
4300 Elf_Internal_Verdef ent;
4301 Elf_External_Verdaux * eaux;
4302 Elf_Internal_Verdaux aux;
4306 vstart = ((char *) edefs) + idx;
4308 edef = (Elf_External_Verdef *) vstart;
4310 ent.vd_version = BYTE_GET (edef->vd_version);
4311 ent.vd_flags = BYTE_GET (edef->vd_flags);
4312 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
4313 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
4314 ent.vd_hash = BYTE_GET (edef->vd_hash);
4315 ent.vd_aux = BYTE_GET (edef->vd_aux);
4316 ent.vd_next = BYTE_GET (edef->vd_next);
4318 printf (_(" %#06x: Rev: %d Flags: %s"),
4319 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
4321 printf (_(" Index: %d Cnt: %d "),
4322 ent.vd_ndx, ent.vd_cnt);
4324 vstart += ent.vd_aux;
4326 eaux = (Elf_External_Verdaux *) vstart;
4328 aux.vda_name = BYTE_GET (eaux->vda_name);
4329 aux.vda_next = BYTE_GET (eaux->vda_next);
4331 if (dynamic_strings)
4332 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
4334 printf (_("Name index: %ld\n"), aux.vda_name);
4336 isum = idx + ent.vd_aux;
4338 for (j = 1; j < ent.vd_cnt; j ++)
4340 isum += aux.vda_next;
4341 vstart += aux.vda_next;
4343 eaux = (Elf_External_Verdaux *) vstart;
4345 aux.vda_name = BYTE_GET (eaux->vda_name);
4346 aux.vda_next = BYTE_GET (eaux->vda_next);
4348 if (dynamic_strings)
4349 printf (_(" %#06x: Parent %d: %s\n"),
4350 isum, j, dynamic_strings + aux.vda_name);
4352 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4353 isum, j, aux.vda_name);
4363 case SHT_GNU_verneed:
4365 Elf_External_Verneed * eneed;
4371 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4372 SECTION_NAME (section), section->sh_info);
4374 printf (_(" Addr: 0x"));
4375 printf_vma (section->sh_addr);
4376 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4377 (unsigned long) section->sh_offset, section->sh_link,
4378 SECTION_NAME (section_headers + section->sh_link));
4380 GET_DATA_ALLOC (section->sh_offset, section->sh_size,
4381 eneed, Elf_External_Verneed *,
4382 "version need section");
4384 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
4386 Elf_External_Verneed * entry;
4387 Elf_Internal_Verneed ent;
4392 vstart = ((char *) eneed) + idx;
4394 entry = (Elf_External_Verneed *) vstart;
4396 ent.vn_version = BYTE_GET (entry->vn_version);
4397 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
4398 ent.vn_file = BYTE_GET (entry->vn_file);
4399 ent.vn_aux = BYTE_GET (entry->vn_aux);
4400 ent.vn_next = BYTE_GET (entry->vn_next);
4402 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
4404 if (dynamic_strings)
4405 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
4407 printf (_(" File: %lx"), ent.vn_file);
4409 printf (_(" Cnt: %d\n"), ent.vn_cnt);
4411 vstart += ent.vn_aux;
4413 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
4415 Elf_External_Vernaux * eaux;
4416 Elf_Internal_Vernaux aux;
4418 eaux = (Elf_External_Vernaux *) vstart;
4420 aux.vna_hash = BYTE_GET (eaux->vna_hash);
4421 aux.vna_flags = BYTE_GET (eaux->vna_flags);
4422 aux.vna_other = BYTE_GET (eaux->vna_other);
4423 aux.vna_name = BYTE_GET (eaux->vna_name);
4424 aux.vna_next = BYTE_GET (eaux->vna_next);
4426 if (dynamic_strings)
4427 printf (_(" %#06x: Name: %s"),
4428 isum, dynamic_strings + aux.vna_name);
4430 printf (_(" %#06x: Name index: %lx"),
4431 isum, aux.vna_name);
4433 printf (_(" Flags: %s Version: %d\n"),
4434 get_ver_flags (aux.vna_flags), aux.vna_other);
4436 isum += aux.vna_next;
4437 vstart += aux.vna_next;
4447 case SHT_GNU_versym:
4449 Elf32_Internal_Shdr * link_section;
4452 unsigned char * edata;
4453 unsigned short * data;
4455 Elf_Internal_Sym * symbols;
4456 Elf32_Internal_Shdr * string_sec;
4458 link_section = section_headers + section->sh_link;
4459 total = section->sh_size / section->sh_entsize;
4463 symbols = GET_ELF_SYMBOLS (file, link_section->sh_offset,
4464 link_section->sh_size / link_section->sh_entsize);
4466 string_sec = section_headers + link_section->sh_link;
4468 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4469 strtab, char *, "version string table");
4471 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4472 SECTION_NAME (section), total);
4474 printf (_(" Addr: "));
4475 printf_vma (section->sh_addr);
4476 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4477 (unsigned long) section->sh_offset, section->sh_link,
4478 SECTION_NAME (link_section));
4480 GET_DATA_ALLOC (version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4482 total * sizeof (short), edata,
4483 unsigned char *, "version symbol data");
4485 data = (unsigned short *) malloc (total * sizeof (short));
4487 for (cnt = total; cnt --;)
4488 data [cnt] = byte_get (edata + cnt * sizeof (short),
4493 for (cnt = 0; cnt < total; cnt += 4)
4496 int check_def, check_need;
4499 printf (" %03x:", cnt);
4501 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
4502 switch (data [cnt + j])
4505 fputs (_(" 0 (*local*) "), stdout);
4509 fputs (_(" 1 (*global*) "), stdout);
4513 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
4514 data [cnt + j] & 0x8000 ? 'h' : ' ');
4518 if (symbols [cnt + j].st_shndx >= SHN_LORESERVE
4519 || section_headers[symbols [cnt + j].st_shndx].sh_type
4522 if (symbols [cnt + j].st_shndx == SHN_UNDEF)
4529 && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
4531 Elf_Internal_Verneed ivn;
4532 unsigned long offset;
4534 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4539 Elf_Internal_Vernaux ivna;
4540 Elf_External_Verneed evn;
4541 Elf_External_Vernaux evna;
4542 unsigned long a_off;
4544 GET_DATA (offset, evn, "version need");
4546 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4547 ivn.vn_next = BYTE_GET (evn.vn_next);
4549 a_off = offset + ivn.vn_aux;
4553 GET_DATA (a_off, evna,
4554 "version need aux (2)");
4556 ivna.vna_next = BYTE_GET (evna.vna_next);
4557 ivna.vna_other = BYTE_GET (evna.vna_other);
4559 a_off += ivna.vna_next;
4561 while (ivna.vna_other != data [cnt + j]
4562 && ivna.vna_next != 0);
4564 if (ivna.vna_other == data [cnt + j])
4566 ivna.vna_name = BYTE_GET (evna.vna_name);
4568 name = strtab + ivna.vna_name;
4569 nn += printf ("(%s%-*s",
4571 12 - (int) strlen (name),
4577 offset += ivn.vn_next;
4579 while (ivn.vn_next);
4582 if (check_def && data [cnt + j] != 0x8001
4583 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
4585 Elf_Internal_Verdef ivd;
4586 Elf_External_Verdef evd;
4587 unsigned long offset;
4589 offset = version_info
4590 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
4594 GET_DATA (offset, evd, "version def");
4596 ivd.vd_next = BYTE_GET (evd.vd_next);
4597 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
4599 offset += ivd.vd_next;
4601 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
4602 && ivd.vd_next != 0);
4604 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
4606 Elf_External_Verdaux evda;
4607 Elf_Internal_Verdaux ivda;
4609 ivd.vd_aux = BYTE_GET (evd.vd_aux);
4611 GET_DATA (offset - ivd.vd_next + ivd.vd_aux,
4612 evda, "version def aux");
4614 ivda.vda_name = BYTE_GET (evda.vda_name);
4616 name = strtab + ivda.vda_name;
4617 nn += printf ("(%s%-*s",
4619 12 - (int) strlen (name),
4625 printf ("%*c", 18 - nn, ' ');
4643 printf (_("\nNo version information found in this file.\n"));
4649 get_symbol_binding (binding)
4650 unsigned int binding;
4652 static char buff [32];
4656 case STB_LOCAL: return "LOCAL";
4657 case STB_GLOBAL: return "GLOBAL";
4658 case STB_WEAK: return "WEAK";
4660 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
4661 sprintf (buff, _("<processor specific>: %d"), binding);
4662 else if (binding >= STB_LOOS && binding <= STB_HIOS)
4663 sprintf (buff, _("<OS specific>: %d"), binding);
4665 sprintf (buff, _("<unknown>: %d"), binding);
4671 get_symbol_type (type)
4674 static char buff [32];
4678 case STT_NOTYPE: return "NOTYPE";
4679 case STT_OBJECT: return "OBJECT";
4680 case STT_FUNC: return "FUNC";
4681 case STT_SECTION: return "SECTION";
4682 case STT_FILE: return "FILE";
4683 case STT_COMMON: return "COMMON";
4685 if (type >= STT_LOPROC && type <= STT_HIPROC)
4687 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
4688 return "THUMB_FUNC";
4690 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
4693 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
4694 return "PARISC_MILLI";
4696 sprintf (buff, _("<processor specific>: %d"), type);
4698 else if (type >= STT_LOOS && type <= STT_HIOS)
4700 if (elf_header.e_machine == EM_PARISC)
4702 if (type == STT_HP_OPAQUE)
4704 if (type == STT_HP_STUB)
4708 sprintf (buff, _("<OS specific>: %d"), type);
4711 sprintf (buff, _("<unknown>: %d"), type);
4717 get_symbol_visibility (visibility)
4718 unsigned int visibility;
4722 case STV_DEFAULT: return "DEFAULT";
4723 case STV_INTERNAL: return "INTERNAL";
4724 case STV_HIDDEN: return "HIDDEN";
4725 case STV_PROTECTED: return "PROTECTED";
4731 get_symbol_index_type (type)
4736 case SHN_UNDEF: return "UND";
4737 case SHN_ABS: return "ABS";
4738 case SHN_COMMON: return "COM";
4740 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
4742 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
4744 else if (type >= SHN_LOOS && type <= SHN_HIOS)
4748 static char buff [32];
4750 sprintf (buff, "%3d", type);
4757 get_dynamic_data (file, number)
4759 unsigned int number;
4761 unsigned char * e_data;
4764 e_data = (unsigned char *) malloc (number * 4);
4768 error (_("Out of memory\n"));
4772 if (fread (e_data, 4, number, file) != number)
4774 error (_("Unable to read in dynamic data\n"));
4778 i_data = (int *) malloc (number * sizeof (* i_data));
4782 error (_("Out of memory\n"));
4788 i_data [number] = byte_get (e_data + number * 4, 4);
4795 /* Dump the symbol table */
4797 process_symbol_table (file)
4800 Elf32_Internal_Shdr * section;
4801 unsigned char nb [4];
4802 unsigned char nc [4];
4805 int * buckets = NULL;
4806 int * chains = NULL;
4808 if (! do_syms && !do_histogram)
4811 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
4814 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
4816 error (_("Unable to seek to start of dynamic information"));
4820 if (fread (nb, sizeof (nb), 1, file) != 1)
4822 error (_("Failed to read in number of buckets\n"));
4826 if (fread (nc, sizeof (nc), 1, file) != 1)
4828 error (_("Failed to read in number of chains\n"));
4832 nbuckets = byte_get (nb, 4);
4833 nchains = byte_get (nc, 4);
4835 buckets = get_dynamic_data (file, nbuckets);
4836 chains = get_dynamic_data (file, nchains);
4838 if (buckets == NULL || chains == NULL)
4843 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
4848 printf (_("\nSymbol table for image:\n"));
4850 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4852 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4854 for (hn = 0; hn < nbuckets; hn++)
4859 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
4861 Elf_Internal_Sym * psym;
4863 psym = dynamic_symbols + si;
4865 printf (" %3d %3d: ", si, hn);
4866 print_vma (psym->st_value, LONG_HEX);
4868 print_vma (psym->st_size, DEC_5);
4870 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4871 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4872 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4873 printf (" %3.3s", get_symbol_index_type (psym->st_shndx));
4874 printf (" %s\n", dynamic_strings + psym->st_name);
4878 else if (do_syms && !do_using_dynamic)
4882 for (i = 0, section = section_headers;
4883 i < elf_header.e_shnum;
4888 Elf_Internal_Sym * symtab;
4889 Elf_Internal_Sym * psym;
4892 if ( section->sh_type != SHT_SYMTAB
4893 && section->sh_type != SHT_DYNSYM)
4896 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4897 SECTION_NAME (section),
4898 (unsigned long) (section->sh_size / section->sh_entsize));
4900 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4902 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4904 symtab = GET_ELF_SYMBOLS (file, section->sh_offset,
4905 section->sh_size / section->sh_entsize);
4909 if (section->sh_link == elf_header.e_shstrndx)
4910 strtab = string_table;
4913 Elf32_Internal_Shdr * string_sec;
4915 string_sec = section_headers + section->sh_link;
4917 GET_DATA_ALLOC (string_sec->sh_offset, string_sec->sh_size,
4918 strtab, char *, "string table");
4921 for (si = 0, psym = symtab;
4922 si < section->sh_size / section->sh_entsize;
4925 printf ("%6d: ", si);
4926 print_vma (psym->st_value, LONG_HEX);
4928 print_vma (psym->st_size, DEC_5);
4929 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
4930 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
4931 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
4932 printf (" %4s", get_symbol_index_type (psym->st_shndx));
4933 printf (" %s", strtab + psym->st_name);
4935 if (section->sh_type == SHT_DYNSYM &&
4936 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
4938 unsigned char data[2];
4939 unsigned short vers_data;
4940 unsigned long offset;
4944 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
4947 GET_DATA (offset + si * sizeof (vers_data), data,
4950 vers_data = byte_get (data, 2);
4952 is_nobits = psym->st_shndx < SHN_LORESERVE ?
4953 (section_headers [psym->st_shndx].sh_type == SHT_NOBITS)
4956 check_def = (psym->st_shndx != SHN_UNDEF);
4958 if ((vers_data & 0x8000) || vers_data > 1)
4960 if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
4961 && (is_nobits || ! check_def))
4963 Elf_External_Verneed evn;
4964 Elf_Internal_Verneed ivn;
4965 Elf_Internal_Vernaux ivna;
4967 /* We must test both. */
4968 offset = version_info
4969 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
4973 unsigned long vna_off;
4975 GET_DATA (offset, evn, "version need");
4977 ivn.vn_aux = BYTE_GET (evn.vn_aux);
4978 ivn.vn_next = BYTE_GET (evn.vn_next);
4980 vna_off = offset + ivn.vn_aux;
4984 Elf_External_Vernaux evna;
4986 GET_DATA (vna_off, evna,
4987 "version need aux (3)");
4989 ivna.vna_other = BYTE_GET (evna.vna_other);
4990 ivna.vna_next = BYTE_GET (evna.vna_next);
4991 ivna.vna_name = BYTE_GET (evna.vna_name);
4993 vna_off += ivna.vna_next;
4995 while (ivna.vna_other != vers_data
4996 && ivna.vna_next != 0);
4998 if (ivna.vna_other == vers_data)
5001 offset += ivn.vn_next;
5003 while (ivn.vn_next != 0);
5005 if (ivna.vna_other == vers_data)
5008 strtab + ivna.vna_name, ivna.vna_other);
5011 else if (! is_nobits)
5012 error (_("bad dynamic symbol"));
5019 if (vers_data != 0x8001
5020 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5022 Elf_Internal_Verdef ivd;
5023 Elf_Internal_Verdaux ivda;
5024 Elf_External_Verdaux evda;
5025 unsigned long offset;
5028 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5033 Elf_External_Verdef evd;
5035 GET_DATA (offset, evd, "version def");
5037 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5038 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5039 ivd.vd_next = BYTE_GET (evd.vd_next);
5041 offset += ivd.vd_next;
5043 while (ivd.vd_ndx != (vers_data & 0x7fff)
5044 && ivd.vd_next != 0);
5046 offset -= ivd.vd_next;
5047 offset += ivd.vd_aux;
5049 GET_DATA (offset, evda, "version def aux");
5051 ivda.vda_name = BYTE_GET (evda.vda_name);
5053 if (psym->st_name != ivda.vda_name)
5054 printf ((vers_data & 0x8000)
5056 strtab + ivda.vda_name);
5066 if (strtab != string_table)
5072 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5074 if (do_histogram && buckets != NULL)
5081 int nzero_counts = 0;
5084 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5086 printf (_(" Length Number %% of total Coverage\n"));
5088 lengths = (int *) calloc (nbuckets, sizeof (int));
5089 if (lengths == NULL)
5091 error (_("Out of memory"));
5094 for (hn = 0; hn < nbuckets; ++hn)
5099 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5102 if (maxlength < ++lengths[hn])
5107 counts = (int *) calloc (maxlength + 1, sizeof (int));
5110 error (_("Out of memory"));
5114 for (hn = 0; hn < nbuckets; ++hn)
5115 ++ counts [lengths [hn]];
5119 printf (" 0 %-10d (%5.1f%%)\n",
5120 counts[0], (counts[0] * 100.0) / nbuckets);
5121 for (si = 1; si <= maxlength; ++si)
5123 nzero_counts += counts[si] * si;
5124 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5125 si, counts[si], (counts[si] * 100.0) / nbuckets,
5126 (nzero_counts * 100.0) / nsyms);
5134 if (buckets != NULL)
5144 process_syminfo (file)
5145 FILE * file ATTRIBUTE_UNUSED;
5149 if (dynamic_syminfo == NULL
5151 /* No syminfo, this is ok. */
5154 /* There better should be a dynamic symbol section. */
5155 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5159 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5160 dynamic_syminfo_offset, dynamic_syminfo_nent);
5162 printf (_(" Num: Name BoundTo Flags\n"));
5163 for (i = 0; i < dynamic_syminfo_nent; ++i)
5165 unsigned short int flags = dynamic_syminfo[i].si_flags;
5167 printf ("%4d: %-30s ", i,
5168 dynamic_strings + dynamic_symbols[i].st_name);
5170 switch (dynamic_syminfo[i].si_boundto)
5172 case SYMINFO_BT_SELF:
5173 fputs ("SELF ", stdout);
5175 case SYMINFO_BT_PARENT:
5176 fputs ("PARENT ", stdout);
5179 if (dynamic_syminfo[i].si_boundto > 0
5180 && dynamic_syminfo[i].si_boundto < dynamic_size)
5183 + dynamic_segment[dynamic_syminfo[i].si_boundto].d_un.d_val);
5185 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5189 if (flags & SYMINFO_FLG_DIRECT)
5191 if (flags & SYMINFO_FLG_PASSTHRU)
5192 printf (" PASSTHRU");
5193 if (flags & SYMINFO_FLG_COPY)
5195 if (flags & SYMINFO_FLG_LAZYLOAD)
5196 printf (" LAZYLOAD");
5204 #ifdef SUPPORT_DISASSEMBLY
5206 disassemble_section (section, file)
5207 Elf32_Internal_Shdr * section;
5210 printf (_("\nAssembly dump of section %s\n"),
5211 SECTION_NAME (section));
5213 /* XXX -- to be done --- XXX */
5220 dump_section (section, file)
5221 Elf32_Internal_Shdr * section;
5224 bfd_size_type bytes;
5226 unsigned char * data;
5227 unsigned char * start;
5229 bytes = section->sh_size;
5233 printf (_("\nSection '%s' has no data to dump.\n"),
5234 SECTION_NAME (section));
5238 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5240 addr = section->sh_addr;
5242 GET_DATA_ALLOC (section->sh_offset, bytes, start, unsigned char *,
5253 lbytes = (bytes > 16 ? 16 : bytes);
5255 printf (" 0x%8.8lx ", (unsigned long) addr);
5257 switch (elf_header.e_ident [EI_DATA])
5261 for (j = 15; j >= 0; j --)
5264 printf ("%2.2x", data [j]);
5274 for (j = 0; j < 16; j++)
5277 printf ("%2.2x", data [j]);
5287 for (j = 0; j < lbytes; j++)
5290 if (k >= ' ' && k < 0x80)
5309 static unsigned long int
5310 read_leb128 (data, length_return, sign)
5311 unsigned char * data;
5312 int * length_return;
5315 unsigned long int result = 0;
5316 unsigned int num_read = 0;
5325 result |= (byte & 0x7f) << shift;
5330 while (byte & 0x80);
5332 if (length_return != NULL)
5333 * length_return = num_read;
5335 if (sign && (shift < 32) && (byte & 0x40))
5336 result |= -1 << shift;
5341 typedef struct State_Machine_Registers
5343 unsigned long address;
5346 unsigned int column;
5350 /* This variable hold the number of the last entry seen
5351 in the File Table. */
5352 unsigned int last_file_entry;
5355 static SMR state_machine_regs;
5358 reset_state_machine (is_stmt)
5361 state_machine_regs.address = 0;
5362 state_machine_regs.file = 1;
5363 state_machine_regs.line = 1;
5364 state_machine_regs.column = 0;
5365 state_machine_regs.is_stmt = is_stmt;
5366 state_machine_regs.basic_block = 0;
5367 state_machine_regs.end_sequence = 0;
5368 state_machine_regs.last_file_entry = 0;
5371 /* Handled an extend line op. Returns true if this is the end
5374 process_extended_line_op (data, is_stmt, pointer_size)
5375 unsigned char * data;
5379 unsigned char op_code;
5382 unsigned char * name;
5385 len = read_leb128 (data, & bytes_read, 0);
5390 warn (_("badly formed extended line op encountered!"));
5395 op_code = * data ++;
5397 printf (_(" Extended opcode %d: "), op_code);
5401 case DW_LNE_end_sequence:
5402 printf (_("End of Sequence\n\n"));
5403 reset_state_machine (is_stmt);
5406 case DW_LNE_set_address:
5407 adr = byte_get (data, pointer_size);
5408 printf (_("set Address to 0x%lx\n"), adr);
5409 state_machine_regs.address = adr;
5412 case DW_LNE_define_file:
5413 printf (_(" define new File Table entry\n"));
5414 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5416 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5418 data += strlen ((char *) data) + 1;
5419 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5421 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5423 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5424 printf (_("%s\n\n"), name);
5428 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
5435 /* Size of pointers in the .debug_line section. This information is not
5436 really present in that section. It's obtained before dumping the debug
5437 sections by doing some pre-scan of the .debug_info section. */
5438 static int debug_line_pointer_size = 4;
5441 display_debug_lines (section, start, file)
5442 Elf32_Internal_Shdr * section;
5443 unsigned char * start;
5444 FILE * file ATTRIBUTE_UNUSED;
5446 DWARF2_External_LineInfo * external;
5447 DWARF2_Internal_LineInfo info;
5448 unsigned char * standard_opcodes;
5449 unsigned char * data = start;
5450 unsigned char * end = start + section->sh_size;
5451 unsigned char * end_of_sequence;
5454 printf (_("\nDump of debug contents of section %s:\n\n"),
5455 SECTION_NAME (section));
5459 external = (DWARF2_External_LineInfo *) data;
5461 /* Check the length of the block. */
5462 info.li_length = BYTE_GET (external->li_length);
5463 if (info.li_length + sizeof (external->li_length) > section->sh_size)
5466 (_("The line info appears to be corrupt - the section is too small\n"));
5470 /* Check its version number. */
5471 info.li_version = BYTE_GET (external->li_version);
5472 if (info.li_version != 2)
5474 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5478 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
5479 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
5480 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
5481 info.li_line_base = BYTE_GET (external->li_line_base);
5482 info.li_line_range = BYTE_GET (external->li_line_range);
5483 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
5485 /* Sign extend the line base field. */
5486 info.li_line_base <<= 24;
5487 info.li_line_base >>= 24;
5489 printf (_(" Length: %ld\n"), info.li_length);
5490 printf (_(" DWARF Version: %d\n"), info.li_version);
5491 printf (_(" Prolgue Length: %d\n"), info.li_prologue_length);
5492 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
5493 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
5494 printf (_(" Line Base: %d\n"), info.li_line_base);
5495 printf (_(" Line Range: %d\n"), info.li_line_range);
5496 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
5498 end_of_sequence = data + info.li_length + sizeof (external->li_length);
5500 reset_state_machine (info.li_default_is_stmt);
5502 /* Display the contents of the Opcodes table. */
5503 standard_opcodes = data + sizeof (* external);
5505 printf (_("\n Opcodes:\n"));
5507 for (i = 1; i < info.li_opcode_base; i++)
5508 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
5510 /* Display the contents of the Directory table. */
5511 data = standard_opcodes + info.li_opcode_base - 1;
5514 printf (_("\n The Directory Table is empty.\n"));
5517 printf (_("\n The Directory Table:\n"));
5521 printf (_(" %s\n"), data);
5523 data += strlen ((char *) data) + 1;
5527 /* Skip the NUL at the end of the table. */
5530 /* Display the contents of the File Name table. */
5532 printf (_("\n The File Name Table is empty.\n"));
5535 printf (_("\n The File Name Table:\n"));
5536 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5540 unsigned char * name;
5543 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
5546 data += strlen ((char *) data) + 1;
5548 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5550 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5552 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
5554 printf (_("%s\n"), name);
5558 /* Skip the NUL at the end of the table. */
5561 /* Now display the statements. */
5562 printf (_("\n Line Number Statements:\n"));
5565 while (data < end_of_sequence)
5567 unsigned char op_code;
5571 op_code = * data ++;
5575 case DW_LNS_extended_op:
5576 data += process_extended_line_op (data, info.li_default_is_stmt,
5577 debug_line_pointer_size);
5581 printf (_(" Copy\n"));
5584 case DW_LNS_advance_pc:
5585 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
5587 state_machine_regs.address += adv;
5588 printf (_(" Advance PC by %d to %lx\n"), adv,
5589 state_machine_regs.address);
5592 case DW_LNS_advance_line:
5593 adv = read_leb128 (data, & bytes_read, 1);
5595 state_machine_regs.line += adv;
5596 printf (_(" Advance Line by %d to %d\n"), adv,
5597 state_machine_regs.line);
5600 case DW_LNS_set_file:
5601 adv = read_leb128 (data, & bytes_read, 0);
5603 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5605 state_machine_regs.file = adv;
5608 case DW_LNS_set_column:
5609 adv = read_leb128 (data, & bytes_read, 0);
5611 printf (_(" Set column to %d\n"), adv);
5612 state_machine_regs.column = adv;
5615 case DW_LNS_negate_stmt:
5616 adv = state_machine_regs.is_stmt;
5618 printf (_(" Set is_stmt to %d\n"), adv);
5619 state_machine_regs.is_stmt = adv;
5622 case DW_LNS_set_basic_block:
5623 printf (_(" Set basic block\n"));
5624 state_machine_regs.basic_block = 1;
5627 case DW_LNS_const_add_pc:
5628 adv = (((255 - info.li_opcode_base) / info.li_line_range)
5629 * info.li_min_insn_length);
5630 state_machine_regs.address += adv;
5631 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
5632 state_machine_regs.address);
5635 case DW_LNS_fixed_advance_pc:
5636 adv = byte_get (data, 2);
5638 state_machine_regs.address += adv;
5639 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5640 adv, state_machine_regs.address);
5644 op_code -= info.li_opcode_base;
5645 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
5646 state_machine_regs.address += adv;
5647 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5648 op_code, adv, state_machine_regs.address);
5649 adv = (op_code % info.li_line_range) + info.li_line_base;
5650 state_machine_regs.line += adv;
5651 printf (_(" and Line by %d to %d\n"),
5652 adv, state_machine_regs.line);
5663 display_debug_pubnames (section, start, file)
5664 Elf32_Internal_Shdr * section;
5665 unsigned char * start;
5666 FILE * file ATTRIBUTE_UNUSED;
5668 DWARF2_External_PubNames * external;
5669 DWARF2_Internal_PubNames pubnames;
5670 unsigned char * end;
5672 end = start + section->sh_size;
5674 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
5678 unsigned char * data;
5679 unsigned long offset;
5681 external = (DWARF2_External_PubNames *) start;
5683 pubnames.pn_length = BYTE_GET (external->pn_length);
5684 pubnames.pn_version = BYTE_GET (external->pn_version);
5685 pubnames.pn_offset = BYTE_GET (external->pn_offset);
5686 pubnames.pn_size = BYTE_GET (external->pn_size);
5688 data = start + sizeof (* external);
5689 start += pubnames.pn_length + sizeof (external->pn_length);
5691 if (pubnames.pn_version != 2)
5693 static int warned = 0;
5697 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5704 printf (_(" Length: %ld\n"),
5705 pubnames.pn_length);
5706 printf (_(" Version: %d\n"),
5707 pubnames.pn_version);
5708 printf (_(" Offset into .debug_info section: %ld\n"),
5709 pubnames.pn_offset);
5710 printf (_(" Size of area in .debug_info section: %ld\n"),
5713 printf (_("\n Offset\tName\n"));
5717 offset = byte_get (data, 4);
5722 printf (" %ld\t\t%s\n", offset, data);
5723 data += strlen ((char *) data) + 1;
5726 while (offset != 0);
5739 case DW_TAG_padding: return "DW_TAG_padding";
5740 case DW_TAG_array_type: return "DW_TAG_array_type";
5741 case DW_TAG_class_type: return "DW_TAG_class_type";
5742 case DW_TAG_entry_point: return "DW_TAG_entry_point";
5743 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
5744 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
5745 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
5746 case DW_TAG_label: return "DW_TAG_label";
5747 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
5748 case DW_TAG_member: return "DW_TAG_member";
5749 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
5750 case DW_TAG_reference_type: return "DW_TAG_reference_type";
5751 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
5752 case DW_TAG_string_type: return "DW_TAG_string_type";
5753 case DW_TAG_structure_type: return "DW_TAG_structure_type";
5754 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
5755 case DW_TAG_typedef: return "DW_TAG_typedef";
5756 case DW_TAG_union_type: return "DW_TAG_union_type";
5757 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
5758 case DW_TAG_variant: return "DW_TAG_variant";
5759 case DW_TAG_common_block: return "DW_TAG_common_block";
5760 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
5761 case DW_TAG_inheritance: return "DW_TAG_inheritance";
5762 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
5763 case DW_TAG_module: return "DW_TAG_module";
5764 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
5765 case DW_TAG_set_type: return "DW_TAG_set_type";
5766 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
5767 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
5768 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
5769 case DW_TAG_base_type: return "DW_TAG_base_type";
5770 case DW_TAG_catch_block: return "DW_TAG_catch_block";
5771 case DW_TAG_const_type: return "DW_TAG_const_type";
5772 case DW_TAG_constant: return "DW_TAG_constant";
5773 case DW_TAG_enumerator: return "DW_TAG_enumerator";
5774 case DW_TAG_file_type: return "DW_TAG_file_type";
5775 case DW_TAG_friend: return "DW_TAG_friend";
5776 case DW_TAG_namelist: return "DW_TAG_namelist";
5777 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
5778 case DW_TAG_packed_type: return "DW_TAG_packed_type";
5779 case DW_TAG_subprogram: return "DW_TAG_subprogram";
5780 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
5781 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
5782 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
5783 case DW_TAG_try_block: return "DW_TAG_try_block";
5784 case DW_TAG_variant_part: return "DW_TAG_variant_part";
5785 case DW_TAG_variable: return "DW_TAG_variable";
5786 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
5787 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
5788 case DW_TAG_format_label: return "DW_TAG_format_label";
5789 case DW_TAG_function_template: return "DW_TAG_function_template";
5790 case DW_TAG_class_template: return "DW_TAG_class_template";
5793 static char buffer [100];
5795 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
5802 get_AT_name (attribute)
5803 unsigned long attribute;
5807 case DW_AT_sibling: return "DW_AT_sibling";
5808 case DW_AT_location: return "DW_AT_location";
5809 case DW_AT_name: return "DW_AT_name";
5810 case DW_AT_ordering: return "DW_AT_ordering";
5811 case DW_AT_subscr_data: return "DW_AT_subscr_data";
5812 case DW_AT_byte_size: return "DW_AT_byte_size";
5813 case DW_AT_bit_offset: return "DW_AT_bit_offset";
5814 case DW_AT_bit_size: return "DW_AT_bit_size";
5815 case DW_AT_element_list: return "DW_AT_element_list";
5816 case DW_AT_stmt_list: return "DW_AT_stmt_list";
5817 case DW_AT_low_pc: return "DW_AT_low_pc";
5818 case DW_AT_high_pc: return "DW_AT_high_pc";
5819 case DW_AT_language: return "DW_AT_language";
5820 case DW_AT_member: return "DW_AT_member";
5821 case DW_AT_discr: return "DW_AT_discr";
5822 case DW_AT_discr_value: return "DW_AT_discr_value";
5823 case DW_AT_visibility: return "DW_AT_visibility";
5824 case DW_AT_import: return "DW_AT_import";
5825 case DW_AT_string_length: return "DW_AT_string_length";
5826 case DW_AT_common_reference: return "DW_AT_common_reference";
5827 case DW_AT_comp_dir: return "DW_AT_comp_dir";
5828 case DW_AT_const_value: return "DW_AT_const_value";
5829 case DW_AT_containing_type: return "DW_AT_containing_type";
5830 case DW_AT_default_value: return "DW_AT_default_value";
5831 case DW_AT_inline: return "DW_AT_inline";
5832 case DW_AT_is_optional: return "DW_AT_is_optional";
5833 case DW_AT_lower_bound: return "DW_AT_lower_bound";
5834 case DW_AT_producer: return "DW_AT_producer";
5835 case DW_AT_prototyped: return "DW_AT_prototyped";
5836 case DW_AT_return_addr: return "DW_AT_return_addr";
5837 case DW_AT_start_scope: return "DW_AT_start_scope";
5838 case DW_AT_stride_size: return "DW_AT_stride_size";
5839 case DW_AT_upper_bound: return "DW_AT_upper_bound";
5840 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
5841 case DW_AT_accessibility: return "DW_AT_accessibility";
5842 case DW_AT_address_class: return "DW_AT_address_class";
5843 case DW_AT_artificial: return "DW_AT_artificial";
5844 case DW_AT_base_types: return "DW_AT_base_types";
5845 case DW_AT_calling_convention: return "DW_AT_calling_convention";
5846 case DW_AT_count: return "DW_AT_count";
5847 case DW_AT_data_member_location: return "DW_AT_data_member_location";
5848 case DW_AT_decl_column: return "DW_AT_decl_column";
5849 case DW_AT_decl_file: return "DW_AT_decl_file";
5850 case DW_AT_decl_line: return "DW_AT_decl_line";
5851 case DW_AT_declaration: return "DW_AT_declaration";
5852 case DW_AT_discr_list: return "DW_AT_discr_list";
5853 case DW_AT_encoding: return "DW_AT_encoding";
5854 case DW_AT_external: return "DW_AT_external";
5855 case DW_AT_frame_base: return "DW_AT_frame_base";
5856 case DW_AT_friend: return "DW_AT_friend";
5857 case DW_AT_identifier_case: return "DW_AT_identifier_case";
5858 case DW_AT_macro_info: return "DW_AT_macro_info";
5859 case DW_AT_namelist_items: return "DW_AT_namelist_items";
5860 case DW_AT_priority: return "DW_AT_priority";
5861 case DW_AT_segment: return "DW_AT_segment";
5862 case DW_AT_specification: return "DW_AT_specification";
5863 case DW_AT_static_link: return "DW_AT_static_link";
5864 case DW_AT_type: return "DW_AT_type";
5865 case DW_AT_use_location: return "DW_AT_use_location";
5866 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
5867 case DW_AT_virtuality: return "DW_AT_virtuality";
5868 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
5869 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
5870 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
5871 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
5872 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
5873 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
5874 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
5875 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
5876 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
5877 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
5878 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
5879 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
5880 case DW_AT_sf_names: return "DW_AT_sf_names";
5881 case DW_AT_src_info: return "DW_AT_src_info";
5882 case DW_AT_mac_info: return "DW_AT_mac_info";
5883 case DW_AT_src_coords: return "DW_AT_src_coords";
5884 case DW_AT_body_begin: return "DW_AT_body_begin";
5885 case DW_AT_body_end: return "DW_AT_body_end";
5888 static char buffer [100];
5890 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
5897 get_FORM_name (form)
5902 case DW_FORM_addr: return "DW_FORM_addr";
5903 case DW_FORM_block2: return "DW_FORM_block2";
5904 case DW_FORM_block4: return "DW_FORM_block4";
5905 case DW_FORM_data2: return "DW_FORM_data2";
5906 case DW_FORM_data4: return "DW_FORM_data4";
5907 case DW_FORM_data8: return "DW_FORM_data8";
5908 case DW_FORM_string: return "DW_FORM_string";
5909 case DW_FORM_block: return "DW_FORM_block";
5910 case DW_FORM_block1: return "DW_FORM_block1";
5911 case DW_FORM_data1: return "DW_FORM_data1";
5912 case DW_FORM_flag: return "DW_FORM_flag";
5913 case DW_FORM_sdata: return "DW_FORM_sdata";
5914 case DW_FORM_strp: return "DW_FORM_strp";
5915 case DW_FORM_udata: return "DW_FORM_udata";
5916 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
5917 case DW_FORM_ref1: return "DW_FORM_ref1";
5918 case DW_FORM_ref2: return "DW_FORM_ref2";
5919 case DW_FORM_ref4: return "DW_FORM_ref4";
5920 case DW_FORM_ref8: return "DW_FORM_ref8";
5921 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
5922 case DW_FORM_indirect: return "DW_FORM_indirect";
5925 static char buffer [100];
5927 sprintf (buffer, _("Unknown FORM value: %lx"), form);
5933 /* FIXME: There are better and more effiecint ways to handle
5934 these structures. For now though, I just want something that
5935 is simple to implement. */
5936 typedef struct abbrev_attr
5938 unsigned long attribute;
5940 struct abbrev_attr * next;
5944 typedef struct abbrev_entry
5946 unsigned long entry;
5949 struct abbrev_attr * first_attr;
5950 struct abbrev_attr * last_attr;
5951 struct abbrev_entry * next;
5955 static abbrev_entry * first_abbrev = NULL;
5956 static abbrev_entry * last_abbrev = NULL;
5959 free_abbrevs PARAMS ((void))
5961 abbrev_entry * abbrev;
5963 for (abbrev = first_abbrev; abbrev;)
5965 abbrev_entry * next = abbrev->next;
5968 for (attr = abbrev->first_attr; attr;)
5970 abbrev_attr * next = attr->next;
5980 last_abbrev = first_abbrev = NULL;
5984 add_abbrev (number, tag, children)
5985 unsigned long number;
5989 abbrev_entry * entry;
5991 entry = (abbrev_entry *) malloc (sizeof (* entry));
5997 entry->entry = number;
5999 entry->children = children;
6000 entry->first_attr = NULL;
6001 entry->last_attr = NULL;
6004 if (first_abbrev == NULL)
6005 first_abbrev = entry;
6007 last_abbrev->next = entry;
6009 last_abbrev = entry;
6013 add_abbrev_attr (attribute, form)
6014 unsigned long attribute;
6019 attr = (abbrev_attr *) malloc (sizeof (* attr));
6025 attr->attribute = attribute;
6029 if (last_abbrev->first_attr == NULL)
6030 last_abbrev->first_attr = attr;
6032 last_abbrev->last_attr->next = attr;
6034 last_abbrev->last_attr = attr;
6037 /* Processes the (partial) contents of a .debug_abbrev section.
6038 Returns NULL if the end of the section was encountered.
6039 Returns the address after the last byte read if the end of
6040 an abbreviation set was found. */
6042 static unsigned char *
6043 process_abbrev_section (start, end)
6044 unsigned char * start;
6045 unsigned char * end;
6047 if (first_abbrev != NULL)
6053 unsigned long entry;
6055 unsigned long attribute;
6058 entry = read_leb128 (start, & bytes_read, 0);
6059 start += bytes_read;
6061 /* A single zero is supposed to end the section according
6062 to the standard. If there's more, then signal that to
6065 return start == end ? NULL : start;
6067 tag = read_leb128 (start, & bytes_read, 0);
6068 start += bytes_read;
6070 children = * start ++;
6072 add_abbrev (entry, tag, children);
6078 attribute = read_leb128 (start, & bytes_read, 0);
6079 start += bytes_read;
6081 form = read_leb128 (start, & bytes_read, 0);
6082 start += bytes_read;
6085 add_abbrev_attr (attribute, form);
6087 while (attribute != 0);
6095 display_debug_abbrev (section, start, file)
6096 Elf32_Internal_Shdr * section;
6097 unsigned char * start;
6098 FILE * file ATTRIBUTE_UNUSED;
6100 abbrev_entry * entry;
6101 unsigned char * end = start + section->sh_size;
6103 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6107 start = process_abbrev_section (start, end);
6109 printf (_(" Number TAG\n"));
6111 for (entry = first_abbrev; entry; entry = entry->next)
6115 printf (_(" %ld %s [%s]\n"),
6117 get_TAG_name (entry->tag),
6118 entry->children ? _("has children") : _("no children"));
6120 for (attr = entry->first_attr; attr; attr = attr->next)
6122 printf (_(" %-18s %s\n"),
6123 get_AT_name (attr->attribute),
6124 get_FORM_name (attr->form));
6136 static unsigned char *
6137 display_block (data, length)
6138 unsigned char * data;
6139 unsigned long length;
6141 printf (_(" %lu byte block: "), length);
6144 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
6150 decode_location_expression (data, pointer_size, length)
6151 unsigned char * data;
6152 unsigned int pointer_size;
6153 unsigned long length;
6157 unsigned long uvalue;
6158 unsigned char * end = data + length;
6167 printf ("DW_OP_addr: %lx",
6168 (unsigned long) byte_get (data, pointer_size));
6169 data += pointer_size;
6172 printf ("DW_OP_deref");
6175 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
6178 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
6181 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
6185 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
6189 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
6193 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
6197 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
6198 (unsigned long) byte_get (data + 4, 4));
6202 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
6203 (long) byte_get (data + 4, 4));
6207 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
6211 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
6215 printf ("DW_OP_dup");
6218 printf ("DW_OP_drop");
6221 printf ("DW_OP_over");
6224 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
6227 printf ("DW_OP_swap");
6230 printf ("DW_OP_rot");
6233 printf ("DW_OP_xderef");
6236 printf ("DW_OP_abs");
6239 printf ("DW_OP_and");
6242 printf ("DW_OP_div");
6245 printf ("DW_OP_minus");
6248 printf ("DW_OP_mod");
6251 printf ("DW_OP_mul");
6254 printf ("DW_OP_neg");
6257 printf ("DW_OP_not");
6260 printf ("DW_OP_or");
6263 printf ("DW_OP_plus");
6265 case DW_OP_plus_uconst:
6266 printf ("DW_OP_plus_uconst: %lu",
6267 read_leb128 (data, &bytes_read, 0));
6271 printf ("DW_OP_shl");
6274 printf ("DW_OP_shr");
6277 printf ("DW_OP_shra");
6280 printf ("DW_OP_xor");
6283 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
6287 printf ("DW_OP_eq");
6290 printf ("DW_OP_ge");
6293 printf ("DW_OP_gt");
6296 printf ("DW_OP_le");
6299 printf ("DW_OP_lt");
6302 printf ("DW_OP_ne");
6305 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
6341 printf ("DW_OP_lit%d", op - DW_OP_lit0);
6376 printf ("DW_OP_reg%d", op - DW_OP_reg0);
6411 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
6412 read_leb128 (data, &bytes_read, 1));
6417 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
6421 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
6425 uvalue = read_leb128 (data, &bytes_read, 0);
6427 printf ("DW_OP_bregx: %lu %ld", uvalue,
6428 read_leb128 (data, &bytes_read, 1));
6432 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
6435 case DW_OP_deref_size:
6436 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
6438 case DW_OP_xderef_size:
6439 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
6442 printf ("DW_OP_nop");
6446 if (op >= DW_OP_lo_user
6447 && op <= DW_OP_hi_user)
6448 printf (_("(User defined location op)"));
6450 printf (_("(Unknown location op)"));
6451 /* No way to tell where the next op is, so just bail. */
6458 static unsigned char *
6459 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
6460 unsigned long attribute;
6462 unsigned char * data;
6463 unsigned long cu_offset;
6464 unsigned long pointer_size;
6466 unsigned long uvalue = 0;
6467 unsigned char * block_start = NULL;
6470 printf (" %-18s:", get_AT_name (attribute));
6477 case DW_FORM_ref_addr:
6479 uvalue = byte_get (data, pointer_size);
6480 data += pointer_size;
6486 uvalue = byte_get (data ++, 1);
6491 uvalue = byte_get (data, 2);
6497 uvalue = byte_get (data, 4);
6502 uvalue = read_leb128 (data, & bytes_read, 1);
6506 case DW_FORM_ref_udata:
6508 uvalue = read_leb128 (data, & bytes_read, 0);
6515 case DW_FORM_ref_addr:
6516 printf (" <#%lx>", uvalue);
6522 case DW_FORM_ref_udata:
6523 printf (" <%lx>", uvalue + cu_offset);
6527 printf (" %#lx", uvalue);
6535 printf (" %ld", uvalue);
6540 uvalue = byte_get (data, 4);
6541 printf (" %lx", uvalue);
6542 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
6546 case DW_FORM_string:
6547 printf (" %s", data);
6548 data += strlen ((char *) data) + 1;
6552 uvalue = read_leb128 (data, & bytes_read, 0);
6553 block_start = data + bytes_read;
6554 data = display_block (block_start, uvalue);
6557 case DW_FORM_block1:
6558 uvalue = byte_get (data, 1);
6559 block_start = data + 1;
6560 data = display_block (block_start, uvalue);
6563 case DW_FORM_block2:
6564 uvalue = byte_get (data, 2);
6565 block_start = data + 2;
6566 data = display_block (block_start, uvalue);
6569 case DW_FORM_block4:
6570 uvalue = byte_get (data, 4);
6571 block_start = data + 4;
6572 data = display_block (block_start, uvalue);
6576 case DW_FORM_indirect:
6577 warn (_("Unable to handle FORM: %d"), form);
6581 warn (_("Unrecognised form: %d"), form);
6585 /* For some attributes we can display futher information. */
6594 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
6595 case DW_INL_inlined: printf (_("(inlined)")); break;
6596 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
6597 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
6598 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
6602 case DW_AT_language:
6605 case DW_LANG_C: printf ("(non-ANSI C)"); break;
6606 case DW_LANG_C89: printf ("(ANSI C)"); break;
6607 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
6608 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
6609 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
6610 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
6611 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
6612 case DW_LANG_Ada83: printf ("(Ada)"); break;
6613 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
6614 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
6615 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
6616 default: printf ("(Unknown: %lx)", uvalue); break;
6620 case DW_AT_encoding:
6623 case DW_ATE_void: printf ("(void)"); break;
6624 case DW_ATE_address: printf ("(machine address)"); break;
6625 case DW_ATE_boolean: printf ("(boolean)"); break;
6626 case DW_ATE_complex_float: printf ("(complex float)"); break;
6627 case DW_ATE_float: printf ("(float)"); break;
6628 case DW_ATE_signed: printf ("(signed)"); break;
6629 case DW_ATE_signed_char: printf ("(signed char)"); break;
6630 case DW_ATE_unsigned: printf ("(unsigned)"); break;
6631 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
6633 if (uvalue >= DW_ATE_lo_user
6634 && uvalue <= DW_ATE_hi_user)
6635 printf ("(user defined type)");
6637 printf ("(unknown type)");
6642 case DW_AT_accessibility:
6645 case DW_ACCESS_public: printf ("(public)"); break;
6646 case DW_ACCESS_protected: printf ("(protected)"); break;
6647 case DW_ACCESS_private: printf ("(private)"); break;
6648 default: printf ("(unknown accessibility)"); break;
6652 case DW_AT_visibility:
6655 case DW_VIS_local: printf ("(local)"); break;
6656 case DW_VIS_exported: printf ("(exported)"); break;
6657 case DW_VIS_qualified: printf ("(qualified)"); break;
6658 default: printf ("(unknown visibility)"); break;
6662 case DW_AT_virtuality:
6665 case DW_VIRTUALITY_none: printf ("(none)"); break;
6666 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
6667 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
6668 default: printf ("(unknown virtuality)"); break;
6672 case DW_AT_identifier_case:
6675 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
6676 case DW_ID_up_case: printf ("(up_case)"); break;
6677 case DW_ID_down_case: printf ("(down_case)"); break;
6678 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
6679 default: printf ("(unknown case)"); break;
6683 case DW_AT_calling_convention:
6686 case DW_CC_normal: printf ("(normal)"); break;
6687 case DW_CC_program: printf ("(program)"); break;
6688 case DW_CC_nocall: printf ("(nocall)"); break;
6690 if (uvalue >= DW_CC_lo_user
6691 && uvalue <= DW_CC_hi_user)
6692 printf ("(user defined)");
6694 printf ("(unknown convention)");
6698 case DW_AT_frame_base:
6699 case DW_AT_location:
6700 case DW_AT_data_member_location:
6701 case DW_AT_vtable_elem_location:
6705 decode_location_expression (block_start, pointer_size, uvalue);
6719 display_debug_info (section, start, file)
6720 Elf32_Internal_Shdr * section;
6721 unsigned char * start;
6724 unsigned char * end = start + section->sh_size;
6725 unsigned char * section_begin = start;
6727 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6731 DWARF2_External_CompUnit * external;
6732 DWARF2_Internal_CompUnit compunit;
6733 unsigned char * tags;
6736 unsigned long cu_offset;
6738 external = (DWARF2_External_CompUnit *) start;
6740 compunit.cu_length = BYTE_GET (external->cu_length);
6741 compunit.cu_version = BYTE_GET (external->cu_version);
6742 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
6743 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
6745 tags = start + sizeof (* external);
6746 cu_offset = start - section_begin;
6747 start += compunit.cu_length + sizeof (external->cu_length);
6749 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
6750 printf (_(" Length: %ld\n"), compunit.cu_length);
6751 printf (_(" Version: %d\n"), compunit.cu_version);
6752 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
6753 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
6755 if (compunit.cu_version != 2)
6757 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6761 if (first_abbrev != NULL)
6764 /* Read in the abbrevs used by this compilation unit. */
6767 Elf32_Internal_Shdr * sec;
6768 unsigned char * begin;
6770 /* Locate the .debug_abbrev section and process it. */
6771 for (i = 0, sec = section_headers;
6772 i < elf_header.e_shnum;
6774 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
6777 if (i == -1 || sec->sh_size == 0)
6779 warn (_("Unable to locate .debug_abbrev section!\n"));
6783 GET_DATA_ALLOC (sec->sh_offset, sec->sh_size, begin, unsigned char *,
6784 "debug_abbrev section data");
6786 process_abbrev_section (begin + compunit.cu_abbrev_offset,
6787 begin + sec->sh_size);
6793 while (tags < start)
6796 unsigned long abbrev_number;
6797 abbrev_entry * entry;
6800 abbrev_number = read_leb128 (tags, & bytes_read, 0);
6803 /* A null DIE marks the end of a list of children. */
6804 if (abbrev_number == 0)
6810 /* Scan through the abbreviation list until we reach the
6812 for (entry = first_abbrev;
6813 entry && entry->entry != abbrev_number;
6814 entry = entry->next)
6819 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6824 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6825 level, tags - section_begin - bytes_read,
6827 get_TAG_name (entry->tag));
6829 for (attr = entry->first_attr; attr; attr = attr->next)
6830 tags = read_and_display_attr (attr->attribute,
6833 compunit.cu_pointer_size);
6835 if (entry->children)
6846 display_debug_aranges (section, start, file)
6847 Elf32_Internal_Shdr * section;
6848 unsigned char * start;
6849 FILE * file ATTRIBUTE_UNUSED;
6851 unsigned char * end = start + section->sh_size;
6853 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
6857 DWARF2_External_ARange * external;
6858 DWARF2_Internal_ARange arange;
6859 unsigned char * ranges;
6860 unsigned long length;
6861 unsigned long address;
6864 external = (DWARF2_External_ARange *) start;
6866 arange.ar_length = BYTE_GET (external->ar_length);
6867 arange.ar_version = BYTE_GET (external->ar_version);
6868 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
6869 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
6870 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
6872 if (arange.ar_version != 2)
6874 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6878 printf (_(" Length: %ld\n"), arange.ar_length);
6879 printf (_(" Version: %d\n"), arange.ar_version);
6880 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
6881 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
6882 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
6884 printf (_("\n Address Length\n"));
6886 ranges = start + sizeof (* external);
6888 /* Must pad to an alignment boundary that is twice the pointer size. */
6889 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
6891 ranges += (2 * arange.ar_pointer_size) - excess;
6895 address = byte_get (ranges, arange.ar_pointer_size);
6897 ranges += arange.ar_pointer_size;
6899 length = byte_get (ranges, arange.ar_pointer_size);
6901 ranges += arange.ar_pointer_size;
6903 /* A pair of zeros marks the end of the list. */
6904 if (address == 0 && length == 0)
6907 printf (" %8.8lx %lu\n", address, length);
6910 start += arange.ar_length + sizeof (external->ar_length);
6918 typedef struct Frame_Chunk
6920 struct Frame_Chunk * next;
6921 unsigned char * chunk_start;
6923 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6924 short int * col_type;
6926 char * augmentation;
6927 unsigned int code_factor;
6928 unsigned int data_factor;
6929 unsigned long pc_begin;
6930 unsigned long pc_range;
6937 /* A marker for a col_type that means this column was never referenced
6938 in the frame info. */
6939 #define DW_CFA_unreferenced (-1)
6942 frame_need_space (fc, reg)
6946 int prev = fc->ncols;
6948 if (reg < fc->ncols)
6951 fc->ncols = reg + 1;
6952 fc->col_type = (short int *) xrealloc (fc->col_type,
6953 fc->ncols * sizeof (short int));
6954 fc->col_offset = (int *) xrealloc (fc->col_offset,
6955 fc->ncols * sizeof (int));
6957 while (prev < fc->ncols)
6959 fc->col_type[prev] = DW_CFA_unreferenced;
6960 fc->col_offset[prev] = 0;
6966 frame_display_row (fc, need_col_headers, max_regs)
6968 int * need_col_headers;
6974 if (* max_regs < fc->ncols)
6975 * max_regs = fc->ncols;
6977 if (* need_col_headers)
6979 * need_col_headers = 0;
6981 printf (" LOC CFA ");
6983 for (r = 0; r < * max_regs; r++)
6984 if (fc->col_type[r] != DW_CFA_unreferenced)
6989 printf ("r%-4d", r);
6995 printf ("%08x ", (unsigned int) fc->pc_begin);
6996 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
6997 printf ("%-8s ", tmp);
6999 for (r = 0; r < fc->ncols; r++)
7001 if (fc->col_type[r] != DW_CFA_unreferenced)
7003 switch (fc->col_type[r])
7005 case DW_CFA_undefined:
7008 case DW_CFA_same_value:
7012 sprintf (tmp, "c%+d", fc->col_offset[r]);
7014 case DW_CFA_register:
7015 sprintf (tmp, "r%d", fc->col_offset[r]);
7018 strcpy (tmp, "n/a");
7021 printf ("%-5s", tmp);
7027 #define GET(N) byte_get (start, N); start += N
7028 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
7029 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
7032 display_debug_frames (section, start, file)
7033 Elf32_Internal_Shdr * section;
7034 unsigned char * start;
7035 FILE * file ATTRIBUTE_UNUSED;
7037 unsigned char * end = start + section->sh_size;
7038 unsigned char * section_start = start;
7039 Frame_Chunk * chunks = 0;
7040 Frame_Chunk * remembered_state = 0;
7042 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
7046 printf (_("The section %s contains:\n"), SECTION_NAME (section));
7050 unsigned char * saved_start;
7051 unsigned char * block_end;
7052 unsigned long length;
7053 unsigned long cie_id;
7056 int need_col_headers = 1;
7058 saved_start = start;
7059 length = byte_get (start, 4); start += 4;
7064 block_end = saved_start + length + 4;
7065 cie_id = byte_get (start, 4); start += 4;
7067 printf ("\n%08x %08lx %08lx ", saved_start - section_start, length, cie_id);
7069 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
7071 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7072 memset (fc, 0, sizeof (Frame_Chunk));
7076 fc->chunk_start = saved_start;
7078 fc->col_type = (short int *) xmalloc (sizeof (short int));
7079 fc->col_offset = (int *) xmalloc (sizeof (int));
7080 frame_need_space (fc, max_regs-1);
7082 start ++; /* version */
7083 fc->augmentation = start;
7088 start++; /* skip past NUL */
7090 if (fc->augmentation[0] == 'z')
7093 fc->code_factor = LEB ();
7094 fc->data_factor = SLEB ();
7095 fc->ra = byte_get (start, 1); start += 1;
7097 printf ("skipping %d extra bytes\n", xtra);
7100 else if (strcmp (fc->augmentation, "eh") == 0)
7103 fc->code_factor = LEB ();
7104 fc->data_factor = SLEB ();
7105 fc->ra = byte_get (start, 1); start += 1;
7109 fc->code_factor = LEB ();
7110 fc->data_factor = SLEB ();
7111 fc->ra = byte_get (start, 1); start += 1;
7114 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n",
7115 fc->augmentation, fc->code_factor, fc->data_factor, fc->ra);
7117 frame_need_space (fc, fc->ra);
7121 unsigned char * look_for;
7122 static Frame_Chunk fde_fc;
7125 memset (fc, 0, sizeof (Frame_Chunk));
7127 look_for = is_eh ? start-4-cie_id : (unsigned char *) cie_id;
7129 fc->pc_begin = byte_get (start, 4); start += 4;
7130 fc->pc_range = byte_get (start, 4); start += 4;
7132 for (cie=chunks; cie && (cie->chunk_start != look_for); cie = cie->next);
7135 warn ("Invalid CIE pointer %08x in FDE at %08x\n", cie_id, saved_start);
7138 fc->col_type = (short int *) xmalloc (sizeof (short int));
7139 fc->col_offset = (int *) xmalloc (sizeof (int));
7140 frame_need_space (fc, max_regs - 1);
7142 fc->augmentation = "";
7146 fc->ncols = cie->ncols;
7147 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
7148 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
7149 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
7150 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
7151 fc->augmentation = cie->augmentation;
7152 fc->code_factor = cie->code_factor;
7153 fc->data_factor = cie->data_factor;
7154 fc->cfa_reg = cie->cfa_reg;
7155 fc->cfa_offset = cie->cfa_offset;
7157 frame_need_space (fc, max_regs-1);
7160 if (cie->augmentation[0] == 'z')
7162 unsigned long l = LEB ();
7166 printf ("FDE cie=%08x pc=%08lx..%08lx\n",
7167 cie->chunk_start-section_start, fc->pc_begin,
7168 fc->pc_begin + fc->pc_range);
7171 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7172 about to interpret instructions for the chunk. */
7174 /* This exists for readelf maintainers. */
7178 /* Start by making a pass over the chunk, allocating storage
7179 and taking note of what registers are used. */
7180 unsigned char * tmp = start;
7182 while (start < block_end)
7193 /* Warning: if you add any more cases to this switch, be
7194 sure to add them to the corresponding switch below. */
7197 case DW_CFA_advance_loc:
7201 frame_need_space (fc, opa);
7202 fc->col_type[opa] = DW_CFA_undefined;
7204 case DW_CFA_restore:
7205 frame_need_space (fc, opa);
7206 fc->col_type[opa] = DW_CFA_undefined;
7208 case DW_CFA_set_loc:
7209 start += sizeof (vma);
7211 case DW_CFA_advance_loc1:
7214 case DW_CFA_advance_loc2:
7217 case DW_CFA_advance_loc4:
7220 case DW_CFA_offset_extended:
7221 reg = LEB (); LEB ();
7222 frame_need_space (fc, reg);
7223 fc->col_type[reg] = DW_CFA_undefined;
7225 case DW_CFA_restore_extended:
7227 frame_need_space (fc, reg);
7228 fc->col_type[reg] = DW_CFA_undefined;
7230 case DW_CFA_undefined:
7232 frame_need_space (fc, reg);
7233 fc->col_type[reg] = DW_CFA_undefined;
7235 case DW_CFA_same_value:
7237 frame_need_space (fc, reg);
7238 fc->col_type[reg] = DW_CFA_undefined;
7240 case DW_CFA_register:
7241 reg = LEB (); LEB ();
7242 frame_need_space (fc, reg);
7243 fc->col_type[reg] = DW_CFA_undefined;
7245 case DW_CFA_def_cfa:
7248 case DW_CFA_def_cfa_register:
7251 case DW_CFA_def_cfa_offset:
7254 #ifndef DW_CFA_GNU_args_size
7255 #define DW_CFA_GNU_args_size 0x2e
7257 case DW_CFA_GNU_args_size:
7260 #ifndef DW_CFA_GNU_negative_offset_extended
7261 #define DW_CFA_GNU_negative_offset_extended 0x2f
7263 case DW_CFA_GNU_negative_offset_extended:
7264 reg = LEB (); LEB ();
7265 frame_need_space (fc, reg);
7266 fc->col_type[reg] = DW_CFA_undefined;
7275 /* Now we know what registers are used, make a second pass over
7276 the chunk, this time actually printing out the info. */
7278 while (start < block_end)
7281 unsigned long ul, reg, roffs;
7290 /* Warning: if you add any more cases to this switch, be
7291 sure to add them to the corresponding switch above. */
7294 case DW_CFA_advance_loc:
7295 frame_display_row (fc, &need_col_headers, &max_regs);
7297 printf (" DW_CFA_advance_loc: %08x = %08x + %d*%d\n",
7298 fc->pc_begin + opa * fc->code_factor, fc->pc_begin, opa, fc->code_factor);
7300 fc->pc_begin += opa * fc->code_factor;
7306 printf (" DW_CFA_offset: r%d = cfa[%d*%d]\n", opa, roffs, fc->data_factor);
7308 fc->col_type[opa] = DW_CFA_offset;
7309 fc->col_offset[opa] = roffs * fc->data_factor;
7312 case DW_CFA_restore:
7314 printf (" DW_CFA_restore: r%d\n", opa);
7316 fc->col_type[opa] = cie->col_type[opa];
7317 fc->col_offset[opa] = cie->col_offset[opa];
7320 case DW_CFA_set_loc:
7321 frame_display_row (fc, &need_col_headers, &max_regs);
7322 vma = byte_get (start, sizeof (vma)); start += sizeof (vma);
7324 printf (" DW_CFA_set_loc: %08x\n", vma);
7329 case DW_CFA_advance_loc1:
7330 frame_display_row (fc, &need_col_headers, &max_regs);
7331 ofs = byte_get (start, 1); start += 1;
7333 printf (" DW_CFA_advance_loc1: %08x = %08x + %d*%d\n",
7334 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7336 fc->pc_begin += ofs * fc->code_factor;
7339 case DW_CFA_advance_loc2:
7340 frame_display_row (fc, &need_col_headers, &max_regs);
7341 ofs = byte_get (start, 2); start += 2;
7343 printf (" DW_CFA_advance_loc2: %08x = %08x + %d*%d\n",
7344 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7346 fc->pc_begin += ofs * fc->code_factor;
7349 case DW_CFA_advance_loc4:
7350 frame_display_row (fc, &need_col_headers, &max_regs);
7351 ofs = byte_get (start, 4); start += 4;
7353 printf (" DW_CFA_advance_loc4: %08x = %08x + %d*%d\n",
7354 fc->pc_begin + ofs * fc->code_factor, fc->pc_begin, ofs, fc->code_factor);
7356 fc->pc_begin += ofs * fc->code_factor;
7359 case DW_CFA_offset_extended:
7363 printf (" DW_CFA_offset_extended: r%d = cfa[%d*%d]\n", reg, roffs, fc->data_factor);
7365 fc->col_type[reg] = DW_CFA_offset;
7366 fc->col_offset[reg] = roffs * fc->data_factor;
7369 case DW_CFA_restore_extended:
7372 printf (" DW_CFA_restore_extended: r%d\n", reg);
7374 fc->col_type[reg] = cie->col_type[reg];
7375 fc->col_offset[reg] = cie->col_offset[reg];
7378 case DW_CFA_undefined:
7381 printf (" DW_CFA_undefined: r%d\n", reg);
7383 fc->col_type[reg] = DW_CFA_undefined;
7384 fc->col_offset[reg] = 0;
7387 case DW_CFA_same_value:
7390 printf (" DW_CFA_same_value: r%d\n", reg);
7392 fc->col_type[reg] = DW_CFA_same_value;
7393 fc->col_offset[reg] = 0;
7396 case DW_CFA_register:
7400 printf (" DW_CFA_register: r%d\n", reg);
7402 fc->col_type[reg] = DW_CFA_register;
7403 fc->col_offset[reg] = roffs;
7406 case DW_CFA_remember_state:
7408 printf (" DW_CFA_remember_state\n");
7410 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
7411 rs->ncols = fc->ncols;
7412 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
7413 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
7414 memcpy (rs->col_type, fc->col_type, rs->ncols);
7415 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
7416 rs->next = remembered_state;
7417 remembered_state = rs;
7420 case DW_CFA_restore_state:
7422 printf (" DW_CFA_restore_state\n");
7424 rs = remembered_state;
7425 remembered_state = rs->next;
7426 frame_need_space (fc, rs->ncols-1);
7427 memcpy (fc->col_type, rs->col_type, rs->ncols);
7428 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
7429 free (rs->col_type);
7430 free (rs->col_offset);
7434 case DW_CFA_def_cfa:
7435 fc->cfa_reg = LEB ();
7436 fc->cfa_offset = LEB ();
7438 printf (" DW_CFA_def_cfa: reg %d ofs %d\n", fc->cfa_reg, fc->cfa_offset);
7442 case DW_CFA_def_cfa_register:
7443 fc->cfa_reg = LEB ();
7445 printf (" DW_CFA_def_cfa_reg: %d\n", fc->cfa_reg);
7449 case DW_CFA_def_cfa_offset:
7450 fc->cfa_offset = LEB ();
7452 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
7458 printf (" DW_CFA_nop\n");
7462 #ifndef DW_CFA_GNU_window_save
7463 #define DW_CFA_GNU_window_save 0x2d
7465 case DW_CFA_GNU_window_save:
7467 printf (" DW_CFA_GNU_window_save\n");
7471 #ifndef DW_CFA_GNU_args_size
7472 #define DW_CFA_GNU_args_size 0x2e
7474 case DW_CFA_GNU_args_size:
7477 printf (" DW_CFA_GNU_args_size: %d\n", ul);
7481 #ifndef DW_CFA_GNU_negative_offset_extended
7482 #define DW_CFA_GNU_negative_offset_extended 0x2f
7484 case DW_CFA_GNU_negative_offset_extended:
7487 frame_need_space (fc, reg);
7489 printf (" DW_CFA_GNU_negative_offset_extended: r%d = cfa[%d*%d]\n", reg, l, fc->data_factor);
7491 fc->col_type[reg] = DW_CFA_offset;
7492 fc->col_offset[reg] = l * fc->data_factor;
7496 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
7501 frame_display_row (fc, &need_col_headers, &max_regs);
7516 display_debug_not_supported (section, start, file)
7517 Elf32_Internal_Shdr * section;
7518 unsigned char * start ATTRIBUTE_UNUSED;
7519 FILE * file ATTRIBUTE_UNUSED;
7521 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7522 SECTION_NAME (section));
7527 /* Pre-scan the .debug_info section to record the size of address.
7528 When dumping the .debug_line, we use that size information, assuming
7529 that all compilation units have the same address size. */
7531 prescan_debug_info (section, start, file)
7532 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
7533 unsigned char * start;
7534 FILE * file ATTRIBUTE_UNUSED;
7536 DWARF2_External_CompUnit * external;
7538 external = (DWARF2_External_CompUnit *) start;
7540 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
7544 /* A structure containing the name of a debug section and a pointer
7545 to a function that can decode it. The third field is a prescan
7546 function to be run over the section before displaying any of the
7551 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7552 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
7556 { ".debug_info", display_debug_info, prescan_debug_info },
7557 { ".debug_abbrev", display_debug_abbrev, NULL },
7558 { ".debug_line", display_debug_lines, NULL },
7559 { ".debug_aranges", display_debug_aranges, NULL },
7560 { ".debug_pubnames", display_debug_pubnames, NULL },
7561 { ".debug_frame", display_debug_frames, NULL },
7562 { ".eh_frame", display_debug_frames, NULL },
7563 { ".debug_macinfo", display_debug_not_supported, NULL },
7564 { ".debug_frame", display_debug_not_supported, NULL },
7565 { ".debug_str", display_debug_not_supported, NULL },
7566 { ".debug_static_func", display_debug_not_supported, NULL },
7567 { ".debug_static_vars", display_debug_not_supported, NULL },
7568 { ".debug_types", display_debug_not_supported, NULL },
7569 { ".debug_weaknames", display_debug_not_supported, NULL }
7573 display_debug_section (section, file)
7574 Elf32_Internal_Shdr * section;
7577 char * name = SECTION_NAME (section);
7578 bfd_size_type length;
7579 unsigned char * start;
7582 length = section->sh_size;
7585 printf (_("\nSection '%s' has no debugging data.\n"), name);
7589 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7590 "debug section data");
7592 /* See if we know how to display the contents of this section. */
7593 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
7594 name = ".debug_info";
7596 for (i = NUM_ELEM (debug_displays); i--;)
7597 if (strcmp (debug_displays[i].name, name) == 0)
7599 debug_displays[i].display (section, start, file);
7604 printf (_("Unrecognised debug section: %s\n"), name);
7608 /* If we loaded in the abbrev section at some point,
7609 we must release it here. */
7610 if (first_abbrev != NULL)
7617 process_section_contents (file)
7620 Elf32_Internal_Shdr * section;
7626 /* Pre-scan the debug sections to find some debug information not
7627 present in some of them. For the .debug_line, we must find out the
7628 size of address (specified in .debug_info and .debug_aranges). */
7629 for (i = 0, section = section_headers;
7630 i < elf_header.e_shnum && i < num_dump_sects;
7633 char * name = SECTION_NAME (section);
7636 if (section->sh_size == 0)
7639 /* See if there is some pre-scan operation for this section. */
7640 for (j = NUM_ELEM (debug_displays); j--;)
7641 if (strcmp (debug_displays[j].name, name) == 0)
7643 if (debug_displays[j].prescan != NULL)
7645 bfd_size_type length;
7646 unsigned char * start;
7648 length = section->sh_size;
7649 GET_DATA_ALLOC (section->sh_offset, length, start, unsigned char *,
7650 "debug section data");
7652 debug_displays[j].prescan (section, start, file);
7660 for (i = 0, section = section_headers;
7661 i < elf_header.e_shnum && i < num_dump_sects;
7664 #ifdef SUPPORT_DISASSEMBLY
7665 if (dump_sects[i] & DISASS_DUMP)
7666 disassemble_section (section, file);
7668 if (dump_sects[i] & HEX_DUMP)
7669 dump_section (section, file);
7671 if (dump_sects[i] & DEBUG_DUMP)
7672 display_debug_section (section, file);
7675 if (i < num_dump_sects)
7676 warn (_("Some sections were not dumped because they do not exist!\n"));
7682 process_mips_fpe_exception (mask)
7688 if (mask & OEX_FPU_INEX)
7689 fputs ("INEX", stdout), first = 0;
7690 if (mask & OEX_FPU_UFLO)
7691 printf ("%sUFLO", first ? "" : "|"), first = 0;
7692 if (mask & OEX_FPU_OFLO)
7693 printf ("%sOFLO", first ? "" : "|"), first = 0;
7694 if (mask & OEX_FPU_DIV0)
7695 printf ("%sDIV0", first ? "" : "|"), first = 0;
7696 if (mask & OEX_FPU_INVAL)
7697 printf ("%sINVAL", first ? "" : "|");
7700 fputs ("0", stdout);
7704 process_mips_specific (file)
7707 Elf_Internal_Dyn * entry;
7708 size_t liblist_offset = 0;
7709 size_t liblistno = 0;
7710 size_t conflictsno = 0;
7711 size_t options_offset = 0;
7712 size_t conflicts_offset = 0;
7714 /* We have a lot of special sections. Thanks SGI! */
7715 if (dynamic_segment == NULL)
7716 /* No information available. */
7719 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
7720 switch (entry->d_tag)
7722 case DT_MIPS_LIBLIST:
7723 liblist_offset = entry->d_un.d_val - loadaddr;
7725 case DT_MIPS_LIBLISTNO:
7726 liblistno = entry->d_un.d_val;
7728 case DT_MIPS_OPTIONS:
7729 options_offset = entry->d_un.d_val - loadaddr;
7731 case DT_MIPS_CONFLICT:
7732 conflicts_offset = entry->d_un.d_val - loadaddr;
7734 case DT_MIPS_CONFLICTNO:
7735 conflictsno = entry->d_un.d_val;
7741 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
7743 Elf32_External_Lib * elib;
7746 GET_DATA_ALLOC (liblist_offset, liblistno * sizeof (Elf32_External_Lib),
7747 elib, Elf32_External_Lib *, "liblist");
7749 printf ("\nSection '.liblist' contains %lu entries:\n",
7750 (unsigned long) liblistno);
7751 fputs (" Library Time Stamp Checksum Version Flags\n",
7754 for (cnt = 0; cnt < liblistno; ++cnt)
7761 liblist.l_name = BYTE_GET (elib[cnt].l_name);
7762 time = BYTE_GET (elib[cnt].l_time_stamp);
7763 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
7764 liblist.l_version = BYTE_GET (elib[cnt].l_version);
7765 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
7767 tmp = gmtime (&time);
7768 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
7769 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7770 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7772 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt,
7773 dynamic_strings + liblist.l_name, timebuf,
7774 liblist.l_checksum, liblist.l_version);
7776 if (liblist.l_flags == 0)
7787 { " EXACT_MATCH", LL_EXACT_MATCH },
7788 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
7789 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
7790 { " EXPORTS", LL_EXPORTS },
7791 { " DELAY_LOAD", LL_DELAY_LOAD },
7792 { " DELTA", LL_DELTA }
7794 int flags = liblist.l_flags;
7798 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
7800 if ((flags & l_flags_vals[fcnt].bit) != 0)
7802 fputs (l_flags_vals[fcnt].name, stdout);
7803 flags ^= l_flags_vals[fcnt].bit;
7806 printf (" %#x", (unsigned int) flags);
7815 if (options_offset != 0)
7817 Elf_External_Options * eopt;
7818 Elf_Internal_Shdr * sect = section_headers;
7819 Elf_Internal_Options * iopt;
7820 Elf_Internal_Options * option;
7824 /* Find the section header so that we get the size. */
7825 while (sect->sh_type != SHT_MIPS_OPTIONS)
7828 GET_DATA_ALLOC (options_offset, sect->sh_size, eopt,
7829 Elf_External_Options *, "options");
7831 iopt = (Elf_Internal_Options *) malloc ((sect->sh_size / sizeof (eopt))
7835 error (_("Out of memory"));
7842 while (offset < sect->sh_size)
7844 Elf_External_Options * eoption;
7846 eoption = (Elf_External_Options *) ((char *) eopt + offset);
7848 option->kind = BYTE_GET (eoption->kind);
7849 option->size = BYTE_GET (eoption->size);
7850 option->section = BYTE_GET (eoption->section);
7851 option->info = BYTE_GET (eoption->info);
7853 offset += option->size;
7859 printf (_("\nSection '%s' contains %d entries:\n"),
7860 SECTION_NAME (sect), cnt);
7868 switch (option->kind)
7871 /* This shouldn't happen. */
7872 printf (" NULL %d %lx", option->section, option->info);
7875 printf (" REGINFO ");
7876 if (elf_header.e_machine == EM_MIPS)
7879 Elf32_External_RegInfo * ereg;
7880 Elf32_RegInfo reginfo;
7882 ereg = (Elf32_External_RegInfo *) (option + 1);
7883 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7884 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7885 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7886 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7887 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7888 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
7890 printf ("GPR %08lx GP 0x%lx\n",
7892 (unsigned long) reginfo.ri_gp_value);
7893 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7894 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7895 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7900 Elf64_External_RegInfo * ereg;
7901 Elf64_Internal_RegInfo reginfo;
7903 ereg = (Elf64_External_RegInfo *) (option + 1);
7904 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
7905 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
7906 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
7907 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
7908 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
7909 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
7911 printf ("GPR %08lx GP 0x",
7912 reginfo.ri_gprmask);
7913 printf_vma (reginfo.ri_gp_value);
7916 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7917 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
7918 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
7922 case ODK_EXCEPTIONS:
7923 fputs (" EXCEPTIONS fpe_min(", stdout);
7924 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
7925 fputs (") fpe_max(", stdout);
7926 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
7927 fputs (")", stdout);
7929 if (option->info & OEX_PAGE0)
7930 fputs (" PAGE0", stdout);
7931 if (option->info & OEX_SMM)
7932 fputs (" SMM", stdout);
7933 if (option->info & OEX_FPDBUG)
7934 fputs (" FPDBUG", stdout);
7935 if (option->info & OEX_DISMISS)
7936 fputs (" DISMISS", stdout);
7939 fputs (" PAD ", stdout);
7940 if (option->info & OPAD_PREFIX)
7941 fputs (" PREFIX", stdout);
7942 if (option->info & OPAD_POSTFIX)
7943 fputs (" POSTFIX", stdout);
7944 if (option->info & OPAD_SYMBOL)
7945 fputs (" SYMBOL", stdout);
7948 fputs (" HWPATCH ", stdout);
7949 if (option->info & OHW_R4KEOP)
7950 fputs (" R4KEOP", stdout);
7951 if (option->info & OHW_R8KPFETCH)
7952 fputs (" R8KPFETCH", stdout);
7953 if (option->info & OHW_R5KEOP)
7954 fputs (" R5KEOP", stdout);
7955 if (option->info & OHW_R5KCVTL)
7956 fputs (" R5KCVTL", stdout);
7959 fputs (" FILL ", stdout);
7960 /* XXX Print content of info word? */
7963 fputs (" TAGS ", stdout);
7964 /* XXX Print content of info word? */
7967 fputs (" HWAND ", stdout);
7968 if (option->info & OHWA0_R4KEOP_CHECKED)
7969 fputs (" R4KEOP_CHECKED", stdout);
7970 if (option->info & OHWA0_R4KEOP_CLEAN)
7971 fputs (" R4KEOP_CLEAN", stdout);
7974 fputs (" HWOR ", stdout);
7975 if (option->info & OHWA0_R4KEOP_CHECKED)
7976 fputs (" R4KEOP_CHECKED", stdout);
7977 if (option->info & OHWA0_R4KEOP_CLEAN)
7978 fputs (" R4KEOP_CLEAN", stdout);
7981 printf (" GP_GROUP %#06lx self-contained %#06lx",
7982 option->info & OGP_GROUP,
7983 (option->info & OGP_SELF) >> 16);
7986 printf (" IDENT %#06lx self-contained %#06lx",
7987 option->info & OGP_GROUP,
7988 (option->info & OGP_SELF) >> 16);
7991 /* This shouldn't happen. */
7992 printf (" %3d ??? %d %lx",
7993 option->kind, option->section, option->info);
7997 len = sizeof (* eopt);
7998 while (len < option->size)
7999 if (((char *) option)[len] >= ' '
8000 && ((char *) option)[len] < 0x7f)
8001 printf ("%c", ((char *) option)[len++]);
8003 printf ("\\%03o", ((char *) option)[len++]);
8005 fputs ("\n", stdout);
8012 if (conflicts_offset != 0 && conflictsno != 0)
8014 Elf32_External_Conflict * econf32;
8015 Elf64_External_Conflict * econf64;
8016 Elf32_Conflict * iconf;
8019 if (dynamic_symbols == NULL)
8021 error (_("conflict list with without table"));
8025 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
8028 error (_("Out of memory"));
8034 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf32),
8035 econf32, Elf32_External_Conflict *, "conflict");
8037 for (cnt = 0; cnt < conflictsno; ++cnt)
8038 iconf[cnt] = BYTE_GET (econf32[cnt]);
8042 GET_DATA_ALLOC (conflicts_offset, conflictsno * sizeof (* econf64),
8043 econf64, Elf64_External_Conflict *, "conflict");
8045 for (cnt = 0; cnt < conflictsno; ++cnt)
8046 iconf[cnt] = BYTE_GET (econf64[cnt]);
8049 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno);
8050 puts (_(" Num: Index Value Name"));
8052 for (cnt = 0; cnt < conflictsno; ++cnt)
8054 Elf_Internal_Sym * psym = &dynamic_symbols[iconf[cnt]];
8056 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
8057 print_vma (psym->st_value, FULL_HEX);
8058 printf (" %s\n", dynamic_strings + psym->st_name);
8068 get_note_type (e_type)
8071 static char buff[64];
8075 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
8076 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
8077 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
8078 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
8079 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
8080 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
8081 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
8082 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
8083 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8084 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8085 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8087 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
8092 /* Note that by the ELF standard, the name field is already null byte
8093 terminated, and namesz includes the terminating null byte.
8094 I.E. the value of namesz for the name "FSF" is 4.
8096 If the value of namesz is zero, there is no name present. */
8098 process_note (pnote)
8099 Elf32_Internal_Note * pnote;
8101 printf (" %s\t\t0x%08lx\t%s\n",
8102 pnote->namesz ? pnote->namedata : "(NONE)",
8103 pnote->descsz, get_note_type (pnote->type));
8109 process_corefile_note_segment (file, offset, length)
8114 Elf_External_Note * pnotes;
8115 Elf_External_Note * external;
8121 GET_DATA_ALLOC (offset, length, pnotes, Elf_External_Note *, "notes");
8125 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8126 (unsigned long) offset, (unsigned long) length);
8127 printf (_(" Owner\t\tData size\tDescription\n"));
8129 while (external < (Elf_External_Note *)((char *) pnotes + length))
8131 Elf32_Internal_Note inote;
8134 inote.type = BYTE_GET (external->type);
8135 inote.namesz = BYTE_GET (external->namesz);
8136 inote.namedata = external->name;
8137 inote.descsz = BYTE_GET (external->descsz);
8138 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
8139 inote.descpos = offset + (inote.descdata - (char *) pnotes);
8141 external = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
8143 /* Verify that name is null terminated. It appears that at least
8144 one version of Linux (RedHat 6.0) generates corefiles that don't
8145 comply with the ELF spec by failing to include the null byte in
8147 if (inote.namedata[inote.namesz] != '\0')
8149 temp = malloc (inote.namesz + 1);
8153 error (_("Out of memory\n"));
8158 strncpy (temp, inote.namedata, inote.namesz);
8159 temp[inote.namesz] = 0;
8161 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8162 inote.namedata = temp;
8165 res &= process_note (& inote);
8180 process_corefile_note_segments (file)
8183 Elf_Internal_Phdr * program_headers;
8184 Elf_Internal_Phdr * segment;
8188 program_headers = (Elf_Internal_Phdr *) malloc
8189 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
8191 if (program_headers == NULL)
8193 error (_("Out of memory\n"));
8198 i = get_32bit_program_headers (file, program_headers);
8200 i = get_64bit_program_headers (file, program_headers);
8204 free (program_headers);
8208 for (i = 0, segment = program_headers;
8209 i < elf_header.e_phnum;
8212 if (segment->p_type == PT_NOTE)
8213 res &= process_corefile_note_segment (file,
8214 (bfd_vma) segment->p_offset,
8215 (bfd_vma) segment->p_filesz);
8218 free (program_headers);
8224 process_corefile_contents (file)
8227 /* If we have not been asked to display the notes then do nothing. */
8231 /* If file is not a core file then exit. */
8232 if (elf_header.e_type != ET_CORE)
8235 /* No program headers means no NOTE segment. */
8236 if (elf_header.e_phnum == 0)
8238 printf (_("No note segments present in the core file.\n"));
8242 return process_corefile_note_segments (file);
8246 process_arch_specific (file)
8252 switch (elf_header.e_machine)
8255 case EM_MIPS_RS4_BE:
8256 return process_mips_specific (file);
8265 get_file_header (file)
8268 /* Read in the identity array. */
8269 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
8272 /* Determine how to read the rest of the header. */
8273 switch (elf_header.e_ident [EI_DATA])
8275 default: /* fall through */
8276 case ELFDATANONE: /* fall through */
8277 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
8278 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
8281 /* For now we only support 32 bit and 64 bit ELF files. */
8282 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
8284 /* Read in the rest of the header. */
8287 Elf32_External_Ehdr ehdr32;
8289 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
8292 elf_header.e_type = BYTE_GET (ehdr32.e_type);
8293 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
8294 elf_header.e_version = BYTE_GET (ehdr32.e_version);
8295 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
8296 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
8297 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
8298 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
8299 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
8300 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
8301 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
8302 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
8303 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
8304 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
8308 Elf64_External_Ehdr ehdr64;
8310 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8311 we will not be able to cope with the 64bit data found in
8312 64 ELF files. Detect this now and abort before we start
8313 overwritting things. */
8314 if (sizeof (bfd_vma) < 8)
8316 error (_("This instance of readelf has been built without support for a\n"));
8317 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
8321 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
8324 elf_header.e_type = BYTE_GET (ehdr64.e_type);
8325 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
8326 elf_header.e_version = BYTE_GET (ehdr64.e_version);
8327 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
8328 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
8329 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
8330 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
8331 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
8332 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
8333 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
8334 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
8335 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
8336 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
8343 process_file (file_name)
8347 struct stat statbuf;
8350 if (stat (file_name, & statbuf) < 0)
8352 error (_("Cannot stat input file %s.\n"), file_name);
8356 file = fopen (file_name, "rb");
8359 error (_("Input file %s not found.\n"), file_name);
8363 if (! get_file_header (file))
8365 error (_("%s: Failed to read file header\n"), file_name);
8370 /* Initialise per file variables. */
8371 for (i = NUM_ELEM (version_info); i--;)
8372 version_info[i] = 0;
8374 for (i = NUM_ELEM (dynamic_info); i--;)
8375 dynamic_info[i] = 0;
8377 /* Process the file. */
8379 printf (_("\nFile: %s\n"), file_name);
8381 if (! process_file_header ())
8387 process_section_headers (file);
8389 process_program_headers (file);
8391 process_dynamic_segment (file);
8393 process_relocs (file);
8395 process_unwind (file);
8397 process_symbol_table (file);
8399 process_syminfo (file);
8401 process_version_sections (file);
8403 process_section_contents (file);
8405 process_corefile_contents (file);
8407 process_arch_specific (file);
8411 if (section_headers)
8413 free (section_headers);
8414 section_headers = NULL;
8419 free (string_table);
8420 string_table = NULL;
8421 string_table_length = 0;
8424 if (dynamic_strings)
8426 free (dynamic_strings);
8427 dynamic_strings = NULL;
8430 if (dynamic_symbols)
8432 free (dynamic_symbols);
8433 dynamic_symbols = NULL;
8434 num_dynamic_syms = 0;
8437 if (dynamic_syminfo)
8439 free (dynamic_syminfo);
8440 dynamic_syminfo = NULL;
8444 #ifdef SUPPORT_DISASSEMBLY
8445 /* Needed by the i386 disassembler. For extra credit, someone could
8446 fix this so that we insert symbolic addresses here, esp for GOT/PLT
8450 print_address (unsigned int addr, FILE * outfile)
8452 fprintf (outfile,"0x%8.8x", addr);
8455 /* Needed by the i386 disassembler. */
8457 db_task_printsym (unsigned int addr)
8459 print_address (addr, stderr);
8468 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
8469 setlocale (LC_MESSAGES, "");
8471 bindtextdomain (PACKAGE, LOCALEDIR);
8472 textdomain (PACKAGE);
8474 parse_args (argc, argv);
8476 if (optind < (argc - 1))
8479 while (optind < argc)
8480 process_file (argv [optind ++]);
8482 if (dump_sects != NULL)