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 believe that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
52 #include "elf/alpha.h"
72 #include "elf/m68hc11.h"
73 #include "elf/mcore.h"
76 #include "elf/mn10200.h"
77 #include "elf/mn10300.h"
78 #include "elf/msp430.h"
84 #include "elf/sparc.h"
87 #include "elf/x86-64.h"
88 #include "elf/xstormy16.h"
93 char *program_name = "readelf";
94 unsigned long dynamic_addr;
95 bfd_size_type dynamic_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 long dynamic_info[DT_JMPREL + 1];
106 long 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
163 PARAMS ((bfd_vma, print_mode));
164 static void print_symbol
165 PARAMS ((int, const char *));
166 static bfd_vma (*byte_get)
167 PARAMS ((unsigned char *, int));
168 static bfd_vma byte_get_little_endian
169 PARAMS ((unsigned char *, int));
170 static bfd_vma byte_get_big_endian
171 PARAMS ((unsigned char *, int));
172 static const char *get_mips_dynamic_type
173 PARAMS ((unsigned long));
174 static const char *get_sparc64_dynamic_type
175 PARAMS ((unsigned long));
176 static const char *get_ppc64_dynamic_type
177 PARAMS ((unsigned long));
178 static const char *get_parisc_dynamic_type
179 PARAMS ((unsigned long));
180 static const char *get_dynamic_type
181 PARAMS ((unsigned long));
182 static int slurp_rela_relocs
183 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **,
185 static int slurp_rel_relocs
186 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela **,
188 static int dump_relocations
189 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym *,
190 unsigned long, char *, int));
191 static char *get_file_type
193 static char *get_machine_name
195 static void decode_ARM_machine_flags
196 PARAMS ((unsigned, char[]));
197 static char *get_machine_flags
198 PARAMS ((unsigned, unsigned));
199 static const char *get_mips_segment_type
200 PARAMS ((unsigned long));
201 static const char *get_parisc_segment_type
202 PARAMS ((unsigned long));
203 static const char *get_ia64_segment_type
204 PARAMS ((unsigned long));
205 static const char *get_segment_type
206 PARAMS ((unsigned long));
207 static const char *get_mips_section_type_name
208 PARAMS ((unsigned int));
209 static const char *get_parisc_section_type_name
210 PARAMS ((unsigned int));
211 static const char *get_ia64_section_type_name
212 PARAMS ((unsigned int));
213 static const char *get_section_type_name
214 PARAMS ((unsigned int));
215 static const char *get_symbol_binding
216 PARAMS ((unsigned int));
217 static const char *get_symbol_type
218 PARAMS ((unsigned int));
219 static const char *get_symbol_visibility
220 PARAMS ((unsigned int));
221 static const char *get_symbol_index_type
222 PARAMS ((unsigned int));
223 static const char *get_dynamic_flags
227 static void parse_args
228 PARAMS ((int, char **));
229 static int process_file_header
231 static int process_program_headers
233 static int process_section_headers
235 static int process_unwind
237 static void dynamic_segment_mips_val
238 PARAMS ((Elf_Internal_Dyn *));
239 static void dynamic_segment_parisc_val
240 PARAMS ((Elf_Internal_Dyn *));
241 static int process_dynamic_segment
243 static int process_symbol_table
245 static int process_syminfo
247 static int process_section_contents
249 static void process_mips_fpe_exception
251 static int process_mips_specific
253 static int process_file
255 static int process_relocs
257 static int process_version_sections
259 static char *get_ver_flags
260 PARAMS ((unsigned int));
261 static int get_32bit_section_headers
262 PARAMS ((FILE *, unsigned int));
263 static int get_64bit_section_headers
264 PARAMS ((FILE *, unsigned int));
265 static int get_32bit_program_headers
266 PARAMS ((FILE *, Elf_Internal_Phdr *));
267 static int get_64bit_program_headers
268 PARAMS ((FILE *, Elf_Internal_Phdr *));
269 static int get_file_header
271 static Elf_Internal_Sym *get_32bit_elf_symbols
272 PARAMS ((FILE *, Elf_Internal_Shdr *));
273 static Elf_Internal_Sym *get_64bit_elf_symbols
274 PARAMS ((FILE *, Elf_Internal_Shdr *));
275 static const char *get_elf_section_flags
277 static int *get_dynamic_data
278 PARAMS ((FILE *, unsigned int));
279 static int get_32bit_dynamic_segment
281 static int get_64bit_dynamic_segment
283 #ifdef SUPPORT_DISASSEMBLY
284 static int disassemble_section
285 PARAMS ((Elf_Internal_Shdr *, FILE *));
287 static int dump_section
288 PARAMS ((Elf_Internal_Shdr *, FILE *));
289 static int display_debug_section
290 PARAMS ((Elf_Internal_Shdr *, FILE *));
291 static int display_debug_info
292 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
293 static int display_debug_not_supported
294 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
295 static int prescan_debug_info
296 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
297 static int display_debug_lines
298 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
299 static int display_debug_pubnames
300 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
301 static int display_debug_abbrev
302 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
303 static int display_debug_aranges
304 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
305 static int display_debug_frames
306 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
307 static int display_debug_macinfo
308 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
309 static int display_debug_str
310 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
311 static int display_debug_loc
312 PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
313 static unsigned char *process_abbrev_section
314 PARAMS ((unsigned char *, unsigned char *));
315 static void load_debug_str
317 static void free_debug_str
319 static const char *fetch_indirect_string
320 PARAMS ((unsigned long));
321 static void load_debug_loc
323 static void free_debug_loc
325 static unsigned long read_leb128
326 PARAMS ((unsigned char *, int *, int));
327 static int process_extended_line_op
328 PARAMS ((unsigned char *, int, int));
329 static void reset_state_machine
331 static char *get_TAG_name
332 PARAMS ((unsigned long));
333 static char *get_AT_name
334 PARAMS ((unsigned long));
335 static char *get_FORM_name
336 PARAMS ((unsigned long));
337 static void free_abbrevs
339 static void add_abbrev
340 PARAMS ((unsigned long, unsigned long, int));
341 static void add_abbrev_attr
342 PARAMS ((unsigned long, unsigned long));
343 static unsigned char *read_and_display_attr
344 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
346 static unsigned char *read_and_display_attr_value
347 PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long,
349 static unsigned char *display_block
350 PARAMS ((unsigned char *, unsigned long));
351 static void decode_location_expression
352 PARAMS ((unsigned char *, unsigned int, unsigned long));
353 static void request_dump
354 PARAMS ((unsigned int, int));
355 static const char *get_elf_class
356 PARAMS ((unsigned int));
357 static const char *get_data_encoding
358 PARAMS ((unsigned int));
359 static const char *get_osabi_name
360 PARAMS ((unsigned int));
361 static int guess_is_rela
362 PARAMS ((unsigned long));
363 static const char *get_note_type
364 PARAMS ((unsigned int));
365 static const char *get_netbsd_elfcore_note_type
366 PARAMS ((unsigned int));
367 static int process_note
368 PARAMS ((Elf_Internal_Note *));
369 static int process_corefile_note_segment
370 PARAMS ((FILE *, bfd_vma, bfd_vma));
371 static int process_corefile_note_segments
373 static int process_corefile_contents
375 static int process_arch_specific
377 static int process_gnu_liblist
380 typedef int Elf32_Word;
384 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
385 ((X)->sh_name >= string_table_length \
386 ? "<corrupt>" : string_table + (X)->sh_name))
388 /* Given st_shndx I, map to section_headers index. */
389 #define SECTION_HEADER_INDEX(I) \
390 ((I) < SHN_LORESERVE \
392 : ((I) <= SHN_HIRESERVE \
394 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
396 /* Reverse of the above. */
397 #define SECTION_HEADER_NUM(N) \
398 ((N) < SHN_LORESERVE \
400 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
402 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
404 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
406 #define BYTE_GET(field) byte_get (field, sizeof (field))
408 /* If we can support a 64 bit data type then BFD64 should be defined
409 and sizeof (bfd_vma) == 8. In this case when translating from an
410 external 8 byte field to an internal field, we can assume that the
411 internal field is also 8 bytes wide and so we can extract all the data.
412 If, however, BFD64 is not defined, then we must assume that the
413 internal data structure only has 4 byte wide fields that are the
414 equivalent of the 8 byte wide external counterparts, and so we must
415 truncate the data. */
417 #define BYTE_GET8(field) byte_get (field, -8)
419 #define BYTE_GET8(field) byte_get (field, 8)
422 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
424 #define GET_ELF_SYMBOLS(file, section) \
425 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
426 : get_64bit_elf_symbols (file, section))
430 error VPARAMS ((const char *message, ...))
432 VA_OPEN (args, message);
433 VA_FIXEDARG (args, const char *, message);
435 fprintf (stderr, _("%s: Error: "), program_name);
436 vfprintf (stderr, message, args);
441 warn VPARAMS ((const char *message, ...))
443 VA_OPEN (args, message);
444 VA_FIXEDARG (args, const char *, message);
446 fprintf (stderr, _("%s: Warning: "), program_name);
447 vfprintf (stderr, message, args);
451 static PTR get_data PARAMS ((PTR, FILE *, long, size_t, const char *));
454 get_data (var, file, offset, size, reason)
466 if (fseek (file, offset, SEEK_SET))
468 error (_("Unable to seek to %x for %s\n"), offset, reason);
475 mvar = (PTR) malloc (size);
479 error (_("Out of memory allocating %d bytes for %s\n"),
485 if (fread (mvar, size, 1, file) != 1)
487 error (_("Unable to read in %d bytes of %s\n"), size, reason);
497 byte_get_little_endian (field, size)
498 unsigned char *field;
507 return ((unsigned int) (field[0]))
508 | (((unsigned int) (field[1])) << 8);
512 /* We want to extract data from an 8 byte wide field and
513 place it into a 4 byte wide field. Since this is a little
514 endian source we can just use the 4 byte extraction code. */
518 return ((unsigned long) (field[0]))
519 | (((unsigned long) (field[1])) << 8)
520 | (((unsigned long) (field[2])) << 16)
521 | (((unsigned long) (field[3])) << 24);
526 /* This is a special case, generated by the BYTE_GET8 macro.
527 It means that we are loading an 8 byte value from a field
528 in an external structure into an 8 byte value in a field
529 in an internal strcuture. */
530 return ((bfd_vma) (field[0]))
531 | (((bfd_vma) (field[1])) << 8)
532 | (((bfd_vma) (field[2])) << 16)
533 | (((bfd_vma) (field[3])) << 24)
534 | (((bfd_vma) (field[4])) << 32)
535 | (((bfd_vma) (field[5])) << 40)
536 | (((bfd_vma) (field[6])) << 48)
537 | (((bfd_vma) (field[7])) << 56);
540 error (_("Unhandled data length: %d\n"), size);
545 /* Print a VMA value. */
547 print_vma (vma, mode)
557 case FULL_HEX: printf ("0x"); /* drop through */
558 case LONG_HEX: printf ("%8.8lx", (unsigned long) vma); break;
559 case PREFIX_HEX: printf ("0x"); /* drop through */
560 case HEX: printf ("%lx", (unsigned long) vma); break;
561 case DEC: printf ("%ld", (unsigned long) vma); break;
562 case DEC_5: printf ("%5ld", (long) vma); break;
563 case UNSIGNED: printf ("%lu", (unsigned long) vma); break;
584 #if BFD_HOST_64BIT_LONG
587 if (_bfd_int64_high (vma))
588 printf ("%lx%8.8lx", _bfd_int64_high (vma), _bfd_int64_low (vma));
590 printf ("%lx", _bfd_int64_low (vma));
595 #if BFD_HOST_64BIT_LONG
598 if (_bfd_int64_high (vma))
600 printf ("++%ld", _bfd_int64_low (vma));
602 printf ("%ld", _bfd_int64_low (vma));
607 #if BFD_HOST_64BIT_LONG
608 printf ("%5ld", vma);
610 if (_bfd_int64_high (vma))
612 printf ("++%ld", _bfd_int64_low (vma));
614 printf ("%5ld", _bfd_int64_low (vma));
619 #if BFD_HOST_64BIT_LONG
622 if (_bfd_int64_high (vma))
624 printf ("++%lu", _bfd_int64_low (vma));
626 printf ("%lu", _bfd_int64_low (vma));
634 /* Display a symbol on stdout. If do_wide is not true then
635 format the symbol to be at most WIDTH characters,
636 truncating as necessary. If WIDTH is negative then
637 format the string to be exactly - WIDTH characters,
638 truncating or padding as necessary. */
641 print_symbol (width, symbol)
646 printf ("%s", symbol);
648 printf ("%-*.*s", width, width, symbol);
650 printf ("%-.*s", width, symbol);
654 byte_get_big_endian (field, size)
655 unsigned char *field;
664 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
667 return ((unsigned long) (field[3]))
668 | (((unsigned long) (field[2])) << 8)
669 | (((unsigned long) (field[1])) << 16)
670 | (((unsigned long) (field[0])) << 24);
674 /* Although we are extracing data from an 8 byte wide field, we
675 are returning only 4 bytes of data. */
676 return ((unsigned long) (field[7]))
677 | (((unsigned long) (field[6])) << 8)
678 | (((unsigned long) (field[5])) << 16)
679 | (((unsigned long) (field[4])) << 24);
683 /* This is a special case, generated by the BYTE_GET8 macro.
684 It means that we are loading an 8 byte value from a field
685 in an external structure into an 8 byte value in a field
686 in an internal strcuture. */
687 return ((bfd_vma) (field[7]))
688 | (((bfd_vma) (field[6])) << 8)
689 | (((bfd_vma) (field[5])) << 16)
690 | (((bfd_vma) (field[4])) << 24)
691 | (((bfd_vma) (field[3])) << 32)
692 | (((bfd_vma) (field[2])) << 40)
693 | (((bfd_vma) (field[1])) << 48)
694 | (((bfd_vma) (field[0])) << 56);
698 error (_("Unhandled data length: %d\n"), size);
703 /* Guess the relocation size commonly used by the specific machines. */
706 guess_is_rela (e_machine)
707 unsigned long e_machine;
711 /* Targets that use REL relocations. */
727 /* Targets that use RELA relocations. */
742 case EM_CYGNUS_MN10200:
744 case EM_CYGNUS_MN10300:
786 warn (_("Don't know about relocations on this machine architecture\n"));
792 slurp_rela_relocs (file, rel_offset, rel_size, relasp, nrelasp)
794 unsigned long rel_offset;
795 unsigned long rel_size;
796 Elf_Internal_Rela **relasp;
797 unsigned long *nrelasp;
799 Elf_Internal_Rela *relas;
800 unsigned long nrelas;
805 Elf32_External_Rela *erelas;
807 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset,
808 rel_size, _("relocs"));
812 nrelas = rel_size / sizeof (Elf32_External_Rela);
814 relas = (Elf_Internal_Rela *)
815 malloc (nrelas * sizeof (Elf_Internal_Rela));
819 error(_("out of memory parsing relocs"));
823 for (i = 0; i < nrelas; i++)
825 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
826 relas[i].r_info = BYTE_GET (erelas[i].r_info);
827 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
834 Elf64_External_Rela *erelas;
836 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset,
837 rel_size, _("relocs"));
841 nrelas = rel_size / sizeof (Elf64_External_Rela);
843 relas = (Elf_Internal_Rela *)
844 malloc (nrelas * sizeof (Elf_Internal_Rela));
848 error(_("out of memory parsing relocs"));
852 for (i = 0; i < nrelas; i++)
854 relas[i].r_offset = BYTE_GET8 (erelas[i].r_offset);
855 relas[i].r_info = BYTE_GET8 (erelas[i].r_info);
856 relas[i].r_addend = BYTE_GET8 (erelas[i].r_addend);
867 slurp_rel_relocs (file, rel_offset, rel_size, relsp, nrelsp)
869 unsigned long rel_offset;
870 unsigned long rel_size;
871 Elf_Internal_Rela **relsp;
872 unsigned long *nrelsp;
874 Elf_Internal_Rela *rels;
880 Elf32_External_Rel *erels;
882 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset,
883 rel_size, _("relocs"));
887 nrels = rel_size / sizeof (Elf32_External_Rel);
889 rels = (Elf_Internal_Rela *) malloc (nrels * sizeof (Elf_Internal_Rela));
893 error(_("out of memory parsing relocs"));
897 for (i = 0; i < nrels; i++)
899 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
900 rels[i].r_info = BYTE_GET (erels[i].r_info);
901 rels[i].r_addend = 0;
908 Elf64_External_Rel *erels;
910 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset,
911 rel_size, _("relocs"));
915 nrels = rel_size / sizeof (Elf64_External_Rel);
917 rels = (Elf_Internal_Rela *) malloc (nrels * sizeof (Elf_Internal_Rela));
921 error(_("out of memory parsing relocs"));
925 for (i = 0; i < nrels; i++)
927 rels[i].r_offset = BYTE_GET8 (erels[i].r_offset);
928 rels[i].r_info = BYTE_GET8 (erels[i].r_info);
929 rels[i].r_addend = 0;
939 /* Display the contents of the relocation data found at the specified offset. */
941 dump_relocations (file, rel_offset, rel_size, symtab, nsyms, strtab, is_rela)
943 unsigned long rel_offset;
944 unsigned long rel_size;
945 Elf_Internal_Sym *symtab;
951 Elf_Internal_Rela *rels;
954 if (is_rela == UNKNOWN)
955 is_rela = guess_is_rela (elf_header.e_machine);
959 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
964 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
973 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
975 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
980 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
982 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
990 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
992 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
997 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
999 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1003 for (i = 0; i < rel_size; i++)
1006 const char *rtype2 = NULL;
1007 const char *rtype3 = NULL;
1010 bfd_vma symtab_index;
1012 bfd_vma type2 = (bfd_vma) NULL;
1013 bfd_vma type3 = (bfd_vma) NULL;
1015 offset = rels[i].r_offset;
1016 info = rels[i].r_info;
1020 type = ELF32_R_TYPE (info);
1021 symtab_index = ELF32_R_SYM (info);
1025 if (elf_header.e_machine == EM_MIPS)
1027 type = ELF64_MIPS_R_TYPE (info);
1028 type2 = ELF64_MIPS_R_TYPE2 (info);
1029 type3 = ELF64_MIPS_R_TYPE3 (info);
1031 else if (elf_header.e_machine == EM_SPARCV9)
1032 type = ELF64_R_TYPE_ID (info);
1034 type = ELF64_R_TYPE (info);
1035 /* The #ifdef BFD64 below is to prevent a compile time warning.
1036 We know that if we do not have a 64 bit data type that we
1037 will never execute this code anyway. */
1039 symtab_index = ELF64_R_SYM (info);
1045 #ifdef _bfd_int64_low
1046 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
1048 printf ("%8.8lx %8.8lx ", offset, info);
1053 #ifdef _bfd_int64_low
1055 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1056 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1057 _bfd_int64_high (offset),
1058 _bfd_int64_low (offset),
1059 _bfd_int64_high (info),
1060 _bfd_int64_low (info));
1063 ? "%16.16lx %16.16lx "
1064 : "%12.12lx %12.12lx ",
1069 switch (elf_header.e_machine)
1076 case EM_CYGNUS_M32R:
1077 rtype = elf_m32r_reloc_type (type);
1082 rtype = elf_i386_reloc_type (type);
1087 rtype = elf_m68hc11_reloc_type (type);
1091 rtype = elf_m68k_reloc_type (type);
1095 rtype = elf_i960_reloc_type (type);
1100 rtype = elf_avr_reloc_type (type);
1103 case EM_OLD_SPARCV9:
1104 case EM_SPARC32PLUS:
1107 rtype = elf_sparc_reloc_type (type);
1111 case EM_CYGNUS_V850:
1112 rtype = v850_reloc_type (type);
1116 case EM_CYGNUS_D10V:
1117 rtype = elf_d10v_reloc_type (type);
1121 case EM_CYGNUS_D30V:
1122 rtype = elf_d30v_reloc_type (type);
1126 rtype = elf_dlx_reloc_type (type);
1130 rtype = elf_sh_reloc_type (type);
1134 case EM_CYGNUS_MN10300:
1135 rtype = elf_mn10300_reloc_type (type);
1139 case EM_CYGNUS_MN10200:
1140 rtype = elf_mn10200_reloc_type (type);
1144 case EM_CYGNUS_FR30:
1145 rtype = elf_fr30_reloc_type (type);
1149 rtype = elf_frv_reloc_type (type);
1153 rtype = elf_mcore_reloc_type (type);
1157 rtype = elf_mmix_reloc_type (type);
1162 rtype = elf_msp430_reloc_type (type);
1167 rtype = elf_ppc_reloc_type (type);
1171 case EM_MIPS_RS3_LE:
1172 rtype = elf_mips_reloc_type (type);
1175 rtype2 = elf_mips_reloc_type (type2);
1176 rtype3 = elf_mips_reloc_type (type3);
1181 rtype = elf_alpha_reloc_type (type);
1185 rtype = elf_arm_reloc_type (type);
1189 rtype = elf_arc_reloc_type (type);
1193 rtype = elf_hppa_reloc_type (type);
1199 rtype = elf_h8_reloc_type (type);
1204 rtype = elf_or32_reloc_type (type);
1209 rtype = elf_pj_reloc_type (type);
1212 rtype = elf_ia64_reloc_type (type);
1216 rtype = elf_cris_reloc_type (type);
1220 rtype = elf_i860_reloc_type (type);
1224 rtype = elf_x86_64_reloc_type (type);
1228 rtype = i370_reloc_type (type);
1233 rtype = elf_s390_reloc_type (type);
1237 rtype = elf_xstormy16_reloc_type (type);
1241 rtype = elf_vax_reloc_type (type);
1246 rtype = elf_ip2k_reloc_type (type);
1251 #ifdef _bfd_int64_low
1252 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1254 printf (_("unrecognized: %-7lx"), type);
1257 printf (do_wide ? "%-21.21s" : "%-17.17s", rtype);
1261 if (symtab == NULL || symtab_index >= nsyms)
1262 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1265 Elf_Internal_Sym *psym;
1267 psym = symtab + symtab_index;
1270 print_vma (psym->st_value, LONG_HEX);
1271 printf (is_32bit_elf ? " " : " ");
1273 if (psym->st_name == 0)
1275 const char *sec_name = "<null>";
1278 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1280 bfd_vma sec_index = (bfd_vma) -1;
1282 if (psym->st_shndx < SHN_LORESERVE)
1283 sec_index = psym->st_shndx;
1284 else if (psym->st_shndx > SHN_LORESERVE)
1285 sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1288 if (sec_index != (bfd_vma) -1)
1289 sec_name = SECTION_NAME (section_headers + sec_index);
1290 else if (psym->st_shndx == SHN_ABS)
1292 else if (psym->st_shndx == SHN_COMMON)
1293 sec_name = "COMMON";
1296 sprintf (name_buf, "<section 0x%x>",
1297 (unsigned int) psym->st_shndx);
1298 sec_name = name_buf;
1301 print_symbol (22, sec_name);
1303 else if (strtab == NULL)
1304 printf (_("<string table index %3ld>"), psym->st_name);
1306 print_symbol (22, strtab + psym->st_name);
1309 printf (" + %lx", (unsigned long) rels[i].r_addend);
1314 printf ("%*c", is_32bit_elf ? (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1315 print_vma (rels[i].r_addend, LONG_HEX);
1318 if (elf_header.e_machine == EM_SPARCV9
1319 && !strcmp (rtype, "R_SPARC_OLO10"))
1320 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1324 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1326 printf (" Type2: ");
1329 #ifdef _bfd_int64_low
1330 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1332 printf (_("unrecognized: %-7lx"), type2);
1335 printf ("%-17.17s", rtype2);
1337 printf("\n Type3: ");
1340 #ifdef _bfd_int64_low
1341 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1343 printf (_("unrecognized: %-7lx"), type3);
1346 printf ("%-17.17s", rtype3);
1358 get_mips_dynamic_type (type)
1363 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1364 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1365 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1366 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1367 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1368 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1369 case DT_MIPS_MSYM: return "MIPS_MSYM";
1370 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1371 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1372 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1373 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1374 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1375 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1376 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1377 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1378 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1379 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1380 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1381 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1382 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1383 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1384 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1385 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1386 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1387 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1388 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1389 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1390 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1391 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1392 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1393 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1394 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1395 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1396 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1397 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1398 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1399 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1400 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1401 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1402 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1403 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1404 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1405 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1412 get_sparc64_dynamic_type (type)
1417 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1424 get_ppc64_dynamic_type (type)
1429 case DT_PPC64_GLINK: return "PPC64_GLINK";
1430 case DT_PPC64_OPD: return "PPC64_OPD";
1431 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1438 get_parisc_dynamic_type (type)
1443 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1444 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1445 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1446 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1447 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1448 case DT_HP_PREINIT: return "HP_PREINIT";
1449 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1450 case DT_HP_NEEDED: return "HP_NEEDED";
1451 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1452 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1453 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1454 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1455 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1462 get_dynamic_type (type)
1465 static char buff[32];
1469 case DT_NULL: return "NULL";
1470 case DT_NEEDED: return "NEEDED";
1471 case DT_PLTRELSZ: return "PLTRELSZ";
1472 case DT_PLTGOT: return "PLTGOT";
1473 case DT_HASH: return "HASH";
1474 case DT_STRTAB: return "STRTAB";
1475 case DT_SYMTAB: return "SYMTAB";
1476 case DT_RELA: return "RELA";
1477 case DT_RELASZ: return "RELASZ";
1478 case DT_RELAENT: return "RELAENT";
1479 case DT_STRSZ: return "STRSZ";
1480 case DT_SYMENT: return "SYMENT";
1481 case DT_INIT: return "INIT";
1482 case DT_FINI: return "FINI";
1483 case DT_SONAME: return "SONAME";
1484 case DT_RPATH: return "RPATH";
1485 case DT_SYMBOLIC: return "SYMBOLIC";
1486 case DT_REL: return "REL";
1487 case DT_RELSZ: return "RELSZ";
1488 case DT_RELENT: return "RELENT";
1489 case DT_PLTREL: return "PLTREL";
1490 case DT_DEBUG: return "DEBUG";
1491 case DT_TEXTREL: return "TEXTREL";
1492 case DT_JMPREL: return "JMPREL";
1493 case DT_BIND_NOW: return "BIND_NOW";
1494 case DT_INIT_ARRAY: return "INIT_ARRAY";
1495 case DT_FINI_ARRAY: return "FINI_ARRAY";
1496 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1497 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1498 case DT_RUNPATH: return "RUNPATH";
1499 case DT_FLAGS: return "FLAGS";
1501 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1502 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1504 case DT_CHECKSUM: return "CHECKSUM";
1505 case DT_PLTPADSZ: return "PLTPADSZ";
1506 case DT_MOVEENT: return "MOVEENT";
1507 case DT_MOVESZ: return "MOVESZ";
1508 case DT_FEATURE: return "FEATURE";
1509 case DT_POSFLAG_1: return "POSFLAG_1";
1510 case DT_SYMINSZ: return "SYMINSZ";
1511 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1513 case DT_ADDRRNGLO: return "ADDRRNGLO";
1514 case DT_CONFIG: return "CONFIG";
1515 case DT_DEPAUDIT: return "DEPAUDIT";
1516 case DT_AUDIT: return "AUDIT";
1517 case DT_PLTPAD: return "PLTPAD";
1518 case DT_MOVETAB: return "MOVETAB";
1519 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1521 case DT_VERSYM: return "VERSYM";
1523 case DT_RELACOUNT: return "RELACOUNT";
1524 case DT_RELCOUNT: return "RELCOUNT";
1525 case DT_FLAGS_1: return "FLAGS_1";
1526 case DT_VERDEF: return "VERDEF";
1527 case DT_VERDEFNUM: return "VERDEFNUM";
1528 case DT_VERNEED: return "VERNEED";
1529 case DT_VERNEEDNUM: return "VERNEEDNUM";
1531 case DT_AUXILIARY: return "AUXILIARY";
1532 case DT_USED: return "USED";
1533 case DT_FILTER: return "FILTER";
1535 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1536 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1537 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1538 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1539 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1542 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1546 switch (elf_header.e_machine)
1549 case EM_MIPS_RS3_LE:
1550 result = get_mips_dynamic_type (type);
1553 result = get_sparc64_dynamic_type (type);
1556 result = get_ppc64_dynamic_type (type);
1566 sprintf (buff, _("Processor Specific: %lx"), type);
1568 else if ((type >= DT_LOOS) && (type <= DT_HIOS))
1572 switch (elf_header.e_machine)
1575 result = get_parisc_dynamic_type (type);
1585 sprintf (buff, _("Operating System specific: %lx"), type);
1588 sprintf (buff, _("<unknown>: %lx"), type);
1595 get_file_type (e_type)
1598 static char buff[32];
1602 case ET_NONE: return _("NONE (None)");
1603 case ET_REL: return _("REL (Relocatable file)");
1604 case ET_EXEC: return _("EXEC (Executable file)");
1605 case ET_DYN: return _("DYN (Shared object file)");
1606 case ET_CORE: return _("CORE (Core file)");
1609 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1610 sprintf (buff, _("Processor Specific: (%x)"), e_type);
1611 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1612 sprintf (buff, _("OS Specific: (%x)"), e_type);
1614 sprintf (buff, _("<unknown>: %x"), e_type);
1620 get_machine_name (e_machine)
1623 static char buff[64]; /* XXX */
1627 case EM_NONE: return _("None");
1628 case EM_M32: return "WE32100";
1629 case EM_SPARC: return "Sparc";
1630 case EM_386: return "Intel 80386";
1631 case EM_68K: return "MC68000";
1632 case EM_88K: return "MC88000";
1633 case EM_486: return "Intel 80486";
1634 case EM_860: return "Intel 80860";
1635 case EM_MIPS: return "MIPS R3000";
1636 case EM_S370: return "IBM System/370";
1637 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1638 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1639 case EM_PARISC: return "HPPA";
1640 case EM_PPC_OLD: return "Power PC (old)";
1641 case EM_SPARC32PLUS: return "Sparc v8+" ;
1642 case EM_960: return "Intel 90860";
1643 case EM_PPC: return "PowerPC";
1644 case EM_PPC64: return "PowerPC64";
1645 case EM_V800: return "NEC V800";
1646 case EM_FR20: return "Fujitsu FR20";
1647 case EM_RH32: return "TRW RH32";
1648 case EM_MCORE: return "MCORE";
1649 case EM_ARM: return "ARM";
1650 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1651 case EM_SH: return "Hitachi SH";
1652 case EM_SPARCV9: return "Sparc v9";
1653 case EM_TRICORE: return "Siemens Tricore";
1654 case EM_ARC: return "ARC";
1655 case EM_H8_300: return "Hitachi H8/300";
1656 case EM_H8_300H: return "Hitachi H8/300H";
1657 case EM_H8S: return "Hitachi H8S";
1658 case EM_H8_500: return "Hitachi H8/500";
1659 case EM_IA_64: return "Intel IA-64";
1660 case EM_MIPS_X: return "Stanford MIPS-X";
1661 case EM_COLDFIRE: return "Motorola Coldfire";
1662 case EM_68HC12: return "Motorola M68HC12";
1663 case EM_ALPHA: return "Alpha";
1664 case EM_CYGNUS_D10V:
1665 case EM_D10V: return "d10v";
1666 case EM_CYGNUS_D30V:
1667 case EM_D30V: return "d30v";
1668 case EM_CYGNUS_M32R:
1669 case EM_M32R: return "Mitsubishi M32r";
1670 case EM_CYGNUS_V850:
1671 case EM_V850: return "NEC v850";
1672 case EM_CYGNUS_MN10300:
1673 case EM_MN10300: return "mn10300";
1674 case EM_CYGNUS_MN10200:
1675 case EM_MN10200: return "mn10200";
1676 case EM_CYGNUS_FR30:
1677 case EM_FR30: return "Fujitsu FR30";
1678 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1680 case EM_PJ: return "picoJava";
1681 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1682 case EM_PCP: return "Siemens PCP";
1683 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1684 case EM_NDR1: return "Denso NDR1 microprocesspr";
1685 case EM_STARCORE: return "Motorola Star*Core processor";
1686 case EM_ME16: return "Toyota ME16 processor";
1687 case EM_ST100: return "STMicroelectronics ST100 processor";
1688 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1689 case EM_FX66: return "Siemens FX66 microcontroller";
1690 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1691 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1692 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1693 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1694 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1695 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1696 case EM_SVX: return "Silicon Graphics SVx";
1697 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1698 case EM_VAX: return "Digital VAX";
1700 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1701 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1702 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1703 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1704 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1705 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1706 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1707 case EM_PRISM: return "SiTera Prism";
1708 case EM_X86_64: return "Advanced Micro Devices X86-64";
1710 case EM_S390: return "IBM S/390";
1711 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1713 case EM_OR32: return "OpenRISC";
1714 case EM_DLX: return "OpenDLX";
1716 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1718 sprintf (buff, _("<unknown>: %x"), e_machine);
1724 decode_ARM_machine_flags (e_flags, buf)
1731 eabi = EF_ARM_EABI_VERSION (e_flags);
1732 e_flags &= ~ EF_ARM_EABIMASK;
1734 /* Handle "generic" ARM flags. */
1735 if (e_flags & EF_ARM_RELEXEC)
1737 strcat (buf, ", relocatable executable");
1738 e_flags &= ~ EF_ARM_RELEXEC;
1741 if (e_flags & EF_ARM_HASENTRY)
1743 strcat (buf, ", has entry point");
1744 e_flags &= ~ EF_ARM_HASENTRY;
1747 /* Now handle EABI specific flags. */
1751 strcat (buf, ", <unrecognized EABI>");
1756 case EF_ARM_EABI_VER1:
1757 strcat (buf, ", Version1 EABI");
1762 /* Process flags one bit at a time. */
1763 flag = e_flags & - e_flags;
1768 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1769 strcat (buf, ", sorted symbol tables");
1779 case EF_ARM_EABI_VER2:
1780 strcat (buf, ", Version2 EABI");
1785 /* Process flags one bit at a time. */
1786 flag = e_flags & - e_flags;
1791 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1792 strcat (buf, ", sorted symbol tables");
1795 case EF_ARM_DYNSYMSUSESEGIDX:
1796 strcat (buf, ", dynamic symbols use segment index");
1799 case EF_ARM_MAPSYMSFIRST:
1800 strcat (buf, ", mapping symbols precede others");
1810 case EF_ARM_EABI_UNKNOWN:
1811 strcat (buf, ", GNU EABI");
1816 /* Process flags one bit at a time. */
1817 flag = e_flags & - e_flags;
1822 case EF_ARM_INTERWORK:
1823 strcat (buf, ", interworking enabled");
1826 case EF_ARM_APCS_26:
1827 strcat (buf, ", uses APCS/26");
1830 case EF_ARM_APCS_FLOAT:
1831 strcat (buf, ", uses APCS/float");
1835 strcat (buf, ", position independent");
1839 strcat (buf, ", 8 bit structure alignment");
1842 case EF_ARM_NEW_ABI:
1843 strcat (buf, ", uses new ABI");
1846 case EF_ARM_OLD_ABI:
1847 strcat (buf, ", uses old ABI");
1850 case EF_ARM_SOFT_FLOAT:
1851 strcat (buf, ", software FP");
1862 strcat (buf,", <unknown>");
1866 get_machine_flags (e_flags, e_machine)
1870 static char buf[1024];
1882 decode_ARM_machine_flags (e_flags, buf);
1886 if (e_flags & EF_CPU32)
1887 strcat (buf, ", cpu32");
1888 if (e_flags & EF_M68000)
1889 strcat (buf, ", m68000");
1893 if (e_flags & EF_PPC_EMB)
1894 strcat (buf, ", emb");
1896 if (e_flags & EF_PPC_RELOCATABLE)
1897 strcat (buf, ", relocatable");
1899 if (e_flags & EF_PPC_RELOCATABLE_LIB)
1900 strcat (buf, ", relocatable-lib");
1904 case EM_CYGNUS_V850:
1905 switch (e_flags & EF_V850_ARCH)
1908 strcat (buf, ", v850e");
1911 strcat (buf, ", v850");
1914 strcat (buf, ", unknown v850 architecture variant");
1920 case EM_CYGNUS_M32R:
1921 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
1922 strcat (buf, ", m32r");
1927 case EM_MIPS_RS3_LE:
1928 if (e_flags & EF_MIPS_NOREORDER)
1929 strcat (buf, ", noreorder");
1931 if (e_flags & EF_MIPS_PIC)
1932 strcat (buf, ", pic");
1934 if (e_flags & EF_MIPS_CPIC)
1935 strcat (buf, ", cpic");
1937 if (e_flags & EF_MIPS_UCODE)
1938 strcat (buf, ", ugen_reserved");
1940 if (e_flags & EF_MIPS_ABI2)
1941 strcat (buf, ", abi2");
1943 if (e_flags & EF_MIPS_OPTIONS_FIRST)
1944 strcat (buf, ", odk first");
1946 if (e_flags & EF_MIPS_32BITMODE)
1947 strcat (buf, ", 32bitmode");
1949 switch ((e_flags & EF_MIPS_MACH))
1951 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
1952 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
1953 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
1954 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
1955 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
1956 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
1957 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
1958 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
1959 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
1961 /* We simply ignore the field in this case to avoid confusion:
1962 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1965 default: strcat (buf, ", unknown CPU"); break;
1968 switch ((e_flags & EF_MIPS_ABI))
1970 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
1971 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
1972 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
1973 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
1975 /* We simply ignore the field in this case to avoid confusion:
1976 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1977 This means it is likely to be an o32 file, but not for
1980 default: strcat (buf, ", unknown ABI"); break;
1983 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
1984 strcat (buf, ", mdmx");
1986 if (e_flags & EF_MIPS_ARCH_ASE_M16)
1987 strcat (buf, ", mips16");
1989 switch ((e_flags & EF_MIPS_ARCH))
1991 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
1992 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
1993 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
1994 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
1995 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
1996 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
1997 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
1998 default: strcat (buf, ", unknown ISA"); break;
2004 if (e_flags & EF_SPARC_32PLUS)
2005 strcat (buf, ", v8+");
2007 if (e_flags & EF_SPARC_SUN_US1)
2008 strcat (buf, ", ultrasparcI");
2010 if (e_flags & EF_SPARC_SUN_US3)
2011 strcat (buf, ", ultrasparcIII");
2013 if (e_flags & EF_SPARC_HAL_R1)
2014 strcat (buf, ", halr1");
2016 if (e_flags & EF_SPARC_LEDATA)
2017 strcat (buf, ", ledata");
2019 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2020 strcat (buf, ", tso");
2022 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2023 strcat (buf, ", pso");
2025 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2026 strcat (buf, ", rmo");
2030 switch (e_flags & EF_PARISC_ARCH)
2032 case EFA_PARISC_1_0:
2033 strcpy (buf, ", PA-RISC 1.0");
2035 case EFA_PARISC_1_1:
2036 strcpy (buf, ", PA-RISC 1.1");
2038 case EFA_PARISC_2_0:
2039 strcpy (buf, ", PA-RISC 2.0");
2044 if (e_flags & EF_PARISC_TRAPNIL)
2045 strcat (buf, ", trapnil");
2046 if (e_flags & EF_PARISC_EXT)
2047 strcat (buf, ", ext");
2048 if (e_flags & EF_PARISC_LSB)
2049 strcat (buf, ", lsb");
2050 if (e_flags & EF_PARISC_WIDE)
2051 strcat (buf, ", wide");
2052 if (e_flags & EF_PARISC_NO_KABP)
2053 strcat (buf, ", no kabp");
2054 if (e_flags & EF_PARISC_LAZYSWAP)
2055 strcat (buf, ", lazyswap");
2060 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2061 strcat (buf, ", new calling convention");
2063 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2064 strcat (buf, ", gnu calling convention");
2068 if ((e_flags & EF_IA_64_ABI64))
2069 strcat (buf, ", 64-bit");
2071 strcat (buf, ", 32-bit");
2072 if ((e_flags & EF_IA_64_REDUCEDFP))
2073 strcat (buf, ", reduced fp model");
2074 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2075 strcat (buf, ", no function descriptors, constant gp");
2076 else if ((e_flags & EF_IA_64_CONS_GP))
2077 strcat (buf, ", constant gp");
2078 if ((e_flags & EF_IA_64_ABSOLUTE))
2079 strcat (buf, ", absolute");
2083 if ((e_flags & EF_VAX_NONPIC))
2084 strcat (buf, ", non-PIC");
2085 if ((e_flags & EF_VAX_DFLOAT))
2086 strcat (buf, ", D-Float");
2087 if ((e_flags & EF_VAX_GFLOAT))
2088 strcat (buf, ", G-Float");
2097 get_mips_segment_type (type)
2102 case PT_MIPS_REGINFO:
2104 case PT_MIPS_RTPROC:
2106 case PT_MIPS_OPTIONS:
2116 get_parisc_segment_type (type)
2121 case PT_HP_TLS: return "HP_TLS";
2122 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2123 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2124 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2125 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2126 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2127 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2128 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2129 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2130 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2131 case PT_HP_PARALLEL: return "HP_PARALLEL";
2132 case PT_HP_FASTBIND: return "HP_FASTBIND";
2133 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2134 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2143 get_ia64_segment_type (type)
2148 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2149 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2150 case PT_HP_TLS: return "HP_TLS";
2151 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2152 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2153 case PT_IA_64_HP_STACK: return "HP_STACK";
2162 get_segment_type (p_type)
2163 unsigned long p_type;
2165 static char buff[32];
2169 case PT_NULL: return "NULL";
2170 case PT_LOAD: return "LOAD";
2171 case PT_DYNAMIC: return "DYNAMIC";
2172 case PT_INTERP: return "INTERP";
2173 case PT_NOTE: return "NOTE";
2174 case PT_SHLIB: return "SHLIB";
2175 case PT_PHDR: return "PHDR";
2176 case PT_TLS: return "TLS";
2178 case PT_GNU_EH_FRAME:
2179 return "GNU_EH_FRAME";
2182 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2186 switch (elf_header.e_machine)
2189 case EM_MIPS_RS3_LE:
2190 result = get_mips_segment_type (p_type);
2193 result = get_parisc_segment_type (p_type);
2196 result = get_ia64_segment_type (p_type);
2206 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2208 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2212 switch (elf_header.e_machine)
2215 result = get_parisc_segment_type (p_type);
2218 result = get_ia64_segment_type (p_type);
2228 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2231 sprintf (buff, _("<unknown>: %lx"), p_type);
2238 get_mips_section_type_name (sh_type)
2239 unsigned int sh_type;
2243 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2244 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2245 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2246 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2247 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2248 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2249 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2250 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2251 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2252 case SHT_MIPS_RELD: return "MIPS_RELD";
2253 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2254 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2255 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2256 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2257 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2258 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2259 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2260 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2261 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2262 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2263 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2264 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2265 case SHT_MIPS_LINE: return "MIPS_LINE";
2266 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2267 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2268 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2269 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2270 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2271 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2272 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2273 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2274 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2275 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2276 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2277 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2278 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2279 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2280 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2281 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2289 get_parisc_section_type_name (sh_type)
2290 unsigned int sh_type;
2294 case SHT_PARISC_EXT: return "PARISC_EXT";
2295 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2296 case SHT_PARISC_DOC: return "PARISC_DOC";
2304 get_ia64_section_type_name (sh_type)
2305 unsigned int sh_type;
2309 case SHT_IA_64_EXT: return "IA_64_EXT";
2310 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2318 get_section_type_name (sh_type)
2319 unsigned int sh_type;
2321 static char buff[32];
2325 case SHT_NULL: return "NULL";
2326 case SHT_PROGBITS: return "PROGBITS";
2327 case SHT_SYMTAB: return "SYMTAB";
2328 case SHT_STRTAB: return "STRTAB";
2329 case SHT_RELA: return "RELA";
2330 case SHT_HASH: return "HASH";
2331 case SHT_DYNAMIC: return "DYNAMIC";
2332 case SHT_NOTE: return "NOTE";
2333 case SHT_NOBITS: return "NOBITS";
2334 case SHT_REL: return "REL";
2335 case SHT_SHLIB: return "SHLIB";
2336 case SHT_DYNSYM: return "DYNSYM";
2337 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2338 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2339 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2340 case SHT_GROUP: return "GROUP";
2341 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2342 case SHT_GNU_verdef: return "VERDEF";
2343 case SHT_GNU_verneed: return "VERNEED";
2344 case SHT_GNU_versym: return "VERSYM";
2345 case 0x6ffffff0: return "VERSYM";
2346 case 0x6ffffffc: return "VERDEF";
2347 case 0x7ffffffd: return "AUXILIARY";
2348 case 0x7fffffff: return "FILTER";
2349 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2352 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2356 switch (elf_header.e_machine)
2359 case EM_MIPS_RS3_LE:
2360 result = get_mips_section_type_name (sh_type);
2363 result = get_parisc_section_type_name (sh_type);
2366 result = get_ia64_section_type_name (sh_type);
2376 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2378 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2379 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2380 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2381 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2383 sprintf (buff, _("<unknown>: %x"), sh_type);
2389 #define OPTION_DEBUG_DUMP 512
2391 struct option options[] =
2393 {"all", no_argument, 0, 'a'},
2394 {"file-header", no_argument, 0, 'h'},
2395 {"program-headers", no_argument, 0, 'l'},
2396 {"headers", no_argument, 0, 'e'},
2397 {"histogram", no_argument, 0, 'I'},
2398 {"segments", no_argument, 0, 'l'},
2399 {"sections", no_argument, 0, 'S'},
2400 {"section-headers", no_argument, 0, 'S'},
2401 {"symbols", no_argument, 0, 's'},
2402 {"syms", no_argument, 0, 's'},
2403 {"relocs", no_argument, 0, 'r'},
2404 {"notes", no_argument, 0, 'n'},
2405 {"dynamic", no_argument, 0, 'd'},
2406 {"arch-specific", no_argument, 0, 'A'},
2407 {"version-info", no_argument, 0, 'V'},
2408 {"use-dynamic", no_argument, 0, 'D'},
2409 {"hex-dump", required_argument, 0, 'x'},
2410 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2411 {"unwind", no_argument, 0, 'u'},
2412 #ifdef SUPPORT_DISASSEMBLY
2413 {"instruction-dump", required_argument, 0, 'i'},
2416 {"version", no_argument, 0, 'v'},
2417 {"wide", no_argument, 0, 'W'},
2418 {"help", no_argument, 0, 'H'},
2419 {0, no_argument, 0, 0}
2425 fprintf (stdout, _("Usage: readelf <option(s)> elf-file(s)\n"));
2426 fprintf (stdout, _(" Display information about the contents of ELF format files\n"));
2427 fprintf (stdout, _(" Options are:\n\
2428 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2429 -h --file-header Display the ELF file header\n\
2430 -l --program-headers Display the program headers\n\
2431 --segments An alias for --program-headers\n\
2432 -S --section-headers Display the sections' header\n\
2433 --sections An alias for --section-headers\n\
2434 -e --headers Equivalent to: -h -l -S\n\
2435 -s --syms Display the symbol table\n\
2436 --symbols An alias for --syms\n\
2437 -n --notes Display the core notes (if present)\n\
2438 -r --relocs Display the relocations (if present)\n\
2439 -u --unwind Display the unwind info (if present)\n\
2440 -d --dynamic Display the dynamic segment (if present)\n\
2441 -V --version-info Display the version sections (if present)\n\
2442 -A --arch-specific Display architecture specific information (if any).\n\
2443 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2444 -x --hex-dump=<number> Dump the contents of section <number>\n\
2445 -w[liaprmfFso] or\n\
2446 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2447 Display the contents of DWARF2 debug sections\n"));
2448 #ifdef SUPPORT_DISASSEMBLY
2449 fprintf (stdout, _("\
2450 -i --instruction-dump=<number>\n\
2451 Disassemble the contents of section <number>\n"));
2453 fprintf (stdout, _("\
2454 -I --histogram Display histogram of bucket list lengths\n\
2455 -W --wide Allow output width to exceed 80 characters\n\
2456 -H --help Display this information\n\
2457 -v --version Display the version number of readelf\n"));
2458 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2464 request_dump (section, type)
2465 unsigned int section;
2468 if (section >= num_dump_sects)
2470 char *new_dump_sects;
2472 new_dump_sects = (char *) calloc (section + 1, 1);
2474 if (new_dump_sects == NULL)
2475 error (_("Out of memory allocating dump request table."));
2478 /* Copy current flag settings. */
2479 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2483 dump_sects = new_dump_sects;
2484 num_dump_sects = section + 1;
2489 dump_sects[section] |= type;
2495 parse_args (argc, argv)
2504 while ((c = getopt_long
2505 (argc, argv, "ersuahnldSDAIw::x:i:vVW", options, NULL)) != EOF)
2572 section = strtoul (optarg, & cp, 0);
2573 if (! *cp && section >= 0)
2575 request_dump (section, HEX_DUMP);
2585 unsigned int index = 0;
2589 while (optarg[index])
2590 switch (optarg[index++])
2599 do_debug_abbrevs = 1;
2609 do_debug_pubnames = 1;
2614 do_debug_aranges = 1;
2618 do_debug_frames_interp = 1;
2620 do_debug_frames = 1;
2625 do_debug_macinfo = 1;
2639 warn (_("Unrecognized debug option '%s'\n"), optarg);
2644 case OPTION_DEBUG_DUMP:
2650 static const char *debug_dump_opt[]
2651 = { "line", "info", "abbrev", "pubnames", "ranges",
2652 "macro", "frames", "frames-interp", "str", "loc", NULL };
2661 for (index = 0; debug_dump_opt[index]; index++)
2663 size_t len = strlen (debug_dump_opt[index]);
2665 if (strncmp (p, debug_dump_opt[index], len) == 0
2666 && (p[len] == ',' || p[len] == '\0'))
2675 do_debug_abbrevs = 1;
2686 do_debug_pubnames = 1;
2690 do_debug_aranges = 1;
2695 do_debug_frames_interp = 1;
2696 do_debug_frames = 1;
2700 do_debug_macinfo = 1;
2713 if (debug_dump_opt[index] == NULL)
2715 warn (_("Unrecognized debug option '%s'\n"), p);
2716 p = strchr (p, ',');
2726 #ifdef SUPPORT_DISASSEMBLY
2729 section = strtoul (optarg, & cp, 0);
2730 if (! *cp && section >= 0)
2732 request_dump (section, DISASS_DUMP);
2738 print_version (program_name);
2748 /* xgettext:c-format */
2749 error (_("Invalid option '-%c'\n"), c);
2756 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
2757 && !do_segments && !do_header && !do_dump && !do_version
2758 && !do_histogram && !do_debugging && !do_arch && !do_notes)
2762 warn (_("Nothing to do.\n"));
2768 get_elf_class (elf_class)
2769 unsigned int elf_class;
2771 static char buff[32];
2775 case ELFCLASSNONE: return _("none");
2776 case ELFCLASS32: return "ELF32";
2777 case ELFCLASS64: return "ELF64";
2779 sprintf (buff, _("<unknown: %x>"), elf_class);
2785 get_data_encoding (encoding)
2786 unsigned int encoding;
2788 static char buff[32];
2792 case ELFDATANONE: return _("none");
2793 case ELFDATA2LSB: return _("2's complement, little endian");
2794 case ELFDATA2MSB: return _("2's complement, big endian");
2796 sprintf (buff, _("<unknown: %x>"), encoding);
2802 get_osabi_name (osabi)
2805 static char buff[32];
2809 case ELFOSABI_NONE: return "UNIX - System V";
2810 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2811 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2812 case ELFOSABI_LINUX: return "UNIX - Linux";
2813 case ELFOSABI_HURD: return "GNU/Hurd";
2814 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2815 case ELFOSABI_AIX: return "UNIX - AIX";
2816 case ELFOSABI_IRIX: return "UNIX - IRIX";
2817 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2818 case ELFOSABI_TRU64: return "UNIX - TRU64";
2819 case ELFOSABI_MODESTO: return "Novell - Modesto";
2820 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2821 case ELFOSABI_STANDALONE: return _("Standalone App");
2822 case ELFOSABI_ARM: return "ARM";
2824 sprintf (buff, _("<unknown: %x>"), osabi);
2829 /* Decode the data held in 'elf_header'. */
2831 process_file_header ()
2833 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
2834 || elf_header.e_ident[EI_MAG1] != ELFMAG1
2835 || elf_header.e_ident[EI_MAG2] != ELFMAG2
2836 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
2839 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2847 printf (_("ELF Header:\n"));
2848 printf (_(" Magic: "));
2849 for (i = 0; i < EI_NIDENT; i++)
2850 printf ("%2.2x ", elf_header.e_ident[i]);
2852 printf (_(" Class: %s\n"),
2853 get_elf_class (elf_header.e_ident[EI_CLASS]));
2854 printf (_(" Data: %s\n"),
2855 get_data_encoding (elf_header.e_ident[EI_DATA]));
2856 printf (_(" Version: %d %s\n"),
2857 elf_header.e_ident[EI_VERSION],
2858 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
2860 : (elf_header.e_ident[EI_VERSION] != EV_NONE
2863 printf (_(" OS/ABI: %s\n"),
2864 get_osabi_name (elf_header.e_ident[EI_OSABI]));
2865 printf (_(" ABI Version: %d\n"),
2866 elf_header.e_ident[EI_ABIVERSION]);
2867 printf (_(" Type: %s\n"),
2868 get_file_type (elf_header.e_type));
2869 printf (_(" Machine: %s\n"),
2870 get_machine_name (elf_header.e_machine));
2871 printf (_(" Version: 0x%lx\n"),
2872 (unsigned long) elf_header.e_version);
2874 printf (_(" Entry point address: "));
2875 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
2876 printf (_("\n Start of program headers: "));
2877 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
2878 printf (_(" (bytes into file)\n Start of section headers: "));
2879 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
2880 printf (_(" (bytes into file)\n"));
2882 printf (_(" Flags: 0x%lx%s\n"),
2883 (unsigned long) elf_header.e_flags,
2884 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
2885 printf (_(" Size of this header: %ld (bytes)\n"),
2886 (long) elf_header.e_ehsize);
2887 printf (_(" Size of program headers: %ld (bytes)\n"),
2888 (long) elf_header.e_phentsize);
2889 printf (_(" Number of program headers: %ld\n"),
2890 (long) elf_header.e_phnum);
2891 printf (_(" Size of section headers: %ld (bytes)\n"),
2892 (long) elf_header.e_shentsize);
2893 printf (_(" Number of section headers: %ld"),
2894 (long) elf_header.e_shnum);
2895 if (section_headers != NULL && elf_header.e_shnum == 0)
2896 printf (" (%ld)", (long) section_headers[0].sh_size);
2897 putc ('\n', stdout);
2898 printf (_(" Section header string table index: %ld"),
2899 (long) elf_header.e_shstrndx);
2900 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
2901 printf (" (%ld)", (long) section_headers[0].sh_link);
2902 putc ('\n', stdout);
2905 if (section_headers != NULL)
2907 if (elf_header.e_shnum == 0)
2908 elf_header.e_shnum = section_headers[0].sh_size;
2909 if (elf_header.e_shstrndx == SHN_XINDEX)
2910 elf_header.e_shstrndx = section_headers[0].sh_link;
2911 free (section_headers);
2912 section_headers = NULL;
2920 get_32bit_program_headers (file, program_headers)
2922 Elf_Internal_Phdr *program_headers;
2924 Elf32_External_Phdr *phdrs;
2925 Elf32_External_Phdr *external;
2926 Elf_Internal_Phdr *internal;
2929 phdrs = ((Elf32_External_Phdr *)
2930 get_data (NULL, file, elf_header.e_phoff,
2931 elf_header.e_phentsize * elf_header.e_phnum,
2932 _("program headers")));
2936 for (i = 0, internal = program_headers, external = phdrs;
2937 i < elf_header.e_phnum;
2938 i++, internal++, external++)
2940 internal->p_type = BYTE_GET (external->p_type);
2941 internal->p_offset = BYTE_GET (external->p_offset);
2942 internal->p_vaddr = BYTE_GET (external->p_vaddr);
2943 internal->p_paddr = BYTE_GET (external->p_paddr);
2944 internal->p_filesz = BYTE_GET (external->p_filesz);
2945 internal->p_memsz = BYTE_GET (external->p_memsz);
2946 internal->p_flags = BYTE_GET (external->p_flags);
2947 internal->p_align = BYTE_GET (external->p_align);
2956 get_64bit_program_headers (file, program_headers)
2958 Elf_Internal_Phdr *program_headers;
2960 Elf64_External_Phdr *phdrs;
2961 Elf64_External_Phdr *external;
2962 Elf_Internal_Phdr *internal;
2965 phdrs = ((Elf64_External_Phdr *)
2966 get_data (NULL, file, elf_header.e_phoff,
2967 elf_header.e_phentsize * elf_header.e_phnum,
2968 _("program headers")));
2972 for (i = 0, internal = program_headers, external = phdrs;
2973 i < elf_header.e_phnum;
2974 i++, internal++, external++)
2976 internal->p_type = BYTE_GET (external->p_type);
2977 internal->p_flags = BYTE_GET (external->p_flags);
2978 internal->p_offset = BYTE_GET8 (external->p_offset);
2979 internal->p_vaddr = BYTE_GET8 (external->p_vaddr);
2980 internal->p_paddr = BYTE_GET8 (external->p_paddr);
2981 internal->p_filesz = BYTE_GET8 (external->p_filesz);
2982 internal->p_memsz = BYTE_GET8 (external->p_memsz);
2983 internal->p_align = BYTE_GET8 (external->p_align);
2991 /* Returns 1 if the program headers were loaded. */
2994 process_program_headers (file)
2997 Elf_Internal_Phdr *program_headers;
2998 Elf_Internal_Phdr *segment;
3001 if (elf_header.e_phnum == 0)
3004 printf (_("\nThere are no program headers in this file.\n"));
3008 if (do_segments && !do_header)
3010 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3011 printf (_("Entry point "));
3012 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3013 printf (_("\nThere are %d program headers, starting at offset "),
3014 elf_header.e_phnum);
3015 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3019 program_headers = (Elf_Internal_Phdr *) malloc
3020 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
3022 if (program_headers == NULL)
3024 error (_("Out of memory\n"));
3029 i = get_32bit_program_headers (file, program_headers);
3031 i = get_64bit_program_headers (file, program_headers);
3035 free (program_headers);
3041 if (elf_header.e_phnum > 1)
3042 printf (_("\nProgram Headers:\n"));
3044 printf (_("\nProgram Headers:\n"));
3048 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3051 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3055 (_(" Type Offset VirtAddr PhysAddr\n"));
3057 (_(" FileSiz MemSiz Flags Align\n"));
3065 for (i = 0, segment = program_headers;
3066 i < elf_header.e_phnum;
3071 printf (" %-14.14s ", get_segment_type (segment->p_type));
3075 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3076 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3077 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3078 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3079 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3081 (segment->p_flags & PF_R ? 'R' : ' '),
3082 (segment->p_flags & PF_W ? 'W' : ' '),
3083 (segment->p_flags & PF_X ? 'E' : ' '));
3084 printf ("%#lx", (unsigned long) segment->p_align);
3088 if ((unsigned long) segment->p_offset == segment->p_offset)
3089 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3092 print_vma (segment->p_offset, FULL_HEX);
3096 print_vma (segment->p_vaddr, FULL_HEX);
3098 print_vma (segment->p_paddr, FULL_HEX);
3101 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3102 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3105 print_vma (segment->p_filesz, FULL_HEX);
3109 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3110 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3113 print_vma (segment->p_offset, FULL_HEX);
3117 (segment->p_flags & PF_R ? 'R' : ' '),
3118 (segment->p_flags & PF_W ? 'W' : ' '),
3119 (segment->p_flags & PF_X ? 'E' : ' '));
3121 if ((unsigned long) segment->p_align == segment->p_align)
3122 printf ("%#lx", (unsigned long) segment->p_align);
3125 print_vma (segment->p_align, PREFIX_HEX);
3130 print_vma (segment->p_offset, FULL_HEX);
3132 print_vma (segment->p_vaddr, FULL_HEX);
3134 print_vma (segment->p_paddr, FULL_HEX);
3136 print_vma (segment->p_filesz, FULL_HEX);
3138 print_vma (segment->p_memsz, FULL_HEX);
3140 (segment->p_flags & PF_R ? 'R' : ' '),
3141 (segment->p_flags & PF_W ? 'W' : ' '),
3142 (segment->p_flags & PF_X ? 'E' : ' '));
3143 print_vma (segment->p_align, HEX);
3147 switch (segment->p_type)
3152 unsigned long align_mask = -segment->p_align;
3154 if (align_mask == 0)
3156 loadaddr = ((segment->p_vaddr & align_mask)
3157 - (segment->p_offset & align_mask));
3163 error (_("more than one dynamic segment\n"));
3165 dynamic_addr = segment->p_offset;
3166 dynamic_size = segment->p_filesz;
3170 if (fseek (file, (long) segment->p_offset, SEEK_SET))
3171 error (_("Unable to find program interpreter name\n"));
3174 program_interpreter[0] = 0;
3175 fscanf (file, "%63s", program_interpreter);
3178 printf (_("\n [Requesting program interpreter: %s]"),
3179 program_interpreter);
3185 putc ('\n', stdout);
3194 if (do_segments && section_headers != NULL)
3196 printf (_("\n Section to Segment mapping:\n"));
3197 printf (_(" Segment Sections...\n"));
3199 assert (string_table != NULL);
3201 for (i = 0; i < elf_header.e_phnum; i++)
3204 Elf_Internal_Shdr *section;
3206 segment = program_headers + i;
3207 section = section_headers;
3209 printf (" %2.2d ", i);
3211 for (j = 1; j < elf_header.e_shnum; j++, section++)
3213 if (section->sh_size > 0
3214 /* Compare allocated sections by VMA, unallocated
3215 sections by file offset. */
3216 && (section->sh_flags & SHF_ALLOC
3217 ? (section->sh_addr >= segment->p_vaddr
3218 && section->sh_addr + section->sh_size
3219 <= segment->p_vaddr + segment->p_memsz)
3220 : ((bfd_vma) section->sh_offset >= segment->p_offset
3221 && (section->sh_offset + section->sh_size
3222 <= segment->p_offset + segment->p_filesz))))
3223 printf ("%s ", SECTION_NAME (section));
3230 free (program_headers);
3237 get_32bit_section_headers (file, num)
3241 Elf32_External_Shdr *shdrs;
3242 Elf_Internal_Shdr *internal;
3245 shdrs = ((Elf32_External_Shdr *)
3246 get_data (NULL, file, elf_header.e_shoff,
3247 elf_header.e_shentsize * num,
3248 _("section headers")));
3252 section_headers = ((Elf_Internal_Shdr *)
3253 malloc (num * sizeof (Elf_Internal_Shdr)));
3255 if (section_headers == NULL)
3257 error (_("Out of memory\n"));
3261 for (i = 0, internal = section_headers;
3265 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3266 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3267 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3268 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3269 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3270 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3271 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3272 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3273 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3274 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3283 get_64bit_section_headers (file, num)
3287 Elf64_External_Shdr *shdrs;
3288 Elf_Internal_Shdr *internal;
3291 shdrs = ((Elf64_External_Shdr *)
3292 get_data (NULL, file, elf_header.e_shoff,
3293 elf_header.e_shentsize * num,
3294 _("section headers")));
3298 section_headers = ((Elf_Internal_Shdr *)
3299 malloc (num * sizeof (Elf_Internal_Shdr)));
3301 if (section_headers == NULL)
3303 error (_("Out of memory\n"));
3307 for (i = 0, internal = section_headers;
3311 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3312 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3313 internal->sh_flags = BYTE_GET8 (shdrs[i].sh_flags);
3314 internal->sh_addr = BYTE_GET8 (shdrs[i].sh_addr);
3315 internal->sh_size = BYTE_GET8 (shdrs[i].sh_size);
3316 internal->sh_entsize = BYTE_GET8 (shdrs[i].sh_entsize);
3317 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3318 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3319 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3320 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3328 static Elf_Internal_Sym *
3329 get_32bit_elf_symbols (file, section)
3331 Elf_Internal_Shdr *section;
3333 unsigned long number;
3334 Elf32_External_Sym *esyms;
3335 Elf_External_Sym_Shndx *shndx;
3336 Elf_Internal_Sym *isyms;
3337 Elf_Internal_Sym *psym;
3340 esyms = ((Elf32_External_Sym *)
3341 get_data (NULL, file, section->sh_offset,
3342 section->sh_size, _("symbols")));
3347 if (symtab_shndx_hdr != NULL
3348 && (symtab_shndx_hdr->sh_link
3349 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3351 shndx = ((Elf_External_Sym_Shndx *)
3352 get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3353 symtab_shndx_hdr->sh_size, _("symtab shndx")));
3361 number = section->sh_size / section->sh_entsize;
3362 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3366 error (_("Out of memory\n"));
3373 for (j = 0, psym = isyms;
3377 psym->st_name = BYTE_GET (esyms[j].st_name);
3378 psym->st_value = BYTE_GET (esyms[j].st_value);
3379 psym->st_size = BYTE_GET (esyms[j].st_size);
3380 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3381 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3383 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3384 psym->st_info = BYTE_GET (esyms[j].st_info);
3385 psym->st_other = BYTE_GET (esyms[j].st_other);
3395 static Elf_Internal_Sym *
3396 get_64bit_elf_symbols (file, section)
3398 Elf_Internal_Shdr *section;
3400 unsigned long number;
3401 Elf64_External_Sym *esyms;
3402 Elf_External_Sym_Shndx *shndx;
3403 Elf_Internal_Sym *isyms;
3404 Elf_Internal_Sym *psym;
3407 esyms = ((Elf64_External_Sym *)
3408 get_data (NULL, file, section->sh_offset,
3409 section->sh_size, _("symbols")));
3414 if (symtab_shndx_hdr != NULL
3415 && (symtab_shndx_hdr->sh_link
3416 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3418 shndx = ((Elf_External_Sym_Shndx *)
3419 get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3420 symtab_shndx_hdr->sh_size, _("symtab shndx")));
3428 number = section->sh_size / section->sh_entsize;
3429 isyms = (Elf_Internal_Sym *) malloc (number * sizeof (Elf_Internal_Sym));
3433 error (_("Out of memory\n"));
3440 for (j = 0, psym = isyms;
3444 psym->st_name = BYTE_GET (esyms[j].st_name);
3445 psym->st_info = BYTE_GET (esyms[j].st_info);
3446 psym->st_other = BYTE_GET (esyms[j].st_other);
3447 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3448 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3450 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3451 psym->st_value = BYTE_GET8 (esyms[j].st_value);
3452 psym->st_size = BYTE_GET8 (esyms[j].st_size);
3463 get_elf_section_flags (sh_flags)
3466 static char buff[32];
3474 flag = sh_flags & - sh_flags;
3479 case SHF_WRITE: strcat (buff, "W"); break;
3480 case SHF_ALLOC: strcat (buff, "A"); break;
3481 case SHF_EXECINSTR: strcat (buff, "X"); break;
3482 case SHF_MERGE: strcat (buff, "M"); break;
3483 case SHF_STRINGS: strcat (buff, "S"); break;
3484 case SHF_INFO_LINK: strcat (buff, "I"); break;
3485 case SHF_LINK_ORDER: strcat (buff, "L"); break;
3486 case SHF_OS_NONCONFORMING: strcat (buff, "O"); break;
3487 case SHF_GROUP: strcat (buff, "G"); break;
3488 case SHF_TLS: strcat (buff, "T"); break;
3491 if (flag & SHF_MASKOS)
3494 sh_flags &= ~ SHF_MASKOS;
3496 else if (flag & SHF_MASKPROC)
3499 sh_flags &= ~ SHF_MASKPROC;
3511 process_section_headers (file)
3514 Elf_Internal_Shdr *section;
3517 section_headers = NULL;
3519 if (elf_header.e_shnum == 0)
3522 printf (_("\nThere are no sections in this file.\n"));
3527 if (do_sections && !do_header)
3528 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3529 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
3533 if (! get_32bit_section_headers (file, elf_header.e_shnum))
3536 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
3539 /* Read in the string table, so that we have names to display. */
3540 section = SECTION_HEADER (elf_header.e_shstrndx);
3542 if (section->sh_size != 0)
3544 string_table = (char *) get_data (NULL, file, section->sh_offset,
3545 section->sh_size, _("string table"));
3547 string_table_length = section->sh_size;
3550 /* Scan the sections for the dynamic symbol table
3551 and dynamic string table and debug sections. */
3552 dynamic_symbols = NULL;
3553 dynamic_strings = NULL;
3554 dynamic_syminfo = NULL;
3555 symtab_shndx_hdr = NULL;
3557 for (i = 0, section = section_headers;
3558 i < elf_header.e_shnum;
3561 char *name = SECTION_NAME (section);
3563 if (section->sh_type == SHT_DYNSYM)
3565 if (dynamic_symbols != NULL)
3567 error (_("File contains multiple dynamic symbol tables\n"));
3571 num_dynamic_syms = section->sh_size / section->sh_entsize;
3572 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
3574 else if (section->sh_type == SHT_STRTAB
3575 && strcmp (name, ".dynstr") == 0)
3577 if (dynamic_strings != NULL)
3579 error (_("File contains multiple dynamic string tables\n"));
3583 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
3585 _("dynamic strings"));
3587 else if (section->sh_type == SHT_SYMTAB_SHNDX)
3589 if (symtab_shndx_hdr != NULL)
3591 error (_("File contains multiple symtab shndx tables\n"));
3594 symtab_shndx_hdr = section;
3596 else if ((do_debugging || do_debug_info || do_debug_abbrevs
3597 || do_debug_lines || do_debug_pubnames || do_debug_aranges
3598 || do_debug_frames || do_debug_macinfo || do_debug_str
3600 && strncmp (name, ".debug_", 7) == 0)
3605 || (do_debug_info && (strcmp (name, "info") == 0))
3606 || (do_debug_abbrevs && (strcmp (name, "abbrev") == 0))
3607 || (do_debug_lines && (strcmp (name, "line") == 0))
3608 || (do_debug_pubnames && (strcmp (name, "pubnames") == 0))
3609 || (do_debug_aranges && (strcmp (name, "aranges") == 0))
3610 || (do_debug_frames && (strcmp (name, "frame") == 0))
3611 || (do_debug_macinfo && (strcmp (name, "macinfo") == 0))
3612 || (do_debug_str && (strcmp (name, "str") == 0))
3613 || (do_debug_loc && (strcmp (name, "loc") == 0))
3615 request_dump (i, DEBUG_DUMP);
3617 /* linkonce section to be combined with .debug_info at link time. */
3618 else if ((do_debugging || do_debug_info)
3619 && strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
3620 request_dump (i, DEBUG_DUMP);
3621 else if (do_debug_frames && strcmp (name, ".eh_frame") == 0)
3622 request_dump (i, DEBUG_DUMP);
3628 if (elf_header.e_shnum > 1)
3629 printf (_("\nSection Headers:\n"));
3631 printf (_("\nSection Header:\n"));
3635 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3638 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3641 printf (_(" [Nr] Name Type Address Offset\n"));
3642 printf (_(" Size EntSize Flags Link Info Align\n"));
3645 for (i = 0, section = section_headers;
3646 i < elf_header.e_shnum;
3649 printf (" [%2u] %-17.17s %-15.15s ",
3650 SECTION_HEADER_NUM (i),
3651 SECTION_NAME (section),
3652 get_section_type_name (section->sh_type));
3656 print_vma (section->sh_addr, LONG_HEX);
3658 printf ( " %6.6lx %6.6lx %2.2lx",
3659 (unsigned long) section->sh_offset,
3660 (unsigned long) section->sh_size,
3661 (unsigned long) section->sh_entsize);
3663 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3665 printf ("%2ld %3lx %2ld\n",
3666 (unsigned long) section->sh_link,
3667 (unsigned long) section->sh_info,
3668 (unsigned long) section->sh_addralign);
3672 print_vma (section->sh_addr, LONG_HEX);
3674 if ((long) section->sh_offset == section->sh_offset)
3675 printf (" %6.6lx", (unsigned long) section->sh_offset);
3679 print_vma (section->sh_offset, LONG_HEX);
3682 if ((unsigned long) section->sh_size == section->sh_size)
3683 printf (" %6.6lx", (unsigned long) section->sh_size);
3687 print_vma (section->sh_size, LONG_HEX);
3690 if ((unsigned long) section->sh_entsize == section->sh_entsize)
3691 printf (" %2.2lx", (unsigned long) section->sh_entsize);
3695 print_vma (section->sh_entsize, LONG_HEX);
3698 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3700 printf ("%2ld %3lx ",
3701 (unsigned long) section->sh_link,
3702 (unsigned long) section->sh_info);
3704 if ((unsigned long) section->sh_addralign == section->sh_addralign)
3705 printf ("%2ld\n", (unsigned long) section->sh_addralign);
3708 print_vma (section->sh_addralign, DEC);
3715 print_vma (section->sh_addr, LONG_HEX);
3716 if ((long) section->sh_offset == section->sh_offset)
3717 printf (" %8.8lx", (unsigned long) section->sh_offset);
3721 print_vma (section->sh_offset, LONG_HEX);
3724 print_vma (section->sh_size, LONG_HEX);
3726 print_vma (section->sh_entsize, LONG_HEX);
3728 printf (" %3s ", get_elf_section_flags (section->sh_flags));
3730 printf (" %2ld %3lx %ld\n",
3731 (unsigned long) section->sh_link,
3732 (unsigned long) section->sh_info,
3733 (unsigned long) section->sh_addralign);
3737 printf (_("Key to Flags:\n\
3738 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3739 I (info), L (link order), G (group), x (unknown)\n\
3740 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3745 /* Process the reloc section. */
3747 process_relocs (file)
3750 unsigned long rel_size;
3751 unsigned long rel_offset;
3757 if (do_using_dynamic)
3759 int is_rela = FALSE;
3764 if (dynamic_info[DT_REL])
3766 rel_offset = dynamic_info[DT_REL];
3767 rel_size = dynamic_info[DT_RELSZ];
3770 else if (dynamic_info[DT_RELA])
3772 rel_offset = dynamic_info[DT_RELA];
3773 rel_size = dynamic_info[DT_RELASZ];
3776 else if (dynamic_info[DT_JMPREL])
3778 rel_offset = dynamic_info[DT_JMPREL];
3779 rel_size = dynamic_info[DT_PLTRELSZ];
3781 switch (dynamic_info[DT_PLTREL])
3798 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3799 rel_offset, rel_size);
3801 dump_relocations (file, rel_offset - loadaddr, rel_size,
3802 dynamic_symbols, num_dynamic_syms, dynamic_strings,
3806 printf (_("\nThere are no dynamic relocations in this file.\n"));
3810 Elf_Internal_Shdr *section;
3814 for (i = 0, section = section_headers;
3815 i < elf_header.e_shnum;
3818 if ( section->sh_type != SHT_RELA
3819 && section->sh_type != SHT_REL)
3822 rel_offset = section->sh_offset;
3823 rel_size = section->sh_size;
3827 Elf_Internal_Shdr *strsec;
3828 Elf_Internal_Sym *symtab;
3831 unsigned long nsyms;
3833 printf (_("\nRelocation section "));
3835 if (string_table == NULL)
3836 printf ("%d", section->sh_name);
3838 printf (_("'%s'"), SECTION_NAME (section));
3840 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3841 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
3846 if (section->sh_link)
3848 Elf_Internal_Shdr *symsec;
3850 symsec = SECTION_HEADER (section->sh_link);
3851 nsyms = symsec->sh_size / symsec->sh_entsize;
3852 symtab = GET_ELF_SYMBOLS (file, symsec);
3857 strsec = SECTION_HEADER (symsec->sh_link);
3859 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
3863 is_rela = section->sh_type == SHT_RELA;
3865 dump_relocations (file, rel_offset, rel_size,
3866 symtab, nsyms, strtab, is_rela);
3878 printf (_("\nThere are no relocations in this file.\n"));
3884 #include "unwind-ia64.h"
3886 /* An absolute address consists of a section and an offset. If the
3887 section is NULL, the offset itself is the address, otherwise, the
3888 address equals to LOAD_ADDRESS(section) + offset. */
3892 unsigned short section;
3898 struct unw_table_entry
3900 struct absaddr start;
3902 struct absaddr info;
3904 *table; /* Unwind table. */
3905 unsigned long table_len; /* Length of unwind table. */
3906 unsigned char *info; /* Unwind info. */
3907 unsigned long info_size; /* Size of unwind info. */
3908 bfd_vma info_addr; /* starting address of unwind info. */
3909 bfd_vma seg_base; /* Starting address of segment. */
3910 Elf_Internal_Sym *symtab; /* The symbol table. */
3911 unsigned long nsyms; /* Number of symbols. */
3912 char *strtab; /* The string table. */
3913 unsigned long strtab_size; /* Size of string table. */
3916 static void find_symbol_for_address
3917 PARAMS ((struct unw_aux_info *, struct absaddr, const char **, bfd_vma *));
3918 static void dump_ia64_unwind
3919 PARAMS ((struct unw_aux_info *));
3920 static int slurp_ia64_unwind_table
3921 PARAMS ((FILE *, struct unw_aux_info *, Elf_Internal_Shdr *));
3924 find_symbol_for_address (aux, addr, symname, offset)
3925 struct unw_aux_info *aux;
3926 struct absaddr addr;
3927 const char **symname;
3930 bfd_vma dist = (bfd_vma) 0x100000;
3931 Elf_Internal_Sym *sym, *best = NULL;
3934 for (i = 0, sym = aux->symtab; i < aux->nsyms; ++i, ++sym)
3936 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
3937 && sym->st_name != 0
3938 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
3939 && addr.offset >= sym->st_value
3940 && addr.offset - sym->st_value < dist)
3943 dist = addr.offset - sym->st_value;
3950 *symname = (best->st_name >= aux->strtab_size
3951 ? "<corrupt>" : aux->strtab + best->st_name);
3956 *offset = addr.offset;
3960 dump_ia64_unwind (aux)
3961 struct unw_aux_info *aux;
3964 struct unw_table_entry *tp;
3967 addr_size = is_32bit_elf ? 4 : 8;
3969 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
3973 const unsigned char *dp;
3974 const unsigned char *head;
3975 const char *procname;
3977 find_symbol_for_address (aux, tp->start, &procname, &offset);
3979 fputs ("\n<", stdout);
3983 fputs (procname, stdout);
3986 printf ("+%lx", (unsigned long) offset);
3989 fputs (">: [", stdout);
3990 print_vma (tp->start.offset, PREFIX_HEX);
3991 fputc ('-', stdout);
3992 print_vma (tp->end.offset, PREFIX_HEX);
3993 printf ("], info at +0x%lx\n",
3994 (unsigned long) (tp->info.offset - aux->seg_base));
3996 head = aux->info + (tp->info.offset - aux->info_addr);
3997 stamp = BYTE_GET8 ((unsigned char *) head);
3999 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4000 (unsigned) UNW_VER (stamp),
4001 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4002 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4003 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4004 (unsigned long) (addr_size * UNW_LENGTH (stamp)));
4006 if (UNW_VER (stamp) != 1)
4008 printf ("\tUnknown version.\n");
4013 for (dp = head + 8; dp < head + 8 + addr_size * UNW_LENGTH (stamp);)
4014 dp = unw_decode (dp, in_body, & in_body);
4019 slurp_ia64_unwind_table (file, aux, sec)
4021 struct unw_aux_info *aux;
4022 Elf_Internal_Shdr *sec;
4024 unsigned long size, addr_size, nrelas, i;
4025 Elf_Internal_Phdr *prog_hdrs, *seg;
4026 struct unw_table_entry *tep;
4027 Elf_Internal_Shdr *relsec;
4028 Elf_Internal_Rela *rela, *rp;
4029 unsigned char *table, *tp;
4030 Elf_Internal_Sym *sym;
4031 const char *relname;
4034 addr_size = is_32bit_elf ? 4 : 8;
4036 /* First, find the starting address of the segment that includes
4039 if (elf_header.e_phnum)
4041 prog_hdrs = (Elf_Internal_Phdr *)
4042 xmalloc (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
4045 result = get_32bit_program_headers (file, prog_hdrs);
4047 result = get_64bit_program_headers (file, prog_hdrs);
4055 for (seg = prog_hdrs; seg < prog_hdrs + elf_header.e_phnum; ++seg)
4057 if (seg->p_type != PT_LOAD)
4060 if (sec->sh_addr >= seg->p_vaddr
4061 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4063 aux->seg_base = seg->p_vaddr;
4071 /* Second, build the unwind table from the contents of the unwind section: */
4072 size = sec->sh_size;
4073 table = (char *) get_data (NULL, file, sec->sh_offset,
4074 size, _("unwind table"));
4078 tep = aux->table = xmalloc (size / (3 * addr_size) * sizeof (aux->table[0]));
4079 for (tp = table; tp < table + size; tp += 3 * addr_size, ++tep)
4081 tep->start.section = SHN_UNDEF;
4082 tep->end.section = SHN_UNDEF;
4083 tep->info.section = SHN_UNDEF;
4086 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
4087 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
4088 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
4092 tep->start.offset = BYTE_GET8 ((unsigned char *) tp + 0);
4093 tep->end.offset = BYTE_GET8 ((unsigned char *) tp + 8);
4094 tep->info.offset = BYTE_GET8 ((unsigned char *) tp + 16);
4096 tep->start.offset += aux->seg_base;
4097 tep->end.offset += aux->seg_base;
4098 tep->info.offset += aux->seg_base;
4102 /* Third, apply any relocations to the unwind table: */
4104 for (relsec = section_headers;
4105 relsec < section_headers + elf_header.e_shnum;
4108 if (relsec->sh_type != SHT_RELA
4109 || SECTION_HEADER (relsec->sh_info) != sec)
4112 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
4116 for (rp = rela; rp < rela + nrelas; ++rp)
4120 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
4121 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
4123 if (ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
4125 warn (_("Skipping unexpected symbol type %u\n"),
4126 ELF32_ST_TYPE (sym->st_info));
4132 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
4133 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
4135 if (ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
4137 warn (_("Skipping unexpected symbol type %u\n"),
4138 ELF64_ST_TYPE (sym->st_info));
4143 if (strncmp (relname, "R_IA64_SEGREL", 13) != 0)
4145 warn (_("Skipping unexpected relocation type %s\n"), relname);
4149 i = rp->r_offset / (3 * addr_size);
4151 switch (rp->r_offset/addr_size % 3)
4154 aux->table[i].start.section = sym->st_shndx;
4155 aux->table[i].start.offset += rp->r_addend;
4158 aux->table[i].end.section = sym->st_shndx;
4159 aux->table[i].end.offset += rp->r_addend;
4162 aux->table[i].info.section = sym->st_shndx;
4163 aux->table[i].info.offset += rp->r_addend;
4173 aux->table_len = size / (3 * addr_size);
4178 process_unwind (file)
4181 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
4182 unsigned long i, addr_size, unwcount = 0, unwstart = 0;
4183 struct unw_aux_info aux;
4188 if (elf_header.e_machine != EM_IA_64)
4190 printf (_("\nThere are no unwind sections in this file.\n"));
4194 memset (& aux, 0, sizeof (aux));
4196 addr_size = is_32bit_elf ? 4 : 8;
4198 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
4200 if (sec->sh_type == SHT_SYMTAB)
4202 aux.nsyms = sec->sh_size / sec->sh_entsize;
4203 aux.symtab = GET_ELF_SYMBOLS (file, sec);
4205 strsec = SECTION_HEADER (sec->sh_link);
4206 aux.strtab_size = strsec->sh_size;
4207 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
4208 aux.strtab_size, _("string table"));
4210 else if (sec->sh_type == SHT_IA_64_UNWIND)
4215 printf (_("\nThere are no unwind sections in this file.\n"));
4217 while (unwcount-- > 0)
4222 for (i = unwstart, sec = section_headers + unwstart;
4223 i < elf_header.e_shnum; ++i, ++sec)
4224 if (sec->sh_type == SHT_IA_64_UNWIND)
4231 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
4233 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once,
4236 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4237 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
4238 suffix = SECTION_NAME (unwsec) + len;
4239 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4241 if (strncmp (SECTION_NAME (sec),
4242 ELF_STRING_ia64_unwind_info_once, len2) == 0
4243 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4248 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4249 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4250 len = sizeof (ELF_STRING_ia64_unwind) - 1;
4251 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
4253 if (strncmp (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind,
4255 suffix = SECTION_NAME (unwsec) + len;
4256 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
4258 if (strncmp (SECTION_NAME (sec),
4259 ELF_STRING_ia64_unwind_info, len2) == 0
4260 && strcmp (SECTION_NAME (sec) + len2, suffix) == 0)
4264 if (i == elf_header.e_shnum)
4266 printf (_("\nCould not find unwind info section for "));
4268 if (string_table == NULL)
4269 printf ("%d", unwsec->sh_name);
4271 printf (_("'%s'"), SECTION_NAME (unwsec));
4275 aux.info_size = sec->sh_size;
4276 aux.info_addr = sec->sh_addr;
4277 aux.info = (char *) get_data (NULL, file, sec->sh_offset,
4278 aux.info_size, _("unwind info"));
4280 printf (_("\nUnwind section "));
4282 if (string_table == NULL)
4283 printf ("%d", unwsec->sh_name);
4285 printf (_("'%s'"), SECTION_NAME (unwsec));
4287 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4288 (unsigned long) unwsec->sh_offset,
4289 (unsigned long) (unwsec->sh_size / (3 * addr_size)));
4291 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
4293 if (aux.table_len > 0)
4294 dump_ia64_unwind (& aux);
4297 free ((char *) aux.table);
4299 free ((char *) aux.info);
4308 free ((char *) aux.strtab);
4314 dynamic_segment_mips_val (entry)
4315 Elf_Internal_Dyn *entry;
4317 switch (entry->d_tag)
4320 if (entry->d_un.d_val == 0)
4324 static const char * opts[] =
4326 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4327 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4328 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4329 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4334 for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
4335 if (entry->d_un.d_val & (1 << cnt))
4337 printf ("%s%s", first ? "" : " ", opts[cnt]);
4344 case DT_MIPS_IVERSION:
4345 if (dynamic_strings != NULL)
4346 printf ("Interface Version: %s\n",
4347 dynamic_strings + entry->d_un.d_val);
4349 printf ("%ld\n", (long) entry->d_un.d_ptr);
4352 case DT_MIPS_TIME_STAMP:
4357 time_t time = entry->d_un.d_val;
4358 tmp = gmtime (&time);
4359 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
4360 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
4361 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
4362 printf ("Time Stamp: %s\n", timebuf);
4366 case DT_MIPS_RLD_VERSION:
4367 case DT_MIPS_LOCAL_GOTNO:
4368 case DT_MIPS_CONFLICTNO:
4369 case DT_MIPS_LIBLISTNO:
4370 case DT_MIPS_SYMTABNO:
4371 case DT_MIPS_UNREFEXTNO:
4372 case DT_MIPS_HIPAGENO:
4373 case DT_MIPS_DELTA_CLASS_NO:
4374 case DT_MIPS_DELTA_INSTANCE_NO:
4375 case DT_MIPS_DELTA_RELOC_NO:
4376 case DT_MIPS_DELTA_SYM_NO:
4377 case DT_MIPS_DELTA_CLASSSYM_NO:
4378 case DT_MIPS_COMPACT_SIZE:
4379 printf ("%ld\n", (long) entry->d_un.d_ptr);
4383 printf ("%#lx\n", (long) entry->d_un.d_ptr);
4389 dynamic_segment_parisc_val (entry)
4390 Elf_Internal_Dyn *entry;
4392 switch (entry->d_tag)
4394 case DT_HP_DLD_FLAGS:
4403 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
4404 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
4405 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
4406 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
4407 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
4408 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
4409 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
4410 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
4411 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
4412 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
4413 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" }
4417 bfd_vma val = entry->d_un.d_val;
4419 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
4420 if (val & flags[cnt].bit)
4424 fputs (flags[cnt].str, stdout);
4426 val ^= flags[cnt].bit;
4429 if (val != 0 || first)
4433 print_vma (val, HEX);
4439 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
4446 get_32bit_dynamic_segment (file)
4449 Elf32_External_Dyn *edyn;
4450 Elf_Internal_Dyn *entry;
4453 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr,
4454 dynamic_size, _("dynamic segment"));
4458 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4459 how large this .dynamic is now. We can do this even before the byte
4460 swapping since the DT_NULL tag is recognizable. */
4462 while (*(Elf32_Word *) edyn[dynamic_size++].d_tag != DT_NULL)
4465 dynamic_segment = (Elf_Internal_Dyn *)
4466 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4468 if (dynamic_segment == NULL)
4470 error (_("Out of memory\n"));
4475 for (i = 0, entry = dynamic_segment;
4479 entry->d_tag = BYTE_GET (edyn[i].d_tag);
4480 entry->d_un.d_val = BYTE_GET (edyn[i].d_un.d_val);
4489 get_64bit_dynamic_segment (file)
4492 Elf64_External_Dyn *edyn;
4493 Elf_Internal_Dyn *entry;
4496 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr,
4497 dynamic_size, _("dynamic segment"));
4501 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4502 how large this .dynamic is now. We can do this even before the byte
4503 swapping since the DT_NULL tag is recognizable. */
4505 while (*(bfd_vma *) edyn[dynamic_size++].d_tag != DT_NULL)
4508 dynamic_segment = (Elf_Internal_Dyn *)
4509 malloc (dynamic_size * sizeof (Elf_Internal_Dyn));
4511 if (dynamic_segment == NULL)
4513 error (_("Out of memory\n"));
4518 for (i = 0, entry = dynamic_segment;
4522 entry->d_tag = BYTE_GET8 (edyn[i].d_tag);
4523 entry->d_un.d_val = BYTE_GET8 (edyn[i].d_un.d_val);
4532 get_dynamic_flags (flags)
4535 static char buff[128];
4543 flag = flags & - flags;
4551 case DF_ORIGIN: strcpy (p, "ORIGIN"); break;
4552 case DF_SYMBOLIC: strcpy (p, "SYMBOLIC"); break;
4553 case DF_TEXTREL: strcpy (p, "TEXTREL"); break;
4554 case DF_BIND_NOW: strcpy (p, "BIND_NOW"); break;
4555 case DF_STATIC_TLS: strcpy (p, "STATIC_TLS"); break;
4556 default: strcpy (p, "unknown"); break;
4559 p = strchr (p, '\0');
4564 /* Parse and display the contents of the dynamic segment. */
4566 process_dynamic_segment (file)
4569 Elf_Internal_Dyn *entry;
4572 if (dynamic_size == 0)
4575 printf (_("\nThere is no dynamic segment in this file.\n"));
4582 if (! get_32bit_dynamic_segment (file))
4585 else if (! get_64bit_dynamic_segment (file))
4588 /* Find the appropriate symbol table. */
4589 if (dynamic_symbols == NULL)
4591 for (i = 0, entry = dynamic_segment;
4595 Elf_Internal_Shdr section;
4597 if (entry->d_tag != DT_SYMTAB)
4600 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
4602 /* Since we do not know how big the symbol table is,
4603 we default to reading in the entire file (!) and
4604 processing that. This is overkill, I know, but it
4606 section.sh_offset = entry->d_un.d_val - loadaddr;
4608 if (fseek (file, 0, SEEK_END))
4609 error (_("Unable to seek to end of file!"));
4611 section.sh_size = ftell (file) - section.sh_offset;
4613 section.sh_entsize = sizeof (Elf32_External_Sym);
4615 section.sh_entsize = sizeof (Elf64_External_Sym);
4617 num_dynamic_syms = section.sh_size / section.sh_entsize;
4618 if (num_dynamic_syms < 1)
4620 error (_("Unable to determine the number of symbols to load\n"));
4624 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
4628 /* Similarly find a string table. */
4629 if (dynamic_strings == NULL)
4631 for (i = 0, entry = dynamic_segment;
4635 unsigned long offset;
4638 if (entry->d_tag != DT_STRTAB)
4641 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
4643 /* Since we do not know how big the string table is,
4644 we default to reading in the entire file (!) and
4645 processing that. This is overkill, I know, but it
4648 offset = entry->d_un.d_val - loadaddr;
4649 if (fseek (file, 0, SEEK_END))
4650 error (_("Unable to seek to end of file\n"));
4651 str_tab_len = ftell (file) - offset;
4653 if (str_tab_len < 1)
4656 (_("Unable to determine the length of the dynamic string table\n"));
4660 dynamic_strings = (char *) get_data (NULL, file, offset, str_tab_len,
4661 _("dynamic string table"));
4666 /* And find the syminfo section if available. */
4667 if (dynamic_syminfo == NULL)
4669 unsigned long syminsz = 0;
4671 for (i = 0, entry = dynamic_segment;
4675 if (entry->d_tag == DT_SYMINENT)
4677 /* Note: these braces are necessary to avoid a syntax
4678 error from the SunOS4 C compiler. */
4679 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
4681 else if (entry->d_tag == DT_SYMINSZ)
4682 syminsz = entry->d_un.d_val;
4683 else if (entry->d_tag == DT_SYMINFO)
4684 dynamic_syminfo_offset = entry->d_un.d_val - loadaddr;
4687 if (dynamic_syminfo_offset != 0 && syminsz != 0)
4689 Elf_External_Syminfo *extsyminfo;
4690 Elf_Internal_Syminfo *syminfo;
4692 /* There is a syminfo section. Read the data. */
4693 extsyminfo = ((Elf_External_Syminfo *)
4694 get_data (NULL, file, dynamic_syminfo_offset,
4695 syminsz, _("symbol information")));
4699 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
4700 if (dynamic_syminfo == NULL)
4702 error (_("Out of memory\n"));
4706 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
4707 for (i = 0, syminfo = dynamic_syminfo; i < dynamic_syminfo_nent;
4710 syminfo->si_boundto = BYTE_GET (extsyminfo[i].si_boundto);
4711 syminfo->si_flags = BYTE_GET (extsyminfo[i].si_flags);
4718 if (do_dynamic && dynamic_addr)
4719 printf (_("\nDynamic segment at offset 0x%lx contains %ld entries:\n"),
4720 dynamic_addr, (long) dynamic_size);
4722 printf (_(" Tag Type Name/Value\n"));
4724 for (i = 0, entry = dynamic_segment;
4733 print_vma (entry->d_tag, FULL_HEX);
4734 dtype = get_dynamic_type (entry->d_tag);
4735 printf (" (%s)%*s", dtype,
4736 ((is_32bit_elf ? 27 : 19)
4737 - (int) strlen (dtype)),
4741 switch (entry->d_tag)
4745 puts (get_dynamic_flags (entry->d_un.d_val));
4755 switch (entry->d_tag)
4758 printf (_("Auxiliary library"));
4762 printf (_("Filter library"));
4766 printf (_("Configuration file"));
4770 printf (_("Dependency audit library"));
4774 printf (_("Audit library"));
4778 if (dynamic_strings)
4779 printf (": [%s]\n", dynamic_strings + entry->d_un.d_val);
4783 print_vma (entry->d_un.d_val, PREFIX_HEX);
4792 printf (_("Flags:"));
4794 if (entry->d_un.d_val == 0)
4795 printf (_(" None\n"));
4798 unsigned long int val = entry->d_un.d_val;
4800 if (val & DTF_1_PARINIT)
4802 printf (" PARINIT");
4803 val ^= DTF_1_PARINIT;
4805 if (val & DTF_1_CONFEXP)
4807 printf (" CONFEXP");
4808 val ^= DTF_1_CONFEXP;
4811 printf (" %lx", val);
4820 printf (_("Flags:"));
4822 if (entry->d_un.d_val == 0)
4823 printf (_(" None\n"));
4826 unsigned long int val = entry->d_un.d_val;
4828 if (val & DF_P1_LAZYLOAD)
4830 printf (" LAZYLOAD");
4831 val ^= DF_P1_LAZYLOAD;
4833 if (val & DF_P1_GROUPPERM)
4835 printf (" GROUPPERM");
4836 val ^= DF_P1_GROUPPERM;
4839 printf (" %lx", val);
4848 printf (_("Flags:"));
4849 if (entry->d_un.d_val == 0)
4850 printf (_(" None\n"));
4853 unsigned long int val = entry->d_un.d_val;
4860 if (val & DF_1_GLOBAL)
4865 if (val & DF_1_GROUP)
4870 if (val & DF_1_NODELETE)
4872 printf (" NODELETE");
4873 val ^= DF_1_NODELETE;
4875 if (val & DF_1_LOADFLTR)
4877 printf (" LOADFLTR");
4878 val ^= DF_1_LOADFLTR;
4880 if (val & DF_1_INITFIRST)
4882 printf (" INITFIRST");
4883 val ^= DF_1_INITFIRST;
4885 if (val & DF_1_NOOPEN)
4890 if (val & DF_1_ORIGIN)
4895 if (val & DF_1_DIRECT)
4900 if (val & DF_1_TRANS)
4905 if (val & DF_1_INTERPOSE)
4907 printf (" INTERPOSE");
4908 val ^= DF_1_INTERPOSE;
4910 if (val & DF_1_NODEFLIB)
4912 printf (" NODEFLIB");
4913 val ^= DF_1_NODEFLIB;
4915 if (val & DF_1_NODUMP)
4920 if (val & DF_1_CONLFAT)
4922 printf (" CONLFAT");
4923 val ^= DF_1_CONLFAT;
4926 printf (" %lx", val);
4934 puts (get_dynamic_type (entry->d_un.d_val));
4954 dynamic_info[entry->d_tag] = entry->d_un.d_val;
4960 if (dynamic_strings == NULL)
4963 name = dynamic_strings + entry->d_un.d_val;
4967 switch (entry->d_tag)
4970 printf (_("Shared library: [%s]"), name);
4972 if (strcmp (name, program_interpreter) == 0)
4973 printf (_(" program interpreter"));
4977 printf (_("Library soname: [%s]"), name);
4981 printf (_("Library rpath: [%s]"), name);
4985 printf (_("Library runpath: [%s]"), name);
4989 print_vma (entry->d_un.d_val, PREFIX_HEX);
4994 print_vma (entry->d_un.d_val, PREFIX_HEX);
5010 case DT_INIT_ARRAYSZ:
5011 case DT_FINI_ARRAYSZ:
5012 case DT_GNU_CONFLICTSZ:
5013 case DT_GNU_LIBLISTSZ:
5016 print_vma (entry->d_un.d_val, UNSIGNED);
5017 printf (" (bytes)\n");
5027 print_vma (entry->d_un.d_val, UNSIGNED);
5040 if (dynamic_strings != NULL && entry->d_tag == DT_USED)
5044 name = dynamic_strings + entry->d_un.d_val;
5048 printf (_("Not needed object: [%s]\n"), name);
5053 print_vma (entry->d_un.d_val, PREFIX_HEX);
5059 /* The value of this entry is ignored. */
5064 case DT_GNU_PRELINKED:
5068 time_t time = entry->d_un.d_val;
5070 tmp = gmtime (&time);
5071 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5072 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5073 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5079 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
5080 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
5085 switch (elf_header.e_machine)
5088 case EM_MIPS_RS3_LE:
5089 dynamic_segment_mips_val (entry);
5092 dynamic_segment_parisc_val (entry);
5095 print_vma (entry->d_un.d_val, PREFIX_HEX);
5107 get_ver_flags (flags)
5110 static char buff[32];
5117 if (flags & VER_FLG_BASE)
5118 strcat (buff, "BASE ");
5120 if (flags & VER_FLG_WEAK)
5122 if (flags & VER_FLG_BASE)
5123 strcat (buff, "| ");
5125 strcat (buff, "WEAK ");
5128 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
5129 strcat (buff, "| <unknown>");
5134 /* Display the contents of the version sections. */
5136 process_version_sections (file)
5139 Elf_Internal_Shdr *section;
5146 for (i = 0, section = section_headers;
5147 i < elf_header.e_shnum;
5150 switch (section->sh_type)
5152 case SHT_GNU_verdef:
5154 Elf_External_Verdef *edefs;
5161 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5162 SECTION_NAME (section), section->sh_info);
5164 printf (_(" Addr: 0x"));
5165 printf_vma (section->sh_addr);
5166 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5167 (unsigned long) section->sh_offset, section->sh_link,
5168 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5170 edefs = ((Elf_External_Verdef *)
5171 get_data (NULL, file, section->sh_offset,
5173 _("version definition section")));
5177 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5180 Elf_External_Verdef *edef;
5181 Elf_Internal_Verdef ent;
5182 Elf_External_Verdaux *eaux;
5183 Elf_Internal_Verdaux aux;
5187 vstart = ((char *) edefs) + idx;
5189 edef = (Elf_External_Verdef *) vstart;
5191 ent.vd_version = BYTE_GET (edef->vd_version);
5192 ent.vd_flags = BYTE_GET (edef->vd_flags);
5193 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
5194 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
5195 ent.vd_hash = BYTE_GET (edef->vd_hash);
5196 ent.vd_aux = BYTE_GET (edef->vd_aux);
5197 ent.vd_next = BYTE_GET (edef->vd_next);
5199 printf (_(" %#06x: Rev: %d Flags: %s"),
5200 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
5202 printf (_(" Index: %d Cnt: %d "),
5203 ent.vd_ndx, ent.vd_cnt);
5205 vstart += ent.vd_aux;
5207 eaux = (Elf_External_Verdaux *) vstart;
5209 aux.vda_name = BYTE_GET (eaux->vda_name);
5210 aux.vda_next = BYTE_GET (eaux->vda_next);
5212 if (dynamic_strings)
5213 printf (_("Name: %s\n"), dynamic_strings + aux.vda_name);
5215 printf (_("Name index: %ld\n"), aux.vda_name);
5217 isum = idx + ent.vd_aux;
5219 for (j = 1; j < ent.vd_cnt; j++)
5221 isum += aux.vda_next;
5222 vstart += aux.vda_next;
5224 eaux = (Elf_External_Verdaux *) vstart;
5226 aux.vda_name = BYTE_GET (eaux->vda_name);
5227 aux.vda_next = BYTE_GET (eaux->vda_next);
5229 if (dynamic_strings)
5230 printf (_(" %#06x: Parent %d: %s\n"),
5231 isum, j, dynamic_strings + aux.vda_name);
5233 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5234 isum, j, aux.vda_name);
5244 case SHT_GNU_verneed:
5246 Elf_External_Verneed *eneed;
5252 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5253 SECTION_NAME (section), section->sh_info);
5255 printf (_(" Addr: 0x"));
5256 printf_vma (section->sh_addr);
5257 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5258 (unsigned long) section->sh_offset, section->sh_link,
5259 SECTION_NAME (SECTION_HEADER (section->sh_link)));
5261 eneed = ((Elf_External_Verneed *)
5262 get_data (NULL, file, section->sh_offset,
5263 section->sh_size, _("version need section")));
5267 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
5269 Elf_External_Verneed *entry;
5270 Elf_Internal_Verneed ent;
5275 vstart = ((char *) eneed) + idx;
5277 entry = (Elf_External_Verneed *) vstart;
5279 ent.vn_version = BYTE_GET (entry->vn_version);
5280 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
5281 ent.vn_file = BYTE_GET (entry->vn_file);
5282 ent.vn_aux = BYTE_GET (entry->vn_aux);
5283 ent.vn_next = BYTE_GET (entry->vn_next);
5285 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
5287 if (dynamic_strings)
5288 printf (_(" File: %s"), dynamic_strings + ent.vn_file);
5290 printf (_(" File: %lx"), ent.vn_file);
5292 printf (_(" Cnt: %d\n"), ent.vn_cnt);
5294 vstart += ent.vn_aux;
5296 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
5298 Elf_External_Vernaux *eaux;
5299 Elf_Internal_Vernaux aux;
5301 eaux = (Elf_External_Vernaux *) vstart;
5303 aux.vna_hash = BYTE_GET (eaux->vna_hash);
5304 aux.vna_flags = BYTE_GET (eaux->vna_flags);
5305 aux.vna_other = BYTE_GET (eaux->vna_other);
5306 aux.vna_name = BYTE_GET (eaux->vna_name);
5307 aux.vna_next = BYTE_GET (eaux->vna_next);
5309 if (dynamic_strings)
5310 printf (_(" %#06x: Name: %s"),
5311 isum, dynamic_strings + aux.vna_name);
5313 printf (_(" %#06x: Name index: %lx"),
5314 isum, aux.vna_name);
5316 printf (_(" Flags: %s Version: %d\n"),
5317 get_ver_flags (aux.vna_flags), aux.vna_other);
5319 isum += aux.vna_next;
5320 vstart += aux.vna_next;
5330 case SHT_GNU_versym:
5332 Elf_Internal_Shdr *link_section;
5335 unsigned char *edata;
5336 unsigned short *data;
5338 Elf_Internal_Sym *symbols;
5339 Elf_Internal_Shdr *string_sec;
5341 link_section = SECTION_HEADER (section->sh_link);
5342 total = section->sh_size / section->sh_entsize;
5346 symbols = GET_ELF_SYMBOLS (file, link_section);
5348 string_sec = SECTION_HEADER (link_section->sh_link);
5350 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5351 string_sec->sh_size,
5352 _("version string table"));
5356 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5357 SECTION_NAME (section), total);
5359 printf (_(" Addr: "));
5360 printf_vma (section->sh_addr);
5361 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5362 (unsigned long) section->sh_offset, section->sh_link,
5363 SECTION_NAME (link_section));
5367 get_data (NULL, file,
5368 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] - loadaddr,
5369 total * sizeof (short), _("version symbol data")));
5376 data = (unsigned short *) malloc (total * sizeof (short));
5378 for (cnt = total; cnt --;)
5379 data[cnt] = byte_get (edata + cnt * sizeof (short),
5384 for (cnt = 0; cnt < total; cnt += 4)
5387 int check_def, check_need;
5390 printf (" %03x:", cnt);
5392 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
5393 switch (data[cnt + j])
5396 fputs (_(" 0 (*local*) "), stdout);
5400 fputs (_(" 1 (*global*) "), stdout);
5404 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
5405 data[cnt + j] & 0x8000 ? 'h' : ' ');
5409 if (SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
5412 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
5419 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
5421 Elf_Internal_Verneed ivn;
5422 unsigned long offset;
5424 offset = version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
5429 Elf_Internal_Vernaux ivna;
5430 Elf_External_Verneed evn;
5431 Elf_External_Vernaux evna;
5432 unsigned long a_off;
5434 get_data (&evn, file, offset, sizeof (evn),
5437 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5438 ivn.vn_next = BYTE_GET (evn.vn_next);
5440 a_off = offset + ivn.vn_aux;
5444 get_data (&evna, file, a_off, sizeof (evna),
5445 _("version need aux (2)"));
5447 ivna.vna_next = BYTE_GET (evna.vna_next);
5448 ivna.vna_other = BYTE_GET (evna.vna_other);
5450 a_off += ivna.vna_next;
5452 while (ivna.vna_other != data[cnt + j]
5453 && ivna.vna_next != 0);
5455 if (ivna.vna_other == data[cnt + j])
5457 ivna.vna_name = BYTE_GET (evna.vna_name);
5459 name = strtab + ivna.vna_name;
5460 nn += printf ("(%s%-*s",
5462 12 - (int) strlen (name),
5468 offset += ivn.vn_next;
5470 while (ivn.vn_next);
5473 if (check_def && data[cnt + j] != 0x8001
5474 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
5476 Elf_Internal_Verdef ivd;
5477 Elf_External_Verdef evd;
5478 unsigned long offset;
5480 offset = (version_info[DT_VERSIONTAGIDX (DT_VERDEF)]
5485 get_data (&evd, file, offset, sizeof (evd),
5488 ivd.vd_next = BYTE_GET (evd.vd_next);
5489 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5491 offset += ivd.vd_next;
5493 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
5494 && ivd.vd_next != 0);
5496 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
5498 Elf_External_Verdaux evda;
5499 Elf_Internal_Verdaux ivda;
5501 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5503 get_data (&evda, file,
5504 offset - ivd.vd_next + ivd.vd_aux,
5505 sizeof (evda), _("version def aux"));
5507 ivda.vda_name = BYTE_GET (evda.vda_name);
5509 name = strtab + ivda.vda_name;
5510 nn += printf ("(%s%-*s",
5512 12 - (int) strlen (name),
5518 printf ("%*c", 18 - nn, ' ');
5536 printf (_("\nNo version information found in this file.\n"));
5542 get_symbol_binding (binding)
5543 unsigned int binding;
5545 static char buff[32];
5549 case STB_LOCAL: return "LOCAL";
5550 case STB_GLOBAL: return "GLOBAL";
5551 case STB_WEAK: return "WEAK";
5553 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
5554 sprintf (buff, _("<processor specific>: %d"), binding);
5555 else if (binding >= STB_LOOS && binding <= STB_HIOS)
5556 sprintf (buff, _("<OS specific>: %d"), binding);
5558 sprintf (buff, _("<unknown>: %d"), binding);
5564 get_symbol_type (type)
5567 static char buff[32];
5571 case STT_NOTYPE: return "NOTYPE";
5572 case STT_OBJECT: return "OBJECT";
5573 case STT_FUNC: return "FUNC";
5574 case STT_SECTION: return "SECTION";
5575 case STT_FILE: return "FILE";
5576 case STT_COMMON: return "COMMON";
5577 case STT_TLS: return "TLS";
5579 if (type >= STT_LOPROC && type <= STT_HIPROC)
5581 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
5582 return "THUMB_FUNC";
5584 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
5587 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
5588 return "PARISC_MILLI";
5590 sprintf (buff, _("<processor specific>: %d"), type);
5592 else if (type >= STT_LOOS && type <= STT_HIOS)
5594 if (elf_header.e_machine == EM_PARISC)
5596 if (type == STT_HP_OPAQUE)
5598 if (type == STT_HP_STUB)
5602 sprintf (buff, _("<OS specific>: %d"), type);
5605 sprintf (buff, _("<unknown>: %d"), type);
5611 get_symbol_visibility (visibility)
5612 unsigned int visibility;
5616 case STV_DEFAULT: return "DEFAULT";
5617 case STV_INTERNAL: return "INTERNAL";
5618 case STV_HIDDEN: return "HIDDEN";
5619 case STV_PROTECTED: return "PROTECTED";
5625 get_symbol_index_type (type)
5628 static char buff[32];
5632 case SHN_UNDEF: return "UND";
5633 case SHN_ABS: return "ABS";
5634 case SHN_COMMON: return "COM";
5636 if (type >= SHN_LOPROC && type <= SHN_HIPROC)
5637 sprintf (buff, "PRC[0x%04x]", type);
5638 else if (type >= SHN_LOOS && type <= SHN_HIOS)
5639 sprintf (buff, "OS [0x%04x]", type);
5640 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
5641 sprintf (buff, "RSV[0x%04x]", type);
5643 sprintf (buff, "%3d", type);
5651 get_dynamic_data (file, number)
5653 unsigned int number;
5655 unsigned char *e_data;
5658 e_data = (unsigned char *) malloc (number * 4);
5662 error (_("Out of memory\n"));
5666 if (fread (e_data, 4, number, file) != number)
5668 error (_("Unable to read in dynamic data\n"));
5672 i_data = (int *) malloc (number * sizeof (*i_data));
5676 error (_("Out of memory\n"));
5682 i_data[number] = byte_get (e_data + number * 4, 4);
5689 /* Dump the symbol table. */
5691 process_symbol_table (file)
5694 Elf_Internal_Shdr *section;
5695 unsigned char nb[4];
5696 unsigned char nc[4];
5699 int *buckets = NULL;
5702 if (! do_syms && !do_histogram)
5705 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
5708 if (fseek (file, dynamic_info[DT_HASH] - loadaddr, SEEK_SET))
5710 error (_("Unable to seek to start of dynamic information"));
5714 if (fread (nb, sizeof (nb), 1, file) != 1)
5716 error (_("Failed to read in number of buckets\n"));
5720 if (fread (nc, sizeof (nc), 1, file) != 1)
5722 error (_("Failed to read in number of chains\n"));
5726 nbuckets = byte_get (nb, 4);
5727 nchains = byte_get (nc, 4);
5729 buckets = get_dynamic_data (file, nbuckets);
5730 chains = get_dynamic_data (file, nchains);
5732 if (buckets == NULL || chains == NULL)
5737 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
5742 printf (_("\nSymbol table for image:\n"));
5744 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5746 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5748 for (hn = 0; hn < nbuckets; hn++)
5753 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
5755 Elf_Internal_Sym *psym;
5757 psym = dynamic_symbols + si;
5759 printf (" %3d %3d: ", si, hn);
5760 print_vma (psym->st_value, LONG_HEX);
5762 print_vma (psym->st_size, DEC_5);
5764 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5765 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5766 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5767 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
5768 print_symbol (25, dynamic_strings + psym->st_name);
5773 else if (do_syms && !do_using_dynamic)
5777 for (i = 0, section = section_headers;
5778 i < elf_header.e_shnum;
5783 Elf_Internal_Sym *symtab;
5784 Elf_Internal_Sym *psym;
5787 if ( section->sh_type != SHT_SYMTAB
5788 && section->sh_type != SHT_DYNSYM)
5791 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5792 SECTION_NAME (section),
5793 (unsigned long) (section->sh_size / section->sh_entsize));
5795 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5797 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5799 symtab = GET_ELF_SYMBOLS (file, section);
5803 if (section->sh_link == elf_header.e_shstrndx)
5804 strtab = string_table;
5807 Elf_Internal_Shdr *string_sec;
5809 string_sec = SECTION_HEADER (section->sh_link);
5811 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
5812 string_sec->sh_size,
5816 for (si = 0, psym = symtab;
5817 si < section->sh_size / section->sh_entsize;
5820 printf ("%6d: ", si);
5821 print_vma (psym->st_value, LONG_HEX);
5823 print_vma (psym->st_size, DEC_5);
5824 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
5825 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
5826 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
5827 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
5828 print_symbol (25, strtab + psym->st_name);
5830 if (section->sh_type == SHT_DYNSYM &&
5831 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
5833 unsigned char data[2];
5834 unsigned short vers_data;
5835 unsigned long offset;
5839 offset = version_info[DT_VERSIONTAGIDX (DT_VERSYM)]
5842 get_data (&data, file, offset + si * sizeof (vers_data),
5843 sizeof (data), _("version data"));
5845 vers_data = byte_get (data, 2);
5847 is_nobits = (SECTION_HEADER (psym->st_shndx)->sh_type
5850 check_def = (psym->st_shndx != SHN_UNDEF);
5852 if ((vers_data & 0x8000) || vers_data > 1)
5854 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
5855 && (is_nobits || ! check_def))
5857 Elf_External_Verneed evn;
5858 Elf_Internal_Verneed ivn;
5859 Elf_Internal_Vernaux ivna;
5861 /* We must test both. */
5862 offset = (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
5867 unsigned long vna_off;
5869 get_data (&evn, file, offset, sizeof (evn),
5872 ivn.vn_aux = BYTE_GET (evn.vn_aux);
5873 ivn.vn_next = BYTE_GET (evn.vn_next);
5875 vna_off = offset + ivn.vn_aux;
5879 Elf_External_Vernaux evna;
5881 get_data (&evna, file, vna_off,
5883 _("version need aux (3)"));
5885 ivna.vna_other = BYTE_GET (evna.vna_other);
5886 ivna.vna_next = BYTE_GET (evna.vna_next);
5887 ivna.vna_name = BYTE_GET (evna.vna_name);
5889 vna_off += ivna.vna_next;
5891 while (ivna.vna_other != vers_data
5892 && ivna.vna_next != 0);
5894 if (ivna.vna_other == vers_data)
5897 offset += ivn.vn_next;
5899 while (ivn.vn_next != 0);
5901 if (ivna.vna_other == vers_data)
5904 strtab + ivna.vna_name, ivna.vna_other);
5907 else if (! is_nobits)
5908 error (_("bad dynamic symbol"));
5915 if (vers_data != 0x8001
5916 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
5918 Elf_Internal_Verdef ivd;
5919 Elf_Internal_Verdaux ivda;
5920 Elf_External_Verdaux evda;
5921 unsigned long offset;
5924 = (version_info[DT_VERSIONTAGIDX (DT_VERDEF)]
5929 Elf_External_Verdef evd;
5931 get_data (&evd, file, offset, sizeof (evd),
5934 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
5935 ivd.vd_aux = BYTE_GET (evd.vd_aux);
5936 ivd.vd_next = BYTE_GET (evd.vd_next);
5938 offset += ivd.vd_next;
5940 while (ivd.vd_ndx != (vers_data & 0x7fff)
5941 && ivd.vd_next != 0);
5943 offset -= ivd.vd_next;
5944 offset += ivd.vd_aux;
5946 get_data (&evda, file, offset, sizeof (evda),
5947 _("version def aux"));
5949 ivda.vda_name = BYTE_GET (evda.vda_name);
5951 if (psym->st_name != ivda.vda_name)
5952 printf ((vers_data & 0x8000)
5954 strtab + ivda.vda_name);
5964 if (strtab != string_table)
5970 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5972 if (do_histogram && buckets != NULL)
5979 int nzero_counts = 0;
5982 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5984 printf (_(" Length Number %% of total Coverage\n"));
5986 lengths = (int *) calloc (nbuckets, sizeof (int));
5987 if (lengths == NULL)
5989 error (_("Out of memory"));
5992 for (hn = 0; hn < nbuckets; ++hn)
5997 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
6000 if (maxlength < ++lengths[hn])
6005 counts = (int *) calloc (maxlength + 1, sizeof (int));
6008 error (_("Out of memory"));
6012 for (hn = 0; hn < nbuckets; ++hn)
6013 ++counts[lengths[hn]];
6017 printf (" 0 %-10d (%5.1f%%)\n",
6018 counts[0], (counts[0] * 100.0) / nbuckets);
6019 for (si = 1; si <= maxlength; ++si)
6021 nzero_counts += counts[si] * si;
6022 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6023 si, counts[si], (counts[si] * 100.0) / nbuckets,
6024 (nzero_counts * 100.0) / nsyms);
6032 if (buckets != NULL)
6042 process_syminfo (file)
6043 FILE *file ATTRIBUTE_UNUSED;
6047 if (dynamic_syminfo == NULL
6049 /* No syminfo, this is ok. */
6052 /* There better should be a dynamic symbol section. */
6053 if (dynamic_symbols == NULL || dynamic_strings == NULL)
6057 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6058 dynamic_syminfo_offset, dynamic_syminfo_nent);
6060 printf (_(" Num: Name BoundTo Flags\n"));
6061 for (i = 0; i < dynamic_syminfo_nent; ++i)
6063 unsigned short int flags = dynamic_syminfo[i].si_flags;
6065 printf ("%4d: ", i);
6066 print_symbol (30, dynamic_strings + dynamic_symbols[i].st_name);
6069 switch (dynamic_syminfo[i].si_boundto)
6071 case SYMINFO_BT_SELF:
6072 fputs ("SELF ", stdout);
6074 case SYMINFO_BT_PARENT:
6075 fputs ("PARENT ", stdout);
6078 if (dynamic_syminfo[i].si_boundto > 0
6079 && dynamic_syminfo[i].si_boundto < dynamic_size)
6084 [dynamic_syminfo[i].si_boundto].d_un.d_val));
6088 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
6092 if (flags & SYMINFO_FLG_DIRECT)
6094 if (flags & SYMINFO_FLG_PASSTHRU)
6095 printf (" PASSTHRU");
6096 if (flags & SYMINFO_FLG_COPY)
6098 if (flags & SYMINFO_FLG_LAZYLOAD)
6099 printf (" LAZYLOAD");
6107 #ifdef SUPPORT_DISASSEMBLY
6109 disassemble_section (section, file)
6110 Elf_Internal_Shdr *section;
6113 printf (_("\nAssembly dump of section %s\n"),
6114 SECTION_NAME (section));
6116 /* XXX -- to be done --- XXX */
6123 dump_section (section, file)
6124 Elf_Internal_Shdr *section;
6127 bfd_size_type bytes;
6129 unsigned char *data;
6130 unsigned char *start;
6132 bytes = section->sh_size;
6136 printf (_("\nSection '%s' has no data to dump.\n"),
6137 SECTION_NAME (section));
6141 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
6143 addr = section->sh_addr;
6145 start = (unsigned char *) get_data (NULL, file, section->sh_offset, bytes,
6158 lbytes = (bytes > 16 ? 16 : bytes);
6160 printf (" 0x%8.8lx ", (unsigned long) addr);
6162 switch (elf_header.e_ident[EI_DATA])
6166 for (j = 15; j >= 0; j --)
6169 printf ("%2.2x", data[j]);
6179 for (j = 0; j < 16; j++)
6182 printf ("%2.2x", data[j]);
6192 for (j = 0; j < lbytes; j++)
6195 if (k >= ' ' && k < 0x80)
6214 static unsigned long int
6215 read_leb128 (data, length_return, sign)
6216 unsigned char *data;
6220 unsigned long int result = 0;
6221 unsigned int num_read = 0;
6230 result |= (byte & 0x7f) << shift;
6235 while (byte & 0x80);
6237 if (length_return != NULL)
6238 *length_return = num_read;
6240 if (sign && (shift < 32) && (byte & 0x40))
6241 result |= -1 << shift;
6246 typedef struct State_Machine_Registers
6248 unsigned long address;
6251 unsigned int column;
6255 /* This variable hold the number of the last entry seen
6256 in the File Table. */
6257 unsigned int last_file_entry;
6260 static SMR state_machine_regs;
6263 reset_state_machine (is_stmt)
6266 state_machine_regs.address = 0;
6267 state_machine_regs.file = 1;
6268 state_machine_regs.line = 1;
6269 state_machine_regs.column = 0;
6270 state_machine_regs.is_stmt = is_stmt;
6271 state_machine_regs.basic_block = 0;
6272 state_machine_regs.end_sequence = 0;
6273 state_machine_regs.last_file_entry = 0;
6276 /* Handled an extend line op. Returns true if this is the end
6279 process_extended_line_op (data, is_stmt, pointer_size)
6280 unsigned char *data;
6284 unsigned char op_code;
6287 unsigned char *name;
6290 len = read_leb128 (data, & bytes_read, 0);
6295 warn (_("badly formed extended line op encountered!\n"));
6302 printf (_(" Extended opcode %d: "), op_code);
6306 case DW_LNE_end_sequence:
6307 printf (_("End of Sequence\n\n"));
6308 reset_state_machine (is_stmt);
6311 case DW_LNE_set_address:
6312 adr = byte_get (data, pointer_size);
6313 printf (_("set Address to 0x%lx\n"), adr);
6314 state_machine_regs.address = adr;
6317 case DW_LNE_define_file:
6318 printf (_(" define new File Table entry\n"));
6319 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6321 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6323 data += strlen ((char *) data) + 1;
6324 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6326 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6328 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6329 printf (_("%s\n\n"), name);
6333 printf (_("UNKNOWN: length %d\n"), len - bytes_read);
6340 /* Size of pointers in the .debug_line section. This information is not
6341 really present in that section. It's obtained before dumping the debug
6342 sections by doing some pre-scan of the .debug_info section. */
6343 static int debug_line_pointer_size = 4;
6346 display_debug_lines (section, start, file)
6347 Elf_Internal_Shdr *section;
6348 unsigned char * start;
6349 FILE *file ATTRIBUTE_UNUSED;
6351 DWARF2_External_LineInfo *external;
6352 DWARF2_Internal_LineInfo info;
6353 unsigned char *standard_opcodes;
6354 unsigned char *data = start;
6355 unsigned char *end = start + section->sh_size;
6356 unsigned char *end_of_sequence;
6359 printf (_("\nDump of debug contents of section %s:\n\n"),
6360 SECTION_NAME (section));
6364 external = (DWARF2_External_LineInfo *) data;
6366 /* Check the length of the block. */
6367 info.li_length = BYTE_GET (external->li_length);
6369 if (info.li_length == 0xffffffff)
6371 warn (_("64-bit DWARF line info is not supported yet.\n"));
6375 if (info.li_length + sizeof (external->li_length) > section->sh_size)
6378 (_("The line info appears to be corrupt - the section is too small\n"));
6382 /* Check its version number. */
6383 info.li_version = BYTE_GET (external->li_version);
6384 if (info.li_version != 2)
6386 warn (_("Only DWARF version 2 line info is currently supported.\n"));
6390 info.li_prologue_length = BYTE_GET (external->li_prologue_length);
6391 info.li_min_insn_length = BYTE_GET (external->li_min_insn_length);
6392 info.li_default_is_stmt = BYTE_GET (external->li_default_is_stmt);
6393 info.li_line_base = BYTE_GET (external->li_line_base);
6394 info.li_line_range = BYTE_GET (external->li_line_range);
6395 info.li_opcode_base = BYTE_GET (external->li_opcode_base);
6397 /* Sign extend the line base field. */
6398 info.li_line_base <<= 24;
6399 info.li_line_base >>= 24;
6401 printf (_(" Length: %ld\n"), info.li_length);
6402 printf (_(" DWARF Version: %d\n"), info.li_version);
6403 printf (_(" Prologue Length: %d\n"), info.li_prologue_length);
6404 printf (_(" Minimum Instruction Length: %d\n"), info.li_min_insn_length);
6405 printf (_(" Initial value of 'is_stmt': %d\n"), info.li_default_is_stmt);
6406 printf (_(" Line Base: %d\n"), info.li_line_base);
6407 printf (_(" Line Range: %d\n"), info.li_line_range);
6408 printf (_(" Opcode Base: %d\n"), info.li_opcode_base);
6410 end_of_sequence = data + info.li_length + sizeof (external->li_length);
6412 reset_state_machine (info.li_default_is_stmt);
6414 /* Display the contents of the Opcodes table. */
6415 standard_opcodes = data + sizeof (*external);
6417 printf (_("\n Opcodes:\n"));
6419 for (i = 1; i < info.li_opcode_base; i++)
6420 printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]);
6422 /* Display the contents of the Directory table. */
6423 data = standard_opcodes + info.li_opcode_base - 1;
6426 printf (_("\n The Directory Table is empty.\n"));
6429 printf (_("\n The Directory Table:\n"));
6433 printf (_(" %s\n"), data);
6435 data += strlen ((char *) data) + 1;
6439 /* Skip the NUL at the end of the table. */
6442 /* Display the contents of the File Name table. */
6444 printf (_("\n The File Name Table is empty.\n"));
6447 printf (_("\n The File Name Table:\n"));
6448 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6452 unsigned char *name;
6455 printf (_(" %d\t"), ++state_machine_regs.last_file_entry);
6458 data += strlen ((char *) data) + 1;
6460 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6462 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6464 printf (_("%lu\t"), read_leb128 (data, & bytes_read, 0));
6466 printf (_("%s\n"), name);
6470 /* Skip the NUL at the end of the table. */
6473 /* Now display the statements. */
6474 printf (_("\n Line Number Statements:\n"));
6477 while (data < end_of_sequence)
6479 unsigned char op_code;
6485 if (op_code >= info.li_opcode_base)
6487 op_code -= info.li_opcode_base;
6488 adv = (op_code / info.li_line_range) * info.li_min_insn_length;
6489 state_machine_regs.address += adv;
6490 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6491 op_code, adv, state_machine_regs.address);
6492 adv = (op_code % info.li_line_range) + info.li_line_base;
6493 state_machine_regs.line += adv;
6494 printf (_(" and Line by %d to %d\n"),
6495 adv, state_machine_regs.line);
6497 else switch (op_code)
6499 case DW_LNS_extended_op:
6500 data += process_extended_line_op (data, info.li_default_is_stmt,
6501 debug_line_pointer_size);
6505 printf (_(" Copy\n"));
6508 case DW_LNS_advance_pc:
6509 adv = info.li_min_insn_length * read_leb128 (data, & bytes_read, 0);
6511 state_machine_regs.address += adv;
6512 printf (_(" Advance PC by %d to %lx\n"), adv,
6513 state_machine_regs.address);
6516 case DW_LNS_advance_line:
6517 adv = read_leb128 (data, & bytes_read, 1);
6519 state_machine_regs.line += adv;
6520 printf (_(" Advance Line by %d to %d\n"), adv,
6521 state_machine_regs.line);
6524 case DW_LNS_set_file:
6525 adv = read_leb128 (data, & bytes_read, 0);
6527 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6529 state_machine_regs.file = adv;
6532 case DW_LNS_set_column:
6533 adv = read_leb128 (data, & bytes_read, 0);
6535 printf (_(" Set column to %d\n"), adv);
6536 state_machine_regs.column = adv;
6539 case DW_LNS_negate_stmt:
6540 adv = state_machine_regs.is_stmt;
6542 printf (_(" Set is_stmt to %d\n"), adv);
6543 state_machine_regs.is_stmt = adv;
6546 case DW_LNS_set_basic_block:
6547 printf (_(" Set basic block\n"));
6548 state_machine_regs.basic_block = 1;
6551 case DW_LNS_const_add_pc:
6552 adv = (((255 - info.li_opcode_base) / info.li_line_range)
6553 * info.li_min_insn_length);
6554 state_machine_regs.address += adv;
6555 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv,
6556 state_machine_regs.address);
6559 case DW_LNS_fixed_advance_pc:
6560 adv = byte_get (data, 2);
6562 state_machine_regs.address += adv;
6563 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6564 adv, state_machine_regs.address);
6567 case DW_LNS_set_prologue_end:
6568 printf (_(" Set prologue_end to true\n"));
6571 case DW_LNS_set_epilogue_begin:
6572 printf (_(" Set epilogue_begin to true\n"));
6575 case DW_LNS_set_isa:
6576 adv = read_leb128 (data, & bytes_read, 0);
6578 printf (_(" Set ISA to %d\n"), adv);
6582 printf (_(" Unknown opcode %d with operands: "), op_code);
6585 for (i = standard_opcodes[op_code - 1]; i > 0 ; --i)
6587 printf ("0x%lx%s", read_leb128 (data, &bytes_read, 0),
6588 i == 1 ? "" : ", ");
6603 display_debug_pubnames (section, start, file)
6604 Elf_Internal_Shdr *section;
6605 unsigned char *start;
6606 FILE *file ATTRIBUTE_UNUSED;
6608 DWARF2_External_PubNames *external;
6609 DWARF2_Internal_PubNames pubnames;
6612 end = start + section->sh_size;
6614 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
6618 unsigned char *data;
6619 unsigned long offset;
6621 external = (DWARF2_External_PubNames *) start;
6623 pubnames.pn_length = BYTE_GET (external->pn_length);
6624 pubnames.pn_version = BYTE_GET (external->pn_version);
6625 pubnames.pn_offset = BYTE_GET (external->pn_offset);
6626 pubnames.pn_size = BYTE_GET (external->pn_size);
6628 data = start + sizeof (*external);
6629 start += pubnames.pn_length + sizeof (external->pn_length);
6631 if (pubnames.pn_length == 0xffffffff)
6633 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6637 if (pubnames.pn_version != 2)
6639 static int warned = 0;
6643 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6650 printf (_(" Length: %ld\n"),
6651 pubnames.pn_length);
6652 printf (_(" Version: %d\n"),
6653 pubnames.pn_version);
6654 printf (_(" Offset into .debug_info section: %ld\n"),
6655 pubnames.pn_offset);
6656 printf (_(" Size of area in .debug_info section: %ld\n"),
6659 printf (_("\n Offset\tName\n"));
6663 offset = byte_get (data, 4);
6668 printf (" %ld\t\t%s\n", offset, data);
6669 data += strlen ((char *) data) + 1;
6672 while (offset != 0);
6685 case DW_TAG_padding: return "DW_TAG_padding";
6686 case DW_TAG_array_type: return "DW_TAG_array_type";
6687 case DW_TAG_class_type: return "DW_TAG_class_type";
6688 case DW_TAG_entry_point: return "DW_TAG_entry_point";
6689 case DW_TAG_enumeration_type: return "DW_TAG_enumeration_type";
6690 case DW_TAG_formal_parameter: return "DW_TAG_formal_parameter";
6691 case DW_TAG_imported_declaration: return "DW_TAG_imported_declaration";
6692 case DW_TAG_label: return "DW_TAG_label";
6693 case DW_TAG_lexical_block: return "DW_TAG_lexical_block";
6694 case DW_TAG_member: return "DW_TAG_member";
6695 case DW_TAG_pointer_type: return "DW_TAG_pointer_type";
6696 case DW_TAG_reference_type: return "DW_TAG_reference_type";
6697 case DW_TAG_compile_unit: return "DW_TAG_compile_unit";
6698 case DW_TAG_string_type: return "DW_TAG_string_type";
6699 case DW_TAG_structure_type: return "DW_TAG_structure_type";
6700 case DW_TAG_subroutine_type: return "DW_TAG_subroutine_type";
6701 case DW_TAG_typedef: return "DW_TAG_typedef";
6702 case DW_TAG_union_type: return "DW_TAG_union_type";
6703 case DW_TAG_unspecified_parameters: return "DW_TAG_unspecified_parameters";
6704 case DW_TAG_variant: return "DW_TAG_variant";
6705 case DW_TAG_common_block: return "DW_TAG_common_block";
6706 case DW_TAG_common_inclusion: return "DW_TAG_common_inclusion";
6707 case DW_TAG_inheritance: return "DW_TAG_inheritance";
6708 case DW_TAG_inlined_subroutine: return "DW_TAG_inlined_subroutine";
6709 case DW_TAG_module: return "DW_TAG_module";
6710 case DW_TAG_ptr_to_member_type: return "DW_TAG_ptr_to_member_type";
6711 case DW_TAG_set_type: return "DW_TAG_set_type";
6712 case DW_TAG_subrange_type: return "DW_TAG_subrange_type";
6713 case DW_TAG_with_stmt: return "DW_TAG_with_stmt";
6714 case DW_TAG_access_declaration: return "DW_TAG_access_declaration";
6715 case DW_TAG_base_type: return "DW_TAG_base_type";
6716 case DW_TAG_catch_block: return "DW_TAG_catch_block";
6717 case DW_TAG_const_type: return "DW_TAG_const_type";
6718 case DW_TAG_constant: return "DW_TAG_constant";
6719 case DW_TAG_enumerator: return "DW_TAG_enumerator";
6720 case DW_TAG_file_type: return "DW_TAG_file_type";
6721 case DW_TAG_friend: return "DW_TAG_friend";
6722 case DW_TAG_namelist: return "DW_TAG_namelist";
6723 case DW_TAG_namelist_item: return "DW_TAG_namelist_item";
6724 case DW_TAG_packed_type: return "DW_TAG_packed_type";
6725 case DW_TAG_subprogram: return "DW_TAG_subprogram";
6726 case DW_TAG_template_type_param: return "DW_TAG_template_type_param";
6727 case DW_TAG_template_value_param: return "DW_TAG_template_value_param";
6728 case DW_TAG_thrown_type: return "DW_TAG_thrown_type";
6729 case DW_TAG_try_block: return "DW_TAG_try_block";
6730 case DW_TAG_variant_part: return "DW_TAG_variant_part";
6731 case DW_TAG_variable: return "DW_TAG_variable";
6732 case DW_TAG_volatile_type: return "DW_TAG_volatile_type";
6733 case DW_TAG_MIPS_loop: return "DW_TAG_MIPS_loop";
6734 case DW_TAG_format_label: return "DW_TAG_format_label";
6735 case DW_TAG_function_template: return "DW_TAG_function_template";
6736 case DW_TAG_class_template: return "DW_TAG_class_template";
6737 /* DWARF 2.1 values. */
6738 case DW_TAG_dwarf_procedure: return "DW_TAG_dwarf_procedure";
6739 case DW_TAG_restrict_type: return "DW_TAG_restrict_type";
6740 case DW_TAG_interface_type: return "DW_TAG_interface_type";
6741 case DW_TAG_namespace: return "DW_TAG_namespace";
6742 case DW_TAG_imported_module: return "DW_TAG_imported_module";
6743 case DW_TAG_unspecified_type: return "DW_TAG_unspecified_type";
6744 case DW_TAG_partial_unit: return "DW_TAG_partial_unit";
6745 case DW_TAG_imported_unit: return "DW_TAG_imported_unit";
6747 case DW_TAG_upc_shared_type: return "DW_TAG_upc_shared_type";
6748 case DW_TAG_upc_strict_type: return "DW_TAG_upc_strict_type";
6749 case DW_TAG_upc_relaxed_type: return "DW_TAG_upc_relaxed_type";
6752 static char buffer[100];
6754 sprintf (buffer, _("Unknown TAG value: %lx"), tag);
6761 get_AT_name (attribute)
6762 unsigned long attribute;
6766 case DW_AT_sibling: return "DW_AT_sibling";
6767 case DW_AT_location: return "DW_AT_location";
6768 case DW_AT_name: return "DW_AT_name";
6769 case DW_AT_ordering: return "DW_AT_ordering";
6770 case DW_AT_subscr_data: return "DW_AT_subscr_data";
6771 case DW_AT_byte_size: return "DW_AT_byte_size";
6772 case DW_AT_bit_offset: return "DW_AT_bit_offset";
6773 case DW_AT_bit_size: return "DW_AT_bit_size";
6774 case DW_AT_element_list: return "DW_AT_element_list";
6775 case DW_AT_stmt_list: return "DW_AT_stmt_list";
6776 case DW_AT_low_pc: return "DW_AT_low_pc";
6777 case DW_AT_high_pc: return "DW_AT_high_pc";
6778 case DW_AT_language: return "DW_AT_language";
6779 case DW_AT_member: return "DW_AT_member";
6780 case DW_AT_discr: return "DW_AT_discr";
6781 case DW_AT_discr_value: return "DW_AT_discr_value";
6782 case DW_AT_visibility: return "DW_AT_visibility";
6783 case DW_AT_import: return "DW_AT_import";
6784 case DW_AT_string_length: return "DW_AT_string_length";
6785 case DW_AT_common_reference: return "DW_AT_common_reference";
6786 case DW_AT_comp_dir: return "DW_AT_comp_dir";
6787 case DW_AT_const_value: return "DW_AT_const_value";
6788 case DW_AT_containing_type: return "DW_AT_containing_type";
6789 case DW_AT_default_value: return "DW_AT_default_value";
6790 case DW_AT_inline: return "DW_AT_inline";
6791 case DW_AT_is_optional: return "DW_AT_is_optional";
6792 case DW_AT_lower_bound: return "DW_AT_lower_bound";
6793 case DW_AT_producer: return "DW_AT_producer";
6794 case DW_AT_prototyped: return "DW_AT_prototyped";
6795 case DW_AT_return_addr: return "DW_AT_return_addr";
6796 case DW_AT_start_scope: return "DW_AT_start_scope";
6797 case DW_AT_stride_size: return "DW_AT_stride_size";
6798 case DW_AT_upper_bound: return "DW_AT_upper_bound";
6799 case DW_AT_abstract_origin: return "DW_AT_abstract_origin";
6800 case DW_AT_accessibility: return "DW_AT_accessibility";
6801 case DW_AT_address_class: return "DW_AT_address_class";
6802 case DW_AT_artificial: return "DW_AT_artificial";
6803 case DW_AT_base_types: return "DW_AT_base_types";
6804 case DW_AT_calling_convention: return "DW_AT_calling_convention";
6805 case DW_AT_count: return "DW_AT_count";
6806 case DW_AT_data_member_location: return "DW_AT_data_member_location";
6807 case DW_AT_decl_column: return "DW_AT_decl_column";
6808 case DW_AT_decl_file: return "DW_AT_decl_file";
6809 case DW_AT_decl_line: return "DW_AT_decl_line";
6810 case DW_AT_declaration: return "DW_AT_declaration";
6811 case DW_AT_discr_list: return "DW_AT_discr_list";
6812 case DW_AT_encoding: return "DW_AT_encoding";
6813 case DW_AT_external: return "DW_AT_external";
6814 case DW_AT_frame_base: return "DW_AT_frame_base";
6815 case DW_AT_friend: return "DW_AT_friend";
6816 case DW_AT_identifier_case: return "DW_AT_identifier_case";
6817 case DW_AT_macro_info: return "DW_AT_macro_info";
6818 case DW_AT_namelist_items: return "DW_AT_namelist_items";
6819 case DW_AT_priority: return "DW_AT_priority";
6820 case DW_AT_segment: return "DW_AT_segment";
6821 case DW_AT_specification: return "DW_AT_specification";
6822 case DW_AT_static_link: return "DW_AT_static_link";
6823 case DW_AT_type: return "DW_AT_type";
6824 case DW_AT_use_location: return "DW_AT_use_location";
6825 case DW_AT_variable_parameter: return "DW_AT_variable_parameter";
6826 case DW_AT_virtuality: return "DW_AT_virtuality";
6827 case DW_AT_vtable_elem_location: return "DW_AT_vtable_elem_location";
6828 /* DWARF 2.1 values. */
6829 case DW_AT_allocated: return "DW_AT_allocated";
6830 case DW_AT_associated: return "DW_AT_associated";
6831 case DW_AT_data_location: return "DW_AT_data_location";
6832 case DW_AT_stride: return "DW_AT_stride";
6833 case DW_AT_entry_pc: return "DW_AT_entry_pc";
6834 case DW_AT_use_UTF8: return "DW_AT_use_UTF8";
6835 case DW_AT_extension: return "DW_AT_extension";
6836 case DW_AT_ranges: return "DW_AT_ranges";
6837 case DW_AT_trampoline: return "DW_AT_trampoline";
6838 case DW_AT_call_column: return "DW_AT_call_column";
6839 case DW_AT_call_file: return "DW_AT_call_file";
6840 case DW_AT_call_line: return "DW_AT_call_line";
6841 /* SGI/MIPS extensions. */
6842 case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde";
6843 case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin";
6844 case DW_AT_MIPS_tail_loop_begin: return "DW_AT_MIPS_tail_loop_begin";
6845 case DW_AT_MIPS_epilog_begin: return "DW_AT_MIPS_epilog_begin";
6846 case DW_AT_MIPS_loop_unroll_factor: return "DW_AT_MIPS_loop_unroll_factor";
6847 case DW_AT_MIPS_software_pipeline_depth:
6848 return "DW_AT_MIPS_software_pipeline_depth";
6849 case DW_AT_MIPS_linkage_name: return "DW_AT_MIPS_linkage_name";
6850 case DW_AT_MIPS_stride: return "DW_AT_MIPS_stride";
6851 case DW_AT_MIPS_abstract_name: return "DW_AT_MIPS_abstract_name";
6852 case DW_AT_MIPS_clone_origin: return "DW_AT_MIPS_clone_origin";
6853 case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines";
6854 /* GNU extensions. */
6855 case DW_AT_sf_names: return "DW_AT_sf_names";
6856 case DW_AT_src_info: return "DW_AT_src_info";
6857 case DW_AT_mac_info: return "DW_AT_mac_info";
6858 case DW_AT_src_coords: return "DW_AT_src_coords";
6859 case DW_AT_body_begin: return "DW_AT_body_begin";
6860 case DW_AT_body_end: return "DW_AT_body_end";
6861 case DW_AT_GNU_vector: return "DW_AT_GNU_vector";
6862 /* UPC extension. */
6863 case DW_AT_upc_threads_scaled: return "DW_AT_upc_threads_scaled";
6866 static char buffer[100];
6868 sprintf (buffer, _("Unknown AT value: %lx"), attribute);
6875 get_FORM_name (form)
6880 case DW_FORM_addr: return "DW_FORM_addr";
6881 case DW_FORM_block2: return "DW_FORM_block2";
6882 case DW_FORM_block4: return "DW_FORM_block4";
6883 case DW_FORM_data2: return "DW_FORM_data2";
6884 case DW_FORM_data4: return "DW_FORM_data4";
6885 case DW_FORM_data8: return "DW_FORM_data8";
6886 case DW_FORM_string: return "DW_FORM_string";
6887 case DW_FORM_block: return "DW_FORM_block";
6888 case DW_FORM_block1: return "DW_FORM_block1";
6889 case DW_FORM_data1: return "DW_FORM_data1";
6890 case DW_FORM_flag: return "DW_FORM_flag";
6891 case DW_FORM_sdata: return "DW_FORM_sdata";
6892 case DW_FORM_strp: return "DW_FORM_strp";
6893 case DW_FORM_udata: return "DW_FORM_udata";
6894 case DW_FORM_ref_addr: return "DW_FORM_ref_addr";
6895 case DW_FORM_ref1: return "DW_FORM_ref1";
6896 case DW_FORM_ref2: return "DW_FORM_ref2";
6897 case DW_FORM_ref4: return "DW_FORM_ref4";
6898 case DW_FORM_ref8: return "DW_FORM_ref8";
6899 case DW_FORM_ref_udata: return "DW_FORM_ref_udata";
6900 case DW_FORM_indirect: return "DW_FORM_indirect";
6903 static char buffer[100];
6905 sprintf (buffer, _("Unknown FORM value: %lx"), form);
6911 /* FIXME: There are better and more effiecint ways to handle
6912 these structures. For now though, I just want something that
6913 is simple to implement. */
6914 typedef struct abbrev_attr
6916 unsigned long attribute;
6918 struct abbrev_attr *next;
6922 typedef struct abbrev_entry
6924 unsigned long entry;
6927 struct abbrev_attr *first_attr;
6928 struct abbrev_attr *last_attr;
6929 struct abbrev_entry *next;
6933 static abbrev_entry *first_abbrev = NULL;
6934 static abbrev_entry *last_abbrev = NULL;
6939 abbrev_entry *abbrev;
6941 for (abbrev = first_abbrev; abbrev;)
6943 abbrev_entry *next = abbrev->next;
6946 for (attr = abbrev->first_attr; attr;)
6948 abbrev_attr *next = attr->next;
6958 last_abbrev = first_abbrev = NULL;
6962 add_abbrev (number, tag, children)
6963 unsigned long number;
6967 abbrev_entry *entry;
6969 entry = (abbrev_entry *) malloc (sizeof (*entry));
6975 entry->entry = number;
6977 entry->children = children;
6978 entry->first_attr = NULL;
6979 entry->last_attr = NULL;
6982 if (first_abbrev == NULL)
6983 first_abbrev = entry;
6985 last_abbrev->next = entry;
6987 last_abbrev = entry;
6991 add_abbrev_attr (attribute, form)
6992 unsigned long attribute;
6997 attr = (abbrev_attr *) malloc (sizeof (*attr));
7003 attr->attribute = attribute;
7007 if (last_abbrev->first_attr == NULL)
7008 last_abbrev->first_attr = attr;
7010 last_abbrev->last_attr->next = attr;
7012 last_abbrev->last_attr = attr;
7015 /* Processes the (partial) contents of a .debug_abbrev section.
7016 Returns NULL if the end of the section was encountered.
7017 Returns the address after the last byte read if the end of
7018 an abbreviation set was found. */
7020 static unsigned char *
7021 process_abbrev_section (start, end)
7022 unsigned char *start;
7025 if (first_abbrev != NULL)
7031 unsigned long entry;
7033 unsigned long attribute;
7036 entry = read_leb128 (start, & bytes_read, 0);
7037 start += bytes_read;
7039 /* A single zero is supposed to end the section according
7040 to the standard. If there's more, then signal that to
7043 return start == end ? NULL : start;
7045 tag = read_leb128 (start, & bytes_read, 0);
7046 start += bytes_read;
7048 children = *start++;
7050 add_abbrev (entry, tag, children);
7056 attribute = read_leb128 (start, & bytes_read, 0);
7057 start += bytes_read;
7059 form = read_leb128 (start, & bytes_read, 0);
7060 start += bytes_read;
7063 add_abbrev_attr (attribute, form);
7065 while (attribute != 0);
7073 display_debug_macinfo (section, start, file)
7074 Elf_Internal_Shdr *section;
7075 unsigned char *start;
7076 FILE *file ATTRIBUTE_UNUSED;
7078 unsigned char *end = start + section->sh_size;
7079 unsigned char *curr = start;
7080 unsigned int bytes_read;
7081 enum dwarf_macinfo_record_type op;
7083 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7087 unsigned int lineno;
7095 case DW_MACINFO_start_file:
7097 unsigned int filenum;
7099 lineno = read_leb128 (curr, & bytes_read, 0);
7101 filenum = read_leb128 (curr, & bytes_read, 0);
7104 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno, filenum);
7108 case DW_MACINFO_end_file:
7109 printf (_(" DW_MACINFO_end_file\n"));
7112 case DW_MACINFO_define:
7113 lineno = read_leb128 (curr, & bytes_read, 0);
7116 curr += strlen (string) + 1;
7117 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno, string);
7120 case DW_MACINFO_undef:
7121 lineno = read_leb128 (curr, & bytes_read, 0);
7124 curr += strlen (string) + 1;
7125 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno, string);
7128 case DW_MACINFO_vendor_ext:
7130 unsigned int constant;
7132 constant = read_leb128 (curr, & bytes_read, 0);
7135 curr += strlen (string) + 1;
7136 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant, string);
7147 display_debug_abbrev (section, start, file)
7148 Elf_Internal_Shdr *section;
7149 unsigned char *start;
7150 FILE *file ATTRIBUTE_UNUSED;
7152 abbrev_entry *entry;
7153 unsigned char *end = start + section->sh_size;
7155 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section));
7159 start = process_abbrev_section (start, end);
7161 if (first_abbrev == NULL)
7164 printf (_(" Number TAG\n"));
7166 for (entry = first_abbrev; entry; entry = entry->next)
7170 printf (_(" %ld %s [%s]\n"),
7172 get_TAG_name (entry->tag),
7173 entry->children ? _("has children") : _("no children"));
7175 for (attr = entry->first_attr; attr; attr = attr->next)
7177 printf (_(" %-18s %s\n"),
7178 get_AT_name (attr->attribute),
7179 get_FORM_name (attr->form));
7193 static unsigned char *
7194 display_block (data, length)
7195 unsigned char *data;
7196 unsigned long length;
7198 printf (_(" %lu byte block: "), length);
7201 printf ("%lx ", (unsigned long) byte_get (data++, 1));
7207 decode_location_expression (data, pointer_size, length)
7208 unsigned char * data;
7209 unsigned int pointer_size;
7210 unsigned long length;
7214 unsigned long uvalue;
7215 unsigned char *end = data + length;
7224 printf ("DW_OP_addr: %lx",
7225 (unsigned long) byte_get (data, pointer_size));
7226 data += pointer_size;
7229 printf ("DW_OP_deref");
7232 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data++, 1));
7235 printf ("DW_OP_const1s: %ld", (long) byte_get (data++, 1));
7238 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data, 2));
7242 printf ("DW_OP_const2s: %ld", (long) byte_get (data, 2));
7246 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data, 4));
7250 printf ("DW_OP_const4s: %ld", (long) byte_get (data, 4));
7254 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data, 4),
7255 (unsigned long) byte_get (data + 4, 4));
7259 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data, 4),
7260 (long) byte_get (data + 4, 4));
7264 printf ("DW_OP_constu: %lu", read_leb128 (data, &bytes_read, 0));
7268 printf ("DW_OP_consts: %ld", read_leb128 (data, &bytes_read, 1));
7272 printf ("DW_OP_dup");
7275 printf ("DW_OP_drop");
7278 printf ("DW_OP_over");
7281 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data++, 1));
7284 printf ("DW_OP_swap");
7287 printf ("DW_OP_rot");
7290 printf ("DW_OP_xderef");
7293 printf ("DW_OP_abs");
7296 printf ("DW_OP_and");
7299 printf ("DW_OP_div");
7302 printf ("DW_OP_minus");
7305 printf ("DW_OP_mod");
7308 printf ("DW_OP_mul");
7311 printf ("DW_OP_neg");
7314 printf ("DW_OP_not");
7317 printf ("DW_OP_or");
7320 printf ("DW_OP_plus");
7322 case DW_OP_plus_uconst:
7323 printf ("DW_OP_plus_uconst: %lu",
7324 read_leb128 (data, &bytes_read, 0));
7328 printf ("DW_OP_shl");
7331 printf ("DW_OP_shr");
7334 printf ("DW_OP_shra");
7337 printf ("DW_OP_xor");
7340 printf ("DW_OP_bra: %ld", (long) byte_get (data, 2));
7344 printf ("DW_OP_eq");
7347 printf ("DW_OP_ge");
7350 printf ("DW_OP_gt");
7353 printf ("DW_OP_le");
7356 printf ("DW_OP_lt");
7359 printf ("DW_OP_ne");
7362 printf ("DW_OP_skip: %ld", (long) byte_get (data, 2));
7398 printf ("DW_OP_lit%d", op - DW_OP_lit0);
7433 printf ("DW_OP_reg%d", op - DW_OP_reg0);
7468 printf ("DW_OP_breg%d: %ld", op - DW_OP_breg0,
7469 read_leb128 (data, &bytes_read, 1));
7474 printf ("DW_OP_regx: %lu", read_leb128 (data, &bytes_read, 0));
7478 printf ("DW_OP_fbreg: %ld", read_leb128 (data, &bytes_read, 1));
7482 uvalue = read_leb128 (data, &bytes_read, 0);
7484 printf ("DW_OP_bregx: %lu %ld", uvalue,
7485 read_leb128 (data, &bytes_read, 1));
7489 printf ("DW_OP_piece: %lu", read_leb128 (data, &bytes_read, 0));
7492 case DW_OP_deref_size:
7493 printf ("DW_OP_deref_size: %ld", (long) byte_get (data++, 1));
7495 case DW_OP_xderef_size:
7496 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data++, 1));
7499 printf ("DW_OP_nop");
7502 /* DWARF 3 extensions. */
7503 case DW_OP_push_object_address:
7504 printf ("DW_OP_push_object_address");
7507 printf ("DW_OP_call2: <%lx>", (long) byte_get (data, 2));
7511 printf ("DW_OP_call4: <%lx>", (long) byte_get (data, 4));
7514 case DW_OP_call_ref:
7515 printf ("DW_OP_call_ref");
7518 /* GNU extensions. */
7519 case DW_OP_GNU_push_tls_address:
7520 printf ("DW_OP_GNU_push_tls_address");
7524 if (op >= DW_OP_lo_user
7525 && op <= DW_OP_hi_user)
7526 printf (_("(User defined location op)"));
7528 printf (_("(Unknown location op)"));
7529 /* No way to tell where the next op is, so just bail. */
7533 /* Separate the ops. */
7538 static const char *debug_loc_contents;
7539 static bfd_vma debug_loc_size;
7542 load_debug_loc (file)
7545 Elf_Internal_Shdr *sec;
7548 /* If it is already loaded, do nothing. */
7549 if (debug_loc_contents != NULL)
7552 /* Locate the .debug_loc section. */
7553 for (i = 0, sec = section_headers;
7554 i < elf_header.e_shnum;
7556 if (strcmp (SECTION_NAME (sec), ".debug_loc") == 0)
7559 if (i == elf_header.e_shnum || sec->sh_size == 0)
7562 debug_loc_size = sec->sh_size;
7564 debug_loc_contents = ((char *)
7565 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7566 _("debug_loc section data")));
7572 if (debug_loc_contents == NULL)
7575 free ((char *) debug_loc_contents);
7576 debug_loc_contents = NULL;
7582 display_debug_loc (section, start, file)
7583 Elf_Internal_Shdr *section;
7584 unsigned char *start;
7585 FILE *file ATTRIBUTE_UNUSED;
7587 unsigned char *section_end;
7588 unsigned long bytes;
7589 unsigned char *section_begin = start;
7592 addr = section->sh_addr;
7593 bytes = section->sh_size;
7594 section_end = start + bytes;
7598 printf (_("\nThe .debug_loc section is empty.\n"));
7602 printf (_("Contents of the .debug_loc section:\n\n"));
7603 printf (_("\n Offset Begin End Expression\n"));
7605 while (start < section_end)
7607 unsigned long begin;
7609 unsigned short length;
7610 unsigned long offset;
7612 offset = start - section_begin;
7616 /* Normally, the lists in the debug_loc section are related to a
7617 given compilation unit, and thus, we would use the
7618 pointer size of that compilation unit. However, since we are
7619 displaying it seperately here, we either have to store
7620 pointer sizes of all compilation units, or assume they don't
7621 change. We assume, like the debug_line display, that
7622 it doesn't change. */
7623 begin = byte_get (start, debug_line_pointer_size);
7624 start += debug_line_pointer_size;
7625 end = byte_get (start, debug_line_pointer_size);
7626 start += debug_line_pointer_size;
7628 if (begin == 0 && end == 0)
7634 length = byte_get (start, 2);
7637 printf (" %8.8lx %8.8lx %8.8lx (", offset, begin, end);
7638 decode_location_expression (start, debug_line_pointer_size, length);
7648 static const char *debug_str_contents;
7649 static bfd_vma debug_str_size;
7652 load_debug_str (file)
7655 Elf_Internal_Shdr *sec;
7658 /* If it is already loaded, do nothing. */
7659 if (debug_str_contents != NULL)
7662 /* Locate the .debug_str section. */
7663 for (i = 0, sec = section_headers;
7664 i < elf_header.e_shnum;
7666 if (strcmp (SECTION_NAME (sec), ".debug_str") == 0)
7669 if (i == elf_header.e_shnum || sec->sh_size == 0)
7672 debug_str_size = sec->sh_size;
7674 debug_str_contents = ((char *)
7675 get_data (NULL, file, sec->sh_offset, sec->sh_size,
7676 _("debug_str section data")));
7682 if (debug_str_contents == NULL)
7685 free ((char *) debug_str_contents);
7686 debug_str_contents = NULL;
7691 fetch_indirect_string (offset)
7692 unsigned long offset;
7694 if (debug_str_contents == NULL)
7695 return _("<no .debug_str section>");
7697 if (offset > debug_str_size)
7698 return _("<offset is too big>");
7700 return debug_str_contents + offset;
7704 display_debug_str (section, start, file)
7705 Elf_Internal_Shdr *section;
7706 unsigned char *start;
7707 FILE *file ATTRIBUTE_UNUSED;
7709 unsigned long bytes;
7712 addr = section->sh_addr;
7713 bytes = section->sh_size;
7717 printf (_("\nThe .debug_str section is empty.\n"));
7721 printf (_("Contents of the .debug_str section:\n\n"));
7729 lbytes = (bytes > 16 ? 16 : bytes);
7731 printf (" 0x%8.8lx ", (unsigned long) addr);
7733 for (j = 0; j < 16; j++)
7736 printf ("%2.2x", start[j]);
7744 for (j = 0; j < lbytes; j++)
7747 if (k >= ' ' && k < 0x80)
7763 static unsigned char *
7764 read_and_display_attr_value (attribute, form, data, cu_offset, pointer_size)
7765 unsigned long attribute;
7767 unsigned char *data;
7768 unsigned long cu_offset;
7769 unsigned long pointer_size;
7771 unsigned long uvalue = 0;
7772 unsigned char *block_start = NULL;
7780 case DW_FORM_ref_addr:
7782 uvalue = byte_get (data, pointer_size);
7783 data += pointer_size;
7787 uvalue = byte_get (data, /* offset_size */ 4);
7788 data += /* offset_size */ 4;
7794 uvalue = byte_get (data++, 1);
7799 uvalue = byte_get (data, 2);
7805 uvalue = byte_get (data, 4);
7810 uvalue = read_leb128 (data, & bytes_read, 1);
7814 case DW_FORM_ref_udata:
7816 uvalue = read_leb128 (data, & bytes_read, 0);
7820 case DW_FORM_indirect:
7821 form = read_leb128 (data, & bytes_read, 0);
7823 printf (" %s", get_FORM_name (form));
7824 return read_and_display_attr_value (attribute, form, data, cu_offset,
7830 case DW_FORM_ref_addr:
7831 printf (" <#%lx>", uvalue);
7837 case DW_FORM_ref_udata:
7838 printf (" <%lx>", uvalue + cu_offset);
7842 printf (" %#lx", uvalue);
7850 printf (" %ld", uvalue);
7855 uvalue = byte_get (data, 4);
7856 printf (" %lx", uvalue);
7857 printf (" %lx", (unsigned long) byte_get (data + 4, 4));
7861 case DW_FORM_string:
7862 printf (" %s", data);
7863 data += strlen ((char *) data) + 1;
7867 uvalue = read_leb128 (data, & bytes_read, 0);
7868 block_start = data + bytes_read;
7869 data = display_block (block_start, uvalue);
7872 case DW_FORM_block1:
7873 uvalue = byte_get (data, 1);
7874 block_start = data + 1;
7875 data = display_block (block_start, uvalue);
7878 case DW_FORM_block2:
7879 uvalue = byte_get (data, 2);
7880 block_start = data + 2;
7881 data = display_block (block_start, uvalue);
7884 case DW_FORM_block4:
7885 uvalue = byte_get (data, 4);
7886 block_start = data + 4;
7887 data = display_block (block_start, uvalue);
7891 printf (_(" (indirect string, offset: 0x%lx): %s"),
7892 uvalue, fetch_indirect_string (uvalue));
7895 case DW_FORM_indirect:
7896 /* Handled above. */
7900 warn (_("Unrecognized form: %d\n"), form);
7904 /* For some attributes we can display futher information. */
7913 case DW_INL_not_inlined:
7914 printf (_("(not inlined)"));
7916 case DW_INL_inlined:
7917 printf (_("(inlined)"));
7919 case DW_INL_declared_not_inlined:
7920 printf (_("(declared as inline but ignored)"));
7922 case DW_INL_declared_inlined:
7923 printf (_("(declared as inline and inlined)"));
7926 printf (_(" (Unknown inline attribute value: %lx)"), uvalue);
7931 case DW_AT_language:
7934 case DW_LANG_C: printf ("(non-ANSI C)"); break;
7935 case DW_LANG_C89: printf ("(ANSI C)"); break;
7936 case DW_LANG_C_plus_plus: printf ("(C++)"); break;
7937 case DW_LANG_Fortran77: printf ("(FORTRAN 77)"); break;
7938 case DW_LANG_Fortran90: printf ("(Fortran 90)"); break;
7939 case DW_LANG_Modula2: printf ("(Modula 2)"); break;
7940 case DW_LANG_Pascal83: printf ("(ANSI Pascal)"); break;
7941 case DW_LANG_Ada83: printf ("(Ada)"); break;
7942 case DW_LANG_Cobol74: printf ("(Cobol 74)"); break;
7943 case DW_LANG_Cobol85: printf ("(Cobol 85)"); break;
7944 /* DWARF 2.1 values. */
7945 case DW_LANG_C99: printf ("(ANSI C99)"); break;
7946 case DW_LANG_Ada95: printf ("(ADA 95)"); break;
7947 case DW_LANG_Fortran95: printf ("(Fortran 95)"); break;
7948 /* MIPS extension. */
7949 case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break;
7950 /* UPC extension. */
7951 case DW_LANG_Upc: printf ("(Unified Parallel C)"); break;
7953 printf ("(Unknown: %lx)", uvalue);
7958 case DW_AT_encoding:
7961 case DW_ATE_void: printf ("(void)"); break;
7962 case DW_ATE_address: printf ("(machine address)"); break;
7963 case DW_ATE_boolean: printf ("(boolean)"); break;
7964 case DW_ATE_complex_float: printf ("(complex float)"); break;
7965 case DW_ATE_float: printf ("(float)"); break;
7966 case DW_ATE_signed: printf ("(signed)"); break;
7967 case DW_ATE_signed_char: printf ("(signed char)"); break;
7968 case DW_ATE_unsigned: printf ("(unsigned)"); break;
7969 case DW_ATE_unsigned_char: printf ("(unsigned char)"); break;
7970 /* DWARF 2.1 value. */
7971 case DW_ATE_imaginary_float: printf ("(imaginary float)"); break;
7973 if (uvalue >= DW_ATE_lo_user
7974 && uvalue <= DW_ATE_hi_user)
7975 printf ("(user defined type)");
7977 printf ("(unknown type)");
7982 case DW_AT_accessibility:
7985 case DW_ACCESS_public: printf ("(public)"); break;
7986 case DW_ACCESS_protected: printf ("(protected)"); break;
7987 case DW_ACCESS_private: printf ("(private)"); break;
7989 printf ("(unknown accessibility)");
7994 case DW_AT_visibility:
7997 case DW_VIS_local: printf ("(local)"); break;
7998 case DW_VIS_exported: printf ("(exported)"); break;
7999 case DW_VIS_qualified: printf ("(qualified)"); break;
8000 default: printf ("(unknown visibility)"); break;
8004 case DW_AT_virtuality:
8007 case DW_VIRTUALITY_none: printf ("(none)"); break;
8008 case DW_VIRTUALITY_virtual: printf ("(virtual)"); break;
8009 case DW_VIRTUALITY_pure_virtual:printf ("(pure_virtual)"); break;
8010 default: printf ("(unknown virtuality)"); break;
8014 case DW_AT_identifier_case:
8017 case DW_ID_case_sensitive: printf ("(case_sensitive)"); break;
8018 case DW_ID_up_case: printf ("(up_case)"); break;
8019 case DW_ID_down_case: printf ("(down_case)"); break;
8020 case DW_ID_case_insensitive: printf ("(case_insensitive)"); break;
8021 default: printf ("(unknown case)"); break;
8025 case DW_AT_calling_convention:
8028 case DW_CC_normal: printf ("(normal)"); break;
8029 case DW_CC_program: printf ("(program)"); break;
8030 case DW_CC_nocall: printf ("(nocall)"); break;
8032 if (uvalue >= DW_CC_lo_user
8033 && uvalue <= DW_CC_hi_user)
8034 printf ("(user defined)");
8036 printf ("(unknown convention)");
8040 case DW_AT_ordering:
8043 case -1: printf ("(undefined)"); break;
8044 case 0: printf ("(row major)"); break;
8045 case 1: printf ("(column major)"); break;
8049 case DW_AT_frame_base:
8050 case DW_AT_location:
8051 case DW_AT_data_member_location:
8052 case DW_AT_vtable_elem_location:
8053 case DW_AT_allocated:
8054 case DW_AT_associated:
8055 case DW_AT_data_location:
8057 case DW_AT_upper_bound:
8058 case DW_AT_lower_bound:
8062 decode_location_expression (block_start, pointer_size, uvalue);
8065 else if (form == DW_FORM_data4)
8068 printf ("location list");
8080 static unsigned char *
8081 read_and_display_attr (attribute, form, data, cu_offset, pointer_size)
8082 unsigned long attribute;
8084 unsigned char *data;
8085 unsigned long cu_offset;
8086 unsigned long pointer_size;
8088 printf (" %-18s:", get_AT_name (attribute));
8089 data = read_and_display_attr_value (attribute, form, data, cu_offset,
8096 display_debug_info (section, start, file)
8097 Elf_Internal_Shdr *section;
8098 unsigned char *start;
8101 unsigned char *end = start + section->sh_size;
8102 unsigned char *section_begin = start;
8104 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8106 load_debug_str (file);
8107 load_debug_loc (file);
8111 DWARF2_External_CompUnit *external;
8112 DWARF2_Internal_CompUnit compunit;
8113 Elf_Internal_Shdr *relsec;
8114 unsigned char *tags;
8117 unsigned long cu_offset;
8119 external = (DWARF2_External_CompUnit *) start;
8121 compunit.cu_length = BYTE_GET (external->cu_length);
8122 compunit.cu_version = BYTE_GET (external->cu_version);
8123 compunit.cu_abbrev_offset = BYTE_GET (external->cu_abbrev_offset);
8124 compunit.cu_pointer_size = BYTE_GET (external->cu_pointer_size);
8126 if (compunit.cu_length == 0xffffffff)
8128 warn (_("64-bit DWARF debug info is not supported yet.\n"));
8132 /* Check for RELA relocations in the
8133 abbrev_offset address, and apply them. */
8134 for (relsec = section_headers;
8135 relsec < section_headers + elf_header.e_shnum;
8138 unsigned long nrelas;
8139 Elf_Internal_Rela *rela, *rp;
8140 Elf_Internal_Shdr *symsec;
8141 Elf_Internal_Sym *symtab;
8142 Elf_Internal_Sym *sym;
8144 if (relsec->sh_type != SHT_RELA
8145 || SECTION_HEADER (relsec->sh_info) != section
8146 || relsec->sh_size == 0)
8149 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8153 symsec = SECTION_HEADER (relsec->sh_link);
8154 symtab = GET_ELF_SYMBOLS (file, symsec);
8156 for (rp = rela; rp < rela + nrelas; ++rp)
8159 != (bfd_vma) ((unsigned char *) &external->cu_abbrev_offset
8165 sym = symtab + ELF32_R_SYM (rp->r_info);
8167 if (ELF32_R_SYM (rp->r_info) != 0
8168 && ELF32_ST_TYPE (sym->st_info) != STT_SECTION)
8170 warn (_("Skipping unexpected symbol type %u\n"),
8171 ELF32_ST_TYPE (sym->st_info));
8177 sym = symtab + ELF64_R_SYM (rp->r_info);
8179 if (ELF64_R_SYM (rp->r_info) != 0
8180 && ELF64_ST_TYPE (sym->st_info) != STT_SECTION)
8182 warn (_("Skipping unexpected symbol type %u\n"),
8183 ELF64_ST_TYPE (sym->st_info));
8188 compunit.cu_abbrev_offset = rp->r_addend;
8196 tags = start + sizeof (*external);
8197 cu_offset = start - section_begin;
8198 start += compunit.cu_length + sizeof (external->cu_length);
8200 printf (_(" Compilation Unit @ %lx:\n"), cu_offset);
8201 printf (_(" Length: %ld\n"), compunit.cu_length);
8202 printf (_(" Version: %d\n"), compunit.cu_version);
8203 printf (_(" Abbrev Offset: %ld\n"), compunit.cu_abbrev_offset);
8204 printf (_(" Pointer Size: %d\n"), compunit.cu_pointer_size);
8206 if (compunit.cu_version != 2)
8208 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
8214 /* Read in the abbrevs used by this compilation unit. */
8216 Elf_Internal_Shdr *sec;
8217 unsigned char *begin;
8219 /* Locate the .debug_abbrev section and process it. */
8220 for (i = 0, sec = section_headers;
8221 i < elf_header.e_shnum;
8223 if (strcmp (SECTION_NAME (sec), ".debug_abbrev") == 0)
8226 if (i == elf_header.e_shnum || sec->sh_size == 0)
8228 warn (_("Unable to locate .debug_abbrev section!\n"));
8232 begin = ((unsigned char *)
8233 get_data (NULL, file, sec->sh_offset, sec->sh_size,
8234 _("debug_abbrev section data")));
8238 process_abbrev_section (begin + compunit.cu_abbrev_offset,
8239 begin + sec->sh_size);
8245 while (tags < start)
8248 unsigned long abbrev_number;
8249 abbrev_entry *entry;
8252 abbrev_number = read_leb128 (tags, & bytes_read, 0);
8255 /* A null DIE marks the end of a list of children. */
8256 if (abbrev_number == 0)
8262 /* Scan through the abbreviation list until we reach the
8264 for (entry = first_abbrev;
8265 entry && entry->entry != abbrev_number;
8266 entry = entry->next)
8271 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8276 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8278 (unsigned long) (tags - section_begin - bytes_read),
8280 get_TAG_name (entry->tag));
8282 for (attr = entry->first_attr; attr; attr = attr->next)
8283 tags = read_and_display_attr (attr->attribute,
8286 compunit.cu_pointer_size);
8288 if (entry->children)
8302 display_debug_aranges (section, start, file)
8303 Elf_Internal_Shdr *section;
8304 unsigned char *start;
8305 FILE *file ATTRIBUTE_UNUSED;
8307 unsigned char *end = start + section->sh_size;
8309 printf (_("The section %s contains:\n\n"), SECTION_NAME (section));
8313 DWARF2_External_ARange *external;
8314 DWARF2_Internal_ARange arange;
8315 unsigned char *ranges;
8316 unsigned long length;
8317 unsigned long address;
8320 external = (DWARF2_External_ARange *) start;
8322 arange.ar_length = BYTE_GET (external->ar_length);
8323 arange.ar_version = BYTE_GET (external->ar_version);
8324 arange.ar_info_offset = BYTE_GET (external->ar_info_offset);
8325 arange.ar_pointer_size = BYTE_GET (external->ar_pointer_size);
8326 arange.ar_segment_size = BYTE_GET (external->ar_segment_size);
8328 if (arange.ar_length == 0xffffffff)
8330 warn (_("64-bit DWARF aranges are not supported yet.\n"));
8334 if (arange.ar_version != 2)
8336 warn (_("Only DWARF 2 aranges are currently supported.\n"));
8340 printf (_(" Length: %ld\n"), arange.ar_length);
8341 printf (_(" Version: %d\n"), arange.ar_version);
8342 printf (_(" Offset into .debug_info: %lx\n"), arange.ar_info_offset);
8343 printf (_(" Pointer Size: %d\n"), arange.ar_pointer_size);
8344 printf (_(" Segment Size: %d\n"), arange.ar_segment_size);
8346 printf (_("\n Address Length\n"));
8348 ranges = start + sizeof (*external);
8350 /* Must pad to an alignment boundary that is twice the pointer size. */
8351 excess = sizeof (*external) % (2 * arange.ar_pointer_size);
8353 ranges += (2 * arange.ar_pointer_size) - excess;
8357 address = byte_get (ranges, arange.ar_pointer_size);
8359 ranges += arange.ar_pointer_size;
8361 length = byte_get (ranges, arange.ar_pointer_size);
8363 ranges += arange.ar_pointer_size;
8365 /* A pair of zeros marks the end of the list. */
8366 if (address == 0 && length == 0)
8369 printf (" %8.8lx %lu\n", address, length);
8372 start += arange.ar_length + sizeof (external->ar_length);
8380 typedef struct Frame_Chunk
8382 struct Frame_Chunk *next;
8383 unsigned char *chunk_start;
8385 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8386 short int *col_type;
8389 unsigned int code_factor;
8391 unsigned long pc_begin;
8392 unsigned long pc_range;
8396 unsigned char fde_encoding;
8400 /* A marker for a col_type that means this column was never referenced
8401 in the frame info. */
8402 #define DW_CFA_unreferenced (-1)
8404 static void frame_need_space PARAMS ((Frame_Chunk *, int));
8405 static void frame_display_row PARAMS ((Frame_Chunk *, int *, int *));
8406 static int size_of_encoded_value PARAMS ((int));
8409 frame_need_space (fc, reg)
8413 int prev = fc->ncols;
8415 if (reg < fc->ncols)
8418 fc->ncols = reg + 1;
8419 fc->col_type = (short int *) xrealloc (fc->col_type,
8420 fc->ncols * sizeof (short int));
8421 fc->col_offset = (int *) xrealloc (fc->col_offset,
8422 fc->ncols * sizeof (int));
8424 while (prev < fc->ncols)
8426 fc->col_type[prev] = DW_CFA_unreferenced;
8427 fc->col_offset[prev] = 0;
8433 frame_display_row (fc, need_col_headers, max_regs)
8435 int *need_col_headers;
8441 if (*max_regs < fc->ncols)
8442 *max_regs = fc->ncols;
8444 if (*need_col_headers)
8446 *need_col_headers = 0;
8448 printf (" LOC CFA ");
8450 for (r = 0; r < *max_regs; r++)
8451 if (fc->col_type[r] != DW_CFA_unreferenced)
8456 printf ("r%-4d", r);
8462 printf ("%08lx ", fc->pc_begin);
8463 sprintf (tmp, "r%d%+d", fc->cfa_reg, fc->cfa_offset);
8464 printf ("%-8s ", tmp);
8466 for (r = 0; r < fc->ncols; r++)
8468 if (fc->col_type[r] != DW_CFA_unreferenced)
8470 switch (fc->col_type[r])
8472 case DW_CFA_undefined:
8475 case DW_CFA_same_value:
8479 sprintf (tmp, "c%+d", fc->col_offset[r]);
8481 case DW_CFA_register:
8482 sprintf (tmp, "r%d", fc->col_offset[r]);
8485 strcpy (tmp, "n/a");
8488 printf ("%-5s", tmp);
8495 size_of_encoded_value (encoding)
8498 switch (encoding & 0x7)
8501 case 0: return is_32bit_elf ? 4 : 8;
8508 #define GET(N) byte_get (start, N); start += N
8509 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8510 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8513 display_debug_frames (section, start, file)
8514 Elf_Internal_Shdr *section;
8515 unsigned char *start;
8516 FILE *file ATTRIBUTE_UNUSED;
8518 unsigned char *end = start + section->sh_size;
8519 unsigned char *section_start = start;
8520 Frame_Chunk *chunks = 0;
8521 Frame_Chunk *remembered_state = 0;
8523 int is_eh = (strcmp (SECTION_NAME (section), ".eh_frame") == 0);
8526 int addr_size = is_32bit_elf ? 4 : 8;
8528 printf (_("The section %s contains:\n"), SECTION_NAME (section));
8532 unsigned char *saved_start;
8533 unsigned char *block_end;
8534 unsigned long length;
8535 unsigned long cie_id;
8538 int need_col_headers = 1;
8539 unsigned char *augmentation_data = NULL;
8540 unsigned long augmentation_data_len = 0;
8541 int encoded_ptr_size = addr_size;
8543 saved_start = start;
8544 length = byte_get (start, 4); start += 4;
8548 printf ("\n%08lx ZERO terminator\n\n",
8549 (unsigned long)(saved_start - section_start));
8553 if (length == 0xffffffff)
8555 warn (_("64-bit DWARF format frames are not supported yet.\n"));
8559 block_end = saved_start + length + 4;
8560 cie_id = byte_get (start, 4); start += 4;
8562 if (is_eh ? (cie_id == 0) : (cie_id == DW_CIE_ID))
8566 fc = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8567 memset (fc, 0, sizeof (Frame_Chunk));
8571 fc->chunk_start = saved_start;
8573 fc->col_type = (short int *) xmalloc (sizeof (short int));
8574 fc->col_offset = (int *) xmalloc (sizeof (int));
8575 frame_need_space (fc, max_regs-1);
8579 fc->augmentation = start;
8580 start = strchr (start, '\0') + 1;
8582 if (fc->augmentation[0] == 'z')
8584 fc->code_factor = LEB ();
8585 fc->data_factor = SLEB ();
8586 fc->ra = byte_get (start, 1); start += 1;
8587 augmentation_data_len = LEB ();
8588 augmentation_data = start;
8589 start += augmentation_data_len;
8591 else if (strcmp (fc->augmentation, "eh") == 0)
8594 fc->code_factor = LEB ();
8595 fc->data_factor = SLEB ();
8596 fc->ra = byte_get (start, 1); start += 1;
8600 fc->code_factor = LEB ();
8601 fc->data_factor = SLEB ();
8602 fc->ra = byte_get (start, 1); start += 1;
8606 if (do_debug_frames_interp)
8607 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8608 (unsigned long)(saved_start - section_start), length, cie_id,
8609 fc->augmentation, fc->code_factor, fc->data_factor,
8613 printf ("\n%08lx %08lx %08lx CIE\n",
8614 (unsigned long)(saved_start - section_start), length, cie_id);
8615 printf (" Version: %d\n", version);
8616 printf (" Augmentation: \"%s\"\n", fc->augmentation);
8617 printf (" Code alignment factor: %u\n", fc->code_factor);
8618 printf (" Data alignment factor: %d\n", fc->data_factor);
8619 printf (" Return address column: %d\n", fc->ra);
8621 if (augmentation_data_len)
8624 printf (" Augmentation data: ");
8625 for (i = 0; i < augmentation_data_len; ++i)
8626 printf (" %02x", augmentation_data[i]);
8632 if (augmentation_data_len)
8634 unsigned char *p, *q;
8635 p = fc->augmentation + 1;
8636 q = augmentation_data;
8643 q += 1 + size_of_encoded_value (*q);
8645 fc->fde_encoding = *q++;
8651 if (fc->fde_encoding)
8652 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8655 frame_need_space (fc, fc->ra);
8659 unsigned char *look_for;
8660 static Frame_Chunk fde_fc;
8663 memset (fc, 0, sizeof (Frame_Chunk));
8665 look_for = is_eh ? start - 4 - cie_id : section_start + cie_id;
8667 for (cie = chunks; cie ; cie = cie->next)
8668 if (cie->chunk_start == look_for)
8673 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8674 cie_id, saved_start);
8677 fc->col_type = (short int *) xmalloc (sizeof (short int));
8678 fc->col_offset = (int *) xmalloc (sizeof (int));
8679 frame_need_space (fc, max_regs - 1);
8681 fc->augmentation = "";
8682 fc->fde_encoding = 0;
8686 fc->ncols = cie->ncols;
8687 fc->col_type = (short int *) xmalloc (fc->ncols * sizeof (short int));
8688 fc->col_offset = (int *) xmalloc (fc->ncols * sizeof (int));
8689 memcpy (fc->col_type, cie->col_type, fc->ncols * sizeof (short int));
8690 memcpy (fc->col_offset, cie->col_offset, fc->ncols * sizeof (int));
8691 fc->augmentation = cie->augmentation;
8692 fc->code_factor = cie->code_factor;
8693 fc->data_factor = cie->data_factor;
8694 fc->cfa_reg = cie->cfa_reg;
8695 fc->cfa_offset = cie->cfa_offset;
8697 frame_need_space (fc, max_regs-1);
8698 fc->fde_encoding = cie->fde_encoding;
8701 if (fc->fde_encoding)
8702 encoded_ptr_size = size_of_encoded_value (fc->fde_encoding);
8704 fc->pc_begin = byte_get (start, encoded_ptr_size);
8705 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
8706 fc->pc_begin += section->sh_addr + (start - section_start);
8707 start += encoded_ptr_size;
8708 fc->pc_range = byte_get (start, encoded_ptr_size);
8709 start += encoded_ptr_size;
8711 if (cie->augmentation[0] == 'z')
8713 augmentation_data_len = LEB ();
8714 augmentation_data = start;
8715 start += augmentation_data_len;
8718 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8719 (unsigned long)(saved_start - section_start), length, cie_id,
8720 (unsigned long)(cie->chunk_start - section_start),
8721 fc->pc_begin, fc->pc_begin + fc->pc_range);
8722 if (! do_debug_frames_interp && augmentation_data_len)
8725 printf (" Augmentation data: ");
8726 for (i = 0; i < augmentation_data_len; ++i)
8727 printf (" %02x", augmentation_data[i]);
8733 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8734 about to interpret instructions for the chunk. */
8736 if (do_debug_frames_interp)
8738 /* Start by making a pass over the chunk, allocating storage
8739 and taking note of what registers are used. */
8740 unsigned char *tmp = start;
8742 while (start < block_end)
8752 /* Warning: if you add any more cases to this switch, be
8753 sure to add them to the corresponding switch below. */
8756 case DW_CFA_advance_loc:
8760 frame_need_space (fc, opa);
8761 fc->col_type[opa] = DW_CFA_undefined;
8763 case DW_CFA_restore:
8764 frame_need_space (fc, opa);
8765 fc->col_type[opa] = DW_CFA_undefined;
8767 case DW_CFA_set_loc:
8768 start += encoded_ptr_size;
8770 case DW_CFA_advance_loc1:
8773 case DW_CFA_advance_loc2:
8776 case DW_CFA_advance_loc4:
8779 case DW_CFA_offset_extended:
8780 reg = LEB (); LEB ();
8781 frame_need_space (fc, reg);
8782 fc->col_type[reg] = DW_CFA_undefined;
8784 case DW_CFA_restore_extended:
8786 frame_need_space (fc, reg);
8787 fc->col_type[reg] = DW_CFA_undefined;
8789 case DW_CFA_undefined:
8791 frame_need_space (fc, reg);
8792 fc->col_type[reg] = DW_CFA_undefined;
8794 case DW_CFA_same_value:
8796 frame_need_space (fc, reg);
8797 fc->col_type[reg] = DW_CFA_undefined;
8799 case DW_CFA_register:
8800 reg = LEB (); LEB ();
8801 frame_need_space (fc, reg);
8802 fc->col_type[reg] = DW_CFA_undefined;
8804 case DW_CFA_def_cfa:
8807 case DW_CFA_def_cfa_register:
8810 case DW_CFA_def_cfa_offset:
8813 case DW_CFA_offset_extended_sf:
8814 reg = LEB (); SLEB ();
8815 frame_need_space (fc, reg);
8816 fc->col_type[reg] = DW_CFA_undefined;
8818 case DW_CFA_def_cfa_sf:
8821 case DW_CFA_def_cfa_offset_sf:
8824 case DW_CFA_GNU_args_size:
8827 case DW_CFA_GNU_negative_offset_extended:
8828 reg = LEB (); LEB ();
8829 frame_need_space (fc, reg);
8830 fc->col_type[reg] = DW_CFA_undefined;
8839 /* Now we know what registers are used, make a second pass over
8840 the chunk, this time actually printing out the info. */
8842 while (start < block_end)
8845 unsigned long ul, reg, roffs;
8854 /* Warning: if you add any more cases to this switch, be
8855 sure to add them to the corresponding switch above. */
8858 case DW_CFA_advance_loc:
8859 if (do_debug_frames_interp)
8860 frame_display_row (fc, &need_col_headers, &max_regs);
8862 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8863 opa * fc->code_factor,
8864 fc->pc_begin + opa * fc->code_factor);
8865 fc->pc_begin += opa * fc->code_factor;
8870 if (! do_debug_frames_interp)
8871 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8872 opa, roffs * fc->data_factor);
8873 fc->col_type[opa] = DW_CFA_offset;
8874 fc->col_offset[opa] = roffs * fc->data_factor;
8877 case DW_CFA_restore:
8878 if (! do_debug_frames_interp)
8879 printf (" DW_CFA_restore: r%d\n", opa);
8880 fc->col_type[opa] = cie->col_type[opa];
8881 fc->col_offset[opa] = cie->col_offset[opa];
8884 case DW_CFA_set_loc:
8885 vma = byte_get (start, encoded_ptr_size);
8886 if ((fc->fde_encoding & 0x70) == DW_EH_PE_pcrel)
8887 vma += section->sh_addr + (start - section_start);
8888 start += encoded_ptr_size;
8889 if (do_debug_frames_interp)
8890 frame_display_row (fc, &need_col_headers, &max_regs);
8892 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma);
8896 case DW_CFA_advance_loc1:
8897 ofs = byte_get (start, 1); start += 1;
8898 if (do_debug_frames_interp)
8899 frame_display_row (fc, &need_col_headers, &max_regs);
8901 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8902 ofs * fc->code_factor,
8903 fc->pc_begin + ofs * fc->code_factor);
8904 fc->pc_begin += ofs * fc->code_factor;
8907 case DW_CFA_advance_loc2:
8908 ofs = byte_get (start, 2); start += 2;
8909 if (do_debug_frames_interp)
8910 frame_display_row (fc, &need_col_headers, &max_regs);
8912 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8913 ofs * fc->code_factor,
8914 fc->pc_begin + ofs * fc->code_factor);
8915 fc->pc_begin += ofs * fc->code_factor;
8918 case DW_CFA_advance_loc4:
8919 ofs = byte_get (start, 4); start += 4;
8920 if (do_debug_frames_interp)
8921 frame_display_row (fc, &need_col_headers, &max_regs);
8923 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8924 ofs * fc->code_factor,
8925 fc->pc_begin + ofs * fc->code_factor);
8926 fc->pc_begin += ofs * fc->code_factor;
8929 case DW_CFA_offset_extended:
8932 if (! do_debug_frames_interp)
8933 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8934 reg, roffs * fc->data_factor);
8935 fc->col_type[reg] = DW_CFA_offset;
8936 fc->col_offset[reg] = roffs * fc->data_factor;
8939 case DW_CFA_restore_extended:
8941 if (! do_debug_frames_interp)
8942 printf (" DW_CFA_restore_extended: r%ld\n", reg);
8943 fc->col_type[reg] = cie->col_type[reg];
8944 fc->col_offset[reg] = cie->col_offset[reg];
8947 case DW_CFA_undefined:
8949 if (! do_debug_frames_interp)
8950 printf (" DW_CFA_undefined: r%ld\n", reg);
8951 fc->col_type[reg] = DW_CFA_undefined;
8952 fc->col_offset[reg] = 0;
8955 case DW_CFA_same_value:
8957 if (! do_debug_frames_interp)
8958 printf (" DW_CFA_same_value: r%ld\n", reg);
8959 fc->col_type[reg] = DW_CFA_same_value;
8960 fc->col_offset[reg] = 0;
8963 case DW_CFA_register:
8966 if (! do_debug_frames_interp)
8967 printf (" DW_CFA_register: r%ld\n", reg);
8968 fc->col_type[reg] = DW_CFA_register;
8969 fc->col_offset[reg] = roffs;
8972 case DW_CFA_remember_state:
8973 if (! do_debug_frames_interp)
8974 printf (" DW_CFA_remember_state\n");
8975 rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk));
8976 rs->ncols = fc->ncols;
8977 rs->col_type = (short int *) xmalloc (rs->ncols * sizeof (short int));
8978 rs->col_offset = (int *) xmalloc (rs->ncols * sizeof (int));
8979 memcpy (rs->col_type, fc->col_type, rs->ncols);
8980 memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (int));
8981 rs->next = remembered_state;
8982 remembered_state = rs;
8985 case DW_CFA_restore_state:
8986 if (! do_debug_frames_interp)
8987 printf (" DW_CFA_restore_state\n");
8988 rs = remembered_state;
8989 remembered_state = rs->next;
8990 frame_need_space (fc, rs->ncols-1);
8991 memcpy (fc->col_type, rs->col_type, rs->ncols);
8992 memcpy (fc->col_offset, rs->col_offset, rs->ncols * sizeof (int));
8993 free (rs->col_type);
8994 free (rs->col_offset);
8998 case DW_CFA_def_cfa:
8999 fc->cfa_reg = LEB ();
9000 fc->cfa_offset = LEB ();
9001 if (! do_debug_frames_interp)
9002 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9003 fc->cfa_reg, fc->cfa_offset);
9006 case DW_CFA_def_cfa_register:
9007 fc->cfa_reg = LEB ();
9008 if (! do_debug_frames_interp)
9009 printf (" DW_CFA_def_cfa_reg: r%d\n", fc->cfa_reg);
9012 case DW_CFA_def_cfa_offset:
9013 fc->cfa_offset = LEB ();
9014 if (! do_debug_frames_interp)
9015 printf (" DW_CFA_def_cfa_offset: %d\n", fc->cfa_offset);
9019 if (! do_debug_frames_interp)
9020 printf (" DW_CFA_nop\n");
9023 case DW_CFA_offset_extended_sf:
9026 frame_need_space (fc, reg);
9027 if (! do_debug_frames_interp)
9028 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9029 reg, l * fc->data_factor);
9030 fc->col_type[reg] = DW_CFA_offset;
9031 fc->col_offset[reg] = l * fc->data_factor;
9034 case DW_CFA_def_cfa_sf:
9035 fc->cfa_reg = LEB ();
9036 fc->cfa_offset = SLEB ();
9037 if (! do_debug_frames_interp)
9038 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9039 fc->cfa_reg, fc->cfa_offset);
9042 case DW_CFA_def_cfa_offset_sf:
9043 fc->cfa_offset = SLEB ();
9044 if (! do_debug_frames_interp)
9045 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc->cfa_offset);
9048 case DW_CFA_GNU_window_save:
9049 if (! do_debug_frames_interp)
9050 printf (" DW_CFA_GNU_window_save\n");
9053 case DW_CFA_GNU_args_size:
9055 if (! do_debug_frames_interp)
9056 printf (" DW_CFA_GNU_args_size: %ld\n", ul);
9059 case DW_CFA_GNU_negative_offset_extended:
9062 frame_need_space (fc, reg);
9063 if (! do_debug_frames_interp)
9064 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9065 reg, l * fc->data_factor);
9066 fc->col_type[reg] = DW_CFA_offset;
9067 fc->col_offset[reg] = l * fc->data_factor;
9070 /* FIXME: How do we handle these? */
9071 case DW_CFA_def_cfa_expression:
9072 fprintf (stderr, "unsupported DW_CFA_def_cfa_expression\n");
9076 case DW_CFA_expression:
9077 fprintf (stderr, "unsupported DW_CFA_expression\n");
9082 fprintf (stderr, "unsupported or unknown DW_CFA_%d\n", op);
9087 if (do_debug_frames_interp)
9088 frame_display_row (fc, &need_col_headers, &max_regs);
9103 display_debug_not_supported (section, start, file)
9104 Elf_Internal_Shdr *section;
9105 unsigned char *start ATTRIBUTE_UNUSED;
9106 FILE *file ATTRIBUTE_UNUSED;
9108 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9109 SECTION_NAME (section));
9114 /* Pre-scan the .debug_info section to record the size of address.
9115 When dumping the .debug_line, we use that size information, assuming
9116 that all compilation units have the same address size. */
9118 prescan_debug_info (section, start, file)
9119 Elf_Internal_Shdr *section ATTRIBUTE_UNUSED;
9120 unsigned char *start;
9121 FILE *file ATTRIBUTE_UNUSED;
9123 DWARF2_External_CompUnit *external;
9125 external = (DWARF2_External_CompUnit *) start;
9127 debug_line_pointer_size = BYTE_GET (external->cu_pointer_size);
9131 /* A structure containing the name of a debug section and a pointer
9132 to a function that can decode it. The third field is a prescan
9133 function to be run over the section before displaying any of the
9137 const char *const name;
9138 int (*display) PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
9139 int (*prescan) PARAMS ((Elf_Internal_Shdr *, unsigned char *, FILE *));
9143 { ".debug_abbrev", display_debug_abbrev, NULL },
9144 { ".debug_aranges", display_debug_aranges, NULL },
9145 { ".debug_frame", display_debug_frames, NULL },
9146 { ".debug_info", display_debug_info, prescan_debug_info },
9147 { ".debug_line", display_debug_lines, NULL },
9148 { ".debug_pubnames", display_debug_pubnames, NULL },
9149 { ".eh_frame", display_debug_frames, NULL },
9150 { ".debug_macinfo", display_debug_macinfo, NULL },
9151 { ".debug_str", display_debug_str, NULL },
9152 { ".debug_loc", display_debug_loc, NULL },
9153 { ".debug_pubtypes", display_debug_not_supported, NULL },
9154 { ".debug_ranges", display_debug_not_supported, NULL },
9155 { ".debug_static_func", display_debug_not_supported, NULL },
9156 { ".debug_static_vars", display_debug_not_supported, NULL },
9157 { ".debug_types", display_debug_not_supported, NULL },
9158 { ".debug_weaknames", display_debug_not_supported, NULL }
9162 display_debug_section (section, file)
9163 Elf_Internal_Shdr *section;
9166 char *name = SECTION_NAME (section);
9167 bfd_size_type length;
9168 unsigned char *start;
9171 length = section->sh_size;
9174 printf (_("\nSection '%s' has no debugging data.\n"), name);
9178 start = (unsigned char *) get_data (NULL, file, section->sh_offset, length,
9179 _("debug section data"));
9183 /* See if we know how to display the contents of this section. */
9184 if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
9185 name = ".debug_info";
9187 for (i = NUM_ELEM (debug_displays); i--;)
9188 if (strcmp (debug_displays[i].name, name) == 0)
9190 debug_displays[i].display (section, start, file);
9195 printf (_("Unrecognized debug section: %s\n"), name);
9199 /* If we loaded in the abbrev section at some point,
9200 we must release it here. */
9207 process_section_contents (file)
9210 Elf_Internal_Shdr *section;
9216 /* Pre-scan the debug sections to find some debug information not
9217 present in some of them. For the .debug_line, we must find out the
9218 size of address (specified in .debug_info and .debug_aranges). */
9219 for (i = 0, section = section_headers;
9220 i < elf_header.e_shnum && i < num_dump_sects;
9223 char *name = SECTION_NAME (section);
9226 if (section->sh_size == 0)
9229 /* See if there is some pre-scan operation for this section. */
9230 for (j = NUM_ELEM (debug_displays); j--;)
9231 if (strcmp (debug_displays[j].name, name) == 0)
9233 if (debug_displays[j].prescan != NULL)
9235 bfd_size_type length;
9236 unsigned char *start;
9238 length = section->sh_size;
9239 start = ((unsigned char *)
9240 get_data (NULL, file, section->sh_offset, length,
9241 _("debug section data")));
9245 debug_displays[j].prescan (section, start, file);
9253 for (i = 0, section = section_headers;
9254 i < elf_header.e_shnum && i < num_dump_sects;
9257 #ifdef SUPPORT_DISASSEMBLY
9258 if (dump_sects[i] & DISASS_DUMP)
9259 disassemble_section (section, file);
9261 if (dump_sects[i] & HEX_DUMP)
9262 dump_section (section, file);
9264 if (dump_sects[i] & DEBUG_DUMP)
9265 display_debug_section (section, file);
9268 if (i < num_dump_sects)
9269 warn (_("Some sections were not dumped because they do not exist!\n"));
9275 process_mips_fpe_exception (mask)
9281 if (mask & OEX_FPU_INEX)
9282 fputs ("INEX", stdout), first = 0;
9283 if (mask & OEX_FPU_UFLO)
9284 printf ("%sUFLO", first ? "" : "|"), first = 0;
9285 if (mask & OEX_FPU_OFLO)
9286 printf ("%sOFLO", first ? "" : "|"), first = 0;
9287 if (mask & OEX_FPU_DIV0)
9288 printf ("%sDIV0", first ? "" : "|"), first = 0;
9289 if (mask & OEX_FPU_INVAL)
9290 printf ("%sINVAL", first ? "" : "|");
9293 fputs ("0", stdout);
9297 process_mips_specific (file)
9300 Elf_Internal_Dyn *entry;
9301 size_t liblist_offset = 0;
9302 size_t liblistno = 0;
9303 size_t conflictsno = 0;
9304 size_t options_offset = 0;
9305 size_t conflicts_offset = 0;
9307 /* We have a lot of special sections. Thanks SGI! */
9308 if (dynamic_segment == NULL)
9309 /* No information available. */
9312 for (entry = dynamic_segment; entry->d_tag != DT_NULL; ++entry)
9313 switch (entry->d_tag)
9315 case DT_MIPS_LIBLIST:
9316 liblist_offset = entry->d_un.d_val - loadaddr;
9318 case DT_MIPS_LIBLISTNO:
9319 liblistno = entry->d_un.d_val;
9321 case DT_MIPS_OPTIONS:
9322 options_offset = entry->d_un.d_val - loadaddr;
9324 case DT_MIPS_CONFLICT:
9325 conflicts_offset = entry->d_un.d_val - loadaddr;
9327 case DT_MIPS_CONFLICTNO:
9328 conflictsno = entry->d_un.d_val;
9334 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9336 Elf32_External_Lib *elib;
9339 elib = ((Elf32_External_Lib *)
9340 get_data (NULL, file, liblist_offset,
9341 liblistno * sizeof (Elf32_External_Lib),
9345 printf ("\nSection '.liblist' contains %lu entries:\n",
9346 (unsigned long) liblistno);
9347 fputs (" Library Time Stamp Checksum Version Flags\n",
9350 for (cnt = 0; cnt < liblistno; ++cnt)
9357 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9358 time = BYTE_GET (elib[cnt].l_time_stamp);
9359 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9360 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9361 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9363 tmp = gmtime (&time);
9364 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9365 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9366 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9368 printf ("%3lu: ", (unsigned long) cnt);
9369 print_symbol (20, dynamic_strings + liblist.l_name);
9370 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9373 if (liblist.l_flags == 0)
9384 { " EXACT_MATCH", LL_EXACT_MATCH },
9385 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9386 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9387 { " EXPORTS", LL_EXPORTS },
9388 { " DELAY_LOAD", LL_DELAY_LOAD },
9389 { " DELTA", LL_DELTA }
9391 int flags = liblist.l_flags;
9395 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
9397 if ((flags & l_flags_vals[fcnt].bit) != 0)
9399 fputs (l_flags_vals[fcnt].name, stdout);
9400 flags ^= l_flags_vals[fcnt].bit;
9403 printf (" %#x", (unsigned int) flags);
9413 if (options_offset != 0)
9415 Elf_External_Options *eopt;
9416 Elf_Internal_Shdr *sect = section_headers;
9417 Elf_Internal_Options *iopt;
9418 Elf_Internal_Options *option;
9422 /* Find the section header so that we get the size. */
9423 while (sect->sh_type != SHT_MIPS_OPTIONS)
9426 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset,
9427 sect->sh_size, _("options"));
9430 iopt = ((Elf_Internal_Options *)
9431 malloc ((sect->sh_size / sizeof (eopt)) * sizeof (*iopt)));
9434 error (_("Out of memory"));
9441 while (offset < sect->sh_size)
9443 Elf_External_Options *eoption;
9445 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9447 option->kind = BYTE_GET (eoption->kind);
9448 option->size = BYTE_GET (eoption->size);
9449 option->section = BYTE_GET (eoption->section);
9450 option->info = BYTE_GET (eoption->info);
9452 offset += option->size;
9458 printf (_("\nSection '%s' contains %d entries:\n"),
9459 SECTION_NAME (sect), cnt);
9467 switch (option->kind)
9470 /* This shouldn't happen. */
9471 printf (" NULL %d %lx", option->section, option->info);
9474 printf (" REGINFO ");
9475 if (elf_header.e_machine == EM_MIPS)
9478 Elf32_External_RegInfo *ereg;
9479 Elf32_RegInfo reginfo;
9481 ereg = (Elf32_External_RegInfo *) (option + 1);
9482 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9483 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9484 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9485 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9486 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9487 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9489 printf ("GPR %08lx GP 0x%lx\n",
9491 (unsigned long) reginfo.ri_gp_value);
9492 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9493 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9494 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9499 Elf64_External_RegInfo *ereg;
9500 Elf64_Internal_RegInfo reginfo;
9502 ereg = (Elf64_External_RegInfo *) (option + 1);
9503 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9504 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9505 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9506 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9507 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9508 reginfo.ri_gp_value = BYTE_GET8 (ereg->ri_gp_value);
9510 printf ("GPR %08lx GP 0x",
9511 reginfo.ri_gprmask);
9512 printf_vma (reginfo.ri_gp_value);
9515 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9516 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9517 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9521 case ODK_EXCEPTIONS:
9522 fputs (" EXCEPTIONS fpe_min(", stdout);
9523 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9524 fputs (") fpe_max(", stdout);
9525 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9526 fputs (")", stdout);
9528 if (option->info & OEX_PAGE0)
9529 fputs (" PAGE0", stdout);
9530 if (option->info & OEX_SMM)
9531 fputs (" SMM", stdout);
9532 if (option->info & OEX_FPDBUG)
9533 fputs (" FPDBUG", stdout);
9534 if (option->info & OEX_DISMISS)
9535 fputs (" DISMISS", stdout);
9538 fputs (" PAD ", stdout);
9539 if (option->info & OPAD_PREFIX)
9540 fputs (" PREFIX", stdout);
9541 if (option->info & OPAD_POSTFIX)
9542 fputs (" POSTFIX", stdout);
9543 if (option->info & OPAD_SYMBOL)
9544 fputs (" SYMBOL", stdout);
9547 fputs (" HWPATCH ", stdout);
9548 if (option->info & OHW_R4KEOP)
9549 fputs (" R4KEOP", stdout);
9550 if (option->info & OHW_R8KPFETCH)
9551 fputs (" R8KPFETCH", stdout);
9552 if (option->info & OHW_R5KEOP)
9553 fputs (" R5KEOP", stdout);
9554 if (option->info & OHW_R5KCVTL)
9555 fputs (" R5KCVTL", stdout);
9558 fputs (" FILL ", stdout);
9559 /* XXX Print content of info word? */
9562 fputs (" TAGS ", stdout);
9563 /* XXX Print content of info word? */
9566 fputs (" HWAND ", stdout);
9567 if (option->info & OHWA0_R4KEOP_CHECKED)
9568 fputs (" R4KEOP_CHECKED", stdout);
9569 if (option->info & OHWA0_R4KEOP_CLEAN)
9570 fputs (" R4KEOP_CLEAN", stdout);
9573 fputs (" HWOR ", stdout);
9574 if (option->info & OHWA0_R4KEOP_CHECKED)
9575 fputs (" R4KEOP_CHECKED", stdout);
9576 if (option->info & OHWA0_R4KEOP_CLEAN)
9577 fputs (" R4KEOP_CLEAN", stdout);
9580 printf (" GP_GROUP %#06lx self-contained %#06lx",
9581 option->info & OGP_GROUP,
9582 (option->info & OGP_SELF) >> 16);
9585 printf (" IDENT %#06lx self-contained %#06lx",
9586 option->info & OGP_GROUP,
9587 (option->info & OGP_SELF) >> 16);
9590 /* This shouldn't happen. */
9591 printf (" %3d ??? %d %lx",
9592 option->kind, option->section, option->info);
9596 len = sizeof (*eopt);
9597 while (len < option->size)
9598 if (((char *) option)[len] >= ' '
9599 && ((char *) option)[len] < 0x7f)
9600 printf ("%c", ((char *) option)[len++]);
9602 printf ("\\%03o", ((char *) option)[len++]);
9604 fputs ("\n", stdout);
9612 if (conflicts_offset != 0 && conflictsno != 0)
9614 Elf32_Conflict *iconf;
9617 if (dynamic_symbols == NULL)
9619 error (_("conflict list found without a dynamic symbol table"));
9623 iconf = (Elf32_Conflict *) malloc (conflictsno * sizeof (*iconf));
9626 error (_("Out of memory"));
9632 Elf32_External_Conflict *econf32;
9634 econf32 = ((Elf32_External_Conflict *)
9635 get_data (NULL, file, conflicts_offset,
9636 conflictsno * sizeof (*econf32),
9641 for (cnt = 0; cnt < conflictsno; ++cnt)
9642 iconf[cnt] = BYTE_GET (econf32[cnt]);
9648 Elf64_External_Conflict *econf64;
9650 econf64 = ((Elf64_External_Conflict *)
9651 get_data (NULL, file, conflicts_offset,
9652 conflictsno * sizeof (*econf64),
9657 for (cnt = 0; cnt < conflictsno; ++cnt)
9658 iconf[cnt] = BYTE_GET (econf64[cnt]);
9663 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9664 (long) conflictsno);
9665 puts (_(" Num: Index Value Name"));
9667 for (cnt = 0; cnt < conflictsno; ++cnt)
9669 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
9671 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
9672 print_vma (psym->st_value, FULL_HEX);
9674 print_symbol (25, dynamic_strings + psym->st_name);
9685 process_gnu_liblist (file)
9688 Elf_Internal_Shdr *section, *string_sec;
9689 Elf32_External_Lib *elib;
9697 for (i = 0, section = section_headers;
9698 i < elf_header.e_shnum;
9701 switch (section->sh_type)
9703 case SHT_GNU_LIBLIST:
9704 elib = ((Elf32_External_Lib *)
9705 get_data (NULL, file, section->sh_offset, section->sh_size,
9710 string_sec = SECTION_HEADER (section->sh_link);
9712 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9713 string_sec->sh_size,
9714 _("liblist string table"));
9717 || section->sh_entsize != sizeof (Elf32_External_Lib))
9723 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9724 SECTION_NAME (section),
9725 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9727 puts (" Library Time Stamp Checksum Version Flags");
9729 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9737 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9738 time = BYTE_GET (elib[cnt].l_time_stamp);
9739 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9740 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9741 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9743 tmp = gmtime (&time);
9744 sprintf (timebuf, "%04u-%02u-%02uT%02u:%02u:%02u",
9745 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9746 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9748 printf ("%3lu: ", (unsigned long) cnt);
9750 printf ("%-20s", strtab + liblist.l_name);
9752 printf ("%-20.20s", strtab + liblist.l_name);
9753 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9754 liblist.l_version, liblist.l_flags);
9765 get_note_type (e_type)
9768 static char buff[64];
9772 case NT_PRSTATUS: return _("NT_PRSTATUS (prstatus structure)");
9773 case NT_FPREGSET: return _("NT_FPREGSET (floating point registers)");
9774 case NT_PRPSINFO: return _("NT_PRPSINFO (prpsinfo structure)");
9775 case NT_TASKSTRUCT: return _("NT_TASKSTRUCT (task structure)");
9776 case NT_PRXFPREG: return _("NT_PRXFPREG (user_xfpregs structure)");
9777 case NT_PSTATUS: return _("NT_PSTATUS (pstatus structure)");
9778 case NT_FPREGS: return _("NT_FPREGS (floating point registers)");
9779 case NT_PSINFO: return _("NT_PSINFO (psinfo structure)");
9780 case NT_LWPSTATUS: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9781 case NT_LWPSINFO: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9782 case NT_WIN32PSTATUS: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9784 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9790 get_netbsd_elfcore_note_type (e_type)
9793 static char buff[64];
9795 if (e_type == NT_NETBSDCORE_PROCINFO)
9797 /* NetBSD core "procinfo" structure. */
9798 return _("NetBSD procinfo structure");
9801 /* As of Jan 2002 there are no other machine-independent notes
9802 defined for NetBSD core files. If the note type is less
9803 than the start of the machine-dependent note types, we don't
9806 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9808 sprintf (buff, _("Unknown note type: (0x%08x)"), e_type);
9812 switch (elf_header.e_machine)
9814 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9815 and PT_GETFPREGS == mach+2. */
9820 case EM_SPARC32PLUS:
9824 case NT_NETBSDCORE_FIRSTMACH+0:
9825 return _("PT_GETREGS (reg structure)");
9826 case NT_NETBSDCORE_FIRSTMACH+2:
9827 return _("PT_GETFPREGS (fpreg structure)");
9833 /* On all other arch's, PT_GETREGS == mach+1 and
9834 PT_GETFPREGS == mach+3. */
9838 case NT_NETBSDCORE_FIRSTMACH+1:
9839 return _("PT_GETREGS (reg structure)");
9840 case NT_NETBSDCORE_FIRSTMACH+3:
9841 return _("PT_GETFPREGS (fpreg structure)");
9847 sprintf (buff, _("PT_FIRSTMACH+%d"), e_type - NT_NETBSDCORE_FIRSTMACH);
9851 /* Note that by the ELF standard, the name field is already null byte
9852 terminated, and namesz includes the terminating null byte.
9853 I.E. the value of namesz for the name "FSF" is 4.
9855 If the value of namesz is zero, there is no name present. */
9857 process_note (pnote)
9858 Elf_Internal_Note *pnote;
9862 if (pnote->namesz == 0)
9864 /* If there is no note name, then use the default set of
9865 note type strings. */
9866 nt = get_note_type (pnote->type);
9868 else if (strncmp (pnote->namedata, "NetBSD-CORE", 11) == 0)
9870 /* NetBSD-specific core file notes. */
9871 nt = get_netbsd_elfcore_note_type (pnote->type);
9875 /* Don't recognize this note name; just use the default set of
9876 note type strings. */
9877 nt = get_note_type (pnote->type);
9880 printf (" %s\t\t0x%08lx\t%s\n",
9881 pnote->namesz ? pnote->namedata : "(NONE)",
9888 process_corefile_note_segment (file, offset, length)
9893 Elf_External_Note *pnotes;
9894 Elf_External_Note *external;
9900 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, length,
9907 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9908 (unsigned long) offset, (unsigned long) length);
9909 printf (_(" Owner\t\tData size\tDescription\n"));
9911 while (external < (Elf_External_Note *)((char *) pnotes + length))
9913 Elf_External_Note *next;
9914 Elf_Internal_Note inote;
9917 inote.type = BYTE_GET (external->type);
9918 inote.namesz = BYTE_GET (external->namesz);
9919 inote.namedata = external->name;
9920 inote.descsz = BYTE_GET (external->descsz);
9921 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9922 inote.descpos = offset + (inote.descdata - (char *) pnotes);
9924 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9926 if (((char *) next) > (((char *) pnotes) + length))
9928 warn (_("corrupt note found at offset %x into core notes\n"),
9929 ((char *) external) - ((char *) pnotes));
9930 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9931 inote.type, inote.namesz, inote.descsz);
9937 /* Verify that name is null terminated. It appears that at least
9938 one version of Linux (RedHat 6.0) generates corefiles that don't
9939 comply with the ELF spec by failing to include the null byte in
9941 if (inote.namedata[inote.namesz] != '\0')
9943 temp = malloc (inote.namesz + 1);
9947 error (_("Out of memory\n"));
9952 strncpy (temp, inote.namedata, inote.namesz);
9953 temp[inote.namesz] = 0;
9955 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9956 inote.namedata = temp;
9959 res &= process_note (& inote);
9974 process_corefile_note_segments (file)
9977 Elf_Internal_Phdr *program_headers;
9978 Elf_Internal_Phdr *segment;
9982 program_headers = (Elf_Internal_Phdr *) malloc
9983 (elf_header.e_phnum * sizeof (Elf_Internal_Phdr));
9985 if (program_headers == NULL)
9987 error (_("Out of memory\n"));
9992 i = get_32bit_program_headers (file, program_headers);
9994 i = get_64bit_program_headers (file, program_headers);
9998 free (program_headers);
10002 for (i = 0, segment = program_headers;
10003 i < elf_header.e_phnum;
10006 if (segment->p_type == PT_NOTE)
10007 res &= process_corefile_note_segment (file,
10008 (bfd_vma) segment->p_offset,
10009 (bfd_vma) segment->p_filesz);
10012 free (program_headers);
10018 process_corefile_contents (file)
10021 /* If we have not been asked to display the notes then do nothing. */
10025 /* If file is not a core file then exit. */
10026 if (elf_header.e_type != ET_CORE)
10029 /* No program headers means no NOTE segment. */
10030 if (elf_header.e_phnum == 0)
10032 printf (_("No note segments present in the core file.\n"));
10036 return process_corefile_note_segments (file);
10040 process_arch_specific (file)
10046 switch (elf_header.e_machine)
10049 case EM_MIPS_RS3_LE:
10050 return process_mips_specific (file);
10059 get_file_header (file)
10062 /* Read in the identity array. */
10063 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10066 /* Determine how to read the rest of the header. */
10067 switch (elf_header.e_ident[EI_DATA])
10069 default: /* fall through */
10070 case ELFDATANONE: /* fall through */
10071 case ELFDATA2LSB: byte_get = byte_get_little_endian; break;
10072 case ELFDATA2MSB: byte_get = byte_get_big_endian; break;
10075 /* For now we only support 32 bit and 64 bit ELF files. */
10076 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10078 /* Read in the rest of the header. */
10081 Elf32_External_Ehdr ehdr32;
10083 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10086 elf_header.e_type = BYTE_GET (ehdr32.e_type);
10087 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
10088 elf_header.e_version = BYTE_GET (ehdr32.e_version);
10089 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
10090 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
10091 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
10092 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
10093 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
10094 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10095 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
10096 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10097 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
10098 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
10102 Elf64_External_Ehdr ehdr64;
10104 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10105 we will not be able to cope with the 64bit data found in
10106 64 ELF files. Detect this now and abort before we start
10107 overwritting things. */
10108 if (sizeof (bfd_vma) < 8)
10110 error (_("This instance of readelf has been built without support for a\n\
10111 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10115 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10118 elf_header.e_type = BYTE_GET (ehdr64.e_type);
10119 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
10120 elf_header.e_version = BYTE_GET (ehdr64.e_version);
10121 elf_header.e_entry = BYTE_GET8 (ehdr64.e_entry);
10122 elf_header.e_phoff = BYTE_GET8 (ehdr64.e_phoff);
10123 elf_header.e_shoff = BYTE_GET8 (ehdr64.e_shoff);
10124 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
10125 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
10126 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10127 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
10128 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10129 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
10130 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
10133 if (elf_header.e_shoff)
10135 /* There may be some extensions in the first section header. Don't
10136 bomb if we can't read it. */
10138 get_32bit_section_headers (file, 1);
10140 get_64bit_section_headers (file, 1);
10147 process_file (file_name)
10151 struct stat statbuf;
10154 if (stat (file_name, & statbuf) < 0)
10156 error (_("Cannot stat input file %s.\n"), file_name);
10160 file = fopen (file_name, "rb");
10163 error (_("Input file %s not found.\n"), file_name);
10167 if (! get_file_header (file))
10169 error (_("%s: Failed to read file header\n"), file_name);
10174 /* Initialise per file variables. */
10175 for (i = NUM_ELEM (version_info); i--;)
10176 version_info[i] = 0;
10178 for (i = NUM_ELEM (dynamic_info); i--;)
10179 dynamic_info[i] = 0;
10181 /* Process the file. */
10183 printf (_("\nFile: %s\n"), file_name);
10185 if (! process_file_header ())
10191 if (! process_section_headers (file))
10193 /* Without loaded section headers we
10194 cannot process lots of things. */
10195 do_unwind = do_version = do_dump = do_arch = 0;
10197 if (! do_using_dynamic)
10198 do_syms = do_reloc = 0;
10201 if (process_program_headers (file))
10202 process_dynamic_segment (file);
10204 process_relocs (file);
10206 process_unwind (file);
10208 process_symbol_table (file);
10210 process_syminfo (file);
10212 process_version_sections (file);
10214 process_section_contents (file);
10216 process_corefile_contents (file);
10218 process_gnu_liblist (file);
10220 process_arch_specific (file);
10224 if (section_headers)
10226 free (section_headers);
10227 section_headers = NULL;
10232 free (string_table);
10233 string_table = NULL;
10234 string_table_length = 0;
10237 if (dynamic_strings)
10239 free (dynamic_strings);
10240 dynamic_strings = NULL;
10243 if (dynamic_symbols)
10245 free (dynamic_symbols);
10246 dynamic_symbols = NULL;
10247 num_dynamic_syms = 0;
10250 if (dynamic_syminfo)
10252 free (dynamic_syminfo);
10253 dynamic_syminfo = NULL;
10259 #ifdef SUPPORT_DISASSEMBLY
10260 /* Needed by the i386 disassembler. For extra credit, someone could
10261 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10265 print_address (unsigned int addr, FILE *outfile)
10267 fprintf (outfile,"0x%8.8x", addr);
10270 /* Needed by the i386 disassembler. */
10272 db_task_printsym (unsigned int addr)
10274 print_address (addr, stderr);
10278 int main PARAMS ((int, char **));
10286 char *cmdline_dump_sects = NULL;
10287 unsigned num_cmdline_dump_sects = 0;
10289 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10290 setlocale (LC_MESSAGES, "");
10292 #if defined (HAVE_SETLOCALE)
10293 setlocale (LC_CTYPE, "");
10295 bindtextdomain (PACKAGE, LOCALEDIR);
10296 textdomain (PACKAGE);
10298 parse_args (argc, argv);
10300 if (optind < (argc - 1))
10303 /* When processing more than one file remember the dump requests
10304 issued on command line to reset them after each file. */
10305 if (optind + 1 < argc && dump_sects != NULL)
10307 cmdline_dump_sects = malloc (num_dump_sects);
10308 if (cmdline_dump_sects == NULL)
10309 error (_("Out of memory allocating dump request table."));
10312 memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
10313 num_cmdline_dump_sects = num_dump_sects;
10318 while (optind < argc)
10320 err |= process_file (argv[optind++]);
10322 /* Reset dump requests. */
10323 if (optind < argc && dump_sects != NULL)
10325 num_dump_sects = num_cmdline_dump_sects;
10326 if (num_cmdline_dump_sects > 0)
10327 memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
10331 if (dump_sects != NULL)
10333 if (cmdline_dump_sects != NULL)
10334 free (cmdline_dump_sects);