1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
45 #include <sys/types.h>
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
63 #include "elf/dwarf2.h"
65 /* The following headers use the elf/reloc-macros.h file to
66 automatically generate relocation recognition functions
67 such as elf_mips_reloc_type() */
69 #define RELOC_MACROS_GEN_FUNC
71 #include "elf/alpha.h"
91 #include "elf/m68hc11.h"
92 #include "elf/mcore.h"
95 #include "elf/mn10200.h"
96 #include "elf/mn10300.h"
97 #include "elf/msp430.h"
101 #include "elf/ppc64.h"
102 #include "elf/s390.h"
104 #include "elf/sparc.h"
105 #include "elf/v850.h"
107 #include "elf/x86-64.h"
108 #include "elf/xstormy16.h"
110 #include "elf/iq2000.h"
111 #include "elf/xtensa.h"
117 #include "libiberty.h"
119 char *program_name
= "readelf";
120 long archive_file_offset
;
121 unsigned long archive_file_size
;
122 unsigned long dynamic_addr
;
123 bfd_size_type dynamic_size
;
124 unsigned int dynamic_nent
;
125 char *dynamic_strings
;
126 unsigned long dynamic_strings_length
;
128 unsigned long string_table_length
;
129 unsigned long num_dynamic_syms
;
130 Elf_Internal_Sym
*dynamic_symbols
;
131 Elf_Internal_Syminfo
*dynamic_syminfo
;
132 unsigned long dynamic_syminfo_offset
;
133 unsigned int dynamic_syminfo_nent
;
134 char program_interpreter
[64];
135 bfd_vma dynamic_info
[DT_JMPREL
+ 1];
136 bfd_vma version_info
[16];
137 Elf_Internal_Ehdr elf_header
;
138 Elf_Internal_Shdr
*section_headers
;
139 Elf_Internal_Phdr
*program_headers
;
140 Elf_Internal_Dyn
*dynamic_section
;
141 Elf_Internal_Shdr
*symtab_shndx_hdr
;
147 int do_section_groups
;
148 int do_full_section_name
;
151 int do_using_dynamic
;
159 int do_debug_abbrevs
;
161 int do_debug_pubnames
;
162 int do_debug_aranges
;
165 int do_debug_frames_interp
;
166 int do_debug_macinfo
;
173 int need_base_address
;
174 bfd_vma eh_addr_size
;
178 struct group_list
*next
;
179 unsigned int section_index
;
184 struct group_list
*root
;
185 unsigned int group_index
;
188 struct group
*section_groups
;
191 struct group
**section_headers_groups
;
193 /* A dynamic array of flags indicating for which sections a hex dump
194 has been requested (via the -x switch) and/or a disassembly dump
195 (via the -i switch). */
196 char *cmdline_dump_sects
= NULL
;
197 unsigned num_cmdline_dump_sects
= 0;
199 /* A dynamic array of flags indicating for which sections a dump of
200 some kind has been requested. It is reset on a per-object file
201 basis and then initialised from the cmdline_dump_sects array and
202 the results of interpreting the -w switch. */
203 char *dump_sects
= NULL
;
204 unsigned int num_dump_sects
= 0;
206 #define HEX_DUMP (1 << 0)
207 #define DISASS_DUMP (1 << 1)
208 #define DEBUG_DUMP (1 << 2)
210 /* How to rpint a vma value. */
211 typedef enum print_mode
223 static bfd_vma (*byte_get
) (unsigned char *, int);
224 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
228 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
229 ((X)->sh_name >= string_table_length \
230 ? "<corrupt>" : string_table + (X)->sh_name))
232 /* Given st_shndx I, map to section_headers index. */
233 #define SECTION_HEADER_INDEX(I) \
234 ((I) < SHN_LORESERVE \
236 : ((I) <= SHN_HIRESERVE \
238 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
240 /* Reverse of the above. */
241 #define SECTION_HEADER_NUM(N) \
242 ((N) < SHN_LORESERVE \
244 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
246 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
248 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
250 #define BYTE_GET(field) byte_get (field, sizeof (field))
252 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
254 #define GET_ELF_SYMBOLS(file, section) \
255 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
256 : get_64bit_elf_symbols (file, section))
258 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
259 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
260 already been called and verified that the string exists. */
261 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
263 /* This is just a bit of syntatic sugar. */
264 #define streq(a,b) (strcmp ((a), (b)) == 0)
265 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
268 error (const char *message
, ...)
272 va_start (args
, message
);
273 fprintf (stderr
, _("%s: Error: "), program_name
);
274 vfprintf (stderr
, message
, args
);
279 warn (const char *message
, ...)
283 va_start (args
, message
);
284 fprintf (stderr
, _("%s: Warning: "), program_name
);
285 vfprintf (stderr
, message
, args
);
290 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
297 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
299 error (_("Unable to seek to 0x%x for %s\n"),
300 archive_file_offset
+ offset
, reason
);
307 mvar
= malloc (size
);
311 error (_("Out of memory allocating 0x%x bytes for %s\n"),
317 if (fread (mvar
, size
, 1, file
) != 1)
319 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
329 byte_get_little_endian (unsigned char *field
, int size
)
337 return ((unsigned int) (field
[0]))
338 | (((unsigned int) (field
[1])) << 8);
342 /* We want to extract data from an 8 byte wide field and
343 place it into a 4 byte wide field. Since this is a little
344 endian source we can just use the 4 byte extraction code. */
348 return ((unsigned long) (field
[0]))
349 | (((unsigned long) (field
[1])) << 8)
350 | (((unsigned long) (field
[2])) << 16)
351 | (((unsigned long) (field
[3])) << 24);
355 return ((bfd_vma
) (field
[0]))
356 | (((bfd_vma
) (field
[1])) << 8)
357 | (((bfd_vma
) (field
[2])) << 16)
358 | (((bfd_vma
) (field
[3])) << 24)
359 | (((bfd_vma
) (field
[4])) << 32)
360 | (((bfd_vma
) (field
[5])) << 40)
361 | (((bfd_vma
) (field
[6])) << 48)
362 | (((bfd_vma
) (field
[7])) << 56);
365 error (_("Unhandled data length: %d\n"), size
);
371 byte_get_signed (unsigned char *field
, int size
)
373 bfd_vma x
= byte_get (field
, size
);
378 return (x
^ 0x80) - 0x80;
380 return (x
^ 0x8000) - 0x8000;
382 return (x
^ 0x80000000) - 0x80000000;
391 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
396 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
397 field
[6] = ((value
>> 24) >> 24) & 0xff;
398 field
[5] = ((value
>> 24) >> 16) & 0xff;
399 field
[4] = ((value
>> 24) >> 8) & 0xff;
402 field
[3] = (value
>> 24) & 0xff;
403 field
[2] = (value
>> 16) & 0xff;
406 field
[1] = (value
>> 8) & 0xff;
409 field
[0] = value
& 0xff;
413 error (_("Unhandled data length: %d\n"), size
);
418 #if defined BFD64 && !BFD_HOST_64BIT_LONG
420 print_dec_vma (bfd_vma vma
, int is_signed
)
426 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
435 *bufp
++ = '0' + vma
% 10;
447 print_hex_vma (bfd_vma vma
)
455 char digit
= '0' + (vma
& 0x0f);
457 digit
+= 'a' - '0' - 10;
470 /* Print a VMA value. */
472 print_vma (bfd_vma vma
, print_mode mode
)
481 return printf ("0x%8.8lx", (unsigned long) vma
);
484 return printf ("%8.8lx", (unsigned long) vma
);
488 return printf ("%5ld", (long) vma
);
492 return printf ("0x%lx", (unsigned long) vma
);
495 return printf ("%lx", (unsigned long) vma
);
498 return printf ("%ld", (unsigned long) vma
);
501 return printf ("%lu", (unsigned long) vma
);
524 #if BFD_HOST_64BIT_LONG
525 return nc
+ printf ("%lx", vma
);
527 return nc
+ print_hex_vma (vma
);
531 #if BFD_HOST_64BIT_LONG
532 return printf ("%ld", vma
);
534 return print_dec_vma (vma
, 1);
538 #if BFD_HOST_64BIT_LONG
540 return printf ("%5ld", vma
);
542 return printf ("%#lx", vma
);
545 return printf ("%5ld", _bfd_int64_low (vma
));
547 return print_hex_vma (vma
);
551 #if BFD_HOST_64BIT_LONG
552 return printf ("%lu", vma
);
554 return print_dec_vma (vma
, 0);
562 /* Display a symbol on stdout. If do_wide is not true then
563 format the symbol to be at most WIDTH characters,
564 truncating as necessary. If WIDTH is negative then
565 format the string to be exactly - WIDTH characters,
566 truncating or padding as necessary. */
569 print_symbol (int width
, const char *symbol
)
572 printf ("%s", symbol
);
574 printf ("%-*.*s", width
, width
, symbol
);
576 printf ("%-.*s", width
, symbol
);
580 byte_get_big_endian (unsigned char *field
, int size
)
588 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
592 /* Although we are extracing data from an 8 byte wide field,
593 we are returning only 4 bytes of data. */
598 return ((unsigned long) (field
[3]))
599 | (((unsigned long) (field
[2])) << 8)
600 | (((unsigned long) (field
[1])) << 16)
601 | (((unsigned long) (field
[0])) << 24);
605 return ((bfd_vma
) (field
[7]))
606 | (((bfd_vma
) (field
[6])) << 8)
607 | (((bfd_vma
) (field
[5])) << 16)
608 | (((bfd_vma
) (field
[4])) << 24)
609 | (((bfd_vma
) (field
[3])) << 32)
610 | (((bfd_vma
) (field
[2])) << 40)
611 | (((bfd_vma
) (field
[1])) << 48)
612 | (((bfd_vma
) (field
[0])) << 56);
616 error (_("Unhandled data length: %d\n"), size
);
622 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
627 field
[7] = value
& 0xff;
628 field
[6] = (value
>> 8) & 0xff;
629 field
[5] = (value
>> 16) & 0xff;
630 field
[4] = (value
>> 24) & 0xff;
635 field
[3] = value
& 0xff;
636 field
[2] = (value
>> 8) & 0xff;
640 field
[1] = value
& 0xff;
644 field
[0] = value
& 0xff;
648 error (_("Unhandled data length: %d\n"), size
);
653 /* Return a pointer to section NAME, or NULL if no such section exists. */
655 static Elf_Internal_Shdr
*
656 find_section (const char *name
)
660 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
661 if (streq (SECTION_NAME (section_headers
+ i
), name
))
662 return section_headers
+ i
;
667 /* Guess the relocation size commonly used by the specific machines. */
670 guess_is_rela (unsigned long e_machine
)
674 /* Targets that use REL relocations. */
689 /* Targets that use RELA relocations. */
704 case EM_CYGNUS_MN10200
:
706 case EM_CYGNUS_MN10300
:
753 warn (_("Don't know about relocations on this machine architecture\n"));
759 slurp_rela_relocs (FILE *file
,
760 unsigned long rel_offset
,
761 unsigned long rel_size
,
762 Elf_Internal_Rela
**relasp
,
763 unsigned long *nrelasp
)
765 Elf_Internal_Rela
*relas
;
766 unsigned long nrelas
;
771 Elf32_External_Rela
*erelas
;
773 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
777 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
779 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
783 error (_("out of memory parsing relocs"));
787 for (i
= 0; i
< nrelas
; i
++)
789 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
790 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
791 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
798 Elf64_External_Rela
*erelas
;
800 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
804 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
806 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
810 error (_("out of memory parsing relocs"));
814 for (i
= 0; i
< nrelas
; i
++)
816 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
817 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
818 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
829 slurp_rel_relocs (FILE *file
,
830 unsigned long rel_offset
,
831 unsigned long rel_size
,
832 Elf_Internal_Rela
**relsp
,
833 unsigned long *nrelsp
)
835 Elf_Internal_Rela
*rels
;
841 Elf32_External_Rel
*erels
;
843 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
847 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
849 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
853 error (_("out of memory parsing relocs"));
857 for (i
= 0; i
< nrels
; i
++)
859 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
860 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
861 rels
[i
].r_addend
= 0;
868 Elf64_External_Rel
*erels
;
870 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
874 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
876 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
880 error (_("out of memory parsing relocs"));
884 for (i
= 0; i
< nrels
; i
++)
886 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
887 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
888 rels
[i
].r_addend
= 0;
898 /* Display the contents of the relocation data found at the specified
902 dump_relocations (FILE *file
,
903 unsigned long rel_offset
,
904 unsigned long rel_size
,
905 Elf_Internal_Sym
*symtab
,
908 unsigned long strtablen
,
912 Elf_Internal_Rela
*rels
;
915 if (is_rela
== UNKNOWN
)
916 is_rela
= guess_is_rela (elf_header
.e_machine
);
920 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
925 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
934 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
936 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
941 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
943 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
951 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
953 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
958 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
960 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
964 for (i
= 0; i
< rel_size
; i
++)
967 const char *rtype2
= NULL
;
968 const char *rtype3
= NULL
;
971 bfd_vma symtab_index
;
976 offset
= rels
[i
].r_offset
;
977 info
= rels
[i
].r_info
;
981 type
= ELF32_R_TYPE (info
);
982 symtab_index
= ELF32_R_SYM (info
);
986 /* The #ifdef BFD64 below is to prevent a compile time warning.
987 We know that if we do not have a 64 bit data type that we
988 will never execute this code anyway. */
990 if (elf_header
.e_machine
== EM_MIPS
)
992 /* In little-endian objects, r_info isn't really a 64-bit
993 little-endian value: it has a 32-bit little-endian
994 symbol index followed by four individual byte fields.
995 Reorder INFO accordingly. */
996 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
997 info
= (((info
& 0xffffffff) << 32)
998 | ((info
>> 56) & 0xff)
999 | ((info
>> 40) & 0xff00)
1000 | ((info
>> 24) & 0xff0000)
1001 | ((info
>> 8) & 0xff000000));
1002 type
= ELF64_MIPS_R_TYPE (info
);
1003 type2
= ELF64_MIPS_R_TYPE2 (info
);
1004 type3
= ELF64_MIPS_R_TYPE3 (info
);
1006 else if (elf_header
.e_machine
== EM_SPARCV9
)
1007 type
= ELF64_R_TYPE_ID (info
);
1009 type
= ELF64_R_TYPE (info
);
1011 symtab_index
= ELF64_R_SYM (info
);
1017 #ifdef _bfd_int64_low
1018 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1020 printf ("%8.8lx %8.8lx ", offset
, info
);
1025 #ifdef _bfd_int64_low
1027 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1028 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1029 _bfd_int64_high (offset
),
1030 _bfd_int64_low (offset
),
1031 _bfd_int64_high (info
),
1032 _bfd_int64_low (info
));
1035 ? "%16.16lx %16.16lx "
1036 : "%12.12lx %12.12lx ",
1041 switch (elf_header
.e_machine
)
1048 case EM_CYGNUS_M32R
:
1049 rtype
= elf_m32r_reloc_type (type
);
1054 rtype
= elf_i386_reloc_type (type
);
1059 rtype
= elf_m68hc11_reloc_type (type
);
1063 rtype
= elf_m68k_reloc_type (type
);
1067 rtype
= elf_i960_reloc_type (type
);
1072 rtype
= elf_avr_reloc_type (type
);
1075 case EM_OLD_SPARCV9
:
1076 case EM_SPARC32PLUS
:
1079 rtype
= elf_sparc_reloc_type (type
);
1083 case EM_CYGNUS_V850
:
1084 rtype
= v850_reloc_type (type
);
1088 case EM_CYGNUS_D10V
:
1089 rtype
= elf_d10v_reloc_type (type
);
1093 case EM_CYGNUS_D30V
:
1094 rtype
= elf_d30v_reloc_type (type
);
1098 rtype
= elf_dlx_reloc_type (type
);
1102 rtype
= elf_sh_reloc_type (type
);
1106 case EM_CYGNUS_MN10300
:
1107 rtype
= elf_mn10300_reloc_type (type
);
1111 case EM_CYGNUS_MN10200
:
1112 rtype
= elf_mn10200_reloc_type (type
);
1116 case EM_CYGNUS_FR30
:
1117 rtype
= elf_fr30_reloc_type (type
);
1121 rtype
= elf_frv_reloc_type (type
);
1125 rtype
= elf_mcore_reloc_type (type
);
1129 rtype
= elf_mmix_reloc_type (type
);
1134 rtype
= elf_msp430_reloc_type (type
);
1138 rtype
= elf_ppc_reloc_type (type
);
1142 rtype
= elf_ppc64_reloc_type (type
);
1146 case EM_MIPS_RS3_LE
:
1147 rtype
= elf_mips_reloc_type (type
);
1150 rtype2
= elf_mips_reloc_type (type2
);
1151 rtype3
= elf_mips_reloc_type (type3
);
1156 rtype
= elf_alpha_reloc_type (type
);
1160 rtype
= elf_arm_reloc_type (type
);
1164 rtype
= elf_arc_reloc_type (type
);
1168 rtype
= elf_hppa_reloc_type (type
);
1174 rtype
= elf_h8_reloc_type (type
);
1179 rtype
= elf_or32_reloc_type (type
);
1184 rtype
= elf_pj_reloc_type (type
);
1187 rtype
= elf_ia64_reloc_type (type
);
1191 rtype
= elf_cris_reloc_type (type
);
1195 rtype
= elf_i860_reloc_type (type
);
1199 rtype
= elf_x86_64_reloc_type (type
);
1203 rtype
= i370_reloc_type (type
);
1208 rtype
= elf_s390_reloc_type (type
);
1212 rtype
= elf_xstormy16_reloc_type (type
);
1216 rtype
= elf_crx_reloc_type (type
);
1220 rtype
= elf_vax_reloc_type (type
);
1225 rtype
= elf_ip2k_reloc_type (type
);
1229 rtype
= elf_iq2000_reloc_type (type
);
1234 rtype
= elf_xtensa_reloc_type (type
);
1239 #ifdef _bfd_int64_low
1240 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1242 printf (_("unrecognized: %-7lx"), type
);
1245 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1249 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1250 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1253 Elf_Internal_Sym
*psym
;
1255 psym
= symtab
+ symtab_index
;
1258 print_vma (psym
->st_value
, LONG_HEX
);
1259 printf (is_32bit_elf
? " " : " ");
1261 if (psym
->st_name
== 0)
1263 const char *sec_name
= "<null>";
1266 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1268 bfd_vma sec_index
= (bfd_vma
) -1;
1270 if (psym
->st_shndx
< SHN_LORESERVE
)
1271 sec_index
= psym
->st_shndx
;
1272 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1273 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1276 if (sec_index
!= (bfd_vma
) -1)
1277 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1278 else if (psym
->st_shndx
== SHN_ABS
)
1280 else if (psym
->st_shndx
== SHN_COMMON
)
1281 sec_name
= "COMMON";
1282 else if (elf_header
.e_machine
== EM_IA_64
1283 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1284 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1285 sec_name
= "ANSI_COM";
1288 sprintf (name_buf
, "<section 0x%x>",
1289 (unsigned int) psym
->st_shndx
);
1290 sec_name
= name_buf
;
1293 print_symbol (22, sec_name
);
1295 else if (strtab
== NULL
)
1296 printf (_("<string table index: %3ld>"), psym
->st_name
);
1297 else if (psym
->st_name
> strtablen
)
1298 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1300 print_symbol (22, strtab
+ psym
->st_name
);
1303 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1308 printf ("%*c", is_32bit_elf
?
1309 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1310 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1313 if (elf_header
.e_machine
== EM_SPARCV9
1314 && streq (rtype
, "R_SPARC_OLO10"))
1315 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1319 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1321 printf (" Type2: ");
1324 #ifdef _bfd_int64_low
1325 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1327 printf (_("unrecognized: %-7lx"), type2
);
1330 printf ("%-17.17s", rtype2
);
1332 printf ("\n Type3: ");
1335 #ifdef _bfd_int64_low
1336 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1338 printf (_("unrecognized: %-7lx"), type3
);
1341 printf ("%-17.17s", rtype3
);
1353 get_mips_dynamic_type (unsigned long type
)
1357 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1358 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1359 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1360 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1361 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1362 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1363 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1364 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1365 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1366 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1367 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1368 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1369 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1370 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1371 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1372 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1373 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1374 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1375 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1376 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1377 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1378 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1379 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1380 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1381 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1382 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1383 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1384 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1385 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1386 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1387 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1388 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1389 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1390 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1391 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1392 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1393 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1394 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1395 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1396 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1397 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1398 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1399 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1406 get_sparc64_dynamic_type (unsigned long type
)
1410 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1417 get_ppc64_dynamic_type (unsigned long type
)
1421 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1422 case DT_PPC64_OPD
: return "PPC64_OPD";
1423 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1430 get_parisc_dynamic_type (unsigned long type
)
1434 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1435 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1436 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1437 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1438 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1439 case DT_HP_PREINIT
: return "HP_PREINIT";
1440 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1441 case DT_HP_NEEDED
: return "HP_NEEDED";
1442 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1443 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1444 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1445 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1446 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1453 get_ia64_dynamic_type (unsigned long type
)
1457 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1464 get_dynamic_type (unsigned long type
)
1466 static char buff
[64];
1470 case DT_NULL
: return "NULL";
1471 case DT_NEEDED
: return "NEEDED";
1472 case DT_PLTRELSZ
: return "PLTRELSZ";
1473 case DT_PLTGOT
: return "PLTGOT";
1474 case DT_HASH
: return "HASH";
1475 case DT_STRTAB
: return "STRTAB";
1476 case DT_SYMTAB
: return "SYMTAB";
1477 case DT_RELA
: return "RELA";
1478 case DT_RELASZ
: return "RELASZ";
1479 case DT_RELAENT
: return "RELAENT";
1480 case DT_STRSZ
: return "STRSZ";
1481 case DT_SYMENT
: return "SYMENT";
1482 case DT_INIT
: return "INIT";
1483 case DT_FINI
: return "FINI";
1484 case DT_SONAME
: return "SONAME";
1485 case DT_RPATH
: return "RPATH";
1486 case DT_SYMBOLIC
: return "SYMBOLIC";
1487 case DT_REL
: return "REL";
1488 case DT_RELSZ
: return "RELSZ";
1489 case DT_RELENT
: return "RELENT";
1490 case DT_PLTREL
: return "PLTREL";
1491 case DT_DEBUG
: return "DEBUG";
1492 case DT_TEXTREL
: return "TEXTREL";
1493 case DT_JMPREL
: return "JMPREL";
1494 case DT_BIND_NOW
: return "BIND_NOW";
1495 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1496 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1497 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1498 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1499 case DT_RUNPATH
: return "RUNPATH";
1500 case DT_FLAGS
: return "FLAGS";
1502 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1503 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1505 case DT_CHECKSUM
: return "CHECKSUM";
1506 case DT_PLTPADSZ
: return "PLTPADSZ";
1507 case DT_MOVEENT
: return "MOVEENT";
1508 case DT_MOVESZ
: return "MOVESZ";
1509 case DT_FEATURE
: return "FEATURE";
1510 case DT_POSFLAG_1
: return "POSFLAG_1";
1511 case DT_SYMINSZ
: return "SYMINSZ";
1512 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1514 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1515 case DT_CONFIG
: return "CONFIG";
1516 case DT_DEPAUDIT
: return "DEPAUDIT";
1517 case DT_AUDIT
: return "AUDIT";
1518 case DT_PLTPAD
: return "PLTPAD";
1519 case DT_MOVETAB
: return "MOVETAB";
1520 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1522 case DT_VERSYM
: return "VERSYM";
1524 case DT_RELACOUNT
: return "RELACOUNT";
1525 case DT_RELCOUNT
: return "RELCOUNT";
1526 case DT_FLAGS_1
: return "FLAGS_1";
1527 case DT_VERDEF
: return "VERDEF";
1528 case DT_VERDEFNUM
: return "VERDEFNUM";
1529 case DT_VERNEED
: return "VERNEED";
1530 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1532 case DT_AUXILIARY
: return "AUXILIARY";
1533 case DT_USED
: return "USED";
1534 case DT_FILTER
: return "FILTER";
1536 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1537 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1538 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1539 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1540 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1543 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1547 switch (elf_header
.e_machine
)
1550 case EM_MIPS_RS3_LE
:
1551 result
= get_mips_dynamic_type (type
);
1554 result
= get_sparc64_dynamic_type (type
);
1557 result
= get_ppc64_dynamic_type (type
);
1560 result
= get_ia64_dynamic_type (type
);
1570 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1572 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1576 switch (elf_header
.e_machine
)
1579 result
= get_parisc_dynamic_type (type
);
1589 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1593 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1600 get_file_type (unsigned e_type
)
1602 static char buff
[32];
1606 case ET_NONE
: return _("NONE (None)");
1607 case ET_REL
: return _("REL (Relocatable file)");
1608 case ET_EXEC
: return _("EXEC (Executable file)");
1609 case ET_DYN
: return _("DYN (Shared object file)");
1610 case ET_CORE
: return _("CORE (Core file)");
1613 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1614 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1615 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1616 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1618 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1624 get_machine_name (unsigned e_machine
)
1626 static char buff
[64]; /* XXX */
1630 case EM_NONE
: return _("None");
1631 case EM_M32
: return "WE32100";
1632 case EM_SPARC
: return "Sparc";
1633 case EM_386
: return "Intel 80386";
1634 case EM_68K
: return "MC68000";
1635 case EM_88K
: return "MC88000";
1636 case EM_486
: return "Intel 80486";
1637 case EM_860
: return "Intel 80860";
1638 case EM_MIPS
: return "MIPS R3000";
1639 case EM_S370
: return "IBM System/370";
1640 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1641 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1642 case EM_PARISC
: return "HPPA";
1643 case EM_PPC_OLD
: return "Power PC (old)";
1644 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1645 case EM_960
: return "Intel 90860";
1646 case EM_PPC
: return "PowerPC";
1647 case EM_PPC64
: return "PowerPC64";
1648 case EM_V800
: return "NEC V800";
1649 case EM_FR20
: return "Fujitsu FR20";
1650 case EM_RH32
: return "TRW RH32";
1651 case EM_MCORE
: return "MCORE";
1652 case EM_ARM
: return "ARM";
1653 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1654 case EM_SH
: return "Renesas / SuperH SH";
1655 case EM_SPARCV9
: return "Sparc v9";
1656 case EM_TRICORE
: return "Siemens Tricore";
1657 case EM_ARC
: return "ARC";
1658 case EM_H8_300
: return "Renesas H8/300";
1659 case EM_H8_300H
: return "Renesas H8/300H";
1660 case EM_H8S
: return "Renesas H8S";
1661 case EM_H8_500
: return "Renesas H8/500";
1662 case EM_IA_64
: return "Intel IA-64";
1663 case EM_MIPS_X
: return "Stanford MIPS-X";
1664 case EM_COLDFIRE
: return "Motorola Coldfire";
1665 case EM_68HC12
: return "Motorola M68HC12";
1666 case EM_ALPHA
: return "Alpha";
1667 case EM_CYGNUS_D10V
:
1668 case EM_D10V
: return "d10v";
1669 case EM_CYGNUS_D30V
:
1670 case EM_D30V
: return "d30v";
1671 case EM_CYGNUS_M32R
:
1672 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1673 case EM_CYGNUS_V850
:
1674 case EM_V850
: return "NEC v850";
1675 case EM_CYGNUS_MN10300
:
1676 case EM_MN10300
: return "mn10300";
1677 case EM_CYGNUS_MN10200
:
1678 case EM_MN10200
: return "mn10200";
1679 case EM_CYGNUS_FR30
:
1680 case EM_FR30
: return "Fujitsu FR30";
1681 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1683 case EM_PJ
: return "picoJava";
1684 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1685 case EM_PCP
: return "Siemens PCP";
1686 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1687 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1688 case EM_STARCORE
: return "Motorola Star*Core processor";
1689 case EM_ME16
: return "Toyota ME16 processor";
1690 case EM_ST100
: return "STMicroelectronics ST100 processor";
1691 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1692 case EM_FX66
: return "Siemens FX66 microcontroller";
1693 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1694 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1695 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1696 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1697 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1698 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1699 case EM_SVX
: return "Silicon Graphics SVx";
1700 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1701 case EM_VAX
: return "Digital VAX";
1703 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1704 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1705 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1706 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1707 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1708 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1709 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1710 case EM_PRISM
: return "Vitesse Prism";
1711 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1713 case EM_S390
: return "IBM S/390";
1714 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1716 case EM_OR32
: return "OpenRISC";
1717 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1718 case EM_DLX
: return "OpenDLX";
1720 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1721 case EM_IQ2000
: return "Vitesse IQ2000";
1723 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1725 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1731 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1736 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1737 e_flags
&= ~ EF_ARM_EABIMASK
;
1739 /* Handle "generic" ARM flags. */
1740 if (e_flags
& EF_ARM_RELEXEC
)
1742 strcat (buf
, ", relocatable executable");
1743 e_flags
&= ~ EF_ARM_RELEXEC
;
1746 if (e_flags
& EF_ARM_HASENTRY
)
1748 strcat (buf
, ", has entry point");
1749 e_flags
&= ~ EF_ARM_HASENTRY
;
1752 /* Now handle EABI specific flags. */
1756 strcat (buf
, ", <unrecognized EABI>");
1761 case EF_ARM_EABI_VER1
:
1762 strcat (buf
, ", Version1 EABI");
1767 /* Process flags one bit at a time. */
1768 flag
= e_flags
& - e_flags
;
1773 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1774 strcat (buf
, ", sorted symbol tables");
1784 case EF_ARM_EABI_VER2
:
1785 strcat (buf
, ", Version2 EABI");
1790 /* Process flags one bit at a time. */
1791 flag
= e_flags
& - e_flags
;
1796 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1797 strcat (buf
, ", sorted symbol tables");
1800 case EF_ARM_DYNSYMSUSESEGIDX
:
1801 strcat (buf
, ", dynamic symbols use segment index");
1804 case EF_ARM_MAPSYMSFIRST
:
1805 strcat (buf
, ", mapping symbols precede others");
1815 case EF_ARM_EABI_VER3
:
1816 strcat (buf
, ", Version3 EABI");
1819 case EF_ARM_EABI_VER4
:
1820 strcat (buf
, ", Version4 EABI");
1825 /* Process flags one bit at a time. */
1826 flag
= e_flags
& - e_flags
;
1832 strcat (buf
, ", BE8");
1836 strcat (buf
, ", LE8");
1846 case EF_ARM_EABI_UNKNOWN
:
1847 strcat (buf
, ", GNU EABI");
1852 /* Process flags one bit at a time. */
1853 flag
= e_flags
& - e_flags
;
1858 case EF_ARM_INTERWORK
:
1859 strcat (buf
, ", interworking enabled");
1862 case EF_ARM_APCS_26
:
1863 strcat (buf
, ", uses APCS/26");
1866 case EF_ARM_APCS_FLOAT
:
1867 strcat (buf
, ", uses APCS/float");
1871 strcat (buf
, ", position independent");
1875 strcat (buf
, ", 8 bit structure alignment");
1878 case EF_ARM_NEW_ABI
:
1879 strcat (buf
, ", uses new ABI");
1882 case EF_ARM_OLD_ABI
:
1883 strcat (buf
, ", uses old ABI");
1886 case EF_ARM_SOFT_FLOAT
:
1887 strcat (buf
, ", software FP");
1890 case EF_ARM_VFP_FLOAT
:
1891 strcat (buf
, ", VFP");
1894 case EF_ARM_MAVERICK_FLOAT
:
1895 strcat (buf
, ", Maverick FP");
1906 strcat (buf
,", <unknown>");
1910 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1912 static char buf
[1024];
1924 decode_ARM_machine_flags (e_flags
, buf
);
1928 switch (e_flags
& EF_FRV_CPU_MASK
)
1930 case EF_FRV_CPU_GENERIC
:
1934 strcat (buf
, ", fr???");
1937 case EF_FRV_CPU_FR300
:
1938 strcat (buf
, ", fr300");
1941 case EF_FRV_CPU_FR400
:
1942 strcat (buf
, ", fr400");
1944 case EF_FRV_CPU_FR405
:
1945 strcat (buf
, ", fr405");
1948 case EF_FRV_CPU_FR450
:
1949 strcat (buf
, ", fr450");
1952 case EF_FRV_CPU_FR500
:
1953 strcat (buf
, ", fr500");
1955 case EF_FRV_CPU_FR550
:
1956 strcat (buf
, ", fr550");
1959 case EF_FRV_CPU_SIMPLE
:
1960 strcat (buf
, ", simple");
1962 case EF_FRV_CPU_TOMCAT
:
1963 strcat (buf
, ", tomcat");
1969 if (e_flags
& EF_CPU32
)
1970 strcat (buf
, ", cpu32");
1971 if (e_flags
& EF_M68000
)
1972 strcat (buf
, ", m68000");
1976 if (e_flags
& EF_PPC_EMB
)
1977 strcat (buf
, ", emb");
1979 if (e_flags
& EF_PPC_RELOCATABLE
)
1980 strcat (buf
, ", relocatable");
1982 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1983 strcat (buf
, ", relocatable-lib");
1987 case EM_CYGNUS_V850
:
1988 switch (e_flags
& EF_V850_ARCH
)
1991 strcat (buf
, ", v850e1");
1994 strcat (buf
, ", v850e");
1997 strcat (buf
, ", v850");
2000 strcat (buf
, ", unknown v850 architecture variant");
2006 case EM_CYGNUS_M32R
:
2007 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2008 strcat (buf
, ", m32r");
2013 case EM_MIPS_RS3_LE
:
2014 if (e_flags
& EF_MIPS_NOREORDER
)
2015 strcat (buf
, ", noreorder");
2017 if (e_flags
& EF_MIPS_PIC
)
2018 strcat (buf
, ", pic");
2020 if (e_flags
& EF_MIPS_CPIC
)
2021 strcat (buf
, ", cpic");
2023 if (e_flags
& EF_MIPS_UCODE
)
2024 strcat (buf
, ", ugen_reserved");
2026 if (e_flags
& EF_MIPS_ABI2
)
2027 strcat (buf
, ", abi2");
2029 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2030 strcat (buf
, ", odk first");
2032 if (e_flags
& EF_MIPS_32BITMODE
)
2033 strcat (buf
, ", 32bitmode");
2035 switch ((e_flags
& EF_MIPS_MACH
))
2037 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2038 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2039 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2040 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2041 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2042 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2043 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2044 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2045 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2046 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2048 /* We simply ignore the field in this case to avoid confusion:
2049 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2052 default: strcat (buf
, ", unknown CPU"); break;
2055 switch ((e_flags
& EF_MIPS_ABI
))
2057 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2058 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2059 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2060 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2062 /* We simply ignore the field in this case to avoid confusion:
2063 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2064 This means it is likely to be an o32 file, but not for
2067 default: strcat (buf
, ", unknown ABI"); break;
2070 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2071 strcat (buf
, ", mdmx");
2073 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2074 strcat (buf
, ", mips16");
2076 switch ((e_flags
& EF_MIPS_ARCH
))
2078 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2079 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2080 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2081 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2082 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2083 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2084 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2085 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2086 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2087 default: strcat (buf
, ", unknown ISA"); break;
2093 switch ((e_flags
& EF_SH_MACH_MASK
))
2095 case EF_SH1
: strcat (buf
, ", sh1"); break;
2096 case EF_SH2
: strcat (buf
, ", sh2"); break;
2097 case EF_SH3
: strcat (buf
, ", sh3"); break;
2098 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2099 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2100 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2101 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2102 case EF_SH4
: strcat (buf
, ", sh4"); break;
2103 case EF_SH5
: strcat (buf
, ", sh5"); break;
2104 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2105 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2106 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2107 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2108 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2109 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2110 default: strcat (buf
, ", unknown ISA"); break;
2116 if (e_flags
& EF_SPARC_32PLUS
)
2117 strcat (buf
, ", v8+");
2119 if (e_flags
& EF_SPARC_SUN_US1
)
2120 strcat (buf
, ", ultrasparcI");
2122 if (e_flags
& EF_SPARC_SUN_US3
)
2123 strcat (buf
, ", ultrasparcIII");
2125 if (e_flags
& EF_SPARC_HAL_R1
)
2126 strcat (buf
, ", halr1");
2128 if (e_flags
& EF_SPARC_LEDATA
)
2129 strcat (buf
, ", ledata");
2131 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2132 strcat (buf
, ", tso");
2134 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2135 strcat (buf
, ", pso");
2137 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2138 strcat (buf
, ", rmo");
2142 switch (e_flags
& EF_PARISC_ARCH
)
2144 case EFA_PARISC_1_0
:
2145 strcpy (buf
, ", PA-RISC 1.0");
2147 case EFA_PARISC_1_1
:
2148 strcpy (buf
, ", PA-RISC 1.1");
2150 case EFA_PARISC_2_0
:
2151 strcpy (buf
, ", PA-RISC 2.0");
2156 if (e_flags
& EF_PARISC_TRAPNIL
)
2157 strcat (buf
, ", trapnil");
2158 if (e_flags
& EF_PARISC_EXT
)
2159 strcat (buf
, ", ext");
2160 if (e_flags
& EF_PARISC_LSB
)
2161 strcat (buf
, ", lsb");
2162 if (e_flags
& EF_PARISC_WIDE
)
2163 strcat (buf
, ", wide");
2164 if (e_flags
& EF_PARISC_NO_KABP
)
2165 strcat (buf
, ", no kabp");
2166 if (e_flags
& EF_PARISC_LAZYSWAP
)
2167 strcat (buf
, ", lazyswap");
2172 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2173 strcat (buf
, ", new calling convention");
2175 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2176 strcat (buf
, ", gnu calling convention");
2180 if ((e_flags
& EF_IA_64_ABI64
))
2181 strcat (buf
, ", 64-bit");
2183 strcat (buf
, ", 32-bit");
2184 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2185 strcat (buf
, ", reduced fp model");
2186 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2187 strcat (buf
, ", no function descriptors, constant gp");
2188 else if ((e_flags
& EF_IA_64_CONS_GP
))
2189 strcat (buf
, ", constant gp");
2190 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2191 strcat (buf
, ", absolute");
2195 if ((e_flags
& EF_VAX_NONPIC
))
2196 strcat (buf
, ", non-PIC");
2197 if ((e_flags
& EF_VAX_DFLOAT
))
2198 strcat (buf
, ", D-Float");
2199 if ((e_flags
& EF_VAX_GFLOAT
))
2200 strcat (buf
, ", G-Float");
2209 get_osabi_name (unsigned int osabi
)
2211 static char buff
[32];
2215 case ELFOSABI_NONE
: return "UNIX - System V";
2216 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2217 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2218 case ELFOSABI_LINUX
: return "UNIX - Linux";
2219 case ELFOSABI_HURD
: return "GNU/Hurd";
2220 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2221 case ELFOSABI_AIX
: return "UNIX - AIX";
2222 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2223 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2224 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2225 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2226 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2227 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2228 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2229 case ELFOSABI_AROS
: return "Amiga Research OS";
2230 case ELFOSABI_STANDALONE
: return _("Standalone App");
2231 case ELFOSABI_ARM
: return "ARM";
2233 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2239 get_arm_segment_type (unsigned long type
)
2253 get_mips_segment_type (unsigned long type
)
2257 case PT_MIPS_REGINFO
:
2259 case PT_MIPS_RTPROC
:
2261 case PT_MIPS_OPTIONS
:
2271 get_parisc_segment_type (unsigned long type
)
2275 case PT_HP_TLS
: return "HP_TLS";
2276 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2277 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2278 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2279 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2280 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2281 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2282 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2283 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2284 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2285 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2286 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2287 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2288 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2297 get_ia64_segment_type (unsigned long type
)
2301 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2302 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2303 case PT_HP_TLS
: return "HP_TLS";
2304 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2305 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2306 case PT_IA_64_HP_STACK
: return "HP_STACK";
2315 get_segment_type (unsigned long p_type
)
2317 static char buff
[32];
2321 case PT_NULL
: return "NULL";
2322 case PT_LOAD
: return "LOAD";
2323 case PT_DYNAMIC
: return "DYNAMIC";
2324 case PT_INTERP
: return "INTERP";
2325 case PT_NOTE
: return "NOTE";
2326 case PT_SHLIB
: return "SHLIB";
2327 case PT_PHDR
: return "PHDR";
2328 case PT_TLS
: return "TLS";
2330 case PT_GNU_EH_FRAME
:
2331 return "GNU_EH_FRAME";
2332 case PT_GNU_STACK
: return "GNU_STACK";
2333 case PT_GNU_RELRO
: return "GNU_RELRO";
2336 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2340 switch (elf_header
.e_machine
)
2343 result
= get_arm_segment_type (p_type
);
2346 case EM_MIPS_RS3_LE
:
2347 result
= get_mips_segment_type (p_type
);
2350 result
= get_parisc_segment_type (p_type
);
2353 result
= get_ia64_segment_type (p_type
);
2363 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2365 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2369 switch (elf_header
.e_machine
)
2372 result
= get_parisc_segment_type (p_type
);
2375 result
= get_ia64_segment_type (p_type
);
2385 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2388 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2395 get_mips_section_type_name (unsigned int sh_type
)
2399 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2400 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2401 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2402 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2403 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2404 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2405 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2406 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2407 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2408 case SHT_MIPS_RELD
: return "MIPS_RELD";
2409 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2410 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2411 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2412 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2413 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2414 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2415 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2416 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2417 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2418 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2419 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2420 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2421 case SHT_MIPS_LINE
: return "MIPS_LINE";
2422 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2423 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2424 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2425 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2426 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2427 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2428 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2429 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2430 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2431 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2432 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2433 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2434 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2435 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2436 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2437 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2445 get_parisc_section_type_name (unsigned int sh_type
)
2449 case SHT_PARISC_EXT
: return "PARISC_EXT";
2450 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2451 case SHT_PARISC_DOC
: return "PARISC_DOC";
2459 get_ia64_section_type_name (unsigned int sh_type
)
2461 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2462 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2463 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2467 case SHT_IA_64_EXT
: return "IA_64_EXT";
2468 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2469 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2477 get_x86_64_section_type_name (unsigned int sh_type
)
2481 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2489 get_arm_section_type_name (unsigned int sh_type
)
2502 get_section_type_name (unsigned int sh_type
)
2504 static char buff
[32];
2508 case SHT_NULL
: return "NULL";
2509 case SHT_PROGBITS
: return "PROGBITS";
2510 case SHT_SYMTAB
: return "SYMTAB";
2511 case SHT_STRTAB
: return "STRTAB";
2512 case SHT_RELA
: return "RELA";
2513 case SHT_HASH
: return "HASH";
2514 case SHT_DYNAMIC
: return "DYNAMIC";
2515 case SHT_NOTE
: return "NOTE";
2516 case SHT_NOBITS
: return "NOBITS";
2517 case SHT_REL
: return "REL";
2518 case SHT_SHLIB
: return "SHLIB";
2519 case SHT_DYNSYM
: return "DYNSYM";
2520 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2521 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2522 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2523 case SHT_GROUP
: return "GROUP";
2524 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2525 case SHT_GNU_verdef
: return "VERDEF";
2526 case SHT_GNU_verneed
: return "VERNEED";
2527 case SHT_GNU_versym
: return "VERSYM";
2528 case 0x6ffffff0: return "VERSYM";
2529 case 0x6ffffffc: return "VERDEF";
2530 case 0x7ffffffd: return "AUXILIARY";
2531 case 0x7fffffff: return "FILTER";
2532 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2535 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2539 switch (elf_header
.e_machine
)
2542 case EM_MIPS_RS3_LE
:
2543 result
= get_mips_section_type_name (sh_type
);
2546 result
= get_parisc_section_type_name (sh_type
);
2549 result
= get_ia64_section_type_name (sh_type
);
2552 result
= get_x86_64_section_type_name (sh_type
);
2555 result
= get_arm_section_type_name (sh_type
);
2565 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2567 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2568 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2569 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2570 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2572 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2578 #define OPTION_DEBUG_DUMP 512
2580 struct option options
[] =
2582 {"all", no_argument
, 0, 'a'},
2583 {"file-header", no_argument
, 0, 'h'},
2584 {"program-headers", no_argument
, 0, 'l'},
2585 {"headers", no_argument
, 0, 'e'},
2586 {"histogram", no_argument
, 0, 'I'},
2587 {"segments", no_argument
, 0, 'l'},
2588 {"sections", no_argument
, 0, 'S'},
2589 {"section-headers", no_argument
, 0, 'S'},
2590 {"section-groups", no_argument
, 0, 'g'},
2591 {"full-section-name",no_argument
, 0, 'N'},
2592 {"symbols", no_argument
, 0, 's'},
2593 {"syms", no_argument
, 0, 's'},
2594 {"relocs", no_argument
, 0, 'r'},
2595 {"notes", no_argument
, 0, 'n'},
2596 {"dynamic", no_argument
, 0, 'd'},
2597 {"arch-specific", no_argument
, 0, 'A'},
2598 {"version-info", no_argument
, 0, 'V'},
2599 {"use-dynamic", no_argument
, 0, 'D'},
2600 {"hex-dump", required_argument
, 0, 'x'},
2601 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2602 {"unwind", no_argument
, 0, 'u'},
2603 #ifdef SUPPORT_DISASSEMBLY
2604 {"instruction-dump", required_argument
, 0, 'i'},
2607 {"version", no_argument
, 0, 'v'},
2608 {"wide", no_argument
, 0, 'W'},
2609 {"help", no_argument
, 0, 'H'},
2610 {0, no_argument
, 0, 0}
2616 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2617 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2618 fprintf (stdout
, _(" Options are:\n\
2619 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2620 -h --file-header Display the ELF file header\n\
2621 -l --program-headers Display the program headers\n\
2622 --segments An alias for --program-headers\n\
2623 -S --section-headers Display the sections' header\n\
2624 --sections An alias for --section-headers\n\
2625 -g --section-groups Display the section groups\n\
2626 -N --full-section-name\n\
2627 Display the full section name\n\
2628 -e --headers Equivalent to: -h -l -S\n\
2629 -s --syms Display the symbol table\n\
2630 --symbols An alias for --syms\n\
2631 -n --notes Display the core notes (if present)\n\
2632 -r --relocs Display the relocations (if present)\n\
2633 -u --unwind Display the unwind info (if present)\n\
2634 -d --dynamic Display the dynamic section (if present)\n\
2635 -V --version-info Display the version sections (if present)\n\
2636 -A --arch-specific Display architecture specific information (if any).\n\
2637 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2638 -x --hex-dump=<number> Dump the contents of section <number>\n\
2639 -w[liaprmfFsoR] or\n\
2640 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2641 Display the contents of DWARF2 debug sections\n"));
2642 #ifdef SUPPORT_DISASSEMBLY
2643 fprintf (stdout
, _("\
2644 -i --instruction-dump=<number>\n\
2645 Disassemble the contents of section <number>\n"));
2647 fprintf (stdout
, _("\
2648 -I --histogram Display histogram of bucket list lengths\n\
2649 -W --wide Allow output width to exceed 80 characters\n\
2650 -H --help Display this information\n\
2651 -v --version Display the version number of readelf\n"));
2652 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2657 /* Record the fact that the user wants the contents of section number
2658 SECTION to be displayed using the method(s) encoded as flags bits
2659 in TYPE. Note, TYPE can be zero if we are creating the array for
2663 request_dump (unsigned int section
, int type
)
2665 if (section
>= num_dump_sects
)
2667 char *new_dump_sects
;
2669 new_dump_sects
= calloc (section
+ 1, 1);
2671 if (new_dump_sects
== NULL
)
2672 error (_("Out of memory allocating dump request table."));
2675 /* Copy current flag settings. */
2676 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2680 dump_sects
= new_dump_sects
;
2681 num_dump_sects
= section
+ 1;
2686 dump_sects
[section
] |= type
;
2692 parse_args (int argc
, char **argv
)
2699 while ((c
= getopt_long
2700 (argc
, argv
, "ersuahnldSDAINgw::x:i:vVWH", options
, NULL
)) != EOF
)
2721 do_section_groups
++;
2729 do_section_groups
++;
2732 do_full_section_name
++;
2774 section
= strtoul (optarg
, & cp
, 0);
2775 if (! *cp
&& section
>= 0)
2777 request_dump (section
, HEX_DUMP
);
2787 unsigned int index
= 0;
2791 while (optarg
[index
])
2792 switch (optarg
[index
++])
2801 do_debug_abbrevs
= 1;
2811 do_debug_pubnames
= 1;
2815 do_debug_aranges
= 1;
2819 do_debug_ranges
= 1;
2823 do_debug_frames_interp
= 1;
2825 do_debug_frames
= 1;
2830 do_debug_macinfo
= 1;
2844 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2849 case OPTION_DEBUG_DUMP
:
2857 const char * option
;
2860 debug_dump_long_opts
;
2862 debug_dump_long_opts opts_table
[] =
2864 /* Please keep this table alpha- sorted. */
2865 { "Ranges", & do_debug_ranges
},
2866 { "abbrev", & do_debug_abbrevs
},
2867 { "aranges", & do_debug_aranges
},
2868 { "frames", & do_debug_frames
},
2869 { "frames-interp", & do_debug_frames_interp
},
2870 { "info", & do_debug_info
},
2871 { "line", & do_debug_lines
},
2872 { "loc", & do_debug_loc
},
2873 { "macro", & do_debug_macinfo
},
2874 { "pubnames", & do_debug_pubnames
},
2875 /* This entry is for compatability
2876 with earlier versions of readelf. */
2877 { "ranges", & do_debug_aranges
},
2878 { "str", & do_debug_str
},
2889 debug_dump_long_opts
* entry
;
2891 for (entry
= opts_table
; entry
->option
; entry
++)
2893 size_t len
= strlen (entry
->option
);
2895 if (strneq (p
, entry
->option
, len
)
2896 && (p
[len
] == ',' || p
[len
] == '\0'))
2898 * entry
->variable
= 1;
2900 /* The --debug-dump=frames-interp option also
2901 enables the --debug-dump=frames option. */
2902 if (do_debug_frames_interp
)
2903 do_debug_frames
= 1;
2910 if (entry
->option
== NULL
)
2912 warn (_("Unrecognized debug option '%s'\n"), p
);
2913 p
= strchr (p
, ',');
2923 #ifdef SUPPORT_DISASSEMBLY
2926 section
= strtoul (optarg
, & cp
, 0);
2927 if (! *cp
&& section
>= 0)
2929 request_dump (section
, DISASS_DUMP
);
2935 print_version (program_name
);
2945 /* xgettext:c-format */
2946 error (_("Invalid option '-%c'\n"), c
);
2953 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2954 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2955 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2956 && !do_section_groups
)
2960 warn (_("Nothing to do.\n"));
2966 get_elf_class (unsigned int elf_class
)
2968 static char buff
[32];
2972 case ELFCLASSNONE
: return _("none");
2973 case ELFCLASS32
: return "ELF32";
2974 case ELFCLASS64
: return "ELF64";
2976 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
2982 get_data_encoding (unsigned int encoding
)
2984 static char buff
[32];
2988 case ELFDATANONE
: return _("none");
2989 case ELFDATA2LSB
: return _("2's complement, little endian");
2990 case ELFDATA2MSB
: return _("2's complement, big endian");
2992 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
2997 /* Decode the data held in 'elf_header'. */
3000 process_file_header (void)
3002 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3003 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3004 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3005 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3008 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3016 printf (_("ELF Header:\n"));
3017 printf (_(" Magic: "));
3018 for (i
= 0; i
< EI_NIDENT
; i
++)
3019 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3021 printf (_(" Class: %s\n"),
3022 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3023 printf (_(" Data: %s\n"),
3024 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3025 printf (_(" Version: %d %s\n"),
3026 elf_header
.e_ident
[EI_VERSION
],
3027 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3029 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3032 printf (_(" OS/ABI: %s\n"),
3033 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3034 printf (_(" ABI Version: %d\n"),
3035 elf_header
.e_ident
[EI_ABIVERSION
]);
3036 printf (_(" Type: %s\n"),
3037 get_file_type (elf_header
.e_type
));
3038 printf (_(" Machine: %s\n"),
3039 get_machine_name (elf_header
.e_machine
));
3040 printf (_(" Version: 0x%lx\n"),
3041 (unsigned long) elf_header
.e_version
);
3043 printf (_(" Entry point address: "));
3044 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3045 printf (_("\n Start of program headers: "));
3046 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3047 printf (_(" (bytes into file)\n Start of section headers: "));
3048 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3049 printf (_(" (bytes into file)\n"));
3051 printf (_(" Flags: 0x%lx%s\n"),
3052 (unsigned long) elf_header
.e_flags
,
3053 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3054 printf (_(" Size of this header: %ld (bytes)\n"),
3055 (long) elf_header
.e_ehsize
);
3056 printf (_(" Size of program headers: %ld (bytes)\n"),
3057 (long) elf_header
.e_phentsize
);
3058 printf (_(" Number of program headers: %ld\n"),
3059 (long) elf_header
.e_phnum
);
3060 printf (_(" Size of section headers: %ld (bytes)\n"),
3061 (long) elf_header
.e_shentsize
);
3062 printf (_(" Number of section headers: %ld"),
3063 (long) elf_header
.e_shnum
);
3064 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3065 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3066 putc ('\n', stdout
);
3067 printf (_(" Section header string table index: %ld"),
3068 (long) elf_header
.e_shstrndx
);
3069 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3070 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3071 putc ('\n', stdout
);
3074 if (section_headers
!= NULL
)
3076 if (elf_header
.e_shnum
== 0)
3077 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3078 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3079 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3080 free (section_headers
);
3081 section_headers
= NULL
;
3089 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3091 Elf32_External_Phdr
*phdrs
;
3092 Elf32_External_Phdr
*external
;
3093 Elf_Internal_Phdr
*internal
;
3096 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3097 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3098 _("program headers"));
3102 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3103 i
< elf_header
.e_phnum
;
3104 i
++, internal
++, external
++)
3106 internal
->p_type
= BYTE_GET (external
->p_type
);
3107 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3108 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3109 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3110 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3111 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3112 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3113 internal
->p_align
= BYTE_GET (external
->p_align
);
3122 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3124 Elf64_External_Phdr
*phdrs
;
3125 Elf64_External_Phdr
*external
;
3126 Elf_Internal_Phdr
*internal
;
3129 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3130 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3131 _("program headers"));
3135 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3136 i
< elf_header
.e_phnum
;
3137 i
++, internal
++, external
++)
3139 internal
->p_type
= BYTE_GET (external
->p_type
);
3140 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3141 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3142 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3143 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3144 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3145 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3146 internal
->p_align
= BYTE_GET (external
->p_align
);
3154 /* Returns 1 if the program headers were read into `program_headers'. */
3157 get_program_headers (FILE *file
)
3159 Elf_Internal_Phdr
*phdrs
;
3161 /* Check cache of prior read. */
3162 if (program_headers
!= NULL
)
3165 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3169 error (_("Out of memory\n"));
3174 ? get_32bit_program_headers (file
, phdrs
)
3175 : get_64bit_program_headers (file
, phdrs
))
3177 program_headers
= phdrs
;
3185 /* Returns 1 if the program headers were loaded. */
3188 process_program_headers (FILE *file
)
3190 Elf_Internal_Phdr
*segment
;
3193 if (elf_header
.e_phnum
== 0)
3196 printf (_("\nThere are no program headers in this file.\n"));
3200 if (do_segments
&& !do_header
)
3202 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3203 printf (_("Entry point "));
3204 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3205 printf (_("\nThere are %d program headers, starting at offset "),
3206 elf_header
.e_phnum
);
3207 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3211 if (! get_program_headers (file
))
3216 if (elf_header
.e_phnum
> 1)
3217 printf (_("\nProgram Headers:\n"));
3219 printf (_("\nProgram Headers:\n"));
3223 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3226 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3230 (_(" Type Offset VirtAddr PhysAddr\n"));
3232 (_(" FileSiz MemSiz Flags Align\n"));
3239 for (i
= 0, segment
= program_headers
;
3240 i
< elf_header
.e_phnum
;
3245 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3249 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3250 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3251 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3252 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3253 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3255 (segment
->p_flags
& PF_R
? 'R' : ' '),
3256 (segment
->p_flags
& PF_W
? 'W' : ' '),
3257 (segment
->p_flags
& PF_X
? 'E' : ' '));
3258 printf ("%#lx", (unsigned long) segment
->p_align
);
3262 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3263 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3266 print_vma (segment
->p_offset
, FULL_HEX
);
3270 print_vma (segment
->p_vaddr
, FULL_HEX
);
3272 print_vma (segment
->p_paddr
, FULL_HEX
);
3275 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3276 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3279 print_vma (segment
->p_filesz
, FULL_HEX
);
3283 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3284 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3287 print_vma (segment
->p_offset
, FULL_HEX
);
3291 (segment
->p_flags
& PF_R
? 'R' : ' '),
3292 (segment
->p_flags
& PF_W
? 'W' : ' '),
3293 (segment
->p_flags
& PF_X
? 'E' : ' '));
3295 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3296 printf ("%#lx", (unsigned long) segment
->p_align
);
3299 print_vma (segment
->p_align
, PREFIX_HEX
);
3304 print_vma (segment
->p_offset
, FULL_HEX
);
3306 print_vma (segment
->p_vaddr
, FULL_HEX
);
3308 print_vma (segment
->p_paddr
, FULL_HEX
);
3310 print_vma (segment
->p_filesz
, FULL_HEX
);
3312 print_vma (segment
->p_memsz
, FULL_HEX
);
3314 (segment
->p_flags
& PF_R
? 'R' : ' '),
3315 (segment
->p_flags
& PF_W
? 'W' : ' '),
3316 (segment
->p_flags
& PF_X
? 'E' : ' '));
3317 print_vma (segment
->p_align
, HEX
);
3321 switch (segment
->p_type
)
3325 error (_("more than one dynamic segment\n"));
3327 /* Try to locate the .dynamic section. If there is
3328 a section header table, we can easily locate it. */
3329 if (section_headers
!= NULL
)
3331 Elf_Internal_Shdr
*sec
;
3333 sec
= find_section (".dynamic");
3334 if (sec
== NULL
|| sec
->sh_size
== 0)
3336 error (_("no .dynamic section in the dynamic segment"));
3340 dynamic_addr
= sec
->sh_offset
;
3341 dynamic_size
= sec
->sh_size
;
3343 if (dynamic_addr
< segment
->p_offset
3344 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3345 warn (_("the .dynamic section is not contained within the dynamic segment"));
3346 else if (dynamic_addr
> segment
->p_offset
)
3347 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3351 /* Otherwise, we can only assume that the .dynamic
3352 section is the first section in the DYNAMIC segment. */
3353 dynamic_addr
= segment
->p_offset
;
3354 dynamic_size
= segment
->p_filesz
;
3359 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3361 error (_("Unable to find program interpreter name\n"));
3364 program_interpreter
[0] = 0;
3365 fscanf (file
, "%63s", program_interpreter
);
3368 printf (_("\n [Requesting program interpreter: %s]"),
3369 program_interpreter
);
3375 putc ('\n', stdout
);
3378 if (do_segments
&& section_headers
!= NULL
)
3380 printf (_("\n Section to Segment mapping:\n"));
3381 printf (_(" Segment Sections...\n"));
3383 assert (string_table
!= NULL
);
3385 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3388 Elf_Internal_Shdr
*section
;
3390 segment
= program_headers
+ i
;
3391 section
= section_headers
;
3393 printf (" %2.2d ", i
);
3395 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3397 if (section
->sh_size
> 0
3398 /* Compare allocated sections by VMA, unallocated
3399 sections by file offset. */
3400 && (section
->sh_flags
& SHF_ALLOC
3401 ? (section
->sh_addr
>= segment
->p_vaddr
3402 && section
->sh_addr
+ section
->sh_size
3403 <= segment
->p_vaddr
+ segment
->p_memsz
)
3404 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3405 && (section
->sh_offset
+ section
->sh_size
3406 <= segment
->p_offset
+ segment
->p_filesz
)))
3407 /* .tbss is special. It doesn't contribute memory space
3408 to normal segments. */
3409 && (!((section
->sh_flags
& SHF_TLS
) != 0
3410 && section
->sh_type
== SHT_NOBITS
)
3411 || segment
->p_type
== PT_TLS
))
3412 printf ("%s ", SECTION_NAME (section
));
3423 /* Find the file offset corresponding to VMA by using the program headers. */
3426 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3428 Elf_Internal_Phdr
*seg
;
3430 if (! get_program_headers (file
))
3432 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3436 for (seg
= program_headers
;
3437 seg
< program_headers
+ elf_header
.e_phnum
;
3440 if (seg
->p_type
!= PT_LOAD
)
3443 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3444 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3445 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3448 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3455 get_32bit_section_headers (FILE *file
, unsigned int num
)
3457 Elf32_External_Shdr
*shdrs
;
3458 Elf_Internal_Shdr
*internal
;
3461 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3462 elf_header
.e_shentsize
* num
, _("section headers"));
3466 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3468 if (section_headers
== NULL
)
3470 error (_("Out of memory\n"));
3474 for (i
= 0, internal
= section_headers
;
3478 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3479 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3480 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3481 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3482 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3483 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3484 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3485 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3486 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3487 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3496 get_64bit_section_headers (FILE *file
, unsigned int num
)
3498 Elf64_External_Shdr
*shdrs
;
3499 Elf_Internal_Shdr
*internal
;
3502 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3503 elf_header
.e_shentsize
* num
, _("section headers"));
3507 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3509 if (section_headers
== NULL
)
3511 error (_("Out of memory\n"));
3515 for (i
= 0, internal
= section_headers
;
3519 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3520 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3521 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3522 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3523 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3524 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3525 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3526 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3527 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3528 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3536 static Elf_Internal_Sym
*
3537 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3539 unsigned long number
;
3540 Elf32_External_Sym
*esyms
;
3541 Elf_External_Sym_Shndx
*shndx
;
3542 Elf_Internal_Sym
*isyms
;
3543 Elf_Internal_Sym
*psym
;
3546 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3552 if (symtab_shndx_hdr
!= NULL
3553 && (symtab_shndx_hdr
->sh_link
3554 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3556 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3557 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3565 number
= section
->sh_size
/ section
->sh_entsize
;
3566 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3570 error (_("Out of memory\n"));
3577 for (j
= 0, psym
= isyms
;
3581 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3582 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3583 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3584 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3585 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3587 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3588 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3589 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3599 static Elf_Internal_Sym
*
3600 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3602 unsigned long number
;
3603 Elf64_External_Sym
*esyms
;
3604 Elf_External_Sym_Shndx
*shndx
;
3605 Elf_Internal_Sym
*isyms
;
3606 Elf_Internal_Sym
*psym
;
3609 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3615 if (symtab_shndx_hdr
!= NULL
3616 && (symtab_shndx_hdr
->sh_link
3617 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3619 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3620 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3628 number
= section
->sh_size
/ section
->sh_entsize
;
3629 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3633 error (_("Out of memory\n"));
3640 for (j
= 0, psym
= isyms
;
3644 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3645 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3646 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3647 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3648 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3650 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3651 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3652 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3663 get_elf_section_flags (bfd_vma sh_flags
)
3665 static char buff
[33];
3672 flag
= sh_flags
& - sh_flags
;
3677 case SHF_WRITE
: *p
= 'W'; break;
3678 case SHF_ALLOC
: *p
= 'A'; break;
3679 case SHF_EXECINSTR
: *p
= 'X'; break;
3680 case SHF_MERGE
: *p
= 'M'; break;
3681 case SHF_STRINGS
: *p
= 'S'; break;
3682 case SHF_INFO_LINK
: *p
= 'I'; break;
3683 case SHF_LINK_ORDER
: *p
= 'L'; break;
3684 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3685 case SHF_GROUP
: *p
= 'G'; break;
3686 case SHF_TLS
: *p
= 'T'; break;
3689 if (flag
& SHF_MASKOS
)
3692 sh_flags
&= ~ SHF_MASKOS
;
3694 else if (flag
& SHF_MASKPROC
)
3697 sh_flags
&= ~ SHF_MASKPROC
;
3711 process_section_headers (FILE *file
)
3713 Elf_Internal_Shdr
*section
;
3716 section_headers
= NULL
;
3718 if (elf_header
.e_shnum
== 0)
3721 printf (_("\nThere are no sections in this file.\n"));
3726 if (do_sections
&& !do_header
)
3727 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3728 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3732 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3735 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3738 /* Read in the string table, so that we have names to display. */
3739 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3741 if (section
->sh_size
!= 0)
3743 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3744 section
->sh_size
, _("string table"));
3746 if (string_table
== NULL
)
3749 string_table_length
= section
->sh_size
;
3752 /* Scan the sections for the dynamic symbol table
3753 and dynamic string table and debug sections. */
3754 dynamic_symbols
= NULL
;
3755 dynamic_strings
= NULL
;
3756 dynamic_syminfo
= NULL
;
3757 symtab_shndx_hdr
= NULL
;
3759 eh_addr_size
= is_32bit_elf
? 4 : 8;
3760 switch (elf_header
.e_machine
)
3763 case EM_MIPS_RS3_LE
:
3764 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3765 FDE addresses. However, the ABI also has a semi-official ILP32
3766 variant for which the normal FDE address size rules apply.
3768 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3769 section, where XX is the size of longs in bits. Unfortunately,
3770 earlier compilers provided no way of distinguishing ILP32 objects
3771 from LP64 objects, so if there's any doubt, we should assume that
3772 the official LP64 form is being used. */
3773 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3774 && find_section (".gcc_compiled_long32") == NULL
)
3779 for (i
= 0, section
= section_headers
;
3780 i
< elf_header
.e_shnum
;
3783 char *name
= SECTION_NAME (section
);
3785 if (section
->sh_type
== SHT_DYNSYM
)
3787 if (dynamic_symbols
!= NULL
)
3789 error (_("File contains multiple dynamic symbol tables\n"));
3793 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3794 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3796 else if (section
->sh_type
== SHT_STRTAB
3797 && streq (name
, ".dynstr"))
3799 if (dynamic_strings
!= NULL
)
3801 error (_("File contains multiple dynamic string tables\n"));
3805 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3806 section
->sh_size
, _("dynamic strings"));
3807 dynamic_strings_length
= section
->sh_size
;
3809 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3811 if (symtab_shndx_hdr
!= NULL
)
3813 error (_("File contains multiple symtab shndx tables\n"));
3816 symtab_shndx_hdr
= section
;
3818 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3819 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3820 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3821 || do_debug_loc
|| do_debug_ranges
)
3822 && strneq (name
, ".debug_", 7))
3827 || (do_debug_info
&& streq (name
, "info"))
3828 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3829 || (do_debug_lines
&& streq (name
, "line"))
3830 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3831 || (do_debug_aranges
&& streq (name
, "aranges"))
3832 || (do_debug_ranges
&& streq (name
, "ranges"))
3833 || (do_debug_frames
&& streq (name
, "frame"))
3834 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3835 || (do_debug_str
&& streq (name
, "str"))
3836 || (do_debug_loc
&& streq (name
, "loc"))
3838 request_dump (i
, DEBUG_DUMP
);
3840 /* linkonce section to be combined with .debug_info at link time. */
3841 else if ((do_debugging
|| do_debug_info
)
3842 && strneq (name
, ".gnu.linkonce.wi.", 17))
3843 request_dump (i
, DEBUG_DUMP
);
3844 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3845 request_dump (i
, DEBUG_DUMP
);
3851 if (elf_header
.e_shnum
> 1)
3852 printf (_("\nSection Headers:\n"));
3854 printf (_("\nSection Header:\n"));
3858 if (do_full_section_name
)
3860 printf (_(" [Nr] Name\n"));
3861 printf (_(" Type Addr Off Size ES Flg Lk Inf Al\n"));
3865 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3869 if (do_full_section_name
)
3871 printf (_(" [Nr] Name\n"));
3872 printf (_(" Type Address Off Size ES Flg Lk Inf Al\n"));
3876 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3880 if (do_full_section_name
)
3882 printf (_(" [Nr] Name\n"));
3883 printf (_(" Flags Type Address Offset\n"));
3884 printf (_(" Size EntSize Link Info Align\n"));
3888 printf (_(" [Nr] Name Type Address Offset\n"));
3889 printf (_(" Size EntSize Flags Link Info Align\n"));
3893 for (i
= 0, section
= section_headers
;
3894 i
< elf_header
.e_shnum
;
3897 if (do_full_section_name
)
3899 printf (" [%2u] %s\n",
3900 SECTION_HEADER_NUM (i
),
3901 SECTION_NAME (section
));
3902 if (is_32bit_elf
|| do_wide
)
3903 printf (" %-15.15s ",
3904 get_section_type_name (section
->sh_type
));
3907 printf (" [%2u] %-17.17s %-15.15s ",
3908 SECTION_HEADER_NUM (i
),
3909 SECTION_NAME (section
),
3910 get_section_type_name (section
->sh_type
));
3914 print_vma (section
->sh_addr
, LONG_HEX
);
3916 printf ( " %6.6lx %6.6lx %2.2lx",
3917 (unsigned long) section
->sh_offset
,
3918 (unsigned long) section
->sh_size
,
3919 (unsigned long) section
->sh_entsize
);
3921 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3923 printf ("%2ld %3lu %2ld\n",
3924 (unsigned long) section
->sh_link
,
3925 (unsigned long) section
->sh_info
,
3926 (unsigned long) section
->sh_addralign
);
3930 print_vma (section
->sh_addr
, LONG_HEX
);
3932 if ((long) section
->sh_offset
== section
->sh_offset
)
3933 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3937 print_vma (section
->sh_offset
, LONG_HEX
);
3940 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3941 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3945 print_vma (section
->sh_size
, LONG_HEX
);
3948 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3949 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3953 print_vma (section
->sh_entsize
, LONG_HEX
);
3956 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3958 printf ("%2ld %3lu ",
3959 (unsigned long) section
->sh_link
,
3960 (unsigned long) section
->sh_info
);
3962 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3963 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3966 print_vma (section
->sh_addralign
, DEC
);
3970 else if (do_full_section_name
)
3972 printf (" %-15.15s %-15.15s ",
3973 get_elf_section_flags (section
->sh_flags
),
3974 get_section_type_name (section
->sh_type
));
3976 print_vma (section
->sh_addr
, LONG_HEX
);
3977 if ((long) section
->sh_offset
== section
->sh_offset
)
3978 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3982 print_vma (section
->sh_offset
, LONG_HEX
);
3985 print_vma (section
->sh_size
, LONG_HEX
);
3987 print_vma (section
->sh_entsize
, LONG_HEX
);
3989 printf (" %2ld %3lu %ld\n",
3990 (unsigned long) section
->sh_link
,
3991 (unsigned long) section
->sh_info
,
3992 (unsigned long) section
->sh_addralign
);
3997 print_vma (section
->sh_addr
, LONG_HEX
);
3998 if ((long) section
->sh_offset
== section
->sh_offset
)
3999 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4003 print_vma (section
->sh_offset
, LONG_HEX
);
4006 print_vma (section
->sh_size
, LONG_HEX
);
4008 print_vma (section
->sh_entsize
, LONG_HEX
);
4010 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4012 printf (" %2ld %3lu %ld\n",
4013 (unsigned long) section
->sh_link
,
4014 (unsigned long) section
->sh_info
,
4015 (unsigned long) section
->sh_addralign
);
4019 printf (_("Key to Flags:\n\
4020 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4021 I (info), L (link order), G (group), x (unknown)\n\
4022 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4028 get_group_flags (unsigned int flags
)
4030 static char buff
[32];
4037 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4044 process_section_groups (FILE *file
)
4046 Elf_Internal_Shdr
*section
;
4048 struct group
*group
;
4049 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4050 Elf_Internal_Sym
*symtab
;
4053 /* Don't process section groups unless needed. */
4054 if (!do_unwind
&& !do_section_groups
)
4057 if (elf_header
.e_shnum
== 0)
4059 if (do_section_groups
)
4060 printf (_("\nThere are no sections in this file.\n"));
4065 if (section_headers
== NULL
)
4067 error (_("Section headers are not available!\n"));
4071 section_headers_groups
= calloc (elf_header
.e_shnum
,
4072 sizeof (struct group
*));
4074 if (section_headers_groups
== NULL
)
4076 error (_("Out of memory\n"));
4080 /* Scan the sections for the group section. */
4082 for (i
= 0, section
= section_headers
;
4083 i
< elf_header
.e_shnum
;
4085 if (section
->sh_type
== SHT_GROUP
)
4088 if (group_count
== 0)
4090 if (do_section_groups
)
4091 printf (_("\nThere are no section groups in this file.\n"));
4096 section_groups
= calloc (group_count
, sizeof (struct group
));
4098 if (section_groups
== NULL
)
4100 error (_("Out of memory\n"));
4108 for (i
= 0, section
= section_headers
, group
= section_groups
;
4109 i
< elf_header
.e_shnum
;
4112 if (section
->sh_type
== SHT_GROUP
)
4114 char *name
= SECTION_NAME (section
);
4116 unsigned char *start
, *indices
;
4117 unsigned int entry
, j
, size
;
4118 Elf_Internal_Shdr
*sec
;
4119 Elf_Internal_Sym
*sym
;
4121 /* Get the symbol table. */
4122 sec
= SECTION_HEADER (section
->sh_link
);
4123 if (sec
->sh_type
!= SHT_SYMTAB
)
4125 error (_("Bad sh_link in group section `%s'\n"), name
);
4129 if (symtab_sec
!= sec
)
4134 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4137 sym
= symtab
+ section
->sh_info
;
4139 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4141 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4144 error (_("Bad sh_info in group section `%s'\n"), name
);
4148 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4153 /* Get the string table. */
4154 sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4155 if (strtab_sec
!= sec
)
4160 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4161 strtab_sec
->sh_size
,
4164 group_name
= strtab
+ sym
->st_name
;
4167 start
= get_data (NULL
, file
, section
->sh_offset
,
4168 section
->sh_size
, _("section data"));
4171 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4172 entry
= byte_get (indices
, 4);
4175 if (do_section_groups
)
4177 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4178 get_group_flags (entry
), name
, group_name
, size
);
4180 printf (_(" [Index] Name\n"));
4183 group
->group_index
= i
;
4185 for (j
= 0; j
< size
; j
++)
4187 struct group_list
*g
;
4189 entry
= byte_get (indices
, 4);
4192 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4197 error (_("section [%5u] already in group section [%5u]\n"),
4199 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4204 /* Intel C/C++ compiler may put section 0 in a
4205 section group. We just warn it the first time
4206 and ignore it afterwards. */
4207 static int warned
= 0;
4210 error (_("section 0 in group section [%5u]\n"),
4211 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4217 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4220 if (do_section_groups
)
4222 sec
= SECTION_HEADER (entry
);
4223 printf (" [%5u] %s\n",
4224 entry
, SECTION_NAME (sec
));
4227 g
= xmalloc (sizeof (struct group_list
));
4228 g
->section_index
= entry
;
4229 g
->next
= group
->root
;
4253 } dynamic_relocations
[] =
4255 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4256 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4257 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4260 /* Process the reloc section. */
4263 process_relocs (FILE *file
)
4265 unsigned long rel_size
;
4266 unsigned long rel_offset
;
4272 if (do_using_dynamic
)
4276 int has_dynamic_reloc
;
4279 has_dynamic_reloc
= 0;
4281 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4283 is_rela
= dynamic_relocations
[i
].rela
;
4284 name
= dynamic_relocations
[i
].name
;
4285 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4286 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4288 has_dynamic_reloc
|= rel_size
;
4290 if (is_rela
== UNKNOWN
)
4292 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4293 switch (dynamic_info
[DT_PLTREL
])
4307 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4308 name
, rel_offset
, rel_size
);
4310 dump_relocations (file
,
4311 offset_from_vma (file
, rel_offset
, rel_size
),
4313 dynamic_symbols
, num_dynamic_syms
,
4314 dynamic_strings
, dynamic_strings_length
, is_rela
);
4318 if (! has_dynamic_reloc
)
4319 printf (_("\nThere are no dynamic relocations in this file.\n"));
4323 Elf_Internal_Shdr
*section
;
4327 for (i
= 0, section
= section_headers
;
4328 i
< elf_header
.e_shnum
;
4331 if ( section
->sh_type
!= SHT_RELA
4332 && section
->sh_type
!= SHT_REL
)
4335 rel_offset
= section
->sh_offset
;
4336 rel_size
= section
->sh_size
;
4340 Elf_Internal_Shdr
*strsec
;
4343 printf (_("\nRelocation section "));
4345 if (string_table
== NULL
)
4346 printf ("%d", section
->sh_name
);
4348 printf (_("'%s'"), SECTION_NAME (section
));
4350 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4351 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4353 is_rela
= section
->sh_type
== SHT_RELA
;
4355 if (section
->sh_link
)
4357 Elf_Internal_Shdr
*symsec
;
4358 Elf_Internal_Sym
*symtab
;
4359 unsigned long nsyms
;
4360 unsigned long strtablen
;
4361 char *strtab
= NULL
;
4363 symsec
= SECTION_HEADER (section
->sh_link
);
4364 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4365 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4370 strsec
= SECTION_HEADER (symsec
->sh_link
);
4372 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4373 strsec
->sh_size
, _("string table"));
4374 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4376 dump_relocations (file
, rel_offset
, rel_size
,
4377 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4383 dump_relocations (file
, rel_offset
, rel_size
,
4384 NULL
, 0, NULL
, 0, is_rela
);
4391 printf (_("\nThere are no relocations in this file.\n"));
4397 /* Process the unwind section. */
4399 #include "unwind-ia64.h"
4401 /* An absolute address consists of a section and an offset. If the
4402 section is NULL, the offset itself is the address, otherwise, the
4403 address equals to LOAD_ADDRESS(section) + offset. */
4407 unsigned short section
;
4411 struct ia64_unw_aux_info
4413 struct ia64_unw_table_entry
4415 struct absaddr start
;
4417 struct absaddr info
;
4419 *table
; /* Unwind table. */
4420 unsigned long table_len
; /* Length of unwind table. */
4421 unsigned char *info
; /* Unwind info. */
4422 unsigned long info_size
; /* Size of unwind info. */
4423 bfd_vma info_addr
; /* starting address of unwind info. */
4424 bfd_vma seg_base
; /* Starting address of segment. */
4425 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4426 unsigned long nsyms
; /* Number of symbols. */
4427 char *strtab
; /* The string table. */
4428 unsigned long strtab_size
; /* Size of string table. */
4432 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4433 unsigned long nsyms
,
4435 unsigned long strtab_size
,
4436 struct absaddr addr
,
4437 const char **symname
,
4440 bfd_vma dist
= 0x100000;
4441 Elf_Internal_Sym
*sym
, *best
= NULL
;
4444 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4446 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4447 && sym
->st_name
!= 0
4448 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4449 && addr
.offset
>= sym
->st_value
4450 && addr
.offset
- sym
->st_value
< dist
)
4453 dist
= addr
.offset
- sym
->st_value
;
4460 *symname
= (best
->st_name
>= strtab_size
4461 ? "<corrupt>" : strtab
+ best
->st_name
);
4466 *offset
= addr
.offset
;
4470 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4472 struct ia64_unw_table_entry
*tp
;
4475 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4479 const unsigned char *dp
;
4480 const unsigned char *head
;
4481 const char *procname
;
4483 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4484 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4486 fputs ("\n<", stdout
);
4490 fputs (procname
, stdout
);
4493 printf ("+%lx", (unsigned long) offset
);
4496 fputs (">: [", stdout
);
4497 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4498 fputc ('-', stdout
);
4499 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4500 printf ("], info at +0x%lx\n",
4501 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4503 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4504 stamp
= BYTE_GET ((unsigned char *) head
);
4506 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4507 (unsigned) UNW_VER (stamp
),
4508 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4509 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4510 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4511 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4513 if (UNW_VER (stamp
) != 1)
4515 printf ("\tUnknown version.\n");
4520 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4521 dp
= unw_decode (dp
, in_body
, & in_body
);
4526 slurp_ia64_unwind_table (FILE *file
,
4527 struct ia64_unw_aux_info
*aux
,
4528 Elf_Internal_Shdr
*sec
)
4530 unsigned long size
, nrelas
, i
;
4531 Elf_Internal_Phdr
*seg
;
4532 struct ia64_unw_table_entry
*tep
;
4533 Elf_Internal_Shdr
*relsec
;
4534 Elf_Internal_Rela
*rela
, *rp
;
4535 unsigned char *table
, *tp
;
4536 Elf_Internal_Sym
*sym
;
4537 const char *relname
;
4539 /* First, find the starting address of the segment that includes
4542 if (elf_header
.e_phnum
)
4544 if (! get_program_headers (file
))
4547 for (seg
= program_headers
;
4548 seg
< program_headers
+ elf_header
.e_phnum
;
4551 if (seg
->p_type
!= PT_LOAD
)
4554 if (sec
->sh_addr
>= seg
->p_vaddr
4555 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4557 aux
->seg_base
= seg
->p_vaddr
;
4563 /* Second, build the unwind table from the contents of the unwind section: */
4564 size
= sec
->sh_size
;
4565 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4569 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4571 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4573 tep
->start
.section
= SHN_UNDEF
;
4574 tep
->end
.section
= SHN_UNDEF
;
4575 tep
->info
.section
= SHN_UNDEF
;
4578 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4579 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4580 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4584 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4585 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4586 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4588 tep
->start
.offset
+= aux
->seg_base
;
4589 tep
->end
.offset
+= aux
->seg_base
;
4590 tep
->info
.offset
+= aux
->seg_base
;
4594 /* Third, apply any relocations to the unwind table: */
4596 for (relsec
= section_headers
;
4597 relsec
< section_headers
+ elf_header
.e_shnum
;
4600 if (relsec
->sh_type
!= SHT_RELA
4601 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4604 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4608 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4612 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4613 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4617 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4618 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4621 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4623 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4627 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4629 switch (rp
->r_offset
/eh_addr_size
% 3)
4632 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4633 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4636 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4637 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4640 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4641 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4651 aux
->table_len
= size
/ (3 * eh_addr_size
);
4656 ia64_process_unwind (FILE *file
)
4658 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4659 unsigned long i
, unwcount
= 0, unwstart
= 0;
4660 struct ia64_unw_aux_info aux
;
4662 memset (& aux
, 0, sizeof (aux
));
4664 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4666 if (sec
->sh_type
== SHT_SYMTAB
)
4668 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4669 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4671 strsec
= SECTION_HEADER (sec
->sh_link
);
4672 aux
.strtab_size
= strsec
->sh_size
;
4673 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4674 aux
.strtab_size
, _("string table"));
4676 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4681 printf (_("\nThere are no unwind sections in this file.\n"));
4683 while (unwcount
-- > 0)
4688 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4689 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4690 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4697 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4699 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4701 /* We need to find which section group it is in. */
4702 struct group_list
*g
= section_headers_groups
[i
]->root
;
4704 for (; g
!= NULL
; g
= g
->next
)
4706 sec
= SECTION_HEADER (g
->section_index
);
4708 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4713 i
= elf_header
.e_shnum
;
4715 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4717 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4718 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4719 suffix
= SECTION_NAME (unwsec
) + len
;
4720 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4722 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4723 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4728 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4729 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4730 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4731 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4733 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4734 suffix
= SECTION_NAME (unwsec
) + len
;
4735 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4737 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4738 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4742 if (i
== elf_header
.e_shnum
)
4744 printf (_("\nCould not find unwind info section for "));
4746 if (string_table
== NULL
)
4747 printf ("%d", unwsec
->sh_name
);
4749 printf (_("'%s'"), SECTION_NAME (unwsec
));
4753 aux
.info_size
= sec
->sh_size
;
4754 aux
.info_addr
= sec
->sh_addr
;
4755 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4758 printf (_("\nUnwind section "));
4760 if (string_table
== NULL
)
4761 printf ("%d", unwsec
->sh_name
);
4763 printf (_("'%s'"), SECTION_NAME (unwsec
));
4765 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4766 (unsigned long) unwsec
->sh_offset
,
4767 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4769 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4771 if (aux
.table_len
> 0)
4772 dump_ia64_unwind (& aux
);
4775 free ((char *) aux
.table
);
4777 free ((char *) aux
.info
);
4786 free ((char *) aux
.strtab
);
4791 struct hppa_unw_aux_info
4793 struct hppa_unw_table_entry
4795 struct absaddr start
;
4797 unsigned int Cannot_unwind
:1; /* 0 */
4798 unsigned int Millicode
:1; /* 1 */
4799 unsigned int Millicode_save_sr0
:1; /* 2 */
4800 unsigned int Region_description
:2; /* 3..4 */
4801 unsigned int reserved1
:1; /* 5 */
4802 unsigned int Entry_SR
:1; /* 6 */
4803 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4804 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4805 unsigned int Args_stored
:1; /* 16 */
4806 unsigned int Variable_Frame
:1; /* 17 */
4807 unsigned int Separate_Package_Body
:1; /* 18 */
4808 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4809 unsigned int Stack_Overflow_Check
:1; /* 20 */
4810 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4811 unsigned int Ada_Region
:1; /* 22 */
4812 unsigned int cxx_info
:1; /* 23 */
4813 unsigned int cxx_try_catch
:1; /* 24 */
4814 unsigned int sched_entry_seq
:1; /* 25 */
4815 unsigned int reserved2
:1; /* 26 */
4816 unsigned int Save_SP
:1; /* 27 */
4817 unsigned int Save_RP
:1; /* 28 */
4818 unsigned int Save_MRP_in_frame
:1; /* 29 */
4819 unsigned int extn_ptr_defined
:1; /* 30 */
4820 unsigned int Cleanup_defined
:1; /* 31 */
4822 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4823 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4824 unsigned int Large_frame
:1; /* 2 */
4825 unsigned int Pseudo_SP_Set
:1; /* 3 */
4826 unsigned int reserved4
:1; /* 4 */
4827 unsigned int Total_frame_size
:27; /* 5..31 */
4829 *table
; /* Unwind table. */
4830 unsigned long table_len
; /* Length of unwind table. */
4831 bfd_vma seg_base
; /* Starting address of segment. */
4832 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4833 unsigned long nsyms
; /* Number of symbols. */
4834 char *strtab
; /* The string table. */
4835 unsigned long strtab_size
; /* Size of string table. */
4839 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4841 struct hppa_unw_table_entry
*tp
;
4843 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4846 const char *procname
;
4848 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4849 aux
->strtab_size
, tp
->start
, &procname
,
4852 fputs ("\n<", stdout
);
4856 fputs (procname
, stdout
);
4859 printf ("+%lx", (unsigned long) offset
);
4862 fputs (">: [", stdout
);
4863 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4864 fputc ('-', stdout
);
4865 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4868 #define PF(_m) if (tp->_m) printf (#_m " ");
4869 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4872 PF(Millicode_save_sr0
);
4873 /* PV(Region_description); */
4879 PF(Separate_Package_Body
);
4880 PF(Frame_Extension_Millicode
);
4881 PF(Stack_Overflow_Check
);
4882 PF(Two_Instruction_SP_Increment
);
4886 PF(sched_entry_seq
);
4889 PF(Save_MRP_in_frame
);
4890 PF(extn_ptr_defined
);
4891 PF(Cleanup_defined
);
4892 PF(MPE_XL_interrupt_marker
);
4893 PF(HP_UX_interrupt_marker
);
4896 PV(Total_frame_size
);
4905 slurp_hppa_unwind_table (FILE *file
,
4906 struct hppa_unw_aux_info
*aux
,
4907 Elf_Internal_Shdr
*sec
)
4909 unsigned long size
, unw_ent_size
, nrelas
, i
;
4910 Elf_Internal_Phdr
*seg
;
4911 struct hppa_unw_table_entry
*tep
;
4912 Elf_Internal_Shdr
*relsec
;
4913 Elf_Internal_Rela
*rela
, *rp
;
4914 unsigned char *table
, *tp
;
4915 Elf_Internal_Sym
*sym
;
4916 const char *relname
;
4918 /* First, find the starting address of the segment that includes
4921 if (elf_header
.e_phnum
)
4923 if (! get_program_headers (file
))
4926 for (seg
= program_headers
;
4927 seg
< program_headers
+ elf_header
.e_phnum
;
4930 if (seg
->p_type
!= PT_LOAD
)
4933 if (sec
->sh_addr
>= seg
->p_vaddr
4934 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4936 aux
->seg_base
= seg
->p_vaddr
;
4942 /* Second, build the unwind table from the contents of the unwind
4944 size
= sec
->sh_size
;
4945 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4949 unw_ent_size
= 2 * eh_addr_size
+ 8;
4951 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4953 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
4955 unsigned int tmp1
, tmp2
;
4957 tep
->start
.section
= SHN_UNDEF
;
4958 tep
->end
.section
= SHN_UNDEF
;
4962 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4963 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4964 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4965 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4969 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4970 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4971 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4972 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
4975 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
4976 tep
->Millicode
= (tmp1
>> 30) & 0x1;
4977 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
4978 tep
->Region_description
= (tmp1
>> 27) & 0x3;
4979 tep
->reserved1
= (tmp1
>> 26) & 0x1;
4980 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
4981 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
4982 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
4983 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
4984 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
4985 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
4986 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
4987 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
4988 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
4989 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
4990 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
4991 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
4992 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
4993 tep
->reserved2
= (tmp1
>> 5) & 0x1;
4994 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
4995 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
4996 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
4997 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
4998 tep
->Cleanup_defined
= tmp1
& 0x1;
5000 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5001 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5002 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5003 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5004 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5005 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5007 tep
->start
.offset
+= aux
->seg_base
;
5008 tep
->end
.offset
+= aux
->seg_base
;
5012 /* Third, apply any relocations to the unwind table. */
5014 for (relsec
= section_headers
;
5015 relsec
< section_headers
+ elf_header
.e_shnum
;
5018 if (relsec
->sh_type
!= SHT_RELA
5019 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5022 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5026 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5030 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5031 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5035 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5036 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5039 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5040 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5042 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5046 i
= rp
->r_offset
/ unw_ent_size
;
5048 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5051 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5052 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5055 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5056 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5066 aux
->table_len
= size
/ unw_ent_size
;
5072 hppa_process_unwind (FILE *file
)
5074 struct hppa_unw_aux_info aux
;
5075 Elf_Internal_Shdr
*unwsec
= NULL
;
5076 Elf_Internal_Shdr
*strsec
;
5077 Elf_Internal_Shdr
*sec
;
5080 memset (& aux
, 0, sizeof (aux
));
5082 assert (string_table
!= NULL
);
5084 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5086 if (sec
->sh_type
== SHT_SYMTAB
)
5088 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5089 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5091 strsec
= SECTION_HEADER (sec
->sh_link
);
5092 aux
.strtab_size
= strsec
->sh_size
;
5093 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5094 aux
.strtab_size
, _("string table"));
5096 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5101 printf (_("\nThere are no unwind sections in this file.\n"));
5103 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5105 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5107 printf (_("\nUnwind section "));
5108 printf (_("'%s'"), SECTION_NAME (sec
));
5110 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5111 (unsigned long) sec
->sh_offset
,
5112 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5114 slurp_hppa_unwind_table (file
, &aux
, sec
);
5115 if (aux
.table_len
> 0)
5116 dump_hppa_unwind (&aux
);
5119 free ((char *) aux
.table
);
5127 free ((char *) aux
.strtab
);
5133 process_unwind (FILE *file
)
5135 struct unwind_handler
{
5137 int (*handler
)(FILE *file
);
5139 { EM_IA_64
, ia64_process_unwind
},
5140 { EM_PARISC
, hppa_process_unwind
},
5148 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5149 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5150 return handlers
[i
].handler (file
);
5152 printf (_("\nThere are no unwind sections in this file.\n"));
5157 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5159 switch (entry
->d_tag
)
5162 if (entry
->d_un
.d_val
== 0)
5166 static const char * opts
[] =
5168 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5169 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5170 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5171 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5176 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5177 if (entry
->d_un
.d_val
& (1 << cnt
))
5179 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5186 case DT_MIPS_IVERSION
:
5187 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5188 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5190 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5193 case DT_MIPS_TIME_STAMP
:
5198 time_t time
= entry
->d_un
.d_val
;
5199 tmp
= gmtime (&time
);
5200 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5201 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5202 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5203 printf ("Time Stamp: %s\n", timebuf
);
5207 case DT_MIPS_RLD_VERSION
:
5208 case DT_MIPS_LOCAL_GOTNO
:
5209 case DT_MIPS_CONFLICTNO
:
5210 case DT_MIPS_LIBLISTNO
:
5211 case DT_MIPS_SYMTABNO
:
5212 case DT_MIPS_UNREFEXTNO
:
5213 case DT_MIPS_HIPAGENO
:
5214 case DT_MIPS_DELTA_CLASS_NO
:
5215 case DT_MIPS_DELTA_INSTANCE_NO
:
5216 case DT_MIPS_DELTA_RELOC_NO
:
5217 case DT_MIPS_DELTA_SYM_NO
:
5218 case DT_MIPS_DELTA_CLASSSYM_NO
:
5219 case DT_MIPS_COMPACT_SIZE
:
5220 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5224 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5230 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5232 switch (entry
->d_tag
)
5234 case DT_HP_DLD_FLAGS
:
5243 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5244 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5245 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5246 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5247 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5248 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5249 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5250 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5251 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5252 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5253 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5257 bfd_vma val
= entry
->d_un
.d_val
;
5259 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5260 if (val
& flags
[cnt
].bit
)
5264 fputs (flags
[cnt
].str
, stdout
);
5266 val
^= flags
[cnt
].bit
;
5269 if (val
!= 0 || first
)
5273 print_vma (val
, HEX
);
5279 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5286 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5288 switch (entry
->d_tag
)
5290 case DT_IA_64_PLT_RESERVE
:
5291 /* First 3 slots reserved. */
5292 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5294 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5298 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5305 get_32bit_dynamic_section (FILE *file
)
5307 Elf32_External_Dyn
*edyn
, *ext
;
5308 Elf_Internal_Dyn
*entry
;
5310 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5311 _("dynamic section"));
5315 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5316 might not have the luxury of section headers. Look for the DT_NULL
5317 terminator to determine the number of entries. */
5318 for (ext
= edyn
, dynamic_nent
= 0;
5319 (char *) ext
< (char *) edyn
+ dynamic_size
;
5323 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5327 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5328 if (dynamic_section
== NULL
)
5330 error (_("Out of memory\n"));
5335 for (ext
= edyn
, entry
= dynamic_section
;
5336 entry
< dynamic_section
+ dynamic_nent
;
5339 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5340 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5349 get_64bit_dynamic_section (FILE *file
)
5351 Elf64_External_Dyn
*edyn
, *ext
;
5352 Elf_Internal_Dyn
*entry
;
5354 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5355 _("dynamic section"));
5359 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5360 might not have the luxury of section headers. Look for the DT_NULL
5361 terminator to determine the number of entries. */
5362 for (ext
= edyn
, dynamic_nent
= 0;
5363 (char *) ext
< (char *) edyn
+ dynamic_size
;
5367 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5371 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5372 if (dynamic_section
== NULL
)
5374 error (_("Out of memory\n"));
5379 for (ext
= edyn
, entry
= dynamic_section
;
5380 entry
< dynamic_section
+ dynamic_nent
;
5383 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5384 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5393 print_dynamic_flags (bfd_vma flags
)
5401 flag
= flags
& - flags
;
5411 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5412 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5413 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5414 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5415 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5416 default: fputs ("unknown", stdout
); break;
5422 /* Parse and display the contents of the dynamic section. */
5425 process_dynamic_section (FILE *file
)
5427 Elf_Internal_Dyn
*entry
;
5429 if (dynamic_size
== 0)
5432 printf (_("\nThere is no dynamic section in this file.\n"));
5439 if (! get_32bit_dynamic_section (file
))
5442 else if (! get_64bit_dynamic_section (file
))
5445 /* Find the appropriate symbol table. */
5446 if (dynamic_symbols
== NULL
)
5448 for (entry
= dynamic_section
;
5449 entry
< dynamic_section
+ dynamic_nent
;
5452 Elf_Internal_Shdr section
;
5454 if (entry
->d_tag
!= DT_SYMTAB
)
5457 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5459 /* Since we do not know how big the symbol table is,
5460 we default to reading in the entire file (!) and
5461 processing that. This is overkill, I know, but it
5463 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5465 if (archive_file_offset
!= 0)
5466 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5469 if (fseek (file
, 0, SEEK_END
))
5470 error (_("Unable to seek to end of file!"));
5472 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5476 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5478 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5480 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5481 if (num_dynamic_syms
< 1)
5483 error (_("Unable to determine the number of symbols to load\n"));
5487 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5491 /* Similarly find a string table. */
5492 if (dynamic_strings
== NULL
)
5494 for (entry
= dynamic_section
;
5495 entry
< dynamic_section
+ dynamic_nent
;
5498 unsigned long offset
;
5501 if (entry
->d_tag
!= DT_STRTAB
)
5504 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5506 /* Since we do not know how big the string table is,
5507 we default to reading in the entire file (!) and
5508 processing that. This is overkill, I know, but it
5511 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5513 if (archive_file_offset
!= 0)
5514 str_tab_len
= archive_file_size
- offset
;
5517 if (fseek (file
, 0, SEEK_END
))
5518 error (_("Unable to seek to end of file\n"));
5519 str_tab_len
= ftell (file
) - offset
;
5522 if (str_tab_len
< 1)
5525 (_("Unable to determine the length of the dynamic string table\n"));
5529 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5530 _("dynamic string table"));
5531 dynamic_strings_length
= str_tab_len
;
5536 /* And find the syminfo section if available. */
5537 if (dynamic_syminfo
== NULL
)
5539 unsigned long syminsz
= 0;
5541 for (entry
= dynamic_section
;
5542 entry
< dynamic_section
+ dynamic_nent
;
5545 if (entry
->d_tag
== DT_SYMINENT
)
5547 /* Note: these braces are necessary to avoid a syntax
5548 error from the SunOS4 C compiler. */
5549 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5551 else if (entry
->d_tag
== DT_SYMINSZ
)
5552 syminsz
= entry
->d_un
.d_val
;
5553 else if (entry
->d_tag
== DT_SYMINFO
)
5554 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5558 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5560 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5561 Elf_Internal_Syminfo
*syminfo
;
5563 /* There is a syminfo section. Read the data. */
5564 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5565 _("symbol information"));
5569 dynamic_syminfo
= malloc (syminsz
);
5570 if (dynamic_syminfo
== NULL
)
5572 error (_("Out of memory\n"));
5576 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5577 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5578 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5579 ++syminfo
, ++extsym
)
5581 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5582 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5589 if (do_dynamic
&& dynamic_addr
)
5590 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5591 dynamic_addr
, dynamic_nent
);
5593 printf (_(" Tag Type Name/Value\n"));
5595 for (entry
= dynamic_section
;
5596 entry
< dynamic_section
+ dynamic_nent
;
5604 print_vma (entry
->d_tag
, FULL_HEX
);
5605 dtype
= get_dynamic_type (entry
->d_tag
);
5606 printf (" (%s)%*s", dtype
,
5607 ((is_32bit_elf
? 27 : 19)
5608 - (int) strlen (dtype
)),
5612 switch (entry
->d_tag
)
5616 print_dynamic_flags (entry
->d_un
.d_val
);
5626 switch (entry
->d_tag
)
5629 printf (_("Auxiliary library"));
5633 printf (_("Filter library"));
5637 printf (_("Configuration file"));
5641 printf (_("Dependency audit library"));
5645 printf (_("Audit library"));
5649 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5650 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5654 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5663 printf (_("Flags:"));
5665 if (entry
->d_un
.d_val
== 0)
5666 printf (_(" None\n"));
5669 unsigned long int val
= entry
->d_un
.d_val
;
5671 if (val
& DTF_1_PARINIT
)
5673 printf (" PARINIT");
5674 val
^= DTF_1_PARINIT
;
5676 if (val
& DTF_1_CONFEXP
)
5678 printf (" CONFEXP");
5679 val
^= DTF_1_CONFEXP
;
5682 printf (" %lx", val
);
5691 printf (_("Flags:"));
5693 if (entry
->d_un
.d_val
== 0)
5694 printf (_(" None\n"));
5697 unsigned long int val
= entry
->d_un
.d_val
;
5699 if (val
& DF_P1_LAZYLOAD
)
5701 printf (" LAZYLOAD");
5702 val
^= DF_P1_LAZYLOAD
;
5704 if (val
& DF_P1_GROUPPERM
)
5706 printf (" GROUPPERM");
5707 val
^= DF_P1_GROUPPERM
;
5710 printf (" %lx", val
);
5719 printf (_("Flags:"));
5720 if (entry
->d_un
.d_val
== 0)
5721 printf (_(" None\n"));
5724 unsigned long int val
= entry
->d_un
.d_val
;
5731 if (val
& DF_1_GLOBAL
)
5736 if (val
& DF_1_GROUP
)
5741 if (val
& DF_1_NODELETE
)
5743 printf (" NODELETE");
5744 val
^= DF_1_NODELETE
;
5746 if (val
& DF_1_LOADFLTR
)
5748 printf (" LOADFLTR");
5749 val
^= DF_1_LOADFLTR
;
5751 if (val
& DF_1_INITFIRST
)
5753 printf (" INITFIRST");
5754 val
^= DF_1_INITFIRST
;
5756 if (val
& DF_1_NOOPEN
)
5761 if (val
& DF_1_ORIGIN
)
5766 if (val
& DF_1_DIRECT
)
5771 if (val
& DF_1_TRANS
)
5776 if (val
& DF_1_INTERPOSE
)
5778 printf (" INTERPOSE");
5779 val
^= DF_1_INTERPOSE
;
5781 if (val
& DF_1_NODEFLIB
)
5783 printf (" NODEFLIB");
5784 val
^= DF_1_NODEFLIB
;
5786 if (val
& DF_1_NODUMP
)
5791 if (val
& DF_1_CONLFAT
)
5793 printf (" CONLFAT");
5794 val
^= DF_1_CONLFAT
;
5797 printf (" %lx", val
);
5804 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5806 puts (get_dynamic_type (entry
->d_un
.d_val
));
5826 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5832 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5833 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5839 switch (entry
->d_tag
)
5842 printf (_("Shared library: [%s]"), name
);
5844 if (streq (name
, program_interpreter
))
5845 printf (_(" program interpreter"));
5849 printf (_("Library soname: [%s]"), name
);
5853 printf (_("Library rpath: [%s]"), name
);
5857 printf (_("Library runpath: [%s]"), name
);
5861 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5866 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5879 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5883 case DT_INIT_ARRAYSZ
:
5884 case DT_FINI_ARRAYSZ
:
5885 case DT_GNU_CONFLICTSZ
:
5886 case DT_GNU_LIBLISTSZ
:
5889 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5890 printf (" (bytes)\n");
5900 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5913 if (entry
->d_tag
== DT_USED
5914 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5916 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5920 printf (_("Not needed object: [%s]\n"), name
);
5925 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5931 /* The value of this entry is ignored. */
5936 case DT_GNU_PRELINKED
:
5940 time_t time
= entry
->d_un
.d_val
;
5942 tmp
= gmtime (&time
);
5943 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5944 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5945 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5951 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5952 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5957 switch (elf_header
.e_machine
)
5960 case EM_MIPS_RS3_LE
:
5961 dynamic_section_mips_val (entry
);
5964 dynamic_section_parisc_val (entry
);
5967 dynamic_section_ia64_val (entry
);
5970 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5982 get_ver_flags (unsigned int flags
)
5984 static char buff
[32];
5991 if (flags
& VER_FLG_BASE
)
5992 strcat (buff
, "BASE ");
5994 if (flags
& VER_FLG_WEAK
)
5996 if (flags
& VER_FLG_BASE
)
5997 strcat (buff
, "| ");
5999 strcat (buff
, "WEAK ");
6002 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6003 strcat (buff
, "| <unknown>");
6008 /* Display the contents of the version sections. */
6010 process_version_sections (FILE *file
)
6012 Elf_Internal_Shdr
*section
;
6019 for (i
= 0, section
= section_headers
;
6020 i
< elf_header
.e_shnum
;
6023 switch (section
->sh_type
)
6025 case SHT_GNU_verdef
:
6027 Elf_External_Verdef
*edefs
;
6034 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6035 SECTION_NAME (section
), section
->sh_info
);
6037 printf (_(" Addr: 0x"));
6038 printf_vma (section
->sh_addr
);
6039 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6040 (unsigned long) section
->sh_offset
, section
->sh_link
,
6041 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6043 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6044 _("version definition section"));
6048 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6051 Elf_External_Verdef
*edef
;
6052 Elf_Internal_Verdef ent
;
6053 Elf_External_Verdaux
*eaux
;
6054 Elf_Internal_Verdaux aux
;
6058 vstart
= ((char *) edefs
) + idx
;
6060 edef
= (Elf_External_Verdef
*) vstart
;
6062 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6063 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6064 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6065 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6066 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6067 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6068 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6070 printf (_(" %#06x: Rev: %d Flags: %s"),
6071 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6073 printf (_(" Index: %d Cnt: %d "),
6074 ent
.vd_ndx
, ent
.vd_cnt
);
6076 vstart
+= ent
.vd_aux
;
6078 eaux
= (Elf_External_Verdaux
*) vstart
;
6080 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6081 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6083 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6084 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6086 printf (_("Name index: %ld\n"), aux
.vda_name
);
6088 isum
= idx
+ ent
.vd_aux
;
6090 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6092 isum
+= aux
.vda_next
;
6093 vstart
+= aux
.vda_next
;
6095 eaux
= (Elf_External_Verdaux
*) vstart
;
6097 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6098 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6100 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6101 printf (_(" %#06x: Parent %d: %s\n"),
6102 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6104 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6105 isum
, j
, aux
.vda_name
);
6115 case SHT_GNU_verneed
:
6117 Elf_External_Verneed
*eneed
;
6123 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6124 SECTION_NAME (section
), section
->sh_info
);
6126 printf (_(" Addr: 0x"));
6127 printf_vma (section
->sh_addr
);
6128 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6129 (unsigned long) section
->sh_offset
, section
->sh_link
,
6130 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6132 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6133 _("version need section"));
6137 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6139 Elf_External_Verneed
*entry
;
6140 Elf_Internal_Verneed ent
;
6145 vstart
= ((char *) eneed
) + idx
;
6147 entry
= (Elf_External_Verneed
*) vstart
;
6149 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6150 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6151 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6152 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6153 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6155 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6157 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6158 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6160 printf (_(" File: %lx"), ent
.vn_file
);
6162 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6164 vstart
+= ent
.vn_aux
;
6166 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6168 Elf_External_Vernaux
*eaux
;
6169 Elf_Internal_Vernaux aux
;
6171 eaux
= (Elf_External_Vernaux
*) vstart
;
6173 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6174 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6175 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6176 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6177 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6179 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6180 printf (_(" %#06x: Name: %s"),
6181 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6183 printf (_(" %#06x: Name index: %lx"),
6184 isum
, aux
.vna_name
);
6186 printf (_(" Flags: %s Version: %d\n"),
6187 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6189 isum
+= aux
.vna_next
;
6190 vstart
+= aux
.vna_next
;
6200 case SHT_GNU_versym
:
6202 Elf_Internal_Shdr
*link_section
;
6205 unsigned char *edata
;
6206 unsigned short *data
;
6208 Elf_Internal_Sym
*symbols
;
6209 Elf_Internal_Shdr
*string_sec
;
6212 link_section
= SECTION_HEADER (section
->sh_link
);
6213 total
= section
->sh_size
/ section
->sh_entsize
;
6217 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6219 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6221 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6222 string_sec
->sh_size
, _("version string table"));
6226 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6227 SECTION_NAME (section
), total
);
6229 printf (_(" Addr: "));
6230 printf_vma (section
->sh_addr
);
6231 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6232 (unsigned long) section
->sh_offset
, section
->sh_link
,
6233 SECTION_NAME (link_section
));
6235 off
= offset_from_vma (file
,
6236 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6237 total
* sizeof (short));
6238 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6239 _("version symbol data"));
6246 data
= malloc (total
* sizeof (short));
6248 for (cnt
= total
; cnt
--;)
6249 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6254 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6257 int check_def
, check_need
;
6260 printf (" %03x:", cnt
);
6262 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6263 switch (data
[cnt
+ j
])
6266 fputs (_(" 0 (*local*) "), stdout
);
6270 fputs (_(" 1 (*global*) "), stdout
);
6274 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6275 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6279 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6282 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6289 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6291 Elf_Internal_Verneed ivn
;
6292 unsigned long offset
;
6294 offset
= offset_from_vma
6295 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6296 sizeof (Elf_External_Verneed
));
6300 Elf_Internal_Vernaux ivna
;
6301 Elf_External_Verneed evn
;
6302 Elf_External_Vernaux evna
;
6303 unsigned long a_off
;
6305 get_data (&evn
, file
, offset
, sizeof (evn
),
6308 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6309 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6311 a_off
= offset
+ ivn
.vn_aux
;
6315 get_data (&evna
, file
, a_off
, sizeof (evna
),
6316 _("version need aux (2)"));
6318 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6319 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6321 a_off
+= ivna
.vna_next
;
6323 while (ivna
.vna_other
!= data
[cnt
+ j
]
6324 && ivna
.vna_next
!= 0);
6326 if (ivna
.vna_other
== data
[cnt
+ j
])
6328 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6330 name
= strtab
+ ivna
.vna_name
;
6331 nn
+= printf ("(%s%-*s",
6333 12 - (int) strlen (name
),
6339 offset
+= ivn
.vn_next
;
6341 while (ivn
.vn_next
);
6344 if (check_def
&& data
[cnt
+ j
] != 0x8001
6345 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6347 Elf_Internal_Verdef ivd
;
6348 Elf_External_Verdef evd
;
6349 unsigned long offset
;
6351 offset
= offset_from_vma
6352 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6357 get_data (&evd
, file
, offset
, sizeof (evd
),
6360 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6361 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6363 offset
+= ivd
.vd_next
;
6365 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6366 && ivd
.vd_next
!= 0);
6368 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6370 Elf_External_Verdaux evda
;
6371 Elf_Internal_Verdaux ivda
;
6373 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6375 get_data (&evda
, file
,
6376 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6377 sizeof (evda
), _("version def aux"));
6379 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6381 name
= strtab
+ ivda
.vda_name
;
6382 nn
+= printf ("(%s%-*s",
6384 12 - (int) strlen (name
),
6390 printf ("%*c", 18 - nn
, ' ');
6408 printf (_("\nNo version information found in this file.\n"));
6414 get_symbol_binding (unsigned int binding
)
6416 static char buff
[32];
6420 case STB_LOCAL
: return "LOCAL";
6421 case STB_GLOBAL
: return "GLOBAL";
6422 case STB_WEAK
: return "WEAK";
6424 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6425 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6427 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6428 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6430 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6436 get_symbol_type (unsigned int type
)
6438 static char buff
[32];
6442 case STT_NOTYPE
: return "NOTYPE";
6443 case STT_OBJECT
: return "OBJECT";
6444 case STT_FUNC
: return "FUNC";
6445 case STT_SECTION
: return "SECTION";
6446 case STT_FILE
: return "FILE";
6447 case STT_COMMON
: return "COMMON";
6448 case STT_TLS
: return "TLS";
6450 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6452 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6453 return "THUMB_FUNC";
6455 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6458 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6459 return "PARISC_MILLI";
6461 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6463 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6465 if (elf_header
.e_machine
== EM_PARISC
)
6467 if (type
== STT_HP_OPAQUE
)
6469 if (type
== STT_HP_STUB
)
6473 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6476 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6482 get_symbol_visibility (unsigned int visibility
)
6486 case STV_DEFAULT
: return "DEFAULT";
6487 case STV_INTERNAL
: return "INTERNAL";
6488 case STV_HIDDEN
: return "HIDDEN";
6489 case STV_PROTECTED
: return "PROTECTED";
6495 get_symbol_index_type (unsigned int type
)
6497 static char buff
[32];
6501 case SHN_UNDEF
: return "UND";
6502 case SHN_ABS
: return "ABS";
6503 case SHN_COMMON
: return "COM";
6505 if (type
== SHN_IA_64_ANSI_COMMON
6506 && elf_header
.e_machine
== EM_IA_64
6507 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6509 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6510 sprintf (buff
, "PRC[0x%04x]", type
);
6511 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6512 sprintf (buff
, "OS [0x%04x]", type
);
6513 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6514 sprintf (buff
, "RSV[0x%04x]", type
);
6516 sprintf (buff
, "%3d", type
);
6524 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6526 unsigned char *e_data
;
6529 e_data
= malloc (number
* ent_size
);
6533 error (_("Out of memory\n"));
6537 if (fread (e_data
, ent_size
, number
, file
) != number
)
6539 error (_("Unable to read in dynamic data\n"));
6543 i_data
= malloc (number
* sizeof (*i_data
));
6547 error (_("Out of memory\n"));
6553 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6560 /* Dump the symbol table. */
6562 process_symbol_table (FILE *file
)
6564 Elf_Internal_Shdr
*section
;
6565 bfd_vma nbuckets
= 0;
6566 bfd_vma nchains
= 0;
6567 bfd_vma
*buckets
= NULL
;
6568 bfd_vma
*chains
= NULL
;
6570 if (! do_syms
&& !do_histogram
)
6573 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6576 unsigned char nb
[8];
6577 unsigned char nc
[8];
6578 int hash_ent_size
= 4;
6580 if ((elf_header
.e_machine
== EM_ALPHA
6581 || elf_header
.e_machine
== EM_S390
6582 || elf_header
.e_machine
== EM_S390_OLD
)
6583 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6587 (archive_file_offset
6588 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6589 sizeof nb
+ sizeof nc
)),
6592 error (_("Unable to seek to start of dynamic information"));
6596 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6598 error (_("Failed to read in number of buckets\n"));
6602 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6604 error (_("Failed to read in number of chains\n"));
6608 nbuckets
= byte_get (nb
, hash_ent_size
);
6609 nchains
= byte_get (nc
, hash_ent_size
);
6611 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6612 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6614 if (buckets
== NULL
|| chains
== NULL
)
6619 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6624 printf (_("\nSymbol table for image:\n"));
6626 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6628 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6630 for (hn
= 0; hn
< nbuckets
; hn
++)
6635 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6637 Elf_Internal_Sym
*psym
;
6640 psym
= dynamic_symbols
+ si
;
6642 n
= print_vma (si
, DEC_5
);
6644 fputs (" " + n
, stdout
);
6645 printf (" %3lu: ", hn
);
6646 print_vma (psym
->st_value
, LONG_HEX
);
6648 print_vma (psym
->st_size
, DEC_5
);
6650 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6651 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6652 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6653 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6654 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6655 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6657 printf (" <corrupt: %14ld>", psym
->st_name
);
6662 else if (do_syms
&& !do_using_dynamic
)
6666 for (i
= 0, section
= section_headers
;
6667 i
< elf_header
.e_shnum
;
6672 Elf_Internal_Sym
*symtab
;
6673 Elf_Internal_Sym
*psym
;
6676 if ( section
->sh_type
!= SHT_SYMTAB
6677 && section
->sh_type
!= SHT_DYNSYM
)
6680 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6681 SECTION_NAME (section
),
6682 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6684 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6686 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6688 symtab
= GET_ELF_SYMBOLS (file
, section
);
6692 if (section
->sh_link
== elf_header
.e_shstrndx
)
6693 strtab
= string_table
;
6696 Elf_Internal_Shdr
*string_sec
;
6698 string_sec
= SECTION_HEADER (section
->sh_link
);
6700 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6701 string_sec
->sh_size
, _("string table"));
6704 for (si
= 0, psym
= symtab
;
6705 si
< section
->sh_size
/ section
->sh_entsize
;
6708 printf ("%6d: ", si
);
6709 print_vma (psym
->st_value
, LONG_HEX
);
6711 print_vma (psym
->st_size
, DEC_5
);
6712 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6713 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6714 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6715 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6716 print_symbol (25, strtab
+ psym
->st_name
);
6718 if (section
->sh_type
== SHT_DYNSYM
&&
6719 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6721 unsigned char data
[2];
6722 unsigned short vers_data
;
6723 unsigned long offset
;
6727 offset
= offset_from_vma
6728 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6729 sizeof data
+ si
* sizeof (vers_data
));
6731 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6732 sizeof (data
), _("version data"));
6734 vers_data
= byte_get (data
, 2);
6736 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6739 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6741 if ((vers_data
& 0x8000) || vers_data
> 1)
6743 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6744 && (is_nobits
|| ! check_def
))
6746 Elf_External_Verneed evn
;
6747 Elf_Internal_Verneed ivn
;
6748 Elf_Internal_Vernaux ivna
;
6750 /* We must test both. */
6751 offset
= offset_from_vma
6752 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6757 unsigned long vna_off
;
6759 get_data (&evn
, file
, offset
, sizeof (evn
),
6762 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6763 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6765 vna_off
= offset
+ ivn
.vn_aux
;
6769 Elf_External_Vernaux evna
;
6771 get_data (&evna
, file
, vna_off
,
6773 _("version need aux (3)"));
6775 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6776 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6777 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6779 vna_off
+= ivna
.vna_next
;
6781 while (ivna
.vna_other
!= vers_data
6782 && ivna
.vna_next
!= 0);
6784 if (ivna
.vna_other
== vers_data
)
6787 offset
+= ivn
.vn_next
;
6789 while (ivn
.vn_next
!= 0);
6791 if (ivna
.vna_other
== vers_data
)
6794 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6797 else if (! is_nobits
)
6798 error (_("bad dynamic symbol"));
6805 if (vers_data
!= 0x8001
6806 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6808 Elf_Internal_Verdef ivd
;
6809 Elf_Internal_Verdaux ivda
;
6810 Elf_External_Verdaux evda
;
6811 unsigned long offset
;
6813 offset
= offset_from_vma
6815 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6816 sizeof (Elf_External_Verdef
));
6820 Elf_External_Verdef evd
;
6822 get_data (&evd
, file
, offset
, sizeof (evd
),
6825 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6826 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6827 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6829 offset
+= ivd
.vd_next
;
6831 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6832 && ivd
.vd_next
!= 0);
6834 offset
-= ivd
.vd_next
;
6835 offset
+= ivd
.vd_aux
;
6837 get_data (&evda
, file
, offset
, sizeof (evda
),
6838 _("version def aux"));
6840 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6842 if (psym
->st_name
!= ivda
.vda_name
)
6843 printf ((vers_data
& 0x8000)
6845 strtab
+ ivda
.vda_name
);
6855 if (strtab
!= string_table
)
6861 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6863 if (do_histogram
&& buckets
!= NULL
)
6865 unsigned long *lengths
;
6866 unsigned long *counts
;
6869 unsigned long maxlength
= 0;
6870 unsigned long nzero_counts
= 0;
6871 unsigned long nsyms
= 0;
6873 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
6874 (unsigned long) nbuckets
);
6875 printf (_(" Length Number %% of total Coverage\n"));
6877 lengths
= calloc (nbuckets
, sizeof (*lengths
));
6878 if (lengths
== NULL
)
6880 error (_("Out of memory"));
6883 for (hn
= 0; hn
< nbuckets
; ++hn
)
6885 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6888 if (maxlength
< ++lengths
[hn
])
6893 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
6896 error (_("Out of memory"));
6900 for (hn
= 0; hn
< nbuckets
; ++hn
)
6901 ++counts
[lengths
[hn
]];
6906 printf (" 0 %-10lu (%5.1f%%)\n",
6907 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6908 for (i
= 1; i
<= maxlength
; ++i
)
6910 nzero_counts
+= counts
[i
] * i
;
6911 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
6912 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
6913 (nzero_counts
* 100.0) / nsyms
);
6921 if (buckets
!= NULL
)
6931 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6935 if (dynamic_syminfo
== NULL
6937 /* No syminfo, this is ok. */
6940 /* There better should be a dynamic symbol section. */
6941 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6945 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6946 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6948 printf (_(" Num: Name BoundTo Flags\n"));
6949 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6951 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6953 printf ("%4d: ", i
);
6954 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6955 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6957 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6960 switch (dynamic_syminfo
[i
].si_boundto
)
6962 case SYMINFO_BT_SELF
:
6963 fputs ("SELF ", stdout
);
6965 case SYMINFO_BT_PARENT
:
6966 fputs ("PARENT ", stdout
);
6969 if (dynamic_syminfo
[i
].si_boundto
> 0
6970 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6971 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6973 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6977 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6981 if (flags
& SYMINFO_FLG_DIRECT
)
6983 if (flags
& SYMINFO_FLG_PASSTHRU
)
6984 printf (" PASSTHRU");
6985 if (flags
& SYMINFO_FLG_COPY
)
6987 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6988 printf (" LAZYLOAD");
6996 #ifdef SUPPORT_DISASSEMBLY
6998 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7000 printf (_("\nAssembly dump of section %s\n"),
7001 SECTION_NAME (section
));
7003 /* XXX -- to be done --- XXX */
7010 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7012 bfd_size_type bytes
;
7014 unsigned char *data
;
7015 unsigned char *start
;
7017 bytes
= section
->sh_size
;
7019 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7021 printf (_("\nSection '%s' has no data to dump.\n"),
7022 SECTION_NAME (section
));
7026 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7028 addr
= section
->sh_addr
;
7030 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
7042 lbytes
= (bytes
> 16 ? 16 : bytes
);
7044 printf (" 0x%8.8lx ", (unsigned long) addr
);
7046 switch (elf_header
.e_ident
[EI_DATA
])
7050 for (j
= 15; j
>= 0; j
--)
7053 printf ("%2.2x", data
[j
]);
7063 for (j
= 0; j
< 16; j
++)
7066 printf ("%2.2x", data
[j
]);
7076 for (j
= 0; j
< lbytes
; j
++)
7079 if (k
>= ' ' && k
< 0x7f)
7098 static unsigned long int
7099 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7101 unsigned long int result
= 0;
7102 unsigned int num_read
= 0;
7103 unsigned int shift
= 0;
7111 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7116 while (byte
& 0x80);
7118 if (length_return
!= NULL
)
7119 *length_return
= num_read
;
7121 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7122 result
|= -1L << shift
;
7127 typedef struct State_Machine_Registers
7129 unsigned long address
;
7132 unsigned int column
;
7136 /* This variable hold the number of the last entry seen
7137 in the File Table. */
7138 unsigned int last_file_entry
;
7141 static SMR state_machine_regs
;
7144 reset_state_machine (int is_stmt
)
7146 state_machine_regs
.address
= 0;
7147 state_machine_regs
.file
= 1;
7148 state_machine_regs
.line
= 1;
7149 state_machine_regs
.column
= 0;
7150 state_machine_regs
.is_stmt
= is_stmt
;
7151 state_machine_regs
.basic_block
= 0;
7152 state_machine_regs
.end_sequence
= 0;
7153 state_machine_regs
.last_file_entry
= 0;
7156 /* Handled an extend line op. Returns true if this is the end
7160 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7162 unsigned char op_code
;
7163 unsigned int bytes_read
;
7165 unsigned char *name
;
7168 len
= read_leb128 (data
, & bytes_read
, 0);
7173 warn (_("badly formed extended line op encountered!\n"));
7180 printf (_(" Extended opcode %d: "), op_code
);
7184 case DW_LNE_end_sequence
:
7185 printf (_("End of Sequence\n\n"));
7186 reset_state_machine (is_stmt
);
7189 case DW_LNE_set_address
:
7190 adr
= byte_get (data
, pointer_size
);
7191 printf (_("set Address to 0x%lx\n"), adr
);
7192 state_machine_regs
.address
= adr
;
7195 case DW_LNE_define_file
:
7196 printf (_(" define new File Table entry\n"));
7197 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7199 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7201 data
+= strlen ((char *) data
) + 1;
7202 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7204 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7206 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7207 printf (_("%s\n\n"), name
);
7211 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7218 static const char *debug_str_contents
;
7219 static bfd_vma debug_str_size
;
7222 load_debug_str (FILE *file
)
7224 Elf_Internal_Shdr
*sec
;
7226 /* If it is already loaded, do nothing. */
7227 if (debug_str_contents
!= NULL
)
7230 /* Locate the .debug_str section. */
7231 sec
= find_section (".debug_str");
7235 debug_str_size
= sec
->sh_size
;
7237 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7238 _("debug_str section data"));
7242 free_debug_str (void)
7244 if (debug_str_contents
== NULL
)
7247 free ((char *) debug_str_contents
);
7248 debug_str_contents
= NULL
;
7253 fetch_indirect_string (unsigned long offset
)
7255 if (debug_str_contents
== NULL
)
7256 return _("<no .debug_str section>");
7258 if (offset
> debug_str_size
)
7259 return _("<offset is too big>");
7261 return debug_str_contents
+ offset
;
7264 static const char *debug_loc_contents
;
7265 static bfd_vma debug_loc_size
;
7268 load_debug_loc (FILE *file
)
7270 Elf_Internal_Shdr
*sec
;
7272 /* If it is already loaded, do nothing. */
7273 if (debug_loc_contents
!= NULL
)
7276 /* Locate the .debug_loc section. */
7277 sec
= find_section (".debug_loc");
7281 debug_loc_size
= sec
->sh_size
;
7283 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7284 _("debug_loc section data"));
7288 free_debug_loc (void)
7290 if (debug_loc_contents
== NULL
)
7293 free ((char *) debug_loc_contents
);
7294 debug_loc_contents
= NULL
;
7298 static const char * debug_range_contents
;
7299 static unsigned long debug_range_size
;
7302 load_debug_range (FILE *file
)
7304 Elf_Internal_Shdr
*sec
;
7306 /* If it is already loaded, do nothing. */
7307 if (debug_range_contents
!= NULL
)
7310 /* Locate the .debug_str section. */
7311 sec
= find_section (".debug_ranges");
7315 debug_range_size
= sec
->sh_size
;
7317 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7318 _("debug_range section data"));
7322 free_debug_range (void)
7324 if (debug_range_contents
== NULL
)
7327 free ((char *) debug_range_contents
);
7328 debug_range_contents
= NULL
;
7329 debug_range_size
= 0;
7332 /* Apply addends of RELA relocations. */
7335 debug_apply_rela_addends (FILE *file
,
7336 Elf_Internal_Shdr
*section
,
7338 unsigned char *sec_data
,
7339 unsigned char *start
,
7342 Elf_Internal_Shdr
*relsec
;
7344 if (end
- start
< reloc_size
)
7347 for (relsec
= section_headers
;
7348 relsec
< section_headers
+ elf_header
.e_shnum
;
7351 unsigned long nrelas
;
7352 Elf_Internal_Rela
*rela
, *rp
;
7353 Elf_Internal_Shdr
*symsec
;
7354 Elf_Internal_Sym
*symtab
;
7355 Elf_Internal_Sym
*sym
;
7357 if (relsec
->sh_type
!= SHT_RELA
7358 || SECTION_HEADER (relsec
->sh_info
) != section
7359 || relsec
->sh_size
== 0)
7362 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7366 symsec
= SECTION_HEADER (relsec
->sh_link
);
7367 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7369 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7373 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7374 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7375 loc
= sec_data
+ rp
->r_offset
;
7381 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7383 if (ELF32_R_SYM (rp
->r_info
) != 0
7384 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7385 /* Relocations against object symbols can happen,
7386 eg when referencing a global array. For an
7387 example of this see the _clz.o binary in libgcc.a. */
7388 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7390 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7391 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7392 SECTION_NAME (section
));
7398 /* In MIPS little-endian objects, r_info isn't really a
7399 64-bit little-endian value: it has a 32-bit little-endian
7400 symbol index followed by four individual byte fields.
7401 Reorder INFO accordingly. */
7402 if (elf_header
.e_machine
== EM_MIPS
7403 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7404 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7405 | ((rp
->r_info
>> 56) & 0xff)
7406 | ((rp
->r_info
>> 40) & 0xff00)
7407 | ((rp
->r_info
>> 24) & 0xff0000)
7408 | ((rp
->r_info
>> 8) & 0xff000000));
7410 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7412 if (ELF64_R_SYM (rp
->r_info
) != 0
7413 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7414 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7416 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7417 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7418 SECTION_NAME (section
));
7423 byte_put (loc
, rp
->r_addend
, reloc_size
);
7433 /* FIXME: There are better and more efficient ways to handle
7434 these structures. For now though, I just want something that
7435 is simple to implement. */
7436 typedef struct abbrev_attr
7438 unsigned long attribute
;
7440 struct abbrev_attr
*next
;
7444 typedef struct abbrev_entry
7446 unsigned long entry
;
7449 struct abbrev_attr
*first_attr
;
7450 struct abbrev_attr
*last_attr
;
7451 struct abbrev_entry
*next
;
7455 static abbrev_entry
*first_abbrev
= NULL
;
7456 static abbrev_entry
*last_abbrev
= NULL
;
7461 abbrev_entry
*abbrev
;
7463 for (abbrev
= first_abbrev
; abbrev
;)
7465 abbrev_entry
*next
= abbrev
->next
;
7468 for (attr
= abbrev
->first_attr
; attr
;)
7470 abbrev_attr
*next
= attr
->next
;
7480 last_abbrev
= first_abbrev
= NULL
;
7484 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7486 abbrev_entry
*entry
;
7488 entry
= malloc (sizeof (*entry
));
7494 entry
->entry
= number
;
7496 entry
->children
= children
;
7497 entry
->first_attr
= NULL
;
7498 entry
->last_attr
= NULL
;
7501 if (first_abbrev
== NULL
)
7502 first_abbrev
= entry
;
7504 last_abbrev
->next
= entry
;
7506 last_abbrev
= entry
;
7510 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7514 attr
= malloc (sizeof (*attr
));
7520 attr
->attribute
= attribute
;
7524 if (last_abbrev
->first_attr
== NULL
)
7525 last_abbrev
->first_attr
= attr
;
7527 last_abbrev
->last_attr
->next
= attr
;
7529 last_abbrev
->last_attr
= attr
;
7532 /* Processes the (partial) contents of a .debug_abbrev section.
7533 Returns NULL if the end of the section was encountered.
7534 Returns the address after the last byte read if the end of
7535 an abbreviation set was found. */
7537 static unsigned char *
7538 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7540 if (first_abbrev
!= NULL
)
7545 unsigned int bytes_read
;
7546 unsigned long entry
;
7548 unsigned long attribute
;
7551 entry
= read_leb128 (start
, & bytes_read
, 0);
7552 start
+= bytes_read
;
7554 /* A single zero is supposed to end the section according
7555 to the standard. If there's more, then signal that to
7558 return start
== end
? NULL
: start
;
7560 tag
= read_leb128 (start
, & bytes_read
, 0);
7561 start
+= bytes_read
;
7563 children
= *start
++;
7565 add_abbrev (entry
, tag
, children
);
7571 attribute
= read_leb128 (start
, & bytes_read
, 0);
7572 start
+= bytes_read
;
7574 form
= read_leb128 (start
, & bytes_read
, 0);
7575 start
+= bytes_read
;
7578 add_abbrev_attr (attribute
, form
);
7580 while (attribute
!= 0);
7587 get_TAG_name (unsigned long tag
)
7591 case DW_TAG_padding
: return "DW_TAG_padding";
7592 case DW_TAG_array_type
: return "DW_TAG_array_type";
7593 case DW_TAG_class_type
: return "DW_TAG_class_type";
7594 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7595 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7596 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7597 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7598 case DW_TAG_label
: return "DW_TAG_label";
7599 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7600 case DW_TAG_member
: return "DW_TAG_member";
7601 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7602 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7603 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7604 case DW_TAG_string_type
: return "DW_TAG_string_type";
7605 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7606 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7607 case DW_TAG_typedef
: return "DW_TAG_typedef";
7608 case DW_TAG_union_type
: return "DW_TAG_union_type";
7609 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7610 case DW_TAG_variant
: return "DW_TAG_variant";
7611 case DW_TAG_common_block
: return "DW_TAG_common_block";
7612 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7613 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7614 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7615 case DW_TAG_module
: return "DW_TAG_module";
7616 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7617 case DW_TAG_set_type
: return "DW_TAG_set_type";
7618 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7619 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7620 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7621 case DW_TAG_base_type
: return "DW_TAG_base_type";
7622 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7623 case DW_TAG_const_type
: return "DW_TAG_const_type";
7624 case DW_TAG_constant
: return "DW_TAG_constant";
7625 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7626 case DW_TAG_file_type
: return "DW_TAG_file_type";
7627 case DW_TAG_friend
: return "DW_TAG_friend";
7628 case DW_TAG_namelist
: return "DW_TAG_namelist";
7629 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7630 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7631 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7632 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7633 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7634 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7635 case DW_TAG_try_block
: return "DW_TAG_try_block";
7636 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7637 case DW_TAG_variable
: return "DW_TAG_variable";
7638 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7639 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7640 case DW_TAG_format_label
: return "DW_TAG_format_label";
7641 case DW_TAG_function_template
: return "DW_TAG_function_template";
7642 case DW_TAG_class_template
: return "DW_TAG_class_template";
7643 /* DWARF 2.1 values. */
7644 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7645 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7646 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7647 case DW_TAG_namespace
: return "DW_TAG_namespace";
7648 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7649 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7650 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7651 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7653 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7654 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7655 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7658 static char buffer
[100];
7660 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
7667 get_FORM_name (unsigned long form
)
7671 case DW_FORM_addr
: return "DW_FORM_addr";
7672 case DW_FORM_block2
: return "DW_FORM_block2";
7673 case DW_FORM_block4
: return "DW_FORM_block4";
7674 case DW_FORM_data2
: return "DW_FORM_data2";
7675 case DW_FORM_data4
: return "DW_FORM_data4";
7676 case DW_FORM_data8
: return "DW_FORM_data8";
7677 case DW_FORM_string
: return "DW_FORM_string";
7678 case DW_FORM_block
: return "DW_FORM_block";
7679 case DW_FORM_block1
: return "DW_FORM_block1";
7680 case DW_FORM_data1
: return "DW_FORM_data1";
7681 case DW_FORM_flag
: return "DW_FORM_flag";
7682 case DW_FORM_sdata
: return "DW_FORM_sdata";
7683 case DW_FORM_strp
: return "DW_FORM_strp";
7684 case DW_FORM_udata
: return "DW_FORM_udata";
7685 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7686 case DW_FORM_ref1
: return "DW_FORM_ref1";
7687 case DW_FORM_ref2
: return "DW_FORM_ref2";
7688 case DW_FORM_ref4
: return "DW_FORM_ref4";
7689 case DW_FORM_ref8
: return "DW_FORM_ref8";
7690 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7691 case DW_FORM_indirect
: return "DW_FORM_indirect";
7694 static char buffer
[100];
7696 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
7702 static unsigned char *
7703 display_block (unsigned char *data
, unsigned long length
)
7705 printf (_(" %lu byte block: "), length
);
7708 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7714 decode_location_expression (unsigned char * data
,
7715 unsigned int pointer_size
,
7716 unsigned long length
,
7717 unsigned long cu_offset
)
7720 unsigned int bytes_read
;
7721 unsigned long uvalue
;
7722 unsigned char *end
= data
+ length
;
7723 int need_frame_base
= 0;
7732 printf ("DW_OP_addr: %lx",
7733 (unsigned long) byte_get (data
, pointer_size
));
7734 data
+= pointer_size
;
7737 printf ("DW_OP_deref");
7740 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7743 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7746 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7750 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7754 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7758 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7762 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7763 (unsigned long) byte_get (data
+ 4, 4));
7767 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7768 (long) byte_get (data
+ 4, 4));
7772 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7776 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7780 printf ("DW_OP_dup");
7783 printf ("DW_OP_drop");
7786 printf ("DW_OP_over");
7789 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7792 printf ("DW_OP_swap");
7795 printf ("DW_OP_rot");
7798 printf ("DW_OP_xderef");
7801 printf ("DW_OP_abs");
7804 printf ("DW_OP_and");
7807 printf ("DW_OP_div");
7810 printf ("DW_OP_minus");
7813 printf ("DW_OP_mod");
7816 printf ("DW_OP_mul");
7819 printf ("DW_OP_neg");
7822 printf ("DW_OP_not");
7825 printf ("DW_OP_or");
7828 printf ("DW_OP_plus");
7830 case DW_OP_plus_uconst
:
7831 printf ("DW_OP_plus_uconst: %lu",
7832 read_leb128 (data
, &bytes_read
, 0));
7836 printf ("DW_OP_shl");
7839 printf ("DW_OP_shr");
7842 printf ("DW_OP_shra");
7845 printf ("DW_OP_xor");
7848 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7852 printf ("DW_OP_eq");
7855 printf ("DW_OP_ge");
7858 printf ("DW_OP_gt");
7861 printf ("DW_OP_le");
7864 printf ("DW_OP_lt");
7867 printf ("DW_OP_ne");
7870 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7906 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7941 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7976 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7977 read_leb128 (data
, &bytes_read
, 1));
7982 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7986 need_frame_base
= 1;
7987 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7991 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7993 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7994 read_leb128 (data
, &bytes_read
, 1));
7998 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8001 case DW_OP_deref_size
:
8002 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8004 case DW_OP_xderef_size
:
8005 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8008 printf ("DW_OP_nop");
8011 /* DWARF 3 extensions. */
8012 case DW_OP_push_object_address
:
8013 printf ("DW_OP_push_object_address");
8016 /* XXX: Strictly speaking for 64-bit DWARF3 files
8017 this ought to be an 8-byte wide computation. */
8018 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8022 /* XXX: Strictly speaking for 64-bit DWARF3 files
8023 this ought to be an 8-byte wide computation. */
8024 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8027 case DW_OP_call_ref
:
8028 printf ("DW_OP_call_ref");
8031 /* GNU extensions. */
8032 case DW_OP_GNU_push_tls_address
:
8033 printf ("DW_OP_GNU_push_tls_address");
8037 if (op
>= DW_OP_lo_user
8038 && op
<= DW_OP_hi_user
)
8039 printf (_("(User defined location op)"));
8041 printf (_("(Unknown location op)"));
8042 /* No way to tell where the next op is, so just bail. */
8043 return need_frame_base
;
8046 /* Separate the ops. */
8051 return need_frame_base
;
8054 /* This structure records the information that
8055 we extract from the.debug_info section. */
8058 unsigned int pointer_size
;
8059 unsigned long cu_offset
;
8060 unsigned long base_address
;
8061 /* This is an array of offsets to the location list table. */
8062 unsigned long *loc_offsets
;
8063 int *have_frame_base
;
8064 unsigned int num_loc_offsets
;
8065 unsigned int max_loc_offsets
;
8066 unsigned long *range_lists
;
8067 unsigned int num_range_lists
;
8068 unsigned int max_range_lists
;
8072 static debug_info
* debug_information
= NULL
;
8073 static unsigned int num_debug_info_entries
= 0;
8074 static unsigned int last_pointer_size
= 0;
8075 static int warned_about_missing_comp_units
= FALSE
;
8077 static unsigned char *
8078 read_and_display_attr_value (unsigned long attribute
,
8080 unsigned char *data
,
8081 unsigned long cu_offset
,
8082 unsigned long pointer_size
,
8083 unsigned long offset_size
,
8085 debug_info
*debug_info_p
,
8088 unsigned long uvalue
= 0;
8089 unsigned char *block_start
= NULL
;
8090 unsigned int bytes_read
;
8097 case DW_FORM_ref_addr
:
8098 if (dwarf_version
== 2)
8100 uvalue
= byte_get (data
, pointer_size
);
8101 data
+= pointer_size
;
8103 else if (dwarf_version
== 3)
8105 uvalue
= byte_get (data
, offset_size
);
8106 data
+= offset_size
;
8110 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8115 uvalue
= byte_get (data
, pointer_size
);
8116 data
+= pointer_size
;
8120 uvalue
= byte_get (data
, offset_size
);
8121 data
+= offset_size
;
8127 uvalue
= byte_get (data
++, 1);
8132 uvalue
= byte_get (data
, 2);
8138 uvalue
= byte_get (data
, 4);
8143 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8147 case DW_FORM_ref_udata
:
8149 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8153 case DW_FORM_indirect
:
8154 form
= read_leb128 (data
, & bytes_read
, 0);
8157 printf (" %s", get_FORM_name (form
));
8158 return read_and_display_attr_value (attribute
, form
, data
,
8159 cu_offset
, pointer_size
,
8160 offset_size
, dwarf_version
,
8161 debug_info_p
, do_loc
);
8166 case DW_FORM_ref_addr
:
8168 printf (" <#%lx>", uvalue
);
8174 case DW_FORM_ref_udata
:
8176 printf (" <%lx>", uvalue
+ cu_offset
);
8182 printf (" %#lx", uvalue
);
8191 printf (" %ld", uvalue
);
8198 uvalue
= byte_get (data
, 4);
8199 printf (" %lx", uvalue
);
8200 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8202 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8203 && num_debug_info_entries
== 0)
8205 if (sizeof (uvalue
) == 8)
8206 uvalue
= byte_get (data
, 8);
8208 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8213 case DW_FORM_string
:
8215 printf (" %s", data
);
8216 data
+= strlen ((char *) data
) + 1;
8220 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8221 block_start
= data
+ bytes_read
;
8223 data
= block_start
+ uvalue
;
8225 data
= display_block (block_start
, uvalue
);
8228 case DW_FORM_block1
:
8229 uvalue
= byte_get (data
, 1);
8230 block_start
= data
+ 1;
8232 data
= block_start
+ uvalue
;
8234 data
= display_block (block_start
, uvalue
);
8237 case DW_FORM_block2
:
8238 uvalue
= byte_get (data
, 2);
8239 block_start
= data
+ 2;
8241 data
= block_start
+ uvalue
;
8243 data
= display_block (block_start
, uvalue
);
8246 case DW_FORM_block4
:
8247 uvalue
= byte_get (data
, 4);
8248 block_start
= data
+ 4;
8250 data
= block_start
+ uvalue
;
8252 data
= display_block (block_start
, uvalue
);
8257 printf (_(" (indirect string, offset: 0x%lx): %s"),
8258 uvalue
, fetch_indirect_string (uvalue
));
8261 case DW_FORM_indirect
:
8262 /* Handled above. */
8266 warn (_("Unrecognized form: %d\n"), form
);
8270 /* For some attributes we can display further information. */
8271 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8272 && num_debug_info_entries
== 0)
8276 case DW_AT_frame_base
:
8277 have_frame_base
= 1;
8278 case DW_AT_location
:
8279 case DW_AT_data_member_location
:
8280 case DW_AT_vtable_elem_location
:
8281 case DW_AT_allocated
:
8282 case DW_AT_associated
:
8283 case DW_AT_data_location
:
8285 case DW_AT_upper_bound
:
8286 case DW_AT_lower_bound
:
8287 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8289 /* Process location list. */
8290 unsigned int max
= debug_info_p
->max_loc_offsets
;
8291 unsigned int num
= debug_info_p
->num_loc_offsets
;
8293 if (max
== 0 || num
>= max
)
8296 debug_info_p
->loc_offsets
8297 = xrealloc (debug_info_p
->loc_offsets
,
8298 max
* sizeof (*debug_info_p
->loc_offsets
));
8299 debug_info_p
->have_frame_base
8300 = xrealloc (debug_info_p
->have_frame_base
,
8301 max
* sizeof (*debug_info_p
->have_frame_base
));
8302 debug_info_p
->max_loc_offsets
= max
;
8304 debug_info_p
->loc_offsets
[num
] = uvalue
;
8305 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8306 debug_info_p
->num_loc_offsets
++;
8311 if (need_base_address
)
8312 debug_info_p
->base_address
= uvalue
;
8316 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8318 /* Process range list. */
8319 unsigned int max
= debug_info_p
->max_range_lists
;
8320 unsigned int num
= debug_info_p
->num_range_lists
;
8322 if (max
== 0 || num
>= max
)
8325 debug_info_p
->range_lists
8326 = xrealloc (debug_info_p
->range_lists
,
8327 max
* sizeof (*debug_info_p
->range_lists
));
8328 debug_info_p
->max_range_lists
= max
;
8330 debug_info_p
->range_lists
[num
] = uvalue
;
8331 debug_info_p
->num_range_lists
++;
8350 case DW_INL_not_inlined
:
8351 printf (_("(not inlined)"));
8353 case DW_INL_inlined
:
8354 printf (_("(inlined)"));
8356 case DW_INL_declared_not_inlined
:
8357 printf (_("(declared as inline but ignored)"));
8359 case DW_INL_declared_inlined
:
8360 printf (_("(declared as inline and inlined)"));
8363 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8368 case DW_AT_language
:
8371 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8372 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8373 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8374 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8375 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8376 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8377 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8378 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8379 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8380 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8381 /* DWARF 2.1 values. */
8382 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8383 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8384 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8385 /* MIPS extension. */
8386 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8387 /* UPC extension. */
8388 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8390 printf ("(Unknown: %lx)", uvalue
);
8395 case DW_AT_encoding
:
8398 case DW_ATE_void
: printf ("(void)"); break;
8399 case DW_ATE_address
: printf ("(machine address)"); break;
8400 case DW_ATE_boolean
: printf ("(boolean)"); break;
8401 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8402 case DW_ATE_float
: printf ("(float)"); break;
8403 case DW_ATE_signed
: printf ("(signed)"); break;
8404 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8405 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8406 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8407 /* DWARF 2.1 value. */
8408 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8410 if (uvalue
>= DW_ATE_lo_user
8411 && uvalue
<= DW_ATE_hi_user
)
8412 printf ("(user defined type)");
8414 printf ("(unknown type)");
8419 case DW_AT_accessibility
:
8422 case DW_ACCESS_public
: printf ("(public)"); break;
8423 case DW_ACCESS_protected
: printf ("(protected)"); break;
8424 case DW_ACCESS_private
: printf ("(private)"); break;
8426 printf ("(unknown accessibility)");
8431 case DW_AT_visibility
:
8434 case DW_VIS_local
: printf ("(local)"); break;
8435 case DW_VIS_exported
: printf ("(exported)"); break;
8436 case DW_VIS_qualified
: printf ("(qualified)"); break;
8437 default: printf ("(unknown visibility)"); break;
8441 case DW_AT_virtuality
:
8444 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8445 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8446 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8447 default: printf ("(unknown virtuality)"); break;
8451 case DW_AT_identifier_case
:
8454 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8455 case DW_ID_up_case
: printf ("(up_case)"); break;
8456 case DW_ID_down_case
: printf ("(down_case)"); break;
8457 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8458 default: printf ("(unknown case)"); break;
8462 case DW_AT_calling_convention
:
8465 case DW_CC_normal
: printf ("(normal)"); break;
8466 case DW_CC_program
: printf ("(program)"); break;
8467 case DW_CC_nocall
: printf ("(nocall)"); break;
8469 if (uvalue
>= DW_CC_lo_user
8470 && uvalue
<= DW_CC_hi_user
)
8471 printf ("(user defined)");
8473 printf ("(unknown convention)");
8477 case DW_AT_ordering
:
8480 case -1: printf ("(undefined)"); break;
8481 case 0: printf ("(row major)"); break;
8482 case 1: printf ("(column major)"); break;
8486 case DW_AT_frame_base
:
8487 have_frame_base
= 1;
8488 case DW_AT_location
:
8489 case DW_AT_data_member_location
:
8490 case DW_AT_vtable_elem_location
:
8491 case DW_AT_allocated
:
8492 case DW_AT_associated
:
8493 case DW_AT_data_location
:
8495 case DW_AT_upper_bound
:
8496 case DW_AT_lower_bound
:
8499 int need_frame_base
;
8502 need_frame_base
= decode_location_expression (block_start
,
8507 if (need_frame_base
&& !have_frame_base
)
8508 printf (_(" [without DW_AT_frame_base]"));
8510 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8511 printf (_("(location list)"));
8523 get_AT_name (unsigned long attribute
)
8527 case DW_AT_sibling
: return "DW_AT_sibling";
8528 case DW_AT_location
: return "DW_AT_location";
8529 case DW_AT_name
: return "DW_AT_name";
8530 case DW_AT_ordering
: return "DW_AT_ordering";
8531 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8532 case DW_AT_byte_size
: return "DW_AT_byte_size";
8533 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8534 case DW_AT_bit_size
: return "DW_AT_bit_size";
8535 case DW_AT_element_list
: return "DW_AT_element_list";
8536 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8537 case DW_AT_low_pc
: return "DW_AT_low_pc";
8538 case DW_AT_high_pc
: return "DW_AT_high_pc";
8539 case DW_AT_language
: return "DW_AT_language";
8540 case DW_AT_member
: return "DW_AT_member";
8541 case DW_AT_discr
: return "DW_AT_discr";
8542 case DW_AT_discr_value
: return "DW_AT_discr_value";
8543 case DW_AT_visibility
: return "DW_AT_visibility";
8544 case DW_AT_import
: return "DW_AT_import";
8545 case DW_AT_string_length
: return "DW_AT_string_length";
8546 case DW_AT_common_reference
: return "DW_AT_common_reference";
8547 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8548 case DW_AT_const_value
: return "DW_AT_const_value";
8549 case DW_AT_containing_type
: return "DW_AT_containing_type";
8550 case DW_AT_default_value
: return "DW_AT_default_value";
8551 case DW_AT_inline
: return "DW_AT_inline";
8552 case DW_AT_is_optional
: return "DW_AT_is_optional";
8553 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8554 case DW_AT_producer
: return "DW_AT_producer";
8555 case DW_AT_prototyped
: return "DW_AT_prototyped";
8556 case DW_AT_return_addr
: return "DW_AT_return_addr";
8557 case DW_AT_start_scope
: return "DW_AT_start_scope";
8558 case DW_AT_stride_size
: return "DW_AT_stride_size";
8559 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8560 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8561 case DW_AT_accessibility
: return "DW_AT_accessibility";
8562 case DW_AT_address_class
: return "DW_AT_address_class";
8563 case DW_AT_artificial
: return "DW_AT_artificial";
8564 case DW_AT_base_types
: return "DW_AT_base_types";
8565 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8566 case DW_AT_count
: return "DW_AT_count";
8567 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8568 case DW_AT_decl_column
: return "DW_AT_decl_column";
8569 case DW_AT_decl_file
: return "DW_AT_decl_file";
8570 case DW_AT_decl_line
: return "DW_AT_decl_line";
8571 case DW_AT_declaration
: return "DW_AT_declaration";
8572 case DW_AT_discr_list
: return "DW_AT_discr_list";
8573 case DW_AT_encoding
: return "DW_AT_encoding";
8574 case DW_AT_external
: return "DW_AT_external";
8575 case DW_AT_frame_base
: return "DW_AT_frame_base";
8576 case DW_AT_friend
: return "DW_AT_friend";
8577 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8578 case DW_AT_macro_info
: return "DW_AT_macro_info";
8579 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8580 case DW_AT_priority
: return "DW_AT_priority";
8581 case DW_AT_segment
: return "DW_AT_segment";
8582 case DW_AT_specification
: return "DW_AT_specification";
8583 case DW_AT_static_link
: return "DW_AT_static_link";
8584 case DW_AT_type
: return "DW_AT_type";
8585 case DW_AT_use_location
: return "DW_AT_use_location";
8586 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8587 case DW_AT_virtuality
: return "DW_AT_virtuality";
8588 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8589 /* DWARF 2.1 values. */
8590 case DW_AT_allocated
: return "DW_AT_allocated";
8591 case DW_AT_associated
: return "DW_AT_associated";
8592 case DW_AT_data_location
: return "DW_AT_data_location";
8593 case DW_AT_stride
: return "DW_AT_stride";
8594 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8595 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8596 case DW_AT_extension
: return "DW_AT_extension";
8597 case DW_AT_ranges
: return "DW_AT_ranges";
8598 case DW_AT_trampoline
: return "DW_AT_trampoline";
8599 case DW_AT_call_column
: return "DW_AT_call_column";
8600 case DW_AT_call_file
: return "DW_AT_call_file";
8601 case DW_AT_call_line
: return "DW_AT_call_line";
8602 /* SGI/MIPS extensions. */
8603 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8604 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8605 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8606 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8607 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8608 case DW_AT_MIPS_software_pipeline_depth
:
8609 return "DW_AT_MIPS_software_pipeline_depth";
8610 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8611 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8612 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8613 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8614 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8615 /* GNU extensions. */
8616 case DW_AT_sf_names
: return "DW_AT_sf_names";
8617 case DW_AT_src_info
: return "DW_AT_src_info";
8618 case DW_AT_mac_info
: return "DW_AT_mac_info";
8619 case DW_AT_src_coords
: return "DW_AT_src_coords";
8620 case DW_AT_body_begin
: return "DW_AT_body_begin";
8621 case DW_AT_body_end
: return "DW_AT_body_end";
8622 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8623 /* UPC extension. */
8624 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8627 static char buffer
[100];
8629 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8636 static unsigned char *
8637 read_and_display_attr (unsigned long attribute
,
8639 unsigned char *data
,
8640 unsigned long cu_offset
,
8641 unsigned long pointer_size
,
8642 unsigned long offset_size
,
8644 debug_info
*debug_info_p
,
8648 printf (" %-18s:", get_AT_name (attribute
));
8649 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8650 pointer_size
, offset_size
,
8651 dwarf_version
, debug_info_p
,
8659 /* Process the contents of a .debug_info section. If do_loc is non-zero
8660 then we are scanning for location lists and we do not want to display
8661 anything to the user. */
8664 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8665 FILE *file
, int do_loc
)
8667 unsigned char *end
= start
+ section
->sh_size
;
8668 unsigned char *section_begin
;
8670 unsigned int num_units
= 0;
8672 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8673 && num_debug_info_entries
== 0)
8675 unsigned long length
;
8677 /* First scan the section to get the number of comp units. */
8678 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8681 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8682 will be the length. For a 64-bit DWARF section, it'll be
8683 the escape code 0xffffffff followed by an 8 byte length. */
8684 length
= byte_get (section_begin
, 4);
8686 if (length
== 0xffffffff)
8688 length
= byte_get (section_begin
+ 4, 8);
8689 section_begin
+= length
+ 12;
8692 section_begin
+= length
+ 4;
8697 error (_("No comp units in .debug_info section ?"));
8701 /* Then allocate an array to hold the information. */
8702 debug_information
= malloc (num_units
*
8703 sizeof (* debug_information
));
8704 if (debug_information
== NULL
)
8706 error (_("Not enough memory for a debug info array of %u entries"),
8714 printf (_("The section %s contains:\n\n"),
8715 SECTION_NAME (section
));
8717 load_debug_str (file
);
8718 load_debug_loc (file
);
8719 load_debug_range (file
);
8722 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8724 DWARF2_Internal_CompUnit compunit
;
8725 unsigned char *hdrptr
;
8726 unsigned char *cu_abbrev_offset_ptr
;
8727 unsigned char *tags
;
8729 unsigned long cu_offset
;
8731 int initial_length_size
;
8735 compunit
.cu_length
= byte_get (hdrptr
, 4);
8738 if (compunit
.cu_length
== 0xffffffff)
8740 compunit
.cu_length
= byte_get (hdrptr
, 8);
8743 initial_length_size
= 12;
8748 initial_length_size
= 4;
8751 compunit
.cu_version
= byte_get (hdrptr
, 2);
8754 cu_offset
= start
- section_begin
;
8755 start
+= compunit
.cu_length
+ initial_length_size
;
8757 if (elf_header
.e_type
== ET_REL
8758 && !debug_apply_rela_addends (file
, section
, offset_size
,
8759 section_begin
, hdrptr
, start
))
8762 cu_abbrev_offset_ptr
= hdrptr
;
8763 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8764 hdrptr
+= offset_size
;
8766 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8768 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8769 && num_debug_info_entries
== 0)
8771 debug_information
[unit
].cu_offset
= cu_offset
;
8772 debug_information
[unit
].pointer_size
8773 = compunit
.cu_pointer_size
;
8774 debug_information
[unit
].base_address
= 0;
8775 debug_information
[unit
].loc_offsets
= NULL
;
8776 debug_information
[unit
].have_frame_base
= NULL
;
8777 debug_information
[unit
].max_loc_offsets
= 0;
8778 debug_information
[unit
].num_loc_offsets
= 0;
8779 debug_information
[unit
].range_lists
= NULL
;
8780 debug_information
[unit
].max_range_lists
= 0;
8781 debug_information
[unit
].num_range_lists
= 0;
8788 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8789 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8790 printf (_(" Version: %d\n"), compunit
.cu_version
);
8791 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8792 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8795 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8797 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8803 /* Read in the abbrevs used by this compilation unit. */
8805 Elf_Internal_Shdr
*sec
;
8806 unsigned char *begin
;
8808 /* Locate the .debug_abbrev section and process it. */
8809 sec
= find_section (".debug_abbrev");
8812 warn (_("Unable to locate .debug_abbrev section!\n"));
8816 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8817 _("debug_abbrev section data"));
8821 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8822 begin
+ sec
->sh_size
);
8828 while (tags
< start
)
8830 unsigned int bytes_read
;
8831 unsigned long abbrev_number
;
8832 abbrev_entry
*entry
;
8835 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8838 /* A null DIE marks the end of a list of children. */
8839 if (abbrev_number
== 0)
8845 /* Scan through the abbreviation list until we reach the
8847 for (entry
= first_abbrev
;
8848 entry
&& entry
->entry
!= abbrev_number
;
8849 entry
= entry
->next
)
8854 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8860 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8862 (unsigned long) (tags
- section_begin
8865 get_TAG_name (entry
->tag
));
8870 need_base_address
= 0;
8872 case DW_TAG_compile_unit
:
8873 need_base_address
= 1;
8875 case DW_TAG_entry_point
:
8876 case DW_TAG_inlined_subroutine
:
8877 case DW_TAG_subprogram
:
8878 need_base_address
= 0;
8879 /* Assuming that there is no DW_AT_frame_base. */
8880 have_frame_base
= 0;
8884 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8885 tags
= read_and_display_attr (attr
->attribute
,
8888 compunit
.cu_pointer_size
,
8890 compunit
.cu_version
,
8891 &debug_information
[unit
],
8894 if (entry
->children
)
8899 /* Set num_debug_info_entries here so that it can be used to check if
8900 we need to proecess .debug_loc and .debug_ranges sections. */
8901 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8902 && num_debug_info_entries
== 0)
8903 num_debug_info_entries
= num_units
;
8907 free_debug_range ();
8917 /* Retrieve the pointer size associated with the given compilation unit.
8918 Optionally the offset of this unit into the .debug_info section is
8919 also retutned. If there is no .debug_info section then an error
8920 message is issued and 0 is returned. If the requested comp unit has
8921 not been defined in the .debug_info section then a warning message
8922 is issued and the last know pointer size is returned. This message
8923 is only issued once per section dumped per file dumped. */
8926 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8927 const char * section_name
,
8928 unsigned long * offset_return
)
8930 unsigned long offset
= 0;
8932 if (num_debug_info_entries
== 0)
8933 error (_("%s section needs a populated .debug_info section\n"),
8936 else if (comp_unit
>= num_debug_info_entries
)
8938 if (!warned_about_missing_comp_units
)
8940 warn (_("%s section has more comp units than .debug_info section\n"),
8942 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
8944 warned_about_missing_comp_units
= TRUE
;
8949 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
8950 offset
= debug_information
[comp_unit
].cu_offset
;
8953 if (offset_return
!= NULL
)
8954 * offset_return
= offset
;
8956 return last_pointer_size
;
8959 /* Locate and scan the .debug_info section in the file and record the pointer
8960 sizes and offsets for the compilation units in it. Usually an executable
8961 will have just one pointer size, but this is not guaranteed, and so we try
8962 not to make any assumptions. Returns zero upon failure, or the number of
8963 compilation units upon success. */
8966 get_debug_info (FILE * file
)
8968 Elf_Internal_Shdr
* section
;
8969 unsigned char * start
;
8972 /* Reset the last pointer size so that we can issue correct error
8973 messages if we are displaying the contents of more than one section. */
8974 last_pointer_size
= 0;
8975 warned_about_missing_comp_units
= FALSE
;
8977 /* If we already have the information there is nothing else to do. */
8978 if (num_debug_info_entries
> 0)
8979 return num_debug_info_entries
;
8981 section
= find_section (".debug_info");
8982 if (section
== NULL
)
8985 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
8986 _("extracting information from .debug_info section"));
8990 ret
= process_debug_info (section
, start
, file
, 1);
8993 return ret
? num_debug_info_entries
: 0;
8997 display_debug_lines (Elf_Internal_Shdr
*section
,
8998 unsigned char *start
, FILE *file
)
9000 unsigned char *data
= start
;
9001 unsigned char *end
= start
+ section
->sh_size
;
9002 unsigned int comp_unit
= 0;
9004 printf (_("\nDump of debug contents of section %s:\n\n"),
9005 SECTION_NAME (section
));
9007 get_debug_info (file
);
9011 DWARF2_Internal_LineInfo info
;
9012 unsigned char *standard_opcodes
;
9013 unsigned char *end_of_sequence
;
9014 unsigned char *hdrptr
;
9015 unsigned int pointer_size
;
9016 int initial_length_size
;
9022 /* Check the length of the block. */
9023 info
.li_length
= byte_get (hdrptr
, 4);
9026 if (info
.li_length
== 0xffffffff)
9028 /* This section is 64-bit DWARF 3. */
9029 info
.li_length
= byte_get (hdrptr
, 8);
9032 initial_length_size
= 12;
9037 initial_length_size
= 4;
9040 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9043 (_("The line info appears to be corrupt - the section is too small\n"));
9047 /* Check its version number. */
9048 info
.li_version
= byte_get (hdrptr
, 2);
9050 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9052 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9056 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9057 hdrptr
+= offset_size
;
9058 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9060 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9062 info
.li_line_base
= byte_get (hdrptr
, 1);
9064 info
.li_line_range
= byte_get (hdrptr
, 1);
9066 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9069 /* Sign extend the line base field. */
9070 info
.li_line_base
<<= 24;
9071 info
.li_line_base
>>= 24;
9073 /* Get the pointer size from the comp unit associated
9074 with this block of line number information. */
9075 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9076 (comp_unit
, ".debug_lines", NULL
);
9079 printf (_(" Length: %ld\n"), info
.li_length
);
9080 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9081 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9082 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9083 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9084 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9085 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9086 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9087 printf (_(" (Pointer size: %u)\n"), pointer_size
);
9089 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9091 reset_state_machine (info
.li_default_is_stmt
);
9093 /* Display the contents of the Opcodes table. */
9094 standard_opcodes
= hdrptr
;
9096 printf (_("\n Opcodes:\n"));
9098 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9099 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9101 /* Display the contents of the Directory table. */
9102 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9105 printf (_("\n The Directory Table is empty.\n"));
9108 printf (_("\n The Directory Table:\n"));
9112 printf (_(" %s\n"), data
);
9114 data
+= strlen ((char *) data
) + 1;
9118 /* Skip the NUL at the end of the table. */
9121 /* Display the contents of the File Name table. */
9123 printf (_("\n The File Name Table is empty.\n"));
9126 printf (_("\n The File Name Table:\n"));
9127 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9131 unsigned char *name
;
9132 unsigned int bytes_read
;
9134 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9137 data
+= strlen ((char *) data
) + 1;
9139 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9141 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9143 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9145 printf (_("%s\n"), name
);
9149 /* Skip the NUL at the end of the table. */
9152 /* Now display the statements. */
9153 printf (_("\n Line Number Statements:\n"));
9155 while (data
< end_of_sequence
)
9157 unsigned char op_code
;
9159 unsigned int bytes_read
;
9163 if (op_code
>= info
.li_opcode_base
)
9165 op_code
-= info
.li_opcode_base
;
9166 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9167 state_machine_regs
.address
+= adv
;
9168 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9169 op_code
, adv
, state_machine_regs
.address
);
9170 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9171 state_machine_regs
.line
+= adv
;
9172 printf (_(" and Line by %d to %d\n"),
9173 adv
, state_machine_regs
.line
);
9175 else switch (op_code
)
9177 case DW_LNS_extended_op
:
9178 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9183 printf (_(" Copy\n"));
9186 case DW_LNS_advance_pc
:
9187 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9189 state_machine_regs
.address
+= adv
;
9190 printf (_(" Advance PC by %d to %lx\n"), adv
,
9191 state_machine_regs
.address
);
9194 case DW_LNS_advance_line
:
9195 adv
= read_leb128 (data
, & bytes_read
, 1);
9197 state_machine_regs
.line
+= adv
;
9198 printf (_(" Advance Line by %d to %d\n"), adv
,
9199 state_machine_regs
.line
);
9202 case DW_LNS_set_file
:
9203 adv
= read_leb128 (data
, & bytes_read
, 0);
9205 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9207 state_machine_regs
.file
= adv
;
9210 case DW_LNS_set_column
:
9211 adv
= read_leb128 (data
, & bytes_read
, 0);
9213 printf (_(" Set column to %d\n"), adv
);
9214 state_machine_regs
.column
= adv
;
9217 case DW_LNS_negate_stmt
:
9218 adv
= state_machine_regs
.is_stmt
;
9220 printf (_(" Set is_stmt to %d\n"), adv
);
9221 state_machine_regs
.is_stmt
= adv
;
9224 case DW_LNS_set_basic_block
:
9225 printf (_(" Set basic block\n"));
9226 state_machine_regs
.basic_block
= 1;
9229 case DW_LNS_const_add_pc
:
9230 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9231 * info
.li_min_insn_length
);
9232 state_machine_regs
.address
+= adv
;
9233 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9234 state_machine_regs
.address
);
9237 case DW_LNS_fixed_advance_pc
:
9238 adv
= byte_get (data
, 2);
9240 state_machine_regs
.address
+= adv
;
9241 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9242 adv
, state_machine_regs
.address
);
9245 case DW_LNS_set_prologue_end
:
9246 printf (_(" Set prologue_end to true\n"));
9249 case DW_LNS_set_epilogue_begin
:
9250 printf (_(" Set epilogue_begin to true\n"));
9253 case DW_LNS_set_isa
:
9254 adv
= read_leb128 (data
, & bytes_read
, 0);
9256 printf (_(" Set ISA to %d\n"), adv
);
9260 printf (_(" Unknown opcode %d with operands: "), op_code
);
9262 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9264 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9265 i
== 1 ? "" : ", ");
9279 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9280 unsigned char *start
,
9281 FILE *file ATTRIBUTE_UNUSED
)
9283 DWARF2_Internal_PubNames pubnames
;
9286 end
= start
+ section
->sh_size
;
9288 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9292 unsigned char *data
;
9293 unsigned long offset
;
9294 int offset_size
, initial_length_size
;
9298 pubnames
.pn_length
= byte_get (data
, 4);
9300 if (pubnames
.pn_length
== 0xffffffff)
9302 pubnames
.pn_length
= byte_get (data
, 8);
9305 initial_length_size
= 12;
9310 initial_length_size
= 4;
9313 pubnames
.pn_version
= byte_get (data
, 2);
9315 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9316 data
+= offset_size
;
9317 pubnames
.pn_size
= byte_get (data
, offset_size
);
9318 data
+= offset_size
;
9320 start
+= pubnames
.pn_length
+ initial_length_size
;
9322 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9324 static int warned
= 0;
9328 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9335 printf (_(" Length: %ld\n"),
9336 pubnames
.pn_length
);
9337 printf (_(" Version: %d\n"),
9338 pubnames
.pn_version
);
9339 printf (_(" Offset into .debug_info section: %ld\n"),
9340 pubnames
.pn_offset
);
9341 printf (_(" Size of area in .debug_info section: %ld\n"),
9344 printf (_("\n Offset\tName\n"));
9348 offset
= byte_get (data
, offset_size
);
9352 data
+= offset_size
;
9353 printf (" %-6ld\t\t%s\n", offset
, data
);
9354 data
+= strlen ((char *) data
) + 1;
9357 while (offset
!= 0);
9365 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9366 unsigned char *start
,
9367 FILE *file ATTRIBUTE_UNUSED
)
9369 unsigned char *end
= start
+ section
->sh_size
;
9370 unsigned char *curr
= start
;
9371 unsigned int bytes_read
;
9372 enum dwarf_macinfo_record_type op
;
9374 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9378 unsigned int lineno
;
9386 case DW_MACINFO_start_file
:
9388 unsigned int filenum
;
9390 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9392 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9395 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9400 case DW_MACINFO_end_file
:
9401 printf (_(" DW_MACINFO_end_file\n"));
9404 case DW_MACINFO_define
:
9405 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9407 string
= (char *) curr
;
9408 curr
+= strlen (string
) + 1;
9409 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9413 case DW_MACINFO_undef
:
9414 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9416 string
= (char *) curr
;
9417 curr
+= strlen (string
) + 1;
9418 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9422 case DW_MACINFO_vendor_ext
:
9424 unsigned int constant
;
9426 constant
= read_leb128 (curr
, & bytes_read
, 0);
9428 string
= (char *) curr
;
9429 curr
+= strlen (string
) + 1;
9430 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9442 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9443 unsigned char *start
,
9444 FILE *file ATTRIBUTE_UNUSED
)
9446 abbrev_entry
*entry
;
9447 unsigned char *end
= start
+ section
->sh_size
;
9449 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9453 start
= process_abbrev_section (start
, end
);
9455 if (first_abbrev
== NULL
)
9458 printf (_(" Number TAG\n"));
9460 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9464 printf (_(" %ld %s [%s]\n"),
9466 get_TAG_name (entry
->tag
),
9467 entry
->children
? _("has children") : _("no children"));
9469 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9470 printf (_(" %-18s %s\n"),
9471 get_AT_name (attr
->attribute
),
9472 get_FORM_name (attr
->form
));
9485 display_debug_loc (Elf_Internal_Shdr
*section
,
9486 unsigned char *start
, FILE *file
)
9488 unsigned char *section_end
;
9489 unsigned long bytes
;
9490 unsigned char *section_begin
= start
;
9491 unsigned int num_loc_list
= 0;
9492 unsigned long last_offset
= 0;
9493 unsigned int first
= 0;
9496 int seen_first_offset
= 0;
9497 int use_debug_info
= 1;
9498 unsigned char *next
;
9500 bytes
= section
->sh_size
;
9501 section_end
= start
+ bytes
;
9505 printf (_("\nThe .debug_loc section is empty.\n"));
9509 get_debug_info (file
);
9511 /* Check the order of location list in .debug_info section. If
9512 offsets of location lists are in the ascending order, we can
9513 use `debug_information' directly. */
9514 for (i
= 0; i
< num_debug_info_entries
; i
++)
9518 num
= debug_information
[i
].num_loc_offsets
;
9519 num_loc_list
+= num
;
9521 /* Check if we can use `debug_information' directly. */
9522 if (use_debug_info
&& num
!= 0)
9524 if (!seen_first_offset
)
9526 /* This is the first location list. */
9527 last_offset
= debug_information
[i
].loc_offsets
[0];
9529 seen_first_offset
= 1;
9535 for (; j
< num
; j
++)
9538 debug_information
[i
].loc_offsets
[j
])
9543 last_offset
= debug_information
[i
].loc_offsets
[j
];
9548 if (!use_debug_info
)
9549 /* FIXME: Should we handle this case? */
9550 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9552 if (!seen_first_offset
)
9553 error (_("No location lists in .debug_info section!\n"));
9555 if (debug_information
[first
].loc_offsets
[0] != 0)
9556 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9557 debug_information
[first
].loc_offsets
[0]);
9559 printf (_("Contents of the .debug_loc section:\n\n"));
9560 printf (_(" Offset Begin End Expression\n"));
9562 seen_first_offset
= 0;
9563 for (i
= first
; i
< num_debug_info_entries
; i
++)
9565 unsigned long begin
;
9567 unsigned short length
;
9568 unsigned long offset
;
9569 unsigned int pointer_size
;
9570 unsigned long cu_offset
;
9571 unsigned long base_address
;
9572 int need_frame_base
;
9575 pointer_size
= debug_information
[i
].pointer_size
;
9576 cu_offset
= debug_information
[i
].cu_offset
;
9578 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9580 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9581 offset
= debug_information
[i
].loc_offsets
[j
];
9582 next
= section_begin
+ offset
;
9583 base_address
= debug_information
[i
].base_address
;
9585 if (!seen_first_offset
)
9586 seen_first_offset
= 1;
9590 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9591 start
- section_begin
, next
- section_begin
);
9592 else if (start
> next
)
9593 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9594 start
- section_begin
, next
- section_begin
);
9600 begin
= byte_get (start
, pointer_size
);
9601 start
+= pointer_size
;
9602 end
= byte_get (start
, pointer_size
);
9603 start
+= pointer_size
;
9605 if (begin
== 0 && end
== 0)
9607 printf (_(" %8.8lx <End of list>\n"), offset
);
9611 /* Check base address specifiers. */
9612 if (begin
== -1UL && end
!= -1UL)
9615 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9616 offset
, begin
, end
);
9620 length
= byte_get (start
, 2);
9623 printf (" %8.8lx %8.8lx %8.8lx (",
9624 offset
, begin
+ base_address
, end
+ base_address
);
9625 need_frame_base
= decode_location_expression (start
,
9631 if (need_frame_base
&& !has_frame_base
)
9632 printf (_(" [without DW_AT_frame_base]"));
9635 fputs (_(" (start == end)"), stdout
);
9636 else if (begin
> end
)
9637 fputs (_(" (start > end)"), stdout
);
9649 display_debug_str (Elf_Internal_Shdr
*section
,
9650 unsigned char *start
,
9651 FILE *file ATTRIBUTE_UNUSED
)
9653 unsigned long bytes
;
9656 addr
= section
->sh_addr
;
9657 bytes
= section
->sh_size
;
9661 printf (_("\nThe .debug_str section is empty.\n"));
9665 printf (_("Contents of the .debug_str section:\n\n"));
9673 lbytes
= (bytes
> 16 ? 16 : bytes
);
9675 printf (" 0x%8.8lx ", (unsigned long) addr
);
9677 for (j
= 0; j
< 16; j
++)
9680 printf ("%2.2x", start
[j
]);
9688 for (j
= 0; j
< lbytes
; j
++)
9691 if (k
>= ' ' && k
< 0x80)
9711 display_debug_info (Elf_Internal_Shdr
* section
,
9712 unsigned char * start
, FILE * file
)
9714 return process_debug_info (section
, start
, file
, 0);
9719 display_debug_aranges (Elf_Internal_Shdr
*section
,
9720 unsigned char *start
,
9721 FILE *file ATTRIBUTE_UNUSED
)
9723 unsigned char *end
= start
+ section
->sh_size
;
9725 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9729 unsigned char *hdrptr
;
9730 DWARF2_Internal_ARange arange
;
9731 unsigned char *ranges
;
9732 unsigned long length
;
9733 unsigned long address
;
9736 int initial_length_size
;
9740 arange
.ar_length
= byte_get (hdrptr
, 4);
9743 if (arange
.ar_length
== 0xffffffff)
9745 arange
.ar_length
= byte_get (hdrptr
, 8);
9748 initial_length_size
= 12;
9753 initial_length_size
= 4;
9756 arange
.ar_version
= byte_get (hdrptr
, 2);
9759 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9760 hdrptr
+= offset_size
;
9762 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9765 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9768 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9770 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9774 printf (_(" Length: %ld\n"), arange
.ar_length
);
9775 printf (_(" Version: %d\n"), arange
.ar_version
);
9776 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9777 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9778 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9780 printf (_("\n Address Length\n"));
9784 /* Must pad to an alignment boundary that is twice the pointer size. */
9785 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9787 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9791 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9793 ranges
+= arange
.ar_pointer_size
;
9795 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9797 ranges
+= arange
.ar_pointer_size
;
9799 /* A pair of zeros marks the end of the list. */
9800 if (address
== 0 && length
== 0)
9803 printf (" %8.8lx %lu\n", address
, length
);
9806 start
+= arange
.ar_length
+ initial_length_size
;
9815 display_debug_ranges (Elf_Internal_Shdr
*section
,
9816 unsigned char *start
,
9817 FILE *file ATTRIBUTE_UNUSED
)
9819 unsigned char *section_end
;
9820 unsigned long bytes
;
9821 unsigned char *section_begin
= start
;
9822 unsigned int num_range_list
= 0;
9823 unsigned long last_offset
= 0;
9824 unsigned int first
= 0;
9827 int seen_first_offset
= 0;
9828 int use_debug_info
= 1;
9829 unsigned char *next
;
9831 bytes
= section
->sh_size
;
9832 section_end
= start
+ bytes
;
9836 printf (_("\nThe .debug_ranges section is empty.\n"));
9840 get_debug_info (file
);
9842 /* Check the order of range list in .debug_info section. If
9843 offsets of range lists are in the ascending order, we can
9844 use `debug_information' directly. */
9845 for (i
= 0; i
< num_debug_info_entries
; i
++)
9849 num
= debug_information
[i
].num_range_lists
;
9850 num_range_list
+= num
;
9852 /* Check if we can use `debug_information' directly. */
9853 if (use_debug_info
&& num
!= 0)
9855 if (!seen_first_offset
)
9857 /* This is the first range list. */
9858 last_offset
= debug_information
[i
].range_lists
[0];
9860 seen_first_offset
= 1;
9866 for (; j
< num
; j
++)
9869 debug_information
[i
].range_lists
[j
])
9874 last_offset
= debug_information
[i
].range_lists
[j
];
9879 if (!use_debug_info
)
9880 /* FIXME: Should we handle this case? */
9881 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9883 if (!seen_first_offset
)
9884 error (_("No range lists in .debug_info section!\n"));
9886 if (debug_information
[first
].range_lists
[0] != 0)
9887 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9888 debug_information
[first
].range_lists
[0]);
9890 printf (_("Contents of the .debug_ranges section:\n\n"));
9891 printf (_(" Offset Begin End\n"));
9893 seen_first_offset
= 0;
9894 for (i
= first
; i
< num_debug_info_entries
; i
++)
9896 unsigned long begin
;
9898 unsigned long offset
;
9899 unsigned int pointer_size
;
9900 unsigned long base_address
;
9902 pointer_size
= debug_information
[i
].pointer_size
;
9904 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9906 offset
= debug_information
[i
].range_lists
[j
];
9907 next
= section_begin
+ offset
;
9908 base_address
= debug_information
[i
].base_address
;
9910 if (!seen_first_offset
)
9911 seen_first_offset
= 1;
9915 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9916 start
- section_begin
, next
- section_begin
);
9917 else if (start
> next
)
9918 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9919 start
- section_begin
, next
- section_begin
);
9925 begin
= byte_get (start
, pointer_size
);
9926 start
+= pointer_size
;
9927 end
= byte_get (start
, pointer_size
);
9928 start
+= pointer_size
;
9930 if (begin
== 0 && end
== 0)
9932 printf (_(" %8.8lx <End of list>\n"), offset
);
9936 /* Check base address specifiers. */
9937 if (begin
== -1UL && end
!= -1UL)
9940 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9941 offset
, begin
, end
);
9945 printf (" %8.8lx %8.8lx %8.8lx",
9946 offset
, begin
+ base_address
, end
+ base_address
);
9949 fputs (_(" (start == end)"), stdout
);
9950 else if (begin
> end
)
9951 fputs (_(" (start > end)"), stdout
);
9961 typedef struct Frame_Chunk
9963 struct Frame_Chunk
*next
;
9964 unsigned char *chunk_start
;
9966 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9967 short int *col_type
;
9970 unsigned int code_factor
;
9972 unsigned long pc_begin
;
9973 unsigned long pc_range
;
9977 unsigned char fde_encoding
;
9978 unsigned char cfa_exp
;
9982 /* A marker for a col_type that means this column was never referenced
9983 in the frame info. */
9984 #define DW_CFA_unreferenced (-1)
9987 frame_need_space (Frame_Chunk
*fc
, int reg
)
9989 int prev
= fc
->ncols
;
9991 if (reg
< fc
->ncols
)
9994 fc
->ncols
= reg
+ 1;
9995 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
9996 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
9998 while (prev
< fc
->ncols
)
10000 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10001 fc
->col_offset
[prev
] = 0;
10007 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10012 if (*max_regs
< fc
->ncols
)
10013 *max_regs
= fc
->ncols
;
10015 if (*need_col_headers
)
10017 *need_col_headers
= 0;
10019 printf (" LOC CFA ");
10021 for (r
= 0; r
< *max_regs
; r
++)
10022 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10027 printf ("r%-4d", r
);
10033 printf ("%08lx ", fc
->pc_begin
);
10035 strcpy (tmp
, "exp");
10037 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10038 printf ("%-8s ", tmp
);
10040 for (r
= 0; r
< fc
->ncols
; r
++)
10042 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10044 switch (fc
->col_type
[r
])
10046 case DW_CFA_undefined
:
10049 case DW_CFA_same_value
:
10052 case DW_CFA_offset
:
10053 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10055 case DW_CFA_register
:
10056 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10058 case DW_CFA_expression
:
10059 strcpy (tmp
, "exp");
10062 strcpy (tmp
, "n/a");
10065 printf ("%-5s", tmp
);
10072 size_of_encoded_value (int encoding
)
10074 switch (encoding
& 0x7)
10077 case 0: return eh_addr_size
;
10085 get_encoded_value (unsigned char *data
, int encoding
)
10087 int size
= size_of_encoded_value (encoding
);
10088 if (encoding
& DW_EH_PE_signed
)
10089 return byte_get_signed (data
, size
);
10091 return byte_get (data
, size
);
10094 #define GET(N) byte_get (start, N); start += N
10095 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10096 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10099 display_debug_frames (Elf_Internal_Shdr
*section
,
10100 unsigned char *start
,
10101 FILE *file ATTRIBUTE_UNUSED
)
10103 unsigned char *end
= start
+ section
->sh_size
;
10104 unsigned char *section_start
= start
;
10105 Frame_Chunk
*chunks
= 0;
10106 Frame_Chunk
*remembered_state
= 0;
10108 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10109 unsigned int length_return
;
10112 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10114 while (start
< end
)
10116 unsigned char *saved_start
;
10117 unsigned char *block_end
;
10118 unsigned long length
;
10119 unsigned long cie_id
;
10122 int need_col_headers
= 1;
10123 unsigned char *augmentation_data
= NULL
;
10124 unsigned long augmentation_data_len
= 0;
10125 int encoded_ptr_size
= eh_addr_size
;
10127 int initial_length_size
;
10129 saved_start
= start
;
10130 length
= byte_get (start
, 4); start
+= 4;
10134 printf ("\n%08lx ZERO terminator\n\n",
10135 (unsigned long)(saved_start
- section_start
));
10139 if (length
== 0xffffffff)
10141 length
= byte_get (start
, 8);
10144 initial_length_size
= 12;
10149 initial_length_size
= 4;
10152 block_end
= saved_start
+ length
+ initial_length_size
;
10153 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10155 if (elf_header
.e_type
== ET_REL
10156 && !debug_apply_rela_addends (file
, section
, offset_size
,
10157 section_start
, start
, block_end
))
10160 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10164 fc
= xmalloc (sizeof (Frame_Chunk
));
10165 memset (fc
, 0, sizeof (Frame_Chunk
));
10169 fc
->chunk_start
= saved_start
;
10171 fc
->col_type
= xmalloc (sizeof (short int));
10172 fc
->col_offset
= xmalloc (sizeof (int));
10173 frame_need_space (fc
, max_regs
-1);
10175 version
= *start
++;
10177 fc
->augmentation
= (char *) start
;
10178 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10180 if (fc
->augmentation
[0] == 'z')
10182 fc
->code_factor
= LEB ();
10183 fc
->data_factor
= SLEB ();
10192 augmentation_data_len
= LEB ();
10193 augmentation_data
= start
;
10194 start
+= augmentation_data_len
;
10196 else if (streq (fc
->augmentation
, "eh"))
10198 start
+= eh_addr_size
;
10199 fc
->code_factor
= LEB ();
10200 fc
->data_factor
= SLEB ();
10212 fc
->code_factor
= LEB ();
10213 fc
->data_factor
= SLEB ();
10225 if (do_debug_frames_interp
)
10226 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10227 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10228 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10232 printf ("\n%08lx %08lx %08lx CIE\n",
10233 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10234 printf (" Version: %d\n", version
);
10235 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10236 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10237 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10238 printf (" Return address column: %d\n", fc
->ra
);
10240 if (augmentation_data_len
)
10243 printf (" Augmentation data: ");
10244 for (i
= 0; i
< augmentation_data_len
; ++i
)
10245 printf (" %02x", augmentation_data
[i
]);
10251 if (augmentation_data_len
)
10253 unsigned char *p
, *q
;
10254 p
= (unsigned char *) fc
->augmentation
+ 1;
10255 q
= augmentation_data
;
10261 else if (*p
== 'P')
10262 q
+= 1 + size_of_encoded_value (*q
);
10263 else if (*p
== 'R')
10264 fc
->fde_encoding
= *q
++;
10270 if (fc
->fde_encoding
)
10271 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10274 frame_need_space (fc
, fc
->ra
);
10278 unsigned char *look_for
;
10279 static Frame_Chunk fde_fc
;
10282 memset (fc
, 0, sizeof (Frame_Chunk
));
10284 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10286 for (cie
= chunks
; cie
; cie
= cie
->next
)
10287 if (cie
->chunk_start
== look_for
)
10292 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10293 cie_id
, saved_start
);
10296 fc
->col_type
= xmalloc (sizeof (short int));
10297 fc
->col_offset
= xmalloc (sizeof (int));
10298 frame_need_space (fc
, max_regs
- 1);
10300 fc
->augmentation
= "";
10301 fc
->fde_encoding
= 0;
10305 fc
->ncols
= cie
->ncols
;
10306 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10307 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10308 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10309 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10310 fc
->augmentation
= cie
->augmentation
;
10311 fc
->code_factor
= cie
->code_factor
;
10312 fc
->data_factor
= cie
->data_factor
;
10313 fc
->cfa_reg
= cie
->cfa_reg
;
10314 fc
->cfa_offset
= cie
->cfa_offset
;
10316 frame_need_space (fc
, max_regs
-1);
10317 fc
->fde_encoding
= cie
->fde_encoding
;
10320 if (fc
->fde_encoding
)
10321 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10323 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10324 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10325 /* Don't adjust for ET_REL since there's invariably a pcrel
10326 reloc here, which we haven't applied. */
10327 && elf_header
.e_type
!= ET_REL
)
10328 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10329 start
+= encoded_ptr_size
;
10330 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10331 start
+= encoded_ptr_size
;
10333 if (cie
->augmentation
[0] == 'z')
10335 augmentation_data_len
= LEB ();
10336 augmentation_data
= start
;
10337 start
+= augmentation_data_len
;
10340 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10341 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10342 (unsigned long)(cie
->chunk_start
- section_start
),
10343 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10344 if (! do_debug_frames_interp
&& augmentation_data_len
)
10348 printf (" Augmentation data: ");
10349 for (i
= 0; i
< augmentation_data_len
; ++i
)
10350 printf (" %02x", augmentation_data
[i
]);
10356 /* At this point, fc is the current chunk, cie (if any) is set, and
10357 we're about to interpret instructions for the chunk. */
10358 /* ??? At present we need to do this always, since this sizes the
10359 fc->col_type and fc->col_offset arrays, which we write into always.
10360 We should probably split the interpreted and non-interpreted bits
10361 into two different routines, since there's so much that doesn't
10362 really overlap between them. */
10363 if (1 || do_debug_frames_interp
)
10365 /* Start by making a pass over the chunk, allocating storage
10366 and taking note of what registers are used. */
10367 unsigned char *tmp
= start
;
10369 while (start
< block_end
)
10372 unsigned long reg
, tmp
;
10379 /* Warning: if you add any more cases to this switch, be
10380 sure to add them to the corresponding switch below. */
10383 case DW_CFA_advance_loc
:
10385 case DW_CFA_offset
:
10387 frame_need_space (fc
, opa
);
10388 fc
->col_type
[opa
] = DW_CFA_undefined
;
10390 case DW_CFA_restore
:
10391 frame_need_space (fc
, opa
);
10392 fc
->col_type
[opa
] = DW_CFA_undefined
;
10394 case DW_CFA_set_loc
:
10395 start
+= encoded_ptr_size
;
10397 case DW_CFA_advance_loc1
:
10400 case DW_CFA_advance_loc2
:
10403 case DW_CFA_advance_loc4
:
10406 case DW_CFA_offset_extended
:
10407 reg
= LEB (); LEB ();
10408 frame_need_space (fc
, reg
);
10409 fc
->col_type
[reg
] = DW_CFA_undefined
;
10411 case DW_CFA_restore_extended
:
10413 frame_need_space (fc
, reg
);
10414 fc
->col_type
[reg
] = DW_CFA_undefined
;
10416 case DW_CFA_undefined
:
10418 frame_need_space (fc
, reg
);
10419 fc
->col_type
[reg
] = DW_CFA_undefined
;
10421 case DW_CFA_same_value
:
10423 frame_need_space (fc
, reg
);
10424 fc
->col_type
[reg
] = DW_CFA_undefined
;
10426 case DW_CFA_register
:
10427 reg
= LEB (); LEB ();
10428 frame_need_space (fc
, reg
);
10429 fc
->col_type
[reg
] = DW_CFA_undefined
;
10431 case DW_CFA_def_cfa
:
10434 case DW_CFA_def_cfa_register
:
10437 case DW_CFA_def_cfa_offset
:
10440 case DW_CFA_def_cfa_expression
:
10444 case DW_CFA_expression
:
10448 frame_need_space (fc
, reg
);
10449 fc
->col_type
[reg
] = DW_CFA_undefined
;
10451 case DW_CFA_offset_extended_sf
:
10452 reg
= LEB (); SLEB ();
10453 frame_need_space (fc
, reg
);
10454 fc
->col_type
[reg
] = DW_CFA_undefined
;
10456 case DW_CFA_def_cfa_sf
:
10459 case DW_CFA_def_cfa_offset_sf
:
10462 case DW_CFA_MIPS_advance_loc8
:
10465 case DW_CFA_GNU_args_size
:
10468 case DW_CFA_GNU_negative_offset_extended
:
10469 reg
= LEB (); LEB ();
10470 frame_need_space (fc
, reg
);
10471 fc
->col_type
[reg
] = DW_CFA_undefined
;
10480 /* Now we know what registers are used, make a second pass over
10481 the chunk, this time actually printing out the info. */
10483 while (start
< block_end
)
10486 unsigned long ul
, reg
, roffs
;
10495 /* Warning: if you add any more cases to this switch, be
10496 sure to add them to the corresponding switch above. */
10499 case DW_CFA_advance_loc
:
10500 if (do_debug_frames_interp
)
10501 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10503 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10504 opa
* fc
->code_factor
,
10505 fc
->pc_begin
+ opa
* fc
->code_factor
);
10506 fc
->pc_begin
+= opa
* fc
->code_factor
;
10509 case DW_CFA_offset
:
10511 if (! do_debug_frames_interp
)
10512 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10513 opa
, roffs
* fc
->data_factor
);
10514 fc
->col_type
[opa
] = DW_CFA_offset
;
10515 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10518 case DW_CFA_restore
:
10519 if (! do_debug_frames_interp
)
10520 printf (" DW_CFA_restore: r%d\n", opa
);
10521 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10522 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10525 case DW_CFA_set_loc
:
10526 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10527 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10528 && elf_header
.e_type
!= ET_REL
)
10529 vma
+= section
->sh_addr
+ (start
- section_start
);
10530 start
+= encoded_ptr_size
;
10531 if (do_debug_frames_interp
)
10532 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10534 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10535 fc
->pc_begin
= vma
;
10538 case DW_CFA_advance_loc1
:
10539 ofs
= byte_get (start
, 1); start
+= 1;
10540 if (do_debug_frames_interp
)
10541 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10543 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10544 ofs
* fc
->code_factor
,
10545 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10546 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10549 case DW_CFA_advance_loc2
:
10550 ofs
= byte_get (start
, 2); start
+= 2;
10551 if (do_debug_frames_interp
)
10552 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10554 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10555 ofs
* fc
->code_factor
,
10556 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10557 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10560 case DW_CFA_advance_loc4
:
10561 ofs
= byte_get (start
, 4); start
+= 4;
10562 if (do_debug_frames_interp
)
10563 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10565 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10566 ofs
* fc
->code_factor
,
10567 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10568 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10571 case DW_CFA_offset_extended
:
10574 if (! do_debug_frames_interp
)
10575 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10576 reg
, roffs
* fc
->data_factor
);
10577 fc
->col_type
[reg
] = DW_CFA_offset
;
10578 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10581 case DW_CFA_restore_extended
:
10583 if (! do_debug_frames_interp
)
10584 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10585 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10586 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10589 case DW_CFA_undefined
:
10591 if (! do_debug_frames_interp
)
10592 printf (" DW_CFA_undefined: r%ld\n", reg
);
10593 fc
->col_type
[reg
] = DW_CFA_undefined
;
10594 fc
->col_offset
[reg
] = 0;
10597 case DW_CFA_same_value
:
10599 if (! do_debug_frames_interp
)
10600 printf (" DW_CFA_same_value: r%ld\n", reg
);
10601 fc
->col_type
[reg
] = DW_CFA_same_value
;
10602 fc
->col_offset
[reg
] = 0;
10605 case DW_CFA_register
:
10608 if (! do_debug_frames_interp
)
10609 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10610 fc
->col_type
[reg
] = DW_CFA_register
;
10611 fc
->col_offset
[reg
] = roffs
;
10614 case DW_CFA_remember_state
:
10615 if (! do_debug_frames_interp
)
10616 printf (" DW_CFA_remember_state\n");
10617 rs
= xmalloc (sizeof (Frame_Chunk
));
10618 rs
->ncols
= fc
->ncols
;
10619 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10620 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10621 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10622 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10623 rs
->next
= remembered_state
;
10624 remembered_state
= rs
;
10627 case DW_CFA_restore_state
:
10628 if (! do_debug_frames_interp
)
10629 printf (" DW_CFA_restore_state\n");
10630 rs
= remembered_state
;
10633 remembered_state
= rs
->next
;
10634 frame_need_space (fc
, rs
->ncols
-1);
10635 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10636 memcpy (fc
->col_offset
, rs
->col_offset
,
10637 rs
->ncols
* sizeof (int));
10638 free (rs
->col_type
);
10639 free (rs
->col_offset
);
10642 else if (do_debug_frames_interp
)
10643 printf ("Mismatched DW_CFA_restore_state\n");
10646 case DW_CFA_def_cfa
:
10647 fc
->cfa_reg
= LEB ();
10648 fc
->cfa_offset
= LEB ();
10650 if (! do_debug_frames_interp
)
10651 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10652 fc
->cfa_reg
, fc
->cfa_offset
);
10655 case DW_CFA_def_cfa_register
:
10656 fc
->cfa_reg
= LEB ();
10658 if (! do_debug_frames_interp
)
10659 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10662 case DW_CFA_def_cfa_offset
:
10663 fc
->cfa_offset
= LEB ();
10664 if (! do_debug_frames_interp
)
10665 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10669 if (! do_debug_frames_interp
)
10670 printf (" DW_CFA_nop\n");
10673 case DW_CFA_def_cfa_expression
:
10675 if (! do_debug_frames_interp
)
10677 printf (" DW_CFA_def_cfa_expression (");
10678 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10685 case DW_CFA_expression
:
10688 if (! do_debug_frames_interp
)
10690 printf (" DW_CFA_expression: r%ld (", reg
);
10691 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10694 fc
->col_type
[reg
] = DW_CFA_expression
;
10698 case DW_CFA_offset_extended_sf
:
10701 frame_need_space (fc
, reg
);
10702 if (! do_debug_frames_interp
)
10703 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10704 reg
, l
* fc
->data_factor
);
10705 fc
->col_type
[reg
] = DW_CFA_offset
;
10706 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10709 case DW_CFA_def_cfa_sf
:
10710 fc
->cfa_reg
= LEB ();
10711 fc
->cfa_offset
= SLEB ();
10713 if (! do_debug_frames_interp
)
10714 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10715 fc
->cfa_reg
, fc
->cfa_offset
);
10718 case DW_CFA_def_cfa_offset_sf
:
10719 fc
->cfa_offset
= SLEB ();
10720 if (! do_debug_frames_interp
)
10721 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10724 case DW_CFA_MIPS_advance_loc8
:
10725 ofs
= byte_get (start
, 8); start
+= 8;
10726 if (do_debug_frames_interp
)
10727 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10729 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10730 ofs
* fc
->code_factor
,
10731 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10732 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10735 case DW_CFA_GNU_window_save
:
10736 if (! do_debug_frames_interp
)
10737 printf (" DW_CFA_GNU_window_save\n");
10740 case DW_CFA_GNU_args_size
:
10742 if (! do_debug_frames_interp
)
10743 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10746 case DW_CFA_GNU_negative_offset_extended
:
10749 frame_need_space (fc
, reg
);
10750 if (! do_debug_frames_interp
)
10751 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10752 reg
, l
* fc
->data_factor
);
10753 fc
->col_type
[reg
] = DW_CFA_offset
;
10754 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10758 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10763 if (do_debug_frames_interp
)
10764 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10779 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10780 unsigned char *start ATTRIBUTE_UNUSED
,
10781 FILE *file ATTRIBUTE_UNUSED
)
10783 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10784 SECTION_NAME (section
));
10789 /* A structure containing the name of a debug section
10790 and a pointer to a function that can decode it. */
10793 const char *const name
;
10794 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10798 { ".debug_abbrev", display_debug_abbrev
},
10799 { ".debug_aranges", display_debug_aranges
},
10800 { ".debug_frame", display_debug_frames
},
10801 { ".debug_info", display_debug_info
},
10802 { ".debug_line", display_debug_lines
},
10803 { ".debug_pubnames", display_debug_pubnames
},
10804 { ".eh_frame", display_debug_frames
},
10805 { ".debug_macinfo", display_debug_macinfo
},
10806 { ".debug_str", display_debug_str
},
10807 { ".debug_loc", display_debug_loc
},
10808 { ".debug_pubtypes", display_debug_pubnames
},
10809 { ".debug_ranges", display_debug_ranges
},
10810 { ".debug_static_func", display_debug_not_supported
},
10811 { ".debug_static_vars", display_debug_not_supported
},
10812 { ".debug_types", display_debug_not_supported
},
10813 { ".debug_weaknames", display_debug_not_supported
}
10817 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10819 char *name
= SECTION_NAME (section
);
10820 bfd_size_type length
;
10824 length
= section
->sh_size
;
10827 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10831 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10832 name
= ".debug_info";
10834 /* See if we know how to display the contents of this section. */
10835 for (i
= NUM_ELEM (debug_displays
); i
--;)
10836 if (streq (debug_displays
[i
].name
, name
))
10838 unsigned char *start
;
10840 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10841 _("debug section data"));
10848 result
&= debug_displays
[i
].display (section
, start
, file
);
10851 /* If we loaded in the abbrev section
10852 at some point, we must release it here. */
10860 printf (_("Unrecognized debug section: %s\n"), name
);
10868 process_section_contents (FILE *file
)
10870 Elf_Internal_Shdr
*section
;
10876 for (i
= 0, section
= section_headers
;
10877 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10880 #ifdef SUPPORT_DISASSEMBLY
10881 if (dump_sects
[i
] & DISASS_DUMP
)
10882 disassemble_section (section
, file
);
10884 if (dump_sects
[i
] & HEX_DUMP
)
10885 dump_section (section
, file
);
10887 if (dump_sects
[i
] & DEBUG_DUMP
)
10888 display_debug_section (section
, file
);
10891 /* Check to see if the user requested a
10892 dump of a section that does not exist. */
10893 while (i
++ < num_dump_sects
)
10895 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10899 process_mips_fpe_exception (int mask
)
10904 if (mask
& OEX_FPU_INEX
)
10905 fputs ("INEX", stdout
), first
= 0;
10906 if (mask
& OEX_FPU_UFLO
)
10907 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10908 if (mask
& OEX_FPU_OFLO
)
10909 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10910 if (mask
& OEX_FPU_DIV0
)
10911 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10912 if (mask
& OEX_FPU_INVAL
)
10913 printf ("%sINVAL", first
? "" : "|");
10916 fputs ("0", stdout
);
10920 process_mips_specific (FILE *file
)
10922 Elf_Internal_Dyn
*entry
;
10923 size_t liblist_offset
= 0;
10924 size_t liblistno
= 0;
10925 size_t conflictsno
= 0;
10926 size_t options_offset
= 0;
10927 size_t conflicts_offset
= 0;
10929 /* We have a lot of special sections. Thanks SGI! */
10930 if (dynamic_section
== NULL
)
10931 /* No information available. */
10934 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10935 switch (entry
->d_tag
)
10937 case DT_MIPS_LIBLIST
:
10939 = offset_from_vma (file
, entry
->d_un
.d_val
,
10940 liblistno
* sizeof (Elf32_External_Lib
));
10942 case DT_MIPS_LIBLISTNO
:
10943 liblistno
= entry
->d_un
.d_val
;
10945 case DT_MIPS_OPTIONS
:
10946 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10948 case DT_MIPS_CONFLICT
:
10950 = offset_from_vma (file
, entry
->d_un
.d_val
,
10951 conflictsno
* sizeof (Elf32_External_Conflict
));
10953 case DT_MIPS_CONFLICTNO
:
10954 conflictsno
= entry
->d_un
.d_val
;
10960 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10962 Elf32_External_Lib
*elib
;
10965 elib
= get_data (NULL
, file
, liblist_offset
,
10966 liblistno
* sizeof (Elf32_External_Lib
),
10970 printf ("\nSection '.liblist' contains %lu entries:\n",
10971 (unsigned long) liblistno
);
10972 fputs (" Library Time Stamp Checksum Version Flags\n",
10975 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10982 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10983 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10984 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10985 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10986 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10988 tmp
= gmtime (&time
);
10989 snprintf (timebuf
, sizeof (timebuf
),
10990 "%04u-%02u-%02uT%02u:%02u:%02u",
10991 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10992 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10994 printf ("%3lu: ", (unsigned long) cnt
);
10995 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10996 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10998 printf ("<corrupt: %9ld>", liblist
.l_name
);
10999 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11000 liblist
.l_version
);
11002 if (liblist
.l_flags
== 0)
11006 static const struct
11013 { " EXACT_MATCH", LL_EXACT_MATCH
},
11014 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11015 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11016 { " EXPORTS", LL_EXPORTS
},
11017 { " DELAY_LOAD", LL_DELAY_LOAD
},
11018 { " DELTA", LL_DELTA
}
11020 int flags
= liblist
.l_flags
;
11024 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11026 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11028 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11029 flags
^= l_flags_vals
[fcnt
].bit
;
11032 printf (" %#x", (unsigned int) flags
);
11042 if (options_offset
!= 0)
11044 Elf_External_Options
*eopt
;
11045 Elf_Internal_Shdr
*sect
= section_headers
;
11046 Elf_Internal_Options
*iopt
;
11047 Elf_Internal_Options
*option
;
11051 /* Find the section header so that we get the size. */
11052 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11055 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
11059 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
11062 error (_("Out of memory"));
11069 while (offset
< sect
->sh_size
)
11071 Elf_External_Options
*eoption
;
11073 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11075 option
->kind
= BYTE_GET (eoption
->kind
);
11076 option
->size
= BYTE_GET (eoption
->size
);
11077 option
->section
= BYTE_GET (eoption
->section
);
11078 option
->info
= BYTE_GET (eoption
->info
);
11080 offset
+= option
->size
;
11086 printf (_("\nSection '%s' contains %d entries:\n"),
11087 SECTION_NAME (sect
), cnt
);
11095 switch (option
->kind
)
11098 /* This shouldn't happen. */
11099 printf (" NULL %d %lx", option
->section
, option
->info
);
11102 printf (" REGINFO ");
11103 if (elf_header
.e_machine
== EM_MIPS
)
11106 Elf32_External_RegInfo
*ereg
;
11107 Elf32_RegInfo reginfo
;
11109 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11110 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11111 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11112 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11113 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11114 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11115 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11117 printf ("GPR %08lx GP 0x%lx\n",
11118 reginfo
.ri_gprmask
,
11119 (unsigned long) reginfo
.ri_gp_value
);
11120 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11121 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11122 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11127 Elf64_External_RegInfo
*ereg
;
11128 Elf64_Internal_RegInfo reginfo
;
11130 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11131 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11132 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11133 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11134 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11135 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11136 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11138 printf ("GPR %08lx GP 0x",
11139 reginfo
.ri_gprmask
);
11140 printf_vma (reginfo
.ri_gp_value
);
11143 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11144 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11145 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11149 case ODK_EXCEPTIONS
:
11150 fputs (" EXCEPTIONS fpe_min(", stdout
);
11151 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11152 fputs (") fpe_max(", stdout
);
11153 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11154 fputs (")", stdout
);
11156 if (option
->info
& OEX_PAGE0
)
11157 fputs (" PAGE0", stdout
);
11158 if (option
->info
& OEX_SMM
)
11159 fputs (" SMM", stdout
);
11160 if (option
->info
& OEX_FPDBUG
)
11161 fputs (" FPDBUG", stdout
);
11162 if (option
->info
& OEX_DISMISS
)
11163 fputs (" DISMISS", stdout
);
11166 fputs (" PAD ", stdout
);
11167 if (option
->info
& OPAD_PREFIX
)
11168 fputs (" PREFIX", stdout
);
11169 if (option
->info
& OPAD_POSTFIX
)
11170 fputs (" POSTFIX", stdout
);
11171 if (option
->info
& OPAD_SYMBOL
)
11172 fputs (" SYMBOL", stdout
);
11175 fputs (" HWPATCH ", stdout
);
11176 if (option
->info
& OHW_R4KEOP
)
11177 fputs (" R4KEOP", stdout
);
11178 if (option
->info
& OHW_R8KPFETCH
)
11179 fputs (" R8KPFETCH", stdout
);
11180 if (option
->info
& OHW_R5KEOP
)
11181 fputs (" R5KEOP", stdout
);
11182 if (option
->info
& OHW_R5KCVTL
)
11183 fputs (" R5KCVTL", stdout
);
11186 fputs (" FILL ", stdout
);
11187 /* XXX Print content of info word? */
11190 fputs (" TAGS ", stdout
);
11191 /* XXX Print content of info word? */
11194 fputs (" HWAND ", stdout
);
11195 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11196 fputs (" R4KEOP_CHECKED", stdout
);
11197 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11198 fputs (" R4KEOP_CLEAN", stdout
);
11201 fputs (" HWOR ", stdout
);
11202 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11203 fputs (" R4KEOP_CHECKED", stdout
);
11204 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11205 fputs (" R4KEOP_CLEAN", stdout
);
11208 printf (" GP_GROUP %#06lx self-contained %#06lx",
11209 option
->info
& OGP_GROUP
,
11210 (option
->info
& OGP_SELF
) >> 16);
11213 printf (" IDENT %#06lx self-contained %#06lx",
11214 option
->info
& OGP_GROUP
,
11215 (option
->info
& OGP_SELF
) >> 16);
11218 /* This shouldn't happen. */
11219 printf (" %3d ??? %d %lx",
11220 option
->kind
, option
->section
, option
->info
);
11224 len
= sizeof (*eopt
);
11225 while (len
< option
->size
)
11226 if (((char *) option
)[len
] >= ' '
11227 && ((char *) option
)[len
] < 0x7f)
11228 printf ("%c", ((char *) option
)[len
++]);
11230 printf ("\\%03o", ((char *) option
)[len
++]);
11232 fputs ("\n", stdout
);
11240 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11242 Elf32_Conflict
*iconf
;
11245 if (dynamic_symbols
== NULL
)
11247 error (_("conflict list found without a dynamic symbol table"));
11251 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11254 error (_("Out of memory"));
11260 Elf32_External_Conflict
*econf32
;
11262 econf32
= get_data (NULL
, file
, conflicts_offset
,
11263 conflictsno
* sizeof (*econf32
), _("conflict"));
11267 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11268 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11274 Elf64_External_Conflict
*econf64
;
11276 econf64
= get_data (NULL
, file
, conflicts_offset
,
11277 conflictsno
* sizeof (*econf64
), _("conflict"));
11281 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11282 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11287 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11288 (unsigned long) conflictsno
);
11289 puts (_(" Num: Index Value Name"));
11291 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11293 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11295 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11296 print_vma (psym
->st_value
, FULL_HEX
);
11298 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11299 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11301 printf ("<corrupt: %14ld>", psym
->st_name
);
11312 process_gnu_liblist (FILE *file
)
11314 Elf_Internal_Shdr
*section
, *string_sec
;
11315 Elf32_External_Lib
*elib
;
11323 for (i
= 0, section
= section_headers
;
11324 i
< elf_header
.e_shnum
;
11327 switch (section
->sh_type
)
11329 case SHT_GNU_LIBLIST
:
11330 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11335 string_sec
= SECTION_HEADER (section
->sh_link
);
11337 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11338 string_sec
->sh_size
, _("liblist string table"));
11341 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11347 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11348 SECTION_NAME (section
),
11349 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11351 puts (" Library Time Stamp Checksum Version Flags");
11353 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11361 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11362 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11363 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11364 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11365 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11367 tmp
= gmtime (&time
);
11368 snprintf (timebuf
, sizeof (timebuf
),
11369 "%04u-%02u-%02uT%02u:%02u:%02u",
11370 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11371 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11373 printf ("%3lu: ", (unsigned long) cnt
);
11375 printf ("%-20s", strtab
+ liblist
.l_name
);
11377 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11378 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11379 liblist
.l_version
, liblist
.l_flags
);
11389 static const char *
11390 get_note_type (unsigned e_type
)
11392 static char buff
[64];
11394 if (elf_header
.e_type
== ET_CORE
)
11398 return _("NT_AUXV (auxiliary vector)");
11400 return _("NT_PRSTATUS (prstatus structure)");
11402 return _("NT_FPREGSET (floating point registers)");
11404 return _("NT_PRPSINFO (prpsinfo structure)");
11405 case NT_TASKSTRUCT
:
11406 return _("NT_TASKSTRUCT (task structure)");
11408 return _("NT_PRXFPREG (user_xfpregs structure)");
11410 return _("NT_PSTATUS (pstatus structure)");
11412 return _("NT_FPREGS (floating point registers)");
11414 return _("NT_PSINFO (psinfo structure)");
11416 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11418 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11419 case NT_WIN32PSTATUS
:
11420 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11428 return _("NT_VERSION (version)");
11430 return _("NT_ARCH (architecture)");
11435 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11439 static const char *
11440 get_netbsd_elfcore_note_type (unsigned e_type
)
11442 static char buff
[64];
11444 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11446 /* NetBSD core "procinfo" structure. */
11447 return _("NetBSD procinfo structure");
11450 /* As of Jan 2002 there are no other machine-independent notes
11451 defined for NetBSD core files. If the note type is less
11452 than the start of the machine-dependent note types, we don't
11455 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11457 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11461 switch (elf_header
.e_machine
)
11463 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11464 and PT_GETFPREGS == mach+2. */
11469 case EM_SPARC32PLUS
:
11473 case NT_NETBSDCORE_FIRSTMACH
+0:
11474 return _("PT_GETREGS (reg structure)");
11475 case NT_NETBSDCORE_FIRSTMACH
+2:
11476 return _("PT_GETFPREGS (fpreg structure)");
11482 /* On all other arch's, PT_GETREGS == mach+1 and
11483 PT_GETFPREGS == mach+3. */
11487 case NT_NETBSDCORE_FIRSTMACH
+1:
11488 return _("PT_GETREGS (reg structure)");
11489 case NT_NETBSDCORE_FIRSTMACH
+3:
11490 return _("PT_GETFPREGS (fpreg structure)");
11496 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11497 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11501 /* Note that by the ELF standard, the name field is already null byte
11502 terminated, and namesz includes the terminating null byte.
11503 I.E. the value of namesz for the name "FSF" is 4.
11505 If the value of namesz is zero, there is no name present. */
11507 process_note (Elf_Internal_Note
*pnote
)
11511 if (pnote
->namesz
== 0)
11512 /* If there is no note name, then use the default set of
11513 note type strings. */
11514 nt
= get_note_type (pnote
->type
);
11516 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11517 /* NetBSD-specific core file notes. */
11518 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11521 /* Don't recognize this note name; just use the default set of
11522 note type strings. */
11523 nt
= get_note_type (pnote
->type
);
11525 printf (" %s\t\t0x%08lx\t%s\n",
11526 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11527 pnote
->descsz
, nt
);
11533 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11535 Elf_External_Note
*pnotes
;
11536 Elf_External_Note
*external
;
11542 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11548 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11549 (unsigned long) offset
, (unsigned long) length
);
11550 printf (_(" Owner\t\tData size\tDescription\n"));
11552 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11554 Elf_External_Note
*next
;
11555 Elf_Internal_Note inote
;
11558 inote
.type
= BYTE_GET (external
->type
);
11559 inote
.namesz
= BYTE_GET (external
->namesz
);
11560 inote
.namedata
= external
->name
;
11561 inote
.descsz
= BYTE_GET (external
->descsz
);
11562 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11563 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11565 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11567 if (((char *) next
) > (((char *) pnotes
) + length
))
11569 warn (_("corrupt note found at offset %x into core notes\n"),
11570 ((char *) external
) - ((char *) pnotes
));
11571 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11572 inote
.type
, inote
.namesz
, inote
.descsz
);
11578 /* Verify that name is null terminated. It appears that at least
11579 one version of Linux (RedHat 6.0) generates corefiles that don't
11580 comply with the ELF spec by failing to include the null byte in
11582 if (inote
.namedata
[inote
.namesz
] != '\0')
11584 temp
= malloc (inote
.namesz
+ 1);
11588 error (_("Out of memory\n"));
11593 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11594 temp
[inote
.namesz
] = 0;
11596 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11597 inote
.namedata
= temp
;
11600 res
&= process_note (& inote
);
11615 process_corefile_note_segments (FILE *file
)
11617 Elf_Internal_Phdr
*segment
;
11621 if (! get_program_headers (file
))
11624 for (i
= 0, segment
= program_headers
;
11625 i
< elf_header
.e_phnum
;
11628 if (segment
->p_type
== PT_NOTE
)
11629 res
&= process_corefile_note_segment (file
,
11630 (bfd_vma
) segment
->p_offset
,
11631 (bfd_vma
) segment
->p_filesz
);
11638 process_note_sections (FILE *file
)
11640 Elf_Internal_Shdr
*section
;
11644 for (i
= 0, section
= section_headers
;
11645 i
< elf_header
.e_shnum
;
11647 if (section
->sh_type
== SHT_NOTE
)
11648 res
&= process_corefile_note_segment (file
,
11649 (bfd_vma
) section
->sh_offset
,
11650 (bfd_vma
) section
->sh_size
);
11656 process_notes (FILE *file
)
11658 /* If we have not been asked to display the notes then do nothing. */
11662 if (elf_header
.e_type
!= ET_CORE
)
11663 return process_note_sections (file
);
11665 /* No program headers means no NOTE segment. */
11666 if (elf_header
.e_phnum
> 0)
11667 return process_corefile_note_segments (file
);
11669 printf (_("No note segments present in the core file.\n"));
11674 process_arch_specific (FILE *file
)
11679 switch (elf_header
.e_machine
)
11682 case EM_MIPS_RS3_LE
:
11683 return process_mips_specific (file
);
11692 get_file_header (FILE *file
)
11694 /* Read in the identity array. */
11695 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11698 /* Determine how to read the rest of the header. */
11699 switch (elf_header
.e_ident
[EI_DATA
])
11701 default: /* fall through */
11702 case ELFDATANONE
: /* fall through */
11704 byte_get
= byte_get_little_endian
;
11705 byte_put
= byte_put_little_endian
;
11708 byte_get
= byte_get_big_endian
;
11709 byte_put
= byte_put_big_endian
;
11713 /* For now we only support 32 bit and 64 bit ELF files. */
11714 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11716 /* Read in the rest of the header. */
11719 Elf32_External_Ehdr ehdr32
;
11721 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11724 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11725 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11726 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11727 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11728 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11729 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11730 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11731 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11732 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11733 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11734 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11735 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11736 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11740 Elf64_External_Ehdr ehdr64
;
11742 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11743 we will not be able to cope with the 64bit data found in
11744 64 ELF files. Detect this now and abort before we start
11745 overwriting things. */
11746 if (sizeof (bfd_vma
) < 8)
11748 error (_("This instance of readelf has been built without support for a\n\
11749 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11753 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11756 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11757 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11758 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11759 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11760 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11761 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11762 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11763 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11764 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11765 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11766 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11767 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11768 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11771 if (elf_header
.e_shoff
)
11773 /* There may be some extensions in the first section header. Don't
11774 bomb if we can't read it. */
11776 get_32bit_section_headers (file
, 1);
11778 get_64bit_section_headers (file
, 1);
11784 /* Process one ELF object file according to the command line options.
11785 This file may actually be stored in an archive. The file is
11786 positioned at the start of the ELF object. */
11789 process_object (char *file_name
, FILE *file
)
11793 if (! get_file_header (file
))
11795 error (_("%s: Failed to read file header\n"), file_name
);
11799 /* Initialise per file variables. */
11800 for (i
= NUM_ELEM (version_info
); i
--;)
11801 version_info
[i
] = 0;
11803 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11804 dynamic_info
[i
] = 0;
11806 /* Process the file. */
11808 printf (_("\nFile: %s\n"), file_name
);
11810 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11811 Note we do this even if cmdline_dump_sects is empty because we
11812 must make sure that the dump_sets array is zeroed out before each
11813 object file is processed. */
11814 if (num_dump_sects
> num_cmdline_dump_sects
)
11815 memset (dump_sects
, 0, num_dump_sects
);
11817 if (num_cmdline_dump_sects
> 0)
11819 if (num_dump_sects
== 0)
11820 /* A sneaky way of allocating the dump_sects array. */
11821 request_dump (num_cmdline_dump_sects
, 0);
11823 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11824 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11827 if (! process_file_header ())
11830 if (! process_section_headers (file
))
11832 /* Without loaded section headers we cannot process lots of
11834 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11836 if (! do_using_dynamic
)
11837 do_syms
= do_reloc
= 0;
11840 if (! process_section_groups (file
))
11842 /* Without loaded section groups we cannot process unwind. */
11846 if (process_program_headers (file
))
11847 process_dynamic_section (file
);
11849 process_relocs (file
);
11851 process_unwind (file
);
11853 process_symbol_table (file
);
11855 process_syminfo (file
);
11857 process_version_sections (file
);
11859 process_section_contents (file
);
11861 process_notes (file
);
11863 process_gnu_liblist (file
);
11865 process_arch_specific (file
);
11867 if (program_headers
)
11869 free (program_headers
);
11870 program_headers
= NULL
;
11873 if (section_headers
)
11875 free (section_headers
);
11876 section_headers
= NULL
;
11881 free (string_table
);
11882 string_table
= NULL
;
11883 string_table_length
= 0;
11886 if (dynamic_strings
)
11888 free (dynamic_strings
);
11889 dynamic_strings
= NULL
;
11890 dynamic_strings_length
= 0;
11893 if (dynamic_symbols
)
11895 free (dynamic_symbols
);
11896 dynamic_symbols
= NULL
;
11897 num_dynamic_syms
= 0;
11900 if (dynamic_syminfo
)
11902 free (dynamic_syminfo
);
11903 dynamic_syminfo
= NULL
;
11906 if (section_headers_groups
)
11908 free (section_headers_groups
);
11909 section_headers_groups
= NULL
;
11912 if (section_groups
)
11914 struct group_list
*g
, *next
;
11916 for (i
= 0; i
< group_count
; i
++)
11918 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11925 free (section_groups
);
11926 section_groups
= NULL
;
11929 if (debug_information
)
11931 for (i
= 0; i
< num_debug_info_entries
; i
++)
11933 if (!debug_information
[i
].max_loc_offsets
)
11935 free (debug_information
[i
].loc_offsets
);
11936 free (debug_information
[i
].have_frame_base
);
11938 if (!debug_information
[i
].max_range_lists
)
11939 free (debug_information
[i
].range_lists
);
11941 free (debug_information
);
11942 debug_information
= NULL
;
11943 num_debug_info_entries
= 0;
11949 /* Process an ELF archive. The file is positioned just after the
11953 process_archive (char *file_name
, FILE *file
)
11955 struct ar_hdr arhdr
;
11957 unsigned long size
;
11958 char *longnames
= NULL
;
11959 unsigned long longnames_size
= 0;
11960 size_t file_name_size
;
11965 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11966 if (got
!= sizeof arhdr
)
11971 error (_("%s: failed to read archive header\n"), file_name
);
11975 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
11977 /* This is the archive symbol table. Skip it.
11978 FIXME: We should have an option to dump it. */
11979 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11980 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
11982 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11986 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11987 if (got
!= sizeof arhdr
)
11992 error (_("%s: failed to read archive header\n"), file_name
);
11997 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
11999 /* This is the archive string table holding long member
12002 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12004 longnames
= malloc (longnames_size
);
12005 if (longnames
== NULL
)
12007 error (_("Out of memory\n"));
12011 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12014 error (_("%s: failed to read string table\n"), file_name
);
12018 if ((longnames_size
& 1) != 0)
12021 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12022 if (got
!= sizeof arhdr
)
12029 error (_("%s: failed to read archive header\n"), file_name
);
12034 file_name_size
= strlen (file_name
);
12043 if (arhdr
.ar_name
[0] == '/')
12047 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12048 if (off
>= longnames_size
)
12050 error (_("%s: invalid archive string table offset %lu\n"), off
);
12055 name
= longnames
+ off
;
12056 nameend
= memchr (name
, '/', longnames_size
- off
);
12060 name
= arhdr
.ar_name
;
12061 nameend
= memchr (name
, '/', 16);
12064 if (nameend
== NULL
)
12066 error (_("%s: bad archive file name\n"));
12071 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12072 if (namealc
== NULL
)
12074 error (_("Out of memory\n"));
12079 memcpy (namealc
, file_name
, file_name_size
);
12080 namealc
[file_name_size
] = '(';
12081 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12082 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12083 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12085 archive_file_offset
= ftell (file
);
12086 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12088 ret
|= process_object (namealc
, file
);
12093 (archive_file_offset
12094 + archive_file_size
12095 + (archive_file_size
& 1)),
12098 error (_("%s: failed to seek to next archive header\n"), file_name
);
12103 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12104 if (got
!= sizeof arhdr
)
12109 error (_("%s: failed to read archive header\n"), file_name
);
12115 if (longnames
!= 0)
12122 process_file (char *file_name
)
12125 struct stat statbuf
;
12126 char armag
[SARMAG
];
12129 if (stat (file_name
, &statbuf
) < 0)
12131 if (errno
== ENOENT
)
12132 error (_("'%s': No such file\n"), file_name
);
12134 error (_("Could not locate '%s'. System error message: %s\n"),
12135 file_name
, strerror (errno
));
12139 if (! S_ISREG (statbuf
.st_mode
))
12141 error (_("'%s' is not an ordinary file\n"), file_name
);
12145 file
= fopen (file_name
, "rb");
12148 error (_("Input file '%s' is not readable.\n"), file_name
);
12152 if (fread (armag
, SARMAG
, 1, file
) != 1)
12154 error (_("%s: Failed to read file header\n"), file_name
);
12159 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12160 ret
= process_archive (file_name
, file
);
12164 archive_file_size
= archive_file_offset
= 0;
12165 ret
= process_object (file_name
, file
);
12173 #ifdef SUPPORT_DISASSEMBLY
12174 /* Needed by the i386 disassembler. For extra credit, someone could
12175 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12179 print_address (unsigned int addr
, FILE *outfile
)
12181 fprintf (outfile
,"0x%8.8x", addr
);
12184 /* Needed by the i386 disassembler. */
12186 db_task_printsym (unsigned int addr
)
12188 print_address (addr
, stderr
);
12193 main (int argc
, char **argv
)
12197 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12198 setlocale (LC_MESSAGES
, "");
12200 #if defined (HAVE_SETLOCALE)
12201 setlocale (LC_CTYPE
, "");
12203 bindtextdomain (PACKAGE
, LOCALEDIR
);
12204 textdomain (PACKAGE
);
12206 parse_args (argc
, argv
);
12208 if (num_dump_sects
> 0)
12210 /* Make a copy of the dump_sects array. */
12211 cmdline_dump_sects
= malloc (num_dump_sects
);
12212 if (cmdline_dump_sects
== NULL
)
12213 error (_("Out of memory allocating dump request table."));
12216 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12217 num_cmdline_dump_sects
= num_dump_sects
;
12221 if (optind
< (argc
- 1))
12225 while (optind
< argc
)
12226 err
|= process_file (argv
[optind
++]);
12228 if (dump_sects
!= NULL
)
12230 if (cmdline_dump_sects
!= NULL
)
12231 free (cmdline_dump_sects
);