1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.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
52 #include "elf/alpha.h"
72 #include "elf/m68hc11.h"
73 #include "elf/mcore.h"
76 #include "elf/mn10200.h"
77 #include "elf/mn10300.h"
83 #include "elf/sparc.h"
86 #include "elf/x86-64.h"
87 #include "elf/xstormy16.h"
92 char * program_name = "readelf";
93 unsigned int dynamic_addr;
94 bfd_size_type dynamic_size;
95 unsigned int rela_addr;
96 unsigned int rela_size;
97 char * dynamic_strings;
99 unsigned long string_table_length;
100 unsigned long num_dynamic_syms;
101 Elf_Internal_Sym * dynamic_symbols;
102 Elf_Internal_Syminfo * dynamic_syminfo;
103 unsigned long dynamic_syminfo_offset;
104 unsigned int dynamic_syminfo_nent;
105 char program_interpreter [64];
106 int dynamic_info[DT_JMPREL + 1];
107 int version_info[16];
109 Elf_Internal_Ehdr elf_header;
110 Elf_Internal_Shdr * section_headers;
111 Elf_Internal_Dyn * dynamic_segment;
112 Elf_Internal_Shdr * symtab_shndx_hdr;
120 int do_using_dynamic;
128 int do_debug_abbrevs;
130 int do_debug_pubnames;
131 int do_debug_aranges;
133 int do_debug_frames_interp;
134 int do_debug_macinfo;
141 /* A dynamic array of flags indicating which sections require dumping. */
142 char * dump_sects = NULL;
143 unsigned int num_dump_sects = 0;
145 #define HEX_DUMP (1 << 0)
146 #define DISASS_DUMP (1 << 1)
147 #define DEBUG_DUMP (1 << 2)
149 /* How to rpint a vma value. */
150 typedef enum print_mode
162 /* Forward declarations for dumb compilers. */
163 static void print_vma PARAMS ((bfd_vma, print_mode));
164 static void print_symbol PARAMS ((int, char *));
165 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
166 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
167 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
168 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
169 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
170 static const char * get_ppc64_dynamic_type PARAMS ((unsigned long));
171 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
172 static const char * get_dynamic_type PARAMS ((unsigned long));
173 static int slurp_rela_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **, unsigned long *));
174 static int slurp_rel_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel **, unsigned long *));
175 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
176 static char * get_file_type PARAMS ((unsigned));
177 static char * get_machine_name PARAMS ((unsigned));
178 static void decode_ARM_machine_flags PARAMS ((unsigned, char []));
179 static char * get_machine_flags PARAMS ((unsigned, unsigned));
180 static const char * get_mips_segment_type PARAMS ((unsigned long));
181 static const char * get_parisc_segment_type PARAMS ((unsigned long));
182 static const char * get_ia64_segment_type PARAMS ((unsigned long));
183 static const char * get_segment_type PARAMS ((unsigned long));
184 static const char * get_mips_section_type_name PARAMS ((unsigned int));
185 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
186 static const char * get_ia64_section_type_name PARAMS ((unsigned int));
187 static const char * get_section_type_name PARAMS ((unsigned int));
188 static const char * get_symbol_binding PARAMS ((unsigned int));
189 static const char * get_symbol_type PARAMS ((unsigned int));
190 static const char * get_symbol_visibility PARAMS ((unsigned int));
191 static const char * get_symbol_index_type PARAMS ((unsigned int));
192 static const char * get_dynamic_flags PARAMS ((bfd_vma));
193 static void usage PARAMS ((void));
194 static void parse_args PARAMS ((int, char **));
195 static int process_file_header PARAMS ((void));
196 static int process_program_headers PARAMS ((FILE *));
197 static int process_section_headers PARAMS ((FILE *));
198 static int process_unwind PARAMS ((FILE *));
199 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
200 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
201 static int process_dynamic_segment PARAMS ((FILE *));
202 static int process_symbol_table PARAMS ((FILE *));
203 static int process_syminfo PARAMS ((FILE *));
204 static int process_section_contents PARAMS ((FILE *));
205 static void process_mips_fpe_exception PARAMS ((int));
206 static int process_mips_specific PARAMS ((FILE *));
207 static int process_file PARAMS ((char *));
208 static int process_relocs PARAMS ((FILE *));
209 static int process_version_sections PARAMS ((FILE *));
210 static char * get_ver_flags PARAMS ((unsigned int));
211 static int get_32bit_section_headers PARAMS ((FILE *, unsigned int));
212 static int get_64bit_section_headers PARAMS ((FILE *, unsigned int));
213 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
214 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
215 static int get_file_header PARAMS ((FILE *));
216 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, Elf_Internal_Shdr *));
217 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, Elf_Internal_Shdr *));
218 static const char * get_elf_section_flags PARAMS ((bfd_vma));
219 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
220 static int get_32bit_dynamic_segment PARAMS ((FILE *));
221 static int get_64bit_dynamic_segment PARAMS ((FILE *));
222 #ifdef SUPPORT_DISASSEMBLY
223 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
225 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
226 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
227 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
228 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
229 static int prescan_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
230 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
231 static int display_debug_pubnames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
232 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
233 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
234 static int display_debug_frames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
235 static int display_debug_macinfo PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
236 static int display_debug_str PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
237 static int display_debug_loc PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
238 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
239 static void load_debug_str PARAMS ((FILE *));
240 static void free_debug_str PARAMS ((void));
241 static const char * fetch_indirect_string PARAMS ((unsigned long));
242 static void load_debug_loc PARAMS ((FILE *));
243 static void free_debug_loc PARAMS ((void));
244 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
245 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
246 static void reset_state_machine PARAMS ((int));
247 static char * get_TAG_name PARAMS ((unsigned long));
248 static char * get_AT_name PARAMS ((unsigned long));
249 static char * get_FORM_name PARAMS ((unsigned long));
250 static void free_abbrevs PARAMS ((void));
251 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
252 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
253 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
254 static unsigned char * read_and_display_attr_value PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
255 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
256 static void decode_location_expression PARAMS ((unsigned char *, unsigned int, unsigned long));
257 static void request_dump PARAMS ((unsigned int, int));
258 static const char * get_elf_class PARAMS ((unsigned int));
259 static const char * get_data_encoding PARAMS ((unsigned int));
260 static const char * get_osabi_name PARAMS ((unsigned int));
261 static int guess_is_rela PARAMS ((unsigned long));
262 static const char * get_note_type PARAMS ((unsigned int));
263 static const char * get_netbsd_elfcore_note_type PARAMS ((unsigned int));
264 static int process_note PARAMS ((Elf32_Internal_Note *));
265 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
266 static int process_corefile_note_segments PARAMS ((FILE *));
267 static int process_corefile_contents PARAMS ((FILE *));
268 static int process_arch_specific PARAMS ((FILE *));
269 static int process_gnu_liblist PARAMS ((FILE *));
271 typedef int Elf32_Word;
279 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
280 ((X)->sh_name >= string_table_length \
281 ? "<corrupt>" : string_table + (X)->sh_name))
283 /* Given st_shndx I, map to section_headers index. */
284 #define SECTION_HEADER_INDEX(I) \
285 ((I) < SHN_LORESERVE \
287 : ((I) <= SHN_HIRESERVE \
289 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
291 /* Reverse of the above. */
292 #define SECTION_HEADER_NUM(N) \
293 ((N) < SHN_LORESERVE \
295 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
297 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
299 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
301 #define BYTE_GET(field) byte_get (field, sizeof (field))
303 /* If we can support a 64 bit data type then BFD64 should be defined
304 and sizeof (bfd_vma) == 8. In this case when translating from an
305 external 8 byte field to an internal field, we can assume that the
306 internal field is also 8 bytes wide and so we can extract all the data.
307 If, however, BFD64 is not defined, then we must assume that the
308 internal data structure only has 4 byte wide fields that are the
309 equivalent of the 8 byte wide external counterparts, and so we must
310 truncate the data. */
312 #define BYTE_GET8(field) byte_get (field, -8)
314 #define BYTE_GET8(field) byte_get (field, 8)
317 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
319 #define GET_ELF_SYMBOLS(file, section) \
320 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
321 : get_64bit_elf_symbols (file, section))
325 error VPARAMS ((const char *message, ...))
327 VA_OPEN (args, message);
328 VA_FIXEDARG (args, const char *, message);
330 fprintf (stderr, _("%s: Error: "), program_name);
331 vfprintf (stderr, message, args);
336 warn VPARAMS ((const char *message, ...))
338 VA_OPEN (args, message);
339 VA_FIXEDARG (args, const char *, message);
341 fprintf (stderr, _("%s: Warning: "), program_name);
342 vfprintf (stderr, message, args);
346 static PTR get_data PARAMS ((PTR, FILE *, long, size_t, const char *));
349 get_data (var, file, offset, size, reason)
361 if (fseek (file, offset, SEEK_SET))
363 error (_("Unable to seek to %x for %s\n"), offset, reason);
370 mvar = (PTR) malloc (size);
374 error (_("Out of memory allocating %d bytes for %s\n"),
380 if (fread (mvar, size, 1, file) != 1)
382 error (_("Unable to read in %d bytes of %s\n"), size, reason);
392 byte_get_little_endian (field, size)
393 unsigned char * field;
402 return ((unsigned int) (field [0]))
403 | (((unsigned int) (field [1])) << 8);
407 /* We want to extract data from an 8 byte wide field and
408 place it into a 4 byte wide field. Since this is a little
409 endian source we can juts use the 4 byte extraction code. */
413 return ((unsigned long) (field [0]))
414 | (((unsigned long) (field [1])) << 8)
415 | (((unsigned long) (field [2])) << 16)
416 | (((unsigned long) (field [3])) << 24);
421 /* This is a special case, generated by the BYTE_GET8 macro.
422 It means that we are loading an 8 byte value from a field
423 in an external structure into an 8 byte value in a field
424 in an internal strcuture. */
425 return ((bfd_vma) (field [0]))
426 | (((bfd_vma) (field [1])) << 8)
427 | (((bfd_vma) (field [2])) << 16)
428 | (((bfd_vma) (field [3])) << 24)
429 | (((bfd_vma) (field [4])) << 32)
430 | (((bfd_vma) (field [5])) << 40)
431 | (((bfd_vma) (field [6])) << 48)
432 | (((bfd_vma) (field [7])) << 56);
435 error (_("Unhandled data length: %d\n"), size);
440 /* Print a VMA value. */
442 print_vma (vma, mode)
452 case FULL_HEX: printf ("0x"); /* drop through */
453 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
454 case PREFIX_HEX: printf ("0x"); /* drop through */
455 case HEX: printf ("%lx", (unsigned long) vma); break;
456 case DEC: printf ("%ld", (unsigned long) vma); break;
457 case DEC_5: printf ("%5ld", (long) vma); break;
458 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
479 #if BFD_HOST_64BIT_LONG
482 if (_bfd_int64_high (vma))
483 printf ("%lx%8.8lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
485 printf ("%lx", _bfd_int64_low (vma));
490 #if BFD_HOST_64BIT_LONG
493 if (_bfd_int64_high (vma))
495 printf ("++%ld", _bfd_int64_low (vma));
497 printf ("%ld", _bfd_int64_low (vma));
502 #if BFD_HOST_64BIT_LONG
503 printf ("%5ld", vma);
505 if (_bfd_int64_high (vma))
507 printf ("++%ld", _bfd_int64_low (vma));
509 printf ("%5ld", _bfd_int64_low (vma));
514 #if BFD_HOST_64BIT_LONG
517 if (_bfd_int64_high (vma))
519 printf ("++%lu", _bfd_int64_low (vma));
521 printf ("%lu", _bfd_int64_low (vma));
529 /* Display a symbol on stdout. If do_wide is not true then
530 format the symbol to be at most WIDTH characters,
531 truncating as necessary. If WIDTH is negative then
532 format the string to be exactly - WIDTH characters,
533 truncating or padding as necessary. */
536 print_symbol (width, symbol)
543 printf ("%-*.*s", width, width, symbol);
545 printf ("%-.*s", width, symbol);
549 byte_get_big_endian (field, size)
550 unsigned char * field;
559 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
562 return ((unsigned long) (field [3]))
563 | (((unsigned long) (field [2])) << 8)
564 | (((unsigned long) (field [1])) << 16)
565 | (((unsigned long) (field [0])) << 24);
569 /* Although we are extracing data from an 8 byte wide field, we
570 are returning only 4 bytes of data. */
571 return ((unsigned long) (field [7]))
572 | (((unsigned long) (field [6])) << 8)
573 | (((unsigned long) (field [5])) << 16)
574 | (((unsigned long) (field [4])) << 24);
578 /* This is a special case, generated by the BYTE_GET8 macro.
579 It means that we are loading an 8 byte value from a field
580 in an external structure into an 8 byte value in a field
581 in an internal strcuture. */
582 return ((bfd_vma) (field [7]))
583 | (((bfd_vma) (field [6])) << 8)
584 | (((bfd_vma) (field [5])) << 16)
585 | (((bfd_vma) (field [4])) << 24)
586 | (((bfd_vma) (field [3])) << 32)
587 | (((bfd_vma) (field [2])) << 40)
588 | (((bfd_vma) (field [1])) << 48)
589 | (((bfd_vma) (field [0])) << 56);
593 error (_("Unhandled data length: %d\n"), size);
598 /* Guess the relocation size commonly used by the specific machines. */
601 guess_is_rela (e_machine)
602 unsigned long e_machine;
606 /* Targets that use REL relocations. */
622 /* Targets that use RELA relocations. */
637 case EM_CYGNUS_MN10200:
639 case EM_CYGNUS_MN10300:
679 warn (_("Don't know about relocations on this machine architecture\n"));
685 slurp_rela_relocs (file, rel_offset, rel_size, relasp, nrelasp)
687 unsigned long rel_offset;
688 unsigned long rel_size;
689 Elf_Internal_Rela **relasp;
690 unsigned long *nrelasp;
692 Elf_Internal_Rela *relas;
693 unsigned long nrelas;
698 Elf32_External_Rela * erelas;
700 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset,
701 rel_size, _("relocs"));
705 nrelas = rel_size / sizeof (Elf32_External_Rela);
707 relas = (Elf_Internal_Rela *)
708 malloc (nrelas * sizeof (Elf_Internal_Rela));
712 error(_("out of memory parsing relocs"));
716 for (i = 0; i < nrelas; i++)
718 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
719 relas[i].r_info = BYTE_GET (erelas[i].r_info);
720 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
727 Elf64_External_Rela * erelas;
729 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset,
730 rel_size, _("relocs"));
734 nrelas = rel_size / sizeof (Elf64_External_Rela);
736 relas = (Elf_Internal_Rela *)
737 malloc (nrelas * sizeof (Elf_Internal_Rela));
741 error(_("out of memory parsing relocs"));
745 for (i = 0; i < nrelas; i++)
747 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
748 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
749 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
760 slurp_rel_relocs (file, rel_offset, rel_size, relsp, nrelsp)
762 unsigned long rel_offset;
763 unsigned long rel_size;
764 Elf_Internal_Rel **relsp;
765 unsigned long *nrelsp;
767 Elf_Internal_Rel *rels;
773 Elf32_External_Rel * erels;
775 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset,
776 rel_size, _("relocs"));
780 nrels = rel_size / sizeof (Elf32_External_Rel);
782 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
786 error(_("out of memory parsing relocs"));
790 for (i = 0; i < nrels; i++)
792 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
793 rels[i].r_info = BYTE_GET (erels[i].r_info);
800 Elf64_External_Rel * erels;
802 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset,
803 rel_size, _("relocs"));
807 nrels = rel_size / sizeof (Elf64_External_Rel);
809 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
813 error(_("out of memory parsing relocs"));
817 for (i = 0; i < nrels; i++)
819 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
820 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
830 /* Display the contents of the relocation data found at the specified offset. */
832 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
834 unsigned long rel_offset;
835 unsigned long rel_size;
836 Elf_Internal_Sym * symtab;
842 Elf_Internal_Rel * rels;
843 Elf_Internal_Rela * relas;
846 if (is_rela == UNKNOWN)
847 is_rela = guess_is_rela (elf_header.e_machine);
851 if (!slurp_rela_relocs (file, rel_offset, rel_size, &relas, &rel_size))
856 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
865 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
867 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
872 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
874 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
882 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
884 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
889 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
891 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
895 for (i = 0; i < rel_size; i++)
898 const char * rtype2 = NULL;
899 const char * rtype3 = NULL;
902 bfd_vma symtab_index;
904 bfd_vma type2 = (bfd_vma) NULL;
905 bfd_vma type3 = (bfd_vma) NULL;
909 offset = relas [i].r_offset;
910 info = relas [i].r_info;
914 offset = rels [i].r_offset;
915 info = rels [i].r_info;
920 type = ELF32_R_TYPE (info);
921 symtab_index = ELF32_R_SYM (info);
925 if (elf_header.e_machine == EM_MIPS)
927 type = ELF64_MIPS_R_TYPE (info);
928 type2 = ELF64_MIPS_R_TYPE2 (info);
929 type3 = ELF64_MIPS_R_TYPE3 (info);
931 else if (elf_header.e_machine == EM_SPARCV9)
932 type = ELF64_R_TYPE_ID (info);
934 type = ELF64_R_TYPE (info);
935 /* The #ifdef BFD64 below is to prevent a compile time warning.
936 We know that if we do not have a 64 bit data type that we
937 will never execute this code anyway. */
939 symtab_index = ELF64_R_SYM (info);
945 #ifdef _bfd_int64_low
946 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
948 printf ("%8.8lx %8.8lx ", offset, info);
953 #ifdef _bfd_int64_low
955 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
956 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
957 _bfd_int64_high (offset),
958 _bfd_int64_low (offset),
959 _bfd_int64_high (info),
960 _bfd_int64_low (info));
963 ? "%16.16lx %16.16lx "
964 : "%12.12lx %12.12lx ",
969 switch (elf_header.e_machine)
977 rtype = elf_m32r_reloc_type (type);
982 rtype = elf_i386_reloc_type (type);
987 rtype = elf_m68hc11_reloc_type (type);
991 rtype = elf_m68k_reloc_type (type);
995 rtype = elf_i960_reloc_type (type);
1000 rtype = elf_avr_reloc_type (type);
1003 case EM_OLD_SPARCV9:
1004 case EM_SPARC32PLUS:
1007 rtype = elf_sparc_reloc_type (type);
1011 case EM_CYGNUS_V850:
1012 rtype = v850_reloc_type (type);
1016 case EM_CYGNUS_D10V:
1017 rtype = elf_d10v_reloc_type (type);
1021 case EM_CYGNUS_D30V:
1022 rtype = elf_d30v_reloc_type (type);
1026 rtype = elf_dlx_reloc_type (type);
1030 rtype = elf_sh_reloc_type (type);
1034 case EM_CYGNUS_MN10300:
1035 rtype = elf_mn10300_reloc_type (type);
1039 case EM_CYGNUS_MN10200:
1040 rtype = elf_mn10200_reloc_type (type);
1044 case EM_CYGNUS_FR30:
1045 rtype = elf_fr30_reloc_type (type);
1049 rtype = elf_frv_reloc_type (type);
1053 rtype = elf_mcore_reloc_type (type);
1057 rtype = elf_mmix_reloc_type (type);
1062 rtype = elf_ppc_reloc_type (type);
1066 case EM_MIPS_RS3_LE:
1067 rtype = elf_mips_reloc_type (type);
1070 rtype2 = elf_mips_reloc_type (type2);
1071 rtype3 = elf_mips_reloc_type (type3);
1076 rtype = elf_alpha_reloc_type (type);
1080 rtype = elf_arm_reloc_type (type);
1084 rtype = elf_arc_reloc_type (type);
1088 rtype = elf_hppa_reloc_type (type);
1094 rtype = elf_h8_reloc_type (type);
1099 rtype = elf_or32_reloc_type (type);
1104 rtype = elf_pj_reloc_type (type);
1107 rtype = elf_ia64_reloc_type (type);
1111 rtype = elf_cris_reloc_type (type);
1115 rtype = elf_i860_reloc_type (type);
1119 rtype = elf_x86_64_reloc_type (type);
1123 rtype = i370_reloc_type (type);
1128 rtype = elf_s390_reloc_type (type);
1132 rtype = elf_xstormy16_reloc_type (type);
1136 rtype = elf_vax_reloc_type (type);
1141 rtype = elf_ip2k_reloc_type (type);
1146 #ifdef _bfd_int64_low
1147 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1149 printf (_("unrecognized: %-7lx"), type);
1152 printf (do_wide ? "%-21.21s" : "%-17.17s", rtype);
1156 if (symtab == NULL || symtab_index >= nsyms)
1157 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1160 Elf_Internal_Sym * psym;
1162 psym = symtab + symtab_index;
1165 print_vma (psym->st_value, LONG_HEX);
1166 printf (is_32bit_elf ? " " : " ");
1168 if (psym->st_name == 0)
1169 print_symbol (22, SECTION_NAME (section_headers + psym->st_shndx));
1170 else if (strtab == NULL)
1171 printf (_("<string table index %3ld>"), psym->st_name);
1173 print_symbol (22, strtab + psym->st_name);
1176 printf (" + %lx", (unsigned long) relas [i].r_addend);
1181 printf ("%*c", is_32bit_elf ? (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1182 print_vma (relas[i].r_addend, LONG_HEX);
1185 if (elf_header.e_machine == EM_SPARCV9
1186 && !strcmp (rtype, "R_SPARC_OLO10"))
1187 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1191 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1193 printf (" Type2: ");
1196 #ifdef _bfd_int64_low
1197 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1199 printf (_("unrecognized: %-7lx"), type2);
1202 printf ("%-17.17s", rtype2);
1204 printf("\n Type3: ");
1207 #ifdef _bfd_int64_low
1208 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1210 printf (_("unrecognized: %-7lx"), type3);
1213 printf ("%-17.17s", rtype3);
1228 get_mips_dynamic_type (type)
1233 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1234 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1235 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1236 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1237 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1238 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1239 case DT_MIPS_MSYM: return "MIPS_MSYM";
1240 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1241 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1242 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1243 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1244 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1245 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1246 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1247 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1248 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1249 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1250 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1251 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1252 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1253 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1254 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1255 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1256 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1257 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1258 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1259 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1260 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1261 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1262 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1263 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1264 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1265 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1266 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1267 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1268 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1269 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1270 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1271 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1272 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1273 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1274 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1275 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1282 get_sparc64_dynamic_type (type)
1287 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1294 get_ppc64_dynamic_type (type)
1299 case DT_PPC64_GLINK: return "PPC64_GLINK";
1300 case DT_PPC64_OPD: return "PPC64_OPD";
1301 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1308 get_parisc_dynamic_type (type)
1313 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1314 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1315 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1316 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1317 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1318 case DT_HP_PREINIT: return "HP_PREINIT";
1319 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1320 case DT_HP_NEEDED: return "HP_NEEDED";
1321 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1322 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1323 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1324 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1325 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1332 get_dynamic_type (type)
1335 static char buff [32];
1339 case DT_NULL: return "NULL";
1340 case DT_NEEDED: return "NEEDED";
1341 case DT_PLTRELSZ: return "PLTRELSZ";
1342 case DT_PLTGOT: return "PLTGOT";
1343 case DT_HASH: return "HASH";
1344 case DT_STRTAB: return "STRTAB";
1345 case DT_SYMTAB: return "SYMTAB";
1346 case DT_RELA: return "RELA";
1347 case DT_RELASZ: return "RELASZ";
1348 case DT_RELAENT: return "RELAENT";
1349 case DT_STRSZ: return "STRSZ";
1350 case DT_SYMENT: return "SYMENT";
1351 case DT_INIT: return "INIT";
1352 case DT_FINI: return "FINI";
1353 case DT_SONAME: return "SONAME";
1354 case DT_RPATH: return "RPATH";
1355 case DT_SYMBOLIC: return "SYMBOLIC";
1356 case DT_REL: return "REL";
1357 case DT_RELSZ: return "RELSZ";
1358 case DT_RELENT: return "RELENT";
1359 case DT_PLTREL: return "PLTREL";
1360 case DT_DEBUG: return "DEBUG";
1361 case DT_TEXTREL: return "TEXTREL";
1362 case DT_JMPREL: return "JMPREL";
1363 case DT_BIND_NOW: return "BIND_NOW";
1364 case DT_INIT_ARRAY: return "INIT_ARRAY";
1365 case DT_FINI_ARRAY: return "FINI_ARRAY";
1366 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1367 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1368 case DT_RUNPATH: return "RUNPATH";
1369 case DT_FLAGS: return "FLAGS";
1371 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1372 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1374 case DT_CHECKSUM: return "CHECKSUM";
1375 case DT_PLTPADSZ: return "PLTPADSZ";
1376 case DT_MOVEENT: return "MOVEENT";
1377 case DT_MOVESZ: return "MOVESZ";
1378 case DT_FEATURE: return "FEATURE";
1379 case DT_POSFLAG_1: return "POSFLAG_1";
1380 case DT_SYMINSZ: return "SYMINSZ";
1381 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1383 case DT_ADDRRNGLO: return "ADDRRNGLO";
1384 case DT_CONFIG: return "CONFIG";
1385 case DT_DEPAUDIT: return "DEPAUDIT";
1386 case DT_AUDIT: return "AUDIT";
1387 case DT_PLTPAD: return "PLTPAD";
1388 case DT_MOVETAB: return "MOVETAB";
1389 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1391 case DT_VERSYM: return "VERSYM";
1393 case DT_RELACOUNT: return "RELACOUNT";
1394 case DT_RELCOUNT: return "RELCOUNT";
1395 case DT_FLAGS_1: return "FLAGS_1";
1396 case DT_VERDEF: return "VERDEF";
1397 case DT_VERDEFNUM: return "VERDEFNUM";
1398 case DT_VERNEED: return "VERNEED";
1399 case DT_VERNEEDNUM: return "VERNEEDNUM";
1401 case DT_AUXILIARY: return "AUXILIARY";
1402 case DT_USED: return "USED";
1403 case DT_FILTER: return "FILTER";
1405 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1406 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1407 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1408 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1409 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1412 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1414 const char * result;
1416 switch (elf_header.e_machine)
1419 case EM_MIPS_RS3_LE:
1420 result = get_mips_dynamic_type (type);
1423 result = get_sparc64_dynamic_type (type);
1426 result = get_ppc64_dynamic_type (type);
1436 sprintf (buff, _("Processor Specific: %lx"), type);
1438 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1440 const char * result;
1442 switch (elf_header.e_machine)
1445 result = get_parisc_dynamic_type (type);
1455 sprintf (buff, _("Operating System specific: %lx"), type);
1458 sprintf (buff, _("<unknown>: %lx"), type);
1465 get_file_type (e_type)
1468 static char buff [32];
1472 case ET_NONE: return _("NONE (None)");
1473 case ET_REL: return _("REL (Relocatable file)");
1474 case ET_EXEC: return _("EXEC (Executable file)");
1475 case ET_DYN: return _("DYN (Shared object file)");
1476 case ET_CORE: return _("CORE (Core file)");
1479 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1480 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1481 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1482 sprintf (buff, _("OS Specific: (%x)"), e_type);
1484 sprintf (buff, _("<unknown>: %x"), e_type);
1490 get_machine_name (e_machine)
1493 static char buff [64]; /* XXX */
1497 case EM_NONE: return _("None");
1498 case EM_M32: return "WE32100";
1499 case EM_SPARC: return "Sparc";
1500 case EM_386: return "Intel 80386";
1501 case EM_68K: return "MC68000";
1502 case EM_88K: return "MC88000";
1503 case EM_486: return "Intel 80486";
1504 case EM_860: return "Intel 80860";
1505 case EM_MIPS: return "MIPS R3000";
1506 case EM_S370: return "IBM System/370";
1507 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1508 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1509 case EM_PARISC: return "HPPA";
1510 case EM_PPC_OLD: return "Power PC (old)";
1511 case EM_SPARC32PLUS: return "Sparc v8+" ;
1512 case EM_960: return "Intel 90860";
1513 case EM_PPC: return "PowerPC";
1514 case EM_PPC64: return "PowerPC64";
1515 case EM_V800: return "NEC V800";
1516 case EM_FR20: return "Fujitsu FR20";
1517 case EM_RH32: return "TRW RH32";
1518 case EM_MCORE: return "MCORE";
1519 case EM_ARM: return "ARM";
1520 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1521 case EM_SH: return "Hitachi SH";
1522 case EM_SPARCV9: return "Sparc v9";
1523 case EM_TRICORE: return "Siemens Tricore";
1524 case EM_ARC: return "ARC";
1525 case EM_H8_300: return "Hitachi H8/300";
1526 case EM_H8_300H: return "Hitachi H8/300H";
1527 case EM_H8S: return "Hitachi H8S";
1528 case EM_H8_500: return "Hitachi H8/500";
1529 case EM_IA_64: return "Intel IA-64";
1530 case EM_MIPS_X: return "Stanford MIPS-X";
1531 case EM_COLDFIRE: return "Motorola Coldfire";
1532 case EM_68HC12: return "Motorola M68HC12";
1533 case EM_ALPHA: return "Alpha";
1534 case EM_CYGNUS_D10V:
1535 case EM_D10V: return "d10v";
1536 case EM_CYGNUS_D30V:
1537 case EM_D30V: return "d30v";
1538 case EM_CYGNUS_M32R:
1539 case EM_M32R: return "Mitsubishi M32r";
1540 case EM_CYGNUS_V850:
1541 case EM_V850: return "NEC v850";
1542 case EM_CYGNUS_MN10300:
1543 case EM_MN10300: return "mn10300";
1544 case EM_CYGNUS_MN10200:
1545 case EM_MN10200: return "mn10200";
1546 case EM_CYGNUS_FR30:
1547 case EM_FR30: return "Fujitsu FR30";
1548 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1550 case EM_PJ: return "picoJava";
1551 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1552 case EM_PCP: return "Siemens PCP";
1553 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1554 case EM_NDR1: return "Denso NDR1 microprocesspr";
1555 case EM_STARCORE: return "Motorola Star*Core processor";
1556 case EM_ME16: return "Toyota ME16 processor";
1557 case EM_ST100: return "STMicroelectronics ST100 processor";
1558 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1559 case EM_FX66: return "Siemens FX66 microcontroller";
1560 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1561 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1562 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1563 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1564 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1565 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1566 case EM_SVX: return "Silicon Graphics SVx";
1567 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1568 case EM_VAX: return "Digital VAX";
1570 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1571 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1572 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1573 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1574 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1575 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1576 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1577 case EM_PRISM: return "SiTera Prism";
1578 case EM_X86_64: return "Advanced Micro Devices X86-64";
1580 case EM_S390: return "IBM S/390";
1581 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1583 case EM_OR32: return "OpenRISC";
1584 case EM_DLX: return "OpenDLX";
1586 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1588 sprintf (buff, _("<unknown>: %x"), e_machine);
1594 decode_ARM_machine_flags (e_flags, buf)
1601 eabi = EF_ARM_EABI_VERSION (e_flags);
1602 e_flags &= ~ EF_ARM_EABIMASK;
1604 /* Handle "generic" ARM flags. */
1605 if (e_flags & EF_ARM_RELEXEC)
1607 strcat (buf, ", relocatable executable");
1608 e_flags &= ~ EF_ARM_RELEXEC;
1611 if (e_flags & EF_ARM_HASENTRY)
1613 strcat (buf, ", has entry point");
1614 e_flags &= ~ EF_ARM_HASENTRY;
1617 /* Now handle EABI specific flags. */
1621 strcat (buf, ", <unrecognized EABI>");
1626 case EF_ARM_EABI_VER1:
1627 strcat (buf, ", Version1 EABI");
1632 /* Process flags one bit at a time. */
1633 flag = e_flags & - e_flags;
1638 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1639 strcat (buf, ", sorted symbol tables");
1649 case EF_ARM_EABI_VER2:
1650 strcat (buf, ", Version2 EABI");
1655 /* Process flags one bit at a time. */
1656 flag = e_flags & - e_flags;
1661 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1662 strcat (buf, ", sorted symbol tables");
1665 case EF_ARM_DYNSYMSUSESEGIDX:
1666 strcat (buf, ", dynamic symbols use segment index");
1669 case EF_ARM_MAPSYMSFIRST:
1670 strcat (buf, ", mapping symbols precede others");
1680 case EF_ARM_EABI_UNKNOWN:
1681 strcat (buf, ", GNU EABI");
1686 /* Process flags one bit at a time. */
1687 flag = e_flags & - e_flags;
1692 case EF_ARM_INTERWORK:
1693 strcat (buf, ", interworking enabled");
1696 case EF_ARM_APCS_26:
1697 strcat (buf, ", uses APCS/26");
1700 case EF_ARM_APCS_FLOAT:
1701 strcat (buf, ", uses APCS/float");
1705 strcat (buf, ", position independent");
1709 strcat (buf, ", 8 bit structure alignment");
1712 case EF_ARM_NEW_ABI:
1713 strcat (buf, ", uses new ABI");
1716 case EF_ARM_OLD_ABI:
1717 strcat (buf, ", uses old ABI");
1720 case EF_ARM_SOFT_FLOAT:
1721 strcat (buf, ", software FP");
1732 strcat (buf,", <unknown>");
1736 get_machine_flags (e_flags, e_machine)
1740 static char buf [1024];
1752 decode_ARM_machine_flags (e_flags, buf);
1756 if (e_flags & EF_CPU32)
1757 strcat (buf, ", cpu32");
1758 if (e_flags & EF_M68000)
1759 strcat (buf, ", m68000");
1763 if (e_flags & EF_PPC_EMB)
1764 strcat (buf, ", emb");
1766 if (e_flags & EF_PPC_RELOCATABLE)
1767 strcat (buf, ", relocatable");
1769 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1770 strcat (buf, ", relocatable-lib");
1774 case EM_CYGNUS_V850:
1775 switch (e_flags & EF_V850_ARCH)
1778 strcat (buf, ", v850e");
1781 strcat (buf, ", v850ea");
1784 strcat (buf, ", v850");
1787 strcat (buf, ", unknown v850 architecture variant");
1793 case EM_CYGNUS_M32R:
1794 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1795 strcat (buf, ", m32r");
1800 case EM_MIPS_RS3_LE:
1801 if (e_flags & EF_MIPS_NOREORDER)
1802 strcat (buf, ", noreorder");
1804 if (e_flags & EF_MIPS_PIC)
1805 strcat (buf, ", pic");
1807 if (e_flags & EF_MIPS_CPIC)
1808 strcat (buf, ", cpic");
1810 if (e_flags & EF_MIPS_UCODE)
1811 strcat (buf, ", ugen_reserved");
1813 if (e_flags & EF_MIPS_ABI2)
1814 strcat (buf, ", abi2");
1816 if (e_flags & EF_MIPS_OPTIONS_FIRST)
1817 strcat (buf, ", odk first");
1819 if (e_flags & EF_MIPS_32BITMODE)
1820 strcat (buf, ", 32bitmode");
1822 switch ((e_flags & EF_MIPS_MACH))
1824 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1825 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1826 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1827 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1828 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1829 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1831 /* We simply ignore the field in this case to avoid confusion:
1832 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1835 default: strcat (buf, ", unknown CPU"); break;
1838 switch ((e_flags & EF_MIPS_ABI))
1840 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
1841 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
1842 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
1843 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
1845 /* We simply ignore the field in this case to avoid confusion:
1846 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1847 This means it is likely to be an o32 file, but not for
1850 default: strcat (buf, ", unknown ABI"); break;
1853 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
1854 strcat (buf, ", mdmx");
1856 if (e_flags & EF_MIPS_ARCH_ASE_M16)
1857 strcat (buf, ", mips16");
1859 switch ((e_flags & EF_MIPS_ARCH))
1861 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
1862 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
1863 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
1864 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
1865 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
1866 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
1867 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
1868 default: strcat (buf, ", unknown ISA"); break;
1874 if (e_flags & EF_SPARC_32PLUS)
1875 strcat (buf, ", v8+");
1877 if (e_flags & EF_SPARC_SUN_US1)
1878 strcat (buf, ", ultrasparcI");
1880 if (e_flags & EF_SPARC_SUN_US3)
1881 strcat (buf, ", ultrasparcIII");
1883 if (e_flags & EF_SPARC_HAL_R1)
1884 strcat (buf, ", halr1");
1886 if (e_flags & EF_SPARC_LEDATA)
1887 strcat (buf, ", ledata");
1889 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1890 strcat (buf, ", tso");
1892 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1893 strcat (buf, ", pso");
1895 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1896 strcat (buf, ", rmo");
1900 switch (e_flags & EF_PARISC_ARCH)
1902 case EFA_PARISC_1_0:
1903 strcpy (buf, ", PA-RISC 1.0");
1905 case EFA_PARISC_1_1:
1906 strcpy (buf, ", PA-RISC 1.1");
1908 case EFA_PARISC_2_0:
1909 strcpy (buf, ", PA-RISC 2.0");
1914 if (e_flags & EF_PARISC_TRAPNIL)
1915 strcat (buf, ", trapnil");
1916 if (e_flags & EF_PARISC_EXT)
1917 strcat (buf, ", ext");
1918 if (e_flags & EF_PARISC_LSB)
1919 strcat (buf, ", lsb");
1920 if (e_flags & EF_PARISC_WIDE)
1921 strcat (buf, ", wide");
1922 if (e_flags & EF_PARISC_NO_KABP)
1923 strcat (buf, ", no kabp");
1924 if (e_flags & EF_PARISC_LAZYSWAP)
1925 strcat (buf, ", lazyswap");
1930 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1931 strcat (buf, ", new calling convention");
1933 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1934 strcat (buf, ", gnu calling convention");
1938 if ((e_flags & EF_IA_64_ABI64))
1939 strcat (buf, ", 64-bit");
1941 strcat (buf, ", 32-bit");
1942 if ((e_flags & EF_IA_64_REDUCEDFP))
1943 strcat (buf, ", reduced fp model");
1944 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
1945 strcat (buf, ", no function descriptors, constant gp");
1946 else if ((e_flags & EF_IA_64_CONS_GP))
1947 strcat (buf, ", constant gp");
1948 if ((e_flags & EF_IA_64_ABSOLUTE))
1949 strcat (buf, ", absolute");
1953 if ((e_flags & EF_VAX_NONPIC))
1954 strcat (buf, ", non-PIC");
1955 if ((e_flags & EF_VAX_DFLOAT))
1956 strcat (buf, ", D-Float");
1957 if ((e_flags & EF_VAX_GFLOAT))
1958 strcat (buf, ", G-Float");
1967 get_mips_segment_type (type)
1972 case PT_MIPS_REGINFO:
1974 case PT_MIPS_RTPROC:
1976 case PT_MIPS_OPTIONS:
1986 get_parisc_segment_type (type)
1991 case PT_HP_TLS: return "HP_TLS";
1992 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1993 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1994 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1995 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1996 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1997 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1998 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1999 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2000 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2001 case PT_HP_PARALLEL: return "HP_PARALLEL";
2002 case PT_HP_FASTBIND: return "HP_FASTBIND";
2003 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2004 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2013 get_ia64_segment_type (type)
2018 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2019 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2020 case PT_HP_TLS: return "HP_TLS";
2021 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2022 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2023 case PT_IA_64_HP_STACK: return "HP_STACK";
2032 get_segment_type (p_type)
2033 unsigned long p_type;
2035 static char buff [32];
2039 case PT_NULL: return "NULL";
2040 case PT_LOAD: return "LOAD";
2041 case PT_DYNAMIC: return "DYNAMIC";
2042 case PT_INTERP: return "INTERP";
2043 case PT_NOTE: return "NOTE";
2044 case PT_SHLIB: return "SHLIB";
2045 case PT_PHDR: return "PHDR";
2046 case PT_TLS: return "TLS";
2048 case PT_GNU_EH_FRAME:
2049 return "GNU_EH_FRAME";
2052 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2054 const char * result;
2056 switch (elf_header.e_machine)
2059 case EM_MIPS_RS3_LE:
2060 result = get_mips_segment_type (p_type);
2063 result = get_parisc_segment_type (p_type);
2066 result = get_ia64_segment_type (p_type);
2076 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2078 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2080 const char * result;
2082 switch (elf_header.e_machine)
2085 result = get_parisc_segment_type (p_type);
2088 result = get_ia64_segment_type (p_type);
2098 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2101 sprintf (buff, _("<unknown>: %lx"), p_type);
2108 get_mips_section_type_name (sh_type)
2109 unsigned int sh_type;
2113 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2114 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2115 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2116 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2117 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2118 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2119 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2120 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2121 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2122 case SHT_MIPS_RELD: return "MIPS_RELD";
2123 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2124 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2125 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2126 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2127 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2128 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2129 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2130 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2131 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2132 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2133 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2134 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2135 case SHT_MIPS_LINE: return "MIPS_LINE";
2136 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2137 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2138 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2139 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2140 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2141 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2142 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2143 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2144 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2145 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2146 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2147 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2148 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2149 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2150 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2151 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2159 get_parisc_section_type_name (sh_type)
2160 unsigned int sh_type;
2164 case SHT_PARISC_EXT: return "PARISC_EXT";
2165 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2166 case SHT_PARISC_DOC: return "PARISC_DOC";
2174 get_ia64_section_type_name (sh_type)
2175 unsigned int sh_type;
2179 case SHT_IA_64_EXT: return "IA_64_EXT";
2180 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2188 get_section_type_name (sh_type)
2189 unsigned int sh_type;
2191 static char buff [32];
2195 case SHT_NULL: return "NULL";
2196 case SHT_PROGBITS: return "PROGBITS";
2197 case SHT_SYMTAB: return "SYMTAB";
2198 case SHT_STRTAB: return "STRTAB";
2199 case SHT_RELA: return "RELA";
2200 case SHT_HASH: return "HASH";
2201 case SHT_DYNAMIC: return "DYNAMIC";
2202 case SHT_NOTE: return "NOTE";
2203 case SHT_NOBITS: return "NOBITS";
2204 case SHT_REL: return "REL";
2205 case SHT_SHLIB: return "SHLIB";
2206 case SHT_DYNSYM: return "DYNSYM";
2207 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2208 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2209 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2210 case SHT_GROUP: return "GROUP";
2211 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2212 case SHT_GNU_verdef: return "VERDEF";
2213 case SHT_GNU_verneed: return "VERNEED";
2214 case SHT_GNU_versym: return "VERSYM";
2215 case 0x6ffffff0: return "VERSYM";
2216 case 0x6ffffffc: return "VERDEF";
2217 case 0x7ffffffd: return "AUXILIARY";
2218 case 0x7fffffff: return "FILTER";
2219 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2222 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2224 const char * result;
2226 switch (elf_header.e_machine)
2229 case EM_MIPS_RS3_LE:
2230 result = get_mips_section_type_name (sh_type);
2233 result = get_parisc_section_type_name (sh_type);
2236 result = get_ia64_section_type_name (sh_type);
2246 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2248 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2249 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2250 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2251 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2253 sprintf (buff, _("<unknown>: %x"), sh_type);
2259 #define OPTION_DEBUG_DUMP 512
2261 struct option options [] =
2263 {"all", no_argument, 0, 'a'},
2264 {"file-header", no_argument, 0, 'h'},
2265 {"program-headers", no_argument, 0, 'l'},
2266 {"headers", no_argument, 0, 'e'},
2267 {"histogram", no_argument, 0, 'I'},
2268 {"segments", no_argument, 0, 'l'},
2269 {"sections", no_argument, 0, 'S'},
2270 {"section-headers", no_argument, 0, 'S'},
2271 {"symbols", no_argument, 0, 's'},
2272 {"syms", no_argument, 0, 's'},
2273 {"relocs", no_argument, 0, 'r'},
2274 {"notes", no_argument, 0, 'n'},
2275 {"dynamic", no_argument, 0, 'd'},
2276 {"arch-specific", no_argument, 0, 'A'},
2277 {"version-info", no_argument, 0, 'V'},
2278 {"use-dynamic", no_argument, 0, 'D'},
2279 {"hex-dump", required_argument, 0, 'x'},
2280 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2281 {"unwind", no_argument, 0, 'u'},
2282 #ifdef SUPPORT_DISASSEMBLY
2283 {"instruction-dump", required_argument, 0, 'i'},
2286 {"version", no_argument, 0, 'v'},
2287 {"wide", no_argument, 0, 'W'},
2288 {"help", no_argument, 0, 'H'},
2289 {0, no_argument, 0, 0}
2295 fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2296 fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2297 fprintf (stdout, _(" Options are:\n\
2298 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2299 -h --file-header Display the ELF file header\n\
2300 -l --program-headers Display the program headers\n\
2301 --segments An alias for --program-headers\n\
2302 -S --section-headers Display the sections' header\n\
2303 --sections An alias for --section-headers\n\
2304 -e --headers Equivalent to: -h -l -S\n\
2305 -s --syms Display the symbol table\n\
2306 --symbols An alias for --syms\n\
2307 -n --notes Display the core notes (if present)\n\
2308 -r --relocs Display the relocations (if present)\n\
2309 -u --unwind Display the unwind info (if present)\n\
2310 -d --dynamic Display the dynamic segment (if present)\n\
2311 -V --version-info Display the version sections (if present)\n\
2312 -A --arch-specific Display architecture specific information (if any).\n\
2313 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2314 -x --hex-dump=<number> Dump the contents of section <number>\n\
2315 -w[liaprmfFso] or\n\
2316 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2317 Display the contents of DWARF2 debug sections\n"));
2318 #ifdef SUPPORT_DISASSEMBLY
2319 fprintf (stdout, _("\
2320 -i --instruction-dump=<number>\n\
2321 Disassemble the contents of section <number>\n"));
2323 fprintf (stdout, _("\
2324 -I --histogram Display histogram of bucket list lengths\n\
2325 -W --wide Allow output width to exceed 80 characters\n\
2326 -H --help Display this information\n\
2327 -v --version Display the version number of readelf\n"));
2328 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2334 request_dump (section, type)
2335 unsigned int section;
2338 if (section >= num_dump_sects)
2340 char * new_dump_sects;
2342 new_dump_sects = (char *) calloc (section + 1, 1);
2344 if (new_dump_sects == NULL)
2345 error (_("Out of memory allocating dump request table."));
2348 /* Copy current flag settings. */
2349 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2353 dump_sects = new_dump_sects;
2354 num_dump_sects = section + 1;
2359 dump_sects [section] |= type;
2365 parse_args (argc, argv)
2374 while ((c = getopt_long
2375 (argc, argv, "ersuahnldSDAIw::x:i:vVW", options, NULL)) != EOF)
2411 do_using_dynamic ++;
2442 section = strtoul (optarg, & cp, 0);
2443 if (! * cp && section >= 0)
2445 request_dump (section, HEX_DUMP);
2455 unsigned int index = 0;
2459 while (optarg[index])
2460 switch (optarg[index++])
2469 do_debug_abbrevs = 1;
2479 do_debug_pubnames = 1;
2484 do_debug_aranges = 1;
2488 do_debug_frames_interp = 1;
2490 do_debug_frames = 1;
2495 do_debug_macinfo = 1;
2509 warn (_("Unrecognized debug option '%s'\n"), optarg);
2514 case OPTION_DEBUG_DUMP:
2520 static const char *debug_dump_opt[]
2521 = { "line", "info", "abbrev", "pubnames", "ranges",
2522 "macro", "frames", "frames-interp", "str", "loc", NULL };
2531 for (index = 0; debug_dump_opt[index]; index++)
2533 size_t len = strlen (debug_dump_opt[index]);
2535 if (strncmp (p, debug_dump_opt[index], len) == 0
2536 && (p[len] == ',' || p[len] == '\0'))
2545 do_debug_abbrevs = 1;
2556 do_debug_pubnames = 1;
2560 do_debug_aranges = 1;
2565 do_debug_frames_interp = 1;
2566 do_debug_frames = 1;
2570 do_debug_macinfo = 1;
2583 if (debug_dump_opt[index] == NULL)
2585 warn (_("Unrecognized debug option '%s'\n"), p);
2586 p = strchr (p, ',');
2596 #ifdef SUPPORT_DISASSEMBLY
2599 section = strtoul (optarg, & cp, 0);
2600 if (! * cp && section >= 0)
2602 request_dump (section, DISASS_DUMP);
2608 print_version (program_name);
2618 /* xgettext:c-format */
2619 error (_("Invalid option '-%c'\n"), c);
2626 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2627 && !do_segments && !do_header && !do_dump && !do_version
2628 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2632 warn (_("Nothing to do.\n"));
2638 get_elf_class (elf_class)
2639 unsigned int elf_class;
2641 static char buff [32];
2645 case ELFCLASSNONE: return _("none");
2646 case ELFCLASS32: return "ELF32";
2647 case ELFCLASS64: return "ELF64";
2649 sprintf (buff, _("<unknown: %x>"), elf_class);
2655 get_data_encoding (encoding)
2656 unsigned int encoding;
2658 static char buff [32];
2662 case ELFDATANONE: return _("none");
2663 case ELFDATA2LSB: return _("2's complement, little endian");
2664 case ELFDATA2MSB: return _("2's complement, big endian");
2666 sprintf (buff, _("<unknown: %x>"), encoding);
2672 get_osabi_name (osabi)
2675 static char buff [32];
2679 case ELFOSABI_NONE: return "UNIX - System V";
2680 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2681 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2682 case ELFOSABI_LINUX: return "UNIX - Linux";
2683 case ELFOSABI_HURD: return "GNU/Hurd";
2684 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2685 case ELFOSABI_AIX: return "UNIX - AIX";
2686 case ELFOSABI_IRIX: return "UNIX - IRIX";
2687 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2688 case ELFOSABI_TRU64: return "UNIX - TRU64";
2689 case ELFOSABI_MODESTO: return "Novell - Modesto";
2690 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2691 case ELFOSABI_STANDALONE: return _("Standalone App");
2692 case ELFOSABI_ARM: return "ARM";
2694 sprintf (buff, _("<unknown: %x>"), osabi);
2699 /* Decode the data held in 'elf_header'. */
2701 process_file_header ()
2703 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2704 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2705 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2706 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2709 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2717 printf (_("ELF Header:\n"));
2718 printf (_(" Magic: "));
2719 for (i = 0; i < EI_NIDENT; i ++)
2720 printf ("%2.2x ", elf_header.e_ident [i]);
2722 printf (_(" Class: %s\n"),
2723 get_elf_class (elf_header.e_ident [EI_CLASS]));
2724 printf (_(" Data: %s\n"),
2725 get_data_encoding (elf_header.e_ident [EI_DATA]));
2726 printf (_(" Version: %d %s\n"),
2727 elf_header.e_ident [EI_VERSION],
2728 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2730 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2733 printf (_(" OS/ABI: %s\n"),
2734 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2735 printf (_(" ABI Version: %d\n"),
2736 elf_header.e_ident [EI_ABIVERSION]);
2737 printf (_(" Type: %s\n"),
2738 get_file_type (elf_header.e_type));
2739 printf (_(" Machine: %s\n"),
2740 get_machine_name (elf_header.e_machine));
2741 printf (_(" Version: 0x%lx\n"),
2742 (unsigned long) elf_header.e_version);
2744 printf (_(" Entry point address: "));
2745 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2746 printf (_("\n Start of program headers: "));
2747 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2748 printf (_(" (bytes into file)\n Start of section headers: "));
2749 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2750 printf (_(" (bytes into file)\n"));
2752 printf (_(" Flags: 0x%lx%s\n"),
2753 (unsigned long) elf_header.e_flags,
2754 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2755 printf (_(" Size of this header: %ld (bytes)\n"),
2756 (long) elf_header.e_ehsize);
2757 printf (_(" Size of program headers: %ld (bytes)\n"),
2758 (long) elf_header.e_phentsize);
2759 printf (_(" Number of program headers: %ld\n"),
2760 (long) elf_header.e_phnum);
2761 printf (_(" Size of section headers: %ld (bytes)\n"),
2762 (long) elf_header.e_shentsize);
2763 printf (_(" Number of section headers: %ld"),
2764 (long) elf_header.e_shnum);
2765 if (section_headers != NULL && elf_header.e_shnum == 0)
2766 printf (" (%ld)", (long) section_headers[0].sh_size);
2767 putc ('\n', stdout);
2768 printf (_(" Section header string table index: %ld"),
2769 (long) elf_header.e_shstrndx);
2770 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
2771 printf (" (%ld)", (long) section_headers[0].sh_link);
2772 putc ('\n', stdout);
2775 if (section_headers != NULL)
2777 if (elf_header.e_shnum == 0)
2778 elf_header.e_shnum = section_headers[0].sh_size;
2779 if (elf_header.e_shstrndx == SHN_XINDEX)
2780 elf_header.e_shstrndx = section_headers[0].sh_link;
2781 free (section_headers);
2782 section_headers = NULL;
2790 get_32bit_program_headers (file, program_headers)
2792 Elf_Internal_Phdr * program_headers;
2794 Elf32_External_Phdr * phdrs;
2795 Elf32_External_Phdr * external;
2796 Elf32_Internal_Phdr * internal;
2799 phdrs = ((Elf32_External_Phdr *)
2800 get_data (NULL, file, elf_header.e_phoff,
2801 elf_header.e_phentsize * elf_header.e_phnum,
2802 _("program headers")));
2806 for (i = 0, internal = program_headers, external = phdrs;
2807 i < elf_header.e_phnum;
2808 i ++, internal ++, external ++)
2810 internal->p_type = BYTE_GET (external->p_type);
2811 internal->p_offset = BYTE_GET (external->p_offset);
2812 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2813 internal->p_paddr = BYTE_GET (external->p_paddr);
2814 internal->p_filesz = BYTE_GET (external->p_filesz);
2815 internal->p_memsz = BYTE_GET (external->p_memsz);
2816 internal->p_flags = BYTE_GET (external->p_flags);
2817 internal->p_align = BYTE_GET (external->p_align);
2826 get_64bit_program_headers (file, program_headers)
2828 Elf_Internal_Phdr * program_headers;
2830 Elf64_External_Phdr * phdrs;
2831 Elf64_External_Phdr * external;
2832 Elf64_Internal_Phdr * internal;
2835 phdrs = ((Elf64_External_Phdr *)
2836 get_data (NULL, file, elf_header.e_phoff,
2837 elf_header.e_phentsize * elf_header.e_phnum,
2838 _("program headers")));
2842 for (i = 0, internal = program_headers, external = phdrs;
2843 i < elf_header.e_phnum;
2844 i ++, internal ++, external ++)
2846 internal->p_type = BYTE_GET (external->p_type);
2847 internal->p_flags = BYTE_GET (external->p_flags);
2848 internal->p_offset = BYTE_GET8 (external->p_offset);
2849 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2850 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2851 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2852 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2853 internal->p_align = BYTE_GET8 (external->p_align);
2862 process_program_headers (file)
2865 Elf_Internal_Phdr * program_headers;
2866 Elf_Internal_Phdr * segment;
2869 if (elf_header.e_phnum == 0)
2872 printf (_("\nThere are no program headers in this file.\n"));
2876 if (do_segments && !do_header)
2878 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2879 printf (_("Entry point "));
2880 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2881 printf (_("\nThere are %d program headers, starting at offset "),
2882 elf_header.e_phnum);
2883 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2887 program_headers = (Elf_Internal_Phdr *) malloc
2888 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2890 if (program_headers == NULL)
2892 error (_("Out of memory\n"));
2897 i = get_32bit_program_headers (file, program_headers);
2899 i = get_64bit_program_headers (file, program_headers);
2903 free (program_headers);
2909 if (elf_header.e_phnum > 1)
2910 printf (_("\nProgram Headers:\n"));
2912 printf (_("\nProgram Headers:\n"));
2916 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2919 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2923 (_(" Type Offset VirtAddr PhysAddr\n"));
2925 (_(" FileSiz MemSiz Flags Align\n"));
2933 for (i = 0, segment = program_headers;
2934 i < elf_header.e_phnum;
2939 printf (" %-14.14s ", get_segment_type (segment->p_type));
2943 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2944 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2945 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2946 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2947 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2949 (segment->p_flags & PF_R ? 'R' : ' '),
2950 (segment->p_flags & PF_W ? 'W' : ' '),
2951 (segment->p_flags & PF_X ? 'E' : ' '));
2952 printf ("%#lx", (unsigned long) segment->p_align);
2956 if ((unsigned long) segment->p_offset == segment->p_offset)
2957 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2960 print_vma (segment->p_offset, FULL_HEX);
2964 print_vma (segment->p_vaddr, FULL_HEX);
2966 print_vma (segment->p_paddr, FULL_HEX);
2969 if ((unsigned long) segment->p_filesz == segment->p_filesz)
2970 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
2973 print_vma (segment->p_filesz, FULL_HEX);
2977 if ((unsigned long) segment->p_memsz == segment->p_memsz)
2978 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
2981 print_vma (segment->p_offset, FULL_HEX);
2985 (segment->p_flags & PF_R ? 'R' : ' '),
2986 (segment->p_flags & PF_W ? 'W' : ' '),
2987 (segment->p_flags & PF_X ? 'E' : ' '));
2989 if ((unsigned long) segment->p_align == segment->p_align)
2990 printf ("%#lx", (unsigned long) segment->p_align);
2993 print_vma (segment->p_align, PREFIX_HEX);
2998 print_vma (segment->p_offset, FULL_HEX);
3000 print_vma (segment->p_vaddr, FULL_HEX);
3002 print_vma (segment->p_paddr, FULL_HEX);
3004 print_vma (segment->p_filesz, FULL_HEX);
3006 print_vma (segment->p_memsz, FULL_HEX);
3008 (segment->p_flags & PF_R ? 'R' : ' '),
3009 (segment->p_flags & PF_W ? 'W' : ' '),
3010 (segment->p_flags & PF_X ? 'E' : ' '));
3011 print_vma (segment->p_align, HEX);
3015 switch (segment->p_type)
3019 loadaddr = (segment->p_vaddr & 0xfffff000)
3020 - (segment->p_offset & 0xfffff000);
3025 error (_("more than one dynamic segment\n"));
3027 dynamic_addr = segment->p_offset;
3028 dynamic_size = segment->p_filesz;
3032 if (fseek (file, (long) segment->p_offset, SEEK_SET))
3033 error (_("Unable to find program interpreter name\n"));
3036 program_interpreter[0] = 0;
3037 fscanf (file, "%63s", program_interpreter);
3040 printf (_("\n [Requesting program interpreter: %s]"),
3041 program_interpreter);
3047 putc ('\n', stdout);
3056 if (do_segments && section_headers != NULL)
3058 printf (_("\n Section to Segment mapping:\n"));
3059 printf (_(" Segment Sections...\n"));
3061 assert (string_table != NULL);
3063 for (i = 0; i < elf_header.e_phnum; i++)
3066 Elf_Internal_Shdr * section;
3068 segment = program_headers + i;
3069 section = section_headers;
3071 printf (" %2.2d ", i);
3073 for (j = 1; j < elf_header.e_shnum; j++, section ++)
3075 if (section->sh_size > 0
3076 /* Compare allocated sections by VMA, unallocated
3077 sections by file offset. */
3078 && (section->sh_flags & SHF_ALLOC
3079 ? (section->sh_addr >= segment->p_vaddr
3080 && section->sh_addr + section->sh_size
3081 <= segment->p_vaddr + segment->p_memsz)
3082 : ((bfd_vma) section->sh_offset >= segment->p_offset
3083 && (section->sh_offset + section->sh_size
3084 <= segment->p_offset + segment->p_filesz))))
3085 printf ("%s ", SECTION_NAME (section));
3092 free (program_headers);
3099 get_32bit_section_headers (file, num)
3103 Elf32_External_Shdr * shdrs;
3104 Elf32_Internal_Shdr * internal;
3107 shdrs = ((Elf32_External_Shdr *)
3108 get_data (NULL, file, elf_header.e_shoff,
3109 elf_header.e_shentsize * num,
3110 _("section headers")));
3114 section_headers = ((Elf_Internal_Shdr *)
3115 malloc (num * sizeof (Elf_Internal_Shdr)));
3117 if (section_headers == NULL)
3119 error (_("Out of memory\n"));
3123 for (i = 0, internal = section_headers;
3127 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3128 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3129 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3130 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3131 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3132 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3133 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3134 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3135 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3136 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3145 get_64bit_section_headers (file, num)
3149 Elf64_External_Shdr * shdrs;
3150 Elf64_Internal_Shdr * internal;
3153 shdrs = ((Elf64_External_Shdr *)
3154 get_data (NULL, file, elf_header.e_shoff,
3155 elf_header.e_shentsize * num,
3156 _("section headers")));
3160 section_headers = ((Elf_Internal_Shdr *)
3161 malloc (num * sizeof (Elf_Internal_Shdr)));
3163 if (section_headers == NULL)
3165 error (_("Out of memory\n"));
3169 for (i = 0, internal = section_headers;
3173 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3174 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3175 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
3176 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
3177 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
3178 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
3179 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3180 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3181 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3182 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3190 static Elf_Internal_Sym *
3191 get_32bit_elf_symbols (file, section)
3193 Elf_Internal_Shdr *section;
3195 unsigned long number;
3196 Elf32_External_Sym * esyms;
3197 Elf_External_Sym_Shndx *shndx;
3198 Elf_Internal_Sym * isyms;
3199 Elf_Internal_Sym * psym;
3202 esyms = ((Elf32_External_Sym *)
3203 get_data (NULL, file, section->sh_offset,
3204 section->sh_size, _("symbols")));
3209 if (symtab_shndx_hdr != NULL
3210 && (symtab_shndx_hdr->sh_link
3211 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3213 shndx = ((Elf_External_Sym_Shndx *)
3214 get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3215 symtab_shndx_hdr->sh_size, _("symtab shndx")));
3223 number = section->sh_size / section->sh_entsize;
3224 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3228 error (_("Out of memory\n"));
3235 for (j = 0, psym = isyms;
3239 psym->st_name = BYTE_GET (esyms[j].st_name);
3240 psym->st_value = BYTE_GET (esyms[j].st_value);
3241 psym->st_size = BYTE_GET (esyms[j].st_size);
3242 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3243 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3245 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3246 psym->st_info = BYTE_GET (esyms[j].st_info);
3247 psym->st_other = BYTE_GET (esyms[j].st_other);
3257 static Elf_Internal_Sym *
3258 get_64bit_elf_symbols (file, section)
3260 Elf_Internal_Shdr *section;
3262 unsigned long number;
3263 Elf64_External_Sym * esyms;
3264 Elf_External_Sym_Shndx *shndx;
3265 Elf_Internal_Sym * isyms;
3266 Elf_Internal_Sym * psym;
3269 esyms = ((Elf64_External_Sym *)
3270 get_data (NULL, file, section->sh_offset,
3271 section->sh_size, _("symbols")));
3276 if (symtab_shndx_hdr != NULL
3277 && (symtab_shndx_hdr->sh_link
3278 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3280 shndx = ((Elf_External_Sym_Shndx *)
3281 get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3282 symtab_shndx_hdr->sh_size, _("symtab shndx")));
3290 number = section->sh_size / section->sh_entsize;
3291 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3295 error (_("Out of memory\n"));
3302 for (j = 0, psym = isyms;
3306 psym->st_name = BYTE_GET (esyms[j].st_name);
3307 psym->st_info = BYTE_GET (esyms[j].st_info);
3308 psym->st_other = BYTE_GET (esyms[j].st_other);
3309 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3310 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3312 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3313 psym->st_value = BYTE_GET8 (esyms[j].st_value);
3314 psym->st_size = BYTE_GET8 (esyms[j].st_size);
3325 get_elf_section_flags (sh_flags)
3328 static char buff [32];
3336 flag = sh_flags & - sh_flags;
3341 case SHF_WRITE: strcat (buff, "W"); break;
3342 case SHF_ALLOC: strcat (buff, "A"); break;
3343 case SHF_EXECINSTR: strcat (buff, "X"); break;
3344 case SHF_MERGE: strcat (buff, "M"); break;
3345 case SHF_STRINGS: strcat (buff, "S"); break;
3346 case SHF_INFO_LINK: strcat (buff, "I"); break;
3347 case SHF_LINK_ORDER: strcat (buff, "L"); break;
3348 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
3349 case SHF_GROUP: strcat (buff, "G"); break;
3350 case SHF_TLS: strcat (buff, "T"); break;
3353 if (flag & SHF_MASKOS)
3356 sh_flags &= ~ SHF_MASKOS;
3358 else if (flag & SHF_MASKPROC)
3361 sh_flags &= ~ SHF_MASKPROC;
3373 process_section_headers (file)
3376 Elf_Internal_Shdr * section;
3379 section_headers = NULL;
3381 if (elf_header.e_shnum == 0)
3384 printf (_("\nThere are no sections in this file.\n"));
3389 if (do_sections && !do_header)
3390 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3391 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3395 if (! get_32bit_section_headers (file, elf_header.e_shnum))
3398 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3401 /* Read in the string table, so that we have names to display. */
3402 section = SECTION_HEADER (elf_header.e_shstrndx);
3404 if (section->sh_size != 0)
3406 string_table = (char *) get_data (NULL, file, section->sh_offset,
3407 section->sh_size, _("string table"));
3409 string_table_length = section->sh_size;
3412 /* Scan the sections for the dynamic symbol table
3413 and dynamic string table and debug sections. */
3414 dynamic_symbols = NULL;
3415 dynamic_strings = NULL;
3416 dynamic_syminfo = NULL;
3418 for (i = 0, section = section_headers;
3419 i < elf_header.e_shnum;
3422 char * name = SECTION_NAME (section);
3424 if (section->sh_type == SHT_DYNSYM)
3426 if (dynamic_symbols != NULL)
3428 error (_("File contains multiple dynamic symbol tables\n"));
3432 num_dynamic_syms = section->sh_size / section->sh_entsize;
3433 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3435 else if (section->sh_type == SHT_STRTAB
3436 && strcmp (name, ".dynstr") == 0)
3438 if (dynamic_strings != NULL)
3440 error (_("File contains multiple dynamic string tables\n"));
3444 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
3446 _("dynamic strings"));
3448 else if (section->sh_type == SHT_SYMTAB_SHNDX)
3450 if (symtab_shndx_hdr != NULL)
3452 error (_("File contains multiple symtab shndx tables\n"));
3455 symtab_shndx_hdr = section;
3457 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3458 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3459 || do_debug_frames || do_debug_macinfo || do_debug_str
3461 && strncmp (name, ".debug_", 7) == 0)
3466 || (do_debug_info && (strcmp (name, "info") == 0))
3467 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3468 || (do_debug_lines && (strcmp (name, "line") == 0))
3469 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3470 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3471 || (do_debug_frames && (strcmp (name, "frame") == 0))
3472 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3473 || (do_debug_str && (strcmp (name, "str") == 0))
3474 || (do_debug_loc && (strcmp (name, "loc") == 0))
3476 request_dump (i, DEBUG_DUMP);
3478 /* linkonce section to be combined with .debug_info at link time. */
3479 else if ((do_debugging || do_debug_info)
3480 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3481 request_dump (i, DEBUG_DUMP);
3482 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3483 request_dump (i, DEBUG_DUMP);
3489 if (elf_header.e_shnum > 1)
3490 printf (_("\nSection Headers:\n"));
3492 printf (_("\nSection Header:\n"));
3496 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3499 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3502 printf (_(" [Nr] Name Type Address Offset\n"));
3503 printf (_(" Size EntSize Flags Link Info Align\n"));
3506 for (i = 0, section = section_headers;
3507 i < elf_header.e_shnum;
3510 printf (" [%2u] %-17.17s %-15.15s ",
3511 SECTION_HEADER_NUM (i),
3512 SECTION_NAME (section),
3513 get_section_type_name (section->sh_type));
3517 print_vma (section->sh_addr, LONG_HEX);
3519 printf ( " %6.6lx %6.6lx %2.2lx",
3520 (unsigned long) section->sh_offset,
3521 (unsigned long) section->sh_size,
3522 (unsigned long) section->sh_entsize);
3524 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3526 printf ("%2ld %3lx %2ld\n",
3527 (unsigned long) section->sh_link,
3528 (unsigned long) section->sh_info,
3529 (unsigned long) section->sh_addralign);
3533 print_vma (section->sh_addr, LONG_HEX);
3535 if ((long) section->sh_offset == section->sh_offset)
3536 printf (" %6.6lx", (unsigned long) section->sh_offset);
3540 print_vma (section->sh_offset, LONG_HEX);
3543 if ((unsigned long) section->sh_size == section->sh_size)
3544 printf (" %6.6lx", (unsigned long) section->sh_size);
3548 print_vma (section->sh_size, LONG_HEX);
3551 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3552 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3556 print_vma (section->sh_entsize, LONG_HEX);
3559 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3561 printf ("%2ld %3lx ",
3562 (unsigned long) section->sh_link,
3563 (unsigned long) section->sh_info);
3565 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3566 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3569 print_vma (section->sh_addralign, DEC);
3576 print_vma (section->sh_addr, LONG_HEX);
3577 if ((long) section->sh_offset == section->sh_offset)
3578 printf (" %8.8lx", (unsigned long) section->sh_offset);
3582 print_vma (section->sh_offset, LONG_HEX);
3585 print_vma (section->sh_size, LONG_HEX);
3587 print_vma (section->sh_entsize, LONG_HEX);
3589 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3591 printf (" %2ld %3lx %ld\n",
3592 (unsigned long) section->sh_link,
3593 (unsigned long) section->sh_info,
3594 (unsigned long) section->sh_addralign);
3598 printf (_("Key to Flags:\n\
3599 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3600 I (info), L (link order), G (group), x (unknown)\n\
3601 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3606 /* Process the reloc section. */
3608 process_relocs (file)
3611 unsigned long rel_size;
3612 unsigned long rel_offset;
3618 if (do_using_dynamic)
3620 int is_rela = FALSE;
3625 if (dynamic_info[DT_REL])
3627 rel_offset = dynamic_info[DT_REL];
3628 rel_size = dynamic_info[DT_RELSZ];
3631 else if (dynamic_info [DT_RELA])
3633 rel_offset = dynamic_info[DT_RELA];
3634 rel_size = dynamic_info[DT_RELASZ];
3637 else if (dynamic_info[DT_JMPREL])
3639 rel_offset = dynamic_info[DT_JMPREL];
3640 rel_size = dynamic_info[DT_PLTRELSZ];
3642 switch (dynamic_info[DT_PLTREL])
3659 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3660 rel_offset, rel_size);
3662 dump_relocations (file, rel_offset - loadaddr, rel_size,
3663 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3666 printf (_("\nThere are no dynamic relocations in this file.\n"));
3670 Elf32_Internal_Shdr * section;
3674 for (i = 0, section = section_headers;
3675 i < elf_header.e_shnum;
3678 if ( section->sh_type != SHT_RELA
3679 && section->sh_type != SHT_REL)
3682 rel_offset = section->sh_offset;
3683 rel_size = section->sh_size;
3687 Elf32_Internal_Shdr * strsec;
3688 Elf_Internal_Sym * symtab;
3691 unsigned long nsyms;
3693 printf (_("\nRelocation section "));
3695 if (string_table == NULL)
3696 printf ("%d", section->sh_name);
3698 printf (_("'%s'"), SECTION_NAME (section));
3700 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3701 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3706 if (section->sh_link)
3708 Elf32_Internal_Shdr * symsec;
3710 symsec = SECTION_HEADER (section->sh_link);
3711 nsyms = symsec->sh_size / symsec->sh_entsize;
3712 symtab = GET_ELF_SYMBOLS (file, symsec);
3717 strsec = SECTION_HEADER (symsec->sh_link);
3719 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3723 is_rela = section->sh_type == SHT_RELA;
3725 dump_relocations (file, rel_offset, rel_size,
3726 symtab, nsyms, strtab, is_rela);
3738 printf (_("\nThere are no relocations in this file.\n"));
3744 #include "unwind-ia64.h"
3746 /* An absolute address consists of a section and an offset. If the
3747 section is NULL, the offset itself is the address, otherwise, the
3748 address equals to LOAD_ADDRESS(section) + offset. */
3752 unsigned short section;
3758 struct unw_table_entry
3760 struct absaddr start;
3762 struct absaddr info;
3764 *table; /* Unwind table. */
3765 unsigned long table_len; /* Length of unwind table. */
3766 unsigned char * info; /* Unwind info. */
3767 unsigned long info_size; /* Size of unwind info. */
3768 bfd_vma info_addr; /* starting address of unwind info. */
3769 bfd_vma seg_base; /* Starting address of segment. */
3770 Elf_Internal_Sym * symtab; /* The symbol table. */
3771 unsigned long nsyms; /* Number of symbols. */
3772 char * strtab; /* The string table. */
3773 unsigned long strtab_size; /* Size of string table. */
3776 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3777 struct absaddr, const char **,
3779 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3780 static int slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3781 Elf32_Internal_Shdr *));
3784 find_symbol_for_address (aux, addr, symname, offset)
3785 struct unw_aux_info *aux;
3786 struct absaddr addr;
3787 const char **symname;
3790 bfd_vma dist = (bfd_vma) 0x100000;
3791 Elf_Internal_Sym *sym, *best = NULL;
3794 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3796 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3797 && sym->st_name != 0
3798 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3799 && addr.offset >= sym->st_value
3800 && addr.offset - sym->st_value < dist)
3803 dist = addr.offset - sym->st_value;
3810 *symname = (best->st_name >= aux->strtab_size
3811 ? "<corrupt>" : aux->strtab + best->st_name);
3816 *offset = addr.offset;
3820 dump_ia64_unwind (aux)
3821 struct unw_aux_info *aux;
3824 struct unw_table_entry * tp;
3827 addr_size = is_32bit_elf ? 4 : 8;
3829 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3833 const unsigned char * dp;
3834 const unsigned char * head;
3835 const char * procname;
3837 find_symbol_for_address (aux, tp->start, &procname, &offset);
3839 fputs ("\n<", stdout);
3843 fputs (procname, stdout);
3846 printf ("+%lx", (unsigned long) offset);
3849 fputs (">: [", stdout);
3850 print_vma (tp->start.offset, PREFIX_HEX);
3851 fputc ('-', stdout);
3852 print_vma (tp->end.offset, PREFIX_HEX);
3853 printf ("], info at +0x%lx\n",
3854 (unsigned long) (tp->info.offset - aux->seg_base));
3856 head = aux->info + (tp->info.offset - aux->info_addr);
3857 stamp = BYTE_GET8 ((unsigned char *) head);
3859 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
3860 (unsigned) UNW_VER (stamp),
3861 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3862 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3863 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3864 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3866 if (UNW_VER (stamp) != 1)
3868 printf ("\tUnknown version.\n");
3873 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3874 dp = unw_decode (dp, in_body, & in_body);
3879 slurp_ia64_unwind_table (file, aux, sec)
3881 struct unw_aux_info *aux;
3882 Elf32_Internal_Shdr *sec;
3884 unsigned long size, addr_size, nrelas, i;
3885 Elf_Internal_Phdr *prog_hdrs, *seg;
3886 struct unw_table_entry *tep;
3887 Elf32_Internal_Shdr *relsec;
3888 Elf_Internal_Rela *rela, *rp;
3889 unsigned char *table, *tp;
3890 Elf_Internal_Sym *sym;
3891 const char *relname;
3894 addr_size = is_32bit_elf ? 4 : 8;
3896 /* First, find the starting address of the segment that includes
3899 if (elf_header.e_phnum)
3901 prog_hdrs = (Elf_Internal_Phdr *)
3902 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3905 result = get_32bit_program_headers (file, prog_hdrs);
3907 result = get_64bit_program_headers (file, prog_hdrs);
3915 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3917 if (seg->p_type != PT_LOAD)
3920 if (sec->sh_addr >= seg->p_vaddr
3921 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3923 aux->seg_base = seg->p_vaddr;
3931 /* Second, build the unwind table from the contents of the unwind section: */
3932 size = sec->sh_size;
3933 table = (char *) get_data (NULL, file, sec->sh_offset,
3934 size, _("unwind table"));
3938 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3939 for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3941 tep->start.section = SHN_UNDEF;
3942 tep->end.section = SHN_UNDEF;
3943 tep->info.section = SHN_UNDEF;
3946 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3947 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
3948 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
3952 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
3953 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
3954 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
3956 tep->start.offset += aux->seg_base;
3957 tep->end.offset += aux->seg_base;
3958 tep->info.offset += aux->seg_base;
3962 /* Third, apply any relocations to the unwind table: */
3964 for (relsec = section_headers;
3965 relsec < section_headers + elf_header.e_shnum;
3968 if (relsec->sh_type != SHT_RELA
3969 || SECTION_HEADER (relsec->sh_info) != sec)
3972 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3976 for (rp = rela; rp < rela + nrelas; ++rp)
3980 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3981 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3983 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3985 warn (_("Skipping unexpected symbol type %u\n"),
3986 ELF32_ST_TYPE (sym->st_info));
3992 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3993 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3995 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3997 warn (_("Skipping unexpected symbol type %u\n"),
3998 ELF64_ST_TYPE (sym->st_info));
4003 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
4005 warn (_("Skipping unexpected relocation type %s\n"), relname);
4009 i = rp->r_offset / (3 * addr_size);
4011 switch (rp->r_offset/addr_size % 3)
4014 aux->table[i].start.section = sym->st_shndx;
4015 aux->table[i].start.offset += rp->r_addend;
4018 aux->table[i].end.section = sym->st_shndx;
4019 aux->table[i].end.offset += rp->r_addend;
4022 aux->table[i].info.section = sym->st_shndx;
4023 aux->table[i].info.offset += rp->r_addend;
4033 aux->table_len = size / (3 * addr_size);
4038 process_unwind (file)
4041 Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4042 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
4043 struct unw_aux_info aux;
4048 if (elf_header.e_machine != EM_IA_64)
4050 printf (_("\nThere are no unwind sections in this file.\n"));
4054 memset (& aux, 0, sizeof (aux));
4056 addr_size = is_32bit_elf ? 4 : 8;
4058 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4060 if (sec->sh_type == SHT_SYMTAB)
4062 aux.nsyms = sec->sh_size / sec->sh_entsize;
4063 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4065 strsec = SECTION_HEADER (sec->sh_link);
4066 aux.strtab_size = strsec->sh_size;
4067 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
4068 aux.strtab_size, _("string table"));
4070 else if (sec->sh_type == SHT_IA_64_UNWIND)
4075 printf (_("\nThere are no unwind sections in this file.\n"));
4077 while (unwcount-- > 0)
4082 for (i = unwstart, sec = section_headers + unwstart;
4083 i < elf_header.e_shnum; ++i, ++sec)
4084 if (sec->sh_type == SHT_IA_64_UNWIND)
4091 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4093 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
4096 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4097 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4098 suffix = SECTION_NAME (unwsec) + len;
4099 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4101 if (strncmp (SECTION_NAME (sec),
4102 ELF_STRING_ia64_unwind_info_once, len2) == 0
4103 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4108 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4109 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4110 len = sizeof (ELF_STRING_ia64_unwind) - 1;
4111 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
4113 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
4115 suffix = SECTION_NAME (unwsec) + len;
4116 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4118 if (strncmp (SECTION_NAME (sec),
4119 ELF_STRING_ia64_unwind_info, len2) == 0
4120 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4124 if (i == elf_header.e_shnum)
4126 printf (_("\nCould not find unwind info section for "));
4128 if (string_table == NULL)
4129 printf ("%d", unwsec->sh_name);
4131 printf (_("'%s'"), SECTION_NAME (unwsec));
4135 aux.info_size = sec->sh_size;
4136 aux.info_addr = sec->sh_addr;
4137 aux.info = (char *) get_data (NULL, file, sec->sh_offset,
4138 aux.info_size, _("unwind info"));
4140 printf (_("\nUnwind section "));
4142 if (string_table == NULL)
4143 printf ("%d", unwsec->sh_name);
4145 printf (_("'%s'"), SECTION_NAME (unwsec));
4147 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4148 (unsigned long) unwsec->sh_offset,
4149 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
4151 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4153 if (aux.table_len > 0)
4154 dump_ia64_unwind (& aux);
4157 free ((char *) aux.table);
4159 free ((char *) aux.info);
4168 free ((char *) aux.strtab);
4174 dynamic_segment_mips_val (entry)
4175 Elf_Internal_Dyn * entry;
4177 switch (entry->d_tag)
4180 if (entry->d_un.d_val == 0)
4184 static const char * opts[] =
4186 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4187 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4188 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4189 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4194 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
4195 if (entry->d_un.d_val & (1 << cnt))
4197 printf ("%s%s", first ? "" : " ", opts[cnt]);
4204 case DT_MIPS_IVERSION:
4205 if (dynamic_strings != NULL)
4206 printf ("Interface Version: %s\n",
4207 dynamic_strings + entry->d_un.d_val);
4209 printf ("%ld\n", (long) entry->d_un.d_ptr);
4212 case DT_MIPS_TIME_STAMP:
4217 time_t time = entry->d_un.d_val;
4218 tmp = gmtime (&time);
4219 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
4220 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4221 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4222 printf ("Time Stamp: %s\n", timebuf);
4226 case DT_MIPS_RLD_VERSION:
4227 case DT_MIPS_LOCAL_GOTNO:
4228 case DT_MIPS_CONFLICTNO:
4229 case DT_MIPS_LIBLISTNO:
4230 case DT_MIPS_SYMTABNO:
4231 case DT_MIPS_UNREFEXTNO:
4232 case DT_MIPS_HIPAGENO:
4233 case DT_MIPS_DELTA_CLASS_NO:
4234 case DT_MIPS_DELTA_INSTANCE_NO:
4235 case DT_MIPS_DELTA_RELOC_NO:
4236 case DT_MIPS_DELTA_SYM_NO:
4237 case DT_MIPS_DELTA_CLASSSYM_NO:
4238 case DT_MIPS_COMPACT_SIZE:
4239 printf ("%ld\n", (long) entry->d_un.d_ptr);
4243 printf ("%#lx\n", (long) entry->d_un.d_ptr);
4249 dynamic_segment_parisc_val (entry)
4250 Elf_Internal_Dyn * entry;
4252 switch (entry->d_tag)
4254 case DT_HP_DLD_FLAGS:
4263 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
4264 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
4265 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
4266 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
4267 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
4268 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
4269 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
4270 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
4271 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
4272 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
4273 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
4277 bfd_vma val = entry->d_un.d_val;
4279 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
4280 if (val & flags[cnt].bit)
4284 fputs (flags[cnt].str, stdout);
4286 val ^= flags[cnt].bit;
4289 if (val != 0 || first)
4293 print_vma (val, HEX);
4299 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4306 get_32bit_dynamic_segment (file)
4309 Elf32_External_Dyn * edyn;
4310 Elf_Internal_Dyn * entry;
4313 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr,
4314 dynamic_size, _("dynamic segment"));
4318 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4319 how large this .dynamic is now. We can do this even before the byte
4320 swapping since the DT_NULL tag is recognizable. */
4322 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
4325 dynamic_segment = (Elf_Internal_Dyn *)
4326 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4328 if (dynamic_segment == NULL)
4330 error (_("Out of memory\n"));
4335 for (i = 0, entry = dynamic_segment;
4339 entry->d_tag = BYTE_GET (edyn [i].d_tag);
4340 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
4349 get_64bit_dynamic_segment (file)
4352 Elf64_External_Dyn * edyn;
4353 Elf_Internal_Dyn * entry;
4356 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr,
4357 dynamic_size, _("dynamic segment"));
4361 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4362 how large this .dynamic is now. We can do this even before the byte
4363 swapping since the DT_NULL tag is recognizable. */
4365 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
4368 dynamic_segment = (Elf_Internal_Dyn *)
4369 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4371 if (dynamic_segment == NULL)
4373 error (_("Out of memory\n"));
4378 for (i = 0, entry = dynamic_segment;
4382 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
4383 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
4392 get_dynamic_flags (flags)
4395 static char buff [128];
4403 flag = flags & - flags;
4411 case DF_ORIGIN: strcpy (p, "ORIGIN"); break;
4412 case DF_SYMBOLIC: strcpy (p, "SYMBOLIC"); break;
4413 case DF_TEXTREL: strcpy (p, "TEXTREL"); break;
4414 case DF_BIND_NOW: strcpy (p, "BIND_NOW"); break;
4415 case DF_STATIC_TLS: strcpy (p, "STATIC_TLS"); break;
4416 default: strcpy (p, "unknown"); break;
4419 p = strchr (p, '\0');
4424 /* Parse and display the contents of the dynamic segment. */
4426 process_dynamic_segment (file)
4429 Elf_Internal_Dyn * entry;
4432 if (dynamic_size == 0)
4435 printf (_("\nThere is no dynamic segment in this file.\n"));
4442 if (! get_32bit_dynamic_segment (file))
4445 else if (! get_64bit_dynamic_segment (file))
4448 /* Find the appropriate symbol table. */
4449 if (dynamic_symbols == NULL)
4451 for (i = 0, entry = dynamic_segment;
4455 Elf32_Internal_Shdr section;
4457 if (entry->d_tag != DT_SYMTAB)
4460 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4462 /* Since we do not know how big the symbol table is,
4463 we default to reading in the entire file (!) and
4464 processing that. This is overkill, I know, but it
4466 section.sh_offset = entry->d_un.d_val - loadaddr;
4468 if (fseek (file, 0, SEEK_END))
4469 error (_("Unable to seek to end of file!"));
4471 section.sh_size = ftell (file) - section.sh_offset;
4473 section.sh_entsize = sizeof (Elf32_External_Sym);
4475 section.sh_entsize = sizeof (Elf64_External_Sym);
4477 num_dynamic_syms = section.sh_size / section.sh_entsize;
4478 if (num_dynamic_syms < 1)
4480 error (_("Unable to determine the number of symbols to load\n"));
4484 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
4488 /* Similarly find a string table. */
4489 if (dynamic_strings == NULL)
4491 for (i = 0, entry = dynamic_segment;
4495 unsigned long offset;
4498 if (entry->d_tag != DT_STRTAB)
4501 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4503 /* Since we do not know how big the string table is,
4504 we default to reading in the entire file (!) and
4505 processing that. This is overkill, I know, but it
4508 offset = entry->d_un.d_val - loadaddr;
4509 if (fseek (file, 0, SEEK_END))
4510 error (_("Unable to seek to end of file\n"));
4511 str_tab_len = ftell (file) - offset;
4513 if (str_tab_len < 1)
4516 (_("Unable to determine the length of the dynamic string table\n"));
4520 dynamic_strings = (char *) get_data (NULL, file, offset, str_tab_len,
4521 _("dynamic string table"));
4526 /* And find the syminfo section if available. */
4527 if (dynamic_syminfo == NULL)
4529 unsigned int syminsz = 0;
4531 for (i = 0, entry = dynamic_segment;
4535 if (entry->d_tag == DT_SYMINENT)
4537 /* Note: these braces are necessary to avoid a syntax
4538 error from the SunOS4 C compiler. */
4539 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4541 else if (entry->d_tag == DT_SYMINSZ)
4542 syminsz = entry->d_un.d_val;
4543 else if (entry->d_tag == DT_SYMINFO)
4544 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
4547 if (dynamic_syminfo_offset != 0 && syminsz != 0)
4549 Elf_External_Syminfo * extsyminfo;
4550 Elf_Internal_Syminfo * syminfo;
4552 /* There is a syminfo section. Read the data. */
4553 extsyminfo = ((Elf_External_Syminfo *)
4554 get_data (NULL, file, dynamic_syminfo_offset,
4555 syminsz, _("symbol information")));
4559 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
4560 if (dynamic_syminfo == NULL)
4562 error (_("Out of memory\n"));
4566 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4567 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4570 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4571 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4578 if (do_dynamic && dynamic_addr)
4579 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4580 dynamic_addr, (long) dynamic_size);
4582 printf (_(" Tag Type Name/Value\n"));
4584 for (i = 0, entry = dynamic_segment;
4593 print_vma (entry->d_tag, FULL_HEX);
4594 dtype = get_dynamic_type (entry->d_tag);
4595 printf (" (%s)%*s", dtype,
4596 ((is_32bit_elf ? 27 : 19)
4597 - (int) strlen (dtype)),
4601 switch (entry->d_tag)
4605 puts (get_dynamic_flags (entry->d_un.d_val));
4615 switch (entry->d_tag)
4618 printf (_("Auxiliary library"));
4622 printf (_("Filter library"));
4626 printf (_("Configuration file"));
4630 printf (_("Dependency audit library"));
4634 printf (_("Audit library"));
4638 if (dynamic_strings)
4639 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4643 print_vma (entry->d_un.d_val, PREFIX_HEX);
4652 printf (_("Flags:"));
4654 if (entry->d_un.d_val == 0)
4655 printf (_(" None\n"));
4658 unsigned long int val = entry->d_un.d_val;
4660 if (val & DTF_1_PARINIT)
4662 printf (" PARINIT");
4663 val ^= DTF_1_PARINIT;
4665 if (val & DTF_1_CONFEXP)
4667 printf (" CONFEXP");
4668 val ^= DTF_1_CONFEXP;
4671 printf (" %lx", val);
4680 printf (_("Flags:"));
4682 if (entry->d_un.d_val == 0)
4683 printf (_(" None\n"));
4686 unsigned long int val = entry->d_un.d_val;
4688 if (val & DF_P1_LAZYLOAD)
4690 printf (" LAZYLOAD");
4691 val ^= DF_P1_LAZYLOAD;
4693 if (val & DF_P1_GROUPPERM)
4695 printf (" GROUPPERM");
4696 val ^= DF_P1_GROUPPERM;
4699 printf (" %lx", val);
4708 printf (_("Flags:"));
4709 if (entry->d_un.d_val == 0)
4710 printf (_(" None\n"));
4713 unsigned long int val = entry->d_un.d_val;
4720 if (val & DF_1_GLOBAL)
4725 if (val & DF_1_GROUP)
4730 if (val & DF_1_NODELETE)
4732 printf (" NODELETE");
4733 val ^= DF_1_NODELETE;
4735 if (val & DF_1_LOADFLTR)
4737 printf (" LOADFLTR");
4738 val ^= DF_1_LOADFLTR;
4740 if (val & DF_1_INITFIRST)
4742 printf (" INITFIRST");
4743 val ^= DF_1_INITFIRST;
4745 if (val & DF_1_NOOPEN)
4750 if (val & DF_1_ORIGIN)
4755 if (val & DF_1_DIRECT)
4760 if (val & DF_1_TRANS)
4765 if (val & DF_1_INTERPOSE)
4767 printf (" INTERPOSE");
4768 val ^= DF_1_INTERPOSE;
4770 if (val & DF_1_NODEFLIB)
4772 printf (" NODEFLIB");
4773 val ^= DF_1_NODEFLIB;
4775 if (val & DF_1_NODUMP)
4780 if (val & DF_1_CONLFAT)
4782 printf (" CONLFAT");
4783 val ^= DF_1_CONLFAT;
4786 printf (" %lx", val);
4794 puts (get_dynamic_type (entry->d_un.d_val));
4814 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4820 if (dynamic_strings == NULL)
4823 name = dynamic_strings + entry->d_un.d_val;
4827 switch (entry->d_tag)
4830 printf (_("Shared library: [%s]"), name);
4832 if (strcmp (name, program_interpreter) == 0)
4833 printf (_(" program interpreter"));
4837 printf (_("Library soname: [%s]"), name);
4841 printf (_("Library rpath: [%s]"), name);
4845 printf (_("Library runpath: [%s]"), name);
4849 print_vma (entry->d_un.d_val, PREFIX_HEX);
4854 print_vma (entry->d_un.d_val, PREFIX_HEX);
4870 case DT_INIT_ARRAYSZ:
4871 case DT_FINI_ARRAYSZ:
4872 case DT_GNU_CONFLICTSZ:
4873 case DT_GNU_LIBLISTSZ:
4876 print_vma (entry->d_un.d_val, UNSIGNED);
4877 printf (" (bytes)\n");
4887 print_vma (entry->d_un.d_val, UNSIGNED);
4900 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4904 name = dynamic_strings + entry->d_un.d_val;
4908 printf (_("Not needed object: [%s]\n"), name);
4913 print_vma (entry->d_un.d_val, PREFIX_HEX);
4919 /* The value of this entry is ignored. */
4924 case DT_GNU_PRELINKED:
4928 time_t time = entry->d_un.d_val;
4930 tmp = gmtime (&time);
4931 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
4932 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4933 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4939 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4940 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4945 switch (elf_header.e_machine)
4948 case EM_MIPS_RS3_LE:
4949 dynamic_segment_mips_val (entry);
4952 dynamic_segment_parisc_val (entry);
4955 print_vma (entry->d_un.d_val, PREFIX_HEX);
4967 get_ver_flags (flags)
4970 static char buff [32];
4977 if (flags & VER_FLG_BASE)
4978 strcat (buff, "BASE ");
4980 if (flags & VER_FLG_WEAK)
4982 if (flags & VER_FLG_BASE)
4983 strcat (buff, "| ");
4985 strcat (buff, "WEAK ");
4988 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4989 strcat (buff, "| <unknown>");
4994 /* Display the contents of the version sections. */
4996 process_version_sections (file)
4999 Elf32_Internal_Shdr * section;
5006 for (i = 0, section = section_headers;
5007 i < elf_header.e_shnum;
5010 switch (section->sh_type)
5012 case SHT_GNU_verdef:
5014 Elf_External_Verdef * edefs;
5021 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5022 SECTION_NAME (section), section->sh_info);
5024 printf (_(" Addr: 0x"));
5025 printf_vma (section->sh_addr);
5026 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5027 (unsigned long) section->sh_offset, section->sh_link,
5028 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5030 edefs = ((Elf_External_Verdef *)
5031 get_data (NULL, file, section->sh_offset,
5033 _("version definition section")));
5037 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
5040 Elf_External_Verdef * edef;
5041 Elf_Internal_Verdef ent;
5042 Elf_External_Verdaux * eaux;
5043 Elf_Internal_Verdaux aux;
5047 vstart = ((char *) edefs) + idx;
5049 edef = (Elf_External_Verdef *) vstart;
5051 ent.vd_version = BYTE_GET (edef->vd_version);
5052 ent.vd_flags = BYTE_GET (edef->vd_flags);
5053 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
5054 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
5055 ent.vd_hash = BYTE_GET (edef->vd_hash);
5056 ent.vd_aux = BYTE_GET (edef->vd_aux);
5057 ent.vd_next = BYTE_GET (edef->vd_next);
5059 printf (_(" %#06x: Rev: %d Flags: %s"),
5060 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
5062 printf (_(" Index: %d Cnt: %d "),
5063 ent.vd_ndx, ent.vd_cnt);
5065 vstart += ent.vd_aux;
5067 eaux = (Elf_External_Verdaux *) vstart;
5069 aux.vda_name = BYTE_GET (eaux->vda_name);
5070 aux.vda_next = BYTE_GET (eaux->vda_next);
5072 if (dynamic_strings)
5073 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
5075 printf (_("Name index: %ld\n"), aux.vda_name);
5077 isum = idx + ent.vd_aux;
5079 for (j = 1; j < ent.vd_cnt; j ++)
5081 isum += aux.vda_next;
5082 vstart += aux.vda_next;
5084 eaux = (Elf_External_Verdaux *) vstart;
5086 aux.vda_name = BYTE_GET (eaux->vda_name);
5087 aux.vda_next = BYTE_GET (eaux->vda_next);
5089 if (dynamic_strings)
5090 printf (_(" %#06x: Parent %d: %s\n"),
5091 isum, j, dynamic_strings + aux.vda_name);
5093 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5094 isum, j, aux.vda_name);
5104 case SHT_GNU_verneed:
5106 Elf_External_Verneed * eneed;
5112 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5113 SECTION_NAME (section), section->sh_info);
5115 printf (_(" Addr: 0x"));
5116 printf_vma (section->sh_addr);
5117 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5118 (unsigned long) section->sh_offset, section->sh_link,
5119 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5121 eneed = ((Elf_External_Verneed *)
5122 get_data (NULL, file, section->sh_offset,
5123 section->sh_size, _("version need section")));
5127 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5129 Elf_External_Verneed * entry;
5130 Elf_Internal_Verneed ent;
5135 vstart = ((char *) eneed) + idx;
5137 entry = (Elf_External_Verneed *) vstart;
5139 ent.vn_version = BYTE_GET (entry->vn_version);
5140 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
5141 ent.vn_file = BYTE_GET (entry->vn_file);
5142 ent.vn_aux = BYTE_GET (entry->vn_aux);
5143 ent.vn_next = BYTE_GET (entry->vn_next);
5145 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
5147 if (dynamic_strings)
5148 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
5150 printf (_(" File: %lx"), ent.vn_file);
5152 printf (_(" Cnt: %d\n"), ent.vn_cnt);
5154 vstart += ent.vn_aux;
5156 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
5158 Elf_External_Vernaux * eaux;
5159 Elf_Internal_Vernaux aux;
5161 eaux = (Elf_External_Vernaux *) vstart;
5163 aux.vna_hash = BYTE_GET (eaux->vna_hash);
5164 aux.vna_flags = BYTE_GET (eaux->vna_flags);
5165 aux.vna_other = BYTE_GET (eaux->vna_other);
5166 aux.vna_name = BYTE_GET (eaux->vna_name);
5167 aux.vna_next = BYTE_GET (eaux->vna_next);
5169 if (dynamic_strings)
5170 printf (_(" %#06x: Name: %s"),
5171 isum, dynamic_strings + aux.vna_name);
5173 printf (_(" %#06x: Name index: %lx"),
5174 isum, aux.vna_name);
5176 printf (_(" Flags: %s Version: %d\n"),
5177 get_ver_flags (aux.vna_flags), aux.vna_other);
5179 isum += aux.vna_next;
5180 vstart += aux.vna_next;
5190 case SHT_GNU_versym:
5192 Elf32_Internal_Shdr * link_section;
5195 unsigned char * edata;
5196 unsigned short * data;
5198 Elf_Internal_Sym * symbols;
5199 Elf32_Internal_Shdr * string_sec;
5201 link_section = SECTION_HEADER (section->sh_link);
5202 total = section->sh_size / section->sh_entsize;
5206 symbols = GET_ELF_SYMBOLS (file, link_section);
5208 string_sec = SECTION_HEADER (link_section->sh_link);
5210 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5211 string_sec->sh_size,
5212 _("version string table"));
5216 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5217 SECTION_NAME (section), total);
5219 printf (_(" Addr: "));
5220 printf_vma (section->sh_addr);
5221 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5222 (unsigned long) section->sh_offset, section->sh_link,
5223 SECTION_NAME (link_section));
5227 get_data (NULL, file,
5228 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] - loadaddr,
5229 total * sizeof (short), _("version symbol data")));
5236 data = (unsigned short *) malloc (total * sizeof (short));
5238 for (cnt = total; cnt --;)
5239 data [cnt] = byte_get (edata + cnt * sizeof (short),
5244 for (cnt = 0; cnt < total; cnt += 4)
5247 int check_def, check_need;
5250 printf (" %03x:", cnt);
5252 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
5253 switch (data [cnt + j])
5256 fputs (_(" 0 (*local*) "), stdout);
5260 fputs (_(" 1 (*global*) "), stdout);
5264 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
5265 data [cnt + j] & 0x8000 ? 'h' : ' ');
5269 if (SECTION_HEADER (symbols [cnt + j].st_shndx)->sh_type
5272 if (symbols [cnt + j].st_shndx == SHN_UNDEF)
5279 && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
5281 Elf_Internal_Verneed ivn;
5282 unsigned long offset;
5284 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5289 Elf_Internal_Vernaux ivna;
5290 Elf_External_Verneed evn;
5291 Elf_External_Vernaux evna;
5292 unsigned long a_off;
5294 get_data (&evn, file, offset, sizeof (evn),
5297 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5298 ivn.vn_next = BYTE_GET (evn.vn_next);
5300 a_off = offset + ivn.vn_aux;
5304 get_data (&evna, file, a_off, sizeof (evna),
5305 _("version need aux (2)"));
5307 ivna.vna_next = BYTE_GET (evna.vna_next);
5308 ivna.vna_other = BYTE_GET (evna.vna_other);
5310 a_off += ivna.vna_next;
5312 while (ivna.vna_other != data [cnt + j]
5313 && ivna.vna_next != 0);
5315 if (ivna.vna_other == data [cnt + j])
5317 ivna.vna_name = BYTE_GET (evna.vna_name);
5319 name = strtab + ivna.vna_name;
5320 nn += printf ("(%s%-*s",
5322 12 - (int) strlen (name),
5328 offset += ivn.vn_next;
5330 while (ivn.vn_next);
5333 if (check_def && data [cnt + j] != 0x8001
5334 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5336 Elf_Internal_Verdef ivd;
5337 Elf_External_Verdef evd;
5338 unsigned long offset;
5340 offset = version_info
5341 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
5345 get_data (&evd, file, offset, sizeof (evd),
5348 ivd.vd_next = BYTE_GET (evd.vd_next);
5349 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5351 offset += ivd.vd_next;
5353 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
5354 && ivd.vd_next != 0);
5356 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
5358 Elf_External_Verdaux evda;
5359 Elf_Internal_Verdaux ivda;
5361 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5363 get_data (&evda, file,
5364 offset - ivd.vd_next + ivd.vd_aux,
5365 sizeof (evda), _("version def aux"));
5367 ivda.vda_name = BYTE_GET (evda.vda_name);
5369 name = strtab + ivda.vda_name;
5370 nn += printf ("(%s%-*s",
5372 12 - (int) strlen (name),
5378 printf ("%*c", 18 - nn, ' ');
5396 printf (_("\nNo version information found in this file.\n"));
5402 get_symbol_binding (binding)
5403 unsigned int binding;
5405 static char buff [32];
5409 case STB_LOCAL: return "LOCAL";
5410 case STB_GLOBAL: return "GLOBAL";
5411 case STB_WEAK: return "WEAK";
5413 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
5414 sprintf (buff, _("<processor specific>: %d"), binding);
5415 else if (binding >= STB_LOOS && binding <= STB_HIOS)
5416 sprintf (buff, _("<OS specific>: %d"), binding);
5418 sprintf (buff, _("<unknown>: %d"), binding);
5424 get_symbol_type (type)
5427 static char buff [32];
5431 case STT_NOTYPE: return "NOTYPE";
5432 case STT_OBJECT: return "OBJECT";
5433 case STT_FUNC: return "FUNC";
5434 case STT_SECTION: return "SECTION";
5435 case STT_FILE: return "FILE";
5436 case STT_COMMON: return "COMMON";
5437 case STT_TLS: return "TLS";
5439 if (type >= STT_LOPROC && type <= STT_HIPROC)
5441 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
5442 return "THUMB_FUNC";
5444 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
5447 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
5448 return "PARISC_MILLI";
5450 sprintf (buff, _("<processor specific>: %d"), type);
5452 else if (type >= STT_LOOS && type <= STT_HIOS)
5454 if (elf_header.e_machine == EM_PARISC)
5456 if (type == STT_HP_OPAQUE)
5458 if (type == STT_HP_STUB)
5462 sprintf (buff, _("<OS specific>: %d"), type);
5465 sprintf (buff, _("<unknown>: %d"), type);
5471 get_symbol_visibility (visibility)
5472 unsigned int visibility;
5476 case STV_DEFAULT: return "DEFAULT";
5477 case STV_INTERNAL: return "INTERNAL";
5478 case STV_HIDDEN: return "HIDDEN";
5479 case STV_PROTECTED: return "PROTECTED";
5485 get_symbol_index_type (type)
5490 case SHN_UNDEF: return "UND";
5491 case SHN_ABS: return "ABS";
5492 case SHN_COMMON: return "COM";
5494 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5496 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5498 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5502 static char buff [32];
5504 sprintf (buff, "%3d", type);
5511 get_dynamic_data (file, number)
5513 unsigned int number;
5515 unsigned char * e_data;
5518 e_data = (unsigned char *) malloc (number * 4);
5522 error (_("Out of memory\n"));
5526 if (fread (e_data, 4, number, file) != number)
5528 error (_("Unable to read in dynamic data\n"));
5532 i_data = (int *) malloc (number * sizeof (* i_data));
5536 error (_("Out of memory\n"));
5542 i_data [number] = byte_get (e_data + number * 4, 4);
5549 /* Dump the symbol table. */
5551 process_symbol_table (file)
5554 Elf32_Internal_Shdr * section;
5555 unsigned char nb [4];
5556 unsigned char nc [4];
5559 int * buckets = NULL;
5560 int * chains = NULL;
5562 if (! do_syms && !do_histogram)
5565 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5568 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
5570 error (_("Unable to seek to start of dynamic information"));
5574 if (fread (nb, sizeof (nb), 1, file) != 1)
5576 error (_("Failed to read in number of buckets\n"));
5580 if (fread (nc, sizeof (nc), 1, file) != 1)
5582 error (_("Failed to read in number of chains\n"));
5586 nbuckets = byte_get (nb, 4);
5587 nchains = byte_get (nc, 4);
5589 buckets = get_dynamic_data (file, nbuckets);
5590 chains = get_dynamic_data (file, nchains);
5592 if (buckets == NULL || chains == NULL)
5597 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5602 printf (_("\nSymbol table for image:\n"));
5604 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5606 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5608 for (hn = 0; hn < nbuckets; hn++)
5613 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
5615 Elf_Internal_Sym * psym;
5617 psym = dynamic_symbols + si;
5619 printf (" %3d %3d: ", si, hn);
5620 print_vma (psym->st_value, LONG_HEX);
5622 print_vma (psym->st_size, DEC_5);
5624 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5625 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5626 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5627 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
5628 print_symbol (25, dynamic_strings + psym->st_name);
5633 else if (do_syms && !do_using_dynamic)
5637 for (i = 0, section = section_headers;
5638 i < elf_header.e_shnum;
5643 Elf_Internal_Sym * symtab;
5644 Elf_Internal_Sym * psym;
5647 if ( section->sh_type != SHT_SYMTAB
5648 && section->sh_type != SHT_DYNSYM)
5651 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5652 SECTION_NAME (section),
5653 (unsigned long) (section->sh_size / section->sh_entsize));
5655 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5657 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5659 symtab = GET_ELF_SYMBOLS (file, section);
5663 if (section->sh_link == elf_header.e_shstrndx)
5664 strtab = string_table;
5667 Elf32_Internal_Shdr * string_sec;
5669 string_sec = SECTION_HEADER (section->sh_link);
5671 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5672 string_sec->sh_size,
5676 for (si = 0, psym = symtab;
5677 si < section->sh_size / section->sh_entsize;
5680 printf ("%6d: ", si);
5681 print_vma (psym->st_value, LONG_HEX);
5683 print_vma (psym->st_size, DEC_5);
5684 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5685 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5686 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5687 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
5688 print_symbol (25, strtab + psym->st_name);
5690 if (section->sh_type == SHT_DYNSYM &&
5691 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5693 unsigned char data[2];
5694 unsigned short vers_data;
5695 unsigned long offset;
5699 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
5702 get_data (&data, file, offset + si * sizeof (vers_data),
5703 sizeof (data), _("version data"));
5705 vers_data = byte_get (data, 2);
5707 is_nobits = (SECTION_HEADER (psym->st_shndx)->sh_type
5710 check_def = (psym->st_shndx != SHN_UNDEF);
5712 if ((vers_data & 0x8000) || vers_data > 1)
5714 if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5715 && (is_nobits || ! check_def))
5717 Elf_External_Verneed evn;
5718 Elf_Internal_Verneed ivn;
5719 Elf_Internal_Vernaux ivna;
5721 /* We must test both. */
5722 offset = version_info
5723 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
5727 unsigned long vna_off;
5729 get_data (&evn, file, offset, sizeof (evn),
5732 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5733 ivn.vn_next = BYTE_GET (evn.vn_next);
5735 vna_off = offset + ivn.vn_aux;
5739 Elf_External_Vernaux evna;
5741 get_data (&evna, file, vna_off,
5743 _("version need aux (3)"));
5745 ivna.vna_other = BYTE_GET (evna.vna_other);
5746 ivna.vna_next = BYTE_GET (evna.vna_next);
5747 ivna.vna_name = BYTE_GET (evna.vna_name);
5749 vna_off += ivna.vna_next;
5751 while (ivna.vna_other != vers_data
5752 && ivna.vna_next != 0);
5754 if (ivna.vna_other == vers_data)
5757 offset += ivn.vn_next;
5759 while (ivn.vn_next != 0);
5761 if (ivna.vna_other == vers_data)
5764 strtab + ivna.vna_name, ivna.vna_other);
5767 else if (! is_nobits)
5768 error (_("bad dynamic symbol"));
5775 if (vers_data != 0x8001
5776 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5778 Elf_Internal_Verdef ivd;
5779 Elf_Internal_Verdaux ivda;
5780 Elf_External_Verdaux evda;
5781 unsigned long offset;
5784 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5789 Elf_External_Verdef evd;
5791 get_data (&evd, file, offset, sizeof (evd),
5794 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5795 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5796 ivd.vd_next = BYTE_GET (evd.vd_next);
5798 offset += ivd.vd_next;
5800 while (ivd.vd_ndx != (vers_data & 0x7fff)
5801 && ivd.vd_next != 0);
5803 offset -= ivd.vd_next;
5804 offset += ivd.vd_aux;
5806 get_data (&evda, file, offset, sizeof (evda),
5807 _("version def aux"));
5809 ivda.vda_name = BYTE_GET (evda.vda_name);
5811 if (psym->st_name != ivda.vda_name)
5812 printf ((vers_data & 0x8000)
5814 strtab + ivda.vda_name);
5824 if (strtab != string_table)
5830 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5832 if (do_histogram && buckets != NULL)
5839 int nzero_counts = 0;
5842 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5844 printf (_(" Length Number %% of total Coverage\n"));
5846 lengths = (int *) calloc (nbuckets, sizeof (int));
5847 if (lengths == NULL)
5849 error (_("Out of memory"));
5852 for (hn = 0; hn < nbuckets; ++hn)
5857 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5860 if (maxlength < ++lengths[hn])
5865 counts = (int *) calloc (maxlength + 1, sizeof (int));
5868 error (_("Out of memory"));
5872 for (hn = 0; hn < nbuckets; ++hn)
5873 ++ counts [lengths [hn]];
5877 printf (" 0 %-10d (%5.1f%%)\n",
5878 counts[0], (counts[0] * 100.0) / nbuckets);
5879 for (si = 1; si <= maxlength; ++si)
5881 nzero_counts += counts[si] * si;
5882 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5883 si, counts[si], (counts[si] * 100.0) / nbuckets,
5884 (nzero_counts * 100.0) / nsyms);
5892 if (buckets != NULL)
5902 process_syminfo (file)
5903 FILE * file ATTRIBUTE_UNUSED;
5907 if (dynamic_syminfo == NULL
5909 /* No syminfo, this is ok. */
5912 /* There better should be a dynamic symbol section. */
5913 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5917 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5918 dynamic_syminfo_offset, dynamic_syminfo_nent);
5920 printf (_(" Num: Name BoundTo Flags\n"));
5921 for (i = 0; i < dynamic_syminfo_nent; ++i)
5923 unsigned short int flags = dynamic_syminfo[i].si_flags;
5925 printf ("%4d: ", i);
5926 print_symbol (30, dynamic_strings + dynamic_symbols[i].st_name);
5929 switch (dynamic_syminfo[i].si_boundto)
5931 case SYMINFO_BT_SELF:
5932 fputs ("SELF ", stdout);
5934 case SYMINFO_BT_PARENT:
5935 fputs ("PARENT ", stdout);
5938 if (dynamic_syminfo[i].si_boundto > 0
5939 && dynamic_syminfo[i].si_boundto < dynamic_size)
5941 print_symbol (10, dynamic_strings
5943 [dynamic_syminfo[i].si_boundto].d_un.d_val);
5947 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5951 if (flags & SYMINFO_FLG_DIRECT)
5953 if (flags & SYMINFO_FLG_PASSTHRU)
5954 printf (" PASSTHRU");
5955 if (flags & SYMINFO_FLG_COPY)
5957 if (flags & SYMINFO_FLG_LAZYLOAD)
5958 printf (" LAZYLOAD");
5966 #ifdef SUPPORT_DISASSEMBLY
5968 disassemble_section (section, file)
5969 Elf32_Internal_Shdr * section;
5972 printf (_("\nAssembly dump of section %s\n"),
5973 SECTION_NAME (section));
5975 /* XXX -- to be done --- XXX */
5982 dump_section (section, file)
5983 Elf32_Internal_Shdr * section;
5986 bfd_size_type bytes;
5988 unsigned char * data;
5989 unsigned char * start;
5991 bytes = section->sh_size;
5995 printf (_("\nSection '%s' has no data to dump.\n"),
5996 SECTION_NAME (section));
6000 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
6002 addr = section->sh_addr;
6004 start = (unsigned char *) get_data (NULL, file, section->sh_offset, bytes,
6017 lbytes = (bytes > 16 ? 16 : bytes);
6019 printf (" 0x%8.8lx ", (unsigned long) addr);
6021 switch (elf_header.e_ident [EI_DATA])
6025 for (j = 15; j >= 0; j --)
6028 printf ("%2.2x", data [j]);
6038 for (j = 0; j < 16; j++)
6041 printf ("%2.2x", data [j]);
6051 for (j = 0; j < lbytes; j++)
6054 if (k >= ' ' && k < 0x80)
6073 static unsigned long int
6074 read_leb128 (data, length_return, sign)
6075 unsigned char * data;
6076 int * length_return;
6079 unsigned long int result = 0;
6080 unsigned int num_read = 0;
6089 result |= (byte & 0x7f) << shift;
6094 while (byte & 0x80);
6096 if (length_return != NULL)
6097 * length_return = num_read;
6099 if (sign && (shift < 32) && (byte & 0x40))
6100 result |= -1 << shift;
6105 typedef struct State_Machine_Registers
6107 unsigned long address;
6110 unsigned int column;
6114 /* This variable hold the number of the last entry seen
6115 in the File Table. */
6116 unsigned int last_file_entry;
6119 static SMR state_machine_regs;
6122 reset_state_machine (is_stmt)
6125 state_machine_regs.address = 0;
6126 state_machine_regs.file = 1;
6127 state_machine_regs.line = 1;
6128 state_machine_regs.column = 0;
6129 state_machine_regs.is_stmt = is_stmt;
6130 state_machine_regs.basic_block = 0;
6131 state_machine_regs.end_sequence = 0;
6132 state_machine_regs.last_file_entry = 0;
6135 /* Handled an extend line op. Returns true if this is the end
6138 process_extended_line_op (data, is_stmt, pointer_size)
6139 unsigned char * data;
6143 unsigned char op_code;
6146 unsigned char * name;
6149 len = read_leb128 (data, & bytes_read, 0);
6154 warn (_("badly formed extended line op encountered!\n"));
6159 op_code = * data ++;
6161 printf (_(" Extended opcode %d: "), op_code);
6165 case DW_LNE_end_sequence:
6166 printf (_("End of Sequence\n\n"));
6167 reset_state_machine (is_stmt);
6170 case DW_LNE_set_address:
6171 adr = byte_get (data, pointer_size);
6172 printf (_("set Address to 0x%lx\n"), adr);
6173 state_machine_regs.address = adr;
6176 case DW_LNE_define_file:
6177 printf (_(" define new File Table entry\n"));
6178 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6180 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
6182 data += strlen ((char *) data) + 1;
6183 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6185 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6187 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6188 printf (_("%s\n\n"), name);
6192 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
6199 /* Size of pointers in the .debug_line section. This information is not
6200 really present in that section. It's obtained before dumping the debug
6201 sections by doing some pre-scan of the .debug_info section. */
6202 static int debug_line_pointer_size = 4;
6205 display_debug_lines (section, start, file)
6206 Elf32_Internal_Shdr * section;
6207 unsigned char * start;
6208 FILE * file ATTRIBUTE_UNUSED;
6210 DWARF2_External_LineInfo * external;
6211 DWARF2_Internal_LineInfo info;
6212 unsigned char * standard_opcodes;
6213 unsigned char * data = start;
6214 unsigned char * end = start + section->sh_size;
6215 unsigned char * end_of_sequence;
6218 printf (_("\nDump of debug contents of section %s:\n\n"),
6219 SECTION_NAME (section));
6223 external = (DWARF2_External_LineInfo *) data;
6225 /* Check the length of the block. */
6226 info.li_length = BYTE_GET (external->li_length);
6228 if (info.li_length == 0xffffffff)
6230 warn (_("64-bit DWARF line info is not supported yet.\n"));
6234 if (info.li_length + sizeof (external->li_length) > section->sh_size)
6237 (_("The line info appears to be corrupt - the section is too small\n"));
6241 /* Check its version number. */
6242 info.li_version = BYTE_GET (external->li_version);
6243 if (info.li_version != 2)
6245 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6249 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
6250 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
6251 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
6252 info.li_line_base = BYTE_GET (external->li_line_base);
6253 info.li_line_range = BYTE_GET (external->li_line_range);
6254 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
6256 /* Sign extend the line base field. */
6257 info.li_line_base <<= 24;
6258 info.li_line_base >>= 24;
6260 printf (_(" Length: %ld\n"), info.li_length);
6261 printf (_(" DWARF Version: %d\n"), info.li_version);
6262 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
6263 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
6264 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
6265 printf (_(" Line Base: %d\n"), info.li_line_base);
6266 printf (_(" Line Range: %d\n"), info.li_line_range);
6267 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
6269 end_of_sequence = data + info.li_length + sizeof (external->li_length);
6271 reset_state_machine (info.li_default_is_stmt);
6273 /* Display the contents of the Opcodes table. */
6274 standard_opcodes = data + sizeof (* external);
6276 printf (_("\n Opcodes:\n"));
6278 for (i = 1; i < info.li_opcode_base; i++)
6279 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
6281 /* Display the contents of the Directory table. */
6282 data = standard_opcodes + info.li_opcode_base - 1;
6285 printf (_("\n The Directory Table is empty.\n"));
6288 printf (_("\n The Directory Table:\n"));
6292 printf (_(" %s\n"), data);
6294 data += strlen ((char *) data) + 1;
6298 /* Skip the NUL at the end of the table. */
6301 /* Display the contents of the File Name table. */
6303 printf (_("\n The File Name Table is empty.\n"));
6306 printf (_("\n The File Name Table:\n"));
6307 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6311 unsigned char * name;
6314 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
6317 data += strlen ((char *) data) + 1;
6319 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6321 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6323 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6325 printf (_("%s\n"), name);
6329 /* Skip the NUL at the end of the table. */
6332 /* Now display the statements. */
6333 printf (_("\n Line Number Statements:\n"));
6336 while (data < end_of_sequence)
6338 unsigned char op_code;
6342 op_code = * data ++;
6344 if (op_code >= info.li_opcode_base)
6346 op_code -= info.li_opcode_base;
6347 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
6348 state_machine_regs.address += adv;
6349 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6350 op_code, adv, state_machine_regs.address);
6351 adv = (op_code % info.li_line_range) + info.li_line_base;
6352 state_machine_regs.line += adv;
6353 printf (_(" and Line by %d to %d\n"),
6354 adv, state_machine_regs.line);
6356 else switch (op_code)
6358 case DW_LNS_extended_op:
6359 data += process_extended_line_op (data, info.li_default_is_stmt,
6360 debug_line_pointer_size);
6364 printf (_(" Copy\n"));
6367 case DW_LNS_advance_pc:
6368 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
6370 state_machine_regs.address += adv;
6371 printf (_(" Advance PC by %d to %lx\n"), adv,
6372 state_machine_regs.address);
6375 case DW_LNS_advance_line:
6376 adv = read_leb128 (data, & bytes_read, 1);
6378 state_machine_regs.line += adv;
6379 printf (_(" Advance Line by %d to %d\n"), adv,
6380 state_machine_regs.line);
6383 case DW_LNS_set_file:
6384 adv = read_leb128 (data, & bytes_read, 0);
6386 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6388 state_machine_regs.file = adv;
6391 case DW_LNS_set_column:
6392 adv = read_leb128 (data, & bytes_read, 0);
6394 printf (_(" Set column to %d\n"), adv);
6395 state_machine_regs.column = adv;
6398 case DW_LNS_negate_stmt:
6399 adv = state_machine_regs.is_stmt;
6401 printf (_(" Set is_stmt to %d\n"), adv);
6402 state_machine_regs.is_stmt = adv;
6405 case DW_LNS_set_basic_block:
6406 printf (_(" Set basic block\n"));
6407 state_machine_regs.basic_block = 1;
6410 case DW_LNS_const_add_pc:
6411 adv = (((255 - info.li_opcode_base) / info.li_line_range)
6412 * info.li_min_insn_length);
6413 state_machine_regs.address += adv;
6414 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
6415 state_machine_regs.address);
6418 case DW_LNS_fixed_advance_pc:
6419 adv = byte_get (data, 2);
6421 state_machine_regs.address += adv;
6422 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6423 adv, state_machine_regs.address);
6426 case DW_LNS_set_prologue_end:
6427 printf (_(" Set prologue_end to true\n"));
6430 case DW_LNS_set_epilogue_begin:
6431 printf (_(" Set epilogue_begin to true\n"));
6434 case DW_LNS_set_isa:
6435 adv = read_leb128 (data, & bytes_read, 0);
6437 printf (_(" Set ISA to %d\n"), adv);
6441 printf (_(" Unknown opcode %d with operands: "), op_code);
6444 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
6446 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
6447 i == 1 ? "" : ", ");
6462 display_debug_pubnames (section, start, file)
6463 Elf32_Internal_Shdr * section;
6464 unsigned char * start;
6465 FILE * file ATTRIBUTE_UNUSED;
6467 DWARF2_External_PubNames * external;
6468 DWARF2_Internal_PubNames pubnames;
6469 unsigned char * end;
6471 end = start + section->sh_size;
6473 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6477 unsigned char * data;
6478 unsigned long offset;
6480 external = (DWARF2_External_PubNames *) start;
6482 pubnames.pn_length = BYTE_GET (external->pn_length);
6483 pubnames.pn_version = BYTE_GET (external->pn_version);
6484 pubnames.pn_offset = BYTE_GET (external->pn_offset);
6485 pubnames.pn_size = BYTE_GET (external->pn_size);
6487 data = start + sizeof (* external);
6488 start += pubnames.pn_length + sizeof (external->pn_length);
6490 if (pubnames.pn_length == 0xffffffff)
6492 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6496 if (pubnames.pn_version != 2)
6498 static int warned = 0;
6502 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6509 printf (_(" Length: %ld\n"),
6510 pubnames.pn_length);
6511 printf (_(" Version: %d\n"),
6512 pubnames.pn_version);
6513 printf (_(" Offset into .debug_info section: %ld\n"),
6514 pubnames.pn_offset);
6515 printf (_(" Size of area in .debug_info section: %ld\n"),
6518 printf (_("\n Offset\tName\n"));
6522 offset = byte_get (data, 4);
6527 printf (" %ld\t\t%s\n", offset, data);
6528 data += strlen ((char *) data) + 1;
6531 while (offset != 0);
6544 case DW_TAG_padding: return "DW_TAG_padding";
6545 case DW_TAG_array_type: return "DW_TAG_array_type";
6546 case DW_TAG_class_type: return "DW_TAG_class_type";
6547 case DW_TAG_entry_point: return "DW_TAG_entry_point";
6548 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
6549 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
6550 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
6551 case DW_TAG_label: return "DW_TAG_label";
6552 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
6553 case DW_TAG_member: return "DW_TAG_member";
6554 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
6555 case DW_TAG_reference_type: return "DW_TAG_reference_type";
6556 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
6557 case DW_TAG_string_type: return "DW_TAG_string_type";
6558 case DW_TAG_structure_type: return "DW_TAG_structure_type";
6559 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
6560 case DW_TAG_typedef: return "DW_TAG_typedef";
6561 case DW_TAG_union_type: return "DW_TAG_union_type";
6562 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6563 case DW_TAG_variant: return "DW_TAG_variant";
6564 case DW_TAG_common_block: return "DW_TAG_common_block";
6565 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
6566 case DW_TAG_inheritance: return "DW_TAG_inheritance";
6567 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
6568 case DW_TAG_module: return "DW_TAG_module";
6569 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
6570 case DW_TAG_set_type: return "DW_TAG_set_type";
6571 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
6572 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
6573 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
6574 case DW_TAG_base_type: return "DW_TAG_base_type";
6575 case DW_TAG_catch_block: return "DW_TAG_catch_block";
6576 case DW_TAG_const_type: return "DW_TAG_const_type";
6577 case DW_TAG_constant: return "DW_TAG_constant";
6578 case DW_TAG_enumerator: return "DW_TAG_enumerator";
6579 case DW_TAG_file_type: return "DW_TAG_file_type";
6580 case DW_TAG_friend: return "DW_TAG_friend";
6581 case DW_TAG_namelist: return "DW_TAG_namelist";
6582 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
6583 case DW_TAG_packed_type: return "DW_TAG_packed_type";
6584 case DW_TAG_subprogram: return "DW_TAG_subprogram";
6585 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
6586 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
6587 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
6588 case DW_TAG_try_block: return "DW_TAG_try_block";
6589 case DW_TAG_variant_part: return "DW_TAG_variant_part";
6590 case DW_TAG_variable: return "DW_TAG_variable";
6591 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
6592 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
6593 case DW_TAG_format_label: return "DW_TAG_format_label";
6594 case DW_TAG_function_template: return "DW_TAG_function_template";
6595 case DW_TAG_class_template: return "DW_TAG_class_template";
6596 /* DWARF 2.1 values. */
6597 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
6598 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
6599 case DW_TAG_interface_type: return "DW_TAG_interface_type";
6600 case DW_TAG_namespace: return "DW_TAG_namespace";
6601 case DW_TAG_imported_module: return "DW_TAG_imported_module";
6602 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
6603 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
6604 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
6607 static char buffer [100];
6609 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6616 get_AT_name (attribute)
6617 unsigned long attribute;
6621 case DW_AT_sibling: return "DW_AT_sibling";
6622 case DW_AT_location: return "DW_AT_location";
6623 case DW_AT_name: return "DW_AT_name";
6624 case DW_AT_ordering: return "DW_AT_ordering";
6625 case DW_AT_subscr_data: return "DW_AT_subscr_data";
6626 case DW_AT_byte_size: return "DW_AT_byte_size";
6627 case DW_AT_bit_offset: return "DW_AT_bit_offset";
6628 case DW_AT_bit_size: return "DW_AT_bit_size";
6629 case DW_AT_element_list: return "DW_AT_element_list";
6630 case DW_AT_stmt_list: return "DW_AT_stmt_list";
6631 case DW_AT_low_pc: return "DW_AT_low_pc";
6632 case DW_AT_high_pc: return "DW_AT_high_pc";
6633 case DW_AT_language: return "DW_AT_language";
6634 case DW_AT_member: return "DW_AT_member";
6635 case DW_AT_discr: return "DW_AT_discr";
6636 case DW_AT_discr_value: return "DW_AT_discr_value";
6637 case DW_AT_visibility: return "DW_AT_visibility";
6638 case DW_AT_import: return "DW_AT_import";
6639 case DW_AT_string_length: return "DW_AT_string_length";
6640 case DW_AT_common_reference: return "DW_AT_common_reference";
6641 case DW_AT_comp_dir: return "DW_AT_comp_dir";
6642 case DW_AT_const_value: return "DW_AT_const_value";
6643 case DW_AT_containing_type: return "DW_AT_containing_type";
6644 case DW_AT_default_value: return "DW_AT_default_value";
6645 case DW_AT_inline: return "DW_AT_inline";
6646 case DW_AT_is_optional: return "DW_AT_is_optional";
6647 case DW_AT_lower_bound: return "DW_AT_lower_bound";
6648 case DW_AT_producer: return "DW_AT_producer";
6649 case DW_AT_prototyped: return "DW_AT_prototyped";
6650 case DW_AT_return_addr: return "DW_AT_return_addr";
6651 case DW_AT_start_scope: return "DW_AT_start_scope";
6652 case DW_AT_stride_size: return "DW_AT_stride_size";
6653 case DW_AT_upper_bound: return "DW_AT_upper_bound";
6654 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
6655 case DW_AT_accessibility: return "DW_AT_accessibility";
6656 case DW_AT_address_class: return "DW_AT_address_class";
6657 case DW_AT_artificial: return "DW_AT_artificial";
6658 case DW_AT_base_types: return "DW_AT_base_types";
6659 case DW_AT_calling_convention: return "DW_AT_calling_convention";
6660 case DW_AT_count: return "DW_AT_count";
6661 case DW_AT_data_member_location: return "DW_AT_data_member_location";
6662 case DW_AT_decl_column: return "DW_AT_decl_column";
6663 case DW_AT_decl_file: return "DW_AT_decl_file";
6664 case DW_AT_decl_line: return "DW_AT_decl_line";
6665 case DW_AT_declaration: return "DW_AT_declaration";
6666 case DW_AT_discr_list: return "DW_AT_discr_list";
6667 case DW_AT_encoding: return "DW_AT_encoding";
6668 case DW_AT_external: return "DW_AT_external";
6669 case DW_AT_frame_base: return "DW_AT_frame_base";
6670 case DW_AT_friend: return "DW_AT_friend";
6671 case DW_AT_identifier_case: return "DW_AT_identifier_case";
6672 case DW_AT_macro_info: return "DW_AT_macro_info";
6673 case DW_AT_namelist_items: return "DW_AT_namelist_items";
6674 case DW_AT_priority: return "DW_AT_priority";
6675 case DW_AT_segment: return "DW_AT_segment";
6676 case DW_AT_specification: return "DW_AT_specification";
6677 case DW_AT_static_link: return "DW_AT_static_link";
6678 case DW_AT_type: return "DW_AT_type";
6679 case DW_AT_use_location: return "DW_AT_use_location";
6680 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
6681 case DW_AT_virtuality: return "DW_AT_virtuality";
6682 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6683 /* DWARF 2.1 values. */
6684 case DW_AT_allocated: return "DW_AT_allocated";
6685 case DW_AT_associated: return "DW_AT_associated";
6686 case DW_AT_data_location: return "DW_AT_data_location";
6687 case DW_AT_stride: return "DW_AT_stride";
6688 case DW_AT_entry_pc: return "DW_AT_entry_pc";
6689 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
6690 case DW_AT_extension: return "DW_AT_extension";
6691 case DW_AT_ranges: return "DW_AT_ranges";
6692 case DW_AT_trampoline: return "DW_AT_trampoline";
6693 case DW_AT_call_column: return "DW_AT_call_column";
6694 case DW_AT_call_file: return "DW_AT_call_file";
6695 case DW_AT_call_line: return "DW_AT_call_line";
6696 /* SGI/MIPS extensions. */
6697 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
6698 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
6699 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6700 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
6701 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6702 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
6703 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
6704 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
6705 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
6706 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
6707 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
6708 /* GNU extensions. */
6709 case DW_AT_sf_names: return "DW_AT_sf_names";
6710 case DW_AT_src_info: return "DW_AT_src_info";
6711 case DW_AT_mac_info: return "DW_AT_mac_info";
6712 case DW_AT_src_coords: return "DW_AT_src_coords";
6713 case DW_AT_body_begin: return "DW_AT_body_begin";
6714 case DW_AT_body_end: return "DW_AT_body_end";
6715 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
6718 static char buffer [100];
6720 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6727 get_FORM_name (form)
6732 case DW_FORM_addr: return "DW_FORM_addr";
6733 case DW_FORM_block2: return "DW_FORM_block2";
6734 case DW_FORM_block4: return "DW_FORM_block4";
6735 case DW_FORM_data2: return "DW_FORM_data2";
6736 case DW_FORM_data4: return "DW_FORM_data4";
6737 case DW_FORM_data8: return "DW_FORM_data8";
6738 case DW_FORM_string: return "DW_FORM_string";
6739 case DW_FORM_block: return "DW_FORM_block";
6740 case DW_FORM_block1: return "DW_FORM_block1";
6741 case DW_FORM_data1: return "DW_FORM_data1";
6742 case DW_FORM_flag: return "DW_FORM_flag";
6743 case DW_FORM_sdata: return "DW_FORM_sdata";
6744 case DW_FORM_strp: return "DW_FORM_strp";
6745 case DW_FORM_udata: return "DW_FORM_udata";
6746 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
6747 case DW_FORM_ref1: return "DW_FORM_ref1";
6748 case DW_FORM_ref2: return "DW_FORM_ref2";
6749 case DW_FORM_ref4: return "DW_FORM_ref4";
6750 case DW_FORM_ref8: return "DW_FORM_ref8";
6751 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6752 case DW_FORM_indirect: return "DW_FORM_indirect";
6755 static char buffer [100];
6757 sprintf (buffer, _("Unknown FORM value: %lx"), form);
6763 /* FIXME: There are better and more effiecint ways to handle
6764 these structures. For now though, I just want something that
6765 is simple to implement. */
6766 typedef struct abbrev_attr
6768 unsigned long attribute;
6770 struct abbrev_attr * next;
6774 typedef struct abbrev_entry
6776 unsigned long entry;
6779 struct abbrev_attr * first_attr;
6780 struct abbrev_attr * last_attr;
6781 struct abbrev_entry * next;
6785 static abbrev_entry * first_abbrev = NULL;
6786 static abbrev_entry * last_abbrev = NULL;
6789 free_abbrevs PARAMS ((void))
6791 abbrev_entry * abbrev;
6793 for (abbrev = first_abbrev; abbrev;)
6795 abbrev_entry * next = abbrev->next;
6798 for (attr = abbrev->first_attr; attr;)
6800 abbrev_attr * next = attr->next;
6810 last_abbrev = first_abbrev = NULL;
6814 add_abbrev (number, tag, children)
6815 unsigned long number;
6819 abbrev_entry * entry;
6821 entry = (abbrev_entry *) malloc (sizeof (* entry));
6827 entry->entry = number;
6829 entry->children = children;
6830 entry->first_attr = NULL;
6831 entry->last_attr = NULL;
6834 if (first_abbrev == NULL)
6835 first_abbrev = entry;
6837 last_abbrev->next = entry;
6839 last_abbrev = entry;
6843 add_abbrev_attr (attribute, form)
6844 unsigned long attribute;
6849 attr = (abbrev_attr *) malloc (sizeof (* attr));
6855 attr->attribute = attribute;
6859 if (last_abbrev->first_attr == NULL)
6860 last_abbrev->first_attr = attr;
6862 last_abbrev->last_attr->next = attr;
6864 last_abbrev->last_attr = attr;
6867 /* Processes the (partial) contents of a .debug_abbrev section.
6868 Returns NULL if the end of the section was encountered.
6869 Returns the address after the last byte read if the end of
6870 an abbreviation set was found. */
6872 static unsigned char *
6873 process_abbrev_section (start, end)
6874 unsigned char * start;
6875 unsigned char * end;
6877 if (first_abbrev != NULL)
6883 unsigned long entry;
6885 unsigned long attribute;
6888 entry = read_leb128 (start, & bytes_read, 0);
6889 start += bytes_read;
6891 /* A single zero is supposed to end the section according
6892 to the standard. If there's more, then signal that to
6895 return start == end ? NULL : start;
6897 tag = read_leb128 (start, & bytes_read, 0);
6898 start += bytes_read;
6900 children = * start ++;
6902 add_abbrev (entry, tag, children);
6908 attribute = read_leb128 (start, & bytes_read, 0);
6909 start += bytes_read;
6911 form = read_leb128 (start, & bytes_read, 0);
6912 start += bytes_read;
6915 add_abbrev_attr (attribute, form);
6917 while (attribute != 0);
6925 display_debug_macinfo (section, start, file)
6926 Elf32_Internal_Shdr * section;
6927 unsigned char * start;
6928 FILE * file ATTRIBUTE_UNUSED;
6930 unsigned char * end = start + section->sh_size;
6931 unsigned char * curr = start;
6932 unsigned int bytes_read;
6933 enum dwarf_macinfo_record_type op;
6935 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6939 unsigned int lineno;
6940 const char * string;
6947 case DW_MACINFO_start_file:
6949 unsigned int filenum;
6951 lineno = read_leb128 (curr, & bytes_read, 0);
6953 filenum = read_leb128 (curr, & bytes_read, 0);
6956 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
6960 case DW_MACINFO_end_file:
6961 printf (_(" DW_MACINFO_end_file\n"));
6964 case DW_MACINFO_define:
6965 lineno = read_leb128 (curr, & bytes_read, 0);
6968 curr += strlen (string) + 1;
6969 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
6972 case DW_MACINFO_undef:
6973 lineno = read_leb128 (curr, & bytes_read, 0);
6976 curr += strlen (string) + 1;
6977 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
6980 case DW_MACINFO_vendor_ext:
6982 unsigned int constant;
6984 constant = read_leb128 (curr, & bytes_read, 0);
6987 curr += strlen (string) + 1;
6988 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
6999 display_debug_abbrev (section, start, file)
7000 Elf32_Internal_Shdr * section;
7001 unsigned char * start;
7002 FILE * file ATTRIBUTE_UNUSED;
7004 abbrev_entry * entry;
7005 unsigned char * end = start + section->sh_size;
7007 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7011 start = process_abbrev_section (start, end);
7013 if (first_abbrev == NULL)
7016 printf (_(" Number TAG\n"));
7018 for (entry = first_abbrev; entry; entry = entry->next)
7022 printf (_(" %ld %s [%s]\n"),
7024 get_TAG_name (entry->tag),
7025 entry->children ? _("has children") : _("no children"));
7027 for (attr = entry->first_attr; attr; attr = attr->next)
7029 printf (_(" %-18s %s\n"),
7030 get_AT_name (attr->attribute),
7031 get_FORM_name (attr->form));
7045 static unsigned char *
7046 display_block (data, length)
7047 unsigned char * data;
7048 unsigned long length;
7050 printf (_(" %lu byte block: "), length);
7053 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
7059 decode_location_expression (data, pointer_size, length)
7060 unsigned char * data;
7061 unsigned int pointer_size;
7062 unsigned long length;
7066 unsigned long uvalue;
7067 unsigned char * end = data + length;
7076 printf ("DW_OP_addr: %lx",
7077 (unsigned long) byte_get (data, pointer_size));
7078 data += pointer_size;
7081 printf ("DW_OP_deref");
7084 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
7087 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
7090 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
7094 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
7098 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
7102 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
7106 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
7107 (unsigned long) byte_get (data + 4, 4));
7111 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
7112 (long) byte_get (data + 4, 4));
7116 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
7120 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
7124 printf ("DW_OP_dup");
7127 printf ("DW_OP_drop");
7130 printf ("DW_OP_over");
7133 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
7136 printf ("DW_OP_swap");
7139 printf ("DW_OP_rot");
7142 printf ("DW_OP_xderef");
7145 printf ("DW_OP_abs");
7148 printf ("DW_OP_and");
7151 printf ("DW_OP_div");
7154 printf ("DW_OP_minus");
7157 printf ("DW_OP_mod");
7160 printf ("DW_OP_mul");
7163 printf ("DW_OP_neg");
7166 printf ("DW_OP_not");
7169 printf ("DW_OP_or");
7172 printf ("DW_OP_plus");
7174 case DW_OP_plus_uconst:
7175 printf ("DW_OP_plus_uconst: %lu",
7176 read_leb128 (data, &bytes_read, 0));
7180 printf ("DW_OP_shl");
7183 printf ("DW_OP_shr");
7186 printf ("DW_OP_shra");
7189 printf ("DW_OP_xor");
7192 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
7196 printf ("DW_OP_eq");
7199 printf ("DW_OP_ge");
7202 printf ("DW_OP_gt");
7205 printf ("DW_OP_le");
7208 printf ("DW_OP_lt");
7211 printf ("DW_OP_ne");
7214 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
7250 printf ("DW_OP_lit%d", op - DW_OP_lit0);
7285 printf ("DW_OP_reg%d", op - DW_OP_reg0);
7320 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
7321 read_leb128 (data, &bytes_read, 1));
7326 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
7330 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
7334 uvalue = read_leb128 (data, &bytes_read, 0);
7336 printf ("DW_OP_bregx: %lu %ld", uvalue,
7337 read_leb128 (data, &bytes_read, 1));
7341 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
7344 case DW_OP_deref_size:
7345 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
7347 case DW_OP_xderef_size:
7348 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
7351 printf ("DW_OP_nop");
7354 /* DWARF 2.1 extensions. */
7355 case DW_OP_push_object_address:
7356 printf ("DW_OP_push_object_address");
7359 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
7363 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
7367 printf ("DW_OP_calli");
7371 if (op >= DW_OP_lo_user
7372 && op <= DW_OP_hi_user)
7373 printf (_("(User defined location op)"));
7375 printf (_("(Unknown location op)"));
7376 /* No way to tell where the next op is, so just bail. */
7380 /* Separate the ops. */
7385 static const char * debug_loc_contents;
7386 static bfd_vma debug_loc_size;
7389 load_debug_loc (file)
7392 Elf32_Internal_Shdr * sec;
7395 /* If it is already loaded, do nothing. */
7396 if (debug_loc_contents != NULL)
7399 /* Locate the .debug_loc section. */
7400 for (i = 0, sec = section_headers;
7401 i < elf_header.e_shnum;
7403 if (strcmp (SECTION_NAME (sec), ".debug_loc") == 0)
7406 if (i == elf_header.e_shnum || sec->sh_size == 0)
7409 debug_loc_size = sec->sh_size;
7411 debug_loc_contents = ((char *)
7412 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7413 _("debug_loc section data")));
7419 if (debug_loc_contents == NULL)
7422 free ((char *) debug_loc_contents);
7423 debug_loc_contents = NULL;
7429 display_debug_loc (section, start, file)
7430 Elf32_Internal_Shdr * section;
7431 unsigned char * start;
7432 FILE * file ATTRIBUTE_UNUSED;
7434 unsigned char *section_end;
7435 unsigned long bytes;
7436 unsigned char *section_begin = start;
7439 addr = section->sh_addr;
7440 bytes = section->sh_size;
7441 section_end = start + bytes;
7444 printf (_("\nThe .debug_loc section is empty.\n"));
7447 printf (_("Contents of the .debug_loc section:\n\n"));
7448 printf (_("\n Offset Begin End Expression\n"));
7449 while (start < section_end)
7451 unsigned long begin;
7453 unsigned short length;
7454 unsigned long offset;
7456 offset = start - section_begin;
7460 /* Normally, the lists in the debug_loc section are related to a
7461 given compilation unit, and thus, we would use the
7462 pointer size of that compilation unit. However, since we are
7463 displaying it seperately here, we either have to store
7464 pointer sizes of all compilation units, or assume they don't
7465 change. We assume, like the debug_line display, that
7466 it doesn't change. */
7467 begin = byte_get (start, debug_line_pointer_size);
7468 start += debug_line_pointer_size;
7469 end = byte_get (start, debug_line_pointer_size);
7470 start += debug_line_pointer_size;
7472 if (begin == 0 && end == 0)
7478 length = byte_get (start, 2);
7481 printf (" %8.8lx %8.8lx %8.8lx (", offset, begin, end);
7482 decode_location_expression (start, debug_line_pointer_size, length);
7492 static const char * debug_str_contents;
7493 static bfd_vma debug_str_size;
7496 load_debug_str (file)
7499 Elf32_Internal_Shdr * sec;
7502 /* If it is already loaded, do nothing. */
7503 if (debug_str_contents != NULL)
7506 /* Locate the .debug_str section. */
7507 for (i = 0, sec = section_headers;
7508 i < elf_header.e_shnum;
7510 if (strcmp (SECTION_NAME (sec), ".debug_str") == 0)
7513 if (i == elf_header.e_shnum || sec->sh_size == 0)
7516 debug_str_size = sec->sh_size;
7518 debug_str_contents = ((char *)
7519 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7520 _("debug_str section data")));
7526 if (debug_str_contents == NULL)
7529 free ((char *) debug_str_contents);
7530 debug_str_contents = NULL;
7535 fetch_indirect_string (offset)
7536 unsigned long offset;
7538 if (debug_str_contents == NULL)
7539 return _("<no .debug_str section>");
7541 if (offset > debug_str_size)
7542 return _("<offset is too big>");
7544 return debug_str_contents + offset;
7549 display_debug_str (section, start, file)
7550 Elf32_Internal_Shdr * section;
7551 unsigned char * start;
7552 FILE * file ATTRIBUTE_UNUSED;
7554 unsigned long bytes;
7557 addr = section->sh_addr;
7558 bytes = section->sh_size;
7562 printf (_("\nThe .debug_str section is empty.\n"));
7566 printf (_("Contents of the .debug_str section:\n\n"));
7574 lbytes = (bytes > 16 ? 16 : bytes);
7576 printf (" 0x%8.8lx ", (unsigned long) addr);
7578 for (j = 0; j < 16; j++)
7581 printf ("%2.2x", start [j]);
7589 for (j = 0; j < lbytes; j++)
7592 if (k >= ' ' && k < 0x80)
7609 static unsigned char *
7610 read_and_display_attr_value (attribute, form, data, cu_offset, pointer_size)
7611 unsigned long attribute;
7613 unsigned char * data;
7614 unsigned long cu_offset;
7615 unsigned long pointer_size;
7617 unsigned long uvalue = 0;
7618 unsigned char * block_start = NULL;
7626 case DW_FORM_ref_addr:
7628 uvalue = byte_get (data, pointer_size);
7629 data += pointer_size;
7633 uvalue = byte_get (data, /* offset_size */ 4);
7634 data += /* offset_size */ 4;
7640 uvalue = byte_get (data ++, 1);
7645 uvalue = byte_get (data, 2);
7651 uvalue = byte_get (data, 4);
7656 uvalue = read_leb128 (data, & bytes_read, 1);
7660 case DW_FORM_ref_udata:
7662 uvalue = read_leb128 (data, & bytes_read, 0);
7666 case DW_FORM_indirect:
7667 form = read_leb128 (data, & bytes_read, 0);
7669 printf (" %s", get_FORM_name (form));
7670 return read_and_display_attr_value (attribute, form, data, cu_offset,
7676 case DW_FORM_ref_addr:
7677 printf (" <#%lx>", uvalue);
7683 case DW_FORM_ref_udata:
7684 printf (" <%lx>", uvalue + cu_offset);
7688 printf (" %#lx", uvalue);
7696 printf (" %ld", uvalue);
7701 uvalue = byte_get (data, 4);
7702 printf (" %lx", uvalue);
7703 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
7707 case DW_FORM_string:
7708 printf (" %s", data);
7709 data += strlen ((char *) data) + 1;
7713 uvalue = read_leb128 (data, & bytes_read, 0);
7714 block_start = data + bytes_read;
7715 data = display_block (block_start, uvalue);
7718 case DW_FORM_block1:
7719 uvalue = byte_get (data, 1);
7720 block_start = data + 1;
7721 data = display_block (block_start, uvalue);
7724 case DW_FORM_block2:
7725 uvalue = byte_get (data, 2);
7726 block_start = data + 2;
7727 data = display_block (block_start, uvalue);
7730 case DW_FORM_block4:
7731 uvalue = byte_get (data, 4);
7732 block_start = data + 4;
7733 data = display_block (block_start, uvalue);
7737 printf (_(" (indirect string, offset: 0x%lx): "), uvalue);
7738 printf (fetch_indirect_string (uvalue));
7741 case DW_FORM_indirect:
7742 /* Handled above. */
7746 warn (_("Unrecognized form: %d\n"), form);
7750 /* For some attributes we can display futher information. */
7759 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
7760 case DW_INL_inlined: printf (_("(inlined)")); break;
7761 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
7762 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
7763 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
7767 case DW_AT_language:
7770 case DW_LANG_C: printf ("(non-ANSI C)"); break;
7771 case DW_LANG_C89: printf ("(ANSI C)"); break;
7772 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
7773 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
7774 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
7775 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
7776 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
7777 case DW_LANG_Ada83: printf ("(Ada)"); break;
7778 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
7779 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
7780 /* DWARF 2.1 values. */
7781 case DW_LANG_C99: printf ("(ANSI C99)"); break;
7782 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
7783 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
7784 /* MIPS extension. */
7785 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7786 default: printf ("(Unknown: %lx)", uvalue); break;
7790 case DW_AT_encoding:
7793 case DW_ATE_void: printf ("(void)"); break;
7794 case DW_ATE_address: printf ("(machine address)"); break;
7795 case DW_ATE_boolean: printf ("(boolean)"); break;
7796 case DW_ATE_complex_float: printf ("(complex float)"); break;
7797 case DW_ATE_float: printf ("(float)"); break;
7798 case DW_ATE_signed: printf ("(signed)"); break;
7799 case DW_ATE_signed_char: printf ("(signed char)"); break;
7800 case DW_ATE_unsigned: printf ("(unsigned)"); break;
7801 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
7802 /* DWARF 2.1 value. */
7803 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7805 if (uvalue >= DW_ATE_lo_user
7806 && uvalue <= DW_ATE_hi_user)
7807 printf ("(user defined type)");
7809 printf ("(unknown type)");
7814 case DW_AT_accessibility:
7817 case DW_ACCESS_public: printf ("(public)"); break;
7818 case DW_ACCESS_protected: printf ("(protected)"); break;
7819 case DW_ACCESS_private: printf ("(private)"); break;
7820 default: printf ("(unknown accessibility)"); break;
7824 case DW_AT_visibility:
7827 case DW_VIS_local: printf ("(local)"); break;
7828 case DW_VIS_exported: printf ("(exported)"); break;
7829 case DW_VIS_qualified: printf ("(qualified)"); break;
7830 default: printf ("(unknown visibility)"); break;
7834 case DW_AT_virtuality:
7837 case DW_VIRTUALITY_none: printf ("(none)"); break;
7838 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
7839 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
7840 default: printf ("(unknown virtuality)"); break;
7844 case DW_AT_identifier_case:
7847 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
7848 case DW_ID_up_case: printf ("(up_case)"); break;
7849 case DW_ID_down_case: printf ("(down_case)"); break;
7850 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
7851 default: printf ("(unknown case)"); break;
7855 case DW_AT_calling_convention:
7858 case DW_CC_normal: printf ("(normal)"); break;
7859 case DW_CC_program: printf ("(program)"); break;
7860 case DW_CC_nocall: printf ("(nocall)"); break;
7862 if (uvalue >= DW_CC_lo_user
7863 && uvalue <= DW_CC_hi_user)
7864 printf ("(user defined)");
7866 printf ("(unknown convention)");
7870 case DW_AT_ordering:
7873 case -1: printf ("(undefined)"); break;
7874 case 0: printf ("(row major)"); break;
7875 case 1: printf ("(column major)"); break;
7879 case DW_AT_frame_base:
7880 case DW_AT_location:
7881 case DW_AT_data_member_location:
7882 case DW_AT_vtable_elem_location:
7883 case DW_AT_allocated:
7884 case DW_AT_associated:
7885 case DW_AT_data_location:
7887 case DW_AT_upper_bound:
7888 case DW_AT_lower_bound:
7892 decode_location_expression (block_start, pointer_size, uvalue);
7895 else if (form == DW_FORM_data4)
7898 printf ("location list");
7910 static unsigned char *
7911 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
7912 unsigned long attribute;
7914 unsigned char * data;
7915 unsigned long cu_offset;
7916 unsigned long pointer_size;
7918 printf (" %-18s:", get_AT_name (attribute));
7919 data = read_and_display_attr_value (attribute, form, data, cu_offset,
7926 display_debug_info (section, start, file)
7927 Elf32_Internal_Shdr * section;
7928 unsigned char * start;
7931 unsigned char * end = start + section->sh_size;
7932 unsigned char * section_begin = start;
7934 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7936 load_debug_str (file);
7937 load_debug_loc (file);
7941 DWARF2_External_CompUnit * external;
7942 DWARF2_Internal_CompUnit compunit;
7943 Elf32_Internal_Shdr * relsec;
7944 unsigned char * tags;
7947 unsigned long cu_offset;
7949 external = (DWARF2_External_CompUnit *) start;
7951 compunit.cu_length = BYTE_GET (external->cu_length);
7952 compunit.cu_version = BYTE_GET (external->cu_version);
7953 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
7954 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
7956 if (compunit.cu_length == 0xffffffff)
7958 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7962 /* Check for RELA relocations in the abbrev_offset address, and
7964 for (relsec = section_headers;
7965 relsec < section_headers + elf_header.e_shnum;
7968 unsigned long nrelas;
7969 Elf_Internal_Rela *rela, *rp;
7970 Elf32_Internal_Shdr *symsec;
7971 Elf_Internal_Sym *symtab;
7972 Elf_Internal_Sym *sym;
7974 if (relsec->sh_type != SHT_RELA
7975 || SECTION_HEADER (relsec->sh_info) != section)
7978 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7982 symsec = SECTION_HEADER (relsec->sh_link);
7983 symtab = GET_ELF_SYMBOLS (file, symsec);
7985 for (rp = rela; rp < rela + nrelas; ++rp)
7988 != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
7994 sym = symtab + ELF32_R_SYM (rp->r_info);
7996 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
7998 warn (_("Skipping unexpected symbol type %u\n"),
7999 ELF32_ST_TYPE (sym->st_info));
8005 sym = symtab + ELF64_R_SYM (rp->r_info);
8007 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
8009 warn (_("Skipping unexpected symbol type %u\n"),
8010 ELF64_ST_TYPE (sym->st_info));
8015 compunit.cu_abbrev_offset += rp->r_addend;
8023 tags = start + sizeof (* external);
8024 cu_offset = start - section_begin;
8025 start += compunit.cu_length + sizeof (external->cu_length);
8027 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
8028 printf (_(" Length: %ld\n"), compunit.cu_length);
8029 printf (_(" Version: %d\n"), compunit.cu_version);
8030 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
8031 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
8033 if (compunit.cu_version != 2)
8035 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8041 /* Read in the abbrevs used by this compilation unit. */
8044 Elf32_Internal_Shdr * sec;
8045 unsigned char * begin;
8047 /* Locate the .debug_abbrev section and process it. */
8048 for (i = 0, sec = section_headers;
8049 i < elf_header.e_shnum;
8051 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
8054 if (i == elf_header.e_shnum || sec->sh_size == 0)
8056 warn (_("Unable to locate .debug_abbrev section!\n"));
8060 begin = ((unsigned char *)
8061 get_data (NULL, file, sec->sh_offset, sec->sh_size,
8062 _("debug_abbrev section data")));
8066 process_abbrev_section (begin + compunit.cu_abbrev_offset,
8067 begin + sec->sh_size);
8073 while (tags < start)
8076 unsigned long abbrev_number;
8077 abbrev_entry * entry;
8080 abbrev_number = read_leb128 (tags, & bytes_read, 0);
8083 /* A null DIE marks the end of a list of children. */
8084 if (abbrev_number == 0)
8090 /* Scan through the abbreviation list until we reach the
8092 for (entry = first_abbrev;
8093 entry && entry->entry != abbrev_number;
8094 entry = entry->next)
8099 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8104 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8106 (unsigned long) (tags - section_begin - bytes_read),
8108 get_TAG_name (entry->tag));
8110 for (attr = entry->first_attr; attr; attr = attr->next)
8111 tags = read_and_display_attr (attr->attribute,
8114 compunit.cu_pointer_size);
8116 if (entry->children)
8130 display_debug_aranges (section, start, file)
8131 Elf32_Internal_Shdr * section;
8132 unsigned char * start;
8133 FILE * file ATTRIBUTE_UNUSED;
8135 unsigned char * end = start + section->sh_size;
8137 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8141 DWARF2_External_ARange * external;
8142 DWARF2_Internal_ARange arange;
8143 unsigned char * ranges;
8144 unsigned long length;
8145 unsigned long address;
8148 external = (DWARF2_External_ARange *) start;
8150 arange.ar_length = BYTE_GET (external->ar_length);
8151 arange.ar_version = BYTE_GET (external->ar_version);
8152 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
8153 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
8154 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
8156 if (arange.ar_length == 0xffffffff)
8158 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8162 if (arange.ar_version != 2)
8164 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8168 printf (_(" Length: %ld\n"), arange.ar_length);
8169 printf (_(" Version: %d\n"), arange.ar_version);
8170 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
8171 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
8172 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
8174 printf (_("\n Address Length\n"));
8176 ranges = start + sizeof (* external);
8178 /* Must pad to an alignment boundary that is twice the pointer size. */
8179 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
8181 ranges += (2 * arange.ar_pointer_size) - excess;
8185 address = byte_get (ranges, arange.ar_pointer_size);
8187 ranges += arange.ar_pointer_size;
8189 length = byte_get (ranges, arange.ar_pointer_size);
8191 ranges += arange.ar_pointer_size;
8193 /* A pair of zeros marks the end of the list. */
8194 if (address == 0 && length == 0)
8197 printf (" %8.8lx %lu\n", address, length);
8200 start += arange.ar_length + sizeof (external->ar_length);
8208 typedef struct Frame_Chunk
8210 struct Frame_Chunk * next;
8211 unsigned char * chunk_start;
8213 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8214 short int * col_type;
8216 char * augmentation;
8217 unsigned int code_factor;
8219 unsigned long pc_begin;
8220 unsigned long pc_range;
8224 unsigned char fde_encoding;
8228 /* A marker for a col_type that means this column was never referenced
8229 in the frame info. */
8230 #define DW_CFA_unreferenced (-1)
8232 static void frame_need_space PARAMS ((Frame_Chunk *, int));
8233 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
8234 static int size_of_encoded_value PARAMS ((int));
8237 frame_need_space (fc, reg)
8241 int prev = fc->ncols;
8243 if (reg < fc->ncols)
8246 fc->ncols = reg + 1;
8247 fc->col_type = (short int *) xrealloc (fc->col_type,
8248 fc->ncols * sizeof (short int));
8249 fc->col_offset = (int *) xrealloc (fc->col_offset,
8250 fc->ncols * sizeof (int));
8252 while (prev < fc->ncols)
8254 fc->col_type[prev] = DW_CFA_unreferenced;
8255 fc->col_offset[prev] = 0;
8261 frame_display_row (fc, need_col_headers, max_regs)
8263 int * need_col_headers;
8269 if (* max_regs < fc->ncols)
8270 * max_regs = fc->ncols;
8272 if (* need_col_headers)
8274 * need_col_headers = 0;
8276 printf (" LOC CFA ");
8278 for (r = 0; r < * max_regs; r++)
8279 if (fc->col_type[r] != DW_CFA_unreferenced)
8284 printf ("r%-4d", r);
8290 printf ("%08lx ", fc->pc_begin);
8291 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
8292 printf ("%-8s ", tmp);
8294 for (r = 0; r < fc->ncols; r++)
8296 if (fc->col_type[r] != DW_CFA_unreferenced)
8298 switch (fc->col_type[r])
8300 case DW_CFA_undefined:
8303 case DW_CFA_same_value:
8307 sprintf (tmp, "c%+d", fc->col_offset[r]);
8309 case DW_CFA_register:
8310 sprintf (tmp, "r%d", fc->col_offset[r]);
8313 strcpy (tmp, "n/a");
8316 printf ("%-5s", tmp);
8323 size_of_encoded_value (encoding)
8326 switch (encoding & 0x7)
8329 case 0: return is_32bit_elf ? 4 : 8;
8336 #define GET(N) byte_get (start, N); start += N
8337 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8338 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8341 display_debug_frames (section, start, file)
8342 Elf32_Internal_Shdr * section;
8343 unsigned char * start;
8344 FILE * file ATTRIBUTE_UNUSED;
8346 unsigned char * end = start + section->sh_size;
8347 unsigned char * section_start = start;
8348 Frame_Chunk * chunks = 0;
8349 Frame_Chunk * remembered_state = 0;
8351 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
8354 int addr_size = is_32bit_elf ? 4 : 8;
8356 printf (_("The section %s contains:\n"), SECTION_NAME (section));
8360 unsigned char * saved_start;
8361 unsigned char * block_end;
8362 unsigned long length;
8363 unsigned long cie_id;
8366 int need_col_headers = 1;
8367 unsigned char * augmentation_data = NULL;
8368 unsigned long augmentation_data_len = 0;
8369 int encoded_ptr_size = addr_size;
8371 saved_start = start;
8372 length = byte_get (start, 4); start += 4;
8377 if (length == 0xffffffff)
8379 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8383 block_end = saved_start + length + 4;
8384 cie_id = byte_get (start, 4); start += 4;
8386 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
8390 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8391 memset (fc, 0, sizeof (Frame_Chunk));
8395 fc->chunk_start = saved_start;
8397 fc->col_type = (short int *) xmalloc (sizeof (short int));
8398 fc->col_offset = (int *) xmalloc (sizeof (int));
8399 frame_need_space (fc, max_regs-1);
8403 fc->augmentation = start;
8404 start = strchr (start, '\0') + 1;
8406 if (fc->augmentation[0] == 'z')
8408 fc->code_factor = LEB ();
8409 fc->data_factor = SLEB ();
8410 fc->ra = byte_get (start, 1); start += 1;
8411 augmentation_data_len = LEB ();
8412 augmentation_data = start;
8413 start += augmentation_data_len;
8415 else if (strcmp (fc->augmentation, "eh") == 0)
8418 fc->code_factor = LEB ();
8419 fc->data_factor = SLEB ();
8420 fc->ra = byte_get (start, 1); start += 1;
8424 fc->code_factor = LEB ();
8425 fc->data_factor = SLEB ();
8426 fc->ra = byte_get (start, 1); start += 1;
8430 if (do_debug_frames_interp)
8431 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8432 (unsigned long)(saved_start - section_start), length, cie_id,
8433 fc->augmentation, fc->code_factor, fc->data_factor,
8437 printf ("\n%08lx %08lx %08lx CIE\n",
8438 (unsigned long)(saved_start - section_start), length, cie_id);
8439 printf (" Version: %d\n", version);
8440 printf (" Augmentation: \"%s\"\n", fc->augmentation);
8441 printf (" Code alignment factor: %u\n", fc->code_factor);
8442 printf (" Data alignment factor: %d\n", fc->data_factor);
8443 printf (" Return address column: %d\n", fc->ra);
8445 if (augmentation_data_len)
8448 printf (" Augmentation data: ");
8449 for (i = 0; i < augmentation_data_len; ++i)
8450 printf (" %02x", augmentation_data[i]);
8456 if (augmentation_data_len)
8458 unsigned char *p, *q;
8459 p = fc->augmentation + 1;
8460 q = augmentation_data;
8467 q += 1 + size_of_encoded_value (*q);
8469 fc->fde_encoding = *q++;
8475 if (fc->fde_encoding)
8476 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8479 frame_need_space (fc, fc->ra);
8483 unsigned char * look_for;
8484 static Frame_Chunk fde_fc;
8487 memset (fc, 0, sizeof (Frame_Chunk));
8489 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
8491 for (cie = chunks; cie ; cie = cie->next)
8492 if (cie->chunk_start == look_for)
8497 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8498 cie_id, saved_start);
8501 fc->col_type = (short int *) xmalloc (sizeof (short int));
8502 fc->col_offset = (int *) xmalloc (sizeof (int));
8503 frame_need_space (fc, max_regs - 1);
8505 fc->augmentation = "";
8506 fc->fde_encoding = 0;
8510 fc->ncols = cie->ncols;
8511 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
8512 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
8513 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
8514 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
8515 fc->augmentation = cie->augmentation;
8516 fc->code_factor = cie->code_factor;
8517 fc->data_factor = cie->data_factor;
8518 fc->cfa_reg = cie->cfa_reg;
8519 fc->cfa_offset = cie->cfa_offset;
8521 frame_need_space (fc, max_regs-1);
8522 fc->fde_encoding = cie->fde_encoding;
8525 if (fc->fde_encoding)
8526 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8528 fc->pc_begin = byte_get (start, encoded_ptr_size);
8529 start += encoded_ptr_size;
8530 fc->pc_range = byte_get (start, encoded_ptr_size);
8531 start += encoded_ptr_size;
8533 if (cie->augmentation[0] == 'z')
8535 augmentation_data_len = LEB ();
8536 augmentation_data = start;
8537 start += augmentation_data_len;
8540 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8541 (unsigned long)(saved_start - section_start), length, cie_id,
8542 (unsigned long)(cie->chunk_start - section_start),
8543 fc->pc_begin, fc->pc_begin + fc->pc_range);
8544 if (! do_debug_frames_interp && augmentation_data_len)
8547 printf (" Augmentation data: ");
8548 for (i = 0; i < augmentation_data_len; ++i)
8549 printf (" %02x", augmentation_data[i]);
8555 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8556 about to interpret instructions for the chunk. */
8558 if (do_debug_frames_interp)
8560 /* Start by making a pass over the chunk, allocating storage
8561 and taking note of what registers are used. */
8562 unsigned char * tmp = start;
8564 while (start < block_end)
8574 /* Warning: if you add any more cases to this switch, be
8575 sure to add them to the corresponding switch below. */
8578 case DW_CFA_advance_loc:
8582 frame_need_space (fc, opa);
8583 fc->col_type[opa] = DW_CFA_undefined;
8585 case DW_CFA_restore:
8586 frame_need_space (fc, opa);
8587 fc->col_type[opa] = DW_CFA_undefined;
8589 case DW_CFA_set_loc:
8590 start += encoded_ptr_size;
8592 case DW_CFA_advance_loc1:
8595 case DW_CFA_advance_loc2:
8598 case DW_CFA_advance_loc4:
8601 case DW_CFA_offset_extended:
8602 reg = LEB (); LEB ();
8603 frame_need_space (fc, reg);
8604 fc->col_type[reg] = DW_CFA_undefined;
8606 case DW_CFA_restore_extended:
8608 frame_need_space (fc, reg);
8609 fc->col_type[reg] = DW_CFA_undefined;
8611 case DW_CFA_undefined:
8613 frame_need_space (fc, reg);
8614 fc->col_type[reg] = DW_CFA_undefined;
8616 case DW_CFA_same_value:
8618 frame_need_space (fc, reg);
8619 fc->col_type[reg] = DW_CFA_undefined;
8621 case DW_CFA_register:
8622 reg = LEB (); LEB ();
8623 frame_need_space (fc, reg);
8624 fc->col_type[reg] = DW_CFA_undefined;
8626 case DW_CFA_def_cfa:
8629 case DW_CFA_def_cfa_register:
8632 case DW_CFA_def_cfa_offset:
8635 case DW_CFA_offset_extended_sf:
8636 reg = LEB (); SLEB ();
8637 frame_need_space (fc, reg);
8638 fc->col_type[reg] = DW_CFA_undefined;
8640 case DW_CFA_def_cfa_sf:
8643 case DW_CFA_def_cfa_offset_sf:
8646 case DW_CFA_GNU_args_size:
8649 case DW_CFA_GNU_negative_offset_extended:
8650 reg = LEB (); LEB ();
8651 frame_need_space (fc, reg);
8652 fc->col_type[reg] = DW_CFA_undefined;
8661 /* Now we know what registers are used, make a second pass over
8662 the chunk, this time actually printing out the info. */
8664 while (start < block_end)
8667 unsigned long ul, reg, roffs;
8676 /* Warning: if you add any more cases to this switch, be
8677 sure to add them to the corresponding switch above. */
8680 case DW_CFA_advance_loc:
8681 if (do_debug_frames_interp)
8682 frame_display_row (fc, &need_col_headers, &max_regs);
8684 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8685 opa * fc->code_factor,
8686 fc->pc_begin + opa * fc->code_factor);
8687 fc->pc_begin += opa * fc->code_factor;
8692 if (! do_debug_frames_interp)
8693 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8694 opa, roffs * fc->data_factor);
8695 fc->col_type[opa] = DW_CFA_offset;
8696 fc->col_offset[opa] = roffs * fc->data_factor;
8699 case DW_CFA_restore:
8700 if (! do_debug_frames_interp)
8701 printf (" DW_CFA_restore: r%d\n", opa);
8702 fc->col_type[opa] = cie->col_type[opa];
8703 fc->col_offset[opa] = cie->col_offset[opa];
8706 case DW_CFA_set_loc:
8707 vma = byte_get (start, encoded_ptr_size);
8708 start += encoded_ptr_size;
8709 if (do_debug_frames_interp)
8710 frame_display_row (fc, &need_col_headers, &max_regs);
8712 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
8716 case DW_CFA_advance_loc1:
8717 ofs = byte_get (start, 1); start += 1;
8718 if (do_debug_frames_interp)
8719 frame_display_row (fc, &need_col_headers, &max_regs);
8721 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8722 ofs * fc->code_factor,
8723 fc->pc_begin + ofs * fc->code_factor);
8724 fc->pc_begin += ofs * fc->code_factor;
8727 case DW_CFA_advance_loc2:
8728 ofs = byte_get (start, 2); start += 2;
8729 if (do_debug_frames_interp)
8730 frame_display_row (fc, &need_col_headers, &max_regs);
8732 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8733 ofs * fc->code_factor,
8734 fc->pc_begin + ofs * fc->code_factor);
8735 fc->pc_begin += ofs * fc->code_factor;
8738 case DW_CFA_advance_loc4:
8739 ofs = byte_get (start, 4); start += 4;
8740 if (do_debug_frames_interp)
8741 frame_display_row (fc, &need_col_headers, &max_regs);
8743 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8744 ofs * fc->code_factor,
8745 fc->pc_begin + ofs * fc->code_factor);
8746 fc->pc_begin += ofs * fc->code_factor;
8749 case DW_CFA_offset_extended:
8752 if (! do_debug_frames_interp)
8753 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8754 reg, roffs * fc->data_factor);
8755 fc->col_type[reg] = DW_CFA_offset;
8756 fc->col_offset[reg] = roffs * fc->data_factor;
8759 case DW_CFA_restore_extended:
8761 if (! do_debug_frames_interp)
8762 printf (" DW_CFA_restore_extended: r%ld\n", reg);
8763 fc->col_type[reg] = cie->col_type[reg];
8764 fc->col_offset[reg] = cie->col_offset[reg];
8767 case DW_CFA_undefined:
8769 if (! do_debug_frames_interp)
8770 printf (" DW_CFA_undefined: r%ld\n", reg);
8771 fc->col_type[reg] = DW_CFA_undefined;
8772 fc->col_offset[reg] = 0;
8775 case DW_CFA_same_value:
8777 if (! do_debug_frames_interp)
8778 printf (" DW_CFA_same_value: r%ld\n", reg);
8779 fc->col_type[reg] = DW_CFA_same_value;
8780 fc->col_offset[reg] = 0;
8783 case DW_CFA_register:
8786 if (! do_debug_frames_interp)
8787 printf (" DW_CFA_register: r%ld\n", reg);
8788 fc->col_type[reg] = DW_CFA_register;
8789 fc->col_offset[reg] = roffs;
8792 case DW_CFA_remember_state:
8793 if (! do_debug_frames_interp)
8794 printf (" DW_CFA_remember_state\n");
8795 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8796 rs->ncols = fc->ncols;
8797 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8798 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8799 memcpy (rs->col_type, fc->col_type, rs->ncols);
8800 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8801 rs->next = remembered_state;
8802 remembered_state = rs;
8805 case DW_CFA_restore_state:
8806 if (! do_debug_frames_interp)
8807 printf (" DW_CFA_restore_state\n");
8808 rs = remembered_state;
8809 remembered_state = rs->next;
8810 frame_need_space (fc, rs->ncols-1);
8811 memcpy (fc->col_type, rs->col_type, rs->ncols);
8812 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8813 free (rs->col_type);
8814 free (rs->col_offset);
8818 case DW_CFA_def_cfa:
8819 fc->cfa_reg = LEB ();
8820 fc->cfa_offset = LEB ();
8821 if (! do_debug_frames_interp)
8822 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8823 fc->cfa_reg, fc->cfa_offset);
8826 case DW_CFA_def_cfa_register:
8827 fc->cfa_reg = LEB ();
8828 if (! do_debug_frames_interp)
8829 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
8832 case DW_CFA_def_cfa_offset:
8833 fc->cfa_offset = LEB ();
8834 if (! do_debug_frames_interp)
8835 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
8839 if (! do_debug_frames_interp)
8840 printf (" DW_CFA_nop\n");
8843 case DW_CFA_offset_extended_sf:
8846 frame_need_space (fc, reg);
8847 if (! do_debug_frames_interp)
8848 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8849 reg, l * fc->data_factor);
8850 fc->col_type[reg] = DW_CFA_offset;
8851 fc->col_offset[reg] = l * fc->data_factor;
8854 case DW_CFA_def_cfa_sf:
8855 fc->cfa_reg = LEB ();
8856 fc->cfa_offset = SLEB ();
8857 if (! do_debug_frames_interp)
8858 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8859 fc->cfa_reg, fc->cfa_offset);
8862 case DW_CFA_def_cfa_offset_sf:
8863 fc->cfa_offset = SLEB ();
8864 if (! do_debug_frames_interp)
8865 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
8868 case DW_CFA_GNU_window_save:
8869 if (! do_debug_frames_interp)
8870 printf (" DW_CFA_GNU_window_save\n");
8873 case DW_CFA_GNU_args_size:
8875 if (! do_debug_frames_interp)
8876 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
8879 case DW_CFA_GNU_negative_offset_extended:
8882 frame_need_space (fc, reg);
8883 if (! do_debug_frames_interp)
8884 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8885 reg, l * fc->data_factor);
8886 fc->col_type[reg] = DW_CFA_offset;
8887 fc->col_offset[reg] = l * fc->data_factor;
8890 /* FIXME: How do we handle these? */
8891 case DW_CFA_def_cfa_expression:
8892 fprintf (stderr, "unsupported DW_CFA_def_cfa_expression\n");
8896 case DW_CFA_expression:
8897 fprintf (stderr, "unsupported DW_CFA_expression\n");
8902 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
8907 if (do_debug_frames_interp)
8908 frame_display_row (fc, &need_col_headers, &max_regs);
8923 display_debug_not_supported (section, start, file)
8924 Elf32_Internal_Shdr * section;
8925 unsigned char * start ATTRIBUTE_UNUSED;
8926 FILE * file ATTRIBUTE_UNUSED;
8928 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8929 SECTION_NAME (section));
8934 /* Pre-scan the .debug_info section to record the size of address.
8935 When dumping the .debug_line, we use that size information, assuming
8936 that all compilation units have the same address size. */
8938 prescan_debug_info (section, start, file)
8939 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
8940 unsigned char * start;
8941 FILE * file ATTRIBUTE_UNUSED;
8943 DWARF2_External_CompUnit * external;
8945 external = (DWARF2_External_CompUnit *) start;
8947 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
8951 /* A structure containing the name of a debug section and a pointer
8952 to a function that can decode it. The third field is a prescan
8953 function to be run over the section before displaying any of the
8957 const char * const name;
8958 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8959 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8963 { ".debug_abbrev", display_debug_abbrev, NULL },
8964 { ".debug_aranges", display_debug_aranges, NULL },
8965 { ".debug_frame", display_debug_frames, NULL },
8966 { ".debug_info", display_debug_info, prescan_debug_info },
8967 { ".debug_line", display_debug_lines, NULL },
8968 { ".debug_pubnames", display_debug_pubnames, NULL },
8969 { ".eh_frame", display_debug_frames, NULL },
8970 { ".debug_macinfo", display_debug_macinfo, NULL },
8971 { ".debug_str", display_debug_str, NULL },
8972 { ".debug_loc", display_debug_loc, NULL },
8973 { ".debug_pubtypes", display_debug_not_supported, NULL },
8974 { ".debug_ranges", display_debug_not_supported, NULL },
8975 { ".debug_static_func", display_debug_not_supported, NULL },
8976 { ".debug_static_vars", display_debug_not_supported, NULL },
8977 { ".debug_types", display_debug_not_supported, NULL },
8978 { ".debug_weaknames", display_debug_not_supported, NULL }
8982 display_debug_section (section, file)
8983 Elf32_Internal_Shdr * section;
8986 char * name = SECTION_NAME (section);
8987 bfd_size_type length;
8988 unsigned char * start;
8991 length = section->sh_size;
8994 printf (_("\nSection '%s' has no debugging data.\n"), name);
8998 start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
8999 _("debug section data"));
9003 /* See if we know how to display the contents of this section. */
9004 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
9005 name = ".debug_info";
9007 for (i = NUM_ELEM (debug_displays); i--;)
9008 if (strcmp (debug_displays[i].name, name) == 0)
9010 debug_displays[i].display (section, start, file);
9015 printf (_("Unrecognized debug section: %s\n"), name);
9019 /* If we loaded in the abbrev section at some point,
9020 we must release it here. */
9027 process_section_contents (file)
9030 Elf32_Internal_Shdr * section;
9036 /* Pre-scan the debug sections to find some debug information not
9037 present in some of them. For the .debug_line, we must find out the
9038 size of address (specified in .debug_info and .debug_aranges). */
9039 for (i = 0, section = section_headers;
9040 i < elf_header.e_shnum && i < num_dump_sects;
9043 char * name = SECTION_NAME (section);
9046 if (section->sh_size == 0)
9049 /* See if there is some pre-scan operation for this section. */
9050 for (j = NUM_ELEM (debug_displays); j--;)
9051 if (strcmp (debug_displays[j].name, name) == 0)
9053 if (debug_displays[j].prescan != NULL)
9055 bfd_size_type length;
9056 unsigned char * start;
9058 length = section->sh_size;
9059 start = ((unsigned char *)
9060 get_data (NULL, file, section->sh_offset, length,
9061 _("debug section data")));
9065 debug_displays[j].prescan (section, start, file);
9073 for (i = 0, section = section_headers;
9074 i < elf_header.e_shnum && i < num_dump_sects;
9077 #ifdef SUPPORT_DISASSEMBLY
9078 if (dump_sects[i] & DISASS_DUMP)
9079 disassemble_section (section, file);
9081 if (dump_sects[i] & HEX_DUMP)
9082 dump_section (section, file);
9084 if (dump_sects[i] & DEBUG_DUMP)
9085 display_debug_section (section, file);
9088 if (i < num_dump_sects)
9089 warn (_("Some sections were not dumped because they do not exist!\n"));
9095 process_mips_fpe_exception (mask)
9101 if (mask & OEX_FPU_INEX)
9102 fputs ("INEX", stdout), first = 0;
9103 if (mask & OEX_FPU_UFLO)
9104 printf ("%sUFLO", first ? "" : "|"), first = 0;
9105 if (mask & OEX_FPU_OFLO)
9106 printf ("%sOFLO", first ? "" : "|"), first = 0;
9107 if (mask & OEX_FPU_DIV0)
9108 printf ("%sDIV0", first ? "" : "|"), first = 0;
9109 if (mask & OEX_FPU_INVAL)
9110 printf ("%sINVAL", first ? "" : "|");
9113 fputs ("0", stdout);
9117 process_mips_specific (file)
9120 Elf_Internal_Dyn * entry;
9121 size_t liblist_offset = 0;
9122 size_t liblistno = 0;
9123 size_t conflictsno = 0;
9124 size_t options_offset = 0;
9125 size_t conflicts_offset = 0;
9127 /* We have a lot of special sections. Thanks SGI! */
9128 if (dynamic_segment == NULL)
9129 /* No information available. */
9132 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
9133 switch (entry->d_tag)
9135 case DT_MIPS_LIBLIST:
9136 liblist_offset = entry->d_un.d_val - loadaddr;
9138 case DT_MIPS_LIBLISTNO:
9139 liblistno = entry->d_un.d_val;
9141 case DT_MIPS_OPTIONS:
9142 options_offset = entry->d_un.d_val - loadaddr;
9144 case DT_MIPS_CONFLICT:
9145 conflicts_offset = entry->d_un.d_val - loadaddr;
9147 case DT_MIPS_CONFLICTNO:
9148 conflictsno = entry->d_un.d_val;
9154 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9156 Elf32_External_Lib * elib;
9159 elib = ((Elf32_External_Lib *)
9160 get_data (NULL, file, liblist_offset,
9161 liblistno * sizeof (Elf32_External_Lib),
9165 printf ("\nSection '.liblist' contains %lu entries:\n",
9166 (unsigned long) liblistno);
9167 fputs (" Library Time Stamp Checksum Version Flags\n",
9170 for (cnt = 0; cnt < liblistno; ++cnt)
9177 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9178 time = BYTE_GET (elib[cnt].l_time_stamp);
9179 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9180 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9181 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9183 tmp = gmtime (&time);
9184 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9185 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9186 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9188 printf ("%3lu: ", (unsigned long) cnt);
9189 print_symbol (20, dynamic_strings + liblist.l_name);
9190 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9193 if (liblist.l_flags == 0)
9204 { " EXACT_MATCH", LL_EXACT_MATCH },
9205 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9206 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9207 { " EXPORTS", LL_EXPORTS },
9208 { " DELAY_LOAD", LL_DELAY_LOAD },
9209 { " DELTA", LL_DELTA }
9211 int flags = liblist.l_flags;
9215 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
9217 if ((flags & l_flags_vals[fcnt].bit) != 0)
9219 fputs (l_flags_vals[fcnt].name, stdout);
9220 flags ^= l_flags_vals[fcnt].bit;
9223 printf (" %#x", (unsigned int) flags);
9233 if (options_offset != 0)
9235 Elf_External_Options * eopt;
9236 Elf_Internal_Shdr * sect = section_headers;
9237 Elf_Internal_Options * iopt;
9238 Elf_Internal_Options * option;
9242 /* Find the section header so that we get the size. */
9243 while (sect->sh_type != SHT_MIPS_OPTIONS)
9246 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
9247 sect->sh_size, _("options"));
9250 iopt = ((Elf_Internal_Options *)
9251 malloc ((sect->sh_size / sizeof (eopt)) * sizeof (* iopt)));
9254 error (_("Out of memory"));
9261 while (offset < sect->sh_size)
9263 Elf_External_Options * eoption;
9265 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9267 option->kind = BYTE_GET (eoption->kind);
9268 option->size = BYTE_GET (eoption->size);
9269 option->section = BYTE_GET (eoption->section);
9270 option->info = BYTE_GET (eoption->info);
9272 offset += option->size;
9278 printf (_("\nSection '%s' contains %d entries:\n"),
9279 SECTION_NAME (sect), cnt);
9287 switch (option->kind)
9290 /* This shouldn't happen. */
9291 printf (" NULL %d %lx", option->section, option->info);
9294 printf (" REGINFO ");
9295 if (elf_header.e_machine == EM_MIPS)
9298 Elf32_External_RegInfo * ereg;
9299 Elf32_RegInfo reginfo;
9301 ereg = (Elf32_External_RegInfo *) (option + 1);
9302 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9303 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9304 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9305 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9306 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9307 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9309 printf ("GPR %08lx GP 0x%lx\n",
9311 (unsigned long) reginfo.ri_gp_value);
9312 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9313 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9314 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9319 Elf64_External_RegInfo * ereg;
9320 Elf64_Internal_RegInfo reginfo;
9322 ereg = (Elf64_External_RegInfo *) (option + 1);
9323 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9324 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9325 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9326 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9327 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9328 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
9330 printf ("GPR %08lx GP 0x",
9331 reginfo.ri_gprmask);
9332 printf_vma (reginfo.ri_gp_value);
9335 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9336 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9337 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9341 case ODK_EXCEPTIONS:
9342 fputs (" EXCEPTIONS fpe_min(", stdout);
9343 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9344 fputs (") fpe_max(", stdout);
9345 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9346 fputs (")", stdout);
9348 if (option->info & OEX_PAGE0)
9349 fputs (" PAGE0", stdout);
9350 if (option->info & OEX_SMM)
9351 fputs (" SMM", stdout);
9352 if (option->info & OEX_FPDBUG)
9353 fputs (" FPDBUG", stdout);
9354 if (option->info & OEX_DISMISS)
9355 fputs (" DISMISS", stdout);
9358 fputs (" PAD ", stdout);
9359 if (option->info & OPAD_PREFIX)
9360 fputs (" PREFIX", stdout);
9361 if (option->info & OPAD_POSTFIX)
9362 fputs (" POSTFIX", stdout);
9363 if (option->info & OPAD_SYMBOL)
9364 fputs (" SYMBOL", stdout);
9367 fputs (" HWPATCH ", stdout);
9368 if (option->info & OHW_R4KEOP)
9369 fputs (" R4KEOP", stdout);
9370 if (option->info & OHW_R8KPFETCH)
9371 fputs (" R8KPFETCH", stdout);
9372 if (option->info & OHW_R5KEOP)
9373 fputs (" R5KEOP", stdout);
9374 if (option->info & OHW_R5KCVTL)
9375 fputs (" R5KCVTL", stdout);
9378 fputs (" FILL ", stdout);
9379 /* XXX Print content of info word? */
9382 fputs (" TAGS ", stdout);
9383 /* XXX Print content of info word? */
9386 fputs (" HWAND ", stdout);
9387 if (option->info & OHWA0_R4KEOP_CHECKED)
9388 fputs (" R4KEOP_CHECKED", stdout);
9389 if (option->info & OHWA0_R4KEOP_CLEAN)
9390 fputs (" R4KEOP_CLEAN", stdout);
9393 fputs (" HWOR ", stdout);
9394 if (option->info & OHWA0_R4KEOP_CHECKED)
9395 fputs (" R4KEOP_CHECKED", stdout);
9396 if (option->info & OHWA0_R4KEOP_CLEAN)
9397 fputs (" R4KEOP_CLEAN", stdout);
9400 printf (" GP_GROUP %#06lx self-contained %#06lx",
9401 option->info & OGP_GROUP,
9402 (option->info & OGP_SELF) >> 16);
9405 printf (" IDENT %#06lx self-contained %#06lx",
9406 option->info & OGP_GROUP,
9407 (option->info & OGP_SELF) >> 16);
9410 /* This shouldn't happen. */
9411 printf (" %3d ??? %d %lx",
9412 option->kind, option->section, option->info);
9416 len = sizeof (* eopt);
9417 while (len < option->size)
9418 if (((char *) option)[len] >= ' '
9419 && ((char *) option)[len] < 0x7f)
9420 printf ("%c", ((char *) option)[len++]);
9422 printf ("\\%03o", ((char *) option)[len++]);
9424 fputs ("\n", stdout);
9432 if (conflicts_offset != 0 && conflictsno != 0)
9434 Elf32_Conflict * iconf;
9437 if (dynamic_symbols == NULL)
9439 error (_("conflict list found without a dynamic symbol table"));
9443 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
9446 error (_("Out of memory"));
9452 Elf32_External_Conflict * econf32;
9454 econf32 = ((Elf32_External_Conflict *)
9455 get_data (NULL, file, conflicts_offset,
9456 conflictsno * sizeof (* econf32),
9461 for (cnt = 0; cnt < conflictsno; ++cnt)
9462 iconf[cnt] = BYTE_GET (econf32[cnt]);
9468 Elf64_External_Conflict * econf64;
9470 econf64 = ((Elf64_External_Conflict *)
9471 get_data (NULL, file, conflicts_offset,
9472 conflictsno * sizeof (* econf64),
9477 for (cnt = 0; cnt < conflictsno; ++cnt)
9478 iconf[cnt] = BYTE_GET (econf64[cnt]);
9483 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9484 (long) conflictsno);
9485 puts (_(" Num: Index Value Name"));
9487 for (cnt = 0; cnt < conflictsno; ++cnt)
9489 Elf_Internal_Sym * psym = & dynamic_symbols [iconf [cnt]];
9491 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf [cnt]);
9492 print_vma (psym->st_value, FULL_HEX);
9494 print_symbol (25, dynamic_strings + psym->st_name);
9505 process_gnu_liblist (file)
9508 Elf_Internal_Shdr * section, * string_sec;
9509 Elf32_External_Lib * elib;
9517 for (i = 0, section = section_headers;
9518 i < elf_header.e_shnum;
9521 switch (section->sh_type)
9523 case SHT_GNU_LIBLIST:
9524 elib = ((Elf32_External_Lib *)
9525 get_data (NULL, file, section->sh_offset, section->sh_size,
9530 string_sec = SECTION_HEADER (section->sh_link);
9532 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9533 string_sec->sh_size,
9534 _("liblist string table"));
9537 || section->sh_entsize != sizeof (Elf32_External_Lib))
9543 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9544 SECTION_NAME (section),
9545 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9547 puts (" Library Time Stamp Checksum Version Flags");
9549 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9557 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9558 time = BYTE_GET (elib[cnt].l_time_stamp);
9559 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9560 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9561 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9563 tmp = gmtime (&time);
9564 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9565 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9566 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9568 printf ("%3lu: ", (unsigned long) cnt);
9570 printf ("%-20s", strtab + liblist.l_name);
9572 printf ("%-20.20s", strtab + liblist.l_name);
9573 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9574 liblist.l_version, liblist.l_flags);
9585 get_note_type (e_type)
9588 static char buff[64];
9592 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
9593 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
9594 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
9595 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
9596 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
9597 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
9598 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
9599 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
9600 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9601 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9602 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9604 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9610 get_netbsd_elfcore_note_type (e_type)
9613 static char buff[64];
9615 if (e_type == NT_NETBSDCORE_PROCINFO)
9617 /* NetBSD core "procinfo" structure. */
9618 return _("NetBSD procinfo structure");
9621 /* As of Jan 2002 there are no other machine-independent notes
9622 defined for NetBSD core files. If the note type is less
9623 than the start of the machine-dependent note types, we don't
9626 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9628 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9632 switch (elf_header.e_machine)
9634 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9635 and PT_GETFPREGS == mach+2. */
9640 case EM_SPARC32PLUS:
9644 case NT_NETBSDCORE_FIRSTMACH+0:
9645 return _("PT_GETREGS (reg structure)");
9646 case NT_NETBSDCORE_FIRSTMACH+2:
9647 return _("PT_GETFPREGS (fpreg structure)");
9653 /* On all other arch's, PT_GETREGS == mach+1 and
9654 PT_GETFPREGS == mach+3. */
9658 case NT_NETBSDCORE_FIRSTMACH+1:
9659 return _("PT_GETREGS (reg structure)");
9660 case NT_NETBSDCORE_FIRSTMACH+3:
9661 return _("PT_GETFPREGS (fpreg structure)");
9667 sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
9671 /* Note that by the ELF standard, the name field is already null byte
9672 terminated, and namesz includes the terminating null byte.
9673 I.E. the value of namesz for the name "FSF" is 4.
9675 If the value of namesz is zero, there is no name present. */
9677 process_note (pnote)
9678 Elf32_Internal_Note * pnote;
9682 if (pnote->namesz == 0)
9684 /* If there is no note name, then use the default set of
9685 note type strings. */
9686 nt = get_note_type (pnote->type);
9688 else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
9690 /* NetBSD-specific core file notes. */
9691 nt = get_netbsd_elfcore_note_type (pnote->type);
9695 /* Don't recognize this note name; just use the default set of
9696 note type strings. */
9697 nt = get_note_type (pnote->type);
9700 printf (" %s\t\t0x%08lx\t%s\n",
9701 pnote->namesz ? pnote->namedata : "(NONE)",
9708 process_corefile_note_segment (file, offset, length)
9713 Elf_External_Note * pnotes;
9714 Elf_External_Note * external;
9720 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
9727 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9728 (unsigned long) offset, (unsigned long) length);
9729 printf (_(" Owner\t\tData size\tDescription\n"));
9731 while (external < (Elf_External_Note *)((char *) pnotes + length))
9733 Elf_External_Note * next;
9734 Elf32_Internal_Note inote;
9737 inote.type = BYTE_GET (external->type);
9738 inote.namesz = BYTE_GET (external->namesz);
9739 inote.namedata = external->name;
9740 inote.descsz = BYTE_GET (external->descsz);
9741 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9742 inote.descpos = offset + (inote.descdata - (char *) pnotes);
9744 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9746 if (((char *) next) > (((char *) pnotes) + length))
9748 warn (_("corrupt note found at offset %x into core notes\n"),
9749 ((char *) external) - ((char *) pnotes));
9750 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9751 inote.type, inote.namesz, inote.descsz);
9757 /* Verify that name is null terminated. It appears that at least
9758 one version of Linux (RedHat 6.0) generates corefiles that don't
9759 comply with the ELF spec by failing to include the null byte in
9761 if (inote.namedata[inote.namesz] != '\0')
9763 temp = malloc (inote.namesz + 1);
9767 error (_("Out of memory\n"));
9772 strncpy (temp, inote.namedata, inote.namesz);
9773 temp[inote.namesz] = 0;
9775 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9776 inote.namedata = temp;
9779 res &= process_note (& inote);
9794 process_corefile_note_segments (file)
9797 Elf_Internal_Phdr * program_headers;
9798 Elf_Internal_Phdr * segment;
9802 program_headers = (Elf_Internal_Phdr *) malloc
9803 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
9805 if (program_headers == NULL)
9807 error (_("Out of memory\n"));
9812 i = get_32bit_program_headers (file, program_headers);
9814 i = get_64bit_program_headers (file, program_headers);
9818 free (program_headers);
9822 for (i = 0, segment = program_headers;
9823 i < elf_header.e_phnum;
9826 if (segment->p_type == PT_NOTE)
9827 res &= process_corefile_note_segment (file,
9828 (bfd_vma) segment->p_offset,
9829 (bfd_vma) segment->p_filesz);
9832 free (program_headers);
9838 process_corefile_contents (file)
9841 /* If we have not been asked to display the notes then do nothing. */
9845 /* If file is not a core file then exit. */
9846 if (elf_header.e_type != ET_CORE)
9849 /* No program headers means no NOTE segment. */
9850 if (elf_header.e_phnum == 0)
9852 printf (_("No note segments present in the core file.\n"));
9856 return process_corefile_note_segments (file);
9860 process_arch_specific (file)
9866 switch (elf_header.e_machine)
9869 case EM_MIPS_RS3_LE:
9870 return process_mips_specific (file);
9879 get_file_header (file)
9882 /* Read in the identity array. */
9883 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
9886 /* Determine how to read the rest of the header. */
9887 switch (elf_header.e_ident [EI_DATA])
9889 default: /* fall through */
9890 case ELFDATANONE: /* fall through */
9891 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
9892 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
9895 /* For now we only support 32 bit and 64 bit ELF files. */
9896 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
9898 /* Read in the rest of the header. */
9901 Elf32_External_Ehdr ehdr32;
9903 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
9906 elf_header.e_type = BYTE_GET (ehdr32.e_type);
9907 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
9908 elf_header.e_version = BYTE_GET (ehdr32.e_version);
9909 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
9910 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
9911 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
9912 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
9913 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
9914 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
9915 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
9916 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
9917 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
9918 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
9922 Elf64_External_Ehdr ehdr64;
9924 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9925 we will not be able to cope with the 64bit data found in
9926 64 ELF files. Detect this now and abort before we start
9927 overwritting things. */
9928 if (sizeof (bfd_vma) < 8)
9930 error (_("This instance of readelf has been built without support for a\n\
9931 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9935 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
9938 elf_header.e_type = BYTE_GET (ehdr64.e_type);
9939 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
9940 elf_header.e_version = BYTE_GET (ehdr64.e_version);
9941 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
9942 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
9943 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
9944 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
9945 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
9946 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
9947 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
9948 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
9949 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
9950 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
9953 if (elf_header.e_shoff)
9955 /* There may be some extensions in the first section header. Don't
9956 bomb if we can't read it. */
9958 get_32bit_section_headers (file, 1);
9960 get_64bit_section_headers (file, 1);
9967 process_file (file_name)
9971 struct stat statbuf;
9974 if (stat (file_name, & statbuf) < 0)
9976 error (_("Cannot stat input file %s.\n"), file_name);
9980 file = fopen (file_name, "rb");
9983 error (_("Input file %s not found.\n"), file_name);
9987 if (! get_file_header (file))
9989 error (_("%s: Failed to read file header\n"), file_name);
9994 /* Initialise per file variables. */
9995 for (i = NUM_ELEM (version_info); i--;)
9996 version_info[i] = 0;
9998 for (i = NUM_ELEM (dynamic_info); i--;)
9999 dynamic_info[i] = 0;
10001 /* Process the file. */
10003 printf (_("\nFile: %s\n"), file_name);
10005 if (! process_file_header ())
10011 process_section_headers (file);
10013 process_program_headers (file);
10015 process_dynamic_segment (file);
10017 process_relocs (file);
10019 process_unwind (file);
10021 process_symbol_table (file);
10023 process_syminfo (file);
10025 process_version_sections (file);
10027 process_section_contents (file);
10029 process_corefile_contents (file);
10031 process_gnu_liblist (file);
10033 process_arch_specific (file);
10037 if (section_headers)
10039 free (section_headers);
10040 section_headers = NULL;
10045 free (string_table);
10046 string_table = NULL;
10047 string_table_length = 0;
10050 if (dynamic_strings)
10052 free (dynamic_strings);
10053 dynamic_strings = NULL;
10056 if (dynamic_symbols)
10058 free (dynamic_symbols);
10059 dynamic_symbols = NULL;
10060 num_dynamic_syms = 0;
10063 if (dynamic_syminfo)
10065 free (dynamic_syminfo);
10066 dynamic_syminfo = NULL;
10072 #ifdef SUPPORT_DISASSEMBLY
10073 /* Needed by the i386 disassembler. For extra credit, someone could
10074 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10078 print_address (unsigned int addr, FILE * outfile)
10080 fprintf (outfile,"0x%8.8x", addr);
10083 /* Needed by the i386 disassembler. */
10085 db_task_printsym (unsigned int addr)
10087 print_address (addr, stderr);
10091 int main PARAMS ((int, char **));
10100 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10101 setlocale (LC_MESSAGES, "");
10103 #if defined (HAVE_SETLOCALE)
10104 setlocale (LC_CTYPE, "");
10106 bindtextdomain (PACKAGE, LOCALEDIR);
10107 textdomain (PACKAGE);
10109 parse_args (argc, argv);
10111 if (optind < (argc - 1))
10115 while (optind < argc)
10116 err |= process_file (argv [optind ++]);
10118 if (dump_sects != NULL)