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., 51 Franklin Street - Fifth Floor, 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 static long archive_file_offset
;
121 static unsigned long archive_file_size
;
122 static unsigned long dynamic_addr
;
123 static bfd_size_type dynamic_size
;
124 static unsigned int dynamic_nent
;
125 static char *dynamic_strings
;
126 static unsigned long dynamic_strings_length
;
127 static char *string_table
;
128 static unsigned long string_table_length
;
129 static unsigned long num_dynamic_syms
;
130 static Elf_Internal_Sym
*dynamic_symbols
;
131 static Elf_Internal_Syminfo
*dynamic_syminfo
;
132 static unsigned long dynamic_syminfo_offset
;
133 static unsigned int dynamic_syminfo_nent
;
134 static char program_interpreter
[64];
135 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
136 static bfd_vma version_info
[16];
137 static Elf_Internal_Ehdr elf_header
;
138 static Elf_Internal_Shdr
*section_headers
;
139 static Elf_Internal_Phdr
*program_headers
;
140 static Elf_Internal_Dyn
*dynamic_section
;
141 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
142 static int show_name
;
143 static int do_dynamic
;
146 static int do_sections
;
147 static int do_section_groups
;
148 static int do_full_section_name
;
149 static int do_segments
;
150 static int do_unwind
;
151 static int do_using_dynamic
;
152 static int do_header
;
154 static int do_version
;
156 static int do_histogram
;
157 static int do_debugging
;
158 static int do_debug_info
;
159 static int do_debug_abbrevs
;
160 static int do_debug_lines
;
161 static int do_debug_pubnames
;
162 static int do_debug_aranges
;
163 static int do_debug_ranges
;
164 static int do_debug_frames
;
165 static int do_debug_frames_interp
;
166 static int do_debug_macinfo
;
167 static int do_debug_str
;
168 static int do_debug_loc
;
171 static int is_32bit_elf
;
172 static int have_frame_base
;
173 static int need_base_address
;
174 static 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 static size_t group_count
;
189 static struct group
*section_groups
;
190 static struct group
**section_headers_groups
;
192 /* A dynamic array of flags indicating for which sections a hex dump
193 has been requested (via the -x switch) and/or a disassembly dump
194 (via the -i switch). */
195 char *cmdline_dump_sects
= NULL
;
196 unsigned num_cmdline_dump_sects
= 0;
198 /* A dynamic array of flags indicating for which sections a dump of
199 some kind has been requested. It is reset on a per-object file
200 basis and then initialised from the cmdline_dump_sects array and
201 the results of interpreting the -w switch. */
202 char *dump_sects
= NULL
;
203 unsigned int num_dump_sects
= 0;
205 #define HEX_DUMP (1 << 0)
206 #define DISASS_DUMP (1 << 1)
207 #define DEBUG_DUMP (1 << 2)
209 /* How to rpint a vma value. */
210 typedef enum print_mode
222 static bfd_vma (*byte_get
) (unsigned char *, int);
223 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
227 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
228 ((X)->sh_name >= string_table_length \
229 ? "<corrupt>" : string_table + (X)->sh_name))
231 /* Given st_shndx I, map to section_headers index. */
232 #define SECTION_HEADER_INDEX(I) \
233 ((I) < SHN_LORESERVE \
235 : ((I) <= SHN_HIRESERVE \
237 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
239 /* Reverse of the above. */
240 #define SECTION_HEADER_NUM(N) \
241 ((N) < SHN_LORESERVE \
243 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
245 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
247 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
249 #define BYTE_GET(field) byte_get (field, sizeof (field))
251 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
253 #define GET_ELF_SYMBOLS(file, section) \
254 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
255 : get_64bit_elf_symbols (file, section))
257 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
258 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
259 already been called and verified that the string exists. */
260 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
262 /* This is just a bit of syntatic sugar. */
263 #define streq(a,b) (strcmp ((a), (b)) == 0)
264 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
267 error (const char *message
, ...)
271 va_start (args
, message
);
272 fprintf (stderr
, _("%s: Error: "), program_name
);
273 vfprintf (stderr
, message
, args
);
278 warn (const char *message
, ...)
282 va_start (args
, message
);
283 fprintf (stderr
, _("%s: Warning: "), program_name
);
284 vfprintf (stderr
, message
, args
);
289 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
296 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
298 error (_("Unable to seek to 0x%x for %s\n"),
299 archive_file_offset
+ offset
, reason
);
306 mvar
= malloc (size
);
310 error (_("Out of memory allocating 0x%x bytes for %s\n"),
316 if (fread (mvar
, size
, 1, file
) != 1)
318 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
328 byte_get_little_endian (unsigned char *field
, int size
)
336 return ((unsigned int) (field
[0]))
337 | (((unsigned int) (field
[1])) << 8);
341 /* We want to extract data from an 8 byte wide field and
342 place it into a 4 byte wide field. Since this is a little
343 endian source we can just use the 4 byte extraction code. */
347 return ((unsigned long) (field
[0]))
348 | (((unsigned long) (field
[1])) << 8)
349 | (((unsigned long) (field
[2])) << 16)
350 | (((unsigned long) (field
[3])) << 24);
354 return ((bfd_vma
) (field
[0]))
355 | (((bfd_vma
) (field
[1])) << 8)
356 | (((bfd_vma
) (field
[2])) << 16)
357 | (((bfd_vma
) (field
[3])) << 24)
358 | (((bfd_vma
) (field
[4])) << 32)
359 | (((bfd_vma
) (field
[5])) << 40)
360 | (((bfd_vma
) (field
[6])) << 48)
361 | (((bfd_vma
) (field
[7])) << 56);
364 error (_("Unhandled data length: %d\n"), size
);
370 byte_get_signed (unsigned char *field
, int size
)
372 bfd_vma x
= byte_get (field
, size
);
377 return (x
^ 0x80) - 0x80;
379 return (x
^ 0x8000) - 0x8000;
381 return (x
^ 0x80000000) - 0x80000000;
390 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
395 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
396 field
[6] = ((value
>> 24) >> 24) & 0xff;
397 field
[5] = ((value
>> 24) >> 16) & 0xff;
398 field
[4] = ((value
>> 24) >> 8) & 0xff;
401 field
[3] = (value
>> 24) & 0xff;
402 field
[2] = (value
>> 16) & 0xff;
405 field
[1] = (value
>> 8) & 0xff;
408 field
[0] = value
& 0xff;
412 error (_("Unhandled data length: %d\n"), size
);
417 #if defined BFD64 && !BFD_HOST_64BIT_LONG
419 print_dec_vma (bfd_vma vma
, int is_signed
)
425 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
434 *bufp
++ = '0' + vma
% 10;
446 print_hex_vma (bfd_vma vma
)
454 char digit
= '0' + (vma
& 0x0f);
456 digit
+= 'a' - '0' - 10;
469 /* Print a VMA value. */
471 print_vma (bfd_vma vma
, print_mode mode
)
480 return printf ("0x%8.8lx", (unsigned long) vma
);
483 return printf ("%8.8lx", (unsigned long) vma
);
487 return printf ("%5ld", (long) vma
);
491 return printf ("0x%lx", (unsigned long) vma
);
494 return printf ("%lx", (unsigned long) vma
);
497 return printf ("%ld", (unsigned long) vma
);
500 return printf ("%lu", (unsigned long) vma
);
523 #if BFD_HOST_64BIT_LONG
524 return nc
+ printf ("%lx", vma
);
526 return nc
+ print_hex_vma (vma
);
530 #if BFD_HOST_64BIT_LONG
531 return printf ("%ld", vma
);
533 return print_dec_vma (vma
, 1);
537 #if BFD_HOST_64BIT_LONG
539 return printf ("%5ld", vma
);
541 return printf ("%#lx", vma
);
544 return printf ("%5ld", _bfd_int64_low (vma
));
546 return print_hex_vma (vma
);
550 #if BFD_HOST_64BIT_LONG
551 return printf ("%lu", vma
);
553 return print_dec_vma (vma
, 0);
561 /* Display a symbol on stdout. If do_wide is not true then
562 format the symbol to be at most WIDTH characters,
563 truncating as necessary. If WIDTH is negative then
564 format the string to be exactly - WIDTH characters,
565 truncating or padding as necessary. */
568 print_symbol (int width
, const char *symbol
)
571 printf ("%s", symbol
);
573 printf ("%-*.*s", width
, width
, symbol
);
575 printf ("%-.*s", width
, symbol
);
579 byte_get_big_endian (unsigned char *field
, int size
)
587 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
591 /* Although we are extracing data from an 8 byte wide field,
592 we are returning only 4 bytes of data. */
597 return ((unsigned long) (field
[3]))
598 | (((unsigned long) (field
[2])) << 8)
599 | (((unsigned long) (field
[1])) << 16)
600 | (((unsigned long) (field
[0])) << 24);
604 return ((bfd_vma
) (field
[7]))
605 | (((bfd_vma
) (field
[6])) << 8)
606 | (((bfd_vma
) (field
[5])) << 16)
607 | (((bfd_vma
) (field
[4])) << 24)
608 | (((bfd_vma
) (field
[3])) << 32)
609 | (((bfd_vma
) (field
[2])) << 40)
610 | (((bfd_vma
) (field
[1])) << 48)
611 | (((bfd_vma
) (field
[0])) << 56);
615 error (_("Unhandled data length: %d\n"), size
);
621 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
626 field
[7] = value
& 0xff;
627 field
[6] = (value
>> 8) & 0xff;
628 field
[5] = (value
>> 16) & 0xff;
629 field
[4] = (value
>> 24) & 0xff;
634 field
[3] = value
& 0xff;
635 field
[2] = (value
>> 8) & 0xff;
639 field
[1] = value
& 0xff;
643 field
[0] = value
& 0xff;
647 error (_("Unhandled data length: %d\n"), size
);
652 /* Return a pointer to section NAME, or NULL if no such section exists. */
654 static Elf_Internal_Shdr
*
655 find_section (const char *name
)
659 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
660 if (streq (SECTION_NAME (section_headers
+ i
), name
))
661 return section_headers
+ i
;
666 /* Guess the relocation size commonly used by the specific machines. */
669 guess_is_rela (unsigned long e_machine
)
673 /* Targets that use REL relocations. */
688 /* Targets that use RELA relocations. */
703 case EM_CYGNUS_MN10200
:
705 case EM_CYGNUS_MN10300
:
752 warn (_("Don't know about relocations on this machine architecture\n"));
758 slurp_rela_relocs (FILE *file
,
759 unsigned long rel_offset
,
760 unsigned long rel_size
,
761 Elf_Internal_Rela
**relasp
,
762 unsigned long *nrelasp
)
764 Elf_Internal_Rela
*relas
;
765 unsigned long nrelas
;
770 Elf32_External_Rela
*erelas
;
772 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
776 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
778 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
782 error (_("out of memory parsing relocs"));
786 for (i
= 0; i
< nrelas
; i
++)
788 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
789 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
790 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
797 Elf64_External_Rela
*erelas
;
799 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
803 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
805 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
809 error (_("out of memory parsing relocs"));
813 for (i
= 0; i
< nrelas
; i
++)
815 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
816 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
817 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
828 slurp_rel_relocs (FILE *file
,
829 unsigned long rel_offset
,
830 unsigned long rel_size
,
831 Elf_Internal_Rela
**relsp
,
832 unsigned long *nrelsp
)
834 Elf_Internal_Rela
*rels
;
840 Elf32_External_Rel
*erels
;
842 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
846 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
848 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
852 error (_("out of memory parsing relocs"));
856 for (i
= 0; i
< nrels
; i
++)
858 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
859 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
860 rels
[i
].r_addend
= 0;
867 Elf64_External_Rel
*erels
;
869 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
873 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
875 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
879 error (_("out of memory parsing relocs"));
883 for (i
= 0; i
< nrels
; i
++)
885 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
886 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
887 rels
[i
].r_addend
= 0;
897 /* Display the contents of the relocation data found at the specified
901 dump_relocations (FILE *file
,
902 unsigned long rel_offset
,
903 unsigned long rel_size
,
904 Elf_Internal_Sym
*symtab
,
907 unsigned long strtablen
,
911 Elf_Internal_Rela
*rels
;
914 if (is_rela
== UNKNOWN
)
915 is_rela
= guess_is_rela (elf_header
.e_machine
);
919 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
924 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
933 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
935 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
940 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
942 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
950 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
952 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
957 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
959 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
963 for (i
= 0; i
< rel_size
; i
++)
966 const char *rtype2
= NULL
;
967 const char *rtype3
= NULL
;
970 bfd_vma symtab_index
;
975 offset
= rels
[i
].r_offset
;
976 info
= rels
[i
].r_info
;
980 type
= ELF32_R_TYPE (info
);
981 symtab_index
= ELF32_R_SYM (info
);
985 /* The #ifdef BFD64 below is to prevent a compile time warning.
986 We know that if we do not have a 64 bit data type that we
987 will never execute this code anyway. */
989 if (elf_header
.e_machine
== EM_MIPS
)
991 /* In little-endian objects, r_info isn't really a 64-bit
992 little-endian value: it has a 32-bit little-endian
993 symbol index followed by four individual byte fields.
994 Reorder INFO accordingly. */
995 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
996 info
= (((info
& 0xffffffff) << 32)
997 | ((info
>> 56) & 0xff)
998 | ((info
>> 40) & 0xff00)
999 | ((info
>> 24) & 0xff0000)
1000 | ((info
>> 8) & 0xff000000));
1001 type
= ELF64_MIPS_R_TYPE (info
);
1002 type2
= ELF64_MIPS_R_TYPE2 (info
);
1003 type3
= ELF64_MIPS_R_TYPE3 (info
);
1005 else if (elf_header
.e_machine
== EM_SPARCV9
)
1006 type
= ELF64_R_TYPE_ID (info
);
1008 type
= ELF64_R_TYPE (info
);
1010 symtab_index
= ELF64_R_SYM (info
);
1016 #ifdef _bfd_int64_low
1017 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1019 printf ("%8.8lx %8.8lx ", offset
, info
);
1024 #ifdef _bfd_int64_low
1026 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1027 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1028 _bfd_int64_high (offset
),
1029 _bfd_int64_low (offset
),
1030 _bfd_int64_high (info
),
1031 _bfd_int64_low (info
));
1034 ? "%16.16lx %16.16lx "
1035 : "%12.12lx %12.12lx ",
1040 switch (elf_header
.e_machine
)
1047 case EM_CYGNUS_M32R
:
1048 rtype
= elf_m32r_reloc_type (type
);
1053 rtype
= elf_i386_reloc_type (type
);
1058 rtype
= elf_m68hc11_reloc_type (type
);
1062 rtype
= elf_m68k_reloc_type (type
);
1066 rtype
= elf_i960_reloc_type (type
);
1071 rtype
= elf_avr_reloc_type (type
);
1074 case EM_OLD_SPARCV9
:
1075 case EM_SPARC32PLUS
:
1078 rtype
= elf_sparc_reloc_type (type
);
1082 case EM_CYGNUS_V850
:
1083 rtype
= v850_reloc_type (type
);
1087 case EM_CYGNUS_D10V
:
1088 rtype
= elf_d10v_reloc_type (type
);
1092 case EM_CYGNUS_D30V
:
1093 rtype
= elf_d30v_reloc_type (type
);
1097 rtype
= elf_dlx_reloc_type (type
);
1101 rtype
= elf_sh_reloc_type (type
);
1105 case EM_CYGNUS_MN10300
:
1106 rtype
= elf_mn10300_reloc_type (type
);
1110 case EM_CYGNUS_MN10200
:
1111 rtype
= elf_mn10200_reloc_type (type
);
1115 case EM_CYGNUS_FR30
:
1116 rtype
= elf_fr30_reloc_type (type
);
1120 rtype
= elf_frv_reloc_type (type
);
1124 rtype
= elf_mcore_reloc_type (type
);
1128 rtype
= elf_mmix_reloc_type (type
);
1133 rtype
= elf_msp430_reloc_type (type
);
1137 rtype
= elf_ppc_reloc_type (type
);
1141 rtype
= elf_ppc64_reloc_type (type
);
1145 case EM_MIPS_RS3_LE
:
1146 rtype
= elf_mips_reloc_type (type
);
1149 rtype2
= elf_mips_reloc_type (type2
);
1150 rtype3
= elf_mips_reloc_type (type3
);
1155 rtype
= elf_alpha_reloc_type (type
);
1159 rtype
= elf_arm_reloc_type (type
);
1163 rtype
= elf_arc_reloc_type (type
);
1167 rtype
= elf_hppa_reloc_type (type
);
1173 rtype
= elf_h8_reloc_type (type
);
1178 rtype
= elf_or32_reloc_type (type
);
1183 rtype
= elf_pj_reloc_type (type
);
1186 rtype
= elf_ia64_reloc_type (type
);
1190 rtype
= elf_cris_reloc_type (type
);
1194 rtype
= elf_i860_reloc_type (type
);
1198 rtype
= elf_x86_64_reloc_type (type
);
1202 rtype
= i370_reloc_type (type
);
1207 rtype
= elf_s390_reloc_type (type
);
1211 rtype
= elf_xstormy16_reloc_type (type
);
1215 rtype
= elf_crx_reloc_type (type
);
1219 rtype
= elf_vax_reloc_type (type
);
1224 rtype
= elf_ip2k_reloc_type (type
);
1228 rtype
= elf_iq2000_reloc_type (type
);
1233 rtype
= elf_xtensa_reloc_type (type
);
1238 #ifdef _bfd_int64_low
1239 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1241 printf (_("unrecognized: %-7lx"), type
);
1244 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1248 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1249 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1252 Elf_Internal_Sym
*psym
;
1254 psym
= symtab
+ symtab_index
;
1257 print_vma (psym
->st_value
, LONG_HEX
);
1258 printf (is_32bit_elf
? " " : " ");
1260 if (psym
->st_name
== 0)
1262 const char *sec_name
= "<null>";
1265 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1267 bfd_vma sec_index
= (bfd_vma
) -1;
1269 if (psym
->st_shndx
< SHN_LORESERVE
)
1270 sec_index
= psym
->st_shndx
;
1271 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1272 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1275 if (sec_index
!= (bfd_vma
) -1)
1276 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1277 else if (psym
->st_shndx
== SHN_ABS
)
1279 else if (psym
->st_shndx
== SHN_COMMON
)
1280 sec_name
= "COMMON";
1281 else if (elf_header
.e_machine
== EM_IA_64
1282 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1283 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1284 sec_name
= "ANSI_COM";
1287 sprintf (name_buf
, "<section 0x%x>",
1288 (unsigned int) psym
->st_shndx
);
1289 sec_name
= name_buf
;
1292 print_symbol (22, sec_name
);
1294 else if (strtab
== NULL
)
1295 printf (_("<string table index: %3ld>"), psym
->st_name
);
1296 else if (psym
->st_name
> strtablen
)
1297 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1299 print_symbol (22, strtab
+ psym
->st_name
);
1302 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1307 printf ("%*c", is_32bit_elf
?
1308 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1309 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1312 if (elf_header
.e_machine
== EM_SPARCV9
1313 && streq (rtype
, "R_SPARC_OLO10"))
1314 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1318 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1320 printf (" Type2: ");
1323 #ifdef _bfd_int64_low
1324 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1326 printf (_("unrecognized: %-7lx"), type2
);
1329 printf ("%-17.17s", rtype2
);
1331 printf ("\n Type3: ");
1334 #ifdef _bfd_int64_low
1335 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1337 printf (_("unrecognized: %-7lx"), type3
);
1340 printf ("%-17.17s", rtype3
);
1352 get_mips_dynamic_type (unsigned long type
)
1356 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1357 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1358 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1359 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1360 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1361 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1362 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1363 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1364 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1365 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1366 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1367 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1368 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1369 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1370 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1371 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1372 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1373 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1374 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1375 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1376 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1377 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1378 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1379 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1380 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1381 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1382 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1383 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1384 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1385 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1386 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1387 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1388 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1389 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1390 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1391 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1392 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1393 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1394 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1395 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1396 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1397 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1398 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1405 get_sparc64_dynamic_type (unsigned long type
)
1409 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1416 get_ppc_dynamic_type (unsigned long type
)
1420 case DT_PPC_GOT
: return "PPC_GOT";
1427 get_ppc64_dynamic_type (unsigned long type
)
1431 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1432 case DT_PPC64_OPD
: return "PPC64_OPD";
1433 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1440 get_parisc_dynamic_type (unsigned long type
)
1444 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1445 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1446 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1447 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1448 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1449 case DT_HP_PREINIT
: return "HP_PREINIT";
1450 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1451 case DT_HP_NEEDED
: return "HP_NEEDED";
1452 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1453 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1454 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1455 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1456 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1463 get_ia64_dynamic_type (unsigned long type
)
1467 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1474 get_dynamic_type (unsigned long type
)
1476 static char buff
[64];
1480 case DT_NULL
: return "NULL";
1481 case DT_NEEDED
: return "NEEDED";
1482 case DT_PLTRELSZ
: return "PLTRELSZ";
1483 case DT_PLTGOT
: return "PLTGOT";
1484 case DT_HASH
: return "HASH";
1485 case DT_STRTAB
: return "STRTAB";
1486 case DT_SYMTAB
: return "SYMTAB";
1487 case DT_RELA
: return "RELA";
1488 case DT_RELASZ
: return "RELASZ";
1489 case DT_RELAENT
: return "RELAENT";
1490 case DT_STRSZ
: return "STRSZ";
1491 case DT_SYMENT
: return "SYMENT";
1492 case DT_INIT
: return "INIT";
1493 case DT_FINI
: return "FINI";
1494 case DT_SONAME
: return "SONAME";
1495 case DT_RPATH
: return "RPATH";
1496 case DT_SYMBOLIC
: return "SYMBOLIC";
1497 case DT_REL
: return "REL";
1498 case DT_RELSZ
: return "RELSZ";
1499 case DT_RELENT
: return "RELENT";
1500 case DT_PLTREL
: return "PLTREL";
1501 case DT_DEBUG
: return "DEBUG";
1502 case DT_TEXTREL
: return "TEXTREL";
1503 case DT_JMPREL
: return "JMPREL";
1504 case DT_BIND_NOW
: return "BIND_NOW";
1505 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1506 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1507 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1508 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1509 case DT_RUNPATH
: return "RUNPATH";
1510 case DT_FLAGS
: return "FLAGS";
1512 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1513 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1515 case DT_CHECKSUM
: return "CHECKSUM";
1516 case DT_PLTPADSZ
: return "PLTPADSZ";
1517 case DT_MOVEENT
: return "MOVEENT";
1518 case DT_MOVESZ
: return "MOVESZ";
1519 case DT_FEATURE
: return "FEATURE";
1520 case DT_POSFLAG_1
: return "POSFLAG_1";
1521 case DT_SYMINSZ
: return "SYMINSZ";
1522 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1524 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1525 case DT_CONFIG
: return "CONFIG";
1526 case DT_DEPAUDIT
: return "DEPAUDIT";
1527 case DT_AUDIT
: return "AUDIT";
1528 case DT_PLTPAD
: return "PLTPAD";
1529 case DT_MOVETAB
: return "MOVETAB";
1530 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1532 case DT_VERSYM
: return "VERSYM";
1534 case DT_RELACOUNT
: return "RELACOUNT";
1535 case DT_RELCOUNT
: return "RELCOUNT";
1536 case DT_FLAGS_1
: return "FLAGS_1";
1537 case DT_VERDEF
: return "VERDEF";
1538 case DT_VERDEFNUM
: return "VERDEFNUM";
1539 case DT_VERNEED
: return "VERNEED";
1540 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1542 case DT_AUXILIARY
: return "AUXILIARY";
1543 case DT_USED
: return "USED";
1544 case DT_FILTER
: return "FILTER";
1546 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1547 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1548 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1549 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1550 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1553 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1557 switch (elf_header
.e_machine
)
1560 case EM_MIPS_RS3_LE
:
1561 result
= get_mips_dynamic_type (type
);
1564 result
= get_sparc64_dynamic_type (type
);
1567 result
= get_ppc_dynamic_type (type
);
1570 result
= get_ppc64_dynamic_type (type
);
1573 result
= get_ia64_dynamic_type (type
);
1583 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1585 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1589 switch (elf_header
.e_machine
)
1592 result
= get_parisc_dynamic_type (type
);
1602 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1606 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1613 get_file_type (unsigned e_type
)
1615 static char buff
[32];
1619 case ET_NONE
: return _("NONE (None)");
1620 case ET_REL
: return _("REL (Relocatable file)");
1621 case ET_EXEC
: return _("EXEC (Executable file)");
1622 case ET_DYN
: return _("DYN (Shared object file)");
1623 case ET_CORE
: return _("CORE (Core file)");
1626 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1627 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1628 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1629 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1631 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1637 get_machine_name (unsigned e_machine
)
1639 static char buff
[64]; /* XXX */
1643 case EM_NONE
: return _("None");
1644 case EM_M32
: return "WE32100";
1645 case EM_SPARC
: return "Sparc";
1646 case EM_386
: return "Intel 80386";
1647 case EM_68K
: return "MC68000";
1648 case EM_88K
: return "MC88000";
1649 case EM_486
: return "Intel 80486";
1650 case EM_860
: return "Intel 80860";
1651 case EM_MIPS
: return "MIPS R3000";
1652 case EM_S370
: return "IBM System/370";
1653 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1654 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1655 case EM_PARISC
: return "HPPA";
1656 case EM_PPC_OLD
: return "Power PC (old)";
1657 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1658 case EM_960
: return "Intel 90860";
1659 case EM_PPC
: return "PowerPC";
1660 case EM_PPC64
: return "PowerPC64";
1661 case EM_V800
: return "NEC V800";
1662 case EM_FR20
: return "Fujitsu FR20";
1663 case EM_RH32
: return "TRW RH32";
1664 case EM_MCORE
: return "MCORE";
1665 case EM_ARM
: return "ARM";
1666 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1667 case EM_SH
: return "Renesas / SuperH SH";
1668 case EM_SPARCV9
: return "Sparc v9";
1669 case EM_TRICORE
: return "Siemens Tricore";
1670 case EM_ARC
: return "ARC";
1671 case EM_H8_300
: return "Renesas H8/300";
1672 case EM_H8_300H
: return "Renesas H8/300H";
1673 case EM_H8S
: return "Renesas H8S";
1674 case EM_H8_500
: return "Renesas H8/500";
1675 case EM_IA_64
: return "Intel IA-64";
1676 case EM_MIPS_X
: return "Stanford MIPS-X";
1677 case EM_COLDFIRE
: return "Motorola Coldfire";
1678 case EM_68HC12
: return "Motorola M68HC12";
1679 case EM_ALPHA
: return "Alpha";
1680 case EM_CYGNUS_D10V
:
1681 case EM_D10V
: return "d10v";
1682 case EM_CYGNUS_D30V
:
1683 case EM_D30V
: return "d30v";
1684 case EM_CYGNUS_M32R
:
1685 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1686 case EM_CYGNUS_V850
:
1687 case EM_V850
: return "NEC v850";
1688 case EM_CYGNUS_MN10300
:
1689 case EM_MN10300
: return "mn10300";
1690 case EM_CYGNUS_MN10200
:
1691 case EM_MN10200
: return "mn10200";
1692 case EM_CYGNUS_FR30
:
1693 case EM_FR30
: return "Fujitsu FR30";
1694 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1696 case EM_PJ
: return "picoJava";
1697 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1698 case EM_PCP
: return "Siemens PCP";
1699 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1700 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1701 case EM_STARCORE
: return "Motorola Star*Core processor";
1702 case EM_ME16
: return "Toyota ME16 processor";
1703 case EM_ST100
: return "STMicroelectronics ST100 processor";
1704 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1705 case EM_FX66
: return "Siemens FX66 microcontroller";
1706 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1707 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1708 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1709 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1710 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1711 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1712 case EM_SVX
: return "Silicon Graphics SVx";
1713 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1714 case EM_VAX
: return "Digital VAX";
1716 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1717 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1718 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1719 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1720 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1721 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1722 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1723 case EM_PRISM
: return "Vitesse Prism";
1724 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1726 case EM_S390
: return "IBM S/390";
1727 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1729 case EM_OR32
: return "OpenRISC";
1730 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1731 case EM_DLX
: return "OpenDLX";
1733 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1734 case EM_IQ2000
: return "Vitesse IQ2000";
1736 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1738 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1744 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1749 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1750 e_flags
&= ~ EF_ARM_EABIMASK
;
1752 /* Handle "generic" ARM flags. */
1753 if (e_flags
& EF_ARM_RELEXEC
)
1755 strcat (buf
, ", relocatable executable");
1756 e_flags
&= ~ EF_ARM_RELEXEC
;
1759 if (e_flags
& EF_ARM_HASENTRY
)
1761 strcat (buf
, ", has entry point");
1762 e_flags
&= ~ EF_ARM_HASENTRY
;
1765 /* Now handle EABI specific flags. */
1769 strcat (buf
, ", <unrecognized EABI>");
1774 case EF_ARM_EABI_VER1
:
1775 strcat (buf
, ", Version1 EABI");
1780 /* Process flags one bit at a time. */
1781 flag
= e_flags
& - e_flags
;
1786 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1787 strcat (buf
, ", sorted symbol tables");
1797 case EF_ARM_EABI_VER2
:
1798 strcat (buf
, ", Version2 EABI");
1803 /* Process flags one bit at a time. */
1804 flag
= e_flags
& - e_flags
;
1809 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1810 strcat (buf
, ", sorted symbol tables");
1813 case EF_ARM_DYNSYMSUSESEGIDX
:
1814 strcat (buf
, ", dynamic symbols use segment index");
1817 case EF_ARM_MAPSYMSFIRST
:
1818 strcat (buf
, ", mapping symbols precede others");
1828 case EF_ARM_EABI_VER3
:
1829 strcat (buf
, ", Version3 EABI");
1832 case EF_ARM_EABI_VER4
:
1833 strcat (buf
, ", Version4 EABI");
1838 /* Process flags one bit at a time. */
1839 flag
= e_flags
& - e_flags
;
1845 strcat (buf
, ", BE8");
1849 strcat (buf
, ", LE8");
1859 case EF_ARM_EABI_UNKNOWN
:
1860 strcat (buf
, ", GNU EABI");
1865 /* Process flags one bit at a time. */
1866 flag
= e_flags
& - e_flags
;
1871 case EF_ARM_INTERWORK
:
1872 strcat (buf
, ", interworking enabled");
1875 case EF_ARM_APCS_26
:
1876 strcat (buf
, ", uses APCS/26");
1879 case EF_ARM_APCS_FLOAT
:
1880 strcat (buf
, ", uses APCS/float");
1884 strcat (buf
, ", position independent");
1888 strcat (buf
, ", 8 bit structure alignment");
1891 case EF_ARM_NEW_ABI
:
1892 strcat (buf
, ", uses new ABI");
1895 case EF_ARM_OLD_ABI
:
1896 strcat (buf
, ", uses old ABI");
1899 case EF_ARM_SOFT_FLOAT
:
1900 strcat (buf
, ", software FP");
1903 case EF_ARM_VFP_FLOAT
:
1904 strcat (buf
, ", VFP");
1907 case EF_ARM_MAVERICK_FLOAT
:
1908 strcat (buf
, ", Maverick FP");
1919 strcat (buf
,", <unknown>");
1923 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1925 static char buf
[1024];
1937 decode_ARM_machine_flags (e_flags
, buf
);
1941 switch (e_flags
& EF_FRV_CPU_MASK
)
1943 case EF_FRV_CPU_GENERIC
:
1947 strcat (buf
, ", fr???");
1950 case EF_FRV_CPU_FR300
:
1951 strcat (buf
, ", fr300");
1954 case EF_FRV_CPU_FR400
:
1955 strcat (buf
, ", fr400");
1957 case EF_FRV_CPU_FR405
:
1958 strcat (buf
, ", fr405");
1961 case EF_FRV_CPU_FR450
:
1962 strcat (buf
, ", fr450");
1965 case EF_FRV_CPU_FR500
:
1966 strcat (buf
, ", fr500");
1968 case EF_FRV_CPU_FR550
:
1969 strcat (buf
, ", fr550");
1972 case EF_FRV_CPU_SIMPLE
:
1973 strcat (buf
, ", simple");
1975 case EF_FRV_CPU_TOMCAT
:
1976 strcat (buf
, ", tomcat");
1982 if (e_flags
& EF_CPU32
)
1983 strcat (buf
, ", cpu32");
1984 if (e_flags
& EF_M68000
)
1985 strcat (buf
, ", m68000");
1989 if (e_flags
& EF_PPC_EMB
)
1990 strcat (buf
, ", emb");
1992 if (e_flags
& EF_PPC_RELOCATABLE
)
1993 strcat (buf
, ", relocatable");
1995 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1996 strcat (buf
, ", relocatable-lib");
2000 case EM_CYGNUS_V850
:
2001 switch (e_flags
& EF_V850_ARCH
)
2004 strcat (buf
, ", v850e1");
2007 strcat (buf
, ", v850e");
2010 strcat (buf
, ", v850");
2013 strcat (buf
, ", unknown v850 architecture variant");
2019 case EM_CYGNUS_M32R
:
2020 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2021 strcat (buf
, ", m32r");
2026 case EM_MIPS_RS3_LE
:
2027 if (e_flags
& EF_MIPS_NOREORDER
)
2028 strcat (buf
, ", noreorder");
2030 if (e_flags
& EF_MIPS_PIC
)
2031 strcat (buf
, ", pic");
2033 if (e_flags
& EF_MIPS_CPIC
)
2034 strcat (buf
, ", cpic");
2036 if (e_flags
& EF_MIPS_UCODE
)
2037 strcat (buf
, ", ugen_reserved");
2039 if (e_flags
& EF_MIPS_ABI2
)
2040 strcat (buf
, ", abi2");
2042 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2043 strcat (buf
, ", odk first");
2045 if (e_flags
& EF_MIPS_32BITMODE
)
2046 strcat (buf
, ", 32bitmode");
2048 switch ((e_flags
& EF_MIPS_MACH
))
2050 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2051 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2052 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2053 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2054 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2055 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2056 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2057 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2058 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2059 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2061 /* We simply ignore the field in this case to avoid confusion:
2062 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2065 default: strcat (buf
, ", unknown CPU"); break;
2068 switch ((e_flags
& EF_MIPS_ABI
))
2070 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2071 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2072 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2073 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2075 /* We simply ignore the field in this case to avoid confusion:
2076 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2077 This means it is likely to be an o32 file, but not for
2080 default: strcat (buf
, ", unknown ABI"); break;
2083 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2084 strcat (buf
, ", mdmx");
2086 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2087 strcat (buf
, ", mips16");
2089 switch ((e_flags
& EF_MIPS_ARCH
))
2091 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2092 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2093 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2094 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2095 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2096 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2097 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2098 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2099 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2100 default: strcat (buf
, ", unknown ISA"); break;
2106 switch ((e_flags
& EF_SH_MACH_MASK
))
2108 case EF_SH1
: strcat (buf
, ", sh1"); break;
2109 case EF_SH2
: strcat (buf
, ", sh2"); break;
2110 case EF_SH3
: strcat (buf
, ", sh3"); break;
2111 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2112 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2113 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2114 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2115 case EF_SH4
: strcat (buf
, ", sh4"); break;
2116 case EF_SH5
: strcat (buf
, ", sh5"); break;
2117 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2118 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2119 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2120 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2121 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2122 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2123 default: strcat (buf
, ", unknown ISA"); break;
2129 if (e_flags
& EF_SPARC_32PLUS
)
2130 strcat (buf
, ", v8+");
2132 if (e_flags
& EF_SPARC_SUN_US1
)
2133 strcat (buf
, ", ultrasparcI");
2135 if (e_flags
& EF_SPARC_SUN_US3
)
2136 strcat (buf
, ", ultrasparcIII");
2138 if (e_flags
& EF_SPARC_HAL_R1
)
2139 strcat (buf
, ", halr1");
2141 if (e_flags
& EF_SPARC_LEDATA
)
2142 strcat (buf
, ", ledata");
2144 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2145 strcat (buf
, ", tso");
2147 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2148 strcat (buf
, ", pso");
2150 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2151 strcat (buf
, ", rmo");
2155 switch (e_flags
& EF_PARISC_ARCH
)
2157 case EFA_PARISC_1_0
:
2158 strcpy (buf
, ", PA-RISC 1.0");
2160 case EFA_PARISC_1_1
:
2161 strcpy (buf
, ", PA-RISC 1.1");
2163 case EFA_PARISC_2_0
:
2164 strcpy (buf
, ", PA-RISC 2.0");
2169 if (e_flags
& EF_PARISC_TRAPNIL
)
2170 strcat (buf
, ", trapnil");
2171 if (e_flags
& EF_PARISC_EXT
)
2172 strcat (buf
, ", ext");
2173 if (e_flags
& EF_PARISC_LSB
)
2174 strcat (buf
, ", lsb");
2175 if (e_flags
& EF_PARISC_WIDE
)
2176 strcat (buf
, ", wide");
2177 if (e_flags
& EF_PARISC_NO_KABP
)
2178 strcat (buf
, ", no kabp");
2179 if (e_flags
& EF_PARISC_LAZYSWAP
)
2180 strcat (buf
, ", lazyswap");
2185 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2186 strcat (buf
, ", new calling convention");
2188 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2189 strcat (buf
, ", gnu calling convention");
2193 if ((e_flags
& EF_IA_64_ABI64
))
2194 strcat (buf
, ", 64-bit");
2196 strcat (buf
, ", 32-bit");
2197 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2198 strcat (buf
, ", reduced fp model");
2199 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2200 strcat (buf
, ", no function descriptors, constant gp");
2201 else if ((e_flags
& EF_IA_64_CONS_GP
))
2202 strcat (buf
, ", constant gp");
2203 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2204 strcat (buf
, ", absolute");
2208 if ((e_flags
& EF_VAX_NONPIC
))
2209 strcat (buf
, ", non-PIC");
2210 if ((e_flags
& EF_VAX_DFLOAT
))
2211 strcat (buf
, ", D-Float");
2212 if ((e_flags
& EF_VAX_GFLOAT
))
2213 strcat (buf
, ", G-Float");
2222 get_osabi_name (unsigned int osabi
)
2224 static char buff
[32];
2228 case ELFOSABI_NONE
: return "UNIX - System V";
2229 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2230 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2231 case ELFOSABI_LINUX
: return "UNIX - Linux";
2232 case ELFOSABI_HURD
: return "GNU/Hurd";
2233 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2234 case ELFOSABI_AIX
: return "UNIX - AIX";
2235 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2236 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2237 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2238 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2239 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2240 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2241 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2242 case ELFOSABI_AROS
: return "Amiga Research OS";
2243 case ELFOSABI_STANDALONE
: return _("Standalone App");
2244 case ELFOSABI_ARM
: return "ARM";
2246 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2252 get_arm_segment_type (unsigned long type
)
2266 get_mips_segment_type (unsigned long type
)
2270 case PT_MIPS_REGINFO
:
2272 case PT_MIPS_RTPROC
:
2274 case PT_MIPS_OPTIONS
:
2284 get_parisc_segment_type (unsigned long type
)
2288 case PT_HP_TLS
: return "HP_TLS";
2289 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2290 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2291 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2292 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2293 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2294 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2295 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2296 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2297 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2298 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2299 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2300 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2301 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2310 get_ia64_segment_type (unsigned long type
)
2314 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2315 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2316 case PT_HP_TLS
: return "HP_TLS";
2317 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2318 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2319 case PT_IA_64_HP_STACK
: return "HP_STACK";
2328 get_segment_type (unsigned long p_type
)
2330 static char buff
[32];
2334 case PT_NULL
: return "NULL";
2335 case PT_LOAD
: return "LOAD";
2336 case PT_DYNAMIC
: return "DYNAMIC";
2337 case PT_INTERP
: return "INTERP";
2338 case PT_NOTE
: return "NOTE";
2339 case PT_SHLIB
: return "SHLIB";
2340 case PT_PHDR
: return "PHDR";
2341 case PT_TLS
: return "TLS";
2343 case PT_GNU_EH_FRAME
:
2344 return "GNU_EH_FRAME";
2345 case PT_GNU_STACK
: return "GNU_STACK";
2346 case PT_GNU_RELRO
: return "GNU_RELRO";
2349 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2353 switch (elf_header
.e_machine
)
2356 result
= get_arm_segment_type (p_type
);
2359 case EM_MIPS_RS3_LE
:
2360 result
= get_mips_segment_type (p_type
);
2363 result
= get_parisc_segment_type (p_type
);
2366 result
= get_ia64_segment_type (p_type
);
2376 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2378 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2382 switch (elf_header
.e_machine
)
2385 result
= get_parisc_segment_type (p_type
);
2388 result
= get_ia64_segment_type (p_type
);
2398 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2401 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2408 get_mips_section_type_name (unsigned int sh_type
)
2412 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2413 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2414 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2415 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2416 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2417 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2418 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2419 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2420 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2421 case SHT_MIPS_RELD
: return "MIPS_RELD";
2422 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2423 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2424 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2425 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2426 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2427 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2428 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2429 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2430 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2431 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2432 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2433 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2434 case SHT_MIPS_LINE
: return "MIPS_LINE";
2435 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2436 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2437 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2438 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2439 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2440 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2441 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2442 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2443 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2444 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2445 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2446 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2447 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2448 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2449 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2450 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2458 get_parisc_section_type_name (unsigned int sh_type
)
2462 case SHT_PARISC_EXT
: return "PARISC_EXT";
2463 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2464 case SHT_PARISC_DOC
: return "PARISC_DOC";
2472 get_ia64_section_type_name (unsigned int sh_type
)
2474 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2475 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2476 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2480 case SHT_IA_64_EXT
: return "IA_64_EXT";
2481 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2482 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2490 get_x86_64_section_type_name (unsigned int sh_type
)
2494 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2502 get_arm_section_type_name (unsigned int sh_type
)
2515 get_section_type_name (unsigned int sh_type
)
2517 static char buff
[32];
2521 case SHT_NULL
: return "NULL";
2522 case SHT_PROGBITS
: return "PROGBITS";
2523 case SHT_SYMTAB
: return "SYMTAB";
2524 case SHT_STRTAB
: return "STRTAB";
2525 case SHT_RELA
: return "RELA";
2526 case SHT_HASH
: return "HASH";
2527 case SHT_DYNAMIC
: return "DYNAMIC";
2528 case SHT_NOTE
: return "NOTE";
2529 case SHT_NOBITS
: return "NOBITS";
2530 case SHT_REL
: return "REL";
2531 case SHT_SHLIB
: return "SHLIB";
2532 case SHT_DYNSYM
: return "DYNSYM";
2533 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2534 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2535 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2536 case SHT_GROUP
: return "GROUP";
2537 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2538 case SHT_GNU_verdef
: return "VERDEF";
2539 case SHT_GNU_verneed
: return "VERNEED";
2540 case SHT_GNU_versym
: return "VERSYM";
2541 case 0x6ffffff0: return "VERSYM";
2542 case 0x6ffffffc: return "VERDEF";
2543 case 0x7ffffffd: return "AUXILIARY";
2544 case 0x7fffffff: return "FILTER";
2545 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2548 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2552 switch (elf_header
.e_machine
)
2555 case EM_MIPS_RS3_LE
:
2556 result
= get_mips_section_type_name (sh_type
);
2559 result
= get_parisc_section_type_name (sh_type
);
2562 result
= get_ia64_section_type_name (sh_type
);
2565 result
= get_x86_64_section_type_name (sh_type
);
2568 result
= get_arm_section_type_name (sh_type
);
2578 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2580 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2581 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2582 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2583 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2585 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2591 #define OPTION_DEBUG_DUMP 512
2593 static struct option options
[] =
2595 {"all", no_argument
, 0, 'a'},
2596 {"file-header", no_argument
, 0, 'h'},
2597 {"program-headers", no_argument
, 0, 'l'},
2598 {"headers", no_argument
, 0, 'e'},
2599 {"histogram", no_argument
, 0, 'I'},
2600 {"segments", no_argument
, 0, 'l'},
2601 {"sections", no_argument
, 0, 'S'},
2602 {"section-headers", no_argument
, 0, 'S'},
2603 {"section-groups", no_argument
, 0, 'g'},
2604 {"full-section-name",no_argument
, 0, 'N'},
2605 {"symbols", no_argument
, 0, 's'},
2606 {"syms", no_argument
, 0, 's'},
2607 {"relocs", no_argument
, 0, 'r'},
2608 {"notes", no_argument
, 0, 'n'},
2609 {"dynamic", no_argument
, 0, 'd'},
2610 {"arch-specific", no_argument
, 0, 'A'},
2611 {"version-info", no_argument
, 0, 'V'},
2612 {"use-dynamic", no_argument
, 0, 'D'},
2613 {"hex-dump", required_argument
, 0, 'x'},
2614 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2615 {"unwind", no_argument
, 0, 'u'},
2616 #ifdef SUPPORT_DISASSEMBLY
2617 {"instruction-dump", required_argument
, 0, 'i'},
2620 {"version", no_argument
, 0, 'v'},
2621 {"wide", no_argument
, 0, 'W'},
2622 {"help", no_argument
, 0, 'H'},
2623 {0, no_argument
, 0, 0}
2629 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2630 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2631 fprintf (stdout
, _(" Options are:\n\
2632 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2633 -h --file-header Display the ELF file header\n\
2634 -l --program-headers Display the program headers\n\
2635 --segments An alias for --program-headers\n\
2636 -S --section-headers Display the sections' header\n\
2637 --sections An alias for --section-headers\n\
2638 -g --section-groups Display the section groups\n\
2639 -N --full-section-name\n\
2640 Display the full section name\n\
2641 -e --headers Equivalent to: -h -l -S\n\
2642 -s --syms Display the symbol table\n\
2643 --symbols An alias for --syms\n\
2644 -n --notes Display the core notes (if present)\n\
2645 -r --relocs Display the relocations (if present)\n\
2646 -u --unwind Display the unwind info (if present)\n\
2647 -d --dynamic Display the dynamic section (if present)\n\
2648 -V --version-info Display the version sections (if present)\n\
2649 -A --arch-specific Display architecture specific information (if any).\n\
2650 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2651 -x --hex-dump=<number> Dump the contents of section <number>\n\
2652 -w[liaprmfFsoR] or\n\
2653 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2654 Display the contents of DWARF2 debug sections\n"));
2655 #ifdef SUPPORT_DISASSEMBLY
2656 fprintf (stdout
, _("\
2657 -i --instruction-dump=<number>\n\
2658 Disassemble the contents of section <number>\n"));
2660 fprintf (stdout
, _("\
2661 -I --histogram Display histogram of bucket list lengths\n\
2662 -W --wide Allow output width to exceed 80 characters\n\
2663 -H --help Display this information\n\
2664 -v --version Display the version number of readelf\n"));
2665 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2670 /* Record the fact that the user wants the contents of section number
2671 SECTION to be displayed using the method(s) encoded as flags bits
2672 in TYPE. Note, TYPE can be zero if we are creating the array for
2676 request_dump (unsigned int section
, int type
)
2678 if (section
>= num_dump_sects
)
2680 char *new_dump_sects
;
2682 new_dump_sects
= calloc (section
+ 1, 1);
2684 if (new_dump_sects
== NULL
)
2685 error (_("Out of memory allocating dump request table."));
2688 /* Copy current flag settings. */
2689 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2693 dump_sects
= new_dump_sects
;
2694 num_dump_sects
= section
+ 1;
2699 dump_sects
[section
] |= type
;
2705 parse_args (int argc
, char **argv
)
2712 while ((c
= getopt_long
2713 (argc
, argv
, "ersuahnldSDAINgw::x:i:vVWH", options
, NULL
)) != EOF
)
2734 do_section_groups
++;
2742 do_section_groups
++;
2745 do_full_section_name
++;
2787 section
= strtoul (optarg
, & cp
, 0);
2788 if (! *cp
&& section
>= 0)
2790 request_dump (section
, HEX_DUMP
);
2800 unsigned int index
= 0;
2804 while (optarg
[index
])
2805 switch (optarg
[index
++])
2814 do_debug_abbrevs
= 1;
2824 do_debug_pubnames
= 1;
2828 do_debug_aranges
= 1;
2832 do_debug_ranges
= 1;
2836 do_debug_frames_interp
= 1;
2838 do_debug_frames
= 1;
2843 do_debug_macinfo
= 1;
2857 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2862 case OPTION_DEBUG_DUMP
:
2870 const char * option
;
2873 debug_dump_long_opts
;
2875 debug_dump_long_opts opts_table
[] =
2877 /* Please keep this table alpha- sorted. */
2878 { "Ranges", & do_debug_ranges
},
2879 { "abbrev", & do_debug_abbrevs
},
2880 { "aranges", & do_debug_aranges
},
2881 { "frames", & do_debug_frames
},
2882 { "frames-interp", & do_debug_frames_interp
},
2883 { "info", & do_debug_info
},
2884 { "line", & do_debug_lines
},
2885 { "loc", & do_debug_loc
},
2886 { "macro", & do_debug_macinfo
},
2887 { "pubnames", & do_debug_pubnames
},
2888 /* This entry is for compatability
2889 with earlier versions of readelf. */
2890 { "ranges", & do_debug_aranges
},
2891 { "str", & do_debug_str
},
2902 debug_dump_long_opts
* entry
;
2904 for (entry
= opts_table
; entry
->option
; entry
++)
2906 size_t len
= strlen (entry
->option
);
2908 if (strneq (p
, entry
->option
, len
)
2909 && (p
[len
] == ',' || p
[len
] == '\0'))
2911 * entry
->variable
= 1;
2913 /* The --debug-dump=frames-interp option also
2914 enables the --debug-dump=frames option. */
2915 if (do_debug_frames_interp
)
2916 do_debug_frames
= 1;
2923 if (entry
->option
== NULL
)
2925 warn (_("Unrecognized debug option '%s'\n"), p
);
2926 p
= strchr (p
, ',');
2936 #ifdef SUPPORT_DISASSEMBLY
2939 section
= strtoul (optarg
, & cp
, 0);
2940 if (! *cp
&& section
>= 0)
2942 request_dump (section
, DISASS_DUMP
);
2948 print_version (program_name
);
2958 /* xgettext:c-format */
2959 error (_("Invalid option '-%c'\n"), c
);
2966 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2967 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2968 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2969 && !do_section_groups
)
2973 warn (_("Nothing to do.\n"));
2979 get_elf_class (unsigned int elf_class
)
2981 static char buff
[32];
2985 case ELFCLASSNONE
: return _("none");
2986 case ELFCLASS32
: return "ELF32";
2987 case ELFCLASS64
: return "ELF64";
2989 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
2995 get_data_encoding (unsigned int encoding
)
2997 static char buff
[32];
3001 case ELFDATANONE
: return _("none");
3002 case ELFDATA2LSB
: return _("2's complement, little endian");
3003 case ELFDATA2MSB
: return _("2's complement, big endian");
3005 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3010 /* Decode the data held in 'elf_header'. */
3013 process_file_header (void)
3015 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3016 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3017 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3018 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3021 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3029 printf (_("ELF Header:\n"));
3030 printf (_(" Magic: "));
3031 for (i
= 0; i
< EI_NIDENT
; i
++)
3032 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3034 printf (_(" Class: %s\n"),
3035 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3036 printf (_(" Data: %s\n"),
3037 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3038 printf (_(" Version: %d %s\n"),
3039 elf_header
.e_ident
[EI_VERSION
],
3040 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3042 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3045 printf (_(" OS/ABI: %s\n"),
3046 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3047 printf (_(" ABI Version: %d\n"),
3048 elf_header
.e_ident
[EI_ABIVERSION
]);
3049 printf (_(" Type: %s\n"),
3050 get_file_type (elf_header
.e_type
));
3051 printf (_(" Machine: %s\n"),
3052 get_machine_name (elf_header
.e_machine
));
3053 printf (_(" Version: 0x%lx\n"),
3054 (unsigned long) elf_header
.e_version
);
3056 printf (_(" Entry point address: "));
3057 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3058 printf (_("\n Start of program headers: "));
3059 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3060 printf (_(" (bytes into file)\n Start of section headers: "));
3061 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3062 printf (_(" (bytes into file)\n"));
3064 printf (_(" Flags: 0x%lx%s\n"),
3065 (unsigned long) elf_header
.e_flags
,
3066 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3067 printf (_(" Size of this header: %ld (bytes)\n"),
3068 (long) elf_header
.e_ehsize
);
3069 printf (_(" Size of program headers: %ld (bytes)\n"),
3070 (long) elf_header
.e_phentsize
);
3071 printf (_(" Number of program headers: %ld\n"),
3072 (long) elf_header
.e_phnum
);
3073 printf (_(" Size of section headers: %ld (bytes)\n"),
3074 (long) elf_header
.e_shentsize
);
3075 printf (_(" Number of section headers: %ld"),
3076 (long) elf_header
.e_shnum
);
3077 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3078 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3079 putc ('\n', stdout
);
3080 printf (_(" Section header string table index: %ld"),
3081 (long) elf_header
.e_shstrndx
);
3082 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3083 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3084 putc ('\n', stdout
);
3087 if (section_headers
!= NULL
)
3089 if (elf_header
.e_shnum
== 0)
3090 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3091 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3092 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3093 free (section_headers
);
3094 section_headers
= NULL
;
3102 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3104 Elf32_External_Phdr
*phdrs
;
3105 Elf32_External_Phdr
*external
;
3106 Elf_Internal_Phdr
*internal
;
3109 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3110 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3111 _("program headers"));
3115 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3116 i
< elf_header
.e_phnum
;
3117 i
++, internal
++, external
++)
3119 internal
->p_type
= BYTE_GET (external
->p_type
);
3120 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3121 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3122 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3123 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3124 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3125 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3126 internal
->p_align
= BYTE_GET (external
->p_align
);
3135 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3137 Elf64_External_Phdr
*phdrs
;
3138 Elf64_External_Phdr
*external
;
3139 Elf_Internal_Phdr
*internal
;
3142 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3143 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3144 _("program headers"));
3148 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3149 i
< elf_header
.e_phnum
;
3150 i
++, internal
++, external
++)
3152 internal
->p_type
= BYTE_GET (external
->p_type
);
3153 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3154 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3155 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3156 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3157 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3158 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3159 internal
->p_align
= BYTE_GET (external
->p_align
);
3167 /* Returns 1 if the program headers were read into `program_headers'. */
3170 get_program_headers (FILE *file
)
3172 Elf_Internal_Phdr
*phdrs
;
3174 /* Check cache of prior read. */
3175 if (program_headers
!= NULL
)
3178 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3182 error (_("Out of memory\n"));
3187 ? get_32bit_program_headers (file
, phdrs
)
3188 : get_64bit_program_headers (file
, phdrs
))
3190 program_headers
= phdrs
;
3198 /* Returns 1 if the program headers were loaded. */
3201 process_program_headers (FILE *file
)
3203 Elf_Internal_Phdr
*segment
;
3206 if (elf_header
.e_phnum
== 0)
3209 printf (_("\nThere are no program headers in this file.\n"));
3213 if (do_segments
&& !do_header
)
3215 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3216 printf (_("Entry point "));
3217 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3218 printf (_("\nThere are %d program headers, starting at offset "),
3219 elf_header
.e_phnum
);
3220 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3224 if (! get_program_headers (file
))
3229 if (elf_header
.e_phnum
> 1)
3230 printf (_("\nProgram Headers:\n"));
3232 printf (_("\nProgram Headers:\n"));
3236 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3239 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3243 (_(" Type Offset VirtAddr PhysAddr\n"));
3245 (_(" FileSiz MemSiz Flags Align\n"));
3252 for (i
= 0, segment
= program_headers
;
3253 i
< elf_header
.e_phnum
;
3258 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3262 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3263 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3264 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3265 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3266 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3268 (segment
->p_flags
& PF_R
? 'R' : ' '),
3269 (segment
->p_flags
& PF_W
? 'W' : ' '),
3270 (segment
->p_flags
& PF_X
? 'E' : ' '));
3271 printf ("%#lx", (unsigned long) segment
->p_align
);
3275 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3276 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3279 print_vma (segment
->p_offset
, FULL_HEX
);
3283 print_vma (segment
->p_vaddr
, FULL_HEX
);
3285 print_vma (segment
->p_paddr
, FULL_HEX
);
3288 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3289 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3292 print_vma (segment
->p_filesz
, FULL_HEX
);
3296 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3297 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3300 print_vma (segment
->p_offset
, FULL_HEX
);
3304 (segment
->p_flags
& PF_R
? 'R' : ' '),
3305 (segment
->p_flags
& PF_W
? 'W' : ' '),
3306 (segment
->p_flags
& PF_X
? 'E' : ' '));
3308 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3309 printf ("%#lx", (unsigned long) segment
->p_align
);
3312 print_vma (segment
->p_align
, PREFIX_HEX
);
3317 print_vma (segment
->p_offset
, FULL_HEX
);
3319 print_vma (segment
->p_vaddr
, FULL_HEX
);
3321 print_vma (segment
->p_paddr
, FULL_HEX
);
3323 print_vma (segment
->p_filesz
, FULL_HEX
);
3325 print_vma (segment
->p_memsz
, FULL_HEX
);
3327 (segment
->p_flags
& PF_R
? 'R' : ' '),
3328 (segment
->p_flags
& PF_W
? 'W' : ' '),
3329 (segment
->p_flags
& PF_X
? 'E' : ' '));
3330 print_vma (segment
->p_align
, HEX
);
3334 switch (segment
->p_type
)
3338 error (_("more than one dynamic segment\n"));
3340 /* Try to locate the .dynamic section. If there is
3341 a section header table, we can easily locate it. */
3342 if (section_headers
!= NULL
)
3344 Elf_Internal_Shdr
*sec
;
3346 sec
= find_section (".dynamic");
3347 if (sec
== NULL
|| sec
->sh_size
== 0)
3349 error (_("no .dynamic section in the dynamic segment"));
3353 dynamic_addr
= sec
->sh_offset
;
3354 dynamic_size
= sec
->sh_size
;
3356 if (dynamic_addr
< segment
->p_offset
3357 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3358 warn (_("the .dynamic section is not contained within the dynamic segment"));
3359 else if (dynamic_addr
> segment
->p_offset
)
3360 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3364 /* Otherwise, we can only assume that the .dynamic
3365 section is the first section in the DYNAMIC segment. */
3366 dynamic_addr
= segment
->p_offset
;
3367 dynamic_size
= segment
->p_filesz
;
3372 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3374 error (_("Unable to find program interpreter name\n"));
3377 program_interpreter
[0] = 0;
3378 fscanf (file
, "%63s", program_interpreter
);
3381 printf (_("\n [Requesting program interpreter: %s]"),
3382 program_interpreter
);
3388 putc ('\n', stdout
);
3391 if (do_segments
&& section_headers
!= NULL
)
3393 printf (_("\n Section to Segment mapping:\n"));
3394 printf (_(" Segment Sections...\n"));
3396 assert (string_table
!= NULL
);
3398 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3401 Elf_Internal_Shdr
*section
;
3403 segment
= program_headers
+ i
;
3404 section
= section_headers
;
3406 printf (" %2.2d ", i
);
3408 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3410 if (section
->sh_size
> 0
3411 /* Compare allocated sections by VMA, unallocated
3412 sections by file offset. */
3413 && (section
->sh_flags
& SHF_ALLOC
3414 ? (section
->sh_addr
>= segment
->p_vaddr
3415 && section
->sh_addr
+ section
->sh_size
3416 <= segment
->p_vaddr
+ segment
->p_memsz
)
3417 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3418 && (section
->sh_offset
+ section
->sh_size
3419 <= segment
->p_offset
+ segment
->p_filesz
)))
3420 /* .tbss is special. It doesn't contribute memory space
3421 to normal segments. */
3422 && (!((section
->sh_flags
& SHF_TLS
) != 0
3423 && section
->sh_type
== SHT_NOBITS
)
3424 || segment
->p_type
== PT_TLS
))
3425 printf ("%s ", SECTION_NAME (section
));
3436 /* Find the file offset corresponding to VMA by using the program headers. */
3439 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3441 Elf_Internal_Phdr
*seg
;
3443 if (! get_program_headers (file
))
3445 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3449 for (seg
= program_headers
;
3450 seg
< program_headers
+ elf_header
.e_phnum
;
3453 if (seg
->p_type
!= PT_LOAD
)
3456 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3457 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3458 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3461 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3468 get_32bit_section_headers (FILE *file
, unsigned int num
)
3470 Elf32_External_Shdr
*shdrs
;
3471 Elf_Internal_Shdr
*internal
;
3474 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3475 elf_header
.e_shentsize
* num
, _("section headers"));
3479 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3481 if (section_headers
== NULL
)
3483 error (_("Out of memory\n"));
3487 for (i
= 0, internal
= section_headers
;
3491 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3492 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3493 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3494 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3495 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3496 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3497 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3498 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3499 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3500 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3509 get_64bit_section_headers (FILE *file
, unsigned int num
)
3511 Elf64_External_Shdr
*shdrs
;
3512 Elf_Internal_Shdr
*internal
;
3515 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3516 elf_header
.e_shentsize
* num
, _("section headers"));
3520 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3522 if (section_headers
== NULL
)
3524 error (_("Out of memory\n"));
3528 for (i
= 0, internal
= section_headers
;
3532 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3533 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3534 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3535 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3536 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3537 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3538 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3539 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3540 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3541 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3549 static Elf_Internal_Sym
*
3550 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3552 unsigned long number
;
3553 Elf32_External_Sym
*esyms
;
3554 Elf_External_Sym_Shndx
*shndx
;
3555 Elf_Internal_Sym
*isyms
;
3556 Elf_Internal_Sym
*psym
;
3559 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3565 if (symtab_shndx_hdr
!= NULL
3566 && (symtab_shndx_hdr
->sh_link
3567 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3569 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3570 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3578 number
= section
->sh_size
/ section
->sh_entsize
;
3579 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3583 error (_("Out of memory\n"));
3590 for (j
= 0, psym
= isyms
;
3594 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3595 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3596 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3597 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3598 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3600 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3601 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3602 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3612 static Elf_Internal_Sym
*
3613 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3615 unsigned long number
;
3616 Elf64_External_Sym
*esyms
;
3617 Elf_External_Sym_Shndx
*shndx
;
3618 Elf_Internal_Sym
*isyms
;
3619 Elf_Internal_Sym
*psym
;
3622 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3628 if (symtab_shndx_hdr
!= NULL
3629 && (symtab_shndx_hdr
->sh_link
3630 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3632 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3633 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3641 number
= section
->sh_size
/ section
->sh_entsize
;
3642 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3646 error (_("Out of memory\n"));
3653 for (j
= 0, psym
= isyms
;
3657 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3658 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3659 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3660 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3661 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3663 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3664 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3665 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3676 get_elf_section_flags (bfd_vma sh_flags
)
3678 static char buff
[33];
3685 flag
= sh_flags
& - sh_flags
;
3690 case SHF_WRITE
: *p
= 'W'; break;
3691 case SHF_ALLOC
: *p
= 'A'; break;
3692 case SHF_EXECINSTR
: *p
= 'X'; break;
3693 case SHF_MERGE
: *p
= 'M'; break;
3694 case SHF_STRINGS
: *p
= 'S'; break;
3695 case SHF_INFO_LINK
: *p
= 'I'; break;
3696 case SHF_LINK_ORDER
: *p
= 'L'; break;
3697 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3698 case SHF_GROUP
: *p
= 'G'; break;
3699 case SHF_TLS
: *p
= 'T'; break;
3702 if (flag
& SHF_MASKOS
)
3705 sh_flags
&= ~ SHF_MASKOS
;
3707 else if (flag
& SHF_MASKPROC
)
3710 sh_flags
&= ~ SHF_MASKPROC
;
3724 process_section_headers (FILE *file
)
3726 Elf_Internal_Shdr
*section
;
3729 section_headers
= NULL
;
3731 if (elf_header
.e_shnum
== 0)
3734 printf (_("\nThere are no sections in this file.\n"));
3739 if (do_sections
&& !do_header
)
3740 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3741 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3745 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3748 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3751 /* Read in the string table, so that we have names to display. */
3752 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3754 if (section
->sh_size
!= 0)
3756 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3757 section
->sh_size
, _("string table"));
3759 if (string_table
== NULL
)
3762 string_table_length
= section
->sh_size
;
3765 /* Scan the sections for the dynamic symbol table
3766 and dynamic string table and debug sections. */
3767 dynamic_symbols
= NULL
;
3768 dynamic_strings
= NULL
;
3769 dynamic_syminfo
= NULL
;
3770 symtab_shndx_hdr
= NULL
;
3772 eh_addr_size
= is_32bit_elf
? 4 : 8;
3773 switch (elf_header
.e_machine
)
3776 case EM_MIPS_RS3_LE
:
3777 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3778 FDE addresses. However, the ABI also has a semi-official ILP32
3779 variant for which the normal FDE address size rules apply.
3781 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3782 section, where XX is the size of longs in bits. Unfortunately,
3783 earlier compilers provided no way of distinguishing ILP32 objects
3784 from LP64 objects, so if there's any doubt, we should assume that
3785 the official LP64 form is being used. */
3786 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3787 && find_section (".gcc_compiled_long32") == NULL
)
3792 for (i
= 0, section
= section_headers
;
3793 i
< elf_header
.e_shnum
;
3796 char *name
= SECTION_NAME (section
);
3798 if (section
->sh_type
== SHT_DYNSYM
)
3800 if (dynamic_symbols
!= NULL
)
3802 error (_("File contains multiple dynamic symbol tables\n"));
3806 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3807 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3809 else if (section
->sh_type
== SHT_STRTAB
3810 && streq (name
, ".dynstr"))
3812 if (dynamic_strings
!= NULL
)
3814 error (_("File contains multiple dynamic string tables\n"));
3818 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3819 section
->sh_size
, _("dynamic strings"));
3820 dynamic_strings_length
= section
->sh_size
;
3822 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3824 if (symtab_shndx_hdr
!= NULL
)
3826 error (_("File contains multiple symtab shndx tables\n"));
3829 symtab_shndx_hdr
= section
;
3831 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3832 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3833 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3834 || do_debug_loc
|| do_debug_ranges
)
3835 && strneq (name
, ".debug_", 7))
3840 || (do_debug_info
&& streq (name
, "info"))
3841 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3842 || (do_debug_lines
&& streq (name
, "line"))
3843 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3844 || (do_debug_aranges
&& streq (name
, "aranges"))
3845 || (do_debug_ranges
&& streq (name
, "ranges"))
3846 || (do_debug_frames
&& streq (name
, "frame"))
3847 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3848 || (do_debug_str
&& streq (name
, "str"))
3849 || (do_debug_loc
&& streq (name
, "loc"))
3851 request_dump (i
, DEBUG_DUMP
);
3853 /* linkonce section to be combined with .debug_info at link time. */
3854 else if ((do_debugging
|| do_debug_info
)
3855 && strneq (name
, ".gnu.linkonce.wi.", 17))
3856 request_dump (i
, DEBUG_DUMP
);
3857 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3858 request_dump (i
, DEBUG_DUMP
);
3864 if (elf_header
.e_shnum
> 1)
3865 printf (_("\nSection Headers:\n"));
3867 printf (_("\nSection Header:\n"));
3871 if (do_full_section_name
)
3873 printf (_(" [Nr] Name\n"));
3874 printf (_(" Type Addr Off Size ES Flg Lk Inf Al\n"));
3878 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3882 if (do_full_section_name
)
3884 printf (_(" [Nr] Name\n"));
3885 printf (_(" Type Address Off Size ES Flg Lk Inf Al\n"));
3889 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3893 if (do_full_section_name
)
3895 printf (_(" [Nr] Name\n"));
3896 printf (_(" Flags Type Address Offset\n"));
3897 printf (_(" Size EntSize Link Info Align\n"));
3901 printf (_(" [Nr] Name Type Address Offset\n"));
3902 printf (_(" Size EntSize Flags Link Info Align\n"));
3906 for (i
= 0, section
= section_headers
;
3907 i
< elf_header
.e_shnum
;
3910 if (do_full_section_name
)
3912 printf (" [%2u] %s\n",
3913 SECTION_HEADER_NUM (i
),
3914 SECTION_NAME (section
));
3915 if (is_32bit_elf
|| do_wide
)
3916 printf (" %-15.15s ",
3917 get_section_type_name (section
->sh_type
));
3920 printf (" [%2u] %-17.17s %-15.15s ",
3921 SECTION_HEADER_NUM (i
),
3922 SECTION_NAME (section
),
3923 get_section_type_name (section
->sh_type
));
3927 print_vma (section
->sh_addr
, LONG_HEX
);
3929 printf ( " %6.6lx %6.6lx %2.2lx",
3930 (unsigned long) section
->sh_offset
,
3931 (unsigned long) section
->sh_size
,
3932 (unsigned long) section
->sh_entsize
);
3934 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3936 printf ("%2ld %3lu %2ld\n",
3937 (unsigned long) section
->sh_link
,
3938 (unsigned long) section
->sh_info
,
3939 (unsigned long) section
->sh_addralign
);
3943 print_vma (section
->sh_addr
, LONG_HEX
);
3945 if ((long) section
->sh_offset
== section
->sh_offset
)
3946 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3950 print_vma (section
->sh_offset
, LONG_HEX
);
3953 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3954 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3958 print_vma (section
->sh_size
, LONG_HEX
);
3961 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3962 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3966 print_vma (section
->sh_entsize
, LONG_HEX
);
3969 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3971 printf ("%2ld %3lu ",
3972 (unsigned long) section
->sh_link
,
3973 (unsigned long) section
->sh_info
);
3975 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3976 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3979 print_vma (section
->sh_addralign
, DEC
);
3983 else if (do_full_section_name
)
3985 printf (" %-15.15s %-15.15s ",
3986 get_elf_section_flags (section
->sh_flags
),
3987 get_section_type_name (section
->sh_type
));
3989 print_vma (section
->sh_addr
, LONG_HEX
);
3990 if ((long) section
->sh_offset
== section
->sh_offset
)
3991 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3995 print_vma (section
->sh_offset
, LONG_HEX
);
3998 print_vma (section
->sh_size
, LONG_HEX
);
4000 print_vma (section
->sh_entsize
, LONG_HEX
);
4002 printf (" %2ld %3lu %ld\n",
4003 (unsigned long) section
->sh_link
,
4004 (unsigned long) section
->sh_info
,
4005 (unsigned long) section
->sh_addralign
);
4010 print_vma (section
->sh_addr
, LONG_HEX
);
4011 if ((long) section
->sh_offset
== section
->sh_offset
)
4012 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4016 print_vma (section
->sh_offset
, LONG_HEX
);
4019 print_vma (section
->sh_size
, LONG_HEX
);
4021 print_vma (section
->sh_entsize
, LONG_HEX
);
4023 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4025 printf (" %2ld %3lu %ld\n",
4026 (unsigned long) section
->sh_link
,
4027 (unsigned long) section
->sh_info
,
4028 (unsigned long) section
->sh_addralign
);
4032 printf (_("Key to Flags:\n\
4033 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4034 I (info), L (link order), G (group), x (unknown)\n\
4035 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4041 get_group_flags (unsigned int flags
)
4043 static char buff
[32];
4050 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4057 process_section_groups (FILE *file
)
4059 Elf_Internal_Shdr
*section
;
4061 struct group
*group
;
4062 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4063 Elf_Internal_Sym
*symtab
;
4066 /* Don't process section groups unless needed. */
4067 if (!do_unwind
&& !do_section_groups
)
4070 if (elf_header
.e_shnum
== 0)
4072 if (do_section_groups
)
4073 printf (_("\nThere are no sections in this file.\n"));
4078 if (section_headers
== NULL
)
4080 error (_("Section headers are not available!\n"));
4084 section_headers_groups
= calloc (elf_header
.e_shnum
,
4085 sizeof (struct group
*));
4087 if (section_headers_groups
== NULL
)
4089 error (_("Out of memory\n"));
4093 /* Scan the sections for the group section. */
4095 for (i
= 0, section
= section_headers
;
4096 i
< elf_header
.e_shnum
;
4098 if (section
->sh_type
== SHT_GROUP
)
4101 if (group_count
== 0)
4103 if (do_section_groups
)
4104 printf (_("\nThere are no section groups in this file.\n"));
4109 section_groups
= calloc (group_count
, sizeof (struct group
));
4111 if (section_groups
== NULL
)
4113 error (_("Out of memory\n"));
4121 for (i
= 0, section
= section_headers
, group
= section_groups
;
4122 i
< elf_header
.e_shnum
;
4125 if (section
->sh_type
== SHT_GROUP
)
4127 char *name
= SECTION_NAME (section
);
4129 unsigned char *start
, *indices
;
4130 unsigned int entry
, j
, size
;
4131 Elf_Internal_Shdr
*sec
;
4132 Elf_Internal_Sym
*sym
;
4134 /* Get the symbol table. */
4135 sec
= SECTION_HEADER (section
->sh_link
);
4136 if (sec
->sh_type
!= SHT_SYMTAB
)
4138 error (_("Bad sh_link in group section `%s'\n"), name
);
4142 if (symtab_sec
!= sec
)
4147 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4150 sym
= symtab
+ section
->sh_info
;
4152 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4154 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4157 error (_("Bad sh_info in group section `%s'\n"), name
);
4161 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4166 /* Get the string table. */
4167 sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4168 if (strtab_sec
!= sec
)
4173 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4174 strtab_sec
->sh_size
,
4177 group_name
= strtab
+ sym
->st_name
;
4180 start
= get_data (NULL
, file
, section
->sh_offset
,
4181 section
->sh_size
, _("section data"));
4184 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4185 entry
= byte_get (indices
, 4);
4188 if (do_section_groups
)
4190 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4191 get_group_flags (entry
), name
, group_name
, size
);
4193 printf (_(" [Index] Name\n"));
4196 group
->group_index
= i
;
4198 for (j
= 0; j
< size
; j
++)
4200 struct group_list
*g
;
4202 entry
= byte_get (indices
, 4);
4205 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4210 error (_("section [%5u] already in group section [%5u]\n"),
4212 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4217 /* Intel C/C++ compiler may put section 0 in a
4218 section group. We just warn it the first time
4219 and ignore it afterwards. */
4220 static int warned
= 0;
4223 error (_("section 0 in group section [%5u]\n"),
4224 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4230 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4233 if (do_section_groups
)
4235 sec
= SECTION_HEADER (entry
);
4236 printf (" [%5u] %s\n",
4237 entry
, SECTION_NAME (sec
));
4240 g
= xmalloc (sizeof (struct group_list
));
4241 g
->section_index
= entry
;
4242 g
->next
= group
->root
;
4266 } dynamic_relocations
[] =
4268 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4269 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4270 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4273 /* Process the reloc section. */
4276 process_relocs (FILE *file
)
4278 unsigned long rel_size
;
4279 unsigned long rel_offset
;
4285 if (do_using_dynamic
)
4289 int has_dynamic_reloc
;
4292 has_dynamic_reloc
= 0;
4294 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4296 is_rela
= dynamic_relocations
[i
].rela
;
4297 name
= dynamic_relocations
[i
].name
;
4298 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4299 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4301 has_dynamic_reloc
|= rel_size
;
4303 if (is_rela
== UNKNOWN
)
4305 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4306 switch (dynamic_info
[DT_PLTREL
])
4320 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4321 name
, rel_offset
, rel_size
);
4323 dump_relocations (file
,
4324 offset_from_vma (file
, rel_offset
, rel_size
),
4326 dynamic_symbols
, num_dynamic_syms
,
4327 dynamic_strings
, dynamic_strings_length
, is_rela
);
4331 if (! has_dynamic_reloc
)
4332 printf (_("\nThere are no dynamic relocations in this file.\n"));
4336 Elf_Internal_Shdr
*section
;
4340 for (i
= 0, section
= section_headers
;
4341 i
< elf_header
.e_shnum
;
4344 if ( section
->sh_type
!= SHT_RELA
4345 && section
->sh_type
!= SHT_REL
)
4348 rel_offset
= section
->sh_offset
;
4349 rel_size
= section
->sh_size
;
4353 Elf_Internal_Shdr
*strsec
;
4356 printf (_("\nRelocation section "));
4358 if (string_table
== NULL
)
4359 printf ("%d", section
->sh_name
);
4361 printf (_("'%s'"), SECTION_NAME (section
));
4363 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4364 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4366 is_rela
= section
->sh_type
== SHT_RELA
;
4368 if (section
->sh_link
)
4370 Elf_Internal_Shdr
*symsec
;
4371 Elf_Internal_Sym
*symtab
;
4372 unsigned long nsyms
;
4373 unsigned long strtablen
;
4374 char *strtab
= NULL
;
4376 symsec
= SECTION_HEADER (section
->sh_link
);
4377 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4378 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4383 strsec
= SECTION_HEADER (symsec
->sh_link
);
4385 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4386 strsec
->sh_size
, _("string table"));
4387 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4389 dump_relocations (file
, rel_offset
, rel_size
,
4390 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4396 dump_relocations (file
, rel_offset
, rel_size
,
4397 NULL
, 0, NULL
, 0, is_rela
);
4404 printf (_("\nThere are no relocations in this file.\n"));
4410 /* Process the unwind section. */
4412 #include "unwind-ia64.h"
4414 /* An absolute address consists of a section and an offset. If the
4415 section is NULL, the offset itself is the address, otherwise, the
4416 address equals to LOAD_ADDRESS(section) + offset. */
4420 unsigned short section
;
4424 struct ia64_unw_aux_info
4426 struct ia64_unw_table_entry
4428 struct absaddr start
;
4430 struct absaddr info
;
4432 *table
; /* Unwind table. */
4433 unsigned long table_len
; /* Length of unwind table. */
4434 unsigned char *info
; /* Unwind info. */
4435 unsigned long info_size
; /* Size of unwind info. */
4436 bfd_vma info_addr
; /* starting address of unwind info. */
4437 bfd_vma seg_base
; /* Starting address of segment. */
4438 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4439 unsigned long nsyms
; /* Number of symbols. */
4440 char *strtab
; /* The string table. */
4441 unsigned long strtab_size
; /* Size of string table. */
4445 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4446 unsigned long nsyms
,
4448 unsigned long strtab_size
,
4449 struct absaddr addr
,
4450 const char **symname
,
4453 bfd_vma dist
= 0x100000;
4454 Elf_Internal_Sym
*sym
, *best
= NULL
;
4457 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4459 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4460 && sym
->st_name
!= 0
4461 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4462 && addr
.offset
>= sym
->st_value
4463 && addr
.offset
- sym
->st_value
< dist
)
4466 dist
= addr
.offset
- sym
->st_value
;
4473 *symname
= (best
->st_name
>= strtab_size
4474 ? "<corrupt>" : strtab
+ best
->st_name
);
4479 *offset
= addr
.offset
;
4483 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4485 struct ia64_unw_table_entry
*tp
;
4488 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4492 const unsigned char *dp
;
4493 const unsigned char *head
;
4494 const char *procname
;
4496 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4497 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4499 fputs ("\n<", stdout
);
4503 fputs (procname
, stdout
);
4506 printf ("+%lx", (unsigned long) offset
);
4509 fputs (">: [", stdout
);
4510 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4511 fputc ('-', stdout
);
4512 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4513 printf ("], info at +0x%lx\n",
4514 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4516 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4517 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4519 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4520 (unsigned) UNW_VER (stamp
),
4521 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4522 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4523 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4524 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4526 if (UNW_VER (stamp
) != 1)
4528 printf ("\tUnknown version.\n");
4533 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4534 dp
= unw_decode (dp
, in_body
, & in_body
);
4539 slurp_ia64_unwind_table (FILE *file
,
4540 struct ia64_unw_aux_info
*aux
,
4541 Elf_Internal_Shdr
*sec
)
4543 unsigned long size
, nrelas
, i
;
4544 Elf_Internal_Phdr
*seg
;
4545 struct ia64_unw_table_entry
*tep
;
4546 Elf_Internal_Shdr
*relsec
;
4547 Elf_Internal_Rela
*rela
, *rp
;
4548 unsigned char *table
, *tp
;
4549 Elf_Internal_Sym
*sym
;
4550 const char *relname
;
4552 /* First, find the starting address of the segment that includes
4555 if (elf_header
.e_phnum
)
4557 if (! get_program_headers (file
))
4560 for (seg
= program_headers
;
4561 seg
< program_headers
+ elf_header
.e_phnum
;
4564 if (seg
->p_type
!= PT_LOAD
)
4567 if (sec
->sh_addr
>= seg
->p_vaddr
4568 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4570 aux
->seg_base
= seg
->p_vaddr
;
4576 /* Second, build the unwind table from the contents of the unwind section: */
4577 size
= sec
->sh_size
;
4578 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4582 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4584 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4586 tep
->start
.section
= SHN_UNDEF
;
4587 tep
->end
.section
= SHN_UNDEF
;
4588 tep
->info
.section
= SHN_UNDEF
;
4591 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4592 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4593 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4597 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4598 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4599 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4601 tep
->start
.offset
+= aux
->seg_base
;
4602 tep
->end
.offset
+= aux
->seg_base
;
4603 tep
->info
.offset
+= aux
->seg_base
;
4607 /* Third, apply any relocations to the unwind table: */
4609 for (relsec
= section_headers
;
4610 relsec
< section_headers
+ elf_header
.e_shnum
;
4613 if (relsec
->sh_type
!= SHT_RELA
4614 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4617 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4621 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4625 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4626 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4630 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4631 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4634 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4636 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4640 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4642 switch (rp
->r_offset
/eh_addr_size
% 3)
4645 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4646 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4649 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4650 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4653 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4654 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4664 aux
->table_len
= size
/ (3 * eh_addr_size
);
4669 ia64_process_unwind (FILE *file
)
4671 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4672 unsigned long i
, unwcount
= 0, unwstart
= 0;
4673 struct ia64_unw_aux_info aux
;
4675 memset (& aux
, 0, sizeof (aux
));
4677 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4679 if (sec
->sh_type
== SHT_SYMTAB
)
4681 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4682 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4684 strsec
= SECTION_HEADER (sec
->sh_link
);
4685 aux
.strtab_size
= strsec
->sh_size
;
4686 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4687 aux
.strtab_size
, _("string table"));
4689 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4694 printf (_("\nThere are no unwind sections in this file.\n"));
4696 while (unwcount
-- > 0)
4701 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4702 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4703 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4710 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4712 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4714 /* We need to find which section group it is in. */
4715 struct group_list
*g
= section_headers_groups
[i
]->root
;
4717 for (; g
!= NULL
; g
= g
->next
)
4719 sec
= SECTION_HEADER (g
->section_index
);
4721 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4726 i
= elf_header
.e_shnum
;
4728 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4730 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4731 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4732 suffix
= SECTION_NAME (unwsec
) + len
;
4733 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4735 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4736 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4741 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4742 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4743 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4744 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4746 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4747 suffix
= SECTION_NAME (unwsec
) + len
;
4748 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4750 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4751 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4755 if (i
== elf_header
.e_shnum
)
4757 printf (_("\nCould not find unwind info section for "));
4759 if (string_table
== NULL
)
4760 printf ("%d", unwsec
->sh_name
);
4762 printf (_("'%s'"), SECTION_NAME (unwsec
));
4766 aux
.info_size
= sec
->sh_size
;
4767 aux
.info_addr
= sec
->sh_addr
;
4768 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4771 printf (_("\nUnwind section "));
4773 if (string_table
== NULL
)
4774 printf ("%d", unwsec
->sh_name
);
4776 printf (_("'%s'"), SECTION_NAME (unwsec
));
4778 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4779 (unsigned long) unwsec
->sh_offset
,
4780 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4782 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4784 if (aux
.table_len
> 0)
4785 dump_ia64_unwind (& aux
);
4788 free ((char *) aux
.table
);
4790 free ((char *) aux
.info
);
4799 free ((char *) aux
.strtab
);
4804 struct hppa_unw_aux_info
4806 struct hppa_unw_table_entry
4808 struct absaddr start
;
4810 unsigned int Cannot_unwind
:1; /* 0 */
4811 unsigned int Millicode
:1; /* 1 */
4812 unsigned int Millicode_save_sr0
:1; /* 2 */
4813 unsigned int Region_description
:2; /* 3..4 */
4814 unsigned int reserved1
:1; /* 5 */
4815 unsigned int Entry_SR
:1; /* 6 */
4816 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4817 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4818 unsigned int Args_stored
:1; /* 16 */
4819 unsigned int Variable_Frame
:1; /* 17 */
4820 unsigned int Separate_Package_Body
:1; /* 18 */
4821 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4822 unsigned int Stack_Overflow_Check
:1; /* 20 */
4823 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4824 unsigned int Ada_Region
:1; /* 22 */
4825 unsigned int cxx_info
:1; /* 23 */
4826 unsigned int cxx_try_catch
:1; /* 24 */
4827 unsigned int sched_entry_seq
:1; /* 25 */
4828 unsigned int reserved2
:1; /* 26 */
4829 unsigned int Save_SP
:1; /* 27 */
4830 unsigned int Save_RP
:1; /* 28 */
4831 unsigned int Save_MRP_in_frame
:1; /* 29 */
4832 unsigned int extn_ptr_defined
:1; /* 30 */
4833 unsigned int Cleanup_defined
:1; /* 31 */
4835 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4836 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4837 unsigned int Large_frame
:1; /* 2 */
4838 unsigned int Pseudo_SP_Set
:1; /* 3 */
4839 unsigned int reserved4
:1; /* 4 */
4840 unsigned int Total_frame_size
:27; /* 5..31 */
4842 *table
; /* Unwind table. */
4843 unsigned long table_len
; /* Length of unwind table. */
4844 bfd_vma seg_base
; /* Starting address of segment. */
4845 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4846 unsigned long nsyms
; /* Number of symbols. */
4847 char *strtab
; /* The string table. */
4848 unsigned long strtab_size
; /* Size of string table. */
4852 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4854 struct hppa_unw_table_entry
*tp
;
4856 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4859 const char *procname
;
4861 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4862 aux
->strtab_size
, tp
->start
, &procname
,
4865 fputs ("\n<", stdout
);
4869 fputs (procname
, stdout
);
4872 printf ("+%lx", (unsigned long) offset
);
4875 fputs (">: [", stdout
);
4876 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4877 fputc ('-', stdout
);
4878 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4881 #define PF(_m) if (tp->_m) printf (#_m " ");
4882 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4885 PF(Millicode_save_sr0
);
4886 /* PV(Region_description); */
4892 PF(Separate_Package_Body
);
4893 PF(Frame_Extension_Millicode
);
4894 PF(Stack_Overflow_Check
);
4895 PF(Two_Instruction_SP_Increment
);
4899 PF(sched_entry_seq
);
4902 PF(Save_MRP_in_frame
);
4903 PF(extn_ptr_defined
);
4904 PF(Cleanup_defined
);
4905 PF(MPE_XL_interrupt_marker
);
4906 PF(HP_UX_interrupt_marker
);
4909 PV(Total_frame_size
);
4918 slurp_hppa_unwind_table (FILE *file
,
4919 struct hppa_unw_aux_info
*aux
,
4920 Elf_Internal_Shdr
*sec
)
4922 unsigned long size
, unw_ent_size
, nrelas
, i
;
4923 Elf_Internal_Phdr
*seg
;
4924 struct hppa_unw_table_entry
*tep
;
4925 Elf_Internal_Shdr
*relsec
;
4926 Elf_Internal_Rela
*rela
, *rp
;
4927 unsigned char *table
, *tp
;
4928 Elf_Internal_Sym
*sym
;
4929 const char *relname
;
4931 /* First, find the starting address of the segment that includes
4934 if (elf_header
.e_phnum
)
4936 if (! get_program_headers (file
))
4939 for (seg
= program_headers
;
4940 seg
< program_headers
+ elf_header
.e_phnum
;
4943 if (seg
->p_type
!= PT_LOAD
)
4946 if (sec
->sh_addr
>= seg
->p_vaddr
4947 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4949 aux
->seg_base
= seg
->p_vaddr
;
4955 /* Second, build the unwind table from the contents of the unwind
4957 size
= sec
->sh_size
;
4958 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4962 unw_ent_size
= 2 * eh_addr_size
+ 8;
4964 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4966 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
4968 unsigned int tmp1
, tmp2
;
4970 tep
->start
.section
= SHN_UNDEF
;
4971 tep
->end
.section
= SHN_UNDEF
;
4975 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4976 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4977 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4978 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4982 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4983 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4984 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4985 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
4988 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
4989 tep
->Millicode
= (tmp1
>> 30) & 0x1;
4990 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
4991 tep
->Region_description
= (tmp1
>> 27) & 0x3;
4992 tep
->reserved1
= (tmp1
>> 26) & 0x1;
4993 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
4994 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
4995 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
4996 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
4997 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
4998 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
4999 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5000 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5001 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5002 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5003 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5004 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5005 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5006 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5007 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5008 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5009 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5010 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5011 tep
->Cleanup_defined
= tmp1
& 0x1;
5013 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5014 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5015 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5016 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5017 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5018 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5020 tep
->start
.offset
+= aux
->seg_base
;
5021 tep
->end
.offset
+= aux
->seg_base
;
5025 /* Third, apply any relocations to the unwind table. */
5027 for (relsec
= section_headers
;
5028 relsec
< section_headers
+ elf_header
.e_shnum
;
5031 if (relsec
->sh_type
!= SHT_RELA
5032 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5035 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5039 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5043 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5044 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5048 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5049 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5052 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5053 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5055 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5059 i
= rp
->r_offset
/ unw_ent_size
;
5061 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5064 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5065 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5068 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5069 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5079 aux
->table_len
= size
/ unw_ent_size
;
5085 hppa_process_unwind (FILE *file
)
5087 struct hppa_unw_aux_info aux
;
5088 Elf_Internal_Shdr
*unwsec
= NULL
;
5089 Elf_Internal_Shdr
*strsec
;
5090 Elf_Internal_Shdr
*sec
;
5093 memset (& aux
, 0, sizeof (aux
));
5095 assert (string_table
!= NULL
);
5097 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5099 if (sec
->sh_type
== SHT_SYMTAB
)
5101 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5102 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5104 strsec
= SECTION_HEADER (sec
->sh_link
);
5105 aux
.strtab_size
= strsec
->sh_size
;
5106 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5107 aux
.strtab_size
, _("string table"));
5109 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5114 printf (_("\nThere are no unwind sections in this file.\n"));
5116 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5118 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5120 printf (_("\nUnwind section "));
5121 printf (_("'%s'"), SECTION_NAME (sec
));
5123 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5124 (unsigned long) sec
->sh_offset
,
5125 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5127 slurp_hppa_unwind_table (file
, &aux
, sec
);
5128 if (aux
.table_len
> 0)
5129 dump_hppa_unwind (&aux
);
5132 free ((char *) aux
.table
);
5140 free ((char *) aux
.strtab
);
5146 process_unwind (FILE *file
)
5148 struct unwind_handler
{
5150 int (*handler
)(FILE *file
);
5152 { EM_IA_64
, ia64_process_unwind
},
5153 { EM_PARISC
, hppa_process_unwind
},
5161 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5162 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5163 return handlers
[i
].handler (file
);
5165 printf (_("\nThere are no unwind sections in this file.\n"));
5170 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5172 switch (entry
->d_tag
)
5175 if (entry
->d_un
.d_val
== 0)
5179 static const char * opts
[] =
5181 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5182 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5183 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5184 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5189 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5190 if (entry
->d_un
.d_val
& (1 << cnt
))
5192 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5199 case DT_MIPS_IVERSION
:
5200 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5201 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5203 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5206 case DT_MIPS_TIME_STAMP
:
5211 time_t time
= entry
->d_un
.d_val
;
5212 tmp
= gmtime (&time
);
5213 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5214 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5215 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5216 printf ("Time Stamp: %s\n", timebuf
);
5220 case DT_MIPS_RLD_VERSION
:
5221 case DT_MIPS_LOCAL_GOTNO
:
5222 case DT_MIPS_CONFLICTNO
:
5223 case DT_MIPS_LIBLISTNO
:
5224 case DT_MIPS_SYMTABNO
:
5225 case DT_MIPS_UNREFEXTNO
:
5226 case DT_MIPS_HIPAGENO
:
5227 case DT_MIPS_DELTA_CLASS_NO
:
5228 case DT_MIPS_DELTA_INSTANCE_NO
:
5229 case DT_MIPS_DELTA_RELOC_NO
:
5230 case DT_MIPS_DELTA_SYM_NO
:
5231 case DT_MIPS_DELTA_CLASSSYM_NO
:
5232 case DT_MIPS_COMPACT_SIZE
:
5233 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5237 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5243 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5245 switch (entry
->d_tag
)
5247 case DT_HP_DLD_FLAGS
:
5256 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5257 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5258 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5259 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5260 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5261 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5262 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5263 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5264 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5265 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5266 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5270 bfd_vma val
= entry
->d_un
.d_val
;
5272 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5273 if (val
& flags
[cnt
].bit
)
5277 fputs (flags
[cnt
].str
, stdout
);
5279 val
^= flags
[cnt
].bit
;
5282 if (val
!= 0 || first
)
5286 print_vma (val
, HEX
);
5292 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5299 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5301 switch (entry
->d_tag
)
5303 case DT_IA_64_PLT_RESERVE
:
5304 /* First 3 slots reserved. */
5305 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5307 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5311 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5318 get_32bit_dynamic_section (FILE *file
)
5320 Elf32_External_Dyn
*edyn
, *ext
;
5321 Elf_Internal_Dyn
*entry
;
5323 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5324 _("dynamic section"));
5328 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5329 might not have the luxury of section headers. Look for the DT_NULL
5330 terminator to determine the number of entries. */
5331 for (ext
= edyn
, dynamic_nent
= 0;
5332 (char *) ext
< (char *) edyn
+ dynamic_size
;
5336 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5340 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5341 if (dynamic_section
== NULL
)
5343 error (_("Out of memory\n"));
5348 for (ext
= edyn
, entry
= dynamic_section
;
5349 entry
< dynamic_section
+ dynamic_nent
;
5352 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5353 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5362 get_64bit_dynamic_section (FILE *file
)
5364 Elf64_External_Dyn
*edyn
, *ext
;
5365 Elf_Internal_Dyn
*entry
;
5367 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5368 _("dynamic section"));
5372 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5373 might not have the luxury of section headers. Look for the DT_NULL
5374 terminator to determine the number of entries. */
5375 for (ext
= edyn
, dynamic_nent
= 0;
5376 (char *) ext
< (char *) edyn
+ dynamic_size
;
5380 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5384 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5385 if (dynamic_section
== NULL
)
5387 error (_("Out of memory\n"));
5392 for (ext
= edyn
, entry
= dynamic_section
;
5393 entry
< dynamic_section
+ dynamic_nent
;
5396 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5397 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5406 print_dynamic_flags (bfd_vma flags
)
5414 flag
= flags
& - flags
;
5424 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5425 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5426 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5427 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5428 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5429 default: fputs ("unknown", stdout
); break;
5435 /* Parse and display the contents of the dynamic section. */
5438 process_dynamic_section (FILE *file
)
5440 Elf_Internal_Dyn
*entry
;
5442 if (dynamic_size
== 0)
5445 printf (_("\nThere is no dynamic section in this file.\n"));
5452 if (! get_32bit_dynamic_section (file
))
5455 else if (! get_64bit_dynamic_section (file
))
5458 /* Find the appropriate symbol table. */
5459 if (dynamic_symbols
== NULL
)
5461 for (entry
= dynamic_section
;
5462 entry
< dynamic_section
+ dynamic_nent
;
5465 Elf_Internal_Shdr section
;
5467 if (entry
->d_tag
!= DT_SYMTAB
)
5470 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5472 /* Since we do not know how big the symbol table is,
5473 we default to reading in the entire file (!) and
5474 processing that. This is overkill, I know, but it
5476 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5478 if (archive_file_offset
!= 0)
5479 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5482 if (fseek (file
, 0, SEEK_END
))
5483 error (_("Unable to seek to end of file!"));
5485 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5489 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5491 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5493 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5494 if (num_dynamic_syms
< 1)
5496 error (_("Unable to determine the number of symbols to load\n"));
5500 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5504 /* Similarly find a string table. */
5505 if (dynamic_strings
== NULL
)
5507 for (entry
= dynamic_section
;
5508 entry
< dynamic_section
+ dynamic_nent
;
5511 unsigned long offset
;
5514 if (entry
->d_tag
!= DT_STRTAB
)
5517 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5519 /* Since we do not know how big the string table is,
5520 we default to reading in the entire file (!) and
5521 processing that. This is overkill, I know, but it
5524 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5526 if (archive_file_offset
!= 0)
5527 str_tab_len
= archive_file_size
- offset
;
5530 if (fseek (file
, 0, SEEK_END
))
5531 error (_("Unable to seek to end of file\n"));
5532 str_tab_len
= ftell (file
) - offset
;
5535 if (str_tab_len
< 1)
5538 (_("Unable to determine the length of the dynamic string table\n"));
5542 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5543 _("dynamic string table"));
5544 dynamic_strings_length
= str_tab_len
;
5549 /* And find the syminfo section if available. */
5550 if (dynamic_syminfo
== NULL
)
5552 unsigned long syminsz
= 0;
5554 for (entry
= dynamic_section
;
5555 entry
< dynamic_section
+ dynamic_nent
;
5558 if (entry
->d_tag
== DT_SYMINENT
)
5560 /* Note: these braces are necessary to avoid a syntax
5561 error from the SunOS4 C compiler. */
5562 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5564 else if (entry
->d_tag
== DT_SYMINSZ
)
5565 syminsz
= entry
->d_un
.d_val
;
5566 else if (entry
->d_tag
== DT_SYMINFO
)
5567 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5571 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5573 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5574 Elf_Internal_Syminfo
*syminfo
;
5576 /* There is a syminfo section. Read the data. */
5577 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5578 _("symbol information"));
5582 dynamic_syminfo
= malloc (syminsz
);
5583 if (dynamic_syminfo
== NULL
)
5585 error (_("Out of memory\n"));
5589 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5590 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5591 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5592 ++syminfo
, ++extsym
)
5594 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5595 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5602 if (do_dynamic
&& dynamic_addr
)
5603 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5604 dynamic_addr
, dynamic_nent
);
5606 printf (_(" Tag Type Name/Value\n"));
5608 for (entry
= dynamic_section
;
5609 entry
< dynamic_section
+ dynamic_nent
;
5617 print_vma (entry
->d_tag
, FULL_HEX
);
5618 dtype
= get_dynamic_type (entry
->d_tag
);
5619 printf (" (%s)%*s", dtype
,
5620 ((is_32bit_elf
? 27 : 19)
5621 - (int) strlen (dtype
)),
5625 switch (entry
->d_tag
)
5629 print_dynamic_flags (entry
->d_un
.d_val
);
5639 switch (entry
->d_tag
)
5642 printf (_("Auxiliary library"));
5646 printf (_("Filter library"));
5650 printf (_("Configuration file"));
5654 printf (_("Dependency audit library"));
5658 printf (_("Audit library"));
5662 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5663 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5667 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5676 printf (_("Flags:"));
5678 if (entry
->d_un
.d_val
== 0)
5679 printf (_(" None\n"));
5682 unsigned long int val
= entry
->d_un
.d_val
;
5684 if (val
& DTF_1_PARINIT
)
5686 printf (" PARINIT");
5687 val
^= DTF_1_PARINIT
;
5689 if (val
& DTF_1_CONFEXP
)
5691 printf (" CONFEXP");
5692 val
^= DTF_1_CONFEXP
;
5695 printf (" %lx", val
);
5704 printf (_("Flags:"));
5706 if (entry
->d_un
.d_val
== 0)
5707 printf (_(" None\n"));
5710 unsigned long int val
= entry
->d_un
.d_val
;
5712 if (val
& DF_P1_LAZYLOAD
)
5714 printf (" LAZYLOAD");
5715 val
^= DF_P1_LAZYLOAD
;
5717 if (val
& DF_P1_GROUPPERM
)
5719 printf (" GROUPPERM");
5720 val
^= DF_P1_GROUPPERM
;
5723 printf (" %lx", val
);
5732 printf (_("Flags:"));
5733 if (entry
->d_un
.d_val
== 0)
5734 printf (_(" None\n"));
5737 unsigned long int val
= entry
->d_un
.d_val
;
5744 if (val
& DF_1_GLOBAL
)
5749 if (val
& DF_1_GROUP
)
5754 if (val
& DF_1_NODELETE
)
5756 printf (" NODELETE");
5757 val
^= DF_1_NODELETE
;
5759 if (val
& DF_1_LOADFLTR
)
5761 printf (" LOADFLTR");
5762 val
^= DF_1_LOADFLTR
;
5764 if (val
& DF_1_INITFIRST
)
5766 printf (" INITFIRST");
5767 val
^= DF_1_INITFIRST
;
5769 if (val
& DF_1_NOOPEN
)
5774 if (val
& DF_1_ORIGIN
)
5779 if (val
& DF_1_DIRECT
)
5784 if (val
& DF_1_TRANS
)
5789 if (val
& DF_1_INTERPOSE
)
5791 printf (" INTERPOSE");
5792 val
^= DF_1_INTERPOSE
;
5794 if (val
& DF_1_NODEFLIB
)
5796 printf (" NODEFLIB");
5797 val
^= DF_1_NODEFLIB
;
5799 if (val
& DF_1_NODUMP
)
5804 if (val
& DF_1_CONLFAT
)
5806 printf (" CONLFAT");
5807 val
^= DF_1_CONLFAT
;
5810 printf (" %lx", val
);
5817 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5819 puts (get_dynamic_type (entry
->d_un
.d_val
));
5839 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5845 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5846 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5852 switch (entry
->d_tag
)
5855 printf (_("Shared library: [%s]"), name
);
5857 if (streq (name
, program_interpreter
))
5858 printf (_(" program interpreter"));
5862 printf (_("Library soname: [%s]"), name
);
5866 printf (_("Library rpath: [%s]"), name
);
5870 printf (_("Library runpath: [%s]"), name
);
5874 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5879 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5892 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5896 case DT_INIT_ARRAYSZ
:
5897 case DT_FINI_ARRAYSZ
:
5898 case DT_GNU_CONFLICTSZ
:
5899 case DT_GNU_LIBLISTSZ
:
5902 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5903 printf (" (bytes)\n");
5913 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5926 if (entry
->d_tag
== DT_USED
5927 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5929 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5933 printf (_("Not needed object: [%s]\n"), name
);
5938 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5944 /* The value of this entry is ignored. */
5949 case DT_GNU_PRELINKED
:
5953 time_t time
= entry
->d_un
.d_val
;
5955 tmp
= gmtime (&time
);
5956 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5957 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5958 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5964 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5965 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5970 switch (elf_header
.e_machine
)
5973 case EM_MIPS_RS3_LE
:
5974 dynamic_section_mips_val (entry
);
5977 dynamic_section_parisc_val (entry
);
5980 dynamic_section_ia64_val (entry
);
5983 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5995 get_ver_flags (unsigned int flags
)
5997 static char buff
[32];
6004 if (flags
& VER_FLG_BASE
)
6005 strcat (buff
, "BASE ");
6007 if (flags
& VER_FLG_WEAK
)
6009 if (flags
& VER_FLG_BASE
)
6010 strcat (buff
, "| ");
6012 strcat (buff
, "WEAK ");
6015 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6016 strcat (buff
, "| <unknown>");
6021 /* Display the contents of the version sections. */
6023 process_version_sections (FILE *file
)
6025 Elf_Internal_Shdr
*section
;
6032 for (i
= 0, section
= section_headers
;
6033 i
< elf_header
.e_shnum
;
6036 switch (section
->sh_type
)
6038 case SHT_GNU_verdef
:
6040 Elf_External_Verdef
*edefs
;
6047 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6048 SECTION_NAME (section
), section
->sh_info
);
6050 printf (_(" Addr: 0x"));
6051 printf_vma (section
->sh_addr
);
6052 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6053 (unsigned long) section
->sh_offset
, section
->sh_link
,
6054 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6056 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6057 _("version definition section"));
6061 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6064 Elf_External_Verdef
*edef
;
6065 Elf_Internal_Verdef ent
;
6066 Elf_External_Verdaux
*eaux
;
6067 Elf_Internal_Verdaux aux
;
6071 vstart
= ((char *) edefs
) + idx
;
6073 edef
= (Elf_External_Verdef
*) vstart
;
6075 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6076 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6077 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6078 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6079 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6080 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6081 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6083 printf (_(" %#06x: Rev: %d Flags: %s"),
6084 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6086 printf (_(" Index: %d Cnt: %d "),
6087 ent
.vd_ndx
, ent
.vd_cnt
);
6089 vstart
+= ent
.vd_aux
;
6091 eaux
= (Elf_External_Verdaux
*) vstart
;
6093 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6094 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6096 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6097 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6099 printf (_("Name index: %ld\n"), aux
.vda_name
);
6101 isum
= idx
+ ent
.vd_aux
;
6103 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6105 isum
+= aux
.vda_next
;
6106 vstart
+= aux
.vda_next
;
6108 eaux
= (Elf_External_Verdaux
*) vstart
;
6110 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6111 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6113 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6114 printf (_(" %#06x: Parent %d: %s\n"),
6115 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6117 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6118 isum
, j
, aux
.vda_name
);
6128 case SHT_GNU_verneed
:
6130 Elf_External_Verneed
*eneed
;
6136 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6137 SECTION_NAME (section
), section
->sh_info
);
6139 printf (_(" Addr: 0x"));
6140 printf_vma (section
->sh_addr
);
6141 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6142 (unsigned long) section
->sh_offset
, section
->sh_link
,
6143 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6145 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6146 _("version need section"));
6150 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6152 Elf_External_Verneed
*entry
;
6153 Elf_Internal_Verneed ent
;
6158 vstart
= ((char *) eneed
) + idx
;
6160 entry
= (Elf_External_Verneed
*) vstart
;
6162 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6163 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6164 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6165 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6166 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6168 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6170 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6171 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6173 printf (_(" File: %lx"), ent
.vn_file
);
6175 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6177 vstart
+= ent
.vn_aux
;
6179 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6181 Elf_External_Vernaux
*eaux
;
6182 Elf_Internal_Vernaux aux
;
6184 eaux
= (Elf_External_Vernaux
*) vstart
;
6186 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6187 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6188 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6189 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6190 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6192 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6193 printf (_(" %#06x: Name: %s"),
6194 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6196 printf (_(" %#06x: Name index: %lx"),
6197 isum
, aux
.vna_name
);
6199 printf (_(" Flags: %s Version: %d\n"),
6200 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6202 isum
+= aux
.vna_next
;
6203 vstart
+= aux
.vna_next
;
6213 case SHT_GNU_versym
:
6215 Elf_Internal_Shdr
*link_section
;
6218 unsigned char *edata
;
6219 unsigned short *data
;
6221 Elf_Internal_Sym
*symbols
;
6222 Elf_Internal_Shdr
*string_sec
;
6225 link_section
= SECTION_HEADER (section
->sh_link
);
6226 total
= section
->sh_size
/ section
->sh_entsize
;
6230 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6232 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6234 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6235 string_sec
->sh_size
, _("version string table"));
6239 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6240 SECTION_NAME (section
), total
);
6242 printf (_(" Addr: "));
6243 printf_vma (section
->sh_addr
);
6244 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6245 (unsigned long) section
->sh_offset
, section
->sh_link
,
6246 SECTION_NAME (link_section
));
6248 off
= offset_from_vma (file
,
6249 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6250 total
* sizeof (short));
6251 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6252 _("version symbol data"));
6259 data
= malloc (total
* sizeof (short));
6261 for (cnt
= total
; cnt
--;)
6262 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6267 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6270 int check_def
, check_need
;
6273 printf (" %03x:", cnt
);
6275 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6276 switch (data
[cnt
+ j
])
6279 fputs (_(" 0 (*local*) "), stdout
);
6283 fputs (_(" 1 (*global*) "), stdout
);
6287 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6288 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6292 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6295 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6302 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6304 Elf_Internal_Verneed ivn
;
6305 unsigned long offset
;
6307 offset
= offset_from_vma
6308 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6309 sizeof (Elf_External_Verneed
));
6313 Elf_Internal_Vernaux ivna
;
6314 Elf_External_Verneed evn
;
6315 Elf_External_Vernaux evna
;
6316 unsigned long a_off
;
6318 get_data (&evn
, file
, offset
, sizeof (evn
),
6321 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6322 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6324 a_off
= offset
+ ivn
.vn_aux
;
6328 get_data (&evna
, file
, a_off
, sizeof (evna
),
6329 _("version need aux (2)"));
6331 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6332 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6334 a_off
+= ivna
.vna_next
;
6336 while (ivna
.vna_other
!= data
[cnt
+ j
]
6337 && ivna
.vna_next
!= 0);
6339 if (ivna
.vna_other
== data
[cnt
+ j
])
6341 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6343 name
= strtab
+ ivna
.vna_name
;
6344 nn
+= printf ("(%s%-*s",
6346 12 - (int) strlen (name
),
6352 offset
+= ivn
.vn_next
;
6354 while (ivn
.vn_next
);
6357 if (check_def
&& data
[cnt
+ j
] != 0x8001
6358 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6360 Elf_Internal_Verdef ivd
;
6361 Elf_External_Verdef evd
;
6362 unsigned long offset
;
6364 offset
= offset_from_vma
6365 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6370 get_data (&evd
, file
, offset
, sizeof (evd
),
6373 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6374 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6376 offset
+= ivd
.vd_next
;
6378 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6379 && ivd
.vd_next
!= 0);
6381 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6383 Elf_External_Verdaux evda
;
6384 Elf_Internal_Verdaux ivda
;
6386 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6388 get_data (&evda
, file
,
6389 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6390 sizeof (evda
), _("version def aux"));
6392 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6394 name
= strtab
+ ivda
.vda_name
;
6395 nn
+= printf ("(%s%-*s",
6397 12 - (int) strlen (name
),
6403 printf ("%*c", 18 - nn
, ' ');
6421 printf (_("\nNo version information found in this file.\n"));
6427 get_symbol_binding (unsigned int binding
)
6429 static char buff
[32];
6433 case STB_LOCAL
: return "LOCAL";
6434 case STB_GLOBAL
: return "GLOBAL";
6435 case STB_WEAK
: return "WEAK";
6437 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6438 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6440 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6441 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6443 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6449 get_symbol_type (unsigned int type
)
6451 static char buff
[32];
6455 case STT_NOTYPE
: return "NOTYPE";
6456 case STT_OBJECT
: return "OBJECT";
6457 case STT_FUNC
: return "FUNC";
6458 case STT_SECTION
: return "SECTION";
6459 case STT_FILE
: return "FILE";
6460 case STT_COMMON
: return "COMMON";
6461 case STT_TLS
: return "TLS";
6463 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6465 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6466 return "THUMB_FUNC";
6468 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6471 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6472 return "PARISC_MILLI";
6474 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6476 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6478 if (elf_header
.e_machine
== EM_PARISC
)
6480 if (type
== STT_HP_OPAQUE
)
6482 if (type
== STT_HP_STUB
)
6486 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6489 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6495 get_symbol_visibility (unsigned int visibility
)
6499 case STV_DEFAULT
: return "DEFAULT";
6500 case STV_INTERNAL
: return "INTERNAL";
6501 case STV_HIDDEN
: return "HIDDEN";
6502 case STV_PROTECTED
: return "PROTECTED";
6508 get_symbol_index_type (unsigned int type
)
6510 static char buff
[32];
6514 case SHN_UNDEF
: return "UND";
6515 case SHN_ABS
: return "ABS";
6516 case SHN_COMMON
: return "COM";
6518 if (type
== SHN_IA_64_ANSI_COMMON
6519 && elf_header
.e_machine
== EM_IA_64
6520 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6522 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6523 sprintf (buff
, "PRC[0x%04x]", type
);
6524 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6525 sprintf (buff
, "OS [0x%04x]", type
);
6526 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6527 sprintf (buff
, "RSV[0x%04x]", type
);
6529 sprintf (buff
, "%3d", type
);
6537 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6539 unsigned char *e_data
;
6542 e_data
= malloc (number
* ent_size
);
6546 error (_("Out of memory\n"));
6550 if (fread (e_data
, ent_size
, number
, file
) != number
)
6552 error (_("Unable to read in dynamic data\n"));
6556 i_data
= malloc (number
* sizeof (*i_data
));
6560 error (_("Out of memory\n"));
6566 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6573 /* Dump the symbol table. */
6575 process_symbol_table (FILE *file
)
6577 Elf_Internal_Shdr
*section
;
6578 bfd_vma nbuckets
= 0;
6579 bfd_vma nchains
= 0;
6580 bfd_vma
*buckets
= NULL
;
6581 bfd_vma
*chains
= NULL
;
6583 if (! do_syms
&& !do_histogram
)
6586 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6589 unsigned char nb
[8];
6590 unsigned char nc
[8];
6591 int hash_ent_size
= 4;
6593 if ((elf_header
.e_machine
== EM_ALPHA
6594 || elf_header
.e_machine
== EM_S390
6595 || elf_header
.e_machine
== EM_S390_OLD
)
6596 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6600 (archive_file_offset
6601 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6602 sizeof nb
+ sizeof nc
)),
6605 error (_("Unable to seek to start of dynamic information"));
6609 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6611 error (_("Failed to read in number of buckets\n"));
6615 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6617 error (_("Failed to read in number of chains\n"));
6621 nbuckets
= byte_get (nb
, hash_ent_size
);
6622 nchains
= byte_get (nc
, hash_ent_size
);
6624 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6625 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6627 if (buckets
== NULL
|| chains
== NULL
)
6632 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6637 printf (_("\nSymbol table for image:\n"));
6639 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6641 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6643 for (hn
= 0; hn
< nbuckets
; hn
++)
6648 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6650 Elf_Internal_Sym
*psym
;
6653 psym
= dynamic_symbols
+ si
;
6655 n
= print_vma (si
, DEC_5
);
6657 fputs (" " + n
, stdout
);
6658 printf (" %3lu: ", hn
);
6659 print_vma (psym
->st_value
, LONG_HEX
);
6661 print_vma (psym
->st_size
, DEC_5
);
6663 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6664 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6665 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6666 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6667 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6668 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6670 printf (" <corrupt: %14ld>", psym
->st_name
);
6675 else if (do_syms
&& !do_using_dynamic
)
6679 for (i
= 0, section
= section_headers
;
6680 i
< elf_header
.e_shnum
;
6685 Elf_Internal_Sym
*symtab
;
6686 Elf_Internal_Sym
*psym
;
6689 if ( section
->sh_type
!= SHT_SYMTAB
6690 && section
->sh_type
!= SHT_DYNSYM
)
6693 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6694 SECTION_NAME (section
),
6695 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6697 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6699 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6701 symtab
= GET_ELF_SYMBOLS (file
, section
);
6705 if (section
->sh_link
== elf_header
.e_shstrndx
)
6706 strtab
= string_table
;
6709 Elf_Internal_Shdr
*string_sec
;
6711 string_sec
= SECTION_HEADER (section
->sh_link
);
6713 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6714 string_sec
->sh_size
, _("string table"));
6717 for (si
= 0, psym
= symtab
;
6718 si
< section
->sh_size
/ section
->sh_entsize
;
6721 printf ("%6d: ", si
);
6722 print_vma (psym
->st_value
, LONG_HEX
);
6724 print_vma (psym
->st_size
, DEC_5
);
6725 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6726 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6727 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6728 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6729 print_symbol (25, strtab
+ psym
->st_name
);
6731 if (section
->sh_type
== SHT_DYNSYM
&&
6732 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6734 unsigned char data
[2];
6735 unsigned short vers_data
;
6736 unsigned long offset
;
6740 offset
= offset_from_vma
6741 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6742 sizeof data
+ si
* sizeof (vers_data
));
6744 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6745 sizeof (data
), _("version data"));
6747 vers_data
= byte_get (data
, 2);
6749 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6752 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6754 if ((vers_data
& 0x8000) || vers_data
> 1)
6756 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6757 && (is_nobits
|| ! check_def
))
6759 Elf_External_Verneed evn
;
6760 Elf_Internal_Verneed ivn
;
6761 Elf_Internal_Vernaux ivna
;
6763 /* We must test both. */
6764 offset
= offset_from_vma
6765 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6770 unsigned long vna_off
;
6772 get_data (&evn
, file
, offset
, sizeof (evn
),
6775 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6776 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6778 vna_off
= offset
+ ivn
.vn_aux
;
6782 Elf_External_Vernaux evna
;
6784 get_data (&evna
, file
, vna_off
,
6786 _("version need aux (3)"));
6788 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6789 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6790 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6792 vna_off
+= ivna
.vna_next
;
6794 while (ivna
.vna_other
!= vers_data
6795 && ivna
.vna_next
!= 0);
6797 if (ivna
.vna_other
== vers_data
)
6800 offset
+= ivn
.vn_next
;
6802 while (ivn
.vn_next
!= 0);
6804 if (ivna
.vna_other
== vers_data
)
6807 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6810 else if (! is_nobits
)
6811 error (_("bad dynamic symbol"));
6818 if (vers_data
!= 0x8001
6819 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6821 Elf_Internal_Verdef ivd
;
6822 Elf_Internal_Verdaux ivda
;
6823 Elf_External_Verdaux evda
;
6824 unsigned long offset
;
6826 offset
= offset_from_vma
6828 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6829 sizeof (Elf_External_Verdef
));
6833 Elf_External_Verdef evd
;
6835 get_data (&evd
, file
, offset
, sizeof (evd
),
6838 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6839 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6840 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6842 offset
+= ivd
.vd_next
;
6844 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6845 && ivd
.vd_next
!= 0);
6847 offset
-= ivd
.vd_next
;
6848 offset
+= ivd
.vd_aux
;
6850 get_data (&evda
, file
, offset
, sizeof (evda
),
6851 _("version def aux"));
6853 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6855 if (psym
->st_name
!= ivda
.vda_name
)
6856 printf ((vers_data
& 0x8000)
6858 strtab
+ ivda
.vda_name
);
6868 if (strtab
!= string_table
)
6874 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6876 if (do_histogram
&& buckets
!= NULL
)
6878 unsigned long *lengths
;
6879 unsigned long *counts
;
6882 unsigned long maxlength
= 0;
6883 unsigned long nzero_counts
= 0;
6884 unsigned long nsyms
= 0;
6886 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
6887 (unsigned long) nbuckets
);
6888 printf (_(" Length Number %% of total Coverage\n"));
6890 lengths
= calloc (nbuckets
, sizeof (*lengths
));
6891 if (lengths
== NULL
)
6893 error (_("Out of memory"));
6896 for (hn
= 0; hn
< nbuckets
; ++hn
)
6898 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6901 if (maxlength
< ++lengths
[hn
])
6906 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
6909 error (_("Out of memory"));
6913 for (hn
= 0; hn
< nbuckets
; ++hn
)
6914 ++counts
[lengths
[hn
]];
6919 printf (" 0 %-10lu (%5.1f%%)\n",
6920 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6921 for (i
= 1; i
<= maxlength
; ++i
)
6923 nzero_counts
+= counts
[i
] * i
;
6924 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
6925 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
6926 (nzero_counts
* 100.0) / nsyms
);
6934 if (buckets
!= NULL
)
6944 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6948 if (dynamic_syminfo
== NULL
6950 /* No syminfo, this is ok. */
6953 /* There better should be a dynamic symbol section. */
6954 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6958 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6959 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6961 printf (_(" Num: Name BoundTo Flags\n"));
6962 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6964 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6966 printf ("%4d: ", i
);
6967 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6968 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6970 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6973 switch (dynamic_syminfo
[i
].si_boundto
)
6975 case SYMINFO_BT_SELF
:
6976 fputs ("SELF ", stdout
);
6978 case SYMINFO_BT_PARENT
:
6979 fputs ("PARENT ", stdout
);
6982 if (dynamic_syminfo
[i
].si_boundto
> 0
6983 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6984 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6986 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6990 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6994 if (flags
& SYMINFO_FLG_DIRECT
)
6996 if (flags
& SYMINFO_FLG_PASSTHRU
)
6997 printf (" PASSTHRU");
6998 if (flags
& SYMINFO_FLG_COPY
)
7000 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7001 printf (" LAZYLOAD");
7009 #ifdef SUPPORT_DISASSEMBLY
7011 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7013 printf (_("\nAssembly dump of section %s\n"),
7014 SECTION_NAME (section
));
7016 /* XXX -- to be done --- XXX */
7023 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7025 bfd_size_type bytes
;
7027 unsigned char *data
;
7028 unsigned char *start
;
7030 bytes
= section
->sh_size
;
7032 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7034 printf (_("\nSection '%s' has no data to dump.\n"),
7035 SECTION_NAME (section
));
7039 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7041 addr
= section
->sh_addr
;
7043 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
7055 lbytes
= (bytes
> 16 ? 16 : bytes
);
7057 printf (" 0x%8.8lx ", (unsigned long) addr
);
7059 switch (elf_header
.e_ident
[EI_DATA
])
7063 for (j
= 15; j
>= 0; j
--)
7066 printf ("%2.2x", data
[j
]);
7076 for (j
= 0; j
< 16; j
++)
7079 printf ("%2.2x", data
[j
]);
7089 for (j
= 0; j
< lbytes
; j
++)
7092 if (k
>= ' ' && k
< 0x7f)
7111 static unsigned long int
7112 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7114 unsigned long int result
= 0;
7115 unsigned int num_read
= 0;
7116 unsigned int shift
= 0;
7124 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7129 while (byte
& 0x80);
7131 if (length_return
!= NULL
)
7132 *length_return
= num_read
;
7134 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7135 result
|= -1L << shift
;
7140 typedef struct State_Machine_Registers
7142 unsigned long address
;
7145 unsigned int column
;
7149 /* This variable hold the number of the last entry seen
7150 in the File Table. */
7151 unsigned int last_file_entry
;
7154 static SMR state_machine_regs
;
7157 reset_state_machine (int is_stmt
)
7159 state_machine_regs
.address
= 0;
7160 state_machine_regs
.file
= 1;
7161 state_machine_regs
.line
= 1;
7162 state_machine_regs
.column
= 0;
7163 state_machine_regs
.is_stmt
= is_stmt
;
7164 state_machine_regs
.basic_block
= 0;
7165 state_machine_regs
.end_sequence
= 0;
7166 state_machine_regs
.last_file_entry
= 0;
7169 /* Handled an extend line op.
7170 Returns the number of bytes read. */
7173 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7175 unsigned char op_code
;
7176 unsigned int bytes_read
;
7178 unsigned char *name
;
7181 len
= read_leb128 (data
, & bytes_read
, 0);
7186 warn (_("badly formed extended line op encountered!\n"));
7193 printf (_(" Extended opcode %d: "), op_code
);
7197 case DW_LNE_end_sequence
:
7198 printf (_("End of Sequence\n\n"));
7199 reset_state_machine (is_stmt
);
7202 case DW_LNE_set_address
:
7203 adr
= byte_get (data
, pointer_size
);
7204 printf (_("set Address to 0x%lx\n"), adr
);
7205 state_machine_regs
.address
= adr
;
7208 case DW_LNE_define_file
:
7209 printf (_(" define new File Table entry\n"));
7210 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7212 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7214 data
+= strlen ((char *) data
) + 1;
7215 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7217 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7219 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7220 printf (_("%s\n\n"), name
);
7224 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7231 static const char *debug_str_contents
;
7232 static bfd_vma debug_str_size
;
7235 load_debug_str (FILE *file
)
7237 Elf_Internal_Shdr
*sec
;
7239 /* If it is already loaded, do nothing. */
7240 if (debug_str_contents
!= NULL
)
7243 /* Locate the .debug_str section. */
7244 sec
= find_section (".debug_str");
7248 debug_str_size
= sec
->sh_size
;
7250 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7251 _("debug_str section data"));
7255 free_debug_str (void)
7257 if (debug_str_contents
== NULL
)
7260 free ((char *) debug_str_contents
);
7261 debug_str_contents
= NULL
;
7266 fetch_indirect_string (unsigned long offset
)
7268 if (debug_str_contents
== NULL
)
7269 return _("<no .debug_str section>");
7271 if (offset
> debug_str_size
)
7273 warn (_("DW_FORM_strp offset too big: %x\n"), offset
);
7274 return _("<offset is too big>");
7277 return debug_str_contents
+ offset
;
7280 static const char *debug_loc_contents
;
7281 static bfd_vma debug_loc_size
;
7284 load_debug_loc (FILE *file
)
7286 Elf_Internal_Shdr
*sec
;
7288 /* If it is already loaded, do nothing. */
7289 if (debug_loc_contents
!= NULL
)
7292 /* Locate the .debug_loc section. */
7293 sec
= find_section (".debug_loc");
7297 debug_loc_size
= sec
->sh_size
;
7299 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7300 _("debug_loc section data"));
7304 free_debug_loc (void)
7306 if (debug_loc_contents
== NULL
)
7309 free ((char *) debug_loc_contents
);
7310 debug_loc_contents
= NULL
;
7314 static const char * debug_range_contents
;
7315 static unsigned long debug_range_size
;
7318 load_debug_range (FILE *file
)
7320 Elf_Internal_Shdr
*sec
;
7322 /* If it is already loaded, do nothing. */
7323 if (debug_range_contents
!= NULL
)
7326 /* Locate the .debug_ranges section. */
7327 sec
= find_section (".debug_ranges");
7331 debug_range_size
= sec
->sh_size
;
7333 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7334 _("debug_range section data"));
7338 free_debug_range (void)
7340 if (debug_range_contents
== NULL
)
7343 free ((char *) debug_range_contents
);
7344 debug_range_contents
= NULL
;
7345 debug_range_size
= 0;
7348 /* Apply addends of RELA relocations. */
7351 debug_apply_rela_addends (FILE *file
,
7352 Elf_Internal_Shdr
*section
,
7354 unsigned char *sec_data
,
7355 unsigned char *start
,
7358 Elf_Internal_Shdr
*relsec
;
7360 if (end
- start
< reloc_size
)
7363 for (relsec
= section_headers
;
7364 relsec
< section_headers
+ elf_header
.e_shnum
;
7367 unsigned long nrelas
;
7368 Elf_Internal_Rela
*rela
, *rp
;
7369 Elf_Internal_Shdr
*symsec
;
7370 Elf_Internal_Sym
*symtab
;
7371 Elf_Internal_Sym
*sym
;
7373 if (relsec
->sh_type
!= SHT_RELA
7374 || SECTION_HEADER (relsec
->sh_info
) != section
7375 || relsec
->sh_size
== 0)
7378 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7382 symsec
= SECTION_HEADER (relsec
->sh_link
);
7383 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7385 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7389 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7390 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7391 loc
= sec_data
+ rp
->r_offset
;
7397 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7399 if (ELF32_R_SYM (rp
->r_info
) != 0
7400 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7401 /* Relocations against object symbols can happen,
7402 eg when referencing a global array. For an
7403 example of this see the _clz.o binary in libgcc.a. */
7404 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7406 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7407 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7408 SECTION_NAME (section
));
7414 /* In MIPS little-endian objects, r_info isn't really a
7415 64-bit little-endian value: it has a 32-bit little-endian
7416 symbol index followed by four individual byte fields.
7417 Reorder INFO accordingly. */
7418 if (elf_header
.e_machine
== EM_MIPS
7419 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7420 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7421 | ((rp
->r_info
>> 56) & 0xff)
7422 | ((rp
->r_info
>> 40) & 0xff00)
7423 | ((rp
->r_info
>> 24) & 0xff0000)
7424 | ((rp
->r_info
>> 8) & 0xff000000));
7426 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7428 if (ELF64_R_SYM (rp
->r_info
) != 0
7429 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7430 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7432 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7433 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7434 SECTION_NAME (section
));
7439 byte_put (loc
, rp
->r_addend
, reloc_size
);
7449 /* FIXME: There are better and more efficient ways to handle
7450 these structures. For now though, I just want something that
7451 is simple to implement. */
7452 typedef struct abbrev_attr
7454 unsigned long attribute
;
7456 struct abbrev_attr
*next
;
7460 typedef struct abbrev_entry
7462 unsigned long entry
;
7465 struct abbrev_attr
*first_attr
;
7466 struct abbrev_attr
*last_attr
;
7467 struct abbrev_entry
*next
;
7471 static abbrev_entry
*first_abbrev
= NULL
;
7472 static abbrev_entry
*last_abbrev
= NULL
;
7477 abbrev_entry
*abbrev
;
7479 for (abbrev
= first_abbrev
; abbrev
;)
7481 abbrev_entry
*next
= abbrev
->next
;
7484 for (attr
= abbrev
->first_attr
; attr
;)
7486 abbrev_attr
*next
= attr
->next
;
7496 last_abbrev
= first_abbrev
= NULL
;
7500 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7502 abbrev_entry
*entry
;
7504 entry
= malloc (sizeof (*entry
));
7510 entry
->entry
= number
;
7512 entry
->children
= children
;
7513 entry
->first_attr
= NULL
;
7514 entry
->last_attr
= NULL
;
7517 if (first_abbrev
== NULL
)
7518 first_abbrev
= entry
;
7520 last_abbrev
->next
= entry
;
7522 last_abbrev
= entry
;
7526 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7530 attr
= malloc (sizeof (*attr
));
7536 attr
->attribute
= attribute
;
7540 if (last_abbrev
->first_attr
== NULL
)
7541 last_abbrev
->first_attr
= attr
;
7543 last_abbrev
->last_attr
->next
= attr
;
7545 last_abbrev
->last_attr
= attr
;
7548 /* Processes the (partial) contents of a .debug_abbrev section.
7549 Returns NULL if the end of the section was encountered.
7550 Returns the address after the last byte read if the end of
7551 an abbreviation set was found. */
7553 static unsigned char *
7554 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7556 if (first_abbrev
!= NULL
)
7561 unsigned int bytes_read
;
7562 unsigned long entry
;
7564 unsigned long attribute
;
7567 entry
= read_leb128 (start
, & bytes_read
, 0);
7568 start
+= bytes_read
;
7570 /* A single zero is supposed to end the section according
7571 to the standard. If there's more, then signal that to
7574 return start
== end
? NULL
: start
;
7576 tag
= read_leb128 (start
, & bytes_read
, 0);
7577 start
+= bytes_read
;
7579 children
= *start
++;
7581 add_abbrev (entry
, tag
, children
);
7587 attribute
= read_leb128 (start
, & bytes_read
, 0);
7588 start
+= bytes_read
;
7590 form
= read_leb128 (start
, & bytes_read
, 0);
7591 start
+= bytes_read
;
7594 add_abbrev_attr (attribute
, form
);
7596 while (attribute
!= 0);
7603 get_TAG_name (unsigned long tag
)
7607 case DW_TAG_padding
: return "DW_TAG_padding";
7608 case DW_TAG_array_type
: return "DW_TAG_array_type";
7609 case DW_TAG_class_type
: return "DW_TAG_class_type";
7610 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7611 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7612 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7613 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7614 case DW_TAG_label
: return "DW_TAG_label";
7615 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7616 case DW_TAG_member
: return "DW_TAG_member";
7617 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7618 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7619 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7620 case DW_TAG_string_type
: return "DW_TAG_string_type";
7621 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7622 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7623 case DW_TAG_typedef
: return "DW_TAG_typedef";
7624 case DW_TAG_union_type
: return "DW_TAG_union_type";
7625 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7626 case DW_TAG_variant
: return "DW_TAG_variant";
7627 case DW_TAG_common_block
: return "DW_TAG_common_block";
7628 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7629 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7630 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7631 case DW_TAG_module
: return "DW_TAG_module";
7632 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7633 case DW_TAG_set_type
: return "DW_TAG_set_type";
7634 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7635 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7636 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7637 case DW_TAG_base_type
: return "DW_TAG_base_type";
7638 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7639 case DW_TAG_const_type
: return "DW_TAG_const_type";
7640 case DW_TAG_constant
: return "DW_TAG_constant";
7641 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7642 case DW_TAG_file_type
: return "DW_TAG_file_type";
7643 case DW_TAG_friend
: return "DW_TAG_friend";
7644 case DW_TAG_namelist
: return "DW_TAG_namelist";
7645 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7646 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7647 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7648 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7649 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7650 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7651 case DW_TAG_try_block
: return "DW_TAG_try_block";
7652 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7653 case DW_TAG_variable
: return "DW_TAG_variable";
7654 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7655 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7656 case DW_TAG_format_label
: return "DW_TAG_format_label";
7657 case DW_TAG_function_template
: return "DW_TAG_function_template";
7658 case DW_TAG_class_template
: return "DW_TAG_class_template";
7659 /* DWARF 2.1 values. */
7660 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7661 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7662 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7663 case DW_TAG_namespace
: return "DW_TAG_namespace";
7664 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7665 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7666 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7667 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7669 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7670 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7671 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7674 static char buffer
[100];
7676 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
7683 get_FORM_name (unsigned long form
)
7687 case DW_FORM_addr
: return "DW_FORM_addr";
7688 case DW_FORM_block2
: return "DW_FORM_block2";
7689 case DW_FORM_block4
: return "DW_FORM_block4";
7690 case DW_FORM_data2
: return "DW_FORM_data2";
7691 case DW_FORM_data4
: return "DW_FORM_data4";
7692 case DW_FORM_data8
: return "DW_FORM_data8";
7693 case DW_FORM_string
: return "DW_FORM_string";
7694 case DW_FORM_block
: return "DW_FORM_block";
7695 case DW_FORM_block1
: return "DW_FORM_block1";
7696 case DW_FORM_data1
: return "DW_FORM_data1";
7697 case DW_FORM_flag
: return "DW_FORM_flag";
7698 case DW_FORM_sdata
: return "DW_FORM_sdata";
7699 case DW_FORM_strp
: return "DW_FORM_strp";
7700 case DW_FORM_udata
: return "DW_FORM_udata";
7701 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7702 case DW_FORM_ref1
: return "DW_FORM_ref1";
7703 case DW_FORM_ref2
: return "DW_FORM_ref2";
7704 case DW_FORM_ref4
: return "DW_FORM_ref4";
7705 case DW_FORM_ref8
: return "DW_FORM_ref8";
7706 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7707 case DW_FORM_indirect
: return "DW_FORM_indirect";
7710 static char buffer
[100];
7712 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
7718 static unsigned char *
7719 display_block (unsigned char *data
, unsigned long length
)
7721 printf (_(" %lu byte block: "), length
);
7724 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7730 decode_location_expression (unsigned char * data
,
7731 unsigned int pointer_size
,
7732 unsigned long length
,
7733 unsigned long cu_offset
)
7736 unsigned int bytes_read
;
7737 unsigned long uvalue
;
7738 unsigned char *end
= data
+ length
;
7739 int need_frame_base
= 0;
7748 printf ("DW_OP_addr: %lx",
7749 (unsigned long) byte_get (data
, pointer_size
));
7750 data
+= pointer_size
;
7753 printf ("DW_OP_deref");
7756 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7759 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7762 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7766 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7770 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7774 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7778 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7779 (unsigned long) byte_get (data
+ 4, 4));
7783 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7784 (long) byte_get (data
+ 4, 4));
7788 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7792 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7796 printf ("DW_OP_dup");
7799 printf ("DW_OP_drop");
7802 printf ("DW_OP_over");
7805 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7808 printf ("DW_OP_swap");
7811 printf ("DW_OP_rot");
7814 printf ("DW_OP_xderef");
7817 printf ("DW_OP_abs");
7820 printf ("DW_OP_and");
7823 printf ("DW_OP_div");
7826 printf ("DW_OP_minus");
7829 printf ("DW_OP_mod");
7832 printf ("DW_OP_mul");
7835 printf ("DW_OP_neg");
7838 printf ("DW_OP_not");
7841 printf ("DW_OP_or");
7844 printf ("DW_OP_plus");
7846 case DW_OP_plus_uconst
:
7847 printf ("DW_OP_plus_uconst: %lu",
7848 read_leb128 (data
, &bytes_read
, 0));
7852 printf ("DW_OP_shl");
7855 printf ("DW_OP_shr");
7858 printf ("DW_OP_shra");
7861 printf ("DW_OP_xor");
7864 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7868 printf ("DW_OP_eq");
7871 printf ("DW_OP_ge");
7874 printf ("DW_OP_gt");
7877 printf ("DW_OP_le");
7880 printf ("DW_OP_lt");
7883 printf ("DW_OP_ne");
7886 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7922 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7957 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7992 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7993 read_leb128 (data
, &bytes_read
, 1));
7998 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8002 need_frame_base
= 1;
8003 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8007 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8009 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8010 read_leb128 (data
, &bytes_read
, 1));
8014 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8017 case DW_OP_deref_size
:
8018 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8020 case DW_OP_xderef_size
:
8021 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8024 printf ("DW_OP_nop");
8027 /* DWARF 3 extensions. */
8028 case DW_OP_push_object_address
:
8029 printf ("DW_OP_push_object_address");
8032 /* XXX: Strictly speaking for 64-bit DWARF3 files
8033 this ought to be an 8-byte wide computation. */
8034 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8038 /* XXX: Strictly speaking for 64-bit DWARF3 files
8039 this ought to be an 8-byte wide computation. */
8040 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8043 case DW_OP_call_ref
:
8044 printf ("DW_OP_call_ref");
8047 /* GNU extensions. */
8048 case DW_OP_GNU_push_tls_address
:
8049 printf ("DW_OP_GNU_push_tls_address");
8053 if (op
>= DW_OP_lo_user
8054 && op
<= DW_OP_hi_user
)
8055 printf (_("(User defined location op)"));
8057 printf (_("(Unknown location op)"));
8058 /* No way to tell where the next op is, so just bail. */
8059 return need_frame_base
;
8062 /* Separate the ops. */
8067 return need_frame_base
;
8070 /* This structure records the information that
8071 we extract from the.debug_info section. */
8074 unsigned int pointer_size
;
8075 unsigned long cu_offset
;
8076 unsigned long base_address
;
8077 /* This is an array of offsets to the location list table. */
8078 unsigned long *loc_offsets
;
8079 int *have_frame_base
;
8080 unsigned int num_loc_offsets
;
8081 unsigned int max_loc_offsets
;
8082 unsigned long *range_lists
;
8083 unsigned int num_range_lists
;
8084 unsigned int max_range_lists
;
8088 static debug_info
* debug_information
= NULL
;
8089 static unsigned int num_debug_info_entries
= 0;
8090 static unsigned int last_pointer_size
= 0;
8091 static int warned_about_missing_comp_units
= FALSE
;
8093 static unsigned char *
8094 read_and_display_attr_value (unsigned long attribute
,
8096 unsigned char *data
,
8097 unsigned long cu_offset
,
8098 unsigned long pointer_size
,
8099 unsigned long offset_size
,
8101 debug_info
*debug_info_p
,
8104 unsigned long uvalue
= 0;
8105 unsigned char *block_start
= NULL
;
8106 unsigned int bytes_read
;
8113 case DW_FORM_ref_addr
:
8114 if (dwarf_version
== 2)
8116 uvalue
= byte_get (data
, pointer_size
);
8117 data
+= pointer_size
;
8119 else if (dwarf_version
== 3)
8121 uvalue
= byte_get (data
, offset_size
);
8122 data
+= offset_size
;
8126 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8131 uvalue
= byte_get (data
, pointer_size
);
8132 data
+= pointer_size
;
8136 uvalue
= byte_get (data
, offset_size
);
8137 data
+= offset_size
;
8143 uvalue
= byte_get (data
++, 1);
8148 uvalue
= byte_get (data
, 2);
8154 uvalue
= byte_get (data
, 4);
8159 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8163 case DW_FORM_ref_udata
:
8165 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8169 case DW_FORM_indirect
:
8170 form
= read_leb128 (data
, & bytes_read
, 0);
8173 printf (" %s", get_FORM_name (form
));
8174 return read_and_display_attr_value (attribute
, form
, data
,
8175 cu_offset
, pointer_size
,
8176 offset_size
, dwarf_version
,
8177 debug_info_p
, do_loc
);
8182 case DW_FORM_ref_addr
:
8184 printf (" <#%lx>", uvalue
);
8190 case DW_FORM_ref_udata
:
8192 printf (" <%lx>", uvalue
+ cu_offset
);
8198 printf (" %#lx", uvalue
);
8207 printf (" %ld", uvalue
);
8214 uvalue
= byte_get (data
, 4);
8215 printf (" %lx", uvalue
);
8216 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8218 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8219 && num_debug_info_entries
== 0)
8221 if (sizeof (uvalue
) == 8)
8222 uvalue
= byte_get (data
, 8);
8224 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8229 case DW_FORM_string
:
8231 printf (" %s", data
);
8232 data
+= strlen ((char *) data
) + 1;
8236 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8237 block_start
= data
+ bytes_read
;
8239 data
= block_start
+ uvalue
;
8241 data
= display_block (block_start
, uvalue
);
8244 case DW_FORM_block1
:
8245 uvalue
= byte_get (data
, 1);
8246 block_start
= data
+ 1;
8248 data
= block_start
+ uvalue
;
8250 data
= display_block (block_start
, uvalue
);
8253 case DW_FORM_block2
:
8254 uvalue
= byte_get (data
, 2);
8255 block_start
= data
+ 2;
8257 data
= block_start
+ uvalue
;
8259 data
= display_block (block_start
, uvalue
);
8262 case DW_FORM_block4
:
8263 uvalue
= byte_get (data
, 4);
8264 block_start
= data
+ 4;
8266 data
= block_start
+ uvalue
;
8268 data
= display_block (block_start
, uvalue
);
8273 printf (_(" (indirect string, offset: 0x%lx): %s"),
8274 uvalue
, fetch_indirect_string (uvalue
));
8277 case DW_FORM_indirect
:
8278 /* Handled above. */
8282 warn (_("Unrecognized form: %d\n"), form
);
8286 /* For some attributes we can display further information. */
8287 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8288 && num_debug_info_entries
== 0)
8292 case DW_AT_frame_base
:
8293 have_frame_base
= 1;
8294 case DW_AT_location
:
8295 case DW_AT_data_member_location
:
8296 case DW_AT_vtable_elem_location
:
8297 case DW_AT_allocated
:
8298 case DW_AT_associated
:
8299 case DW_AT_data_location
:
8301 case DW_AT_upper_bound
:
8302 case DW_AT_lower_bound
:
8303 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8305 /* Process location list. */
8306 unsigned int max
= debug_info_p
->max_loc_offsets
;
8307 unsigned int num
= debug_info_p
->num_loc_offsets
;
8309 if (max
== 0 || num
>= max
)
8312 debug_info_p
->loc_offsets
8313 = xrealloc (debug_info_p
->loc_offsets
,
8314 max
* sizeof (*debug_info_p
->loc_offsets
));
8315 debug_info_p
->have_frame_base
8316 = xrealloc (debug_info_p
->have_frame_base
,
8317 max
* sizeof (*debug_info_p
->have_frame_base
));
8318 debug_info_p
->max_loc_offsets
= max
;
8320 debug_info_p
->loc_offsets
[num
] = uvalue
;
8321 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8322 debug_info_p
->num_loc_offsets
++;
8327 if (need_base_address
)
8328 debug_info_p
->base_address
= uvalue
;
8332 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8334 /* Process range list. */
8335 unsigned int max
= debug_info_p
->max_range_lists
;
8336 unsigned int num
= debug_info_p
->num_range_lists
;
8338 if (max
== 0 || num
>= max
)
8341 debug_info_p
->range_lists
8342 = xrealloc (debug_info_p
->range_lists
,
8343 max
* sizeof (*debug_info_p
->range_lists
));
8344 debug_info_p
->max_range_lists
= max
;
8346 debug_info_p
->range_lists
[num
] = uvalue
;
8347 debug_info_p
->num_range_lists
++;
8366 case DW_INL_not_inlined
:
8367 printf (_("(not inlined)"));
8369 case DW_INL_inlined
:
8370 printf (_("(inlined)"));
8372 case DW_INL_declared_not_inlined
:
8373 printf (_("(declared as inline but ignored)"));
8375 case DW_INL_declared_inlined
:
8376 printf (_("(declared as inline and inlined)"));
8379 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8384 case DW_AT_language
:
8387 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8388 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8389 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8390 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8391 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8392 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8393 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8394 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8395 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8396 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8397 /* DWARF 2.1 values. */
8398 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8399 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8400 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8401 /* MIPS extension. */
8402 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8403 /* UPC extension. */
8404 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8406 printf ("(Unknown: %lx)", uvalue
);
8411 case DW_AT_encoding
:
8414 case DW_ATE_void
: printf ("(void)"); break;
8415 case DW_ATE_address
: printf ("(machine address)"); break;
8416 case DW_ATE_boolean
: printf ("(boolean)"); break;
8417 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8418 case DW_ATE_float
: printf ("(float)"); break;
8419 case DW_ATE_signed
: printf ("(signed)"); break;
8420 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8421 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8422 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8423 /* DWARF 2.1 value. */
8424 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8425 /* GNU extension. */
8426 case DW_ATE_GNU_decimal_float
: printf ("(decimal float)"); break;
8428 if (uvalue
>= DW_ATE_lo_user
8429 && uvalue
<= DW_ATE_hi_user
)
8430 printf ("(user defined type)");
8432 printf ("(unknown type)");
8437 case DW_AT_accessibility
:
8440 case DW_ACCESS_public
: printf ("(public)"); break;
8441 case DW_ACCESS_protected
: printf ("(protected)"); break;
8442 case DW_ACCESS_private
: printf ("(private)"); break;
8444 printf ("(unknown accessibility)");
8449 case DW_AT_visibility
:
8452 case DW_VIS_local
: printf ("(local)"); break;
8453 case DW_VIS_exported
: printf ("(exported)"); break;
8454 case DW_VIS_qualified
: printf ("(qualified)"); break;
8455 default: printf ("(unknown visibility)"); break;
8459 case DW_AT_virtuality
:
8462 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8463 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8464 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8465 default: printf ("(unknown virtuality)"); break;
8469 case DW_AT_identifier_case
:
8472 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8473 case DW_ID_up_case
: printf ("(up_case)"); break;
8474 case DW_ID_down_case
: printf ("(down_case)"); break;
8475 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8476 default: printf ("(unknown case)"); break;
8480 case DW_AT_calling_convention
:
8483 case DW_CC_normal
: printf ("(normal)"); break;
8484 case DW_CC_program
: printf ("(program)"); break;
8485 case DW_CC_nocall
: printf ("(nocall)"); break;
8487 if (uvalue
>= DW_CC_lo_user
8488 && uvalue
<= DW_CC_hi_user
)
8489 printf ("(user defined)");
8491 printf ("(unknown convention)");
8495 case DW_AT_ordering
:
8498 case -1: printf ("(undefined)"); break;
8499 case 0: printf ("(row major)"); break;
8500 case 1: printf ("(column major)"); break;
8504 case DW_AT_frame_base
:
8505 have_frame_base
= 1;
8506 case DW_AT_location
:
8507 case DW_AT_data_member_location
:
8508 case DW_AT_vtable_elem_location
:
8509 case DW_AT_allocated
:
8510 case DW_AT_associated
:
8511 case DW_AT_data_location
:
8513 case DW_AT_upper_bound
:
8514 case DW_AT_lower_bound
:
8517 int need_frame_base
;
8520 need_frame_base
= decode_location_expression (block_start
,
8525 if (need_frame_base
&& !have_frame_base
)
8526 printf (_(" [without DW_AT_frame_base]"));
8528 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8529 printf (_("(location list)"));
8541 get_AT_name (unsigned long attribute
)
8545 case DW_AT_sibling
: return "DW_AT_sibling";
8546 case DW_AT_location
: return "DW_AT_location";
8547 case DW_AT_name
: return "DW_AT_name";
8548 case DW_AT_ordering
: return "DW_AT_ordering";
8549 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8550 case DW_AT_byte_size
: return "DW_AT_byte_size";
8551 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8552 case DW_AT_bit_size
: return "DW_AT_bit_size";
8553 case DW_AT_element_list
: return "DW_AT_element_list";
8554 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8555 case DW_AT_low_pc
: return "DW_AT_low_pc";
8556 case DW_AT_high_pc
: return "DW_AT_high_pc";
8557 case DW_AT_language
: return "DW_AT_language";
8558 case DW_AT_member
: return "DW_AT_member";
8559 case DW_AT_discr
: return "DW_AT_discr";
8560 case DW_AT_discr_value
: return "DW_AT_discr_value";
8561 case DW_AT_visibility
: return "DW_AT_visibility";
8562 case DW_AT_import
: return "DW_AT_import";
8563 case DW_AT_string_length
: return "DW_AT_string_length";
8564 case DW_AT_common_reference
: return "DW_AT_common_reference";
8565 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8566 case DW_AT_const_value
: return "DW_AT_const_value";
8567 case DW_AT_containing_type
: return "DW_AT_containing_type";
8568 case DW_AT_default_value
: return "DW_AT_default_value";
8569 case DW_AT_inline
: return "DW_AT_inline";
8570 case DW_AT_is_optional
: return "DW_AT_is_optional";
8571 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8572 case DW_AT_producer
: return "DW_AT_producer";
8573 case DW_AT_prototyped
: return "DW_AT_prototyped";
8574 case DW_AT_return_addr
: return "DW_AT_return_addr";
8575 case DW_AT_start_scope
: return "DW_AT_start_scope";
8576 case DW_AT_stride_size
: return "DW_AT_stride_size";
8577 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8578 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8579 case DW_AT_accessibility
: return "DW_AT_accessibility";
8580 case DW_AT_address_class
: return "DW_AT_address_class";
8581 case DW_AT_artificial
: return "DW_AT_artificial";
8582 case DW_AT_base_types
: return "DW_AT_base_types";
8583 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8584 case DW_AT_count
: return "DW_AT_count";
8585 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8586 case DW_AT_decl_column
: return "DW_AT_decl_column";
8587 case DW_AT_decl_file
: return "DW_AT_decl_file";
8588 case DW_AT_decl_line
: return "DW_AT_decl_line";
8589 case DW_AT_declaration
: return "DW_AT_declaration";
8590 case DW_AT_discr_list
: return "DW_AT_discr_list";
8591 case DW_AT_encoding
: return "DW_AT_encoding";
8592 case DW_AT_external
: return "DW_AT_external";
8593 case DW_AT_frame_base
: return "DW_AT_frame_base";
8594 case DW_AT_friend
: return "DW_AT_friend";
8595 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8596 case DW_AT_macro_info
: return "DW_AT_macro_info";
8597 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8598 case DW_AT_priority
: return "DW_AT_priority";
8599 case DW_AT_segment
: return "DW_AT_segment";
8600 case DW_AT_specification
: return "DW_AT_specification";
8601 case DW_AT_static_link
: return "DW_AT_static_link";
8602 case DW_AT_type
: return "DW_AT_type";
8603 case DW_AT_use_location
: return "DW_AT_use_location";
8604 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8605 case DW_AT_virtuality
: return "DW_AT_virtuality";
8606 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8607 /* DWARF 2.1 values. */
8608 case DW_AT_allocated
: return "DW_AT_allocated";
8609 case DW_AT_associated
: return "DW_AT_associated";
8610 case DW_AT_data_location
: return "DW_AT_data_location";
8611 case DW_AT_stride
: return "DW_AT_stride";
8612 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8613 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8614 case DW_AT_extension
: return "DW_AT_extension";
8615 case DW_AT_ranges
: return "DW_AT_ranges";
8616 case DW_AT_trampoline
: return "DW_AT_trampoline";
8617 case DW_AT_call_column
: return "DW_AT_call_column";
8618 case DW_AT_call_file
: return "DW_AT_call_file";
8619 case DW_AT_call_line
: return "DW_AT_call_line";
8620 /* SGI/MIPS extensions. */
8621 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8622 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8623 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8624 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8625 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8626 case DW_AT_MIPS_software_pipeline_depth
:
8627 return "DW_AT_MIPS_software_pipeline_depth";
8628 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8629 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8630 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8631 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8632 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8633 /* GNU extensions. */
8634 case DW_AT_sf_names
: return "DW_AT_sf_names";
8635 case DW_AT_src_info
: return "DW_AT_src_info";
8636 case DW_AT_mac_info
: return "DW_AT_mac_info";
8637 case DW_AT_src_coords
: return "DW_AT_src_coords";
8638 case DW_AT_body_begin
: return "DW_AT_body_begin";
8639 case DW_AT_body_end
: return "DW_AT_body_end";
8640 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8641 /* UPC extension. */
8642 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8645 static char buffer
[100];
8647 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8654 static unsigned char *
8655 read_and_display_attr (unsigned long attribute
,
8657 unsigned char *data
,
8658 unsigned long cu_offset
,
8659 unsigned long pointer_size
,
8660 unsigned long offset_size
,
8662 debug_info
*debug_info_p
,
8666 printf (" %-18s:", get_AT_name (attribute
));
8667 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8668 pointer_size
, offset_size
,
8669 dwarf_version
, debug_info_p
,
8677 /* Process the contents of a .debug_info section. If do_loc is non-zero
8678 then we are scanning for location lists and we do not want to display
8679 anything to the user. */
8682 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8683 FILE *file
, int do_loc
)
8685 unsigned char *end
= start
+ section
->sh_size
;
8686 unsigned char *section_begin
;
8688 unsigned int num_units
= 0;
8690 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8691 && num_debug_info_entries
== 0)
8693 unsigned long length
;
8695 /* First scan the section to get the number of comp units. */
8696 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8699 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8700 will be the length. For a 64-bit DWARF section, it'll be
8701 the escape code 0xffffffff followed by an 8 byte length. */
8702 length
= byte_get (section_begin
, 4);
8704 if (length
== 0xffffffff)
8706 length
= byte_get (section_begin
+ 4, 8);
8707 section_begin
+= length
+ 12;
8710 section_begin
+= length
+ 4;
8715 error (_("No comp units in .debug_info section ?"));
8719 /* Then allocate an array to hold the information. */
8720 debug_information
= malloc (num_units
*
8721 sizeof (* debug_information
));
8722 if (debug_information
== NULL
)
8724 error (_("Not enough memory for a debug info array of %u entries"),
8732 printf (_("The section %s contains:\n\n"),
8733 SECTION_NAME (section
));
8735 load_debug_str (file
);
8736 load_debug_loc (file
);
8737 load_debug_range (file
);
8740 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8742 DWARF2_Internal_CompUnit compunit
;
8743 unsigned char *hdrptr
;
8744 unsigned char *cu_abbrev_offset_ptr
;
8745 unsigned char *tags
;
8747 unsigned long cu_offset
;
8749 int initial_length_size
;
8753 compunit
.cu_length
= byte_get (hdrptr
, 4);
8756 if (compunit
.cu_length
== 0xffffffff)
8758 compunit
.cu_length
= byte_get (hdrptr
, 8);
8761 initial_length_size
= 12;
8766 initial_length_size
= 4;
8769 compunit
.cu_version
= byte_get (hdrptr
, 2);
8772 cu_offset
= start
- section_begin
;
8773 start
+= compunit
.cu_length
+ initial_length_size
;
8775 if (elf_header
.e_type
== ET_REL
8776 && !debug_apply_rela_addends (file
, section
, offset_size
,
8777 section_begin
, hdrptr
, start
))
8780 cu_abbrev_offset_ptr
= hdrptr
;
8781 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8782 hdrptr
+= offset_size
;
8784 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8786 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8787 && num_debug_info_entries
== 0)
8789 debug_information
[unit
].cu_offset
= cu_offset
;
8790 debug_information
[unit
].pointer_size
8791 = compunit
.cu_pointer_size
;
8792 debug_information
[unit
].base_address
= 0;
8793 debug_information
[unit
].loc_offsets
= NULL
;
8794 debug_information
[unit
].have_frame_base
= NULL
;
8795 debug_information
[unit
].max_loc_offsets
= 0;
8796 debug_information
[unit
].num_loc_offsets
= 0;
8797 debug_information
[unit
].range_lists
= NULL
;
8798 debug_information
[unit
].max_range_lists
= 0;
8799 debug_information
[unit
].num_range_lists
= 0;
8806 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
8807 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8808 printf (_(" Version: %d\n"), compunit
.cu_version
);
8809 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8810 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8813 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8815 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8821 /* Read in the abbrevs used by this compilation unit. */
8823 Elf_Internal_Shdr
*sec
;
8824 unsigned char *begin
;
8826 /* Locate the .debug_abbrev section and process it. */
8827 sec
= find_section (".debug_abbrev");
8830 warn (_("Unable to locate .debug_abbrev section!\n"));
8834 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8835 _("debug_abbrev section data"));
8839 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8840 begin
+ sec
->sh_size
);
8846 while (tags
< start
)
8848 unsigned int bytes_read
;
8849 unsigned long abbrev_number
;
8850 abbrev_entry
*entry
;
8853 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8856 /* A null DIE marks the end of a list of children. */
8857 if (abbrev_number
== 0)
8863 /* Scan through the abbreviation list until we reach the
8865 for (entry
= first_abbrev
;
8866 entry
&& entry
->entry
!= abbrev_number
;
8867 entry
= entry
->next
)
8872 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8878 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8880 (unsigned long) (tags
- section_begin
8883 get_TAG_name (entry
->tag
));
8888 need_base_address
= 0;
8890 case DW_TAG_compile_unit
:
8891 need_base_address
= 1;
8893 case DW_TAG_entry_point
:
8894 case DW_TAG_inlined_subroutine
:
8895 case DW_TAG_subprogram
:
8896 need_base_address
= 0;
8897 /* Assuming that there is no DW_AT_frame_base. */
8898 have_frame_base
= 0;
8902 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8903 tags
= read_and_display_attr (attr
->attribute
,
8906 compunit
.cu_pointer_size
,
8908 compunit
.cu_version
,
8909 &debug_information
[unit
],
8912 if (entry
->children
)
8917 /* Set num_debug_info_entries here so that it can be used to check if
8918 we need to process .debug_loc and .debug_ranges sections. */
8919 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8920 && num_debug_info_entries
== 0)
8921 num_debug_info_entries
= num_units
;
8925 free_debug_range ();
8935 /* Retrieve the pointer size associated with the given compilation unit.
8936 Optionally the offset of this unit into the .debug_info section is
8937 also retutned. If there is no .debug_info section then an error
8938 message is issued and 0 is returned. If the requested comp unit has
8939 not been defined in the .debug_info section then a warning message
8940 is issued and the last know pointer size is returned. This message
8941 is only issued once per section dumped per file dumped. */
8944 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8945 const char * section_name
,
8946 unsigned long * offset_return
)
8948 unsigned long offset
= 0;
8950 if (num_debug_info_entries
== 0)
8951 error (_("%s section needs a populated .debug_info section\n"),
8954 else if (comp_unit
>= num_debug_info_entries
)
8956 if (!warned_about_missing_comp_units
)
8958 warn (_("%s section has more comp units than .debug_info section\n"),
8960 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
8962 warned_about_missing_comp_units
= TRUE
;
8967 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
8968 offset
= debug_information
[comp_unit
].cu_offset
;
8971 if (offset_return
!= NULL
)
8972 * offset_return
= offset
;
8974 return last_pointer_size
;
8977 /* Locate and scan the .debug_info section in the file and record the pointer
8978 sizes and offsets for the compilation units in it. Usually an executable
8979 will have just one pointer size, but this is not guaranteed, and so we try
8980 not to make any assumptions. Returns zero upon failure, or the number of
8981 compilation units upon success. */
8984 get_debug_info (FILE * file
)
8986 Elf_Internal_Shdr
* section
;
8987 unsigned char * start
;
8990 /* Reset the last pointer size so that we can issue correct error
8991 messages if we are displaying the contents of more than one section. */
8992 last_pointer_size
= 0;
8993 warned_about_missing_comp_units
= FALSE
;
8995 /* If we already have the information there is nothing else to do. */
8996 if (num_debug_info_entries
> 0)
8997 return num_debug_info_entries
;
8999 section
= find_section (".debug_info");
9000 if (section
== NULL
)
9003 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9004 _("extracting information from .debug_info section"));
9008 ret
= process_debug_info (section
, start
, file
, 1);
9011 return ret
? num_debug_info_entries
: 0;
9015 display_debug_lines (Elf_Internal_Shdr
*section
,
9016 unsigned char *start
, FILE *file
)
9018 unsigned char *data
= start
;
9019 unsigned char *end
= start
+ section
->sh_size
;
9020 unsigned int comp_unit
= 0;
9022 printf (_("\nDump of debug contents of section %s:\n\n"),
9023 SECTION_NAME (section
));
9025 get_debug_info (file
);
9029 DWARF2_Internal_LineInfo info
;
9030 unsigned char *standard_opcodes
;
9031 unsigned char *end_of_sequence
;
9032 unsigned char *hdrptr
;
9033 unsigned int pointer_size
;
9034 int initial_length_size
;
9040 /* Check the length of the block. */
9041 info
.li_length
= byte_get (hdrptr
, 4);
9044 if (info
.li_length
== 0xffffffff)
9046 /* This section is 64-bit DWARF 3. */
9047 info
.li_length
= byte_get (hdrptr
, 8);
9050 initial_length_size
= 12;
9055 initial_length_size
= 4;
9058 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9061 (_("The line info appears to be corrupt - the section is too small\n"));
9065 /* Check its version number. */
9066 info
.li_version
= byte_get (hdrptr
, 2);
9068 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9070 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9074 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9075 hdrptr
+= offset_size
;
9076 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9078 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9080 info
.li_line_base
= byte_get (hdrptr
, 1);
9082 info
.li_line_range
= byte_get (hdrptr
, 1);
9084 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9087 /* Sign extend the line base field. */
9088 info
.li_line_base
<<= 24;
9089 info
.li_line_base
>>= 24;
9091 /* Get the pointer size from the comp unit associated
9092 with this block of line number information. */
9093 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9094 (comp_unit
, ".debug_line", NULL
);
9097 printf (_(" Length: %ld\n"), info
.li_length
);
9098 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9099 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9100 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9101 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9102 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9103 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9104 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9105 printf (_(" (Pointer size: %u)%s\n"),
9107 warned_about_missing_comp_units
? " [assumed]" : "" );
9109 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9111 reset_state_machine (info
.li_default_is_stmt
);
9113 /* Display the contents of the Opcodes table. */
9114 standard_opcodes
= hdrptr
;
9116 printf (_("\n Opcodes:\n"));
9118 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9119 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9121 /* Display the contents of the Directory table. */
9122 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9125 printf (_("\n The Directory Table is empty.\n"));
9128 printf (_("\n The Directory Table:\n"));
9132 printf (_(" %s\n"), data
);
9134 data
+= strlen ((char *) data
) + 1;
9138 /* Skip the NUL at the end of the table. */
9141 /* Display the contents of the File Name table. */
9143 printf (_("\n The File Name Table is empty.\n"));
9146 printf (_("\n The File Name Table:\n"));
9147 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9151 unsigned char *name
;
9152 unsigned int bytes_read
;
9154 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9157 data
+= strlen ((char *) data
) + 1;
9159 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9161 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9163 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9165 printf (_("%s\n"), name
);
9169 /* Skip the NUL at the end of the table. */
9172 /* Now display the statements. */
9173 printf (_("\n Line Number Statements:\n"));
9175 while (data
< end_of_sequence
)
9177 unsigned char op_code
;
9179 unsigned int bytes_read
;
9183 if (op_code
>= info
.li_opcode_base
)
9185 op_code
-= info
.li_opcode_base
;
9186 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9187 state_machine_regs
.address
+= adv
;
9188 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9189 op_code
, adv
, state_machine_regs
.address
);
9190 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9191 state_machine_regs
.line
+= adv
;
9192 printf (_(" and Line by %d to %d\n"),
9193 adv
, state_machine_regs
.line
);
9195 else switch (op_code
)
9197 case DW_LNS_extended_op
:
9198 if (pointer_size
== 0)
9200 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9204 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9209 printf (_(" Copy\n"));
9212 case DW_LNS_advance_pc
:
9213 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9215 state_machine_regs
.address
+= adv
;
9216 printf (_(" Advance PC by %d to %lx\n"), adv
,
9217 state_machine_regs
.address
);
9220 case DW_LNS_advance_line
:
9221 adv
= read_leb128 (data
, & bytes_read
, 1);
9223 state_machine_regs
.line
+= adv
;
9224 printf (_(" Advance Line by %d to %d\n"), adv
,
9225 state_machine_regs
.line
);
9228 case DW_LNS_set_file
:
9229 adv
= read_leb128 (data
, & bytes_read
, 0);
9231 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9233 state_machine_regs
.file
= adv
;
9236 case DW_LNS_set_column
:
9237 adv
= read_leb128 (data
, & bytes_read
, 0);
9239 printf (_(" Set column to %d\n"), adv
);
9240 state_machine_regs
.column
= adv
;
9243 case DW_LNS_negate_stmt
:
9244 adv
= state_machine_regs
.is_stmt
;
9246 printf (_(" Set is_stmt to %d\n"), adv
);
9247 state_machine_regs
.is_stmt
= adv
;
9250 case DW_LNS_set_basic_block
:
9251 printf (_(" Set basic block\n"));
9252 state_machine_regs
.basic_block
= 1;
9255 case DW_LNS_const_add_pc
:
9256 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9257 * info
.li_min_insn_length
);
9258 state_machine_regs
.address
+= adv
;
9259 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9260 state_machine_regs
.address
);
9263 case DW_LNS_fixed_advance_pc
:
9264 adv
= byte_get (data
, 2);
9266 state_machine_regs
.address
+= adv
;
9267 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9268 adv
, state_machine_regs
.address
);
9271 case DW_LNS_set_prologue_end
:
9272 printf (_(" Set prologue_end to true\n"));
9275 case DW_LNS_set_epilogue_begin
:
9276 printf (_(" Set epilogue_begin to true\n"));
9279 case DW_LNS_set_isa
:
9280 adv
= read_leb128 (data
, & bytes_read
, 0);
9282 printf (_(" Set ISA to %d\n"), adv
);
9286 printf (_(" Unknown opcode %d with operands: "), op_code
);
9288 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9290 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9291 i
== 1 ? "" : ", ");
9305 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9306 unsigned char *start
,
9307 FILE *file ATTRIBUTE_UNUSED
)
9309 DWARF2_Internal_PubNames pubnames
;
9312 end
= start
+ section
->sh_size
;
9314 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9318 unsigned char *data
;
9319 unsigned long offset
;
9320 int offset_size
, initial_length_size
;
9324 pubnames
.pn_length
= byte_get (data
, 4);
9326 if (pubnames
.pn_length
== 0xffffffff)
9328 pubnames
.pn_length
= byte_get (data
, 8);
9331 initial_length_size
= 12;
9336 initial_length_size
= 4;
9339 pubnames
.pn_version
= byte_get (data
, 2);
9341 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9342 data
+= offset_size
;
9343 pubnames
.pn_size
= byte_get (data
, offset_size
);
9344 data
+= offset_size
;
9346 start
+= pubnames
.pn_length
+ initial_length_size
;
9348 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9350 static int warned
= 0;
9354 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9361 printf (_(" Length: %ld\n"),
9362 pubnames
.pn_length
);
9363 printf (_(" Version: %d\n"),
9364 pubnames
.pn_version
);
9365 printf (_(" Offset into .debug_info section: %ld\n"),
9366 pubnames
.pn_offset
);
9367 printf (_(" Size of area in .debug_info section: %ld\n"),
9370 printf (_("\n Offset\tName\n"));
9374 offset
= byte_get (data
, offset_size
);
9378 data
+= offset_size
;
9379 printf (" %-6ld\t\t%s\n", offset
, data
);
9380 data
+= strlen ((char *) data
) + 1;
9383 while (offset
!= 0);
9391 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9392 unsigned char *start
,
9393 FILE *file ATTRIBUTE_UNUSED
)
9395 unsigned char *end
= start
+ section
->sh_size
;
9396 unsigned char *curr
= start
;
9397 unsigned int bytes_read
;
9398 enum dwarf_macinfo_record_type op
;
9400 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9404 unsigned int lineno
;
9412 case DW_MACINFO_start_file
:
9414 unsigned int filenum
;
9416 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9418 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9421 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9426 case DW_MACINFO_end_file
:
9427 printf (_(" DW_MACINFO_end_file\n"));
9430 case DW_MACINFO_define
:
9431 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9433 string
= (char *) curr
;
9434 curr
+= strlen (string
) + 1;
9435 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9439 case DW_MACINFO_undef
:
9440 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9442 string
= (char *) curr
;
9443 curr
+= strlen (string
) + 1;
9444 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9448 case DW_MACINFO_vendor_ext
:
9450 unsigned int constant
;
9452 constant
= read_leb128 (curr
, & bytes_read
, 0);
9454 string
= (char *) curr
;
9455 curr
+= strlen (string
) + 1;
9456 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9468 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9469 unsigned char *start
,
9470 FILE *file ATTRIBUTE_UNUSED
)
9472 abbrev_entry
*entry
;
9473 unsigned char *end
= start
+ section
->sh_size
;
9475 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9479 start
= process_abbrev_section (start
, end
);
9481 if (first_abbrev
== NULL
)
9484 printf (_(" Number TAG\n"));
9486 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9490 printf (_(" %ld %s [%s]\n"),
9492 get_TAG_name (entry
->tag
),
9493 entry
->children
? _("has children") : _("no children"));
9495 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9496 printf (_(" %-18s %s\n"),
9497 get_AT_name (attr
->attribute
),
9498 get_FORM_name (attr
->form
));
9511 display_debug_loc (Elf_Internal_Shdr
*section
,
9512 unsigned char *start
, FILE *file
)
9514 unsigned char *section_end
;
9515 unsigned long bytes
;
9516 unsigned char *section_begin
= start
;
9517 unsigned int num_loc_list
= 0;
9518 unsigned long last_offset
= 0;
9519 unsigned int first
= 0;
9522 int seen_first_offset
= 0;
9523 int use_debug_info
= 1;
9524 unsigned char *next
;
9526 bytes
= section
->sh_size
;
9527 section_end
= start
+ bytes
;
9531 printf (_("\nThe .debug_loc section is empty.\n"));
9535 get_debug_info (file
);
9537 /* Check the order of location list in .debug_info section. If
9538 offsets of location lists are in the ascending order, we can
9539 use `debug_information' directly. */
9540 for (i
= 0; i
< num_debug_info_entries
; i
++)
9544 num
= debug_information
[i
].num_loc_offsets
;
9545 num_loc_list
+= num
;
9547 /* Check if we can use `debug_information' directly. */
9548 if (use_debug_info
&& num
!= 0)
9550 if (!seen_first_offset
)
9552 /* This is the first location list. */
9553 last_offset
= debug_information
[i
].loc_offsets
[0];
9555 seen_first_offset
= 1;
9561 for (; j
< num
; j
++)
9564 debug_information
[i
].loc_offsets
[j
])
9569 last_offset
= debug_information
[i
].loc_offsets
[j
];
9574 if (!use_debug_info
)
9575 /* FIXME: Should we handle this case? */
9576 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9578 if (!seen_first_offset
)
9579 error (_("No location lists in .debug_info section!\n"));
9581 if (debug_information
[first
].loc_offsets
[0] != 0)
9582 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9583 debug_information
[first
].loc_offsets
[0]);
9585 printf (_("Contents of the .debug_loc section:\n\n"));
9586 printf (_(" Offset Begin End Expression\n"));
9588 seen_first_offset
= 0;
9589 for (i
= first
; i
< num_debug_info_entries
; i
++)
9591 unsigned long begin
;
9593 unsigned short length
;
9594 unsigned long offset
;
9595 unsigned int pointer_size
;
9596 unsigned long cu_offset
;
9597 unsigned long base_address
;
9598 int need_frame_base
;
9601 pointer_size
= debug_information
[i
].pointer_size
;
9602 cu_offset
= debug_information
[i
].cu_offset
;
9604 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9606 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9607 offset
= debug_information
[i
].loc_offsets
[j
];
9608 next
= section_begin
+ offset
;
9609 base_address
= debug_information
[i
].base_address
;
9611 if (!seen_first_offset
)
9612 seen_first_offset
= 1;
9616 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9617 start
- section_begin
, next
- section_begin
);
9618 else if (start
> next
)
9619 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9620 start
- section_begin
, next
- section_begin
);
9626 begin
= byte_get (start
, pointer_size
);
9627 start
+= pointer_size
;
9628 end
= byte_get (start
, pointer_size
);
9629 start
+= pointer_size
;
9631 if (begin
== 0 && end
== 0)
9633 printf (_(" %8.8lx <End of list>\n"), offset
);
9637 /* Check base address specifiers. */
9638 if (begin
== -1UL && end
!= -1UL)
9641 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9642 offset
, begin
, end
);
9646 length
= byte_get (start
, 2);
9649 printf (" %8.8lx %8.8lx %8.8lx (",
9650 offset
, begin
+ base_address
, end
+ base_address
);
9651 need_frame_base
= decode_location_expression (start
,
9657 if (need_frame_base
&& !has_frame_base
)
9658 printf (_(" [without DW_AT_frame_base]"));
9661 fputs (_(" (start == end)"), stdout
);
9662 else if (begin
> end
)
9663 fputs (_(" (start > end)"), stdout
);
9675 display_debug_str (Elf_Internal_Shdr
*section
,
9676 unsigned char *start
,
9677 FILE *file ATTRIBUTE_UNUSED
)
9679 unsigned long bytes
;
9682 addr
= section
->sh_addr
;
9683 bytes
= section
->sh_size
;
9687 printf (_("\nThe .debug_str section is empty.\n"));
9691 printf (_("Contents of the .debug_str section:\n\n"));
9699 lbytes
= (bytes
> 16 ? 16 : bytes
);
9701 printf (" 0x%8.8lx ", (unsigned long) addr
);
9703 for (j
= 0; j
< 16; j
++)
9706 printf ("%2.2x", start
[j
]);
9714 for (j
= 0; j
< lbytes
; j
++)
9717 if (k
>= ' ' && k
< 0x80)
9737 display_debug_info (Elf_Internal_Shdr
* section
,
9738 unsigned char * start
, FILE * file
)
9740 return process_debug_info (section
, start
, file
, 0);
9745 display_debug_aranges (Elf_Internal_Shdr
*section
,
9746 unsigned char *start
,
9747 FILE *file ATTRIBUTE_UNUSED
)
9749 unsigned char *end
= start
+ section
->sh_size
;
9751 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9755 unsigned char *hdrptr
;
9756 DWARF2_Internal_ARange arange
;
9757 unsigned char *ranges
;
9758 unsigned long length
;
9759 unsigned long address
;
9762 int initial_length_size
;
9766 arange
.ar_length
= byte_get (hdrptr
, 4);
9769 if (arange
.ar_length
== 0xffffffff)
9771 arange
.ar_length
= byte_get (hdrptr
, 8);
9774 initial_length_size
= 12;
9779 initial_length_size
= 4;
9782 arange
.ar_version
= byte_get (hdrptr
, 2);
9785 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9786 hdrptr
+= offset_size
;
9788 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9791 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9794 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9796 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9800 printf (_(" Length: %ld\n"), arange
.ar_length
);
9801 printf (_(" Version: %d\n"), arange
.ar_version
);
9802 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9803 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9804 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9806 printf (_("\n Address Length\n"));
9810 /* Must pad to an alignment boundary that is twice the pointer size. */
9811 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9813 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9817 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9819 ranges
+= arange
.ar_pointer_size
;
9821 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9823 ranges
+= arange
.ar_pointer_size
;
9825 /* A pair of zeros marks the end of the list. */
9826 if (address
== 0 && length
== 0)
9829 printf (" %8.8lx %lu\n", address
, length
);
9832 start
+= arange
.ar_length
+ initial_length_size
;
9841 display_debug_ranges (Elf_Internal_Shdr
*section
,
9842 unsigned char *start
,
9843 FILE *file ATTRIBUTE_UNUSED
)
9845 unsigned char *section_end
;
9846 unsigned long bytes
;
9847 unsigned char *section_begin
= start
;
9848 unsigned int num_range_list
= 0;
9849 unsigned long last_offset
= 0;
9850 unsigned int first
= 0;
9853 int seen_first_offset
= 0;
9854 int use_debug_info
= 1;
9855 unsigned char *next
;
9857 bytes
= section
->sh_size
;
9858 section_end
= start
+ bytes
;
9862 printf (_("\nThe .debug_ranges section is empty.\n"));
9866 get_debug_info (file
);
9868 /* Check the order of range list in .debug_info section. If
9869 offsets of range lists are in the ascending order, we can
9870 use `debug_information' directly. */
9871 for (i
= 0; i
< num_debug_info_entries
; i
++)
9875 num
= debug_information
[i
].num_range_lists
;
9876 num_range_list
+= num
;
9878 /* Check if we can use `debug_information' directly. */
9879 if (use_debug_info
&& num
!= 0)
9881 if (!seen_first_offset
)
9883 /* This is the first range list. */
9884 last_offset
= debug_information
[i
].range_lists
[0];
9886 seen_first_offset
= 1;
9892 for (; j
< num
; j
++)
9895 debug_information
[i
].range_lists
[j
])
9900 last_offset
= debug_information
[i
].range_lists
[j
];
9905 if (!use_debug_info
)
9906 /* FIXME: Should we handle this case? */
9907 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9909 if (!seen_first_offset
)
9910 error (_("No range lists in .debug_info section!\n"));
9912 if (debug_information
[first
].range_lists
[0] != 0)
9913 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9914 debug_information
[first
].range_lists
[0]);
9916 printf (_("Contents of the .debug_ranges section:\n\n"));
9917 printf (_(" Offset Begin End\n"));
9919 seen_first_offset
= 0;
9920 for (i
= first
; i
< num_debug_info_entries
; i
++)
9922 unsigned long begin
;
9924 unsigned long offset
;
9925 unsigned int pointer_size
;
9926 unsigned long base_address
;
9928 pointer_size
= debug_information
[i
].pointer_size
;
9930 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9932 offset
= debug_information
[i
].range_lists
[j
];
9933 next
= section_begin
+ offset
;
9934 base_address
= debug_information
[i
].base_address
;
9936 if (!seen_first_offset
)
9937 seen_first_offset
= 1;
9941 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9942 start
- section_begin
, next
- section_begin
);
9943 else if (start
> next
)
9944 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9945 start
- section_begin
, next
- section_begin
);
9951 begin
= byte_get (start
, pointer_size
);
9952 start
+= pointer_size
;
9953 end
= byte_get (start
, pointer_size
);
9954 start
+= pointer_size
;
9956 if (begin
== 0 && end
== 0)
9958 printf (_(" %8.8lx <End of list>\n"), offset
);
9962 /* Check base address specifiers. */
9963 if (begin
== -1UL && end
!= -1UL)
9966 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9967 offset
, begin
, end
);
9971 printf (" %8.8lx %8.8lx %8.8lx",
9972 offset
, begin
+ base_address
, end
+ base_address
);
9975 fputs (_(" (start == end)"), stdout
);
9976 else if (begin
> end
)
9977 fputs (_(" (start > end)"), stdout
);
9987 typedef struct Frame_Chunk
9989 struct Frame_Chunk
*next
;
9990 unsigned char *chunk_start
;
9992 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9993 short int *col_type
;
9996 unsigned int code_factor
;
9998 unsigned long pc_begin
;
9999 unsigned long pc_range
;
10003 unsigned char fde_encoding
;
10004 unsigned char cfa_exp
;
10008 /* A marker for a col_type that means this column was never referenced
10009 in the frame info. */
10010 #define DW_CFA_unreferenced (-1)
10013 frame_need_space (Frame_Chunk
*fc
, int reg
)
10015 int prev
= fc
->ncols
;
10017 if (reg
< fc
->ncols
)
10020 fc
->ncols
= reg
+ 1;
10021 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
10022 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
10024 while (prev
< fc
->ncols
)
10026 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10027 fc
->col_offset
[prev
] = 0;
10033 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10038 if (*max_regs
< fc
->ncols
)
10039 *max_regs
= fc
->ncols
;
10041 if (*need_col_headers
)
10043 *need_col_headers
= 0;
10045 printf (" LOC CFA ");
10047 for (r
= 0; r
< *max_regs
; r
++)
10048 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10053 printf ("r%-4d", r
);
10059 printf ("%08lx ", fc
->pc_begin
);
10061 strcpy (tmp
, "exp");
10063 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10064 printf ("%-8s ", tmp
);
10066 for (r
= 0; r
< fc
->ncols
; r
++)
10068 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10070 switch (fc
->col_type
[r
])
10072 case DW_CFA_undefined
:
10075 case DW_CFA_same_value
:
10078 case DW_CFA_offset
:
10079 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10081 case DW_CFA_register
:
10082 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10084 case DW_CFA_expression
:
10085 strcpy (tmp
, "exp");
10088 strcpy (tmp
, "n/a");
10091 printf ("%-5s", tmp
);
10098 size_of_encoded_value (int encoding
)
10100 switch (encoding
& 0x7)
10103 case 0: return eh_addr_size
;
10111 get_encoded_value (unsigned char *data
, int encoding
)
10113 int size
= size_of_encoded_value (encoding
);
10114 if (encoding
& DW_EH_PE_signed
)
10115 return byte_get_signed (data
, size
);
10117 return byte_get (data
, size
);
10120 #define GET(N) byte_get (start, N); start += N
10121 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10122 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10125 display_debug_frames (Elf_Internal_Shdr
*section
,
10126 unsigned char *start
,
10127 FILE *file ATTRIBUTE_UNUSED
)
10129 unsigned char *end
= start
+ section
->sh_size
;
10130 unsigned char *section_start
= start
;
10131 Frame_Chunk
*chunks
= 0;
10132 Frame_Chunk
*remembered_state
= 0;
10134 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10135 unsigned int length_return
;
10138 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10140 while (start
< end
)
10142 unsigned char *saved_start
;
10143 unsigned char *block_end
;
10144 unsigned long length
;
10145 unsigned long cie_id
;
10148 int need_col_headers
= 1;
10149 unsigned char *augmentation_data
= NULL
;
10150 unsigned long augmentation_data_len
= 0;
10151 int encoded_ptr_size
= eh_addr_size
;
10153 int initial_length_size
;
10155 saved_start
= start
;
10156 length
= byte_get (start
, 4); start
+= 4;
10160 printf ("\n%08lx ZERO terminator\n\n",
10161 (unsigned long)(saved_start
- section_start
));
10165 if (length
== 0xffffffff)
10167 length
= byte_get (start
, 8);
10170 initial_length_size
= 12;
10175 initial_length_size
= 4;
10178 block_end
= saved_start
+ length
+ initial_length_size
;
10179 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10181 if (elf_header
.e_type
== ET_REL
10182 && !debug_apply_rela_addends (file
, section
, offset_size
,
10183 section_start
, start
, block_end
))
10186 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10190 fc
= xmalloc (sizeof (Frame_Chunk
));
10191 memset (fc
, 0, sizeof (Frame_Chunk
));
10195 fc
->chunk_start
= saved_start
;
10197 fc
->col_type
= xmalloc (sizeof (short int));
10198 fc
->col_offset
= xmalloc (sizeof (int));
10199 frame_need_space (fc
, max_regs
-1);
10201 version
= *start
++;
10203 fc
->augmentation
= (char *) start
;
10204 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10206 if (fc
->augmentation
[0] == 'z')
10208 fc
->code_factor
= LEB ();
10209 fc
->data_factor
= SLEB ();
10218 augmentation_data_len
= LEB ();
10219 augmentation_data
= start
;
10220 start
+= augmentation_data_len
;
10222 else if (streq (fc
->augmentation
, "eh"))
10224 start
+= eh_addr_size
;
10225 fc
->code_factor
= LEB ();
10226 fc
->data_factor
= SLEB ();
10238 fc
->code_factor
= LEB ();
10239 fc
->data_factor
= SLEB ();
10251 if (do_debug_frames_interp
)
10252 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10253 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10254 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10258 printf ("\n%08lx %08lx %08lx CIE\n",
10259 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10260 printf (" Version: %d\n", version
);
10261 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10262 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10263 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10264 printf (" Return address column: %d\n", fc
->ra
);
10266 if (augmentation_data_len
)
10269 printf (" Augmentation data: ");
10270 for (i
= 0; i
< augmentation_data_len
; ++i
)
10271 printf (" %02x", augmentation_data
[i
]);
10277 if (augmentation_data_len
)
10279 unsigned char *p
, *q
;
10280 p
= (unsigned char *) fc
->augmentation
+ 1;
10281 q
= augmentation_data
;
10287 else if (*p
== 'P')
10288 q
+= 1 + size_of_encoded_value (*q
);
10289 else if (*p
== 'R')
10290 fc
->fde_encoding
= *q
++;
10296 if (fc
->fde_encoding
)
10297 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10300 frame_need_space (fc
, fc
->ra
);
10304 unsigned char *look_for
;
10305 static Frame_Chunk fde_fc
;
10308 memset (fc
, 0, sizeof (Frame_Chunk
));
10310 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10312 for (cie
= chunks
; cie
; cie
= cie
->next
)
10313 if (cie
->chunk_start
== look_for
)
10318 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10319 cie_id
, saved_start
);
10322 fc
->col_type
= xmalloc (sizeof (short int));
10323 fc
->col_offset
= xmalloc (sizeof (int));
10324 frame_need_space (fc
, max_regs
- 1);
10326 fc
->augmentation
= "";
10327 fc
->fde_encoding
= 0;
10331 fc
->ncols
= cie
->ncols
;
10332 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10333 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10334 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10335 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10336 fc
->augmentation
= cie
->augmentation
;
10337 fc
->code_factor
= cie
->code_factor
;
10338 fc
->data_factor
= cie
->data_factor
;
10339 fc
->cfa_reg
= cie
->cfa_reg
;
10340 fc
->cfa_offset
= cie
->cfa_offset
;
10342 frame_need_space (fc
, max_regs
-1);
10343 fc
->fde_encoding
= cie
->fde_encoding
;
10346 if (fc
->fde_encoding
)
10347 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10349 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10350 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10351 /* Don't adjust for ET_REL since there's invariably a pcrel
10352 reloc here, which we haven't applied. */
10353 && elf_header
.e_type
!= ET_REL
)
10354 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10355 start
+= encoded_ptr_size
;
10356 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10357 start
+= encoded_ptr_size
;
10359 if (cie
->augmentation
[0] == 'z')
10361 augmentation_data_len
= LEB ();
10362 augmentation_data
= start
;
10363 start
+= augmentation_data_len
;
10366 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10367 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10368 (unsigned long)(cie
->chunk_start
- section_start
),
10369 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10370 if (! do_debug_frames_interp
&& augmentation_data_len
)
10374 printf (" Augmentation data: ");
10375 for (i
= 0; i
< augmentation_data_len
; ++i
)
10376 printf (" %02x", augmentation_data
[i
]);
10382 /* At this point, fc is the current chunk, cie (if any) is set, and
10383 we're about to interpret instructions for the chunk. */
10384 /* ??? At present we need to do this always, since this sizes the
10385 fc->col_type and fc->col_offset arrays, which we write into always.
10386 We should probably split the interpreted and non-interpreted bits
10387 into two different routines, since there's so much that doesn't
10388 really overlap between them. */
10389 if (1 || do_debug_frames_interp
)
10391 /* Start by making a pass over the chunk, allocating storage
10392 and taking note of what registers are used. */
10393 unsigned char *tmp
= start
;
10395 while (start
< block_end
)
10398 unsigned long reg
, tmp
;
10405 /* Warning: if you add any more cases to this switch, be
10406 sure to add them to the corresponding switch below. */
10409 case DW_CFA_advance_loc
:
10411 case DW_CFA_offset
:
10413 frame_need_space (fc
, opa
);
10414 fc
->col_type
[opa
] = DW_CFA_undefined
;
10416 case DW_CFA_restore
:
10417 frame_need_space (fc
, opa
);
10418 fc
->col_type
[opa
] = DW_CFA_undefined
;
10420 case DW_CFA_set_loc
:
10421 start
+= encoded_ptr_size
;
10423 case DW_CFA_advance_loc1
:
10426 case DW_CFA_advance_loc2
:
10429 case DW_CFA_advance_loc4
:
10432 case DW_CFA_offset_extended
:
10433 reg
= LEB (); LEB ();
10434 frame_need_space (fc
, reg
);
10435 fc
->col_type
[reg
] = DW_CFA_undefined
;
10437 case DW_CFA_restore_extended
:
10439 frame_need_space (fc
, reg
);
10440 fc
->col_type
[reg
] = DW_CFA_undefined
;
10442 case DW_CFA_undefined
:
10444 frame_need_space (fc
, reg
);
10445 fc
->col_type
[reg
] = DW_CFA_undefined
;
10447 case DW_CFA_same_value
:
10449 frame_need_space (fc
, reg
);
10450 fc
->col_type
[reg
] = DW_CFA_undefined
;
10452 case DW_CFA_register
:
10453 reg
= LEB (); LEB ();
10454 frame_need_space (fc
, reg
);
10455 fc
->col_type
[reg
] = DW_CFA_undefined
;
10457 case DW_CFA_def_cfa
:
10460 case DW_CFA_def_cfa_register
:
10463 case DW_CFA_def_cfa_offset
:
10466 case DW_CFA_def_cfa_expression
:
10470 case DW_CFA_expression
:
10474 frame_need_space (fc
, reg
);
10475 fc
->col_type
[reg
] = DW_CFA_undefined
;
10477 case DW_CFA_offset_extended_sf
:
10478 reg
= LEB (); SLEB ();
10479 frame_need_space (fc
, reg
);
10480 fc
->col_type
[reg
] = DW_CFA_undefined
;
10482 case DW_CFA_def_cfa_sf
:
10485 case DW_CFA_def_cfa_offset_sf
:
10488 case DW_CFA_MIPS_advance_loc8
:
10491 case DW_CFA_GNU_args_size
:
10494 case DW_CFA_GNU_negative_offset_extended
:
10495 reg
= LEB (); LEB ();
10496 frame_need_space (fc
, reg
);
10497 fc
->col_type
[reg
] = DW_CFA_undefined
;
10506 /* Now we know what registers are used, make a second pass over
10507 the chunk, this time actually printing out the info. */
10509 while (start
< block_end
)
10512 unsigned long ul
, reg
, roffs
;
10521 /* Warning: if you add any more cases to this switch, be
10522 sure to add them to the corresponding switch above. */
10525 case DW_CFA_advance_loc
:
10526 if (do_debug_frames_interp
)
10527 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10529 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10530 opa
* fc
->code_factor
,
10531 fc
->pc_begin
+ opa
* fc
->code_factor
);
10532 fc
->pc_begin
+= opa
* fc
->code_factor
;
10535 case DW_CFA_offset
:
10537 if (! do_debug_frames_interp
)
10538 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10539 opa
, roffs
* fc
->data_factor
);
10540 fc
->col_type
[opa
] = DW_CFA_offset
;
10541 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10544 case DW_CFA_restore
:
10545 if (! do_debug_frames_interp
)
10546 printf (" DW_CFA_restore: r%d\n", opa
);
10547 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10548 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10551 case DW_CFA_set_loc
:
10552 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10553 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10554 && elf_header
.e_type
!= ET_REL
)
10555 vma
+= section
->sh_addr
+ (start
- section_start
);
10556 start
+= encoded_ptr_size
;
10557 if (do_debug_frames_interp
)
10558 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10560 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10561 fc
->pc_begin
= vma
;
10564 case DW_CFA_advance_loc1
:
10565 ofs
= byte_get (start
, 1); start
+= 1;
10566 if (do_debug_frames_interp
)
10567 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10569 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10570 ofs
* fc
->code_factor
,
10571 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10572 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10575 case DW_CFA_advance_loc2
:
10576 ofs
= byte_get (start
, 2); start
+= 2;
10577 if (do_debug_frames_interp
)
10578 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10580 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10581 ofs
* fc
->code_factor
,
10582 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10583 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10586 case DW_CFA_advance_loc4
:
10587 ofs
= byte_get (start
, 4); start
+= 4;
10588 if (do_debug_frames_interp
)
10589 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10591 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10592 ofs
* fc
->code_factor
,
10593 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10594 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10597 case DW_CFA_offset_extended
:
10600 if (! do_debug_frames_interp
)
10601 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10602 reg
, roffs
* fc
->data_factor
);
10603 fc
->col_type
[reg
] = DW_CFA_offset
;
10604 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10607 case DW_CFA_restore_extended
:
10609 if (! do_debug_frames_interp
)
10610 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10611 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10612 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10615 case DW_CFA_undefined
:
10617 if (! do_debug_frames_interp
)
10618 printf (" DW_CFA_undefined: r%ld\n", reg
);
10619 fc
->col_type
[reg
] = DW_CFA_undefined
;
10620 fc
->col_offset
[reg
] = 0;
10623 case DW_CFA_same_value
:
10625 if (! do_debug_frames_interp
)
10626 printf (" DW_CFA_same_value: r%ld\n", reg
);
10627 fc
->col_type
[reg
] = DW_CFA_same_value
;
10628 fc
->col_offset
[reg
] = 0;
10631 case DW_CFA_register
:
10634 if (! do_debug_frames_interp
)
10635 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10636 fc
->col_type
[reg
] = DW_CFA_register
;
10637 fc
->col_offset
[reg
] = roffs
;
10640 case DW_CFA_remember_state
:
10641 if (! do_debug_frames_interp
)
10642 printf (" DW_CFA_remember_state\n");
10643 rs
= xmalloc (sizeof (Frame_Chunk
));
10644 rs
->ncols
= fc
->ncols
;
10645 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10646 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10647 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10648 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10649 rs
->next
= remembered_state
;
10650 remembered_state
= rs
;
10653 case DW_CFA_restore_state
:
10654 if (! do_debug_frames_interp
)
10655 printf (" DW_CFA_restore_state\n");
10656 rs
= remembered_state
;
10659 remembered_state
= rs
->next
;
10660 frame_need_space (fc
, rs
->ncols
-1);
10661 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10662 memcpy (fc
->col_offset
, rs
->col_offset
,
10663 rs
->ncols
* sizeof (int));
10664 free (rs
->col_type
);
10665 free (rs
->col_offset
);
10668 else if (do_debug_frames_interp
)
10669 printf ("Mismatched DW_CFA_restore_state\n");
10672 case DW_CFA_def_cfa
:
10673 fc
->cfa_reg
= LEB ();
10674 fc
->cfa_offset
= LEB ();
10676 if (! do_debug_frames_interp
)
10677 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10678 fc
->cfa_reg
, fc
->cfa_offset
);
10681 case DW_CFA_def_cfa_register
:
10682 fc
->cfa_reg
= LEB ();
10684 if (! do_debug_frames_interp
)
10685 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10688 case DW_CFA_def_cfa_offset
:
10689 fc
->cfa_offset
= LEB ();
10690 if (! do_debug_frames_interp
)
10691 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10695 if (! do_debug_frames_interp
)
10696 printf (" DW_CFA_nop\n");
10699 case DW_CFA_def_cfa_expression
:
10701 if (! do_debug_frames_interp
)
10703 printf (" DW_CFA_def_cfa_expression (");
10704 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10711 case DW_CFA_expression
:
10714 if (! do_debug_frames_interp
)
10716 printf (" DW_CFA_expression: r%ld (", reg
);
10717 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10720 fc
->col_type
[reg
] = DW_CFA_expression
;
10724 case DW_CFA_offset_extended_sf
:
10727 frame_need_space (fc
, reg
);
10728 if (! do_debug_frames_interp
)
10729 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10730 reg
, l
* fc
->data_factor
);
10731 fc
->col_type
[reg
] = DW_CFA_offset
;
10732 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10735 case DW_CFA_def_cfa_sf
:
10736 fc
->cfa_reg
= LEB ();
10737 fc
->cfa_offset
= SLEB ();
10738 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10740 if (! do_debug_frames_interp
)
10741 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10742 fc
->cfa_reg
, fc
->cfa_offset
);
10745 case DW_CFA_def_cfa_offset_sf
:
10746 fc
->cfa_offset
= SLEB ();
10747 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10748 if (! do_debug_frames_interp
)
10749 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10752 case DW_CFA_MIPS_advance_loc8
:
10753 ofs
= byte_get (start
, 8); start
+= 8;
10754 if (do_debug_frames_interp
)
10755 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10757 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10758 ofs
* fc
->code_factor
,
10759 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10760 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10763 case DW_CFA_GNU_window_save
:
10764 if (! do_debug_frames_interp
)
10765 printf (" DW_CFA_GNU_window_save\n");
10768 case DW_CFA_GNU_args_size
:
10770 if (! do_debug_frames_interp
)
10771 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10774 case DW_CFA_GNU_negative_offset_extended
:
10777 frame_need_space (fc
, reg
);
10778 if (! do_debug_frames_interp
)
10779 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10780 reg
, l
* fc
->data_factor
);
10781 fc
->col_type
[reg
] = DW_CFA_offset
;
10782 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10786 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10791 if (do_debug_frames_interp
)
10792 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10807 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10808 unsigned char *start ATTRIBUTE_UNUSED
,
10809 FILE *file ATTRIBUTE_UNUSED
)
10811 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10812 SECTION_NAME (section
));
10817 /* A structure containing the name of a debug section
10818 and a pointer to a function that can decode it. */
10821 const char *const name
;
10822 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10826 { ".debug_abbrev", display_debug_abbrev
},
10827 { ".debug_aranges", display_debug_aranges
},
10828 { ".debug_frame", display_debug_frames
},
10829 { ".debug_info", display_debug_info
},
10830 { ".debug_line", display_debug_lines
},
10831 { ".debug_pubnames", display_debug_pubnames
},
10832 { ".eh_frame", display_debug_frames
},
10833 { ".debug_macinfo", display_debug_macinfo
},
10834 { ".debug_str", display_debug_str
},
10835 { ".debug_loc", display_debug_loc
},
10836 { ".debug_pubtypes", display_debug_pubnames
},
10837 { ".debug_ranges", display_debug_ranges
},
10838 { ".debug_static_func", display_debug_not_supported
},
10839 { ".debug_static_vars", display_debug_not_supported
},
10840 { ".debug_types", display_debug_not_supported
},
10841 { ".debug_weaknames", display_debug_not_supported
}
10845 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10847 char *name
= SECTION_NAME (section
);
10848 bfd_size_type length
;
10852 length
= section
->sh_size
;
10855 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10859 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10860 name
= ".debug_info";
10862 /* See if we know how to display the contents of this section. */
10863 for (i
= NUM_ELEM (debug_displays
); i
--;)
10864 if (streq (debug_displays
[i
].name
, name
))
10866 unsigned char *start
;
10868 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10869 _("debug section data"));
10876 result
&= debug_displays
[i
].display (section
, start
, file
);
10879 /* If we loaded in the abbrev section
10880 at some point, we must release it here. */
10888 printf (_("Unrecognized debug section: %s\n"), name
);
10896 process_section_contents (FILE *file
)
10898 Elf_Internal_Shdr
*section
;
10904 for (i
= 0, section
= section_headers
;
10905 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10908 #ifdef SUPPORT_DISASSEMBLY
10909 if (dump_sects
[i
] & DISASS_DUMP
)
10910 disassemble_section (section
, file
);
10912 if (dump_sects
[i
] & HEX_DUMP
)
10913 dump_section (section
, file
);
10915 if (dump_sects
[i
] & DEBUG_DUMP
)
10916 display_debug_section (section
, file
);
10919 /* Check to see if the user requested a
10920 dump of a section that does not exist. */
10921 while (i
++ < num_dump_sects
)
10923 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10927 process_mips_fpe_exception (int mask
)
10932 if (mask
& OEX_FPU_INEX
)
10933 fputs ("INEX", stdout
), first
= 0;
10934 if (mask
& OEX_FPU_UFLO
)
10935 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10936 if (mask
& OEX_FPU_OFLO
)
10937 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10938 if (mask
& OEX_FPU_DIV0
)
10939 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10940 if (mask
& OEX_FPU_INVAL
)
10941 printf ("%sINVAL", first
? "" : "|");
10944 fputs ("0", stdout
);
10948 process_mips_specific (FILE *file
)
10950 Elf_Internal_Dyn
*entry
;
10951 size_t liblist_offset
= 0;
10952 size_t liblistno
= 0;
10953 size_t conflictsno
= 0;
10954 size_t options_offset
= 0;
10955 size_t conflicts_offset
= 0;
10957 /* We have a lot of special sections. Thanks SGI! */
10958 if (dynamic_section
== NULL
)
10959 /* No information available. */
10962 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10963 switch (entry
->d_tag
)
10965 case DT_MIPS_LIBLIST
:
10967 = offset_from_vma (file
, entry
->d_un
.d_val
,
10968 liblistno
* sizeof (Elf32_External_Lib
));
10970 case DT_MIPS_LIBLISTNO
:
10971 liblistno
= entry
->d_un
.d_val
;
10973 case DT_MIPS_OPTIONS
:
10974 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10976 case DT_MIPS_CONFLICT
:
10978 = offset_from_vma (file
, entry
->d_un
.d_val
,
10979 conflictsno
* sizeof (Elf32_External_Conflict
));
10981 case DT_MIPS_CONFLICTNO
:
10982 conflictsno
= entry
->d_un
.d_val
;
10988 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10990 Elf32_External_Lib
*elib
;
10993 elib
= get_data (NULL
, file
, liblist_offset
,
10994 liblistno
* sizeof (Elf32_External_Lib
),
10998 printf ("\nSection '.liblist' contains %lu entries:\n",
10999 (unsigned long) liblistno
);
11000 fputs (" Library Time Stamp Checksum Version Flags\n",
11003 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11010 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11011 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11012 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11013 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11014 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11016 tmp
= gmtime (&time
);
11017 snprintf (timebuf
, sizeof (timebuf
),
11018 "%04u-%02u-%02uT%02u:%02u:%02u",
11019 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11020 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11022 printf ("%3lu: ", (unsigned long) cnt
);
11023 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11024 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11026 printf ("<corrupt: %9ld>", liblist
.l_name
);
11027 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11028 liblist
.l_version
);
11030 if (liblist
.l_flags
== 0)
11034 static const struct
11041 { " EXACT_MATCH", LL_EXACT_MATCH
},
11042 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11043 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11044 { " EXPORTS", LL_EXPORTS
},
11045 { " DELAY_LOAD", LL_DELAY_LOAD
},
11046 { " DELTA", LL_DELTA
}
11048 int flags
= liblist
.l_flags
;
11052 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11054 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11056 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11057 flags
^= l_flags_vals
[fcnt
].bit
;
11060 printf (" %#x", (unsigned int) flags
);
11070 if (options_offset
!= 0)
11072 Elf_External_Options
*eopt
;
11073 Elf_Internal_Shdr
*sect
= section_headers
;
11074 Elf_Internal_Options
*iopt
;
11075 Elf_Internal_Options
*option
;
11079 /* Find the section header so that we get the size. */
11080 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11083 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
11087 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
11090 error (_("Out of memory"));
11097 while (offset
< sect
->sh_size
)
11099 Elf_External_Options
*eoption
;
11101 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11103 option
->kind
= BYTE_GET (eoption
->kind
);
11104 option
->size
= BYTE_GET (eoption
->size
);
11105 option
->section
= BYTE_GET (eoption
->section
);
11106 option
->info
= BYTE_GET (eoption
->info
);
11108 offset
+= option
->size
;
11114 printf (_("\nSection '%s' contains %d entries:\n"),
11115 SECTION_NAME (sect
), cnt
);
11123 switch (option
->kind
)
11126 /* This shouldn't happen. */
11127 printf (" NULL %d %lx", option
->section
, option
->info
);
11130 printf (" REGINFO ");
11131 if (elf_header
.e_machine
== EM_MIPS
)
11134 Elf32_External_RegInfo
*ereg
;
11135 Elf32_RegInfo reginfo
;
11137 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11138 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11139 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11140 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11141 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11142 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11143 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11145 printf ("GPR %08lx GP 0x%lx\n",
11146 reginfo
.ri_gprmask
,
11147 (unsigned long) reginfo
.ri_gp_value
);
11148 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11149 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11150 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11155 Elf64_External_RegInfo
*ereg
;
11156 Elf64_Internal_RegInfo reginfo
;
11158 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11159 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11160 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11161 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11162 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11163 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11164 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11166 printf ("GPR %08lx GP 0x",
11167 reginfo
.ri_gprmask
);
11168 printf_vma (reginfo
.ri_gp_value
);
11171 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11172 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11173 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11177 case ODK_EXCEPTIONS
:
11178 fputs (" EXCEPTIONS fpe_min(", stdout
);
11179 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11180 fputs (") fpe_max(", stdout
);
11181 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11182 fputs (")", stdout
);
11184 if (option
->info
& OEX_PAGE0
)
11185 fputs (" PAGE0", stdout
);
11186 if (option
->info
& OEX_SMM
)
11187 fputs (" SMM", stdout
);
11188 if (option
->info
& OEX_FPDBUG
)
11189 fputs (" FPDBUG", stdout
);
11190 if (option
->info
& OEX_DISMISS
)
11191 fputs (" DISMISS", stdout
);
11194 fputs (" PAD ", stdout
);
11195 if (option
->info
& OPAD_PREFIX
)
11196 fputs (" PREFIX", stdout
);
11197 if (option
->info
& OPAD_POSTFIX
)
11198 fputs (" POSTFIX", stdout
);
11199 if (option
->info
& OPAD_SYMBOL
)
11200 fputs (" SYMBOL", stdout
);
11203 fputs (" HWPATCH ", stdout
);
11204 if (option
->info
& OHW_R4KEOP
)
11205 fputs (" R4KEOP", stdout
);
11206 if (option
->info
& OHW_R8KPFETCH
)
11207 fputs (" R8KPFETCH", stdout
);
11208 if (option
->info
& OHW_R5KEOP
)
11209 fputs (" R5KEOP", stdout
);
11210 if (option
->info
& OHW_R5KCVTL
)
11211 fputs (" R5KCVTL", stdout
);
11214 fputs (" FILL ", stdout
);
11215 /* XXX Print content of info word? */
11218 fputs (" TAGS ", stdout
);
11219 /* XXX Print content of info word? */
11222 fputs (" HWAND ", stdout
);
11223 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11224 fputs (" R4KEOP_CHECKED", stdout
);
11225 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11226 fputs (" R4KEOP_CLEAN", stdout
);
11229 fputs (" HWOR ", stdout
);
11230 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11231 fputs (" R4KEOP_CHECKED", stdout
);
11232 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11233 fputs (" R4KEOP_CLEAN", stdout
);
11236 printf (" GP_GROUP %#06lx self-contained %#06lx",
11237 option
->info
& OGP_GROUP
,
11238 (option
->info
& OGP_SELF
) >> 16);
11241 printf (" IDENT %#06lx self-contained %#06lx",
11242 option
->info
& OGP_GROUP
,
11243 (option
->info
& OGP_SELF
) >> 16);
11246 /* This shouldn't happen. */
11247 printf (" %3d ??? %d %lx",
11248 option
->kind
, option
->section
, option
->info
);
11252 len
= sizeof (*eopt
);
11253 while (len
< option
->size
)
11254 if (((char *) option
)[len
] >= ' '
11255 && ((char *) option
)[len
] < 0x7f)
11256 printf ("%c", ((char *) option
)[len
++]);
11258 printf ("\\%03o", ((char *) option
)[len
++]);
11260 fputs ("\n", stdout
);
11268 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11270 Elf32_Conflict
*iconf
;
11273 if (dynamic_symbols
== NULL
)
11275 error (_("conflict list found without a dynamic symbol table"));
11279 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11282 error (_("Out of memory"));
11288 Elf32_External_Conflict
*econf32
;
11290 econf32
= get_data (NULL
, file
, conflicts_offset
,
11291 conflictsno
* sizeof (*econf32
), _("conflict"));
11295 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11296 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11302 Elf64_External_Conflict
*econf64
;
11304 econf64
= get_data (NULL
, file
, conflicts_offset
,
11305 conflictsno
* sizeof (*econf64
), _("conflict"));
11309 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11310 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11315 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11316 (unsigned long) conflictsno
);
11317 puts (_(" Num: Index Value Name"));
11319 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11321 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11323 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11324 print_vma (psym
->st_value
, FULL_HEX
);
11326 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11327 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11329 printf ("<corrupt: %14ld>", psym
->st_name
);
11340 process_gnu_liblist (FILE *file
)
11342 Elf_Internal_Shdr
*section
, *string_sec
;
11343 Elf32_External_Lib
*elib
;
11351 for (i
= 0, section
= section_headers
;
11352 i
< elf_header
.e_shnum
;
11355 switch (section
->sh_type
)
11357 case SHT_GNU_LIBLIST
:
11358 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11363 string_sec
= SECTION_HEADER (section
->sh_link
);
11365 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11366 string_sec
->sh_size
, _("liblist string table"));
11369 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11375 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11376 SECTION_NAME (section
),
11377 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11379 puts (" Library Time Stamp Checksum Version Flags");
11381 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11389 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11390 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11391 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11392 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11393 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11395 tmp
= gmtime (&time
);
11396 snprintf (timebuf
, sizeof (timebuf
),
11397 "%04u-%02u-%02uT%02u:%02u:%02u",
11398 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11399 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11401 printf ("%3lu: ", (unsigned long) cnt
);
11403 printf ("%-20s", strtab
+ liblist
.l_name
);
11405 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11406 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11407 liblist
.l_version
, liblist
.l_flags
);
11417 static const char *
11418 get_note_type (unsigned e_type
)
11420 static char buff
[64];
11422 if (elf_header
.e_type
== ET_CORE
)
11426 return _("NT_AUXV (auxiliary vector)");
11428 return _("NT_PRSTATUS (prstatus structure)");
11430 return _("NT_FPREGSET (floating point registers)");
11432 return _("NT_PRPSINFO (prpsinfo structure)");
11433 case NT_TASKSTRUCT
:
11434 return _("NT_TASKSTRUCT (task structure)");
11436 return _("NT_PRXFPREG (user_xfpregs structure)");
11438 return _("NT_PSTATUS (pstatus structure)");
11440 return _("NT_FPREGS (floating point registers)");
11442 return _("NT_PSINFO (psinfo structure)");
11444 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11446 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11447 case NT_WIN32PSTATUS
:
11448 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11456 return _("NT_VERSION (version)");
11458 return _("NT_ARCH (architecture)");
11463 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11467 static const char *
11468 get_netbsd_elfcore_note_type (unsigned e_type
)
11470 static char buff
[64];
11472 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11474 /* NetBSD core "procinfo" structure. */
11475 return _("NetBSD procinfo structure");
11478 /* As of Jan 2002 there are no other machine-independent notes
11479 defined for NetBSD core files. If the note type is less
11480 than the start of the machine-dependent note types, we don't
11483 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11485 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11489 switch (elf_header
.e_machine
)
11491 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11492 and PT_GETFPREGS == mach+2. */
11497 case EM_SPARC32PLUS
:
11501 case NT_NETBSDCORE_FIRSTMACH
+0:
11502 return _("PT_GETREGS (reg structure)");
11503 case NT_NETBSDCORE_FIRSTMACH
+2:
11504 return _("PT_GETFPREGS (fpreg structure)");
11510 /* On all other arch's, PT_GETREGS == mach+1 and
11511 PT_GETFPREGS == mach+3. */
11515 case NT_NETBSDCORE_FIRSTMACH
+1:
11516 return _("PT_GETREGS (reg structure)");
11517 case NT_NETBSDCORE_FIRSTMACH
+3:
11518 return _("PT_GETFPREGS (fpreg structure)");
11524 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11525 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11529 /* Note that by the ELF standard, the name field is already null byte
11530 terminated, and namesz includes the terminating null byte.
11531 I.E. the value of namesz for the name "FSF" is 4.
11533 If the value of namesz is zero, there is no name present. */
11535 process_note (Elf_Internal_Note
*pnote
)
11539 if (pnote
->namesz
== 0)
11540 /* If there is no note name, then use the default set of
11541 note type strings. */
11542 nt
= get_note_type (pnote
->type
);
11544 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11545 /* NetBSD-specific core file notes. */
11546 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11549 /* Don't recognize this note name; just use the default set of
11550 note type strings. */
11551 nt
= get_note_type (pnote
->type
);
11553 printf (" %s\t\t0x%08lx\t%s\n",
11554 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11555 pnote
->descsz
, nt
);
11561 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11563 Elf_External_Note
*pnotes
;
11564 Elf_External_Note
*external
;
11570 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11576 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11577 (unsigned long) offset
, (unsigned long) length
);
11578 printf (_(" Owner\t\tData size\tDescription\n"));
11580 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11582 Elf_External_Note
*next
;
11583 Elf_Internal_Note inote
;
11586 inote
.type
= BYTE_GET (external
->type
);
11587 inote
.namesz
= BYTE_GET (external
->namesz
);
11588 inote
.namedata
= external
->name
;
11589 inote
.descsz
= BYTE_GET (external
->descsz
);
11590 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11591 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11593 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11595 if (((char *) next
) > (((char *) pnotes
) + length
))
11597 warn (_("corrupt note found at offset %x into core notes\n"),
11598 ((char *) external
) - ((char *) pnotes
));
11599 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11600 inote
.type
, inote
.namesz
, inote
.descsz
);
11606 /* Verify that name is null terminated. It appears that at least
11607 one version of Linux (RedHat 6.0) generates corefiles that don't
11608 comply with the ELF spec by failing to include the null byte in
11610 if (inote
.namedata
[inote
.namesz
] != '\0')
11612 temp
= malloc (inote
.namesz
+ 1);
11616 error (_("Out of memory\n"));
11621 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11622 temp
[inote
.namesz
] = 0;
11624 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11625 inote
.namedata
= temp
;
11628 res
&= process_note (& inote
);
11643 process_corefile_note_segments (FILE *file
)
11645 Elf_Internal_Phdr
*segment
;
11649 if (! get_program_headers (file
))
11652 for (i
= 0, segment
= program_headers
;
11653 i
< elf_header
.e_phnum
;
11656 if (segment
->p_type
== PT_NOTE
)
11657 res
&= process_corefile_note_segment (file
,
11658 (bfd_vma
) segment
->p_offset
,
11659 (bfd_vma
) segment
->p_filesz
);
11666 process_note_sections (FILE *file
)
11668 Elf_Internal_Shdr
*section
;
11672 for (i
= 0, section
= section_headers
;
11673 i
< elf_header
.e_shnum
;
11675 if (section
->sh_type
== SHT_NOTE
)
11676 res
&= process_corefile_note_segment (file
,
11677 (bfd_vma
) section
->sh_offset
,
11678 (bfd_vma
) section
->sh_size
);
11684 process_notes (FILE *file
)
11686 /* If we have not been asked to display the notes then do nothing. */
11690 if (elf_header
.e_type
!= ET_CORE
)
11691 return process_note_sections (file
);
11693 /* No program headers means no NOTE segment. */
11694 if (elf_header
.e_phnum
> 0)
11695 return process_corefile_note_segments (file
);
11697 printf (_("No note segments present in the core file.\n"));
11702 process_arch_specific (FILE *file
)
11707 switch (elf_header
.e_machine
)
11710 case EM_MIPS_RS3_LE
:
11711 return process_mips_specific (file
);
11720 get_file_header (FILE *file
)
11722 /* Read in the identity array. */
11723 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11726 /* Determine how to read the rest of the header. */
11727 switch (elf_header
.e_ident
[EI_DATA
])
11729 default: /* fall through */
11730 case ELFDATANONE
: /* fall through */
11732 byte_get
= byte_get_little_endian
;
11733 byte_put
= byte_put_little_endian
;
11736 byte_get
= byte_get_big_endian
;
11737 byte_put
= byte_put_big_endian
;
11741 /* For now we only support 32 bit and 64 bit ELF files. */
11742 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11744 /* Read in the rest of the header. */
11747 Elf32_External_Ehdr ehdr32
;
11749 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11752 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11753 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11754 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11755 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11756 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11757 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11758 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11759 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11760 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11761 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11762 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11763 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11764 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11768 Elf64_External_Ehdr ehdr64
;
11770 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11771 we will not be able to cope with the 64bit data found in
11772 64 ELF files. Detect this now and abort before we start
11773 overwriting things. */
11774 if (sizeof (bfd_vma
) < 8)
11776 error (_("This instance of readelf has been built without support for a\n\
11777 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11781 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11784 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11785 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11786 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11787 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11788 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11789 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11790 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11791 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11792 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11793 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11794 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11795 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11796 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11799 if (elf_header
.e_shoff
)
11801 /* There may be some extensions in the first section header. Don't
11802 bomb if we can't read it. */
11804 get_32bit_section_headers (file
, 1);
11806 get_64bit_section_headers (file
, 1);
11812 /* Process one ELF object file according to the command line options.
11813 This file may actually be stored in an archive. The file is
11814 positioned at the start of the ELF object. */
11817 process_object (char *file_name
, FILE *file
)
11821 if (! get_file_header (file
))
11823 error (_("%s: Failed to read file header\n"), file_name
);
11827 /* Initialise per file variables. */
11828 for (i
= NUM_ELEM (version_info
); i
--;)
11829 version_info
[i
] = 0;
11831 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11832 dynamic_info
[i
] = 0;
11834 /* Process the file. */
11836 printf (_("\nFile: %s\n"), file_name
);
11838 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11839 Note we do this even if cmdline_dump_sects is empty because we
11840 must make sure that the dump_sets array is zeroed out before each
11841 object file is processed. */
11842 if (num_dump_sects
> num_cmdline_dump_sects
)
11843 memset (dump_sects
, 0, num_dump_sects
);
11845 if (num_cmdline_dump_sects
> 0)
11847 if (num_dump_sects
== 0)
11848 /* A sneaky way of allocating the dump_sects array. */
11849 request_dump (num_cmdline_dump_sects
, 0);
11851 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11852 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11855 if (! process_file_header ())
11858 if (! process_section_headers (file
))
11860 /* Without loaded section headers we cannot process lots of
11862 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11864 if (! do_using_dynamic
)
11865 do_syms
= do_reloc
= 0;
11868 if (! process_section_groups (file
))
11870 /* Without loaded section groups we cannot process unwind. */
11874 if (process_program_headers (file
))
11875 process_dynamic_section (file
);
11877 process_relocs (file
);
11879 process_unwind (file
);
11881 process_symbol_table (file
);
11883 process_syminfo (file
);
11885 process_version_sections (file
);
11887 process_section_contents (file
);
11889 process_notes (file
);
11891 process_gnu_liblist (file
);
11893 process_arch_specific (file
);
11895 if (program_headers
)
11897 free (program_headers
);
11898 program_headers
= NULL
;
11901 if (section_headers
)
11903 free (section_headers
);
11904 section_headers
= NULL
;
11909 free (string_table
);
11910 string_table
= NULL
;
11911 string_table_length
= 0;
11914 if (dynamic_strings
)
11916 free (dynamic_strings
);
11917 dynamic_strings
= NULL
;
11918 dynamic_strings_length
= 0;
11921 if (dynamic_symbols
)
11923 free (dynamic_symbols
);
11924 dynamic_symbols
= NULL
;
11925 num_dynamic_syms
= 0;
11928 if (dynamic_syminfo
)
11930 free (dynamic_syminfo
);
11931 dynamic_syminfo
= NULL
;
11934 if (section_headers_groups
)
11936 free (section_headers_groups
);
11937 section_headers_groups
= NULL
;
11940 if (section_groups
)
11942 struct group_list
*g
, *next
;
11944 for (i
= 0; i
< group_count
; i
++)
11946 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11953 free (section_groups
);
11954 section_groups
= NULL
;
11957 if (debug_information
)
11959 for (i
= 0; i
< num_debug_info_entries
; i
++)
11961 if (!debug_information
[i
].max_loc_offsets
)
11963 free (debug_information
[i
].loc_offsets
);
11964 free (debug_information
[i
].have_frame_base
);
11966 if (!debug_information
[i
].max_range_lists
)
11967 free (debug_information
[i
].range_lists
);
11969 free (debug_information
);
11970 debug_information
= NULL
;
11971 num_debug_info_entries
= 0;
11977 /* Process an ELF archive. The file is positioned just after the
11981 process_archive (char *file_name
, FILE *file
)
11983 struct ar_hdr arhdr
;
11985 unsigned long size
;
11986 char *longnames
= NULL
;
11987 unsigned long longnames_size
= 0;
11988 size_t file_name_size
;
11993 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11994 if (got
!= sizeof arhdr
)
11999 error (_("%s: failed to read archive header\n"), file_name
);
12003 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12005 /* This is the archive symbol table. Skip it.
12006 FIXME: We should have an option to dump it. */
12007 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12008 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12010 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12014 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12015 if (got
!= sizeof arhdr
)
12020 error (_("%s: failed to read archive header\n"), file_name
);
12025 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12027 /* This is the archive string table holding long member
12030 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12032 longnames
= malloc (longnames_size
);
12033 if (longnames
== NULL
)
12035 error (_("Out of memory\n"));
12039 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12042 error (_("%s: failed to read string table\n"), file_name
);
12046 if ((longnames_size
& 1) != 0)
12049 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12050 if (got
!= sizeof arhdr
)
12057 error (_("%s: failed to read archive header\n"), file_name
);
12062 file_name_size
= strlen (file_name
);
12071 if (arhdr
.ar_name
[0] == '/')
12075 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12076 if (off
>= longnames_size
)
12078 error (_("%s: invalid archive string table offset %lu\n"), off
);
12083 name
= longnames
+ off
;
12084 nameend
= memchr (name
, '/', longnames_size
- off
);
12088 name
= arhdr
.ar_name
;
12089 nameend
= memchr (name
, '/', 16);
12092 if (nameend
== NULL
)
12094 error (_("%s: bad archive file name\n"));
12099 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12100 if (namealc
== NULL
)
12102 error (_("Out of memory\n"));
12107 memcpy (namealc
, file_name
, file_name_size
);
12108 namealc
[file_name_size
] = '(';
12109 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12110 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12111 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12113 archive_file_offset
= ftell (file
);
12114 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12116 ret
|= process_object (namealc
, file
);
12121 (archive_file_offset
12122 + archive_file_size
12123 + (archive_file_size
& 1)),
12126 error (_("%s: failed to seek to next archive header\n"), file_name
);
12131 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12132 if (got
!= sizeof arhdr
)
12137 error (_("%s: failed to read archive header\n"), file_name
);
12143 if (longnames
!= 0)
12150 process_file (char *file_name
)
12153 struct stat statbuf
;
12154 char armag
[SARMAG
];
12157 if (stat (file_name
, &statbuf
) < 0)
12159 if (errno
== ENOENT
)
12160 error (_("'%s': No such file\n"), file_name
);
12162 error (_("Could not locate '%s'. System error message: %s\n"),
12163 file_name
, strerror (errno
));
12167 if (! S_ISREG (statbuf
.st_mode
))
12169 error (_("'%s' is not an ordinary file\n"), file_name
);
12173 file
= fopen (file_name
, "rb");
12176 error (_("Input file '%s' is not readable.\n"), file_name
);
12180 if (fread (armag
, SARMAG
, 1, file
) != 1)
12182 error (_("%s: Failed to read file header\n"), file_name
);
12187 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12188 ret
= process_archive (file_name
, file
);
12192 archive_file_size
= archive_file_offset
= 0;
12193 ret
= process_object (file_name
, file
);
12201 #ifdef SUPPORT_DISASSEMBLY
12202 /* Needed by the i386 disassembler. For extra credit, someone could
12203 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12207 print_address (unsigned int addr
, FILE *outfile
)
12209 fprintf (outfile
,"0x%8.8x", addr
);
12212 /* Needed by the i386 disassembler. */
12214 db_task_printsym (unsigned int addr
)
12216 print_address (addr
, stderr
);
12221 main (int argc
, char **argv
)
12225 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12226 setlocale (LC_MESSAGES
, "");
12228 #if defined (HAVE_SETLOCALE)
12229 setlocale (LC_CTYPE
, "");
12231 bindtextdomain (PACKAGE
, LOCALEDIR
);
12232 textdomain (PACKAGE
);
12234 parse_args (argc
, argv
);
12236 if (num_dump_sects
> 0)
12238 /* Make a copy of the dump_sects array. */
12239 cmdline_dump_sects
= malloc (num_dump_sects
);
12240 if (cmdline_dump_sects
== NULL
)
12241 error (_("Out of memory allocating dump request table."));
12244 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12245 num_cmdline_dump_sects
= num_dump_sects
;
12249 if (optind
< (argc
- 1))
12253 while (optind
< argc
)
12254 err
|= process_file (argv
[optind
++]);
12256 if (dump_sects
!= NULL
)
12258 if (cmdline_dump_sects
!= NULL
)
12259 free (cmdline_dump_sects
);