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"
71 #include "elf/m68hc11.h"
72 #include "elf/mcore.h"
75 #include "elf/mn10200.h"
76 #include "elf/mn10300.h"
82 #include "elf/sparc.h"
85 #include "elf/x86-64.h"
86 #include "elf/xstormy16.h"
91 char * program_name = "readelf";
92 unsigned int dynamic_addr;
93 bfd_size_type dynamic_size;
94 unsigned int rela_addr;
95 unsigned int rela_size;
96 char * dynamic_strings;
98 unsigned long string_table_length;
99 unsigned long num_dynamic_syms;
100 Elf_Internal_Sym * dynamic_symbols;
101 Elf_Internal_Syminfo * dynamic_syminfo;
102 unsigned long dynamic_syminfo_offset;
103 unsigned int dynamic_syminfo_nent;
104 char program_interpreter [64];
105 int dynamic_info[DT_JMPREL + 1];
106 int version_info[16];
108 Elf_Internal_Ehdr elf_header;
109 Elf_Internal_Shdr * section_headers;
110 Elf_Internal_Dyn * dynamic_segment;
111 Elf_Internal_Shdr * symtab_shndx_hdr;
119 int do_using_dynamic;
127 int do_debug_abbrevs;
129 int do_debug_pubnames;
130 int do_debug_aranges;
132 int do_debug_frames_interp;
133 int do_debug_macinfo;
140 /* A dynamic array of flags indicating which sections require dumping. */
141 char * dump_sects = NULL;
142 unsigned int num_dump_sects = 0;
144 #define HEX_DUMP (1 << 0)
145 #define DISASS_DUMP (1 << 1)
146 #define DEBUG_DUMP (1 << 2)
148 /* How to rpint a vma value. */
149 typedef enum print_mode
161 /* Forward declarations for dumb compilers. */
162 static void print_vma PARAMS ((bfd_vma, print_mode));
163 static void print_symbol PARAMS ((int, char *));
164 static bfd_vma (* byte_get) PARAMS ((unsigned char *, int));
165 static bfd_vma byte_get_little_endian PARAMS ((unsigned char *, int));
166 static bfd_vma byte_get_big_endian PARAMS ((unsigned char *, int));
167 static const char * get_mips_dynamic_type PARAMS ((unsigned long));
168 static const char * get_sparc64_dynamic_type PARAMS ((unsigned long));
169 static const char * get_ppc64_dynamic_type PARAMS ((unsigned long));
170 static const char * get_parisc_dynamic_type PARAMS ((unsigned long));
171 static const char * get_dynamic_type PARAMS ((unsigned long));
172 static int slurp_rela_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **, unsigned long *));
173 static int slurp_rel_relocs PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel **, unsigned long *));
174 static int dump_relocations PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *, unsigned long, char *, int));
175 static char * get_file_type PARAMS ((unsigned));
176 static char * get_machine_name PARAMS ((unsigned));
177 static void decode_ARM_machine_flags PARAMS ((unsigned, char []));
178 static char * get_machine_flags PARAMS ((unsigned, unsigned));
179 static const char * get_mips_segment_type PARAMS ((unsigned long));
180 static const char * get_parisc_segment_type PARAMS ((unsigned long));
181 static const char * get_ia64_segment_type PARAMS ((unsigned long));
182 static const char * get_segment_type PARAMS ((unsigned long));
183 static const char * get_mips_section_type_name PARAMS ((unsigned int));
184 static const char * get_parisc_section_type_name PARAMS ((unsigned int));
185 static const char * get_ia64_section_type_name PARAMS ((unsigned int));
186 static const char * get_section_type_name PARAMS ((unsigned int));
187 static const char * get_symbol_binding PARAMS ((unsigned int));
188 static const char * get_symbol_type PARAMS ((unsigned int));
189 static const char * get_symbol_visibility PARAMS ((unsigned int));
190 static const char * get_symbol_index_type PARAMS ((unsigned int));
191 static const char * get_dynamic_flags PARAMS ((bfd_vma));
192 static void usage PARAMS ((void));
193 static void parse_args PARAMS ((int, char **));
194 static int process_file_header PARAMS ((void));
195 static int process_program_headers PARAMS ((FILE *));
196 static int process_section_headers PARAMS ((FILE *));
197 static int process_unwind PARAMS ((FILE *));
198 static void dynamic_segment_mips_val PARAMS ((Elf_Internal_Dyn *));
199 static void dynamic_segment_parisc_val PARAMS ((Elf_Internal_Dyn *));
200 static int process_dynamic_segment PARAMS ((FILE *));
201 static int process_symbol_table PARAMS ((FILE *));
202 static int process_syminfo PARAMS ((FILE *));
203 static int process_section_contents PARAMS ((FILE *));
204 static void process_mips_fpe_exception PARAMS ((int));
205 static int process_mips_specific PARAMS ((FILE *));
206 static int process_file PARAMS ((char *));
207 static int process_relocs PARAMS ((FILE *));
208 static int process_version_sections PARAMS ((FILE *));
209 static char * get_ver_flags PARAMS ((unsigned int));
210 static int get_32bit_section_headers PARAMS ((FILE *, unsigned int));
211 static int get_64bit_section_headers PARAMS ((FILE *, unsigned int));
212 static int get_32bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
213 static int get_64bit_program_headers PARAMS ((FILE *, Elf_Internal_Phdr *));
214 static int get_file_header PARAMS ((FILE *));
215 static Elf_Internal_Sym * get_32bit_elf_symbols PARAMS ((FILE *, Elf_Internal_Shdr *));
216 static Elf_Internal_Sym * get_64bit_elf_symbols PARAMS ((FILE *, Elf_Internal_Shdr *));
217 static const char * get_elf_section_flags PARAMS ((bfd_vma));
218 static int * get_dynamic_data PARAMS ((FILE *, unsigned int));
219 static int get_32bit_dynamic_segment PARAMS ((FILE *));
220 static int get_64bit_dynamic_segment PARAMS ((FILE *));
221 #ifdef SUPPORT_DISASSEMBLY
222 static int disassemble_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
224 static int dump_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
225 static int display_debug_section PARAMS ((Elf32_Internal_Shdr *, FILE *));
226 static int display_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
227 static int display_debug_not_supported PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
228 static int prescan_debug_info PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
229 static int display_debug_lines PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
230 static int display_debug_pubnames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
231 static int display_debug_abbrev PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
232 static int display_debug_aranges PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
233 static int display_debug_frames PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
234 static int display_debug_macinfo PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
235 static int display_debug_str PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
236 static int display_debug_loc PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
237 static unsigned char * process_abbrev_section PARAMS ((unsigned char *, unsigned char *));
238 static void load_debug_str PARAMS ((FILE *));
239 static void free_debug_str PARAMS ((void));
240 static const char * fetch_indirect_string PARAMS ((unsigned long));
241 static void load_debug_loc PARAMS ((FILE *));
242 static void free_debug_loc PARAMS ((void));
243 static unsigned long read_leb128 PARAMS ((unsigned char *, int *, int));
244 static int process_extended_line_op PARAMS ((unsigned char *, int, int));
245 static void reset_state_machine PARAMS ((int));
246 static char * get_TAG_name PARAMS ((unsigned long));
247 static char * get_AT_name PARAMS ((unsigned long));
248 static char * get_FORM_name PARAMS ((unsigned long));
249 static void free_abbrevs PARAMS ((void));
250 static void add_abbrev PARAMS ((unsigned long, unsigned long, int));
251 static void add_abbrev_attr PARAMS ((unsigned long, unsigned long));
252 static unsigned char * read_and_display_attr PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
253 static unsigned char * read_and_display_attr_value PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
254 static unsigned char * display_block PARAMS ((unsigned char *, unsigned long));
255 static void decode_location_expression PARAMS ((unsigned char *, unsigned int, unsigned long));
256 static void request_dump PARAMS ((unsigned int, int));
257 static const char * get_elf_class PARAMS ((unsigned int));
258 static const char * get_data_encoding PARAMS ((unsigned int));
259 static const char * get_osabi_name PARAMS ((unsigned int));
260 static int guess_is_rela PARAMS ((unsigned long));
261 static const char * get_note_type PARAMS ((unsigned int));
262 static const char * get_netbsd_elfcore_note_type PARAMS ((unsigned int));
263 static int process_note PARAMS ((Elf32_Internal_Note *));
264 static int process_corefile_note_segment PARAMS ((FILE *, bfd_vma, bfd_vma));
265 static int process_corefile_note_segments PARAMS ((FILE *));
266 static int process_corefile_contents PARAMS ((FILE *));
267 static int process_arch_specific PARAMS ((FILE *));
268 static int process_gnu_liblist PARAMS ((FILE *));
270 typedef int Elf32_Word;
278 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
279 ((X)->sh_name >= string_table_length \
280 ? "<corrupt>" : string_table + (X)->sh_name))
282 /* Given st_shndx I, map to section_headers index. */
283 #define SECTION_HEADER_INDEX(I) \
284 ((I) < SHN_LORESERVE \
286 : ((I) <= SHN_HIRESERVE \
288 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
290 /* Reverse of the above. */
291 #define SECTION_HEADER_NUM(N) \
292 ((N) < SHN_LORESERVE \
294 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
296 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
298 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
300 #define BYTE_GET(field) byte_get (field, sizeof (field))
302 /* If we can support a 64 bit data type then BFD64 should be defined
303 and sizeof (bfd_vma) == 8. In this case when translating from an
304 external 8 byte field to an internal field, we can assume that the
305 internal field is also 8 bytes wide and so we can extract all the data.
306 If, however, BFD64 is not defined, then we must assume that the
307 internal data structure only has 4 byte wide fields that are the
308 equivalent of the 8 byte wide external counterparts, and so we must
309 truncate the data. */
311 #define BYTE_GET8(field) byte_get (field, -8)
313 #define BYTE_GET8(field) byte_get (field, 8)
316 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
318 #define GET_ELF_SYMBOLS(file, section) \
319 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
320 : get_64bit_elf_symbols (file, section))
324 error VPARAMS ((const char *message, ...))
326 VA_OPEN (args, message);
327 VA_FIXEDARG (args, const char *, message);
329 fprintf (stderr, _("%s: Error: "), program_name);
330 vfprintf (stderr, message, args);
335 warn VPARAMS ((const char *message, ...))
337 VA_OPEN (args, message);
338 VA_FIXEDARG (args, const char *, message);
340 fprintf (stderr, _("%s: Warning: "), program_name);
341 vfprintf (stderr, message, args);
345 static PTR get_data PARAMS ((PTR, FILE *, long, size_t, const char *));
348 get_data (var, file, offset, size, reason)
360 if (fseek (file, offset, SEEK_SET))
362 error (_("Unable to seek to %x for %s\n"), offset, reason);
369 mvar = (PTR) malloc (size);
373 error (_("Out of memory allocating %d bytes for %s\n"),
379 if (fread (mvar, size, 1, file) != 1)
381 error (_("Unable to read in %d bytes of %s\n"), size, reason);
391 byte_get_little_endian (field, size)
392 unsigned char * field;
401 return ((unsigned int) (field [0]))
402 | (((unsigned int) (field [1])) << 8);
406 /* We want to extract data from an 8 byte wide field and
407 place it into a 4 byte wide field. Since this is a little
408 endian source we can juts use the 4 byte extraction code. */
412 return ((unsigned long) (field [0]))
413 | (((unsigned long) (field [1])) << 8)
414 | (((unsigned long) (field [2])) << 16)
415 | (((unsigned long) (field [3])) << 24);
420 /* This is a special case, generated by the BYTE_GET8 macro.
421 It means that we are loading an 8 byte value from a field
422 in an external structure into an 8 byte value in a field
423 in an internal strcuture. */
424 return ((bfd_vma) (field [0]))
425 | (((bfd_vma) (field [1])) << 8)
426 | (((bfd_vma) (field [2])) << 16)
427 | (((bfd_vma) (field [3])) << 24)
428 | (((bfd_vma) (field [4])) << 32)
429 | (((bfd_vma) (field [5])) << 40)
430 | (((bfd_vma) (field [6])) << 48)
431 | (((bfd_vma) (field [7])) << 56);
434 error (_("Unhandled data length: %d\n"), size);
439 /* Print a VMA value. */
441 print_vma (vma, mode)
451 case FULL_HEX: printf ("0x"); /* drop through */
452 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
453 case PREFIX_HEX: printf ("0x"); /* drop through */
454 case HEX: printf ("%lx", (unsigned long) vma); break;
455 case DEC: printf ("%ld", (unsigned long) vma); break;
456 case DEC_5: printf ("%5ld", (long) vma); break;
457 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
478 #if BFD_HOST_64BIT_LONG
481 if (_bfd_int64_high (vma))
482 printf ("%lx%8.8lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
484 printf ("%lx", _bfd_int64_low (vma));
489 #if BFD_HOST_64BIT_LONG
492 if (_bfd_int64_high (vma))
494 printf ("++%ld", _bfd_int64_low (vma));
496 printf ("%ld", _bfd_int64_low (vma));
501 #if BFD_HOST_64BIT_LONG
502 printf ("%5ld", vma);
504 if (_bfd_int64_high (vma))
506 printf ("++%ld", _bfd_int64_low (vma));
508 printf ("%5ld", _bfd_int64_low (vma));
513 #if BFD_HOST_64BIT_LONG
516 if (_bfd_int64_high (vma))
518 printf ("++%lu", _bfd_int64_low (vma));
520 printf ("%lu", _bfd_int64_low (vma));
528 /* Display a symbol on stdout. If do_wide is not true then
529 format the symbol to be at most WIDTH characters,
530 truncating as necessary. If WIDTH is negative then
531 format the string to be exactly - WIDTH characters,
532 truncating or padding as necessary. */
535 print_symbol (width, symbol)
542 printf ("%-*.*s", width, width, symbol);
544 printf ("%-.*s", width, symbol);
548 byte_get_big_endian (field, size)
549 unsigned char * field;
558 return ((unsigned int) (field [1])) | (((int) (field [0])) << 8);
561 return ((unsigned long) (field [3]))
562 | (((unsigned long) (field [2])) << 8)
563 | (((unsigned long) (field [1])) << 16)
564 | (((unsigned long) (field [0])) << 24);
568 /* Although we are extracing data from an 8 byte wide field, we
569 are returning only 4 bytes of data. */
570 return ((unsigned long) (field [7]))
571 | (((unsigned long) (field [6])) << 8)
572 | (((unsigned long) (field [5])) << 16)
573 | (((unsigned long) (field [4])) << 24);
577 /* This is a special case, generated by the BYTE_GET8 macro.
578 It means that we are loading an 8 byte value from a field
579 in an external structure into an 8 byte value in a field
580 in an internal strcuture. */
581 return ((bfd_vma) (field [7]))
582 | (((bfd_vma) (field [6])) << 8)
583 | (((bfd_vma) (field [5])) << 16)
584 | (((bfd_vma) (field [4])) << 24)
585 | (((bfd_vma) (field [3])) << 32)
586 | (((bfd_vma) (field [2])) << 40)
587 | (((bfd_vma) (field [1])) << 48)
588 | (((bfd_vma) (field [0])) << 56);
592 error (_("Unhandled data length: %d\n"), size);
597 /* Guess the relocation size commonly used by the specific machines. */
600 guess_is_rela (e_machine)
601 unsigned long e_machine;
605 /* Targets that use REL relocations. */
621 /* Targets that use RELA relocations. */
636 case EM_CYGNUS_MN10200:
638 case EM_CYGNUS_MN10300:
678 warn (_("Don't know about relocations on this machine architecture\n"));
684 slurp_rela_relocs (file, rel_offset, rel_size, relasp, nrelasp)
686 unsigned long rel_offset;
687 unsigned long rel_size;
688 Elf_Internal_Rela **relasp;
689 unsigned long *nrelasp;
691 Elf_Internal_Rela *relas;
692 unsigned long nrelas;
697 Elf32_External_Rela * erelas;
699 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset,
700 rel_size, _("relocs"));
704 nrelas = rel_size / sizeof (Elf32_External_Rela);
706 relas = (Elf_Internal_Rela *)
707 malloc (nrelas * sizeof (Elf_Internal_Rela));
711 error(_("out of memory parsing relocs"));
715 for (i = 0; i < nrelas; i++)
717 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
718 relas[i].r_info = BYTE_GET (erelas[i].r_info);
719 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
726 Elf64_External_Rela * erelas;
728 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset,
729 rel_size, _("relocs"));
733 nrelas = rel_size / sizeof (Elf64_External_Rela);
735 relas = (Elf_Internal_Rela *)
736 malloc (nrelas * sizeof (Elf_Internal_Rela));
740 error(_("out of memory parsing relocs"));
744 for (i = 0; i < nrelas; i++)
746 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
747 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
748 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
759 slurp_rel_relocs (file, rel_offset, rel_size, relsp, nrelsp)
761 unsigned long rel_offset;
762 unsigned long rel_size;
763 Elf_Internal_Rel **relsp;
764 unsigned long *nrelsp;
766 Elf_Internal_Rel *rels;
772 Elf32_External_Rel * erels;
774 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset,
775 rel_size, _("relocs"));
779 nrels = rel_size / sizeof (Elf32_External_Rel);
781 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
785 error(_("out of memory parsing relocs"));
789 for (i = 0; i < nrels; i++)
791 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
792 rels[i].r_info = BYTE_GET (erels[i].r_info);
799 Elf64_External_Rel * erels;
801 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset,
802 rel_size, _("relocs"));
806 nrels = rel_size / sizeof (Elf64_External_Rel);
808 rels = (Elf_Internal_Rel *) malloc (nrels * sizeof (Elf_Internal_Rel));
812 error(_("out of memory parsing relocs"));
816 for (i = 0; i < nrels; i++)
818 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
819 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
829 /* Display the contents of the relocation data found at the specified offset. */
831 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
833 unsigned long rel_offset;
834 unsigned long rel_size;
835 Elf_Internal_Sym * symtab;
841 Elf_Internal_Rel * rels;
842 Elf_Internal_Rela * relas;
845 if (is_rela == UNKNOWN)
846 is_rela = guess_is_rela (elf_header.e_machine);
850 if (!slurp_rela_relocs (file, rel_offset, rel_size, &relas, &rel_size))
855 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
864 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
866 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
871 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
873 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
881 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
883 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
888 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
890 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
894 for (i = 0; i < rel_size; i++)
897 const char * rtype2 = NULL;
898 const char * rtype3 = NULL;
901 bfd_vma symtab_index;
903 bfd_vma type2 = (bfd_vma) NULL;
904 bfd_vma type3 = (bfd_vma) NULL;
908 offset = relas [i].r_offset;
909 info = relas [i].r_info;
913 offset = rels [i].r_offset;
914 info = rels [i].r_info;
919 type = ELF32_R_TYPE (info);
920 symtab_index = ELF32_R_SYM (info);
924 if (elf_header.e_machine == EM_MIPS)
926 type = ELF64_MIPS_R_TYPE (info);
927 type2 = ELF64_MIPS_R_TYPE2 (info);
928 type3 = ELF64_MIPS_R_TYPE3 (info);
930 else if (elf_header.e_machine == EM_SPARCV9)
931 type = ELF64_R_TYPE_ID (info);
933 type = ELF64_R_TYPE (info);
934 /* The #ifdef BFD64 below is to prevent a compile time warning.
935 We know that if we do not have a 64 bit data type that we
936 will never execute this code anyway. */
938 symtab_index = ELF64_R_SYM (info);
944 #ifdef _bfd_int64_low
945 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
947 printf ("%8.8lx %8.8lx ", offset, info);
952 #ifdef _bfd_int64_low
954 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
955 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
956 _bfd_int64_high (offset),
957 _bfd_int64_low (offset),
958 _bfd_int64_high (info),
959 _bfd_int64_low (info));
962 ? "%16.16lx %16.16lx "
963 : "%12.12lx %12.12lx ",
968 switch (elf_header.e_machine)
976 rtype = elf_m32r_reloc_type (type);
981 rtype = elf_i386_reloc_type (type);
986 rtype = elf_m68hc11_reloc_type (type);
990 rtype = elf_m68k_reloc_type (type);
994 rtype = elf_i960_reloc_type (type);
999 rtype = elf_avr_reloc_type (type);
1002 case EM_OLD_SPARCV9:
1003 case EM_SPARC32PLUS:
1006 rtype = elf_sparc_reloc_type (type);
1010 case EM_CYGNUS_V850:
1011 rtype = v850_reloc_type (type);
1015 case EM_CYGNUS_D10V:
1016 rtype = elf_d10v_reloc_type (type);
1020 case EM_CYGNUS_D30V:
1021 rtype = elf_d30v_reloc_type (type);
1025 rtype = elf_dlx_reloc_type (type);
1029 rtype = elf_sh_reloc_type (type);
1033 case EM_CYGNUS_MN10300:
1034 rtype = elf_mn10300_reloc_type (type);
1038 case EM_CYGNUS_MN10200:
1039 rtype = elf_mn10200_reloc_type (type);
1043 case EM_CYGNUS_FR30:
1044 rtype = elf_fr30_reloc_type (type);
1048 rtype = elf_frv_reloc_type (type);
1052 rtype = elf_mcore_reloc_type (type);
1056 rtype = elf_mmix_reloc_type (type);
1061 rtype = elf_ppc_reloc_type (type);
1065 case EM_MIPS_RS3_LE:
1066 rtype = elf_mips_reloc_type (type);
1069 rtype2 = elf_mips_reloc_type (type2);
1070 rtype3 = elf_mips_reloc_type (type3);
1075 rtype = elf_alpha_reloc_type (type);
1079 rtype = elf_arm_reloc_type (type);
1083 rtype = elf_arc_reloc_type (type);
1087 rtype = elf_hppa_reloc_type (type);
1093 rtype = elf_h8_reloc_type (type);
1098 rtype = elf_or32_reloc_type (type);
1103 rtype = elf_pj_reloc_type (type);
1106 rtype = elf_ia64_reloc_type (type);
1110 rtype = elf_cris_reloc_type (type);
1114 rtype = elf_i860_reloc_type (type);
1118 rtype = elf_x86_64_reloc_type (type);
1123 rtype = elf_s390_reloc_type (type);
1127 rtype = elf_xstormy16_reloc_type (type);
1131 rtype = elf_vax_reloc_type (type);
1136 rtype = elf_ip2k_reloc_type (type);
1141 #ifdef _bfd_int64_low
1142 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1144 printf (_("unrecognized: %-7lx"), type);
1147 printf (do_wide ? "%-21.21s" : "%-17.17s", rtype);
1151 if (symtab == NULL || symtab_index >= nsyms)
1152 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1155 Elf_Internal_Sym * psym;
1157 psym = symtab + symtab_index;
1160 print_vma (psym->st_value, LONG_HEX);
1161 printf (is_32bit_elf ? " " : " ");
1163 if (psym->st_name == 0)
1164 print_symbol (22, SECTION_NAME (section_headers + psym->st_shndx));
1165 else if (strtab == NULL)
1166 printf (_("<string table index %3ld>"), psym->st_name);
1168 print_symbol (22, strtab + psym->st_name);
1171 printf (" + %lx", (unsigned long) relas [i].r_addend);
1176 printf ("%*c", is_32bit_elf ? (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1177 print_vma (relas[i].r_addend, LONG_HEX);
1180 if (elf_header.e_machine == EM_SPARCV9
1181 && !strcmp (rtype, "R_SPARC_OLO10"))
1182 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1186 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1188 printf (" Type2: ");
1191 #ifdef _bfd_int64_low
1192 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1194 printf (_("unrecognized: %-7lx"), type2);
1197 printf ("%-17.17s", rtype2);
1199 printf("\n Type3: ");
1202 #ifdef _bfd_int64_low
1203 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1205 printf (_("unrecognized: %-7lx"), type3);
1208 printf ("%-17.17s", rtype3);
1223 get_mips_dynamic_type (type)
1228 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1229 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1230 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1231 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1232 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1233 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1234 case DT_MIPS_MSYM: return "MIPS_MSYM";
1235 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1236 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1237 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1238 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1239 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1240 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1241 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1242 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1243 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1244 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1245 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1246 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1247 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1248 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1249 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1250 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1251 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1252 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1253 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1254 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1255 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1256 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1257 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1258 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1259 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1260 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1261 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1262 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1263 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1264 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1265 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1266 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1267 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1268 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1269 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1270 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1277 get_sparc64_dynamic_type (type)
1282 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1289 get_ppc64_dynamic_type (type)
1294 case DT_PPC64_GLINK: return "PPC64_GLINK";
1295 case DT_PPC64_OPD: return "PPC64_OPD";
1296 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1303 get_parisc_dynamic_type (type)
1308 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1309 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1310 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1311 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1312 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1313 case DT_HP_PREINIT: return "HP_PREINIT";
1314 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1315 case DT_HP_NEEDED: return "HP_NEEDED";
1316 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1317 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1318 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1319 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1320 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1327 get_dynamic_type (type)
1330 static char buff [32];
1334 case DT_NULL: return "NULL";
1335 case DT_NEEDED: return "NEEDED";
1336 case DT_PLTRELSZ: return "PLTRELSZ";
1337 case DT_PLTGOT: return "PLTGOT";
1338 case DT_HASH: return "HASH";
1339 case DT_STRTAB: return "STRTAB";
1340 case DT_SYMTAB: return "SYMTAB";
1341 case DT_RELA: return "RELA";
1342 case DT_RELASZ: return "RELASZ";
1343 case DT_RELAENT: return "RELAENT";
1344 case DT_STRSZ: return "STRSZ";
1345 case DT_SYMENT: return "SYMENT";
1346 case DT_INIT: return "INIT";
1347 case DT_FINI: return "FINI";
1348 case DT_SONAME: return "SONAME";
1349 case DT_RPATH: return "RPATH";
1350 case DT_SYMBOLIC: return "SYMBOLIC";
1351 case DT_REL: return "REL";
1352 case DT_RELSZ: return "RELSZ";
1353 case DT_RELENT: return "RELENT";
1354 case DT_PLTREL: return "PLTREL";
1355 case DT_DEBUG: return "DEBUG";
1356 case DT_TEXTREL: return "TEXTREL";
1357 case DT_JMPREL: return "JMPREL";
1358 case DT_BIND_NOW: return "BIND_NOW";
1359 case DT_INIT_ARRAY: return "INIT_ARRAY";
1360 case DT_FINI_ARRAY: return "FINI_ARRAY";
1361 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1362 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1363 case DT_RUNPATH: return "RUNPATH";
1364 case DT_FLAGS: return "FLAGS";
1366 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1367 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1369 case DT_CHECKSUM: return "CHECKSUM";
1370 case DT_PLTPADSZ: return "PLTPADSZ";
1371 case DT_MOVEENT: return "MOVEENT";
1372 case DT_MOVESZ: return "MOVESZ";
1373 case DT_FEATURE: return "FEATURE";
1374 case DT_POSFLAG_1: return "POSFLAG_1";
1375 case DT_SYMINSZ: return "SYMINSZ";
1376 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1378 case DT_ADDRRNGLO: return "ADDRRNGLO";
1379 case DT_CONFIG: return "CONFIG";
1380 case DT_DEPAUDIT: return "DEPAUDIT";
1381 case DT_AUDIT: return "AUDIT";
1382 case DT_PLTPAD: return "PLTPAD";
1383 case DT_MOVETAB: return "MOVETAB";
1384 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1386 case DT_VERSYM: return "VERSYM";
1388 case DT_RELACOUNT: return "RELACOUNT";
1389 case DT_RELCOUNT: return "RELCOUNT";
1390 case DT_FLAGS_1: return "FLAGS_1";
1391 case DT_VERDEF: return "VERDEF";
1392 case DT_VERDEFNUM: return "VERDEFNUM";
1393 case DT_VERNEED: return "VERNEED";
1394 case DT_VERNEEDNUM: return "VERNEEDNUM";
1396 case DT_AUXILIARY: return "AUXILIARY";
1397 case DT_USED: return "USED";
1398 case DT_FILTER: return "FILTER";
1400 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1401 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1402 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1403 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1404 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1407 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1409 const char * result;
1411 switch (elf_header.e_machine)
1414 case EM_MIPS_RS3_LE:
1415 result = get_mips_dynamic_type (type);
1418 result = get_sparc64_dynamic_type (type);
1421 result = get_ppc64_dynamic_type (type);
1431 sprintf (buff, _("Processor Specific: %lx"), type);
1433 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1435 const char * result;
1437 switch (elf_header.e_machine)
1440 result = get_parisc_dynamic_type (type);
1450 sprintf (buff, _("Operating System specific: %lx"), type);
1453 sprintf (buff, _("<unknown>: %lx"), type);
1460 get_file_type (e_type)
1463 static char buff [32];
1467 case ET_NONE: return _("NONE (None)");
1468 case ET_REL: return _("REL (Relocatable file)");
1469 case ET_EXEC: return _("EXEC (Executable file)");
1470 case ET_DYN: return _("DYN (Shared object file)");
1471 case ET_CORE: return _("CORE (Core file)");
1474 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1475 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1476 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1477 sprintf (buff, _("OS Specific: (%x)"), e_type);
1479 sprintf (buff, _("<unknown>: %x"), e_type);
1485 get_machine_name (e_machine)
1488 static char buff [64]; /* XXX */
1492 case EM_NONE: return _("None");
1493 case EM_M32: return "WE32100";
1494 case EM_SPARC: return "Sparc";
1495 case EM_386: return "Intel 80386";
1496 case EM_68K: return "MC68000";
1497 case EM_88K: return "MC88000";
1498 case EM_486: return "Intel 80486";
1499 case EM_860: return "Intel 80860";
1500 case EM_MIPS: return "MIPS R3000";
1501 case EM_S370: return "IBM System/370";
1502 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1503 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1504 case EM_PARISC: return "HPPA";
1505 case EM_PPC_OLD: return "Power PC (old)";
1506 case EM_SPARC32PLUS: return "Sparc v8+" ;
1507 case EM_960: return "Intel 90860";
1508 case EM_PPC: return "PowerPC";
1509 case EM_PPC64: return "PowerPC64";
1510 case EM_V800: return "NEC V800";
1511 case EM_FR20: return "Fujitsu FR20";
1512 case EM_RH32: return "TRW RH32";
1513 case EM_MCORE: return "MCORE";
1514 case EM_ARM: return "ARM";
1515 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1516 case EM_SH: return "Hitachi SH";
1517 case EM_SPARCV9: return "Sparc v9";
1518 case EM_TRICORE: return "Siemens Tricore";
1519 case EM_ARC: return "ARC";
1520 case EM_H8_300: return "Hitachi H8/300";
1521 case EM_H8_300H: return "Hitachi H8/300H";
1522 case EM_H8S: return "Hitachi H8S";
1523 case EM_H8_500: return "Hitachi H8/500";
1524 case EM_IA_64: return "Intel IA-64";
1525 case EM_MIPS_X: return "Stanford MIPS-X";
1526 case EM_COLDFIRE: return "Motorola Coldfire";
1527 case EM_68HC12: return "Motorola M68HC12";
1528 case EM_ALPHA: return "Alpha";
1529 case EM_CYGNUS_D10V:
1530 case EM_D10V: return "d10v";
1531 case EM_CYGNUS_D30V:
1532 case EM_D30V: return "d30v";
1533 case EM_CYGNUS_M32R:
1534 case EM_M32R: return "Mitsubishi M32r";
1535 case EM_CYGNUS_V850:
1536 case EM_V850: return "NEC v850";
1537 case EM_CYGNUS_MN10300:
1538 case EM_MN10300: return "mn10300";
1539 case EM_CYGNUS_MN10200:
1540 case EM_MN10200: return "mn10200";
1541 case EM_CYGNUS_FR30:
1542 case EM_FR30: return "Fujitsu FR30";
1543 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1545 case EM_PJ: return "picoJava";
1546 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1547 case EM_PCP: return "Siemens PCP";
1548 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1549 case EM_NDR1: return "Denso NDR1 microprocesspr";
1550 case EM_STARCORE: return "Motorola Star*Core processor";
1551 case EM_ME16: return "Toyota ME16 processor";
1552 case EM_ST100: return "STMicroelectronics ST100 processor";
1553 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1554 case EM_FX66: return "Siemens FX66 microcontroller";
1555 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1556 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1557 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1558 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1559 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1560 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1561 case EM_SVX: return "Silicon Graphics SVx";
1562 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1563 case EM_VAX: return "Digital VAX";
1565 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1566 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1567 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1568 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1569 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1570 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1571 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1572 case EM_PRISM: return "SiTera Prism";
1573 case EM_X86_64: return "Advanced Micro Devices X86-64";
1575 case EM_S390: return "IBM S/390";
1576 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1578 case EM_OR32: return "OpenRISC";
1579 case EM_DLX: return "OpenDLX";
1581 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1583 sprintf (buff, _("<unknown>: %x"), e_machine);
1589 decode_ARM_machine_flags (e_flags, buf)
1596 eabi = EF_ARM_EABI_VERSION (e_flags);
1597 e_flags &= ~ EF_ARM_EABIMASK;
1599 /* Handle "generic" ARM flags. */
1600 if (e_flags & EF_ARM_RELEXEC)
1602 strcat (buf, ", relocatable executable");
1603 e_flags &= ~ EF_ARM_RELEXEC;
1606 if (e_flags & EF_ARM_HASENTRY)
1608 strcat (buf, ", has entry point");
1609 e_flags &= ~ EF_ARM_HASENTRY;
1612 /* Now handle EABI specific flags. */
1616 strcat (buf, ", <unrecognized EABI>");
1621 case EF_ARM_EABI_VER1:
1622 strcat (buf, ", Version1 EABI");
1627 /* Process flags one bit at a time. */
1628 flag = e_flags & - e_flags;
1633 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1634 strcat (buf, ", sorted symbol tables");
1644 case EF_ARM_EABI_VER2:
1645 strcat (buf, ", Version2 EABI");
1650 /* Process flags one bit at a time. */
1651 flag = e_flags & - e_flags;
1656 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1657 strcat (buf, ", sorted symbol tables");
1660 case EF_ARM_DYNSYMSUSESEGIDX:
1661 strcat (buf, ", dynamic symbols use segment index");
1664 case EF_ARM_MAPSYMSFIRST:
1665 strcat (buf, ", mapping symbols precede others");
1675 case EF_ARM_EABI_UNKNOWN:
1676 strcat (buf, ", GNU EABI");
1681 /* Process flags one bit at a time. */
1682 flag = e_flags & - e_flags;
1687 case EF_ARM_INTERWORK:
1688 strcat (buf, ", interworking enabled");
1691 case EF_ARM_APCS_26:
1692 strcat (buf, ", uses APCS/26");
1695 case EF_ARM_APCS_FLOAT:
1696 strcat (buf, ", uses APCS/float");
1700 strcat (buf, ", position independent");
1704 strcat (buf, ", 8 bit structure alignment");
1707 case EF_ARM_NEW_ABI:
1708 strcat (buf, ", uses new ABI");
1711 case EF_ARM_OLD_ABI:
1712 strcat (buf, ", uses old ABI");
1715 case EF_ARM_SOFT_FLOAT:
1716 strcat (buf, ", software FP");
1727 strcat (buf,", <unknown>");
1731 get_machine_flags (e_flags, e_machine)
1735 static char buf [1024];
1747 decode_ARM_machine_flags (e_flags, buf);
1751 if (e_flags & EF_CPU32)
1752 strcat (buf, ", cpu32");
1753 if (e_flags & EF_M68000)
1754 strcat (buf, ", m68000");
1758 if (e_flags & EF_PPC_EMB)
1759 strcat (buf, ", emb");
1761 if (e_flags & EF_PPC_RELOCATABLE)
1762 strcat (buf, ", relocatable");
1764 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1765 strcat (buf, ", relocatable-lib");
1769 case EM_CYGNUS_V850:
1770 switch (e_flags & EF_V850_ARCH)
1773 strcat (buf, ", v850e");
1776 strcat (buf, ", v850ea");
1779 strcat (buf, ", v850");
1782 strcat (buf, ", unknown v850 architecture variant");
1788 case EM_CYGNUS_M32R:
1789 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1790 strcat (buf, ", m32r");
1795 case EM_MIPS_RS3_LE:
1796 if (e_flags & EF_MIPS_NOREORDER)
1797 strcat (buf, ", noreorder");
1799 if (e_flags & EF_MIPS_PIC)
1800 strcat (buf, ", pic");
1802 if (e_flags & EF_MIPS_CPIC)
1803 strcat (buf, ", cpic");
1805 if (e_flags & EF_MIPS_UCODE)
1806 strcat (buf, ", ugen_reserved");
1808 if (e_flags & EF_MIPS_ABI2)
1809 strcat (buf, ", abi2");
1811 if (e_flags & EF_MIPS_OPTIONS_FIRST)
1812 strcat (buf, ", odk first");
1814 if (e_flags & EF_MIPS_32BITMODE)
1815 strcat (buf, ", 32bitmode");
1817 switch ((e_flags & EF_MIPS_MACH))
1819 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1820 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1821 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1822 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1823 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1824 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1826 /* We simply ignore the field in this case to avoid confusion:
1827 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1830 default: strcat (buf, ", unknown CPU"); break;
1833 switch ((e_flags & EF_MIPS_ABI))
1835 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
1836 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
1837 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
1838 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
1840 /* We simply ignore the field in this case to avoid confusion:
1841 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1842 This means it is likely to be an o32 file, but not for
1845 default: strcat (buf, ", unknown ABI"); break;
1848 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
1849 strcat (buf, ", mdmx");
1851 if (e_flags & EF_MIPS_ARCH_ASE_M16)
1852 strcat (buf, ", mips16");
1854 switch ((e_flags & EF_MIPS_ARCH))
1856 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
1857 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
1858 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
1859 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
1860 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
1861 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
1862 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
1863 default: strcat (buf, ", unknown ISA"); break;
1869 if (e_flags & EF_SPARC_32PLUS)
1870 strcat (buf, ", v8+");
1872 if (e_flags & EF_SPARC_SUN_US1)
1873 strcat (buf, ", ultrasparcI");
1875 if (e_flags & EF_SPARC_SUN_US3)
1876 strcat (buf, ", ultrasparcIII");
1878 if (e_flags & EF_SPARC_HAL_R1)
1879 strcat (buf, ", halr1");
1881 if (e_flags & EF_SPARC_LEDATA)
1882 strcat (buf, ", ledata");
1884 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
1885 strcat (buf, ", tso");
1887 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
1888 strcat (buf, ", pso");
1890 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
1891 strcat (buf, ", rmo");
1895 switch (e_flags & EF_PARISC_ARCH)
1897 case EFA_PARISC_1_0:
1898 strcpy (buf, ", PA-RISC 1.0");
1900 case EFA_PARISC_1_1:
1901 strcpy (buf, ", PA-RISC 1.1");
1903 case EFA_PARISC_2_0:
1904 strcpy (buf, ", PA-RISC 2.0");
1909 if (e_flags & EF_PARISC_TRAPNIL)
1910 strcat (buf, ", trapnil");
1911 if (e_flags & EF_PARISC_EXT)
1912 strcat (buf, ", ext");
1913 if (e_flags & EF_PARISC_LSB)
1914 strcat (buf, ", lsb");
1915 if (e_flags & EF_PARISC_WIDE)
1916 strcat (buf, ", wide");
1917 if (e_flags & EF_PARISC_NO_KABP)
1918 strcat (buf, ", no kabp");
1919 if (e_flags & EF_PARISC_LAZYSWAP)
1920 strcat (buf, ", lazyswap");
1925 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
1926 strcat (buf, ", new calling convention");
1928 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
1929 strcat (buf, ", gnu calling convention");
1933 if ((e_flags & EF_IA_64_ABI64))
1934 strcat (buf, ", 64-bit");
1936 strcat (buf, ", 32-bit");
1937 if ((e_flags & EF_IA_64_REDUCEDFP))
1938 strcat (buf, ", reduced fp model");
1939 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
1940 strcat (buf, ", no function descriptors, constant gp");
1941 else if ((e_flags & EF_IA_64_CONS_GP))
1942 strcat (buf, ", constant gp");
1943 if ((e_flags & EF_IA_64_ABSOLUTE))
1944 strcat (buf, ", absolute");
1948 if ((e_flags & EF_VAX_NONPIC))
1949 strcat (buf, ", non-PIC");
1950 if ((e_flags & EF_VAX_DFLOAT))
1951 strcat (buf, ", D-Float");
1952 if ((e_flags & EF_VAX_GFLOAT))
1953 strcat (buf, ", G-Float");
1962 get_mips_segment_type (type)
1967 case PT_MIPS_REGINFO:
1969 case PT_MIPS_RTPROC:
1971 case PT_MIPS_OPTIONS:
1981 get_parisc_segment_type (type)
1986 case PT_HP_TLS: return "HP_TLS";
1987 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
1988 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
1989 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
1990 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
1991 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
1992 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
1993 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
1994 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
1995 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
1996 case PT_HP_PARALLEL: return "HP_PARALLEL";
1997 case PT_HP_FASTBIND: return "HP_FASTBIND";
1998 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
1999 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2008 get_ia64_segment_type (type)
2013 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2014 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2015 case PT_HP_TLS: return "HP_TLS";
2016 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2017 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2018 case PT_IA_64_HP_STACK: return "HP_STACK";
2027 get_segment_type (p_type)
2028 unsigned long p_type;
2030 static char buff [32];
2034 case PT_NULL: return "NULL";
2035 case PT_LOAD: return "LOAD";
2036 case PT_DYNAMIC: return "DYNAMIC";
2037 case PT_INTERP: return "INTERP";
2038 case PT_NOTE: return "NOTE";
2039 case PT_SHLIB: return "SHLIB";
2040 case PT_PHDR: return "PHDR";
2041 case PT_TLS: return "TLS";
2043 case PT_GNU_EH_FRAME:
2044 return "GNU_EH_FRAME";
2047 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2049 const char * result;
2051 switch (elf_header.e_machine)
2054 case EM_MIPS_RS3_LE:
2055 result = get_mips_segment_type (p_type);
2058 result = get_parisc_segment_type (p_type);
2061 result = get_ia64_segment_type (p_type);
2071 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2073 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2075 const char * result;
2077 switch (elf_header.e_machine)
2080 result = get_parisc_segment_type (p_type);
2083 result = get_ia64_segment_type (p_type);
2093 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2096 sprintf (buff, _("<unknown>: %lx"), p_type);
2103 get_mips_section_type_name (sh_type)
2104 unsigned int sh_type;
2108 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2109 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2110 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2111 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2112 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2113 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2114 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2115 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2116 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2117 case SHT_MIPS_RELD: return "MIPS_RELD";
2118 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2119 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2120 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2121 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2122 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2123 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2124 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2125 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2126 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2127 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2128 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2129 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2130 case SHT_MIPS_LINE: return "MIPS_LINE";
2131 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2132 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2133 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2134 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2135 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2136 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2137 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2138 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2139 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2140 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2141 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2142 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2143 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2144 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2145 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2146 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2154 get_parisc_section_type_name (sh_type)
2155 unsigned int sh_type;
2159 case SHT_PARISC_EXT: return "PARISC_EXT";
2160 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2161 case SHT_PARISC_DOC: return "PARISC_DOC";
2169 get_ia64_section_type_name (sh_type)
2170 unsigned int sh_type;
2174 case SHT_IA_64_EXT: return "IA_64_EXT";
2175 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2183 get_section_type_name (sh_type)
2184 unsigned int sh_type;
2186 static char buff [32];
2190 case SHT_NULL: return "NULL";
2191 case SHT_PROGBITS: return "PROGBITS";
2192 case SHT_SYMTAB: return "SYMTAB";
2193 case SHT_STRTAB: return "STRTAB";
2194 case SHT_RELA: return "RELA";
2195 case SHT_HASH: return "HASH";
2196 case SHT_DYNAMIC: return "DYNAMIC";
2197 case SHT_NOTE: return "NOTE";
2198 case SHT_NOBITS: return "NOBITS";
2199 case SHT_REL: return "REL";
2200 case SHT_SHLIB: return "SHLIB";
2201 case SHT_DYNSYM: return "DYNSYM";
2202 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2203 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2204 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2205 case SHT_GROUP: return "GROUP";
2206 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2207 case SHT_GNU_verdef: return "VERDEF";
2208 case SHT_GNU_verneed: return "VERNEED";
2209 case SHT_GNU_versym: return "VERSYM";
2210 case 0x6ffffff0: return "VERSYM";
2211 case 0x6ffffffc: return "VERDEF";
2212 case 0x7ffffffd: return "AUXILIARY";
2213 case 0x7fffffff: return "FILTER";
2214 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2217 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2219 const char * result;
2221 switch (elf_header.e_machine)
2224 case EM_MIPS_RS3_LE:
2225 result = get_mips_section_type_name (sh_type);
2228 result = get_parisc_section_type_name (sh_type);
2231 result = get_ia64_section_type_name (sh_type);
2241 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2243 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2244 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2245 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2246 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2248 sprintf (buff, _("<unknown>: %x"), sh_type);
2254 #define OPTION_DEBUG_DUMP 512
2256 struct option options [] =
2258 {"all", no_argument, 0, 'a'},
2259 {"file-header", no_argument, 0, 'h'},
2260 {"program-headers", no_argument, 0, 'l'},
2261 {"headers", no_argument, 0, 'e'},
2262 {"histogram", no_argument, 0, 'I'},
2263 {"segments", no_argument, 0, 'l'},
2264 {"sections", no_argument, 0, 'S'},
2265 {"section-headers", no_argument, 0, 'S'},
2266 {"symbols", no_argument, 0, 's'},
2267 {"syms", no_argument, 0, 's'},
2268 {"relocs", no_argument, 0, 'r'},
2269 {"notes", no_argument, 0, 'n'},
2270 {"dynamic", no_argument, 0, 'd'},
2271 {"arch-specific", no_argument, 0, 'A'},
2272 {"version-info", no_argument, 0, 'V'},
2273 {"use-dynamic", no_argument, 0, 'D'},
2274 {"hex-dump", required_argument, 0, 'x'},
2275 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2276 {"unwind", no_argument, 0, 'u'},
2277 #ifdef SUPPORT_DISASSEMBLY
2278 {"instruction-dump", required_argument, 0, 'i'},
2281 {"version", no_argument, 0, 'v'},
2282 {"wide", no_argument, 0, 'W'},
2283 {"help", no_argument, 0, 'H'},
2284 {0, no_argument, 0, 0}
2290 fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2291 fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2292 fprintf (stdout, _(" Options are:\n\
2293 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2294 -h --file-header Display the ELF file header\n\
2295 -l --program-headers Display the program headers\n\
2296 --segments An alias for --program-headers\n\
2297 -S --section-headers Display the sections' header\n\
2298 --sections An alias for --section-headers\n\
2299 -e --headers Equivalent to: -h -l -S\n\
2300 -s --syms Display the symbol table\n\
2301 --symbols An alias for --syms\n\
2302 -n --notes Display the core notes (if present)\n\
2303 -r --relocs Display the relocations (if present)\n\
2304 -u --unwind Display the unwind info (if present)\n\
2305 -d --dynamic Display the dynamic segment (if present)\n\
2306 -V --version-info Display the version sections (if present)\n\
2307 -A --arch-specific Display architecture specific information (if any).\n\
2308 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2309 -x --hex-dump=<number> Dump the contents of section <number>\n\
2310 -w[liaprmfFso] or\n\
2311 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2312 Display the contents of DWARF2 debug sections\n"));
2313 #ifdef SUPPORT_DISASSEMBLY
2314 fprintf (stdout, _("\
2315 -i --instruction-dump=<number>\n\
2316 Disassemble the contents of section <number>\n"));
2318 fprintf (stdout, _("\
2319 -I --histogram Display histogram of bucket list lengths\n\
2320 -W --wide Allow output width to exceed 80 characters\n\
2321 -H --help Display this information\n\
2322 -v --version Display the version number of readelf\n"));
2323 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2329 request_dump (section, type)
2330 unsigned int section;
2333 if (section >= num_dump_sects)
2335 char * new_dump_sects;
2337 new_dump_sects = (char *) calloc (section + 1, 1);
2339 if (new_dump_sects == NULL)
2340 error (_("Out of memory allocating dump request table."));
2343 /* Copy current flag settings. */
2344 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2348 dump_sects = new_dump_sects;
2349 num_dump_sects = section + 1;
2354 dump_sects [section] |= type;
2360 parse_args (argc, argv)
2369 while ((c = getopt_long
2370 (argc, argv, "ersuahnldSDAIw::x:i:vVW", options, NULL)) != EOF)
2406 do_using_dynamic ++;
2437 section = strtoul (optarg, & cp, 0);
2438 if (! * cp && section >= 0)
2440 request_dump (section, HEX_DUMP);
2450 unsigned int index = 0;
2454 while (optarg[index])
2455 switch (optarg[index++])
2464 do_debug_abbrevs = 1;
2474 do_debug_pubnames = 1;
2479 do_debug_aranges = 1;
2483 do_debug_frames_interp = 1;
2485 do_debug_frames = 1;
2490 do_debug_macinfo = 1;
2504 warn (_("Unrecognized debug option '%s'\n"), optarg);
2509 case OPTION_DEBUG_DUMP:
2515 const char *debug_dump_opt[]
2516 = { "line", "info", "abbrev", "pubnames", "ranges",
2517 "macro", "frames", "frames-interp", "str", "loc", NULL };
2526 for (index = 0; debug_dump_opt[index]; index++)
2528 size_t len = strlen (debug_dump_opt[index]);
2530 if (strncmp (p, debug_dump_opt[index], len) == 0
2531 && (p[len] == ',' || p[len] == '\0'))
2540 do_debug_abbrevs = 1;
2551 do_debug_pubnames = 1;
2555 do_debug_aranges = 1;
2560 do_debug_frames_interp = 1;
2561 do_debug_frames = 1;
2565 do_debug_macinfo = 1;
2578 if (debug_dump_opt[index] == NULL)
2580 warn (_("Unrecognized debug option '%s'\n"), p);
2581 p = strchr (p, ',');
2591 #ifdef SUPPORT_DISASSEMBLY
2594 section = strtoul (optarg, & cp, 0);
2595 if (! * cp && section >= 0)
2597 request_dump (section, DISASS_DUMP);
2603 print_version (program_name);
2613 /* xgettext:c-format */
2614 error (_("Invalid option '-%c'\n"), c);
2621 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2622 && !do_segments && !do_header && !do_dump && !do_version
2623 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2627 warn (_("Nothing to do.\n"));
2633 get_elf_class (elf_class)
2634 unsigned int elf_class;
2636 static char buff [32];
2640 case ELFCLASSNONE: return _("none");
2641 case ELFCLASS32: return "ELF32";
2642 case ELFCLASS64: return "ELF64";
2644 sprintf (buff, _("<unknown: %x>"), elf_class);
2650 get_data_encoding (encoding)
2651 unsigned int encoding;
2653 static char buff [32];
2657 case ELFDATANONE: return _("none");
2658 case ELFDATA2LSB: return _("2's complement, little endian");
2659 case ELFDATA2MSB: return _("2's complement, big endian");
2661 sprintf (buff, _("<unknown: %x>"), encoding);
2667 get_osabi_name (osabi)
2670 static char buff [32];
2674 case ELFOSABI_NONE: return "UNIX - System V";
2675 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2676 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2677 case ELFOSABI_LINUX: return "UNIX - Linux";
2678 case ELFOSABI_HURD: return "GNU/Hurd";
2679 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2680 case ELFOSABI_AIX: return "UNIX - AIX";
2681 case ELFOSABI_IRIX: return "UNIX - IRIX";
2682 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2683 case ELFOSABI_TRU64: return "UNIX - TRU64";
2684 case ELFOSABI_MODESTO: return "Novell - Modesto";
2685 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2686 case ELFOSABI_STANDALONE: return _("Standalone App");
2687 case ELFOSABI_ARM: return "ARM";
2689 sprintf (buff, _("<unknown: %x>"), osabi);
2694 /* Decode the data held in 'elf_header'. */
2696 process_file_header ()
2698 if ( elf_header.e_ident [EI_MAG0] != ELFMAG0
2699 || elf_header.e_ident [EI_MAG1] != ELFMAG1
2700 || elf_header.e_ident [EI_MAG2] != ELFMAG2
2701 || elf_header.e_ident [EI_MAG3] != ELFMAG3)
2704 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2712 printf (_("ELF Header:\n"));
2713 printf (_(" Magic: "));
2714 for (i = 0; i < EI_NIDENT; i ++)
2715 printf ("%2.2x ", elf_header.e_ident [i]);
2717 printf (_(" Class: %s\n"),
2718 get_elf_class (elf_header.e_ident [EI_CLASS]));
2719 printf (_(" Data: %s\n"),
2720 get_data_encoding (elf_header.e_ident [EI_DATA]));
2721 printf (_(" Version: %d %s\n"),
2722 elf_header.e_ident [EI_VERSION],
2723 (elf_header.e_ident [EI_VERSION] == EV_CURRENT
2725 : (elf_header.e_ident [EI_VERSION] != EV_NONE
2728 printf (_(" OS/ABI: %s\n"),
2729 get_osabi_name (elf_header.e_ident [EI_OSABI]));
2730 printf (_(" ABI Version: %d\n"),
2731 elf_header.e_ident [EI_ABIVERSION]);
2732 printf (_(" Type: %s\n"),
2733 get_file_type (elf_header.e_type));
2734 printf (_(" Machine: %s\n"),
2735 get_machine_name (elf_header.e_machine));
2736 printf (_(" Version: 0x%lx\n"),
2737 (unsigned long) elf_header.e_version);
2739 printf (_(" Entry point address: "));
2740 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2741 printf (_("\n Start of program headers: "));
2742 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2743 printf (_(" (bytes into file)\n Start of section headers: "));
2744 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2745 printf (_(" (bytes into file)\n"));
2747 printf (_(" Flags: 0x%lx%s\n"),
2748 (unsigned long) elf_header.e_flags,
2749 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2750 printf (_(" Size of this header: %ld (bytes)\n"),
2751 (long) elf_header.e_ehsize);
2752 printf (_(" Size of program headers: %ld (bytes)\n"),
2753 (long) elf_header.e_phentsize);
2754 printf (_(" Number of program headers: %ld\n"),
2755 (long) elf_header.e_phnum);
2756 printf (_(" Size of section headers: %ld (bytes)\n"),
2757 (long) elf_header.e_shentsize);
2758 printf (_(" Number of section headers: %ld"),
2759 (long) elf_header.e_shnum);
2760 if (section_headers != NULL && elf_header.e_shnum == 0)
2761 printf (" (%ld)", (long) section_headers[0].sh_size);
2762 putc ('\n', stdout);
2763 printf (_(" Section header string table index: %ld"),
2764 (long) elf_header.e_shstrndx);
2765 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
2766 printf (" (%ld)", (long) section_headers[0].sh_link);
2767 putc ('\n', stdout);
2770 if (section_headers != NULL)
2772 if (elf_header.e_shnum == 0)
2773 elf_header.e_shnum = section_headers[0].sh_size;
2774 if (elf_header.e_shstrndx == SHN_XINDEX)
2775 elf_header.e_shstrndx = section_headers[0].sh_link;
2776 free (section_headers);
2777 section_headers = NULL;
2785 get_32bit_program_headers (file, program_headers)
2787 Elf_Internal_Phdr * program_headers;
2789 Elf32_External_Phdr * phdrs;
2790 Elf32_External_Phdr * external;
2791 Elf32_Internal_Phdr * internal;
2794 phdrs = ((Elf32_External_Phdr *)
2795 get_data (NULL, file, elf_header.e_phoff,
2796 elf_header.e_phentsize * elf_header.e_phnum,
2797 _("program headers")));
2801 for (i = 0, internal = program_headers, external = phdrs;
2802 i < elf_header.e_phnum;
2803 i ++, internal ++, external ++)
2805 internal->p_type = BYTE_GET (external->p_type);
2806 internal->p_offset = BYTE_GET (external->p_offset);
2807 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2808 internal->p_paddr = BYTE_GET (external->p_paddr);
2809 internal->p_filesz = BYTE_GET (external->p_filesz);
2810 internal->p_memsz = BYTE_GET (external->p_memsz);
2811 internal->p_flags = BYTE_GET (external->p_flags);
2812 internal->p_align = BYTE_GET (external->p_align);
2821 get_64bit_program_headers (file, program_headers)
2823 Elf_Internal_Phdr * program_headers;
2825 Elf64_External_Phdr * phdrs;
2826 Elf64_External_Phdr * external;
2827 Elf64_Internal_Phdr * internal;
2830 phdrs = ((Elf64_External_Phdr *)
2831 get_data (NULL, file, elf_header.e_phoff,
2832 elf_header.e_phentsize * elf_header.e_phnum,
2833 _("program headers")));
2837 for (i = 0, internal = program_headers, external = phdrs;
2838 i < elf_header.e_phnum;
2839 i ++, internal ++, external ++)
2841 internal->p_type = BYTE_GET (external->p_type);
2842 internal->p_flags = BYTE_GET (external->p_flags);
2843 internal->p_offset = BYTE_GET8 (external->p_offset);
2844 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2845 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2846 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2847 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2848 internal->p_align = BYTE_GET8 (external->p_align);
2857 process_program_headers (file)
2860 Elf_Internal_Phdr * program_headers;
2861 Elf_Internal_Phdr * segment;
2864 if (elf_header.e_phnum == 0)
2867 printf (_("\nThere are no program headers in this file.\n"));
2871 if (do_segments && !do_header)
2873 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
2874 printf (_("Entry point "));
2875 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2876 printf (_("\nThere are %d program headers, starting at offset "),
2877 elf_header.e_phnum);
2878 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2882 program_headers = (Elf_Internal_Phdr *) malloc
2883 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
2885 if (program_headers == NULL)
2887 error (_("Out of memory\n"));
2892 i = get_32bit_program_headers (file, program_headers);
2894 i = get_64bit_program_headers (file, program_headers);
2898 free (program_headers);
2904 if (elf_header.e_phnum > 1)
2905 printf (_("\nProgram Headers:\n"));
2907 printf (_("\nProgram Headers:\n"));
2911 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2914 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2918 (_(" Type Offset VirtAddr PhysAddr\n"));
2920 (_(" FileSiz MemSiz Flags Align\n"));
2928 for (i = 0, segment = program_headers;
2929 i < elf_header.e_phnum;
2934 printf (" %-14.14s ", get_segment_type (segment->p_type));
2938 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2939 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
2940 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
2941 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
2942 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
2944 (segment->p_flags & PF_R ? 'R' : ' '),
2945 (segment->p_flags & PF_W ? 'W' : ' '),
2946 (segment->p_flags & PF_X ? 'E' : ' '));
2947 printf ("%#lx", (unsigned long) segment->p_align);
2951 if ((unsigned long) segment->p_offset == segment->p_offset)
2952 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
2955 print_vma (segment->p_offset, FULL_HEX);
2959 print_vma (segment->p_vaddr, FULL_HEX);
2961 print_vma (segment->p_paddr, FULL_HEX);
2964 if ((unsigned long) segment->p_filesz == segment->p_filesz)
2965 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
2968 print_vma (segment->p_filesz, FULL_HEX);
2972 if ((unsigned long) segment->p_memsz == segment->p_memsz)
2973 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
2976 print_vma (segment->p_offset, FULL_HEX);
2980 (segment->p_flags & PF_R ? 'R' : ' '),
2981 (segment->p_flags & PF_W ? 'W' : ' '),
2982 (segment->p_flags & PF_X ? 'E' : ' '));
2984 if ((unsigned long) segment->p_align == segment->p_align)
2985 printf ("%#lx", (unsigned long) segment->p_align);
2988 print_vma (segment->p_align, PREFIX_HEX);
2993 print_vma (segment->p_offset, FULL_HEX);
2995 print_vma (segment->p_vaddr, FULL_HEX);
2997 print_vma (segment->p_paddr, FULL_HEX);
2999 print_vma (segment->p_filesz, FULL_HEX);
3001 print_vma (segment->p_memsz, FULL_HEX);
3003 (segment->p_flags & PF_R ? 'R' : ' '),
3004 (segment->p_flags & PF_W ? 'W' : ' '),
3005 (segment->p_flags & PF_X ? 'E' : ' '));
3006 print_vma (segment->p_align, HEX);
3010 switch (segment->p_type)
3014 loadaddr = (segment->p_vaddr & 0xfffff000)
3015 - (segment->p_offset & 0xfffff000);
3020 error (_("more than one dynamic segment\n"));
3022 dynamic_addr = segment->p_offset;
3023 dynamic_size = segment->p_filesz;
3027 if (fseek (file, (long) segment->p_offset, SEEK_SET))
3028 error (_("Unable to find program interpreter name\n"));
3031 program_interpreter[0] = 0;
3032 fscanf (file, "%63s", program_interpreter);
3035 printf (_("\n [Requesting program interpreter: %s]"),
3036 program_interpreter);
3042 putc ('\n', stdout);
3051 if (do_segments && section_headers != NULL)
3053 printf (_("\n Section to Segment mapping:\n"));
3054 printf (_(" Segment Sections...\n"));
3056 assert (string_table != NULL);
3058 for (i = 0; i < elf_header.e_phnum; i++)
3061 Elf_Internal_Shdr * section;
3063 segment = program_headers + i;
3064 section = section_headers;
3066 printf (" %2.2d ", i);
3068 for (j = 1; j < elf_header.e_shnum; j++, section ++)
3070 if (section->sh_size > 0
3071 /* Compare allocated sections by VMA, unallocated
3072 sections by file offset. */
3073 && (section->sh_flags & SHF_ALLOC
3074 ? (section->sh_addr >= segment->p_vaddr
3075 && section->sh_addr + section->sh_size
3076 <= segment->p_vaddr + segment->p_memsz)
3077 : ((bfd_vma) section->sh_offset >= segment->p_offset
3078 && (section->sh_offset + section->sh_size
3079 <= segment->p_offset + segment->p_filesz))))
3080 printf ("%s ", SECTION_NAME (section));
3087 free (program_headers);
3094 get_32bit_section_headers (file, num)
3098 Elf32_External_Shdr * shdrs;
3099 Elf32_Internal_Shdr * internal;
3102 shdrs = ((Elf32_External_Shdr *)
3103 get_data (NULL, file, elf_header.e_shoff,
3104 elf_header.e_shentsize * num,
3105 _("section headers")));
3109 section_headers = ((Elf_Internal_Shdr *)
3110 malloc (num * sizeof (Elf_Internal_Shdr)));
3112 if (section_headers == NULL)
3114 error (_("Out of memory\n"));
3118 for (i = 0, internal = section_headers;
3122 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3123 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3124 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3125 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3126 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3127 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3128 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3129 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3130 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3131 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3140 get_64bit_section_headers (file, num)
3144 Elf64_External_Shdr * shdrs;
3145 Elf64_Internal_Shdr * internal;
3148 shdrs = ((Elf64_External_Shdr *)
3149 get_data (NULL, file, elf_header.e_shoff,
3150 elf_header.e_shentsize * num,
3151 _("section headers")));
3155 section_headers = ((Elf_Internal_Shdr *)
3156 malloc (num * sizeof (Elf_Internal_Shdr)));
3158 if (section_headers == NULL)
3160 error (_("Out of memory\n"));
3164 for (i = 0, internal = section_headers;
3168 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3169 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3170 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
3171 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
3172 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
3173 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
3174 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3175 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3176 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3177 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3185 static Elf_Internal_Sym *
3186 get_32bit_elf_symbols (file, section)
3188 Elf_Internal_Shdr *section;
3190 unsigned long number;
3191 Elf32_External_Sym * esyms;
3192 Elf_External_Sym_Shndx *shndx;
3193 Elf_Internal_Sym * isyms;
3194 Elf_Internal_Sym * psym;
3197 esyms = ((Elf32_External_Sym *)
3198 get_data (NULL, file, section->sh_offset,
3199 section->sh_size, _("symbols")));
3204 if (symtab_shndx_hdr != NULL
3205 && (symtab_shndx_hdr->sh_link
3206 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3208 shndx = ((Elf_External_Sym_Shndx *)
3209 get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3210 symtab_shndx_hdr->sh_size, _("symtab shndx")));
3218 number = section->sh_size / section->sh_entsize;
3219 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3223 error (_("Out of memory\n"));
3230 for (j = 0, psym = isyms;
3234 psym->st_name = BYTE_GET (esyms[j].st_name);
3235 psym->st_value = BYTE_GET (esyms[j].st_value);
3236 psym->st_size = BYTE_GET (esyms[j].st_size);
3237 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3238 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3240 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3241 psym->st_info = BYTE_GET (esyms[j].st_info);
3242 psym->st_other = BYTE_GET (esyms[j].st_other);
3252 static Elf_Internal_Sym *
3253 get_64bit_elf_symbols (file, section)
3255 Elf_Internal_Shdr *section;
3257 unsigned long number;
3258 Elf64_External_Sym * esyms;
3259 Elf_External_Sym_Shndx *shndx;
3260 Elf_Internal_Sym * isyms;
3261 Elf_Internal_Sym * psym;
3264 esyms = ((Elf64_External_Sym *)
3265 get_data (NULL, file, section->sh_offset,
3266 section->sh_size, _("symbols")));
3271 if (symtab_shndx_hdr != NULL
3272 && (symtab_shndx_hdr->sh_link
3273 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3275 shndx = ((Elf_External_Sym_Shndx *)
3276 get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3277 symtab_shndx_hdr->sh_size, _("symtab shndx")));
3285 number = section->sh_size / section->sh_entsize;
3286 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3290 error (_("Out of memory\n"));
3297 for (j = 0, psym = isyms;
3301 psym->st_name = BYTE_GET (esyms[j].st_name);
3302 psym->st_info = BYTE_GET (esyms[j].st_info);
3303 psym->st_other = BYTE_GET (esyms[j].st_other);
3304 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3305 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3307 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3308 psym->st_value = BYTE_GET8 (esyms[j].st_value);
3309 psym->st_size = BYTE_GET8 (esyms[j].st_size);
3320 get_elf_section_flags (sh_flags)
3323 static char buff [32];
3331 flag = sh_flags & - sh_flags;
3336 case SHF_WRITE: strcat (buff, "W"); break;
3337 case SHF_ALLOC: strcat (buff, "A"); break;
3338 case SHF_EXECINSTR: strcat (buff, "X"); break;
3339 case SHF_MERGE: strcat (buff, "M"); break;
3340 case SHF_STRINGS: strcat (buff, "S"); break;
3341 case SHF_INFO_LINK: strcat (buff, "I"); break;
3342 case SHF_LINK_ORDER: strcat (buff, "L"); break;
3343 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
3344 case SHF_GROUP: strcat (buff, "G"); break;
3345 case SHF_TLS: strcat (buff, "T"); break;
3348 if (flag & SHF_MASKOS)
3351 sh_flags &= ~ SHF_MASKOS;
3353 else if (flag & SHF_MASKPROC)
3356 sh_flags &= ~ SHF_MASKPROC;
3368 process_section_headers (file)
3371 Elf_Internal_Shdr * section;
3374 section_headers = NULL;
3376 if (elf_header.e_shnum == 0)
3379 printf (_("\nThere are no sections in this file.\n"));
3384 if (do_sections && !do_header)
3385 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3386 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3390 if (! get_32bit_section_headers (file, elf_header.e_shnum))
3393 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3396 /* Read in the string table, so that we have names to display. */
3397 section = SECTION_HEADER (elf_header.e_shstrndx);
3399 if (section->sh_size != 0)
3401 string_table = (char *) get_data (NULL, file, section->sh_offset,
3402 section->sh_size, _("string table"));
3404 string_table_length = section->sh_size;
3407 /* Scan the sections for the dynamic symbol table
3408 and dynamic string table and debug sections. */
3409 dynamic_symbols = NULL;
3410 dynamic_strings = NULL;
3411 dynamic_syminfo = NULL;
3413 for (i = 0, section = section_headers;
3414 i < elf_header.e_shnum;
3417 char * name = SECTION_NAME (section);
3419 if (section->sh_type == SHT_DYNSYM)
3421 if (dynamic_symbols != NULL)
3423 error (_("File contains multiple dynamic symbol tables\n"));
3427 num_dynamic_syms = section->sh_size / section->sh_entsize;
3428 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3430 else if (section->sh_type == SHT_STRTAB
3431 && strcmp (name, ".dynstr") == 0)
3433 if (dynamic_strings != NULL)
3435 error (_("File contains multiple dynamic string tables\n"));
3439 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
3441 _("dynamic strings"));
3443 else if (section->sh_type == SHT_SYMTAB_SHNDX)
3445 if (symtab_shndx_hdr != NULL)
3447 error (_("File contains multiple symtab shndx tables\n"));
3450 symtab_shndx_hdr = section;
3452 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3453 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3454 || do_debug_frames || do_debug_macinfo || do_debug_str
3456 && strncmp (name, ".debug_", 7) == 0)
3461 || (do_debug_info && (strcmp (name, "info") == 0))
3462 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3463 || (do_debug_lines && (strcmp (name, "line") == 0))
3464 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3465 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3466 || (do_debug_frames && (strcmp (name, "frame") == 0))
3467 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3468 || (do_debug_str && (strcmp (name, "str") == 0))
3469 || (do_debug_loc && (strcmp (name, "loc") == 0))
3471 request_dump (i, DEBUG_DUMP);
3473 /* linkonce section to be combined with .debug_info at link time. */
3474 else if ((do_debugging || do_debug_info)
3475 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3476 request_dump (i, DEBUG_DUMP);
3477 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3478 request_dump (i, DEBUG_DUMP);
3484 if (elf_header.e_shnum > 1)
3485 printf (_("\nSection Headers:\n"));
3487 printf (_("\nSection Header:\n"));
3491 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3494 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3497 printf (_(" [Nr] Name Type Address Offset\n"));
3498 printf (_(" Size EntSize Flags Link Info Align\n"));
3501 for (i = 0, section = section_headers;
3502 i < elf_header.e_shnum;
3505 printf (" [%2u] %-17.17s %-15.15s ",
3506 SECTION_HEADER_NUM (i),
3507 SECTION_NAME (section),
3508 get_section_type_name (section->sh_type));
3512 print_vma (section->sh_addr, LONG_HEX);
3514 printf ( " %6.6lx %6.6lx %2.2lx",
3515 (unsigned long) section->sh_offset,
3516 (unsigned long) section->sh_size,
3517 (unsigned long) section->sh_entsize);
3519 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3521 printf ("%2ld %3lx %2ld\n",
3522 (unsigned long) section->sh_link,
3523 (unsigned long) section->sh_info,
3524 (unsigned long) section->sh_addralign);
3528 print_vma (section->sh_addr, LONG_HEX);
3530 if ((long) section->sh_offset == section->sh_offset)
3531 printf (" %6.6lx", (unsigned long) section->sh_offset);
3535 print_vma (section->sh_offset, LONG_HEX);
3538 if ((unsigned long) section->sh_size == section->sh_size)
3539 printf (" %6.6lx", (unsigned long) section->sh_size);
3543 print_vma (section->sh_size, LONG_HEX);
3546 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3547 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3551 print_vma (section->sh_entsize, LONG_HEX);
3554 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3556 printf ("%2ld %3lx ",
3557 (unsigned long) section->sh_link,
3558 (unsigned long) section->sh_info);
3560 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3561 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3564 print_vma (section->sh_addralign, DEC);
3571 print_vma (section->sh_addr, LONG_HEX);
3572 if ((long) section->sh_offset == section->sh_offset)
3573 printf (" %8.8lx", (unsigned long) section->sh_offset);
3577 print_vma (section->sh_offset, LONG_HEX);
3580 print_vma (section->sh_size, LONG_HEX);
3582 print_vma (section->sh_entsize, LONG_HEX);
3584 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3586 printf (" %2ld %3lx %ld\n",
3587 (unsigned long) section->sh_link,
3588 (unsigned long) section->sh_info,
3589 (unsigned long) section->sh_addralign);
3593 printf (_("Key to Flags:\n\
3594 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3595 I (info), L (link order), G (group), x (unknown)\n\
3596 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3601 /* Process the reloc section. */
3603 process_relocs (file)
3606 unsigned long rel_size;
3607 unsigned long rel_offset;
3613 if (do_using_dynamic)
3615 int is_rela = FALSE;
3620 if (dynamic_info[DT_REL])
3622 rel_offset = dynamic_info[DT_REL];
3623 rel_size = dynamic_info[DT_RELSZ];
3626 else if (dynamic_info [DT_RELA])
3628 rel_offset = dynamic_info[DT_RELA];
3629 rel_size = dynamic_info[DT_RELASZ];
3632 else if (dynamic_info[DT_JMPREL])
3634 rel_offset = dynamic_info[DT_JMPREL];
3635 rel_size = dynamic_info[DT_PLTRELSZ];
3637 switch (dynamic_info[DT_PLTREL])
3654 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3655 rel_offset, rel_size);
3657 dump_relocations (file, rel_offset - loadaddr, rel_size,
3658 dynamic_symbols, num_dynamic_syms, dynamic_strings, is_rela);
3661 printf (_("\nThere are no dynamic relocations in this file.\n"));
3665 Elf32_Internal_Shdr * section;
3669 for (i = 0, section = section_headers;
3670 i < elf_header.e_shnum;
3673 if ( section->sh_type != SHT_RELA
3674 && section->sh_type != SHT_REL)
3677 rel_offset = section->sh_offset;
3678 rel_size = section->sh_size;
3682 Elf32_Internal_Shdr * strsec;
3683 Elf_Internal_Sym * symtab;
3686 unsigned long nsyms;
3688 printf (_("\nRelocation section "));
3690 if (string_table == NULL)
3691 printf ("%d", section->sh_name);
3693 printf (_("'%s'"), SECTION_NAME (section));
3695 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3696 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3701 if (section->sh_link)
3703 Elf32_Internal_Shdr * symsec;
3705 symsec = SECTION_HEADER (section->sh_link);
3706 nsyms = symsec->sh_size / symsec->sh_entsize;
3707 symtab = GET_ELF_SYMBOLS (file, symsec);
3712 strsec = SECTION_HEADER (symsec->sh_link);
3714 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3718 is_rela = section->sh_type == SHT_RELA;
3720 dump_relocations (file, rel_offset, rel_size,
3721 symtab, nsyms, strtab, is_rela);
3733 printf (_("\nThere are no relocations in this file.\n"));
3739 #include "unwind-ia64.h"
3741 /* An absolute address consists of a section and an offset. If the
3742 section is NULL, the offset itself is the address, otherwise, the
3743 address equals to LOAD_ADDRESS(section) + offset. */
3747 unsigned short section;
3753 struct unw_table_entry
3755 struct absaddr start;
3757 struct absaddr info;
3759 *table; /* Unwind table. */
3760 unsigned long table_len; /* Length of unwind table. */
3761 unsigned char * info; /* Unwind info. */
3762 unsigned long info_size; /* Size of unwind info. */
3763 bfd_vma info_addr; /* starting address of unwind info. */
3764 bfd_vma seg_base; /* Starting address of segment. */
3765 Elf_Internal_Sym * symtab; /* The symbol table. */
3766 unsigned long nsyms; /* Number of symbols. */
3767 char * strtab; /* The string table. */
3768 unsigned long strtab_size; /* Size of string table. */
3771 static void find_symbol_for_address PARAMS ((struct unw_aux_info *,
3772 struct absaddr, const char **,
3774 static void dump_ia64_unwind PARAMS ((struct unw_aux_info *));
3775 static int slurp_ia64_unwind_table PARAMS ((FILE *, struct unw_aux_info *,
3776 Elf32_Internal_Shdr *));
3779 find_symbol_for_address (aux, addr, symname, offset)
3780 struct unw_aux_info *aux;
3781 struct absaddr addr;
3782 const char **symname;
3785 bfd_vma dist = (bfd_vma) 0x100000;
3786 Elf_Internal_Sym *sym, *best = NULL;
3789 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3791 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3792 && sym->st_name != 0
3793 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3794 && addr.offset >= sym->st_value
3795 && addr.offset - sym->st_value < dist)
3798 dist = addr.offset - sym->st_value;
3805 *symname = (best->st_name >= aux->strtab_size
3806 ? "<corrupt>" : aux->strtab + best->st_name);
3811 *offset = addr.offset;
3815 dump_ia64_unwind (aux)
3816 struct unw_aux_info *aux;
3819 struct unw_table_entry * tp;
3822 addr_size = is_32bit_elf ? 4 : 8;
3824 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3828 const unsigned char * dp;
3829 const unsigned char * head;
3830 const char * procname;
3832 find_symbol_for_address (aux, tp->start, &procname, &offset);
3834 fputs ("\n<", stdout);
3838 fputs (procname, stdout);
3841 printf ("+%lx", (unsigned long) offset);
3844 fputs (">: [", stdout);
3845 print_vma (tp->start.offset, PREFIX_HEX);
3846 fputc ('-', stdout);
3847 print_vma (tp->end.offset, PREFIX_HEX);
3848 printf ("), info at +0x%lx\n",
3849 (unsigned long) (tp->info.offset - aux->seg_base));
3851 head = aux->info + (tp->info.offset - aux->info_addr);
3852 stamp = BYTE_GET8 ((unsigned char *) head);
3854 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3855 (unsigned) UNW_VER (stamp),
3856 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
3857 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
3858 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
3859 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
3861 if (UNW_VER (stamp) != 1)
3863 printf ("\tUnknown version.\n");
3868 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
3869 dp = unw_decode (dp, in_body, & in_body);
3874 slurp_ia64_unwind_table (file, aux, sec)
3876 struct unw_aux_info *aux;
3877 Elf32_Internal_Shdr *sec;
3879 unsigned long size, addr_size, nrelas, i;
3880 Elf_Internal_Phdr *prog_hdrs, *seg;
3881 struct unw_table_entry *tep;
3882 Elf32_Internal_Shdr *relsec;
3883 Elf_Internal_Rela *rela, *rp;
3884 unsigned char *table, *tp;
3885 Elf_Internal_Sym *sym;
3886 const char *relname;
3889 addr_size = is_32bit_elf ? 4 : 8;
3891 /* First, find the starting address of the segment that includes
3894 if (elf_header.e_phnum)
3896 prog_hdrs = (Elf_Internal_Phdr *)
3897 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3900 result = get_32bit_program_headers (file, prog_hdrs);
3902 result = get_64bit_program_headers (file, prog_hdrs);
3910 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
3912 if (seg->p_type != PT_LOAD)
3915 if (sec->sh_addr >= seg->p_vaddr
3916 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
3918 aux->seg_base = seg->p_vaddr;
3926 /* Second, build the unwind table from the contents of the unwind section: */
3927 size = sec->sh_size;
3928 table = (char *) get_data (NULL, file, sec->sh_offset,
3929 size, _("unwind table"));
3933 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
3934 for (tp = table; tp < table + size; tp += 3 * addr_size, ++ tep)
3936 tep->start.section = SHN_UNDEF;
3937 tep->end.section = SHN_UNDEF;
3938 tep->info.section = SHN_UNDEF;
3941 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
3942 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
3943 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
3947 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
3948 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
3949 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
3951 tep->start.offset += aux->seg_base;
3952 tep->end.offset += aux->seg_base;
3953 tep->info.offset += aux->seg_base;
3957 /* Third, apply any relocations to the unwind table: */
3959 for (relsec = section_headers;
3960 relsec < section_headers + elf_header.e_shnum;
3963 if (relsec->sh_type != SHT_RELA
3964 || SECTION_HEADER (relsec->sh_info) != sec)
3967 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
3971 for (rp = rela; rp < rela + nrelas; ++rp)
3975 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
3976 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
3978 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
3980 warn (_("Skipping unexpected symbol type %u\n"),
3981 ELF32_ST_TYPE (sym->st_info));
3987 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
3988 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
3990 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
3992 warn (_("Skipping unexpected symbol type %u\n"),
3993 ELF64_ST_TYPE (sym->st_info));
3998 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
4000 warn (_("Skipping unexpected relocation type %s\n"), relname);
4004 i = rp->r_offset / (3 * addr_size);
4006 switch (rp->r_offset/addr_size % 3)
4009 aux->table[i].start.section = sym->st_shndx;
4010 aux->table[i].start.offset += rp->r_addend;
4013 aux->table[i].end.section = sym->st_shndx;
4014 aux->table[i].end.offset += rp->r_addend;
4017 aux->table[i].info.section = sym->st_shndx;
4018 aux->table[i].info.offset += rp->r_addend;
4028 aux->table_len = size / (3 * addr_size);
4033 process_unwind (file)
4036 Elf32_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4037 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
4038 struct unw_aux_info aux;
4043 if (elf_header.e_machine != EM_IA_64)
4045 printf (_("\nThere are no unwind sections in this file.\n"));
4049 memset (& aux, 0, sizeof (aux));
4051 addr_size = is_32bit_elf ? 4 : 8;
4053 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4055 if (sec->sh_type == SHT_SYMTAB)
4057 aux.nsyms = sec->sh_size / sec->sh_entsize;
4058 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4060 strsec = SECTION_HEADER (sec->sh_link);
4061 aux.strtab_size = strsec->sh_size;
4062 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
4063 aux.strtab_size, _("string table"));
4065 else if (sec->sh_type == SHT_IA_64_UNWIND)
4070 printf (_("\nThere are no unwind sections in this file.\n"));
4072 while (unwcount-- > 0)
4077 for (i = unwstart, sec = section_headers + unwstart;
4078 i < elf_header.e_shnum; ++i, ++sec)
4079 if (sec->sh_type == SHT_IA_64_UNWIND)
4086 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4088 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
4091 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4092 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4093 suffix = SECTION_NAME (unwsec) + len;
4094 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4096 if (strncmp (SECTION_NAME (sec),
4097 ELF_STRING_ia64_unwind_info_once, len2) == 0
4098 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4103 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4104 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4105 len = sizeof (ELF_STRING_ia64_unwind) - 1;
4106 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
4108 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
4110 suffix = SECTION_NAME (unwsec) + len;
4111 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4113 if (strncmp (SECTION_NAME (sec),
4114 ELF_STRING_ia64_unwind_info, len2) == 0
4115 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4119 if (i == elf_header.e_shnum)
4121 printf (_("\nCould not find unwind info section for "));
4123 if (string_table == NULL)
4124 printf ("%d", unwsec->sh_name);
4126 printf (_("'%s'"), SECTION_NAME (unwsec));
4130 aux.info_size = sec->sh_size;
4131 aux.info_addr = sec->sh_addr;
4132 aux.info = (char *) get_data (NULL, file, sec->sh_offset,
4133 aux.info_size, _("unwind info"));
4135 printf (_("\nUnwind section "));
4137 if (string_table == NULL)
4138 printf ("%d", unwsec->sh_name);
4140 printf (_("'%s'"), SECTION_NAME (unwsec));
4142 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4143 (unsigned long) unwsec->sh_offset,
4144 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
4146 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4148 if (aux.table_len > 0)
4149 dump_ia64_unwind (& aux);
4152 free ((char *) aux.table);
4154 free ((char *) aux.info);
4163 free ((char *) aux.strtab);
4169 dynamic_segment_mips_val (entry)
4170 Elf_Internal_Dyn * entry;
4172 switch (entry->d_tag)
4175 if (entry->d_un.d_val == 0)
4179 static const char * opts[] =
4181 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4182 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4183 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4184 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4189 for (cnt = 0; cnt < NUM_ELEM (opts); ++ cnt)
4190 if (entry->d_un.d_val & (1 << cnt))
4192 printf ("%s%s", first ? "" : " ", opts[cnt]);
4199 case DT_MIPS_IVERSION:
4200 if (dynamic_strings != NULL)
4201 printf ("Interface Version: %s\n",
4202 dynamic_strings + entry->d_un.d_val);
4204 printf ("%ld\n", (long) entry->d_un.d_ptr);
4207 case DT_MIPS_TIME_STAMP:
4212 time_t time = entry->d_un.d_val;
4213 tmp = gmtime (&time);
4214 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
4215 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4216 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4217 printf ("Time Stamp: %s\n", timebuf);
4221 case DT_MIPS_RLD_VERSION:
4222 case DT_MIPS_LOCAL_GOTNO:
4223 case DT_MIPS_CONFLICTNO:
4224 case DT_MIPS_LIBLISTNO:
4225 case DT_MIPS_SYMTABNO:
4226 case DT_MIPS_UNREFEXTNO:
4227 case DT_MIPS_HIPAGENO:
4228 case DT_MIPS_DELTA_CLASS_NO:
4229 case DT_MIPS_DELTA_INSTANCE_NO:
4230 case DT_MIPS_DELTA_RELOC_NO:
4231 case DT_MIPS_DELTA_SYM_NO:
4232 case DT_MIPS_DELTA_CLASSSYM_NO:
4233 case DT_MIPS_COMPACT_SIZE:
4234 printf ("%ld\n", (long) entry->d_un.d_ptr);
4238 printf ("%#lx\n", (long) entry->d_un.d_ptr);
4244 dynamic_segment_parisc_val (entry)
4245 Elf_Internal_Dyn * entry;
4247 switch (entry->d_tag)
4249 case DT_HP_DLD_FLAGS:
4258 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
4259 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
4260 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
4261 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
4262 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
4263 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
4264 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
4265 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
4266 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
4267 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
4268 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
4272 bfd_vma val = entry->d_un.d_val;
4274 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
4275 if (val & flags[cnt].bit)
4279 fputs (flags[cnt].str, stdout);
4281 val ^= flags[cnt].bit;
4284 if (val != 0 || first)
4288 print_vma (val, HEX);
4294 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4300 get_32bit_dynamic_segment (file)
4303 Elf32_External_Dyn * edyn;
4304 Elf_Internal_Dyn * entry;
4307 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr,
4308 dynamic_size, _("dynamic segment"));
4312 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4313 how large this .dynamic is now. We can do this even before the byte
4314 swapping since the DT_NULL tag is recognizable. */
4316 while (*(Elf32_Word *) edyn [dynamic_size++].d_tag != DT_NULL)
4319 dynamic_segment = (Elf_Internal_Dyn *)
4320 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4322 if (dynamic_segment == NULL)
4324 error (_("Out of memory\n"));
4329 for (i = 0, entry = dynamic_segment;
4333 entry->d_tag = BYTE_GET (edyn [i].d_tag);
4334 entry->d_un.d_val = BYTE_GET (edyn [i].d_un.d_val);
4343 get_64bit_dynamic_segment (file)
4346 Elf64_External_Dyn * edyn;
4347 Elf_Internal_Dyn * entry;
4350 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr,
4351 dynamic_size, _("dynamic segment"));
4355 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4356 how large this .dynamic is now. We can do this even before the byte
4357 swapping since the DT_NULL tag is recognizable. */
4359 while (*(bfd_vma *) edyn [dynamic_size ++].d_tag != DT_NULL)
4362 dynamic_segment = (Elf_Internal_Dyn *)
4363 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4365 if (dynamic_segment == NULL)
4367 error (_("Out of memory\n"));
4372 for (i = 0, entry = dynamic_segment;
4376 entry->d_tag = BYTE_GET8 (edyn [i].d_tag);
4377 entry->d_un.d_val = BYTE_GET8 (edyn [i].d_un.d_val);
4386 get_dynamic_flags (flags)
4389 static char buff [128];
4397 flag = flags & - flags;
4405 case DF_ORIGIN: strcpy (p, "ORIGIN"); break;
4406 case DF_SYMBOLIC: strcpy (p, "SYMBOLIC"); break;
4407 case DF_TEXTREL: strcpy (p, "TEXTREL"); break;
4408 case DF_BIND_NOW: strcpy (p, "BIND_NOW"); break;
4409 case DF_STATIC_TLS: strcpy (p, "STATIC_TLS"); break;
4410 default: strcpy (p, "unknown"); break;
4413 p = strchr (p, '\0');
4418 /* Parse and display the contents of the dynamic segment. */
4420 process_dynamic_segment (file)
4423 Elf_Internal_Dyn * entry;
4426 if (dynamic_size == 0)
4429 printf (_("\nThere is no dynamic segment in this file.\n"));
4436 if (! get_32bit_dynamic_segment (file))
4439 else if (! get_64bit_dynamic_segment (file))
4442 /* Find the appropriate symbol table. */
4443 if (dynamic_symbols == NULL)
4445 for (i = 0, entry = dynamic_segment;
4449 Elf32_Internal_Shdr section;
4451 if (entry->d_tag != DT_SYMTAB)
4454 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4456 /* Since we do not know how big the symbol table is,
4457 we default to reading in the entire file (!) and
4458 processing that. This is overkill, I know, but it
4460 section.sh_offset = entry->d_un.d_val - loadaddr;
4462 if (fseek (file, 0, SEEK_END))
4463 error (_("Unable to seek to end of file!"));
4465 section.sh_size = ftell (file) - section.sh_offset;
4467 section.sh_entsize = sizeof (Elf32_External_Sym);
4469 section.sh_entsize = sizeof (Elf64_External_Sym);
4471 num_dynamic_syms = section.sh_size / section.sh_entsize;
4472 if (num_dynamic_syms < 1)
4474 error (_("Unable to determine the number of symbols to load\n"));
4478 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
4482 /* Similarly find a string table. */
4483 if (dynamic_strings == NULL)
4485 for (i = 0, entry = dynamic_segment;
4489 unsigned long offset;
4492 if (entry->d_tag != DT_STRTAB)
4495 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4497 /* Since we do not know how big the string table is,
4498 we default to reading in the entire file (!) and
4499 processing that. This is overkill, I know, but it
4502 offset = entry->d_un.d_val - loadaddr;
4503 if (fseek (file, 0, SEEK_END))
4504 error (_("Unable to seek to end of file\n"));
4505 str_tab_len = ftell (file) - offset;
4507 if (str_tab_len < 1)
4510 (_("Unable to determine the length of the dynamic string table\n"));
4514 dynamic_strings = (char *) get_data (NULL, file, offset, str_tab_len,
4515 _("dynamic string table"));
4520 /* And find the syminfo section if available. */
4521 if (dynamic_syminfo == NULL)
4523 unsigned int syminsz = 0;
4525 for (i = 0, entry = dynamic_segment;
4529 if (entry->d_tag == DT_SYMINENT)
4531 /* Note: these braces are necessary to avoid a syntax
4532 error from the SunOS4 C compiler. */
4533 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4535 else if (entry->d_tag == DT_SYMINSZ)
4536 syminsz = entry->d_un.d_val;
4537 else if (entry->d_tag == DT_SYMINFO)
4538 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
4541 if (dynamic_syminfo_offset != 0 && syminsz != 0)
4543 Elf_External_Syminfo * extsyminfo;
4544 Elf_Internal_Syminfo * syminfo;
4546 /* There is a syminfo section. Read the data. */
4547 extsyminfo = ((Elf_External_Syminfo *)
4548 get_data (NULL, file, dynamic_syminfo_offset,
4549 syminsz, _("symbol information")));
4553 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
4554 if (dynamic_syminfo == NULL)
4556 error (_("Out of memory\n"));
4560 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4561 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4564 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4565 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4572 if (do_dynamic && dynamic_addr)
4573 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4574 dynamic_addr, (long) dynamic_size);
4576 printf (_(" Tag Type Name/Value\n"));
4578 for (i = 0, entry = dynamic_segment;
4587 print_vma (entry->d_tag, FULL_HEX);
4588 dtype = get_dynamic_type (entry->d_tag);
4589 printf (" (%s)%*s", dtype,
4590 ((is_32bit_elf ? 27 : 19)
4591 - (int) strlen (dtype)),
4595 switch (entry->d_tag)
4599 puts (get_dynamic_flags (entry->d_un.d_val));
4609 switch (entry->d_tag)
4612 printf (_("Auxiliary library"));
4616 printf (_("Filter library"));
4620 printf (_("Configuration file"));
4624 printf (_("Dependency audit library"));
4628 printf (_("Audit library"));
4632 if (dynamic_strings)
4633 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4637 print_vma (entry->d_un.d_val, PREFIX_HEX);
4646 printf (_("Flags:"));
4647 if (entry->d_un.d_val == 0)
4648 printf (_(" None\n"));
4651 unsigned long int val = entry->d_un.d_val;
4652 if (val & DTF_1_PARINIT)
4654 printf (" PARINIT");
4655 val ^= DTF_1_PARINIT;
4657 if (val & DTF_1_CONFEXP)
4659 printf (" CONFEXP");
4660 val ^= DTF_1_CONFEXP;
4663 printf (" %lx", val);
4672 printf (_("Flags:"));
4673 if (entry->d_un.d_val == 0)
4674 printf (_(" None\n"));
4677 unsigned long int val = entry->d_un.d_val;
4678 if (val & DF_P1_LAZYLOAD)
4680 printf (" LAZYLOAD");
4681 val ^= DF_P1_LAZYLOAD;
4683 if (val & DF_P1_GROUPPERM)
4685 printf (" GROUPPERM");
4686 val ^= DF_P1_GROUPPERM;
4689 printf (" %lx", val);
4698 printf (_("Flags:"));
4699 if (entry->d_un.d_val == 0)
4700 printf (_(" None\n"));
4703 unsigned long int val = entry->d_un.d_val;
4709 if (val & DF_1_GLOBAL)
4714 if (val & DF_1_GROUP)
4719 if (val & DF_1_NODELETE)
4721 printf (" NODELETE");
4722 val ^= DF_1_NODELETE;
4724 if (val & DF_1_LOADFLTR)
4726 printf (" LOADFLTR");
4727 val ^= DF_1_LOADFLTR;
4729 if (val & DF_1_INITFIRST)
4731 printf (" INITFIRST");
4732 val ^= DF_1_INITFIRST;
4734 if (val & DF_1_NOOPEN)
4739 if (val & DF_1_ORIGIN)
4744 if (val & DF_1_DIRECT)
4749 if (val & DF_1_TRANS)
4754 if (val & DF_1_INTERPOSE)
4756 printf (" INTERPOSE");
4757 val ^= DF_1_INTERPOSE;
4759 if (val & DF_1_NODEFLIB)
4761 printf (" NODEFLIB");
4762 val ^= DF_1_NODEFLIB;
4764 if (val & DF_1_NODUMP)
4769 if (val & DF_1_CONLFAT)
4771 printf (" CONLFAT");
4772 val ^= DF_1_CONLFAT;
4775 printf (" %lx", val);
4783 puts (get_dynamic_type (entry->d_un.d_val));
4803 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4809 if (dynamic_strings == NULL)
4812 name = dynamic_strings + entry->d_un.d_val;
4816 switch (entry->d_tag)
4819 printf (_("Shared library: [%s]"), name);
4821 if (strcmp (name, program_interpreter) == 0)
4822 printf (_(" program interpreter"));
4826 printf (_("Library soname: [%s]"), name);
4830 printf (_("Library rpath: [%s]"), name);
4834 printf (_("Library runpath: [%s]"), name);
4838 print_vma (entry->d_un.d_val, PREFIX_HEX);
4843 print_vma (entry->d_un.d_val, PREFIX_HEX);
4859 case DT_INIT_ARRAYSZ:
4860 case DT_FINI_ARRAYSZ:
4861 case DT_GNU_CONFLICTSZ:
4862 case DT_GNU_LIBLISTSZ:
4865 print_vma (entry->d_un.d_val, UNSIGNED);
4866 printf (" (bytes)\n");
4876 print_vma (entry->d_un.d_val, UNSIGNED);
4889 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
4893 name = dynamic_strings + entry->d_un.d_val;
4897 printf (_("Not needed object: [%s]\n"), name);
4902 print_vma (entry->d_un.d_val, PREFIX_HEX);
4908 /* The value of this entry is ignored. */
4911 case DT_GNU_PRELINKED:
4915 time_t time = entry->d_un.d_val;
4917 tmp = gmtime (&time);
4918 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
4919 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4920 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4926 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
4927 version_info [DT_VERSIONTAGIDX (entry->d_tag)] =
4932 switch (elf_header.e_machine)
4935 case EM_MIPS_RS3_LE:
4936 dynamic_segment_mips_val (entry);
4939 dynamic_segment_parisc_val (entry);
4942 print_vma (entry->d_un.d_val, PREFIX_HEX);
4954 get_ver_flags (flags)
4957 static char buff [32];
4964 if (flags & VER_FLG_BASE)
4965 strcat (buff, "BASE ");
4967 if (flags & VER_FLG_WEAK)
4969 if (flags & VER_FLG_BASE)
4970 strcat (buff, "| ");
4972 strcat (buff, "WEAK ");
4975 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
4976 strcat (buff, "| <unknown>");
4981 /* Display the contents of the version sections. */
4983 process_version_sections (file)
4986 Elf32_Internal_Shdr * section;
4993 for (i = 0, section = section_headers;
4994 i < elf_header.e_shnum;
4997 switch (section->sh_type)
4999 case SHT_GNU_verdef:
5001 Elf_External_Verdef * edefs;
5008 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5009 SECTION_NAME (section), section->sh_info);
5011 printf (_(" Addr: 0x"));
5012 printf_vma (section->sh_addr);
5013 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5014 (unsigned long) section->sh_offset, section->sh_link,
5015 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5017 edefs = ((Elf_External_Verdef *)
5018 get_data (NULL, file, section->sh_offset,
5020 _("version definition section")));
5024 for (idx = cnt = 0; cnt < section->sh_info; ++ cnt)
5027 Elf_External_Verdef * edef;
5028 Elf_Internal_Verdef ent;
5029 Elf_External_Verdaux * eaux;
5030 Elf_Internal_Verdaux aux;
5034 vstart = ((char *) edefs) + idx;
5036 edef = (Elf_External_Verdef *) vstart;
5038 ent.vd_version = BYTE_GET (edef->vd_version);
5039 ent.vd_flags = BYTE_GET (edef->vd_flags);
5040 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
5041 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
5042 ent.vd_hash = BYTE_GET (edef->vd_hash);
5043 ent.vd_aux = BYTE_GET (edef->vd_aux);
5044 ent.vd_next = BYTE_GET (edef->vd_next);
5046 printf (_(" %#06x: Rev: %d Flags: %s"),
5047 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
5049 printf (_(" Index: %d Cnt: %d "),
5050 ent.vd_ndx, ent.vd_cnt);
5052 vstart += ent.vd_aux;
5054 eaux = (Elf_External_Verdaux *) vstart;
5056 aux.vda_name = BYTE_GET (eaux->vda_name);
5057 aux.vda_next = BYTE_GET (eaux->vda_next);
5059 if (dynamic_strings)
5060 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
5062 printf (_("Name index: %ld\n"), aux.vda_name);
5064 isum = idx + ent.vd_aux;
5066 for (j = 1; j < ent.vd_cnt; j ++)
5068 isum += aux.vda_next;
5069 vstart += aux.vda_next;
5071 eaux = (Elf_External_Verdaux *) vstart;
5073 aux.vda_name = BYTE_GET (eaux->vda_name);
5074 aux.vda_next = BYTE_GET (eaux->vda_next);
5076 if (dynamic_strings)
5077 printf (_(" %#06x: Parent %d: %s\n"),
5078 isum, j, dynamic_strings + aux.vda_name);
5080 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5081 isum, j, aux.vda_name);
5091 case SHT_GNU_verneed:
5093 Elf_External_Verneed * eneed;
5099 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5100 SECTION_NAME (section), section->sh_info);
5102 printf (_(" Addr: 0x"));
5103 printf_vma (section->sh_addr);
5104 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5105 (unsigned long) section->sh_offset, section->sh_link,
5106 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5108 eneed = ((Elf_External_Verneed *)
5109 get_data (NULL, file, section->sh_offset,
5110 section->sh_size, _("version need section")));
5114 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5116 Elf_External_Verneed * entry;
5117 Elf_Internal_Verneed ent;
5122 vstart = ((char *) eneed) + idx;
5124 entry = (Elf_External_Verneed *) vstart;
5126 ent.vn_version = BYTE_GET (entry->vn_version);
5127 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
5128 ent.vn_file = BYTE_GET (entry->vn_file);
5129 ent.vn_aux = BYTE_GET (entry->vn_aux);
5130 ent.vn_next = BYTE_GET (entry->vn_next);
5132 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
5134 if (dynamic_strings)
5135 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
5137 printf (_(" File: %lx"), ent.vn_file);
5139 printf (_(" Cnt: %d\n"), ent.vn_cnt);
5141 vstart += ent.vn_aux;
5143 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
5145 Elf_External_Vernaux * eaux;
5146 Elf_Internal_Vernaux aux;
5148 eaux = (Elf_External_Vernaux *) vstart;
5150 aux.vna_hash = BYTE_GET (eaux->vna_hash);
5151 aux.vna_flags = BYTE_GET (eaux->vna_flags);
5152 aux.vna_other = BYTE_GET (eaux->vna_other);
5153 aux.vna_name = BYTE_GET (eaux->vna_name);
5154 aux.vna_next = BYTE_GET (eaux->vna_next);
5156 if (dynamic_strings)
5157 printf (_(" %#06x: Name: %s"),
5158 isum, dynamic_strings + aux.vna_name);
5160 printf (_(" %#06x: Name index: %lx"),
5161 isum, aux.vna_name);
5163 printf (_(" Flags: %s Version: %d\n"),
5164 get_ver_flags (aux.vna_flags), aux.vna_other);
5166 isum += aux.vna_next;
5167 vstart += aux.vna_next;
5177 case SHT_GNU_versym:
5179 Elf32_Internal_Shdr * link_section;
5182 unsigned char * edata;
5183 unsigned short * data;
5185 Elf_Internal_Sym * symbols;
5186 Elf32_Internal_Shdr * string_sec;
5188 link_section = SECTION_HEADER (section->sh_link);
5189 total = section->sh_size / section->sh_entsize;
5193 symbols = GET_ELF_SYMBOLS (file, link_section);
5195 string_sec = SECTION_HEADER (link_section->sh_link);
5197 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5198 string_sec->sh_size,
5199 _("version string table"));
5203 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5204 SECTION_NAME (section), total);
5206 printf (_(" Addr: "));
5207 printf_vma (section->sh_addr);
5208 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5209 (unsigned long) section->sh_offset, section->sh_link,
5210 SECTION_NAME (link_section));
5214 get_data (NULL, file,
5215 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] - loadaddr,
5216 total * sizeof (short), _("version symbol data")));
5223 data = (unsigned short *) malloc (total * sizeof (short));
5225 for (cnt = total; cnt --;)
5226 data [cnt] = byte_get (edata + cnt * sizeof (short),
5231 for (cnt = 0; cnt < total; cnt += 4)
5234 int check_def, check_need;
5237 printf (" %03x:", cnt);
5239 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
5240 switch (data [cnt + j])
5243 fputs (_(" 0 (*local*) "), stdout);
5247 fputs (_(" 1 (*global*) "), stdout);
5251 nn = printf ("%4x%c", data [cnt + j] & 0x7fff,
5252 data [cnt + j] & 0x8000 ? 'h' : ' ');
5256 if (SECTION_HEADER (symbols [cnt + j].st_shndx)->sh_type
5259 if (symbols [cnt + j].st_shndx == SHN_UNDEF)
5266 && version_info [DT_VERSIONTAGIDX (DT_VERNEED)])
5268 Elf_Internal_Verneed ivn;
5269 unsigned long offset;
5271 offset = version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5276 Elf_Internal_Vernaux ivna;
5277 Elf_External_Verneed evn;
5278 Elf_External_Vernaux evna;
5279 unsigned long a_off;
5281 get_data (&evn, file, offset, sizeof (evn),
5284 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5285 ivn.vn_next = BYTE_GET (evn.vn_next);
5287 a_off = offset + ivn.vn_aux;
5291 get_data (&evna, file, a_off, sizeof (evna),
5292 _("version need aux (2)"));
5294 ivna.vna_next = BYTE_GET (evna.vna_next);
5295 ivna.vna_other = BYTE_GET (evna.vna_other);
5297 a_off += ivna.vna_next;
5299 while (ivna.vna_other != data [cnt + j]
5300 && ivna.vna_next != 0);
5302 if (ivna.vna_other == data [cnt + j])
5304 ivna.vna_name = BYTE_GET (evna.vna_name);
5306 name = strtab + ivna.vna_name;
5307 nn += printf ("(%s%-*s",
5309 12 - (int) strlen (name),
5315 offset += ivn.vn_next;
5317 while (ivn.vn_next);
5320 if (check_def && data [cnt + j] != 0x8001
5321 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5323 Elf_Internal_Verdef ivd;
5324 Elf_External_Verdef evd;
5325 unsigned long offset;
5327 offset = version_info
5328 [DT_VERSIONTAGIDX (DT_VERDEF)] - loadaddr;
5332 get_data (&evd, file, offset, sizeof (evd),
5335 ivd.vd_next = BYTE_GET (evd.vd_next);
5336 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5338 offset += ivd.vd_next;
5340 while (ivd.vd_ndx != (data [cnt + j] & 0x7fff)
5341 && ivd.vd_next != 0);
5343 if (ivd.vd_ndx == (data [cnt + j] & 0x7fff))
5345 Elf_External_Verdaux evda;
5346 Elf_Internal_Verdaux ivda;
5348 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5350 get_data (&evda, file,
5351 offset - ivd.vd_next + ivd.vd_aux,
5352 sizeof (evda), _("version def aux"));
5354 ivda.vda_name = BYTE_GET (evda.vda_name);
5356 name = strtab + ivda.vda_name;
5357 nn += printf ("(%s%-*s",
5359 12 - (int) strlen (name),
5365 printf ("%*c", 18 - nn, ' ');
5383 printf (_("\nNo version information found in this file.\n"));
5389 get_symbol_binding (binding)
5390 unsigned int binding;
5392 static char buff [32];
5396 case STB_LOCAL: return "LOCAL";
5397 case STB_GLOBAL: return "GLOBAL";
5398 case STB_WEAK: return "WEAK";
5400 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
5401 sprintf (buff, _("<processor specific>: %d"), binding);
5402 else if (binding >= STB_LOOS && binding <= STB_HIOS)
5403 sprintf (buff, _("<OS specific>: %d"), binding);
5405 sprintf (buff, _("<unknown>: %d"), binding);
5411 get_symbol_type (type)
5414 static char buff [32];
5418 case STT_NOTYPE: return "NOTYPE";
5419 case STT_OBJECT: return "OBJECT";
5420 case STT_FUNC: return "FUNC";
5421 case STT_SECTION: return "SECTION";
5422 case STT_FILE: return "FILE";
5423 case STT_COMMON: return "COMMON";
5424 case STT_TLS: return "TLS";
5426 if (type >= STT_LOPROC && type <= STT_HIPROC)
5428 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
5429 return "THUMB_FUNC";
5431 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
5434 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
5435 return "PARISC_MILLI";
5437 sprintf (buff, _("<processor specific>: %d"), type);
5439 else if (type >= STT_LOOS && type <= STT_HIOS)
5441 if (elf_header.e_machine == EM_PARISC)
5443 if (type == STT_HP_OPAQUE)
5445 if (type == STT_HP_STUB)
5449 sprintf (buff, _("<OS specific>: %d"), type);
5452 sprintf (buff, _("<unknown>: %d"), type);
5458 get_symbol_visibility (visibility)
5459 unsigned int visibility;
5463 case STV_DEFAULT: return "DEFAULT";
5464 case STV_INTERNAL: return "INTERNAL";
5465 case STV_HIDDEN: return "HIDDEN";
5466 case STV_PROTECTED: return "PROTECTED";
5472 get_symbol_index_type (type)
5477 case SHN_UNDEF: return "UND";
5478 case SHN_ABS: return "ABS";
5479 case SHN_COMMON: return "COM";
5481 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5483 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5485 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5489 static char buff [32];
5491 sprintf (buff, "%3d", type);
5498 get_dynamic_data (file, number)
5500 unsigned int number;
5502 unsigned char * e_data;
5505 e_data = (unsigned char *) malloc (number * 4);
5509 error (_("Out of memory\n"));
5513 if (fread (e_data, 4, number, file) != number)
5515 error (_("Unable to read in dynamic data\n"));
5519 i_data = (int *) malloc (number * sizeof (* i_data));
5523 error (_("Out of memory\n"));
5529 i_data [number] = byte_get (e_data + number * 4, 4);
5536 /* Dump the symbol table. */
5538 process_symbol_table (file)
5541 Elf32_Internal_Shdr * section;
5542 unsigned char nb [4];
5543 unsigned char nc [4];
5546 int * buckets = NULL;
5547 int * chains = NULL;
5549 if (! do_syms && !do_histogram)
5552 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5555 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
5557 error (_("Unable to seek to start of dynamic information"));
5561 if (fread (nb, sizeof (nb), 1, file) != 1)
5563 error (_("Failed to read in number of buckets\n"));
5567 if (fread (nc, sizeof (nc), 1, file) != 1)
5569 error (_("Failed to read in number of chains\n"));
5573 nbuckets = byte_get (nb, 4);
5574 nchains = byte_get (nc, 4);
5576 buckets = get_dynamic_data (file, nbuckets);
5577 chains = get_dynamic_data (file, nchains);
5579 if (buckets == NULL || chains == NULL)
5584 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5589 printf (_("\nSymbol table for image:\n"));
5591 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5593 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5595 for (hn = 0; hn < nbuckets; hn++)
5600 for (si = buckets [hn]; si < nchains && si > 0; si = chains [si])
5602 Elf_Internal_Sym * psym;
5604 psym = dynamic_symbols + si;
5606 printf (" %3d %3d: ", si, hn);
5607 print_vma (psym->st_value, LONG_HEX);
5609 print_vma (psym->st_size, DEC_5);
5611 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5612 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5613 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5614 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
5615 print_symbol (25, dynamic_strings + psym->st_name);
5620 else if (do_syms && !do_using_dynamic)
5624 for (i = 0, section = section_headers;
5625 i < elf_header.e_shnum;
5630 Elf_Internal_Sym * symtab;
5631 Elf_Internal_Sym * psym;
5634 if ( section->sh_type != SHT_SYMTAB
5635 && section->sh_type != SHT_DYNSYM)
5638 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5639 SECTION_NAME (section),
5640 (unsigned long) (section->sh_size / section->sh_entsize));
5642 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5644 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5646 symtab = GET_ELF_SYMBOLS (file, section);
5650 if (section->sh_link == elf_header.e_shstrndx)
5651 strtab = string_table;
5654 Elf32_Internal_Shdr * string_sec;
5656 string_sec = SECTION_HEADER (section->sh_link);
5658 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5659 string_sec->sh_size,
5663 for (si = 0, psym = symtab;
5664 si < section->sh_size / section->sh_entsize;
5667 printf ("%6d: ", si);
5668 print_vma (psym->st_value, LONG_HEX);
5670 print_vma (psym->st_size, DEC_5);
5671 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5672 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5673 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5674 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
5675 print_symbol (25, strtab + psym->st_name);
5677 if (section->sh_type == SHT_DYNSYM &&
5678 version_info [DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5680 unsigned char data[2];
5681 unsigned short vers_data;
5682 unsigned long offset;
5686 offset = version_info [DT_VERSIONTAGIDX (DT_VERSYM)]
5689 get_data (&data, file, offset + si * sizeof (vers_data),
5690 sizeof (data), _("version data"));
5692 vers_data = byte_get (data, 2);
5694 is_nobits = (SECTION_HEADER (psym->st_shndx)->sh_type
5697 check_def = (psym->st_shndx != SHN_UNDEF);
5699 if ((vers_data & 0x8000) || vers_data > 1)
5701 if (version_info [DT_VERSIONTAGIDX (DT_VERNEED)]
5702 && (is_nobits || ! check_def))
5704 Elf_External_Verneed evn;
5705 Elf_Internal_Verneed ivn;
5706 Elf_Internal_Vernaux ivna;
5708 /* We must test both. */
5709 offset = version_info
5710 [DT_VERSIONTAGIDX (DT_VERNEED)] - loadaddr;
5714 unsigned long vna_off;
5716 get_data (&evn, file, offset, sizeof (evn),
5719 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5720 ivn.vn_next = BYTE_GET (evn.vn_next);
5722 vna_off = offset + ivn.vn_aux;
5726 Elf_External_Vernaux evna;
5728 get_data (&evna, file, vna_off,
5730 _("version need aux (3)"));
5732 ivna.vna_other = BYTE_GET (evna.vna_other);
5733 ivna.vna_next = BYTE_GET (evna.vna_next);
5734 ivna.vna_name = BYTE_GET (evna.vna_name);
5736 vna_off += ivna.vna_next;
5738 while (ivna.vna_other != vers_data
5739 && ivna.vna_next != 0);
5741 if (ivna.vna_other == vers_data)
5744 offset += ivn.vn_next;
5746 while (ivn.vn_next != 0);
5748 if (ivna.vna_other == vers_data)
5751 strtab + ivna.vna_name, ivna.vna_other);
5754 else if (! is_nobits)
5755 error (_("bad dynamic symbol"));
5762 if (vers_data != 0x8001
5763 && version_info [DT_VERSIONTAGIDX (DT_VERDEF)])
5765 Elf_Internal_Verdef ivd;
5766 Elf_Internal_Verdaux ivda;
5767 Elf_External_Verdaux evda;
5768 unsigned long offset;
5771 version_info [DT_VERSIONTAGIDX (DT_VERDEF)]
5776 Elf_External_Verdef evd;
5778 get_data (&evd, file, offset, sizeof (evd),
5781 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5782 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5783 ivd.vd_next = BYTE_GET (evd.vd_next);
5785 offset += ivd.vd_next;
5787 while (ivd.vd_ndx != (vers_data & 0x7fff)
5788 && ivd.vd_next != 0);
5790 offset -= ivd.vd_next;
5791 offset += ivd.vd_aux;
5793 get_data (&evda, file, offset, sizeof (evda),
5794 _("version def aux"));
5796 ivda.vda_name = BYTE_GET (evda.vda_name);
5798 if (psym->st_name != ivda.vda_name)
5799 printf ((vers_data & 0x8000)
5801 strtab + ivda.vda_name);
5811 if (strtab != string_table)
5817 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5819 if (do_histogram && buckets != NULL)
5826 int nzero_counts = 0;
5829 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5831 printf (_(" Length Number %% of total Coverage\n"));
5833 lengths = (int *) calloc (nbuckets, sizeof (int));
5834 if (lengths == NULL)
5836 error (_("Out of memory"));
5839 for (hn = 0; hn < nbuckets; ++hn)
5844 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
5847 if (maxlength < ++lengths[hn])
5852 counts = (int *) calloc (maxlength + 1, sizeof (int));
5855 error (_("Out of memory"));
5859 for (hn = 0; hn < nbuckets; ++hn)
5860 ++ counts [lengths [hn]];
5864 printf (" 0 %-10d (%5.1f%%)\n",
5865 counts[0], (counts[0] * 100.0) / nbuckets);
5866 for (si = 1; si <= maxlength; ++si)
5868 nzero_counts += counts[si] * si;
5869 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5870 si, counts[si], (counts[si] * 100.0) / nbuckets,
5871 (nzero_counts * 100.0) / nsyms);
5879 if (buckets != NULL)
5889 process_syminfo (file)
5890 FILE * file ATTRIBUTE_UNUSED;
5894 if (dynamic_syminfo == NULL
5896 /* No syminfo, this is ok. */
5899 /* There better should be a dynamic symbol section. */
5900 if (dynamic_symbols == NULL || dynamic_strings == NULL)
5904 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5905 dynamic_syminfo_offset, dynamic_syminfo_nent);
5907 printf (_(" Num: Name BoundTo Flags\n"));
5908 for (i = 0; i < dynamic_syminfo_nent; ++i)
5910 unsigned short int flags = dynamic_syminfo[i].si_flags;
5912 printf ("%4d: ", i);
5913 print_symbol (30, dynamic_strings + dynamic_symbols[i].st_name);
5916 switch (dynamic_syminfo[i].si_boundto)
5918 case SYMINFO_BT_SELF:
5919 fputs ("SELF ", stdout);
5921 case SYMINFO_BT_PARENT:
5922 fputs ("PARENT ", stdout);
5925 if (dynamic_syminfo[i].si_boundto > 0
5926 && dynamic_syminfo[i].si_boundto < dynamic_size)
5928 print_symbol (10, dynamic_strings
5930 [dynamic_syminfo[i].si_boundto].d_un.d_val);
5934 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
5938 if (flags & SYMINFO_FLG_DIRECT)
5940 if (flags & SYMINFO_FLG_PASSTHRU)
5941 printf (" PASSTHRU");
5942 if (flags & SYMINFO_FLG_COPY)
5944 if (flags & SYMINFO_FLG_LAZYLOAD)
5945 printf (" LAZYLOAD");
5953 #ifdef SUPPORT_DISASSEMBLY
5955 disassemble_section (section, file)
5956 Elf32_Internal_Shdr * section;
5959 printf (_("\nAssembly dump of section %s\n"),
5960 SECTION_NAME (section));
5962 /* XXX -- to be done --- XXX */
5969 dump_section (section, file)
5970 Elf32_Internal_Shdr * section;
5973 bfd_size_type bytes;
5975 unsigned char * data;
5976 unsigned char * start;
5978 bytes = section->sh_size;
5982 printf (_("\nSection '%s' has no data to dump.\n"),
5983 SECTION_NAME (section));
5987 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
5989 addr = section->sh_addr;
5991 start = (unsigned char *) get_data (NULL, file, section->sh_offset, bytes,
6004 lbytes = (bytes > 16 ? 16 : bytes);
6006 printf (" 0x%8.8lx ", (unsigned long) addr);
6008 switch (elf_header.e_ident [EI_DATA])
6012 for (j = 15; j >= 0; j --)
6015 printf ("%2.2x", data [j]);
6025 for (j = 0; j < 16; j++)
6028 printf ("%2.2x", data [j]);
6038 for (j = 0; j < lbytes; j++)
6041 if (k >= ' ' && k < 0x80)
6060 static unsigned long int
6061 read_leb128 (data, length_return, sign)
6062 unsigned char * data;
6063 int * length_return;
6066 unsigned long int result = 0;
6067 unsigned int num_read = 0;
6076 result |= (byte & 0x7f) << shift;
6081 while (byte & 0x80);
6083 if (length_return != NULL)
6084 * length_return = num_read;
6086 if (sign && (shift < 32) && (byte & 0x40))
6087 result |= -1 << shift;
6092 typedef struct State_Machine_Registers
6094 unsigned long address;
6097 unsigned int column;
6101 /* This variable hold the number of the last entry seen
6102 in the File Table. */
6103 unsigned int last_file_entry;
6106 static SMR state_machine_regs;
6109 reset_state_machine (is_stmt)
6112 state_machine_regs.address = 0;
6113 state_machine_regs.file = 1;
6114 state_machine_regs.line = 1;
6115 state_machine_regs.column = 0;
6116 state_machine_regs.is_stmt = is_stmt;
6117 state_machine_regs.basic_block = 0;
6118 state_machine_regs.end_sequence = 0;
6119 state_machine_regs.last_file_entry = 0;
6122 /* Handled an extend line op. Returns true if this is the end
6125 process_extended_line_op (data, is_stmt, pointer_size)
6126 unsigned char * data;
6130 unsigned char op_code;
6133 unsigned char * name;
6136 len = read_leb128 (data, & bytes_read, 0);
6141 warn (_("badly formed extended line op encountered!\n"));
6146 op_code = * data ++;
6148 printf (_(" Extended opcode %d: "), op_code);
6152 case DW_LNE_end_sequence:
6153 printf (_("End of Sequence\n\n"));
6154 reset_state_machine (is_stmt);
6157 case DW_LNE_set_address:
6158 adr = byte_get (data, pointer_size);
6159 printf (_("set Address to 0x%lx\n"), adr);
6160 state_machine_regs.address = adr;
6163 case DW_LNE_define_file:
6164 printf (_(" define new File Table entry\n"));
6165 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6167 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
6169 data += strlen ((char *) data) + 1;
6170 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6172 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6174 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6175 printf (_("%s\n\n"), name);
6179 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
6186 /* Size of pointers in the .debug_line section. This information is not
6187 really present in that section. It's obtained before dumping the debug
6188 sections by doing some pre-scan of the .debug_info section. */
6189 static int debug_line_pointer_size = 4;
6192 display_debug_lines (section, start, file)
6193 Elf32_Internal_Shdr * section;
6194 unsigned char * start;
6195 FILE * file ATTRIBUTE_UNUSED;
6197 DWARF2_External_LineInfo * external;
6198 DWARF2_Internal_LineInfo info;
6199 unsigned char * standard_opcodes;
6200 unsigned char * data = start;
6201 unsigned char * end = start + section->sh_size;
6202 unsigned char * end_of_sequence;
6205 printf (_("\nDump of debug contents of section %s:\n\n"),
6206 SECTION_NAME (section));
6210 external = (DWARF2_External_LineInfo *) data;
6212 /* Check the length of the block. */
6213 info.li_length = BYTE_GET (external->li_length);
6215 if (info.li_length == 0xffffffff)
6217 warn (_("64-bit DWARF line info is not supported yet.\n"));
6221 if (info.li_length + sizeof (external->li_length) > section->sh_size)
6224 (_("The line info appears to be corrupt - the section is too small\n"));
6228 /* Check its version number. */
6229 info.li_version = BYTE_GET (external->li_version);
6230 if (info.li_version != 2)
6232 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6236 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
6237 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
6238 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
6239 info.li_line_base = BYTE_GET (external->li_line_base);
6240 info.li_line_range = BYTE_GET (external->li_line_range);
6241 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
6243 /* Sign extend the line base field. */
6244 info.li_line_base <<= 24;
6245 info.li_line_base >>= 24;
6247 printf (_(" Length: %ld\n"), info.li_length);
6248 printf (_(" DWARF Version: %d\n"), info.li_version);
6249 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
6250 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
6251 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
6252 printf (_(" Line Base: %d\n"), info.li_line_base);
6253 printf (_(" Line Range: %d\n"), info.li_line_range);
6254 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
6256 end_of_sequence = data + info.li_length + sizeof (external->li_length);
6258 reset_state_machine (info.li_default_is_stmt);
6260 /* Display the contents of the Opcodes table. */
6261 standard_opcodes = data + sizeof (* external);
6263 printf (_("\n Opcodes:\n"));
6265 for (i = 1; i < info.li_opcode_base; i++)
6266 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
6268 /* Display the contents of the Directory table. */
6269 data = standard_opcodes + info.li_opcode_base - 1;
6272 printf (_("\n The Directory Table is empty.\n"));
6275 printf (_("\n The Directory Table:\n"));
6279 printf (_(" %s\n"), data);
6281 data += strlen ((char *) data) + 1;
6285 /* Skip the NUL at the end of the table. */
6288 /* Display the contents of the File Name table. */
6290 printf (_("\n The File Name Table is empty.\n"));
6293 printf (_("\n The File Name Table:\n"));
6294 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6298 unsigned char * name;
6301 printf (_(" %d\t"), ++ state_machine_regs.last_file_entry);
6304 data += strlen ((char *) data) + 1;
6306 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6308 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6310 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6312 printf (_("%s\n"), name);
6316 /* Skip the NUL at the end of the table. */
6319 /* Now display the statements. */
6320 printf (_("\n Line Number Statements:\n"));
6323 while (data < end_of_sequence)
6325 unsigned char op_code;
6329 op_code = * data ++;
6331 if (op_code >= info.li_opcode_base)
6333 op_code -= info.li_opcode_base;
6334 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
6335 state_machine_regs.address += adv;
6336 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6337 op_code, adv, state_machine_regs.address);
6338 adv = (op_code % info.li_line_range) + info.li_line_base;
6339 state_machine_regs.line += adv;
6340 printf (_(" and Line by %d to %d\n"),
6341 adv, state_machine_regs.line);
6343 else switch (op_code)
6345 case DW_LNS_extended_op:
6346 data += process_extended_line_op (data, info.li_default_is_stmt,
6347 debug_line_pointer_size);
6351 printf (_(" Copy\n"));
6354 case DW_LNS_advance_pc:
6355 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
6357 state_machine_regs.address += adv;
6358 printf (_(" Advance PC by %d to %lx\n"), adv,
6359 state_machine_regs.address);
6362 case DW_LNS_advance_line:
6363 adv = read_leb128 (data, & bytes_read, 1);
6365 state_machine_regs.line += adv;
6366 printf (_(" Advance Line by %d to %d\n"), adv,
6367 state_machine_regs.line);
6370 case DW_LNS_set_file:
6371 adv = read_leb128 (data, & bytes_read, 0);
6373 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6375 state_machine_regs.file = adv;
6378 case DW_LNS_set_column:
6379 adv = read_leb128 (data, & bytes_read, 0);
6381 printf (_(" Set column to %d\n"), adv);
6382 state_machine_regs.column = adv;
6385 case DW_LNS_negate_stmt:
6386 adv = state_machine_regs.is_stmt;
6388 printf (_(" Set is_stmt to %d\n"), adv);
6389 state_machine_regs.is_stmt = adv;
6392 case DW_LNS_set_basic_block:
6393 printf (_(" Set basic block\n"));
6394 state_machine_regs.basic_block = 1;
6397 case DW_LNS_const_add_pc:
6398 adv = (((255 - info.li_opcode_base) / info.li_line_range)
6399 * info.li_min_insn_length);
6400 state_machine_regs.address += adv;
6401 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
6402 state_machine_regs.address);
6405 case DW_LNS_fixed_advance_pc:
6406 adv = byte_get (data, 2);
6408 state_machine_regs.address += adv;
6409 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6410 adv, state_machine_regs.address);
6413 case DW_LNS_set_prologue_end:
6414 printf (_(" Set prologue_end to true\n"));
6417 case DW_LNS_set_epilogue_begin:
6418 printf (_(" Set epilogue_begin to true\n"));
6421 case DW_LNS_set_isa:
6422 adv = read_leb128 (data, & bytes_read, 0);
6424 printf (_(" Set ISA to %d\n"), adv);
6428 printf (_(" Unknown opcode %d with operands: "), op_code);
6431 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
6433 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
6434 i == 1 ? "" : ", ");
6449 display_debug_pubnames (section, start, file)
6450 Elf32_Internal_Shdr * section;
6451 unsigned char * start;
6452 FILE * file ATTRIBUTE_UNUSED;
6454 DWARF2_External_PubNames * external;
6455 DWARF2_Internal_PubNames pubnames;
6456 unsigned char * end;
6458 end = start + section->sh_size;
6460 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6464 unsigned char * data;
6465 unsigned long offset;
6467 external = (DWARF2_External_PubNames *) start;
6469 pubnames.pn_length = BYTE_GET (external->pn_length);
6470 pubnames.pn_version = BYTE_GET (external->pn_version);
6471 pubnames.pn_offset = BYTE_GET (external->pn_offset);
6472 pubnames.pn_size = BYTE_GET (external->pn_size);
6474 data = start + sizeof (* external);
6475 start += pubnames.pn_length + sizeof (external->pn_length);
6477 if (pubnames.pn_length == 0xffffffff)
6479 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6483 if (pubnames.pn_version != 2)
6485 static int warned = 0;
6489 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6496 printf (_(" Length: %ld\n"),
6497 pubnames.pn_length);
6498 printf (_(" Version: %d\n"),
6499 pubnames.pn_version);
6500 printf (_(" Offset into .debug_info section: %ld\n"),
6501 pubnames.pn_offset);
6502 printf (_(" Size of area in .debug_info section: %ld\n"),
6505 printf (_("\n Offset\tName\n"));
6509 offset = byte_get (data, 4);
6514 printf (" %ld\t\t%s\n", offset, data);
6515 data += strlen ((char *) data) + 1;
6518 while (offset != 0);
6531 case DW_TAG_padding: return "DW_TAG_padding";
6532 case DW_TAG_array_type: return "DW_TAG_array_type";
6533 case DW_TAG_class_type: return "DW_TAG_class_type";
6534 case DW_TAG_entry_point: return "DW_TAG_entry_point";
6535 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
6536 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
6537 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
6538 case DW_TAG_label: return "DW_TAG_label";
6539 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
6540 case DW_TAG_member: return "DW_TAG_member";
6541 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
6542 case DW_TAG_reference_type: return "DW_TAG_reference_type";
6543 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
6544 case DW_TAG_string_type: return "DW_TAG_string_type";
6545 case DW_TAG_structure_type: return "DW_TAG_structure_type";
6546 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
6547 case DW_TAG_typedef: return "DW_TAG_typedef";
6548 case DW_TAG_union_type: return "DW_TAG_union_type";
6549 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6550 case DW_TAG_variant: return "DW_TAG_variant";
6551 case DW_TAG_common_block: return "DW_TAG_common_block";
6552 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
6553 case DW_TAG_inheritance: return "DW_TAG_inheritance";
6554 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
6555 case DW_TAG_module: return "DW_TAG_module";
6556 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
6557 case DW_TAG_set_type: return "DW_TAG_set_type";
6558 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
6559 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
6560 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
6561 case DW_TAG_base_type: return "DW_TAG_base_type";
6562 case DW_TAG_catch_block: return "DW_TAG_catch_block";
6563 case DW_TAG_const_type: return "DW_TAG_const_type";
6564 case DW_TAG_constant: return "DW_TAG_constant";
6565 case DW_TAG_enumerator: return "DW_TAG_enumerator";
6566 case DW_TAG_file_type: return "DW_TAG_file_type";
6567 case DW_TAG_friend: return "DW_TAG_friend";
6568 case DW_TAG_namelist: return "DW_TAG_namelist";
6569 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
6570 case DW_TAG_packed_type: return "DW_TAG_packed_type";
6571 case DW_TAG_subprogram: return "DW_TAG_subprogram";
6572 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
6573 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
6574 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
6575 case DW_TAG_try_block: return "DW_TAG_try_block";
6576 case DW_TAG_variant_part: return "DW_TAG_variant_part";
6577 case DW_TAG_variable: return "DW_TAG_variable";
6578 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
6579 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
6580 case DW_TAG_format_label: return "DW_TAG_format_label";
6581 case DW_TAG_function_template: return "DW_TAG_function_template";
6582 case DW_TAG_class_template: return "DW_TAG_class_template";
6583 /* DWARF 2.1 values. */
6584 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
6585 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
6586 case DW_TAG_interface_type: return "DW_TAG_interface_type";
6587 case DW_TAG_namespace: return "DW_TAG_namespace";
6588 case DW_TAG_imported_module: return "DW_TAG_imported_module";
6589 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
6590 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
6591 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
6594 static char buffer [100];
6596 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6603 get_AT_name (attribute)
6604 unsigned long attribute;
6608 case DW_AT_sibling: return "DW_AT_sibling";
6609 case DW_AT_location: return "DW_AT_location";
6610 case DW_AT_name: return "DW_AT_name";
6611 case DW_AT_ordering: return "DW_AT_ordering";
6612 case DW_AT_subscr_data: return "DW_AT_subscr_data";
6613 case DW_AT_byte_size: return "DW_AT_byte_size";
6614 case DW_AT_bit_offset: return "DW_AT_bit_offset";
6615 case DW_AT_bit_size: return "DW_AT_bit_size";
6616 case DW_AT_element_list: return "DW_AT_element_list";
6617 case DW_AT_stmt_list: return "DW_AT_stmt_list";
6618 case DW_AT_low_pc: return "DW_AT_low_pc";
6619 case DW_AT_high_pc: return "DW_AT_high_pc";
6620 case DW_AT_language: return "DW_AT_language";
6621 case DW_AT_member: return "DW_AT_member";
6622 case DW_AT_discr: return "DW_AT_discr";
6623 case DW_AT_discr_value: return "DW_AT_discr_value";
6624 case DW_AT_visibility: return "DW_AT_visibility";
6625 case DW_AT_import: return "DW_AT_import";
6626 case DW_AT_string_length: return "DW_AT_string_length";
6627 case DW_AT_common_reference: return "DW_AT_common_reference";
6628 case DW_AT_comp_dir: return "DW_AT_comp_dir";
6629 case DW_AT_const_value: return "DW_AT_const_value";
6630 case DW_AT_containing_type: return "DW_AT_containing_type";
6631 case DW_AT_default_value: return "DW_AT_default_value";
6632 case DW_AT_inline: return "DW_AT_inline";
6633 case DW_AT_is_optional: return "DW_AT_is_optional";
6634 case DW_AT_lower_bound: return "DW_AT_lower_bound";
6635 case DW_AT_producer: return "DW_AT_producer";
6636 case DW_AT_prototyped: return "DW_AT_prototyped";
6637 case DW_AT_return_addr: return "DW_AT_return_addr";
6638 case DW_AT_start_scope: return "DW_AT_start_scope";
6639 case DW_AT_stride_size: return "DW_AT_stride_size";
6640 case DW_AT_upper_bound: return "DW_AT_upper_bound";
6641 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
6642 case DW_AT_accessibility: return "DW_AT_accessibility";
6643 case DW_AT_address_class: return "DW_AT_address_class";
6644 case DW_AT_artificial: return "DW_AT_artificial";
6645 case DW_AT_base_types: return "DW_AT_base_types";
6646 case DW_AT_calling_convention: return "DW_AT_calling_convention";
6647 case DW_AT_count: return "DW_AT_count";
6648 case DW_AT_data_member_location: return "DW_AT_data_member_location";
6649 case DW_AT_decl_column: return "DW_AT_decl_column";
6650 case DW_AT_decl_file: return "DW_AT_decl_file";
6651 case DW_AT_decl_line: return "DW_AT_decl_line";
6652 case DW_AT_declaration: return "DW_AT_declaration";
6653 case DW_AT_discr_list: return "DW_AT_discr_list";
6654 case DW_AT_encoding: return "DW_AT_encoding";
6655 case DW_AT_external: return "DW_AT_external";
6656 case DW_AT_frame_base: return "DW_AT_frame_base";
6657 case DW_AT_friend: return "DW_AT_friend";
6658 case DW_AT_identifier_case: return "DW_AT_identifier_case";
6659 case DW_AT_macro_info: return "DW_AT_macro_info";
6660 case DW_AT_namelist_items: return "DW_AT_namelist_items";
6661 case DW_AT_priority: return "DW_AT_priority";
6662 case DW_AT_segment: return "DW_AT_segment";
6663 case DW_AT_specification: return "DW_AT_specification";
6664 case DW_AT_static_link: return "DW_AT_static_link";
6665 case DW_AT_type: return "DW_AT_type";
6666 case DW_AT_use_location: return "DW_AT_use_location";
6667 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
6668 case DW_AT_virtuality: return "DW_AT_virtuality";
6669 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6670 /* DWARF 2.1 values. */
6671 case DW_AT_allocated: return "DW_AT_allocated";
6672 case DW_AT_associated: return "DW_AT_associated";
6673 case DW_AT_data_location: return "DW_AT_data_location";
6674 case DW_AT_stride: return "DW_AT_stride";
6675 case DW_AT_entry_pc: return "DW_AT_entry_pc";
6676 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
6677 case DW_AT_extension: return "DW_AT_extension";
6678 case DW_AT_ranges: return "DW_AT_ranges";
6679 case DW_AT_trampoline: return "DW_AT_trampoline";
6680 case DW_AT_call_column: return "DW_AT_call_column";
6681 case DW_AT_call_file: return "DW_AT_call_file";
6682 case DW_AT_call_line: return "DW_AT_call_line";
6683 /* SGI/MIPS extensions. */
6684 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
6685 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
6686 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6687 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
6688 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6689 case DW_AT_MIPS_software_pipeline_depth: return "DW_AT_MIPS_software_pipeline_depth";
6690 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
6691 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
6692 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
6693 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
6694 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
6695 /* GNU extensions. */
6696 case DW_AT_sf_names: return "DW_AT_sf_names";
6697 case DW_AT_src_info: return "DW_AT_src_info";
6698 case DW_AT_mac_info: return "DW_AT_mac_info";
6699 case DW_AT_src_coords: return "DW_AT_src_coords";
6700 case DW_AT_body_begin: return "DW_AT_body_begin";
6701 case DW_AT_body_end: return "DW_AT_body_end";
6702 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
6705 static char buffer [100];
6707 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6714 get_FORM_name (form)
6719 case DW_FORM_addr: return "DW_FORM_addr";
6720 case DW_FORM_block2: return "DW_FORM_block2";
6721 case DW_FORM_block4: return "DW_FORM_block4";
6722 case DW_FORM_data2: return "DW_FORM_data2";
6723 case DW_FORM_data4: return "DW_FORM_data4";
6724 case DW_FORM_data8: return "DW_FORM_data8";
6725 case DW_FORM_string: return "DW_FORM_string";
6726 case DW_FORM_block: return "DW_FORM_block";
6727 case DW_FORM_block1: return "DW_FORM_block1";
6728 case DW_FORM_data1: return "DW_FORM_data1";
6729 case DW_FORM_flag: return "DW_FORM_flag";
6730 case DW_FORM_sdata: return "DW_FORM_sdata";
6731 case DW_FORM_strp: return "DW_FORM_strp";
6732 case DW_FORM_udata: return "DW_FORM_udata";
6733 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
6734 case DW_FORM_ref1: return "DW_FORM_ref1";
6735 case DW_FORM_ref2: return "DW_FORM_ref2";
6736 case DW_FORM_ref4: return "DW_FORM_ref4";
6737 case DW_FORM_ref8: return "DW_FORM_ref8";
6738 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6739 case DW_FORM_indirect: return "DW_FORM_indirect";
6742 static char buffer [100];
6744 sprintf (buffer, _("Unknown FORM value: %lx"), form);
6750 /* FIXME: There are better and more effiecint ways to handle
6751 these structures. For now though, I just want something that
6752 is simple to implement. */
6753 typedef struct abbrev_attr
6755 unsigned long attribute;
6757 struct abbrev_attr * next;
6761 typedef struct abbrev_entry
6763 unsigned long entry;
6766 struct abbrev_attr * first_attr;
6767 struct abbrev_attr * last_attr;
6768 struct abbrev_entry * next;
6772 static abbrev_entry * first_abbrev = NULL;
6773 static abbrev_entry * last_abbrev = NULL;
6776 free_abbrevs PARAMS ((void))
6778 abbrev_entry * abbrev;
6780 for (abbrev = first_abbrev; abbrev;)
6782 abbrev_entry * next = abbrev->next;
6785 for (attr = abbrev->first_attr; attr;)
6787 abbrev_attr * next = attr->next;
6797 last_abbrev = first_abbrev = NULL;
6801 add_abbrev (number, tag, children)
6802 unsigned long number;
6806 abbrev_entry * entry;
6808 entry = (abbrev_entry *) malloc (sizeof (* entry));
6814 entry->entry = number;
6816 entry->children = children;
6817 entry->first_attr = NULL;
6818 entry->last_attr = NULL;
6821 if (first_abbrev == NULL)
6822 first_abbrev = entry;
6824 last_abbrev->next = entry;
6826 last_abbrev = entry;
6830 add_abbrev_attr (attribute, form)
6831 unsigned long attribute;
6836 attr = (abbrev_attr *) malloc (sizeof (* attr));
6842 attr->attribute = attribute;
6846 if (last_abbrev->first_attr == NULL)
6847 last_abbrev->first_attr = attr;
6849 last_abbrev->last_attr->next = attr;
6851 last_abbrev->last_attr = attr;
6854 /* Processes the (partial) contents of a .debug_abbrev section.
6855 Returns NULL if the end of the section was encountered.
6856 Returns the address after the last byte read if the end of
6857 an abbreviation set was found. */
6859 static unsigned char *
6860 process_abbrev_section (start, end)
6861 unsigned char * start;
6862 unsigned char * end;
6864 if (first_abbrev != NULL)
6870 unsigned long entry;
6872 unsigned long attribute;
6875 entry = read_leb128 (start, & bytes_read, 0);
6876 start += bytes_read;
6878 /* A single zero is supposed to end the section according
6879 to the standard. If there's more, then signal that to
6882 return start == end ? NULL : start;
6884 tag = read_leb128 (start, & bytes_read, 0);
6885 start += bytes_read;
6887 children = * start ++;
6889 add_abbrev (entry, tag, children);
6895 attribute = read_leb128 (start, & bytes_read, 0);
6896 start += bytes_read;
6898 form = read_leb128 (start, & bytes_read, 0);
6899 start += bytes_read;
6902 add_abbrev_attr (attribute, form);
6904 while (attribute != 0);
6912 display_debug_macinfo (section, start, file)
6913 Elf32_Internal_Shdr * section;
6914 unsigned char * start;
6915 FILE * file ATTRIBUTE_UNUSED;
6917 unsigned char * end = start + section->sh_size;
6918 unsigned char * curr = start;
6919 unsigned int bytes_read;
6920 enum dwarf_macinfo_record_type op;
6922 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6926 unsigned int lineno;
6927 const char * string;
6934 case DW_MACINFO_start_file:
6936 unsigned int filenum;
6938 lineno = read_leb128 (curr, & bytes_read, 0);
6940 filenum = read_leb128 (curr, & bytes_read, 0);
6943 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
6947 case DW_MACINFO_end_file:
6948 printf (_(" DW_MACINFO_end_file\n"));
6951 case DW_MACINFO_define:
6952 lineno = read_leb128 (curr, & bytes_read, 0);
6955 curr += strlen (string) + 1;
6956 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
6959 case DW_MACINFO_undef:
6960 lineno = read_leb128 (curr, & bytes_read, 0);
6963 curr += strlen (string) + 1;
6964 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
6967 case DW_MACINFO_vendor_ext:
6969 unsigned int constant;
6971 constant = read_leb128 (curr, & bytes_read, 0);
6974 curr += strlen (string) + 1;
6975 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
6986 display_debug_abbrev (section, start, file)
6987 Elf32_Internal_Shdr * section;
6988 unsigned char * start;
6989 FILE * file ATTRIBUTE_UNUSED;
6991 abbrev_entry * entry;
6992 unsigned char * end = start + section->sh_size;
6994 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6998 start = process_abbrev_section (start, end);
7000 if (first_abbrev == NULL)
7003 printf (_(" Number TAG\n"));
7005 for (entry = first_abbrev; entry; entry = entry->next)
7009 printf (_(" %ld %s [%s]\n"),
7011 get_TAG_name (entry->tag),
7012 entry->children ? _("has children") : _("no children"));
7014 for (attr = entry->first_attr; attr; attr = attr->next)
7016 printf (_(" %-18s %s\n"),
7017 get_AT_name (attr->attribute),
7018 get_FORM_name (attr->form));
7032 static unsigned char *
7033 display_block (data, length)
7034 unsigned char * data;
7035 unsigned long length;
7037 printf (_(" %lu byte block: "), length);
7040 printf ("%lx ", (unsigned long) byte_get (data ++, 1));
7046 decode_location_expression (data, pointer_size, length)
7047 unsigned char * data;
7048 unsigned int pointer_size;
7049 unsigned long length;
7053 unsigned long uvalue;
7054 unsigned char * end = data + length;
7063 printf ("DW_OP_addr: %lx",
7064 (unsigned long) byte_get (data, pointer_size));
7065 data += pointer_size;
7068 printf ("DW_OP_deref");
7071 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
7074 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
7077 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
7081 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
7085 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
7089 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
7093 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
7094 (unsigned long) byte_get (data + 4, 4));
7098 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
7099 (long) byte_get (data + 4, 4));
7103 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
7107 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
7111 printf ("DW_OP_dup");
7114 printf ("DW_OP_drop");
7117 printf ("DW_OP_over");
7120 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
7123 printf ("DW_OP_swap");
7126 printf ("DW_OP_rot");
7129 printf ("DW_OP_xderef");
7132 printf ("DW_OP_abs");
7135 printf ("DW_OP_and");
7138 printf ("DW_OP_div");
7141 printf ("DW_OP_minus");
7144 printf ("DW_OP_mod");
7147 printf ("DW_OP_mul");
7150 printf ("DW_OP_neg");
7153 printf ("DW_OP_not");
7156 printf ("DW_OP_or");
7159 printf ("DW_OP_plus");
7161 case DW_OP_plus_uconst:
7162 printf ("DW_OP_plus_uconst: %lu",
7163 read_leb128 (data, &bytes_read, 0));
7167 printf ("DW_OP_shl");
7170 printf ("DW_OP_shr");
7173 printf ("DW_OP_shra");
7176 printf ("DW_OP_xor");
7179 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
7183 printf ("DW_OP_eq");
7186 printf ("DW_OP_ge");
7189 printf ("DW_OP_gt");
7192 printf ("DW_OP_le");
7195 printf ("DW_OP_lt");
7198 printf ("DW_OP_ne");
7201 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
7237 printf ("DW_OP_lit%d", op - DW_OP_lit0);
7272 printf ("DW_OP_reg%d", op - DW_OP_reg0);
7307 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
7308 read_leb128 (data, &bytes_read, 1));
7313 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
7317 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
7321 uvalue = read_leb128 (data, &bytes_read, 0);
7323 printf ("DW_OP_bregx: %lu %ld", uvalue,
7324 read_leb128 (data, &bytes_read, 1));
7328 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
7331 case DW_OP_deref_size:
7332 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
7334 case DW_OP_xderef_size:
7335 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
7338 printf ("DW_OP_nop");
7341 /* DWARF 2.1 extensions. */
7342 case DW_OP_push_object_address:
7343 printf ("DW_OP_push_object_address");
7346 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
7350 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
7354 printf ("DW_OP_calli");
7358 if (op >= DW_OP_lo_user
7359 && op <= DW_OP_hi_user)
7360 printf (_("(User defined location op)"));
7362 printf (_("(Unknown location op)"));
7363 /* No way to tell where the next op is, so just bail. */
7367 /* Separate the ops. */
7372 static const char * debug_loc_contents;
7373 static bfd_vma debug_loc_size;
7376 load_debug_loc (file)
7379 Elf32_Internal_Shdr * sec;
7382 /* If it is already loaded, do nothing. */
7383 if (debug_loc_contents != NULL)
7386 /* Locate the .debug_loc section. */
7387 for (i = 0, sec = section_headers;
7388 i < elf_header.e_shnum;
7390 if (strcmp (SECTION_NAME (sec), ".debug_loc") == 0)
7393 if (i == elf_header.e_shnum || sec->sh_size == 0)
7396 debug_loc_size = sec->sh_size;
7398 debug_loc_contents = ((char *)
7399 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7400 _("debug_loc section data")));
7406 if (debug_loc_contents == NULL)
7409 free ((char *) debug_loc_contents);
7410 debug_loc_contents = NULL;
7416 display_debug_loc (section, start, file)
7417 Elf32_Internal_Shdr * section;
7418 unsigned char * start;
7419 FILE * file ATTRIBUTE_UNUSED;
7421 unsigned char *section_end;
7422 unsigned long bytes;
7423 unsigned char *section_begin = start;
7426 addr = section->sh_addr;
7427 bytes = section->sh_size;
7428 section_end = start + bytes;
7431 printf (_("\nThe .debug_loc section is empty.\n"));
7434 printf (_("Contents of the .debug_loc section:\n\n"));
7435 printf (_("\n Offset Begin End Expression\n"));
7436 while (start < section_end)
7438 unsigned long begin;
7440 unsigned short length;
7441 unsigned long offset;
7443 offset = start - section_begin;
7447 /* Normally, the lists in the debug_loc section are related to a
7448 given compilation unit, and thus, we would use the
7449 pointer size of that compilation unit. However, since we are
7450 displaying it seperately here, we either have to store
7451 pointer sizes of all compilation units, or assume they don't
7452 change. We assume, like the debug_line display, that
7453 it doesn't change. */
7454 begin = byte_get (start, debug_line_pointer_size);
7455 start += debug_line_pointer_size;
7456 end = byte_get (start, debug_line_pointer_size);
7457 start += debug_line_pointer_size;
7459 if (begin == 0 && end == 0)
7465 length = byte_get (start, 2);
7468 printf (" %8.8lx %8.8lx %8.8lx (", offset, begin, end);
7469 decode_location_expression (start, debug_line_pointer_size, length);
7479 static const char * debug_str_contents;
7480 static bfd_vma debug_str_size;
7483 load_debug_str (file)
7486 Elf32_Internal_Shdr * sec;
7489 /* If it is already loaded, do nothing. */
7490 if (debug_str_contents != NULL)
7493 /* Locate the .debug_str section. */
7494 for (i = 0, sec = section_headers;
7495 i < elf_header.e_shnum;
7497 if (strcmp (SECTION_NAME (sec), ".debug_str") == 0)
7500 if (i == elf_header.e_shnum || sec->sh_size == 0)
7503 debug_str_size = sec->sh_size;
7505 debug_str_contents = ((char *)
7506 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7507 _("debug_str section data")));
7513 if (debug_str_contents == NULL)
7516 free ((char *) debug_str_contents);
7517 debug_str_contents = NULL;
7522 fetch_indirect_string (offset)
7523 unsigned long offset;
7525 if (debug_str_contents == NULL)
7526 return _("<no .debug_str section>");
7528 if (offset > debug_str_size)
7529 return _("<offset is too big>");
7531 return debug_str_contents + offset;
7536 display_debug_str (section, start, file)
7537 Elf32_Internal_Shdr * section;
7538 unsigned char * start;
7539 FILE * file ATTRIBUTE_UNUSED;
7541 unsigned long bytes;
7544 addr = section->sh_addr;
7545 bytes = section->sh_size;
7549 printf (_("\nThe .debug_str section is empty.\n"));
7553 printf (_("Contents of the .debug_str section:\n\n"));
7561 lbytes = (bytes > 16 ? 16 : bytes);
7563 printf (" 0x%8.8lx ", (unsigned long) addr);
7565 for (j = 0; j < 16; j++)
7568 printf ("%2.2x", start [j]);
7576 for (j = 0; j < lbytes; j++)
7579 if (k >= ' ' && k < 0x80)
7596 static unsigned char *
7597 read_and_display_attr_value (attribute, form, data, cu_offset, pointer_size)
7598 unsigned long attribute;
7600 unsigned char * data;
7601 unsigned long cu_offset;
7602 unsigned long pointer_size;
7604 unsigned long uvalue = 0;
7605 unsigned char * block_start = NULL;
7613 case DW_FORM_ref_addr:
7615 uvalue = byte_get (data, pointer_size);
7616 data += pointer_size;
7620 uvalue = byte_get (data, /* offset_size */ 4);
7621 data += /* offset_size */ 4;
7627 uvalue = byte_get (data ++, 1);
7632 uvalue = byte_get (data, 2);
7638 uvalue = byte_get (data, 4);
7643 uvalue = read_leb128 (data, & bytes_read, 1);
7647 case DW_FORM_ref_udata:
7649 uvalue = read_leb128 (data, & bytes_read, 0);
7653 case DW_FORM_indirect:
7654 form = read_leb128 (data, & bytes_read, 0);
7656 printf (" %s", get_FORM_name (form));
7657 return read_and_display_attr_value (attribute, form, data, cu_offset,
7663 case DW_FORM_ref_addr:
7664 printf (" <#%lx>", uvalue);
7670 case DW_FORM_ref_udata:
7671 printf (" <%lx>", uvalue + cu_offset);
7675 printf (" %#lx", uvalue);
7683 printf (" %ld", uvalue);
7688 uvalue = byte_get (data, 4);
7689 printf (" %lx", uvalue);
7690 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
7694 case DW_FORM_string:
7695 printf (" %s", data);
7696 data += strlen ((char *) data) + 1;
7700 uvalue = read_leb128 (data, & bytes_read, 0);
7701 block_start = data + bytes_read;
7702 data = display_block (block_start, uvalue);
7705 case DW_FORM_block1:
7706 uvalue = byte_get (data, 1);
7707 block_start = data + 1;
7708 data = display_block (block_start, uvalue);
7711 case DW_FORM_block2:
7712 uvalue = byte_get (data, 2);
7713 block_start = data + 2;
7714 data = display_block (block_start, uvalue);
7717 case DW_FORM_block4:
7718 uvalue = byte_get (data, 4);
7719 block_start = data + 4;
7720 data = display_block (block_start, uvalue);
7724 printf (_(" (indirect string, offset: 0x%lx): "), uvalue);
7725 printf (fetch_indirect_string (uvalue));
7728 case DW_FORM_indirect:
7729 /* Handled above. */
7733 warn (_("Unrecognized form: %d\n"), form);
7737 /* For some attributes we can display futher information. */
7746 case DW_INL_not_inlined: printf (_("(not inlined)")); break;
7747 case DW_INL_inlined: printf (_("(inlined)")); break;
7748 case DW_INL_declared_not_inlined: printf (_("(declared as inline but ignored)")); break;
7749 case DW_INL_declared_inlined: printf (_("(declared as inline and inlined)")); break;
7750 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue); break;
7754 case DW_AT_language:
7757 case DW_LANG_C: printf ("(non-ANSI C)"); break;
7758 case DW_LANG_C89: printf ("(ANSI C)"); break;
7759 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
7760 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
7761 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
7762 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
7763 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
7764 case DW_LANG_Ada83: printf ("(Ada)"); break;
7765 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
7766 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
7767 /* DWARF 2.1 values. */
7768 case DW_LANG_C99: printf ("(ANSI C99)"); break;
7769 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
7770 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
7771 /* MIPS extension. */
7772 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7773 default: printf ("(Unknown: %lx)", uvalue); break;
7777 case DW_AT_encoding:
7780 case DW_ATE_void: printf ("(void)"); break;
7781 case DW_ATE_address: printf ("(machine address)"); break;
7782 case DW_ATE_boolean: printf ("(boolean)"); break;
7783 case DW_ATE_complex_float: printf ("(complex float)"); break;
7784 case DW_ATE_float: printf ("(float)"); break;
7785 case DW_ATE_signed: printf ("(signed)"); break;
7786 case DW_ATE_signed_char: printf ("(signed char)"); break;
7787 case DW_ATE_unsigned: printf ("(unsigned)"); break;
7788 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
7789 /* DWARF 2.1 value. */
7790 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7792 if (uvalue >= DW_ATE_lo_user
7793 && uvalue <= DW_ATE_hi_user)
7794 printf ("(user defined type)");
7796 printf ("(unknown type)");
7801 case DW_AT_accessibility:
7804 case DW_ACCESS_public: printf ("(public)"); break;
7805 case DW_ACCESS_protected: printf ("(protected)"); break;
7806 case DW_ACCESS_private: printf ("(private)"); break;
7807 default: printf ("(unknown accessibility)"); break;
7811 case DW_AT_visibility:
7814 case DW_VIS_local: printf ("(local)"); break;
7815 case DW_VIS_exported: printf ("(exported)"); break;
7816 case DW_VIS_qualified: printf ("(qualified)"); break;
7817 default: printf ("(unknown visibility)"); break;
7821 case DW_AT_virtuality:
7824 case DW_VIRTUALITY_none: printf ("(none)"); break;
7825 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
7826 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
7827 default: printf ("(unknown virtuality)"); break;
7831 case DW_AT_identifier_case:
7834 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
7835 case DW_ID_up_case: printf ("(up_case)"); break;
7836 case DW_ID_down_case: printf ("(down_case)"); break;
7837 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
7838 default: printf ("(unknown case)"); break;
7842 case DW_AT_calling_convention:
7845 case DW_CC_normal: printf ("(normal)"); break;
7846 case DW_CC_program: printf ("(program)"); break;
7847 case DW_CC_nocall: printf ("(nocall)"); break;
7849 if (uvalue >= DW_CC_lo_user
7850 && uvalue <= DW_CC_hi_user)
7851 printf ("(user defined)");
7853 printf ("(unknown convention)");
7857 case DW_AT_ordering:
7860 case -1: printf ("(undefined)"); break;
7861 case 0: printf ("(row major)"); break;
7862 case 1: printf ("(column major)"); break;
7866 case DW_AT_frame_base:
7867 case DW_AT_location:
7868 case DW_AT_data_member_location:
7869 case DW_AT_vtable_elem_location:
7870 case DW_AT_allocated:
7871 case DW_AT_associated:
7872 case DW_AT_data_location:
7874 case DW_AT_upper_bound:
7875 case DW_AT_lower_bound:
7879 decode_location_expression (block_start, pointer_size, uvalue);
7882 else if (form == DW_FORM_data4)
7885 printf ("location list");
7897 static unsigned char *
7898 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
7899 unsigned long attribute;
7901 unsigned char * data;
7902 unsigned long cu_offset;
7903 unsigned long pointer_size;
7905 printf (" %-18s:", get_AT_name (attribute));
7906 data = read_and_display_attr_value (attribute, form, data, cu_offset,
7913 display_debug_info (section, start, file)
7914 Elf32_Internal_Shdr * section;
7915 unsigned char * start;
7918 unsigned char * end = start + section->sh_size;
7919 unsigned char * section_begin = start;
7921 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
7923 load_debug_str (file);
7924 load_debug_loc (file);
7928 DWARF2_External_CompUnit * external;
7929 DWARF2_Internal_CompUnit compunit;
7930 Elf32_Internal_Shdr * relsec;
7931 unsigned char * tags;
7934 unsigned long cu_offset;
7936 external = (DWARF2_External_CompUnit *) start;
7938 compunit.cu_length = BYTE_GET (external->cu_length);
7939 compunit.cu_version = BYTE_GET (external->cu_version);
7940 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
7941 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
7943 if (compunit.cu_length == 0xffffffff)
7945 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7949 /* Check for RELA relocations in the abbrev_offset address, and
7951 for (relsec = section_headers;
7952 relsec < section_headers + elf_header.e_shnum;
7955 unsigned long nrelas;
7956 Elf_Internal_Rela *rela, *rp;
7957 Elf32_Internal_Shdr *symsec;
7958 Elf_Internal_Sym *symtab;
7959 Elf_Internal_Sym *sym;
7961 if (relsec->sh_type != SHT_RELA
7962 || SECTION_HEADER (relsec->sh_info) != section)
7965 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7969 symsec = SECTION_HEADER (relsec->sh_link);
7970 symtab = GET_ELF_SYMBOLS (file, symsec);
7972 for (rp = rela; rp < rela + nrelas; ++rp)
7975 != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
7981 sym = symtab + ELF32_R_SYM (rp->r_info);
7983 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
7985 warn (_("Skipping unexpected symbol type %u\n"),
7986 ELF32_ST_TYPE (sym->st_info));
7992 sym = symtab + ELF64_R_SYM (rp->r_info);
7994 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
7996 warn (_("Skipping unexpected symbol type %u\n"),
7997 ELF64_ST_TYPE (sym->st_info));
8002 compunit.cu_abbrev_offset += rp->r_addend;
8010 tags = start + sizeof (* external);
8011 cu_offset = start - section_begin;
8012 start += compunit.cu_length + sizeof (external->cu_length);
8014 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
8015 printf (_(" Length: %ld\n"), compunit.cu_length);
8016 printf (_(" Version: %d\n"), compunit.cu_version);
8017 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
8018 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
8020 if (compunit.cu_version != 2)
8022 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8028 /* Read in the abbrevs used by this compilation unit. */
8031 Elf32_Internal_Shdr * sec;
8032 unsigned char * begin;
8034 /* Locate the .debug_abbrev section and process it. */
8035 for (i = 0, sec = section_headers;
8036 i < elf_header.e_shnum;
8038 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
8041 if (i == elf_header.e_shnum || sec->sh_size == 0)
8043 warn (_("Unable to locate .debug_abbrev section!\n"));
8047 begin = ((unsigned char *)
8048 get_data (NULL, file, sec->sh_offset, sec->sh_size,
8049 _("debug_abbrev section data")));
8053 process_abbrev_section (begin + compunit.cu_abbrev_offset,
8054 begin + sec->sh_size);
8060 while (tags < start)
8063 unsigned long abbrev_number;
8064 abbrev_entry * entry;
8067 abbrev_number = read_leb128 (tags, & bytes_read, 0);
8070 /* A null DIE marks the end of a list of children. */
8071 if (abbrev_number == 0)
8077 /* Scan through the abbreviation list until we reach the
8079 for (entry = first_abbrev;
8080 entry && entry->entry != abbrev_number;
8081 entry = entry->next)
8086 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8091 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8093 (unsigned long) (tags - section_begin - bytes_read),
8095 get_TAG_name (entry->tag));
8097 for (attr = entry->first_attr; attr; attr = attr->next)
8098 tags = read_and_display_attr (attr->attribute,
8101 compunit.cu_pointer_size);
8103 if (entry->children)
8117 display_debug_aranges (section, start, file)
8118 Elf32_Internal_Shdr * section;
8119 unsigned char * start;
8120 FILE * file ATTRIBUTE_UNUSED;
8122 unsigned char * end = start + section->sh_size;
8124 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8128 DWARF2_External_ARange * external;
8129 DWARF2_Internal_ARange arange;
8130 unsigned char * ranges;
8131 unsigned long length;
8132 unsigned long address;
8135 external = (DWARF2_External_ARange *) start;
8137 arange.ar_length = BYTE_GET (external->ar_length);
8138 arange.ar_version = BYTE_GET (external->ar_version);
8139 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
8140 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
8141 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
8143 if (arange.ar_length == 0xffffffff)
8145 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8149 if (arange.ar_version != 2)
8151 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8155 printf (_(" Length: %ld\n"), arange.ar_length);
8156 printf (_(" Version: %d\n"), arange.ar_version);
8157 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
8158 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
8159 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
8161 printf (_("\n Address Length\n"));
8163 ranges = start + sizeof (* external);
8165 /* Must pad to an alignment boundary that is twice the pointer size. */
8166 excess = sizeof (* external) % (2 * arange.ar_pointer_size);
8168 ranges += (2 * arange.ar_pointer_size) - excess;
8172 address = byte_get (ranges, arange.ar_pointer_size);
8174 ranges += arange.ar_pointer_size;
8176 length = byte_get (ranges, arange.ar_pointer_size);
8178 ranges += arange.ar_pointer_size;
8180 /* A pair of zeros marks the end of the list. */
8181 if (address == 0 && length == 0)
8184 printf (" %8.8lx %lu\n", address, length);
8187 start += arange.ar_length + sizeof (external->ar_length);
8195 typedef struct Frame_Chunk
8197 struct Frame_Chunk * next;
8198 unsigned char * chunk_start;
8200 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8201 short int * col_type;
8203 char * augmentation;
8204 unsigned int code_factor;
8206 unsigned long pc_begin;
8207 unsigned long pc_range;
8211 unsigned char fde_encoding;
8215 /* A marker for a col_type that means this column was never referenced
8216 in the frame info. */
8217 #define DW_CFA_unreferenced (-1)
8219 static void frame_need_space PARAMS ((Frame_Chunk *, int));
8220 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
8221 static int size_of_encoded_value PARAMS ((int));
8224 frame_need_space (fc, reg)
8228 int prev = fc->ncols;
8230 if (reg < fc->ncols)
8233 fc->ncols = reg + 1;
8234 fc->col_type = (short int *) xrealloc (fc->col_type,
8235 fc->ncols * sizeof (short int));
8236 fc->col_offset = (int *) xrealloc (fc->col_offset,
8237 fc->ncols * sizeof (int));
8239 while (prev < fc->ncols)
8241 fc->col_type[prev] = DW_CFA_unreferenced;
8242 fc->col_offset[prev] = 0;
8248 frame_display_row (fc, need_col_headers, max_regs)
8250 int * need_col_headers;
8256 if (* max_regs < fc->ncols)
8257 * max_regs = fc->ncols;
8259 if (* need_col_headers)
8261 * need_col_headers = 0;
8263 printf (" LOC CFA ");
8265 for (r = 0; r < * max_regs; r++)
8266 if (fc->col_type[r] != DW_CFA_unreferenced)
8271 printf ("r%-4d", r);
8277 printf ("%08lx ", fc->pc_begin);
8278 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
8279 printf ("%-8s ", tmp);
8281 for (r = 0; r < fc->ncols; r++)
8283 if (fc->col_type[r] != DW_CFA_unreferenced)
8285 switch (fc->col_type[r])
8287 case DW_CFA_undefined:
8290 case DW_CFA_same_value:
8294 sprintf (tmp, "c%+d", fc->col_offset[r]);
8296 case DW_CFA_register:
8297 sprintf (tmp, "r%d", fc->col_offset[r]);
8300 strcpy (tmp, "n/a");
8303 printf ("%-5s", tmp);
8310 size_of_encoded_value (encoding)
8313 switch (encoding & 0x7)
8316 case 0: return is_32bit_elf ? 4 : 8;
8323 #define GET(N) byte_get (start, N); start += N
8324 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8325 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8328 display_debug_frames (section, start, file)
8329 Elf32_Internal_Shdr * section;
8330 unsigned char * start;
8331 FILE * file ATTRIBUTE_UNUSED;
8333 unsigned char * end = start + section->sh_size;
8334 unsigned char * section_start = start;
8335 Frame_Chunk * chunks = 0;
8336 Frame_Chunk * remembered_state = 0;
8338 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
8341 int addr_size = is_32bit_elf ? 4 : 8;
8343 printf (_("The section %s contains:\n"), SECTION_NAME (section));
8347 unsigned char * saved_start;
8348 unsigned char * block_end;
8349 unsigned long length;
8350 unsigned long cie_id;
8353 int need_col_headers = 1;
8354 unsigned char * augmentation_data = NULL;
8355 unsigned long augmentation_data_len = 0;
8356 int encoded_ptr_size = addr_size;
8358 saved_start = start;
8359 length = byte_get (start, 4); start += 4;
8364 if (length == 0xffffffff)
8366 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8370 block_end = saved_start + length + 4;
8371 cie_id = byte_get (start, 4); start += 4;
8373 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
8377 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8378 memset (fc, 0, sizeof (Frame_Chunk));
8382 fc->chunk_start = saved_start;
8384 fc->col_type = (short int *) xmalloc (sizeof (short int));
8385 fc->col_offset = (int *) xmalloc (sizeof (int));
8386 frame_need_space (fc, max_regs-1);
8390 fc->augmentation = start;
8391 start = strchr (start, '\0') + 1;
8393 if (fc->augmentation[0] == 'z')
8395 fc->code_factor = LEB ();
8396 fc->data_factor = SLEB ();
8397 fc->ra = byte_get (start, 1); start += 1;
8398 augmentation_data_len = LEB ();
8399 augmentation_data = start;
8400 start += augmentation_data_len;
8402 else if (strcmp (fc->augmentation, "eh") == 0)
8405 fc->code_factor = LEB ();
8406 fc->data_factor = SLEB ();
8407 fc->ra = byte_get (start, 1); start += 1;
8411 fc->code_factor = LEB ();
8412 fc->data_factor = SLEB ();
8413 fc->ra = byte_get (start, 1); start += 1;
8417 if (do_debug_frames_interp)
8418 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8419 (unsigned long)(saved_start - section_start), length, cie_id,
8420 fc->augmentation, fc->code_factor, fc->data_factor,
8424 printf ("\n%08lx %08lx %08lx CIE\n",
8425 (unsigned long)(saved_start - section_start), length, cie_id);
8426 printf (" Version: %d\n", version);
8427 printf (" Augmentation: \"%s\"\n", fc->augmentation);
8428 printf (" Code alignment factor: %u\n", fc->code_factor);
8429 printf (" Data alignment factor: %d\n", fc->data_factor);
8430 printf (" Return address column: %d\n", fc->ra);
8432 if (augmentation_data_len)
8435 printf (" Augmentation data: ");
8436 for (i = 0; i < augmentation_data_len; ++i)
8437 printf (" %02x", augmentation_data[i]);
8443 if (augmentation_data_len)
8445 unsigned char *p, *q;
8446 p = fc->augmentation + 1;
8447 q = augmentation_data;
8454 q += 1 + size_of_encoded_value (*q);
8456 fc->fde_encoding = *q++;
8462 if (fc->fde_encoding)
8463 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8466 frame_need_space (fc, fc->ra);
8470 unsigned char * look_for;
8471 static Frame_Chunk fde_fc;
8474 memset (fc, 0, sizeof (Frame_Chunk));
8476 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
8478 for (cie = chunks; cie ; cie = cie->next)
8479 if (cie->chunk_start == look_for)
8484 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8485 cie_id, saved_start);
8488 fc->col_type = (short int *) xmalloc (sizeof (short int));
8489 fc->col_offset = (int *) xmalloc (sizeof (int));
8490 frame_need_space (fc, max_regs - 1);
8492 fc->augmentation = "";
8493 fc->fde_encoding = 0;
8497 fc->ncols = cie->ncols;
8498 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
8499 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
8500 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
8501 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
8502 fc->augmentation = cie->augmentation;
8503 fc->code_factor = cie->code_factor;
8504 fc->data_factor = cie->data_factor;
8505 fc->cfa_reg = cie->cfa_reg;
8506 fc->cfa_offset = cie->cfa_offset;
8508 frame_need_space (fc, max_regs-1);
8509 fc->fde_encoding = cie->fde_encoding;
8512 if (fc->fde_encoding)
8513 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8515 fc->pc_begin = byte_get (start, encoded_ptr_size);
8516 start += encoded_ptr_size;
8517 fc->pc_range = byte_get (start, encoded_ptr_size);
8518 start += encoded_ptr_size;
8520 if (cie->augmentation[0] == 'z')
8522 augmentation_data_len = LEB ();
8523 augmentation_data = start;
8524 start += augmentation_data_len;
8527 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8528 (unsigned long)(saved_start - section_start), length, cie_id,
8529 (unsigned long)(cie->chunk_start - section_start),
8530 fc->pc_begin, fc->pc_begin + fc->pc_range);
8531 if (! do_debug_frames_interp && augmentation_data_len)
8534 printf (" Augmentation data: ");
8535 for (i = 0; i < augmentation_data_len; ++i)
8536 printf (" %02x", augmentation_data[i]);
8542 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8543 about to interpret instructions for the chunk. */
8545 if (do_debug_frames_interp)
8547 /* Start by making a pass over the chunk, allocating storage
8548 and taking note of what registers are used. */
8549 unsigned char * tmp = start;
8551 while (start < block_end)
8561 /* Warning: if you add any more cases to this switch, be
8562 sure to add them to the corresponding switch below. */
8565 case DW_CFA_advance_loc:
8569 frame_need_space (fc, opa);
8570 fc->col_type[opa] = DW_CFA_undefined;
8572 case DW_CFA_restore:
8573 frame_need_space (fc, opa);
8574 fc->col_type[opa] = DW_CFA_undefined;
8576 case DW_CFA_set_loc:
8577 start += encoded_ptr_size;
8579 case DW_CFA_advance_loc1:
8582 case DW_CFA_advance_loc2:
8585 case DW_CFA_advance_loc4:
8588 case DW_CFA_offset_extended:
8589 reg = LEB (); LEB ();
8590 frame_need_space (fc, reg);
8591 fc->col_type[reg] = DW_CFA_undefined;
8593 case DW_CFA_restore_extended:
8595 frame_need_space (fc, reg);
8596 fc->col_type[reg] = DW_CFA_undefined;
8598 case DW_CFA_undefined:
8600 frame_need_space (fc, reg);
8601 fc->col_type[reg] = DW_CFA_undefined;
8603 case DW_CFA_same_value:
8605 frame_need_space (fc, reg);
8606 fc->col_type[reg] = DW_CFA_undefined;
8608 case DW_CFA_register:
8609 reg = LEB (); LEB ();
8610 frame_need_space (fc, reg);
8611 fc->col_type[reg] = DW_CFA_undefined;
8613 case DW_CFA_def_cfa:
8616 case DW_CFA_def_cfa_register:
8619 case DW_CFA_def_cfa_offset:
8622 case DW_CFA_offset_extended_sf:
8623 reg = LEB (); SLEB ();
8624 frame_need_space (fc, reg);
8625 fc->col_type[reg] = DW_CFA_undefined;
8627 case DW_CFA_def_cfa_sf:
8630 case DW_CFA_def_cfa_offset_sf:
8633 case DW_CFA_GNU_args_size:
8636 case DW_CFA_GNU_negative_offset_extended:
8637 reg = LEB (); LEB ();
8638 frame_need_space (fc, reg);
8639 fc->col_type[reg] = DW_CFA_undefined;
8648 /* Now we know what registers are used, make a second pass over
8649 the chunk, this time actually printing out the info. */
8651 while (start < block_end)
8654 unsigned long ul, reg, roffs;
8663 /* Warning: if you add any more cases to this switch, be
8664 sure to add them to the corresponding switch above. */
8667 case DW_CFA_advance_loc:
8668 if (do_debug_frames_interp)
8669 frame_display_row (fc, &need_col_headers, &max_regs);
8671 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8672 opa * fc->code_factor,
8673 fc->pc_begin + opa * fc->code_factor);
8674 fc->pc_begin += opa * fc->code_factor;
8679 if (! do_debug_frames_interp)
8680 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8681 opa, roffs * fc->data_factor);
8682 fc->col_type[opa] = DW_CFA_offset;
8683 fc->col_offset[opa] = roffs * fc->data_factor;
8686 case DW_CFA_restore:
8687 if (! do_debug_frames_interp)
8688 printf (" DW_CFA_restore: r%d\n", opa);
8689 fc->col_type[opa] = cie->col_type[opa];
8690 fc->col_offset[opa] = cie->col_offset[opa];
8693 case DW_CFA_set_loc:
8694 vma = byte_get (start, encoded_ptr_size);
8695 start += encoded_ptr_size;
8696 if (do_debug_frames_interp)
8697 frame_display_row (fc, &need_col_headers, &max_regs);
8699 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
8703 case DW_CFA_advance_loc1:
8704 ofs = byte_get (start, 1); start += 1;
8705 if (do_debug_frames_interp)
8706 frame_display_row (fc, &need_col_headers, &max_regs);
8708 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8709 ofs * fc->code_factor,
8710 fc->pc_begin + ofs * fc->code_factor);
8711 fc->pc_begin += ofs * fc->code_factor;
8714 case DW_CFA_advance_loc2:
8715 ofs = byte_get (start, 2); start += 2;
8716 if (do_debug_frames_interp)
8717 frame_display_row (fc, &need_col_headers, &max_regs);
8719 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8720 ofs * fc->code_factor,
8721 fc->pc_begin + ofs * fc->code_factor);
8722 fc->pc_begin += ofs * fc->code_factor;
8725 case DW_CFA_advance_loc4:
8726 ofs = byte_get (start, 4); start += 4;
8727 if (do_debug_frames_interp)
8728 frame_display_row (fc, &need_col_headers, &max_regs);
8730 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8731 ofs * fc->code_factor,
8732 fc->pc_begin + ofs * fc->code_factor);
8733 fc->pc_begin += ofs * fc->code_factor;
8736 case DW_CFA_offset_extended:
8739 if (! do_debug_frames_interp)
8740 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8741 reg, roffs * fc->data_factor);
8742 fc->col_type[reg] = DW_CFA_offset;
8743 fc->col_offset[reg] = roffs * fc->data_factor;
8746 case DW_CFA_restore_extended:
8748 if (! do_debug_frames_interp)
8749 printf (" DW_CFA_restore_extended: r%ld\n", reg);
8750 fc->col_type[reg] = cie->col_type[reg];
8751 fc->col_offset[reg] = cie->col_offset[reg];
8754 case DW_CFA_undefined:
8756 if (! do_debug_frames_interp)
8757 printf (" DW_CFA_undefined: r%ld\n", reg);
8758 fc->col_type[reg] = DW_CFA_undefined;
8759 fc->col_offset[reg] = 0;
8762 case DW_CFA_same_value:
8764 if (! do_debug_frames_interp)
8765 printf (" DW_CFA_same_value: r%ld\n", reg);
8766 fc->col_type[reg] = DW_CFA_same_value;
8767 fc->col_offset[reg] = 0;
8770 case DW_CFA_register:
8773 if (! do_debug_frames_interp)
8774 printf (" DW_CFA_register: r%ld\n", reg);
8775 fc->col_type[reg] = DW_CFA_register;
8776 fc->col_offset[reg] = roffs;
8779 case DW_CFA_remember_state:
8780 if (! do_debug_frames_interp)
8781 printf (" DW_CFA_remember_state\n");
8782 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8783 rs->ncols = fc->ncols;
8784 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8785 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8786 memcpy (rs->col_type, fc->col_type, rs->ncols);
8787 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8788 rs->next = remembered_state;
8789 remembered_state = rs;
8792 case DW_CFA_restore_state:
8793 if (! do_debug_frames_interp)
8794 printf (" DW_CFA_restore_state\n");
8795 rs = remembered_state;
8796 remembered_state = rs->next;
8797 frame_need_space (fc, rs->ncols-1);
8798 memcpy (fc->col_type, rs->col_type, rs->ncols);
8799 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8800 free (rs->col_type);
8801 free (rs->col_offset);
8805 case DW_CFA_def_cfa:
8806 fc->cfa_reg = LEB ();
8807 fc->cfa_offset = LEB ();
8808 if (! do_debug_frames_interp)
8809 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8810 fc->cfa_reg, fc->cfa_offset);
8813 case DW_CFA_def_cfa_register:
8814 fc->cfa_reg = LEB ();
8815 if (! do_debug_frames_interp)
8816 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
8819 case DW_CFA_def_cfa_offset:
8820 fc->cfa_offset = LEB ();
8821 if (! do_debug_frames_interp)
8822 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
8826 if (! do_debug_frames_interp)
8827 printf (" DW_CFA_nop\n");
8830 case DW_CFA_offset_extended_sf:
8833 frame_need_space (fc, reg);
8834 if (! do_debug_frames_interp)
8835 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
8836 reg, l * fc->data_factor);
8837 fc->col_type[reg] = DW_CFA_offset;
8838 fc->col_offset[reg] = l * fc->data_factor;
8841 case DW_CFA_def_cfa_sf:
8842 fc->cfa_reg = LEB ();
8843 fc->cfa_offset = SLEB ();
8844 if (! do_debug_frames_interp)
8845 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
8846 fc->cfa_reg, fc->cfa_offset);
8849 case DW_CFA_def_cfa_offset_sf:
8850 fc->cfa_offset = SLEB ();
8851 if (! do_debug_frames_interp)
8852 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
8855 case DW_CFA_GNU_window_save:
8856 if (! do_debug_frames_interp)
8857 printf (" DW_CFA_GNU_window_save\n");
8860 case DW_CFA_GNU_args_size:
8862 if (! do_debug_frames_interp)
8863 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
8866 case DW_CFA_GNU_negative_offset_extended:
8869 frame_need_space (fc, reg);
8870 if (! do_debug_frames_interp)
8871 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8872 reg, l * fc->data_factor);
8873 fc->col_type[reg] = DW_CFA_offset;
8874 fc->col_offset[reg] = l * fc->data_factor;
8877 /* FIXME: How do we handle these? */
8878 case DW_CFA_def_cfa_expression:
8879 fprintf (stderr, "unsupported DW_CFA_def_cfa_expression\n");
8883 case DW_CFA_expression:
8884 fprintf (stderr, "unsupported DW_CFA_expression\n");
8889 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
8894 if (do_debug_frames_interp)
8895 frame_display_row (fc, &need_col_headers, &max_regs);
8910 display_debug_not_supported (section, start, file)
8911 Elf32_Internal_Shdr * section;
8912 unsigned char * start ATTRIBUTE_UNUSED;
8913 FILE * file ATTRIBUTE_UNUSED;
8915 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8916 SECTION_NAME (section));
8921 /* Pre-scan the .debug_info section to record the size of address.
8922 When dumping the .debug_line, we use that size information, assuming
8923 that all compilation units have the same address size. */
8925 prescan_debug_info (section, start, file)
8926 Elf32_Internal_Shdr * section ATTRIBUTE_UNUSED;
8927 unsigned char * start;
8928 FILE * file ATTRIBUTE_UNUSED;
8930 DWARF2_External_CompUnit * external;
8932 external = (DWARF2_External_CompUnit *) start;
8934 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
8938 /* A structure containing the name of a debug section and a pointer
8939 to a function that can decode it. The third field is a prescan
8940 function to be run over the section before displaying any of the
8944 const char * const name;
8945 int (* display) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8946 int (* prescan) PARAMS ((Elf32_Internal_Shdr *, unsigned char *, FILE *));
8950 { ".debug_abbrev", display_debug_abbrev, NULL },
8951 { ".debug_aranges", display_debug_aranges, NULL },
8952 { ".debug_frame", display_debug_frames, NULL },
8953 { ".debug_info", display_debug_info, prescan_debug_info },
8954 { ".debug_line", display_debug_lines, NULL },
8955 { ".debug_pubnames", display_debug_pubnames, NULL },
8956 { ".eh_frame", display_debug_frames, NULL },
8957 { ".debug_macinfo", display_debug_macinfo, NULL },
8958 { ".debug_str", display_debug_str, NULL },
8959 { ".debug_loc", display_debug_loc, NULL },
8960 { ".debug_pubtypes", display_debug_not_supported, NULL },
8961 { ".debug_ranges", display_debug_not_supported, NULL },
8962 { ".debug_static_func", display_debug_not_supported, NULL },
8963 { ".debug_static_vars", display_debug_not_supported, NULL },
8964 { ".debug_types", display_debug_not_supported, NULL },
8965 { ".debug_weaknames", display_debug_not_supported, NULL }
8969 display_debug_section (section, file)
8970 Elf32_Internal_Shdr * section;
8973 char * name = SECTION_NAME (section);
8974 bfd_size_type length;
8975 unsigned char * start;
8978 length = section->sh_size;
8981 printf (_("\nSection '%s' has no debugging data.\n"), name);
8985 start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
8986 _("debug section data"));
8990 /* See if we know how to display the contents of this section. */
8991 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
8992 name = ".debug_info";
8994 for (i = NUM_ELEM (debug_displays); i--;)
8995 if (strcmp (debug_displays[i].name, name) == 0)
8997 debug_displays[i].display (section, start, file);
9002 printf (_("Unrecognized debug section: %s\n"), name);
9006 /* If we loaded in the abbrev section at some point,
9007 we must release it here. */
9014 process_section_contents (file)
9017 Elf32_Internal_Shdr * section;
9023 /* Pre-scan the debug sections to find some debug information not
9024 present in some of them. For the .debug_line, we must find out the
9025 size of address (specified in .debug_info and .debug_aranges). */
9026 for (i = 0, section = section_headers;
9027 i < elf_header.e_shnum && i < num_dump_sects;
9030 char * name = SECTION_NAME (section);
9033 if (section->sh_size == 0)
9036 /* See if there is some pre-scan operation for this section. */
9037 for (j = NUM_ELEM (debug_displays); j--;)
9038 if (strcmp (debug_displays[j].name, name) == 0)
9040 if (debug_displays[j].prescan != NULL)
9042 bfd_size_type length;
9043 unsigned char * start;
9045 length = section->sh_size;
9046 start = ((unsigned char *)
9047 get_data (NULL, file, section->sh_offset, length,
9048 _("debug section data")));
9052 debug_displays[j].prescan (section, start, file);
9060 for (i = 0, section = section_headers;
9061 i < elf_header.e_shnum && i < num_dump_sects;
9064 #ifdef SUPPORT_DISASSEMBLY
9065 if (dump_sects[i] & DISASS_DUMP)
9066 disassemble_section (section, file);
9068 if (dump_sects[i] & HEX_DUMP)
9069 dump_section (section, file);
9071 if (dump_sects[i] & DEBUG_DUMP)
9072 display_debug_section (section, file);
9075 if (i < num_dump_sects)
9076 warn (_("Some sections were not dumped because they do not exist!\n"));
9082 process_mips_fpe_exception (mask)
9088 if (mask & OEX_FPU_INEX)
9089 fputs ("INEX", stdout), first = 0;
9090 if (mask & OEX_FPU_UFLO)
9091 printf ("%sUFLO", first ? "" : "|"), first = 0;
9092 if (mask & OEX_FPU_OFLO)
9093 printf ("%sOFLO", first ? "" : "|"), first = 0;
9094 if (mask & OEX_FPU_DIV0)
9095 printf ("%sDIV0", first ? "" : "|"), first = 0;
9096 if (mask & OEX_FPU_INVAL)
9097 printf ("%sINVAL", first ? "" : "|");
9100 fputs ("0", stdout);
9104 process_mips_specific (file)
9107 Elf_Internal_Dyn * entry;
9108 size_t liblist_offset = 0;
9109 size_t liblistno = 0;
9110 size_t conflictsno = 0;
9111 size_t options_offset = 0;
9112 size_t conflicts_offset = 0;
9114 /* We have a lot of special sections. Thanks SGI! */
9115 if (dynamic_segment == NULL)
9116 /* No information available. */
9119 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
9120 switch (entry->d_tag)
9122 case DT_MIPS_LIBLIST:
9123 liblist_offset = entry->d_un.d_val - loadaddr;
9125 case DT_MIPS_LIBLISTNO:
9126 liblistno = entry->d_un.d_val;
9128 case DT_MIPS_OPTIONS:
9129 options_offset = entry->d_un.d_val - loadaddr;
9131 case DT_MIPS_CONFLICT:
9132 conflicts_offset = entry->d_un.d_val - loadaddr;
9134 case DT_MIPS_CONFLICTNO:
9135 conflictsno = entry->d_un.d_val;
9141 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9143 Elf32_External_Lib * elib;
9146 elib = ((Elf32_External_Lib *)
9147 get_data (NULL, file, liblist_offset,
9148 liblistno * sizeof (Elf32_External_Lib),
9152 printf ("\nSection '.liblist' contains %lu entries:\n",
9153 (unsigned long) liblistno);
9154 fputs (" Library Time Stamp Checksum Version Flags\n",
9157 for (cnt = 0; cnt < liblistno; ++cnt)
9164 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9165 time = BYTE_GET (elib[cnt].l_time_stamp);
9166 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9167 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9168 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9170 tmp = gmtime (&time);
9171 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9172 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9173 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9175 printf ("%3lu: ", (unsigned long) cnt);
9176 print_symbol (20, dynamic_strings + liblist.l_name);
9177 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9180 if (liblist.l_flags == 0)
9191 { " EXACT_MATCH", LL_EXACT_MATCH },
9192 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9193 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9194 { " EXPORTS", LL_EXPORTS },
9195 { " DELAY_LOAD", LL_DELAY_LOAD },
9196 { " DELTA", LL_DELTA }
9198 int flags = liblist.l_flags;
9202 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
9204 if ((flags & l_flags_vals[fcnt].bit) != 0)
9206 fputs (l_flags_vals[fcnt].name, stdout);
9207 flags ^= l_flags_vals[fcnt].bit;
9210 printf (" %#x", (unsigned int) flags);
9220 if (options_offset != 0)
9222 Elf_External_Options * eopt;
9223 Elf_Internal_Shdr * sect = section_headers;
9224 Elf_Internal_Options * iopt;
9225 Elf_Internal_Options * option;
9229 /* Find the section header so that we get the size. */
9230 while (sect->sh_type != SHT_MIPS_OPTIONS)
9233 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
9234 sect->sh_size, _("options"));
9237 iopt = ((Elf_Internal_Options *)
9238 malloc ((sect->sh_size / sizeof (eopt)) * sizeof (* iopt)));
9241 error (_("Out of memory"));
9248 while (offset < sect->sh_size)
9250 Elf_External_Options * eoption;
9252 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9254 option->kind = BYTE_GET (eoption->kind);
9255 option->size = BYTE_GET (eoption->size);
9256 option->section = BYTE_GET (eoption->section);
9257 option->info = BYTE_GET (eoption->info);
9259 offset += option->size;
9265 printf (_("\nSection '%s' contains %d entries:\n"),
9266 SECTION_NAME (sect), cnt);
9274 switch (option->kind)
9277 /* This shouldn't happen. */
9278 printf (" NULL %d %lx", option->section, option->info);
9281 printf (" REGINFO ");
9282 if (elf_header.e_machine == EM_MIPS)
9285 Elf32_External_RegInfo * ereg;
9286 Elf32_RegInfo reginfo;
9288 ereg = (Elf32_External_RegInfo *) (option + 1);
9289 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9290 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9291 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9292 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9293 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9294 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9296 printf ("GPR %08lx GP 0x%lx\n",
9298 (unsigned long) reginfo.ri_gp_value);
9299 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9300 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9301 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9306 Elf64_External_RegInfo * ereg;
9307 Elf64_Internal_RegInfo reginfo;
9309 ereg = (Elf64_External_RegInfo *) (option + 1);
9310 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9311 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9312 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9313 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9314 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9315 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
9317 printf ("GPR %08lx GP 0x",
9318 reginfo.ri_gprmask);
9319 printf_vma (reginfo.ri_gp_value);
9322 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9323 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9324 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9328 case ODK_EXCEPTIONS:
9329 fputs (" EXCEPTIONS fpe_min(", stdout);
9330 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9331 fputs (") fpe_max(", stdout);
9332 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9333 fputs (")", stdout);
9335 if (option->info & OEX_PAGE0)
9336 fputs (" PAGE0", stdout);
9337 if (option->info & OEX_SMM)
9338 fputs (" SMM", stdout);
9339 if (option->info & OEX_FPDBUG)
9340 fputs (" FPDBUG", stdout);
9341 if (option->info & OEX_DISMISS)
9342 fputs (" DISMISS", stdout);
9345 fputs (" PAD ", stdout);
9346 if (option->info & OPAD_PREFIX)
9347 fputs (" PREFIX", stdout);
9348 if (option->info & OPAD_POSTFIX)
9349 fputs (" POSTFIX", stdout);
9350 if (option->info & OPAD_SYMBOL)
9351 fputs (" SYMBOL", stdout);
9354 fputs (" HWPATCH ", stdout);
9355 if (option->info & OHW_R4KEOP)
9356 fputs (" R4KEOP", stdout);
9357 if (option->info & OHW_R8KPFETCH)
9358 fputs (" R8KPFETCH", stdout);
9359 if (option->info & OHW_R5KEOP)
9360 fputs (" R5KEOP", stdout);
9361 if (option->info & OHW_R5KCVTL)
9362 fputs (" R5KCVTL", stdout);
9365 fputs (" FILL ", stdout);
9366 /* XXX Print content of info word? */
9369 fputs (" TAGS ", stdout);
9370 /* XXX Print content of info word? */
9373 fputs (" HWAND ", stdout);
9374 if (option->info & OHWA0_R4KEOP_CHECKED)
9375 fputs (" R4KEOP_CHECKED", stdout);
9376 if (option->info & OHWA0_R4KEOP_CLEAN)
9377 fputs (" R4KEOP_CLEAN", stdout);
9380 fputs (" HWOR ", stdout);
9381 if (option->info & OHWA0_R4KEOP_CHECKED)
9382 fputs (" R4KEOP_CHECKED", stdout);
9383 if (option->info & OHWA0_R4KEOP_CLEAN)
9384 fputs (" R4KEOP_CLEAN", stdout);
9387 printf (" GP_GROUP %#06lx self-contained %#06lx",
9388 option->info & OGP_GROUP,
9389 (option->info & OGP_SELF) >> 16);
9392 printf (" IDENT %#06lx self-contained %#06lx",
9393 option->info & OGP_GROUP,
9394 (option->info & OGP_SELF) >> 16);
9397 /* This shouldn't happen. */
9398 printf (" %3d ??? %d %lx",
9399 option->kind, option->section, option->info);
9403 len = sizeof (* eopt);
9404 while (len < option->size)
9405 if (((char *) option)[len] >= ' '
9406 && ((char *) option)[len] < 0x7f)
9407 printf ("%c", ((char *) option)[len++]);
9409 printf ("\\%03o", ((char *) option)[len++]);
9411 fputs ("\n", stdout);
9419 if (conflicts_offset != 0 && conflictsno != 0)
9421 Elf32_Conflict * iconf;
9424 if (dynamic_symbols == NULL)
9426 error (_("conflict list found without a dynamic symbol table"));
9430 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (* iconf));
9433 error (_("Out of memory"));
9439 Elf32_External_Conflict * econf32;
9441 econf32 = ((Elf32_External_Conflict *)
9442 get_data (NULL, file, conflicts_offset,
9443 conflictsno * sizeof (* econf32),
9448 for (cnt = 0; cnt < conflictsno; ++cnt)
9449 iconf[cnt] = BYTE_GET (econf32[cnt]);
9455 Elf64_External_Conflict * econf64;
9457 econf64 = ((Elf64_External_Conflict *)
9458 get_data (NULL, file, conflicts_offset,
9459 conflictsno * sizeof (* econf64),
9464 for (cnt = 0; cnt < conflictsno; ++cnt)
9465 iconf[cnt] = BYTE_GET (econf64[cnt]);
9470 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9471 (long) conflictsno);
9472 puts (_(" Num: Index Value Name"));
9474 for (cnt = 0; cnt < conflictsno; ++cnt)
9476 Elf_Internal_Sym * psym = & dynamic_symbols [iconf [cnt]];
9478 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf [cnt]);
9479 print_vma (psym->st_value, FULL_HEX);
9481 print_symbol (25, dynamic_strings + psym->st_name);
9492 process_gnu_liblist (file)
9495 Elf_Internal_Shdr * section, * string_sec;
9496 Elf32_External_Lib * elib;
9504 for (i = 0, section = section_headers;
9505 i < elf_header.e_shnum;
9508 switch (section->sh_type)
9510 case SHT_GNU_LIBLIST:
9511 elib = ((Elf32_External_Lib *)
9512 get_data (NULL, file, section->sh_offset, section->sh_size,
9517 string_sec = SECTION_HEADER (section->sh_link);
9519 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9520 string_sec->sh_size,
9521 _("liblist string table"));
9524 || section->sh_entsize != sizeof (Elf32_External_Lib))
9530 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9531 SECTION_NAME (section),
9532 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9534 puts (" Library Time Stamp Checksum Version Flags");
9536 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9544 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9545 time = BYTE_GET (elib[cnt].l_time_stamp);
9546 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9547 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9548 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9550 tmp = gmtime (&time);
9551 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9552 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9553 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9555 printf ("%3lu: ", (unsigned long) cnt);
9557 printf ("%-20s", strtab + liblist.l_name);
9559 printf ("%-20.20s", strtab + liblist.l_name);
9560 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9561 liblist.l_version, liblist.l_flags);
9572 get_note_type (e_type)
9575 static char buff[64];
9579 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
9580 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
9581 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
9582 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
9583 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
9584 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
9585 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
9586 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
9587 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9588 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9589 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9591 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9597 get_netbsd_elfcore_note_type (e_type)
9600 static char buff[64];
9602 if (e_type == NT_NETBSDCORE_PROCINFO)
9604 /* NetBSD core "procinfo" structure. */
9605 return _("NetBSD procinfo structure");
9608 /* As of Jan 2002 there are no other machine-independent notes
9609 defined for NetBSD core files. If the note type is less
9610 than the start of the machine-dependent note types, we don't
9613 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9615 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9619 switch (elf_header.e_machine)
9621 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9622 and PT_GETFPREGS == mach+2. */
9627 case EM_SPARC32PLUS:
9631 case NT_NETBSDCORE_FIRSTMACH+0:
9632 return _("PT_GETREGS (reg structure)");
9633 case NT_NETBSDCORE_FIRSTMACH+2:
9634 return _("PT_GETFPREGS (fpreg structure)");
9640 /* On all other arch's, PT_GETREGS == mach+1 and
9641 PT_GETFPREGS == mach+3. */
9645 case NT_NETBSDCORE_FIRSTMACH+1:
9646 return _("PT_GETREGS (reg structure)");
9647 case NT_NETBSDCORE_FIRSTMACH+3:
9648 return _("PT_GETFPREGS (fpreg structure)");
9654 sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
9658 /* Note that by the ELF standard, the name field is already null byte
9659 terminated, and namesz includes the terminating null byte.
9660 I.E. the value of namesz for the name "FSF" is 4.
9662 If the value of namesz is zero, there is no name present. */
9664 process_note (pnote)
9665 Elf32_Internal_Note * pnote;
9669 if (pnote->namesz == 0)
9671 /* If there is no note name, then use the default set of
9672 note type strings. */
9673 nt = get_note_type (pnote->type);
9675 else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
9677 /* NetBSD-specific core file notes. */
9678 nt = get_netbsd_elfcore_note_type (pnote->type);
9682 /* Don't recognize this note name; just use the default set of
9683 note type strings. */
9684 nt = get_note_type (pnote->type);
9687 printf (" %s\t\t0x%08lx\t%s\n",
9688 pnote->namesz ? pnote->namedata : "(NONE)",
9695 process_corefile_note_segment (file, offset, length)
9700 Elf_External_Note * pnotes;
9701 Elf_External_Note * external;
9707 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
9714 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9715 (unsigned long) offset, (unsigned long) length);
9716 printf (_(" Owner\t\tData size\tDescription\n"));
9718 while (external < (Elf_External_Note *)((char *) pnotes + length))
9720 Elf_External_Note * next;
9721 Elf32_Internal_Note inote;
9724 inote.type = BYTE_GET (external->type);
9725 inote.namesz = BYTE_GET (external->namesz);
9726 inote.namedata = external->name;
9727 inote.descsz = BYTE_GET (external->descsz);
9728 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9729 inote.descpos = offset + (inote.descdata - (char *) pnotes);
9731 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9733 if (((char *) next) > (((char *) pnotes) + length))
9735 warn (_("corrupt note found at offset %x into core notes\n"),
9736 ((char *) external) - ((char *) pnotes));
9737 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9738 inote.type, inote.namesz, inote.descsz);
9744 /* Verify that name is null terminated. It appears that at least
9745 one version of Linux (RedHat 6.0) generates corefiles that don't
9746 comply with the ELF spec by failing to include the null byte in
9748 if (inote.namedata[inote.namesz] != '\0')
9750 temp = malloc (inote.namesz + 1);
9754 error (_("Out of memory\n"));
9759 strncpy (temp, inote.namedata, inote.namesz);
9760 temp[inote.namesz] = 0;
9762 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9763 inote.namedata = temp;
9766 res &= process_note (& inote);
9781 process_corefile_note_segments (file)
9784 Elf_Internal_Phdr * program_headers;
9785 Elf_Internal_Phdr * segment;
9789 program_headers = (Elf_Internal_Phdr *) malloc
9790 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
9792 if (program_headers == NULL)
9794 error (_("Out of memory\n"));
9799 i = get_32bit_program_headers (file, program_headers);
9801 i = get_64bit_program_headers (file, program_headers);
9805 free (program_headers);
9809 for (i = 0, segment = program_headers;
9810 i < elf_header.e_phnum;
9813 if (segment->p_type == PT_NOTE)
9814 res &= process_corefile_note_segment (file,
9815 (bfd_vma) segment->p_offset,
9816 (bfd_vma) segment->p_filesz);
9819 free (program_headers);
9825 process_corefile_contents (file)
9828 /* If we have not been asked to display the notes then do nothing. */
9832 /* If file is not a core file then exit. */
9833 if (elf_header.e_type != ET_CORE)
9836 /* No program headers means no NOTE segment. */
9837 if (elf_header.e_phnum == 0)
9839 printf (_("No note segments present in the core file.\n"));
9843 return process_corefile_note_segments (file);
9847 process_arch_specific (file)
9853 switch (elf_header.e_machine)
9856 case EM_MIPS_RS3_LE:
9857 return process_mips_specific (file);
9866 get_file_header (file)
9869 /* Read in the identity array. */
9870 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
9873 /* Determine how to read the rest of the header. */
9874 switch (elf_header.e_ident [EI_DATA])
9876 default: /* fall through */
9877 case ELFDATANONE: /* fall through */
9878 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
9879 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
9882 /* For now we only support 32 bit and 64 bit ELF files. */
9883 is_32bit_elf = (elf_header.e_ident [EI_CLASS] != ELFCLASS64);
9885 /* Read in the rest of the header. */
9888 Elf32_External_Ehdr ehdr32;
9890 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
9893 elf_header.e_type = BYTE_GET (ehdr32.e_type);
9894 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
9895 elf_header.e_version = BYTE_GET (ehdr32.e_version);
9896 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
9897 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
9898 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
9899 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
9900 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
9901 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
9902 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
9903 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
9904 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
9905 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
9909 Elf64_External_Ehdr ehdr64;
9911 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9912 we will not be able to cope with the 64bit data found in
9913 64 ELF files. Detect this now and abort before we start
9914 overwritting things. */
9915 if (sizeof (bfd_vma) < 8)
9917 error (_("This instance of readelf has been built without support for a\n\
9918 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9922 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
9925 elf_header.e_type = BYTE_GET (ehdr64.e_type);
9926 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
9927 elf_header.e_version = BYTE_GET (ehdr64.e_version);
9928 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
9929 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
9930 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
9931 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
9932 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
9933 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
9934 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
9935 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
9936 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
9937 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
9940 if (elf_header.e_shoff)
9942 /* There may be some extensions in the first section header. Don't
9943 bomb if we can't read it. */
9945 get_32bit_section_headers (file, 1);
9947 get_64bit_section_headers (file, 1);
9954 process_file (file_name)
9958 struct stat statbuf;
9961 if (stat (file_name, & statbuf) < 0)
9963 error (_("Cannot stat input file %s.\n"), file_name);
9967 file = fopen (file_name, "rb");
9970 error (_("Input file %s not found.\n"), file_name);
9974 if (! get_file_header (file))
9976 error (_("%s: Failed to read file header\n"), file_name);
9981 /* Initialise per file variables. */
9982 for (i = NUM_ELEM (version_info); i--;)
9983 version_info[i] = 0;
9985 for (i = NUM_ELEM (dynamic_info); i--;)
9986 dynamic_info[i] = 0;
9988 /* Process the file. */
9990 printf (_("\nFile: %s\n"), file_name);
9992 if (! process_file_header ())
9998 process_section_headers (file);
10000 process_program_headers (file);
10002 process_dynamic_segment (file);
10004 process_relocs (file);
10006 process_unwind (file);
10008 process_symbol_table (file);
10010 process_syminfo (file);
10012 process_version_sections (file);
10014 process_section_contents (file);
10016 process_corefile_contents (file);
10018 process_gnu_liblist (file);
10020 process_arch_specific (file);
10024 if (section_headers)
10026 free (section_headers);
10027 section_headers = NULL;
10032 free (string_table);
10033 string_table = NULL;
10034 string_table_length = 0;
10037 if (dynamic_strings)
10039 free (dynamic_strings);
10040 dynamic_strings = NULL;
10043 if (dynamic_symbols)
10045 free (dynamic_symbols);
10046 dynamic_symbols = NULL;
10047 num_dynamic_syms = 0;
10050 if (dynamic_syminfo)
10052 free (dynamic_syminfo);
10053 dynamic_syminfo = NULL;
10059 #ifdef SUPPORT_DISASSEMBLY
10060 /* Needed by the i386 disassembler. For extra credit, someone could
10061 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10065 print_address (unsigned int addr, FILE * outfile)
10067 fprintf (outfile,"0x%8.8x", addr);
10070 /* Needed by the i386 disassembler. */
10072 db_task_printsym (unsigned int addr)
10074 print_address (addr, stderr);
10078 int main PARAMS ((int, char **));
10087 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10088 setlocale (LC_MESSAGES, "");
10090 #if defined (HAVE_SETLOCALE)
10091 setlocale (LC_CTYPE, "");
10093 bindtextdomain (PACKAGE, LOCALEDIR);
10094 textdomain (PACKAGE);
10096 parse_args (argc, argv);
10098 if (optind < (argc - 1))
10102 while (optind < argc)
10103 err |= process_file (argv [optind ++]);
10105 if (dump_sects != NULL)