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 [%5u] `%s' [%s] contains %u sections:\n",
4191 get_group_flags (entry
), i
, 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 (entry
>= elf_header
.e_shnum
)
4207 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4208 entry
, i
, elf_header
.e_shnum
- 1);
4211 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4213 error (_("invalid section [%5u] in group section [%5u]\n"),
4218 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4223 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4225 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4230 /* Intel C/C++ compiler may put section 0 in a
4231 section group. We just warn it the first time
4232 and ignore it afterwards. */
4233 static int warned
= 0;
4236 error (_("section 0 in group section [%5u]\n"),
4237 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4243 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4246 if (do_section_groups
)
4248 sec
= SECTION_HEADER (entry
);
4249 printf (" [%5u] %s\n",
4250 entry
, SECTION_NAME (sec
));
4253 g
= xmalloc (sizeof (struct group_list
));
4254 g
->section_index
= entry
;
4255 g
->next
= group
->root
;
4279 } dynamic_relocations
[] =
4281 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4282 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4283 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4286 /* Process the reloc section. */
4289 process_relocs (FILE *file
)
4291 unsigned long rel_size
;
4292 unsigned long rel_offset
;
4298 if (do_using_dynamic
)
4302 int has_dynamic_reloc
;
4305 has_dynamic_reloc
= 0;
4307 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4309 is_rela
= dynamic_relocations
[i
].rela
;
4310 name
= dynamic_relocations
[i
].name
;
4311 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4312 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4314 has_dynamic_reloc
|= rel_size
;
4316 if (is_rela
== UNKNOWN
)
4318 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4319 switch (dynamic_info
[DT_PLTREL
])
4333 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4334 name
, rel_offset
, rel_size
);
4336 dump_relocations (file
,
4337 offset_from_vma (file
, rel_offset
, rel_size
),
4339 dynamic_symbols
, num_dynamic_syms
,
4340 dynamic_strings
, dynamic_strings_length
, is_rela
);
4344 if (! has_dynamic_reloc
)
4345 printf (_("\nThere are no dynamic relocations in this file.\n"));
4349 Elf_Internal_Shdr
*section
;
4353 for (i
= 0, section
= section_headers
;
4354 i
< elf_header
.e_shnum
;
4357 if ( section
->sh_type
!= SHT_RELA
4358 && section
->sh_type
!= SHT_REL
)
4361 rel_offset
= section
->sh_offset
;
4362 rel_size
= section
->sh_size
;
4366 Elf_Internal_Shdr
*strsec
;
4369 printf (_("\nRelocation section "));
4371 if (string_table
== NULL
)
4372 printf ("%d", section
->sh_name
);
4374 printf (_("'%s'"), SECTION_NAME (section
));
4376 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4377 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4379 is_rela
= section
->sh_type
== SHT_RELA
;
4381 if (section
->sh_link
)
4383 Elf_Internal_Shdr
*symsec
;
4384 Elf_Internal_Sym
*symtab
;
4385 unsigned long nsyms
;
4386 unsigned long strtablen
;
4387 char *strtab
= NULL
;
4389 symsec
= SECTION_HEADER (section
->sh_link
);
4390 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4391 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4396 strsec
= SECTION_HEADER (symsec
->sh_link
);
4398 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4399 strsec
->sh_size
, _("string table"));
4400 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4402 dump_relocations (file
, rel_offset
, rel_size
,
4403 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4409 dump_relocations (file
, rel_offset
, rel_size
,
4410 NULL
, 0, NULL
, 0, is_rela
);
4417 printf (_("\nThere are no relocations in this file.\n"));
4423 /* Process the unwind section. */
4425 #include "unwind-ia64.h"
4427 /* An absolute address consists of a section and an offset. If the
4428 section is NULL, the offset itself is the address, otherwise, the
4429 address equals to LOAD_ADDRESS(section) + offset. */
4433 unsigned short section
;
4437 struct ia64_unw_aux_info
4439 struct ia64_unw_table_entry
4441 struct absaddr start
;
4443 struct absaddr info
;
4445 *table
; /* Unwind table. */
4446 unsigned long table_len
; /* Length of unwind table. */
4447 unsigned char *info
; /* Unwind info. */
4448 unsigned long info_size
; /* Size of unwind info. */
4449 bfd_vma info_addr
; /* starting address of unwind info. */
4450 bfd_vma seg_base
; /* Starting address of segment. */
4451 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4452 unsigned long nsyms
; /* Number of symbols. */
4453 char *strtab
; /* The string table. */
4454 unsigned long strtab_size
; /* Size of string table. */
4458 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4459 unsigned long nsyms
,
4461 unsigned long strtab_size
,
4462 struct absaddr addr
,
4463 const char **symname
,
4466 bfd_vma dist
= 0x100000;
4467 Elf_Internal_Sym
*sym
, *best
= NULL
;
4470 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4472 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4473 && sym
->st_name
!= 0
4474 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4475 && addr
.offset
>= sym
->st_value
4476 && addr
.offset
- sym
->st_value
< dist
)
4479 dist
= addr
.offset
- sym
->st_value
;
4486 *symname
= (best
->st_name
>= strtab_size
4487 ? "<corrupt>" : strtab
+ best
->st_name
);
4492 *offset
= addr
.offset
;
4496 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4498 struct ia64_unw_table_entry
*tp
;
4501 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4505 const unsigned char *dp
;
4506 const unsigned char *head
;
4507 const char *procname
;
4509 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4510 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4512 fputs ("\n<", stdout
);
4516 fputs (procname
, stdout
);
4519 printf ("+%lx", (unsigned long) offset
);
4522 fputs (">: [", stdout
);
4523 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4524 fputc ('-', stdout
);
4525 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4526 printf ("], info at +0x%lx\n",
4527 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4529 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4530 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4532 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4533 (unsigned) UNW_VER (stamp
),
4534 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4535 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4536 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4537 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4539 if (UNW_VER (stamp
) != 1)
4541 printf ("\tUnknown version.\n");
4546 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4547 dp
= unw_decode (dp
, in_body
, & in_body
);
4552 slurp_ia64_unwind_table (FILE *file
,
4553 struct ia64_unw_aux_info
*aux
,
4554 Elf_Internal_Shdr
*sec
)
4556 unsigned long size
, nrelas
, i
;
4557 Elf_Internal_Phdr
*seg
;
4558 struct ia64_unw_table_entry
*tep
;
4559 Elf_Internal_Shdr
*relsec
;
4560 Elf_Internal_Rela
*rela
, *rp
;
4561 unsigned char *table
, *tp
;
4562 Elf_Internal_Sym
*sym
;
4563 const char *relname
;
4565 /* First, find the starting address of the segment that includes
4568 if (elf_header
.e_phnum
)
4570 if (! get_program_headers (file
))
4573 for (seg
= program_headers
;
4574 seg
< program_headers
+ elf_header
.e_phnum
;
4577 if (seg
->p_type
!= PT_LOAD
)
4580 if (sec
->sh_addr
>= seg
->p_vaddr
4581 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4583 aux
->seg_base
= seg
->p_vaddr
;
4589 /* Second, build the unwind table from the contents of the unwind section: */
4590 size
= sec
->sh_size
;
4591 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4595 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4597 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4599 tep
->start
.section
= SHN_UNDEF
;
4600 tep
->end
.section
= SHN_UNDEF
;
4601 tep
->info
.section
= SHN_UNDEF
;
4604 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4605 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4606 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4610 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4611 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4612 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4614 tep
->start
.offset
+= aux
->seg_base
;
4615 tep
->end
.offset
+= aux
->seg_base
;
4616 tep
->info
.offset
+= aux
->seg_base
;
4620 /* Third, apply any relocations to the unwind table: */
4622 for (relsec
= section_headers
;
4623 relsec
< section_headers
+ elf_header
.e_shnum
;
4626 if (relsec
->sh_type
!= SHT_RELA
4627 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4630 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4634 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4638 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4639 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4643 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4644 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4647 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4649 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4653 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4655 switch (rp
->r_offset
/eh_addr_size
% 3)
4658 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4659 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4662 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4663 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4666 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4667 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4677 aux
->table_len
= size
/ (3 * eh_addr_size
);
4682 ia64_process_unwind (FILE *file
)
4684 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4685 unsigned long i
, unwcount
= 0, unwstart
= 0;
4686 struct ia64_unw_aux_info aux
;
4688 memset (& aux
, 0, sizeof (aux
));
4690 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4692 if (sec
->sh_type
== SHT_SYMTAB
)
4694 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4695 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4697 strsec
= SECTION_HEADER (sec
->sh_link
);
4698 aux
.strtab_size
= strsec
->sh_size
;
4699 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4700 aux
.strtab_size
, _("string table"));
4702 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4707 printf (_("\nThere are no unwind sections in this file.\n"));
4709 while (unwcount
-- > 0)
4714 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4715 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4716 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4723 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4725 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4727 /* We need to find which section group it is in. */
4728 struct group_list
*g
= section_headers_groups
[i
]->root
;
4730 for (; g
!= NULL
; g
= g
->next
)
4732 sec
= SECTION_HEADER (g
->section_index
);
4734 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4739 i
= elf_header
.e_shnum
;
4741 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4743 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4744 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4745 suffix
= SECTION_NAME (unwsec
) + len
;
4746 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4748 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4749 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4754 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4755 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4756 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4757 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4759 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4760 suffix
= SECTION_NAME (unwsec
) + len
;
4761 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4763 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4764 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4768 if (i
== elf_header
.e_shnum
)
4770 printf (_("\nCould not find unwind info section for "));
4772 if (string_table
== NULL
)
4773 printf ("%d", unwsec
->sh_name
);
4775 printf (_("'%s'"), SECTION_NAME (unwsec
));
4779 aux
.info_size
= sec
->sh_size
;
4780 aux
.info_addr
= sec
->sh_addr
;
4781 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4784 printf (_("\nUnwind section "));
4786 if (string_table
== NULL
)
4787 printf ("%d", unwsec
->sh_name
);
4789 printf (_("'%s'"), SECTION_NAME (unwsec
));
4791 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4792 (unsigned long) unwsec
->sh_offset
,
4793 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4795 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4797 if (aux
.table_len
> 0)
4798 dump_ia64_unwind (& aux
);
4801 free ((char *) aux
.table
);
4803 free ((char *) aux
.info
);
4812 free ((char *) aux
.strtab
);
4817 struct hppa_unw_aux_info
4819 struct hppa_unw_table_entry
4821 struct absaddr start
;
4823 unsigned int Cannot_unwind
:1; /* 0 */
4824 unsigned int Millicode
:1; /* 1 */
4825 unsigned int Millicode_save_sr0
:1; /* 2 */
4826 unsigned int Region_description
:2; /* 3..4 */
4827 unsigned int reserved1
:1; /* 5 */
4828 unsigned int Entry_SR
:1; /* 6 */
4829 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4830 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4831 unsigned int Args_stored
:1; /* 16 */
4832 unsigned int Variable_Frame
:1; /* 17 */
4833 unsigned int Separate_Package_Body
:1; /* 18 */
4834 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4835 unsigned int Stack_Overflow_Check
:1; /* 20 */
4836 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4837 unsigned int Ada_Region
:1; /* 22 */
4838 unsigned int cxx_info
:1; /* 23 */
4839 unsigned int cxx_try_catch
:1; /* 24 */
4840 unsigned int sched_entry_seq
:1; /* 25 */
4841 unsigned int reserved2
:1; /* 26 */
4842 unsigned int Save_SP
:1; /* 27 */
4843 unsigned int Save_RP
:1; /* 28 */
4844 unsigned int Save_MRP_in_frame
:1; /* 29 */
4845 unsigned int extn_ptr_defined
:1; /* 30 */
4846 unsigned int Cleanup_defined
:1; /* 31 */
4848 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4849 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4850 unsigned int Large_frame
:1; /* 2 */
4851 unsigned int Pseudo_SP_Set
:1; /* 3 */
4852 unsigned int reserved4
:1; /* 4 */
4853 unsigned int Total_frame_size
:27; /* 5..31 */
4855 *table
; /* Unwind table. */
4856 unsigned long table_len
; /* Length of unwind table. */
4857 bfd_vma seg_base
; /* Starting address of segment. */
4858 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4859 unsigned long nsyms
; /* Number of symbols. */
4860 char *strtab
; /* The string table. */
4861 unsigned long strtab_size
; /* Size of string table. */
4865 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4867 struct hppa_unw_table_entry
*tp
;
4869 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4872 const char *procname
;
4874 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4875 aux
->strtab_size
, tp
->start
, &procname
,
4878 fputs ("\n<", stdout
);
4882 fputs (procname
, stdout
);
4885 printf ("+%lx", (unsigned long) offset
);
4888 fputs (">: [", stdout
);
4889 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4890 fputc ('-', stdout
);
4891 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4894 #define PF(_m) if (tp->_m) printf (#_m " ");
4895 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4898 PF(Millicode_save_sr0
);
4899 /* PV(Region_description); */
4905 PF(Separate_Package_Body
);
4906 PF(Frame_Extension_Millicode
);
4907 PF(Stack_Overflow_Check
);
4908 PF(Two_Instruction_SP_Increment
);
4912 PF(sched_entry_seq
);
4915 PF(Save_MRP_in_frame
);
4916 PF(extn_ptr_defined
);
4917 PF(Cleanup_defined
);
4918 PF(MPE_XL_interrupt_marker
);
4919 PF(HP_UX_interrupt_marker
);
4922 PV(Total_frame_size
);
4931 slurp_hppa_unwind_table (FILE *file
,
4932 struct hppa_unw_aux_info
*aux
,
4933 Elf_Internal_Shdr
*sec
)
4935 unsigned long size
, unw_ent_size
, nrelas
, i
;
4936 Elf_Internal_Phdr
*seg
;
4937 struct hppa_unw_table_entry
*tep
;
4938 Elf_Internal_Shdr
*relsec
;
4939 Elf_Internal_Rela
*rela
, *rp
;
4940 unsigned char *table
, *tp
;
4941 Elf_Internal_Sym
*sym
;
4942 const char *relname
;
4944 /* First, find the starting address of the segment that includes
4947 if (elf_header
.e_phnum
)
4949 if (! get_program_headers (file
))
4952 for (seg
= program_headers
;
4953 seg
< program_headers
+ elf_header
.e_phnum
;
4956 if (seg
->p_type
!= PT_LOAD
)
4959 if (sec
->sh_addr
>= seg
->p_vaddr
4960 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4962 aux
->seg_base
= seg
->p_vaddr
;
4968 /* Second, build the unwind table from the contents of the unwind
4970 size
= sec
->sh_size
;
4971 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4975 unw_ent_size
= 2 * eh_addr_size
+ 8;
4977 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4979 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
4981 unsigned int tmp1
, tmp2
;
4983 tep
->start
.section
= SHN_UNDEF
;
4984 tep
->end
.section
= SHN_UNDEF
;
4988 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4989 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4990 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4991 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4995 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4996 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4997 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4998 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
5001 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5002 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5003 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5004 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5005 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5006 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5007 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5008 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5009 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5010 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5011 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5012 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5013 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5014 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5015 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5016 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5017 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5018 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5019 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5020 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5021 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5022 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5023 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5024 tep
->Cleanup_defined
= tmp1
& 0x1;
5026 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5027 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5028 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5029 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5030 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5031 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5033 tep
->start
.offset
+= aux
->seg_base
;
5034 tep
->end
.offset
+= aux
->seg_base
;
5038 /* Third, apply any relocations to the unwind table. */
5040 for (relsec
= section_headers
;
5041 relsec
< section_headers
+ elf_header
.e_shnum
;
5044 if (relsec
->sh_type
!= SHT_RELA
5045 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5048 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5052 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5056 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5057 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5061 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5062 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5065 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5066 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5068 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5072 i
= rp
->r_offset
/ unw_ent_size
;
5074 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5077 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5078 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5081 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5082 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5092 aux
->table_len
= size
/ unw_ent_size
;
5098 hppa_process_unwind (FILE *file
)
5100 struct hppa_unw_aux_info aux
;
5101 Elf_Internal_Shdr
*unwsec
= NULL
;
5102 Elf_Internal_Shdr
*strsec
;
5103 Elf_Internal_Shdr
*sec
;
5106 memset (& aux
, 0, sizeof (aux
));
5108 assert (string_table
!= NULL
);
5110 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5112 if (sec
->sh_type
== SHT_SYMTAB
)
5114 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5115 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5117 strsec
= SECTION_HEADER (sec
->sh_link
);
5118 aux
.strtab_size
= strsec
->sh_size
;
5119 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5120 aux
.strtab_size
, _("string table"));
5122 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5127 printf (_("\nThere are no unwind sections in this file.\n"));
5129 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5131 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5133 printf (_("\nUnwind section "));
5134 printf (_("'%s'"), SECTION_NAME (sec
));
5136 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5137 (unsigned long) sec
->sh_offset
,
5138 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5140 slurp_hppa_unwind_table (file
, &aux
, sec
);
5141 if (aux
.table_len
> 0)
5142 dump_hppa_unwind (&aux
);
5145 free ((char *) aux
.table
);
5153 free ((char *) aux
.strtab
);
5159 process_unwind (FILE *file
)
5161 struct unwind_handler
{
5163 int (*handler
)(FILE *file
);
5165 { EM_IA_64
, ia64_process_unwind
},
5166 { EM_PARISC
, hppa_process_unwind
},
5174 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5175 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5176 return handlers
[i
].handler (file
);
5178 printf (_("\nThere are no unwind sections in this file.\n"));
5183 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5185 switch (entry
->d_tag
)
5188 if (entry
->d_un
.d_val
== 0)
5192 static const char * opts
[] =
5194 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5195 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5196 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5197 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5202 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5203 if (entry
->d_un
.d_val
& (1 << cnt
))
5205 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5212 case DT_MIPS_IVERSION
:
5213 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5214 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5216 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5219 case DT_MIPS_TIME_STAMP
:
5224 time_t time
= entry
->d_un
.d_val
;
5225 tmp
= gmtime (&time
);
5226 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5227 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5228 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5229 printf ("Time Stamp: %s\n", timebuf
);
5233 case DT_MIPS_RLD_VERSION
:
5234 case DT_MIPS_LOCAL_GOTNO
:
5235 case DT_MIPS_CONFLICTNO
:
5236 case DT_MIPS_LIBLISTNO
:
5237 case DT_MIPS_SYMTABNO
:
5238 case DT_MIPS_UNREFEXTNO
:
5239 case DT_MIPS_HIPAGENO
:
5240 case DT_MIPS_DELTA_CLASS_NO
:
5241 case DT_MIPS_DELTA_INSTANCE_NO
:
5242 case DT_MIPS_DELTA_RELOC_NO
:
5243 case DT_MIPS_DELTA_SYM_NO
:
5244 case DT_MIPS_DELTA_CLASSSYM_NO
:
5245 case DT_MIPS_COMPACT_SIZE
:
5246 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5250 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5256 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5258 switch (entry
->d_tag
)
5260 case DT_HP_DLD_FLAGS
:
5269 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5270 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5271 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5272 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5273 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5274 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5275 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5276 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5277 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5278 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5279 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5283 bfd_vma val
= entry
->d_un
.d_val
;
5285 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5286 if (val
& flags
[cnt
].bit
)
5290 fputs (flags
[cnt
].str
, stdout
);
5292 val
^= flags
[cnt
].bit
;
5295 if (val
!= 0 || first
)
5299 print_vma (val
, HEX
);
5305 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5312 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5314 switch (entry
->d_tag
)
5316 case DT_IA_64_PLT_RESERVE
:
5317 /* First 3 slots reserved. */
5318 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5320 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5324 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5331 get_32bit_dynamic_section (FILE *file
)
5333 Elf32_External_Dyn
*edyn
, *ext
;
5334 Elf_Internal_Dyn
*entry
;
5336 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5337 _("dynamic section"));
5341 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5342 might not have the luxury of section headers. Look for the DT_NULL
5343 terminator to determine the number of entries. */
5344 for (ext
= edyn
, dynamic_nent
= 0;
5345 (char *) ext
< (char *) edyn
+ dynamic_size
;
5349 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5353 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5354 if (dynamic_section
== NULL
)
5356 error (_("Out of memory\n"));
5361 for (ext
= edyn
, entry
= dynamic_section
;
5362 entry
< dynamic_section
+ dynamic_nent
;
5365 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5366 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5375 get_64bit_dynamic_section (FILE *file
)
5377 Elf64_External_Dyn
*edyn
, *ext
;
5378 Elf_Internal_Dyn
*entry
;
5380 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5381 _("dynamic section"));
5385 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5386 might not have the luxury of section headers. Look for the DT_NULL
5387 terminator to determine the number of entries. */
5388 for (ext
= edyn
, dynamic_nent
= 0;
5389 (char *) ext
< (char *) edyn
+ dynamic_size
;
5393 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5397 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5398 if (dynamic_section
== NULL
)
5400 error (_("Out of memory\n"));
5405 for (ext
= edyn
, entry
= dynamic_section
;
5406 entry
< dynamic_section
+ dynamic_nent
;
5409 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5410 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5419 print_dynamic_flags (bfd_vma flags
)
5427 flag
= flags
& - flags
;
5437 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5438 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5439 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5440 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5441 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5442 default: fputs ("unknown", stdout
); break;
5448 /* Parse and display the contents of the dynamic section. */
5451 process_dynamic_section (FILE *file
)
5453 Elf_Internal_Dyn
*entry
;
5455 if (dynamic_size
== 0)
5458 printf (_("\nThere is no dynamic section in this file.\n"));
5465 if (! get_32bit_dynamic_section (file
))
5468 else if (! get_64bit_dynamic_section (file
))
5471 /* Find the appropriate symbol table. */
5472 if (dynamic_symbols
== NULL
)
5474 for (entry
= dynamic_section
;
5475 entry
< dynamic_section
+ dynamic_nent
;
5478 Elf_Internal_Shdr section
;
5480 if (entry
->d_tag
!= DT_SYMTAB
)
5483 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5485 /* Since we do not know how big the symbol table is,
5486 we default to reading in the entire file (!) and
5487 processing that. This is overkill, I know, but it
5489 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5491 if (archive_file_offset
!= 0)
5492 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5495 if (fseek (file
, 0, SEEK_END
))
5496 error (_("Unable to seek to end of file!"));
5498 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5502 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5504 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5506 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5507 if (num_dynamic_syms
< 1)
5509 error (_("Unable to determine the number of symbols to load\n"));
5513 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5517 /* Similarly find a string table. */
5518 if (dynamic_strings
== NULL
)
5520 for (entry
= dynamic_section
;
5521 entry
< dynamic_section
+ dynamic_nent
;
5524 unsigned long offset
;
5527 if (entry
->d_tag
!= DT_STRTAB
)
5530 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5532 /* Since we do not know how big the string table is,
5533 we default to reading in the entire file (!) and
5534 processing that. This is overkill, I know, but it
5537 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5539 if (archive_file_offset
!= 0)
5540 str_tab_len
= archive_file_size
- offset
;
5543 if (fseek (file
, 0, SEEK_END
))
5544 error (_("Unable to seek to end of file\n"));
5545 str_tab_len
= ftell (file
) - offset
;
5548 if (str_tab_len
< 1)
5551 (_("Unable to determine the length of the dynamic string table\n"));
5555 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5556 _("dynamic string table"));
5557 dynamic_strings_length
= str_tab_len
;
5562 /* And find the syminfo section if available. */
5563 if (dynamic_syminfo
== NULL
)
5565 unsigned long syminsz
= 0;
5567 for (entry
= dynamic_section
;
5568 entry
< dynamic_section
+ dynamic_nent
;
5571 if (entry
->d_tag
== DT_SYMINENT
)
5573 /* Note: these braces are necessary to avoid a syntax
5574 error from the SunOS4 C compiler. */
5575 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5577 else if (entry
->d_tag
== DT_SYMINSZ
)
5578 syminsz
= entry
->d_un
.d_val
;
5579 else if (entry
->d_tag
== DT_SYMINFO
)
5580 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5584 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5586 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5587 Elf_Internal_Syminfo
*syminfo
;
5589 /* There is a syminfo section. Read the data. */
5590 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5591 _("symbol information"));
5595 dynamic_syminfo
= malloc (syminsz
);
5596 if (dynamic_syminfo
== NULL
)
5598 error (_("Out of memory\n"));
5602 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5603 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5604 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5605 ++syminfo
, ++extsym
)
5607 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5608 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5615 if (do_dynamic
&& dynamic_addr
)
5616 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5617 dynamic_addr
, dynamic_nent
);
5619 printf (_(" Tag Type Name/Value\n"));
5621 for (entry
= dynamic_section
;
5622 entry
< dynamic_section
+ dynamic_nent
;
5630 print_vma (entry
->d_tag
, FULL_HEX
);
5631 dtype
= get_dynamic_type (entry
->d_tag
);
5632 printf (" (%s)%*s", dtype
,
5633 ((is_32bit_elf
? 27 : 19)
5634 - (int) strlen (dtype
)),
5638 switch (entry
->d_tag
)
5642 print_dynamic_flags (entry
->d_un
.d_val
);
5652 switch (entry
->d_tag
)
5655 printf (_("Auxiliary library"));
5659 printf (_("Filter library"));
5663 printf (_("Configuration file"));
5667 printf (_("Dependency audit library"));
5671 printf (_("Audit library"));
5675 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5676 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5680 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5689 printf (_("Flags:"));
5691 if (entry
->d_un
.d_val
== 0)
5692 printf (_(" None\n"));
5695 unsigned long int val
= entry
->d_un
.d_val
;
5697 if (val
& DTF_1_PARINIT
)
5699 printf (" PARINIT");
5700 val
^= DTF_1_PARINIT
;
5702 if (val
& DTF_1_CONFEXP
)
5704 printf (" CONFEXP");
5705 val
^= DTF_1_CONFEXP
;
5708 printf (" %lx", val
);
5717 printf (_("Flags:"));
5719 if (entry
->d_un
.d_val
== 0)
5720 printf (_(" None\n"));
5723 unsigned long int val
= entry
->d_un
.d_val
;
5725 if (val
& DF_P1_LAZYLOAD
)
5727 printf (" LAZYLOAD");
5728 val
^= DF_P1_LAZYLOAD
;
5730 if (val
& DF_P1_GROUPPERM
)
5732 printf (" GROUPPERM");
5733 val
^= DF_P1_GROUPPERM
;
5736 printf (" %lx", val
);
5745 printf (_("Flags:"));
5746 if (entry
->d_un
.d_val
== 0)
5747 printf (_(" None\n"));
5750 unsigned long int val
= entry
->d_un
.d_val
;
5757 if (val
& DF_1_GLOBAL
)
5762 if (val
& DF_1_GROUP
)
5767 if (val
& DF_1_NODELETE
)
5769 printf (" NODELETE");
5770 val
^= DF_1_NODELETE
;
5772 if (val
& DF_1_LOADFLTR
)
5774 printf (" LOADFLTR");
5775 val
^= DF_1_LOADFLTR
;
5777 if (val
& DF_1_INITFIRST
)
5779 printf (" INITFIRST");
5780 val
^= DF_1_INITFIRST
;
5782 if (val
& DF_1_NOOPEN
)
5787 if (val
& DF_1_ORIGIN
)
5792 if (val
& DF_1_DIRECT
)
5797 if (val
& DF_1_TRANS
)
5802 if (val
& DF_1_INTERPOSE
)
5804 printf (" INTERPOSE");
5805 val
^= DF_1_INTERPOSE
;
5807 if (val
& DF_1_NODEFLIB
)
5809 printf (" NODEFLIB");
5810 val
^= DF_1_NODEFLIB
;
5812 if (val
& DF_1_NODUMP
)
5817 if (val
& DF_1_CONLFAT
)
5819 printf (" CONLFAT");
5820 val
^= DF_1_CONLFAT
;
5823 printf (" %lx", val
);
5830 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5832 puts (get_dynamic_type (entry
->d_un
.d_val
));
5852 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5858 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5859 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5865 switch (entry
->d_tag
)
5868 printf (_("Shared library: [%s]"), name
);
5870 if (streq (name
, program_interpreter
))
5871 printf (_(" program interpreter"));
5875 printf (_("Library soname: [%s]"), name
);
5879 printf (_("Library rpath: [%s]"), name
);
5883 printf (_("Library runpath: [%s]"), name
);
5887 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5892 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5905 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5909 case DT_INIT_ARRAYSZ
:
5910 case DT_FINI_ARRAYSZ
:
5911 case DT_GNU_CONFLICTSZ
:
5912 case DT_GNU_LIBLISTSZ
:
5915 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5916 printf (" (bytes)\n");
5926 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5939 if (entry
->d_tag
== DT_USED
5940 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5942 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5946 printf (_("Not needed object: [%s]\n"), name
);
5951 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5957 /* The value of this entry is ignored. */
5962 case DT_GNU_PRELINKED
:
5966 time_t time
= entry
->d_un
.d_val
;
5968 tmp
= gmtime (&time
);
5969 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5970 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5971 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5977 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5978 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5983 switch (elf_header
.e_machine
)
5986 case EM_MIPS_RS3_LE
:
5987 dynamic_section_mips_val (entry
);
5990 dynamic_section_parisc_val (entry
);
5993 dynamic_section_ia64_val (entry
);
5996 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6008 get_ver_flags (unsigned int flags
)
6010 static char buff
[32];
6017 if (flags
& VER_FLG_BASE
)
6018 strcat (buff
, "BASE ");
6020 if (flags
& VER_FLG_WEAK
)
6022 if (flags
& VER_FLG_BASE
)
6023 strcat (buff
, "| ");
6025 strcat (buff
, "WEAK ");
6028 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6029 strcat (buff
, "| <unknown>");
6034 /* Display the contents of the version sections. */
6036 process_version_sections (FILE *file
)
6038 Elf_Internal_Shdr
*section
;
6045 for (i
= 0, section
= section_headers
;
6046 i
< elf_header
.e_shnum
;
6049 switch (section
->sh_type
)
6051 case SHT_GNU_verdef
:
6053 Elf_External_Verdef
*edefs
;
6060 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6061 SECTION_NAME (section
), section
->sh_info
);
6063 printf (_(" Addr: 0x"));
6064 printf_vma (section
->sh_addr
);
6065 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6066 (unsigned long) section
->sh_offset
, section
->sh_link
,
6067 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6069 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6070 _("version definition section"));
6074 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6077 Elf_External_Verdef
*edef
;
6078 Elf_Internal_Verdef ent
;
6079 Elf_External_Verdaux
*eaux
;
6080 Elf_Internal_Verdaux aux
;
6084 vstart
= ((char *) edefs
) + idx
;
6086 edef
= (Elf_External_Verdef
*) vstart
;
6088 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6089 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6090 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6091 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6092 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6093 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6094 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6096 printf (_(" %#06x: Rev: %d Flags: %s"),
6097 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6099 printf (_(" Index: %d Cnt: %d "),
6100 ent
.vd_ndx
, ent
.vd_cnt
);
6102 vstart
+= ent
.vd_aux
;
6104 eaux
= (Elf_External_Verdaux
*) vstart
;
6106 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6107 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6109 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6110 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6112 printf (_("Name index: %ld\n"), aux
.vda_name
);
6114 isum
= idx
+ ent
.vd_aux
;
6116 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6118 isum
+= aux
.vda_next
;
6119 vstart
+= aux
.vda_next
;
6121 eaux
= (Elf_External_Verdaux
*) vstart
;
6123 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6124 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6126 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6127 printf (_(" %#06x: Parent %d: %s\n"),
6128 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6130 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6131 isum
, j
, aux
.vda_name
);
6141 case SHT_GNU_verneed
:
6143 Elf_External_Verneed
*eneed
;
6149 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6150 SECTION_NAME (section
), section
->sh_info
);
6152 printf (_(" Addr: 0x"));
6153 printf_vma (section
->sh_addr
);
6154 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6155 (unsigned long) section
->sh_offset
, section
->sh_link
,
6156 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6158 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6159 _("version need section"));
6163 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6165 Elf_External_Verneed
*entry
;
6166 Elf_Internal_Verneed ent
;
6171 vstart
= ((char *) eneed
) + idx
;
6173 entry
= (Elf_External_Verneed
*) vstart
;
6175 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6176 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6177 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6178 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6179 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6181 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6183 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6184 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6186 printf (_(" File: %lx"), ent
.vn_file
);
6188 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6190 vstart
+= ent
.vn_aux
;
6192 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6194 Elf_External_Vernaux
*eaux
;
6195 Elf_Internal_Vernaux aux
;
6197 eaux
= (Elf_External_Vernaux
*) vstart
;
6199 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6200 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6201 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6202 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6203 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6205 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6206 printf (_(" %#06x: Name: %s"),
6207 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6209 printf (_(" %#06x: Name index: %lx"),
6210 isum
, aux
.vna_name
);
6212 printf (_(" Flags: %s Version: %d\n"),
6213 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6215 isum
+= aux
.vna_next
;
6216 vstart
+= aux
.vna_next
;
6226 case SHT_GNU_versym
:
6228 Elf_Internal_Shdr
*link_section
;
6231 unsigned char *edata
;
6232 unsigned short *data
;
6234 Elf_Internal_Sym
*symbols
;
6235 Elf_Internal_Shdr
*string_sec
;
6238 link_section
= SECTION_HEADER (section
->sh_link
);
6239 total
= section
->sh_size
/ section
->sh_entsize
;
6243 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6245 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6247 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6248 string_sec
->sh_size
, _("version string table"));
6252 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6253 SECTION_NAME (section
), total
);
6255 printf (_(" Addr: "));
6256 printf_vma (section
->sh_addr
);
6257 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6258 (unsigned long) section
->sh_offset
, section
->sh_link
,
6259 SECTION_NAME (link_section
));
6261 off
= offset_from_vma (file
,
6262 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6263 total
* sizeof (short));
6264 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6265 _("version symbol data"));
6272 data
= malloc (total
* sizeof (short));
6274 for (cnt
= total
; cnt
--;)
6275 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6280 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6283 int check_def
, check_need
;
6286 printf (" %03x:", cnt
);
6288 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6289 switch (data
[cnt
+ j
])
6292 fputs (_(" 0 (*local*) "), stdout
);
6296 fputs (_(" 1 (*global*) "), stdout
);
6300 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6301 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6305 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6308 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6315 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6317 Elf_Internal_Verneed ivn
;
6318 unsigned long offset
;
6320 offset
= offset_from_vma
6321 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6322 sizeof (Elf_External_Verneed
));
6326 Elf_Internal_Vernaux ivna
;
6327 Elf_External_Verneed evn
;
6328 Elf_External_Vernaux evna
;
6329 unsigned long a_off
;
6331 get_data (&evn
, file
, offset
, sizeof (evn
),
6334 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6335 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6337 a_off
= offset
+ ivn
.vn_aux
;
6341 get_data (&evna
, file
, a_off
, sizeof (evna
),
6342 _("version need aux (2)"));
6344 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6345 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6347 a_off
+= ivna
.vna_next
;
6349 while (ivna
.vna_other
!= data
[cnt
+ j
]
6350 && ivna
.vna_next
!= 0);
6352 if (ivna
.vna_other
== data
[cnt
+ j
])
6354 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6356 name
= strtab
+ ivna
.vna_name
;
6357 nn
+= printf ("(%s%-*s",
6359 12 - (int) strlen (name
),
6365 offset
+= ivn
.vn_next
;
6367 while (ivn
.vn_next
);
6370 if (check_def
&& data
[cnt
+ j
] != 0x8001
6371 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6373 Elf_Internal_Verdef ivd
;
6374 Elf_External_Verdef evd
;
6375 unsigned long offset
;
6377 offset
= offset_from_vma
6378 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6383 get_data (&evd
, file
, offset
, sizeof (evd
),
6386 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6387 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6389 offset
+= ivd
.vd_next
;
6391 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6392 && ivd
.vd_next
!= 0);
6394 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6396 Elf_External_Verdaux evda
;
6397 Elf_Internal_Verdaux ivda
;
6399 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6401 get_data (&evda
, file
,
6402 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6403 sizeof (evda
), _("version def aux"));
6405 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6407 name
= strtab
+ ivda
.vda_name
;
6408 nn
+= printf ("(%s%-*s",
6410 12 - (int) strlen (name
),
6416 printf ("%*c", 18 - nn
, ' ');
6434 printf (_("\nNo version information found in this file.\n"));
6440 get_symbol_binding (unsigned int binding
)
6442 static char buff
[32];
6446 case STB_LOCAL
: return "LOCAL";
6447 case STB_GLOBAL
: return "GLOBAL";
6448 case STB_WEAK
: return "WEAK";
6450 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6451 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6453 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6454 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6456 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6462 get_symbol_type (unsigned int type
)
6464 static char buff
[32];
6468 case STT_NOTYPE
: return "NOTYPE";
6469 case STT_OBJECT
: return "OBJECT";
6470 case STT_FUNC
: return "FUNC";
6471 case STT_SECTION
: return "SECTION";
6472 case STT_FILE
: return "FILE";
6473 case STT_COMMON
: return "COMMON";
6474 case STT_TLS
: return "TLS";
6476 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6478 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6479 return "THUMB_FUNC";
6481 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6484 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6485 return "PARISC_MILLI";
6487 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6489 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6491 if (elf_header
.e_machine
== EM_PARISC
)
6493 if (type
== STT_HP_OPAQUE
)
6495 if (type
== STT_HP_STUB
)
6499 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6502 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6508 get_symbol_visibility (unsigned int visibility
)
6512 case STV_DEFAULT
: return "DEFAULT";
6513 case STV_INTERNAL
: return "INTERNAL";
6514 case STV_HIDDEN
: return "HIDDEN";
6515 case STV_PROTECTED
: return "PROTECTED";
6521 get_symbol_index_type (unsigned int type
)
6523 static char buff
[32];
6527 case SHN_UNDEF
: return "UND";
6528 case SHN_ABS
: return "ABS";
6529 case SHN_COMMON
: return "COM";
6531 if (type
== SHN_IA_64_ANSI_COMMON
6532 && elf_header
.e_machine
== EM_IA_64
6533 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6535 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6536 sprintf (buff
, "PRC[0x%04x]", type
);
6537 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6538 sprintf (buff
, "OS [0x%04x]", type
);
6539 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6540 sprintf (buff
, "RSV[0x%04x]", type
);
6542 sprintf (buff
, "%3d", type
);
6550 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6552 unsigned char *e_data
;
6555 e_data
= malloc (number
* ent_size
);
6559 error (_("Out of memory\n"));
6563 if (fread (e_data
, ent_size
, number
, file
) != number
)
6565 error (_("Unable to read in dynamic data\n"));
6569 i_data
= malloc (number
* sizeof (*i_data
));
6573 error (_("Out of memory\n"));
6579 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6586 /* Dump the symbol table. */
6588 process_symbol_table (FILE *file
)
6590 Elf_Internal_Shdr
*section
;
6591 bfd_vma nbuckets
= 0;
6592 bfd_vma nchains
= 0;
6593 bfd_vma
*buckets
= NULL
;
6594 bfd_vma
*chains
= NULL
;
6596 if (! do_syms
&& !do_histogram
)
6599 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6602 unsigned char nb
[8];
6603 unsigned char nc
[8];
6604 int hash_ent_size
= 4;
6606 if ((elf_header
.e_machine
== EM_ALPHA
6607 || elf_header
.e_machine
== EM_S390
6608 || elf_header
.e_machine
== EM_S390_OLD
)
6609 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6613 (archive_file_offset
6614 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6615 sizeof nb
+ sizeof nc
)),
6618 error (_("Unable to seek to start of dynamic information"));
6622 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6624 error (_("Failed to read in number of buckets\n"));
6628 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6630 error (_("Failed to read in number of chains\n"));
6634 nbuckets
= byte_get (nb
, hash_ent_size
);
6635 nchains
= byte_get (nc
, hash_ent_size
);
6637 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6638 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6640 if (buckets
== NULL
|| chains
== NULL
)
6645 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6650 printf (_("\nSymbol table for image:\n"));
6652 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6654 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6656 for (hn
= 0; hn
< nbuckets
; hn
++)
6661 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6663 Elf_Internal_Sym
*psym
;
6666 psym
= dynamic_symbols
+ si
;
6668 n
= print_vma (si
, DEC_5
);
6670 fputs (" " + n
, stdout
);
6671 printf (" %3lu: ", hn
);
6672 print_vma (psym
->st_value
, LONG_HEX
);
6674 print_vma (psym
->st_size
, DEC_5
);
6676 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6677 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6678 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6679 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6680 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6681 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6683 printf (" <corrupt: %14ld>", psym
->st_name
);
6688 else if (do_syms
&& !do_using_dynamic
)
6692 for (i
= 0, section
= section_headers
;
6693 i
< elf_header
.e_shnum
;
6698 Elf_Internal_Sym
*symtab
;
6699 Elf_Internal_Sym
*psym
;
6702 if ( section
->sh_type
!= SHT_SYMTAB
6703 && section
->sh_type
!= SHT_DYNSYM
)
6706 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6707 SECTION_NAME (section
),
6708 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6710 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6712 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6714 symtab
= GET_ELF_SYMBOLS (file
, section
);
6718 if (section
->sh_link
== elf_header
.e_shstrndx
)
6719 strtab
= string_table
;
6722 Elf_Internal_Shdr
*string_sec
;
6724 string_sec
= SECTION_HEADER (section
->sh_link
);
6726 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6727 string_sec
->sh_size
, _("string table"));
6730 for (si
= 0, psym
= symtab
;
6731 si
< section
->sh_size
/ section
->sh_entsize
;
6734 printf ("%6d: ", si
);
6735 print_vma (psym
->st_value
, LONG_HEX
);
6737 print_vma (psym
->st_size
, DEC_5
);
6738 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6739 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6740 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6741 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6742 print_symbol (25, strtab
+ psym
->st_name
);
6744 if (section
->sh_type
== SHT_DYNSYM
&&
6745 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6747 unsigned char data
[2];
6748 unsigned short vers_data
;
6749 unsigned long offset
;
6753 offset
= offset_from_vma
6754 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6755 sizeof data
+ si
* sizeof (vers_data
));
6757 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6758 sizeof (data
), _("version data"));
6760 vers_data
= byte_get (data
, 2);
6762 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6765 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6767 if ((vers_data
& 0x8000) || vers_data
> 1)
6769 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6770 && (is_nobits
|| ! check_def
))
6772 Elf_External_Verneed evn
;
6773 Elf_Internal_Verneed ivn
;
6774 Elf_Internal_Vernaux ivna
;
6776 /* We must test both. */
6777 offset
= offset_from_vma
6778 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6783 unsigned long vna_off
;
6785 get_data (&evn
, file
, offset
, sizeof (evn
),
6788 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6789 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6791 vna_off
= offset
+ ivn
.vn_aux
;
6795 Elf_External_Vernaux evna
;
6797 get_data (&evna
, file
, vna_off
,
6799 _("version need aux (3)"));
6801 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6802 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6803 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6805 vna_off
+= ivna
.vna_next
;
6807 while (ivna
.vna_other
!= vers_data
6808 && ivna
.vna_next
!= 0);
6810 if (ivna
.vna_other
== vers_data
)
6813 offset
+= ivn
.vn_next
;
6815 while (ivn
.vn_next
!= 0);
6817 if (ivna
.vna_other
== vers_data
)
6820 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6823 else if (! is_nobits
)
6824 error (_("bad dynamic symbol"));
6831 if (vers_data
!= 0x8001
6832 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6834 Elf_Internal_Verdef ivd
;
6835 Elf_Internal_Verdaux ivda
;
6836 Elf_External_Verdaux evda
;
6837 unsigned long offset
;
6839 offset
= offset_from_vma
6841 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6842 sizeof (Elf_External_Verdef
));
6846 Elf_External_Verdef evd
;
6848 get_data (&evd
, file
, offset
, sizeof (evd
),
6851 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6852 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6853 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6855 offset
+= ivd
.vd_next
;
6857 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6858 && ivd
.vd_next
!= 0);
6860 offset
-= ivd
.vd_next
;
6861 offset
+= ivd
.vd_aux
;
6863 get_data (&evda
, file
, offset
, sizeof (evda
),
6864 _("version def aux"));
6866 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6868 if (psym
->st_name
!= ivda
.vda_name
)
6869 printf ((vers_data
& 0x8000)
6871 strtab
+ ivda
.vda_name
);
6881 if (strtab
!= string_table
)
6887 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6889 if (do_histogram
&& buckets
!= NULL
)
6891 unsigned long *lengths
;
6892 unsigned long *counts
;
6895 unsigned long maxlength
= 0;
6896 unsigned long nzero_counts
= 0;
6897 unsigned long nsyms
= 0;
6899 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
6900 (unsigned long) nbuckets
);
6901 printf (_(" Length Number %% of total Coverage\n"));
6903 lengths
= calloc (nbuckets
, sizeof (*lengths
));
6904 if (lengths
== NULL
)
6906 error (_("Out of memory"));
6909 for (hn
= 0; hn
< nbuckets
; ++hn
)
6911 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6914 if (maxlength
< ++lengths
[hn
])
6919 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
6922 error (_("Out of memory"));
6926 for (hn
= 0; hn
< nbuckets
; ++hn
)
6927 ++counts
[lengths
[hn
]];
6932 printf (" 0 %-10lu (%5.1f%%)\n",
6933 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6934 for (i
= 1; i
<= maxlength
; ++i
)
6936 nzero_counts
+= counts
[i
] * i
;
6937 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
6938 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
6939 (nzero_counts
* 100.0) / nsyms
);
6947 if (buckets
!= NULL
)
6957 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6961 if (dynamic_syminfo
== NULL
6963 /* No syminfo, this is ok. */
6966 /* There better should be a dynamic symbol section. */
6967 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6971 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6972 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6974 printf (_(" Num: Name BoundTo Flags\n"));
6975 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6977 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6979 printf ("%4d: ", i
);
6980 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6981 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6983 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6986 switch (dynamic_syminfo
[i
].si_boundto
)
6988 case SYMINFO_BT_SELF
:
6989 fputs ("SELF ", stdout
);
6991 case SYMINFO_BT_PARENT
:
6992 fputs ("PARENT ", stdout
);
6995 if (dynamic_syminfo
[i
].si_boundto
> 0
6996 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6997 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6999 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7003 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7007 if (flags
& SYMINFO_FLG_DIRECT
)
7009 if (flags
& SYMINFO_FLG_PASSTHRU
)
7010 printf (" PASSTHRU");
7011 if (flags
& SYMINFO_FLG_COPY
)
7013 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7014 printf (" LAZYLOAD");
7022 #ifdef SUPPORT_DISASSEMBLY
7024 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7026 printf (_("\nAssembly dump of section %s\n"),
7027 SECTION_NAME (section
));
7029 /* XXX -- to be done --- XXX */
7036 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7038 bfd_size_type bytes
;
7040 unsigned char *data
;
7041 unsigned char *start
;
7043 bytes
= section
->sh_size
;
7045 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7047 printf (_("\nSection '%s' has no data to dump.\n"),
7048 SECTION_NAME (section
));
7052 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7054 addr
= section
->sh_addr
;
7056 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
7068 lbytes
= (bytes
> 16 ? 16 : bytes
);
7070 printf (" 0x%8.8lx ", (unsigned long) addr
);
7072 switch (elf_header
.e_ident
[EI_DATA
])
7076 for (j
= 15; j
>= 0; j
--)
7079 printf ("%2.2x", data
[j
]);
7089 for (j
= 0; j
< 16; j
++)
7092 printf ("%2.2x", data
[j
]);
7102 for (j
= 0; j
< lbytes
; j
++)
7105 if (k
>= ' ' && k
< 0x7f)
7124 static unsigned long int
7125 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7127 unsigned long int result
= 0;
7128 unsigned int num_read
= 0;
7129 unsigned int shift
= 0;
7137 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7142 while (byte
& 0x80);
7144 if (length_return
!= NULL
)
7145 *length_return
= num_read
;
7147 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7148 result
|= -1L << shift
;
7153 typedef struct State_Machine_Registers
7155 unsigned long address
;
7158 unsigned int column
;
7162 /* This variable hold the number of the last entry seen
7163 in the File Table. */
7164 unsigned int last_file_entry
;
7167 static SMR state_machine_regs
;
7170 reset_state_machine (int is_stmt
)
7172 state_machine_regs
.address
= 0;
7173 state_machine_regs
.file
= 1;
7174 state_machine_regs
.line
= 1;
7175 state_machine_regs
.column
= 0;
7176 state_machine_regs
.is_stmt
= is_stmt
;
7177 state_machine_regs
.basic_block
= 0;
7178 state_machine_regs
.end_sequence
= 0;
7179 state_machine_regs
.last_file_entry
= 0;
7182 /* Handled an extend line op.
7183 Returns the number of bytes read. */
7186 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7188 unsigned char op_code
;
7189 unsigned int bytes_read
;
7191 unsigned char *name
;
7194 len
= read_leb128 (data
, & bytes_read
, 0);
7199 warn (_("badly formed extended line op encountered!\n"));
7206 printf (_(" Extended opcode %d: "), op_code
);
7210 case DW_LNE_end_sequence
:
7211 printf (_("End of Sequence\n\n"));
7212 reset_state_machine (is_stmt
);
7215 case DW_LNE_set_address
:
7216 adr
= byte_get (data
, pointer_size
);
7217 printf (_("set Address to 0x%lx\n"), adr
);
7218 state_machine_regs
.address
= adr
;
7221 case DW_LNE_define_file
:
7222 printf (_(" define new File Table entry\n"));
7223 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7225 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7227 data
+= strlen ((char *) data
) + 1;
7228 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7230 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7232 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7233 printf (_("%s\n\n"), name
);
7237 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7244 static const char *debug_str_contents
;
7245 static bfd_vma debug_str_size
;
7248 load_debug_str (FILE *file
)
7250 Elf_Internal_Shdr
*sec
;
7252 /* If it is already loaded, do nothing. */
7253 if (debug_str_contents
!= NULL
)
7256 /* Locate the .debug_str section. */
7257 sec
= find_section (".debug_str");
7261 debug_str_size
= sec
->sh_size
;
7263 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7264 _("debug_str section data"));
7268 free_debug_str (void)
7270 if (debug_str_contents
== NULL
)
7273 free ((char *) debug_str_contents
);
7274 debug_str_contents
= NULL
;
7279 fetch_indirect_string (unsigned long offset
)
7281 if (debug_str_contents
== NULL
)
7282 return _("<no .debug_str section>");
7284 if (offset
> debug_str_size
)
7286 warn (_("DW_FORM_strp offset too big: %x\n"), offset
);
7287 return _("<offset is too big>");
7290 return debug_str_contents
+ offset
;
7293 static const char *debug_loc_contents
;
7294 static bfd_vma debug_loc_size
;
7297 load_debug_loc (FILE *file
)
7299 Elf_Internal_Shdr
*sec
;
7301 /* If it is already loaded, do nothing. */
7302 if (debug_loc_contents
!= NULL
)
7305 /* Locate the .debug_loc section. */
7306 sec
= find_section (".debug_loc");
7310 debug_loc_size
= sec
->sh_size
;
7312 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7313 _("debug_loc section data"));
7317 free_debug_loc (void)
7319 if (debug_loc_contents
== NULL
)
7322 free ((char *) debug_loc_contents
);
7323 debug_loc_contents
= NULL
;
7327 static const char * debug_range_contents
;
7328 static unsigned long debug_range_size
;
7331 load_debug_range (FILE *file
)
7333 Elf_Internal_Shdr
*sec
;
7335 /* If it is already loaded, do nothing. */
7336 if (debug_range_contents
!= NULL
)
7339 /* Locate the .debug_ranges section. */
7340 sec
= find_section (".debug_ranges");
7344 debug_range_size
= sec
->sh_size
;
7346 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7347 _("debug_range section data"));
7351 free_debug_range (void)
7353 if (debug_range_contents
== NULL
)
7356 free ((char *) debug_range_contents
);
7357 debug_range_contents
= NULL
;
7358 debug_range_size
= 0;
7361 /* Apply addends of RELA relocations. */
7364 debug_apply_rela_addends (FILE *file
,
7365 Elf_Internal_Shdr
*section
,
7367 unsigned char *sec_data
,
7368 unsigned char *start
,
7371 Elf_Internal_Shdr
*relsec
;
7373 if (end
- start
< reloc_size
)
7376 for (relsec
= section_headers
;
7377 relsec
< section_headers
+ elf_header
.e_shnum
;
7380 unsigned long nrelas
;
7381 Elf_Internal_Rela
*rela
, *rp
;
7382 Elf_Internal_Shdr
*symsec
;
7383 Elf_Internal_Sym
*symtab
;
7384 Elf_Internal_Sym
*sym
;
7386 if (relsec
->sh_type
!= SHT_RELA
7387 || SECTION_HEADER (relsec
->sh_info
) != section
7388 || relsec
->sh_size
== 0)
7391 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7395 symsec
= SECTION_HEADER (relsec
->sh_link
);
7396 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7398 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7402 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7403 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7404 loc
= sec_data
+ rp
->r_offset
;
7410 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7412 if (ELF32_R_SYM (rp
->r_info
) != 0
7413 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7414 /* Relocations against object symbols can happen,
7415 eg when referencing a global array. For an
7416 example of this see the _clz.o binary in libgcc.a. */
7417 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7419 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7420 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7421 SECTION_NAME (section
));
7427 /* In MIPS little-endian objects, r_info isn't really a
7428 64-bit little-endian value: it has a 32-bit little-endian
7429 symbol index followed by four individual byte fields.
7430 Reorder INFO accordingly. */
7431 if (elf_header
.e_machine
== EM_MIPS
7432 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7433 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7434 | ((rp
->r_info
>> 56) & 0xff)
7435 | ((rp
->r_info
>> 40) & 0xff00)
7436 | ((rp
->r_info
>> 24) & 0xff0000)
7437 | ((rp
->r_info
>> 8) & 0xff000000));
7439 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7441 if (ELF64_R_SYM (rp
->r_info
) != 0
7442 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7443 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7445 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7446 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7447 SECTION_NAME (section
));
7452 byte_put (loc
, rp
->r_addend
, reloc_size
);
7462 /* FIXME: There are better and more efficient ways to handle
7463 these structures. For now though, I just want something that
7464 is simple to implement. */
7465 typedef struct abbrev_attr
7467 unsigned long attribute
;
7469 struct abbrev_attr
*next
;
7473 typedef struct abbrev_entry
7475 unsigned long entry
;
7478 struct abbrev_attr
*first_attr
;
7479 struct abbrev_attr
*last_attr
;
7480 struct abbrev_entry
*next
;
7484 static abbrev_entry
*first_abbrev
= NULL
;
7485 static abbrev_entry
*last_abbrev
= NULL
;
7490 abbrev_entry
*abbrev
;
7492 for (abbrev
= first_abbrev
; abbrev
;)
7494 abbrev_entry
*next
= abbrev
->next
;
7497 for (attr
= abbrev
->first_attr
; attr
;)
7499 abbrev_attr
*next
= attr
->next
;
7509 last_abbrev
= first_abbrev
= NULL
;
7513 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7515 abbrev_entry
*entry
;
7517 entry
= malloc (sizeof (*entry
));
7523 entry
->entry
= number
;
7525 entry
->children
= children
;
7526 entry
->first_attr
= NULL
;
7527 entry
->last_attr
= NULL
;
7530 if (first_abbrev
== NULL
)
7531 first_abbrev
= entry
;
7533 last_abbrev
->next
= entry
;
7535 last_abbrev
= entry
;
7539 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7543 attr
= malloc (sizeof (*attr
));
7549 attr
->attribute
= attribute
;
7553 if (last_abbrev
->first_attr
== NULL
)
7554 last_abbrev
->first_attr
= attr
;
7556 last_abbrev
->last_attr
->next
= attr
;
7558 last_abbrev
->last_attr
= attr
;
7561 /* Processes the (partial) contents of a .debug_abbrev section.
7562 Returns NULL if the end of the section was encountered.
7563 Returns the address after the last byte read if the end of
7564 an abbreviation set was found. */
7566 static unsigned char *
7567 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7569 if (first_abbrev
!= NULL
)
7574 unsigned int bytes_read
;
7575 unsigned long entry
;
7577 unsigned long attribute
;
7580 entry
= read_leb128 (start
, & bytes_read
, 0);
7581 start
+= bytes_read
;
7583 /* A single zero is supposed to end the section according
7584 to the standard. If there's more, then signal that to
7587 return start
== end
? NULL
: start
;
7589 tag
= read_leb128 (start
, & bytes_read
, 0);
7590 start
+= bytes_read
;
7592 children
= *start
++;
7594 add_abbrev (entry
, tag
, children
);
7600 attribute
= read_leb128 (start
, & bytes_read
, 0);
7601 start
+= bytes_read
;
7603 form
= read_leb128 (start
, & bytes_read
, 0);
7604 start
+= bytes_read
;
7607 add_abbrev_attr (attribute
, form
);
7609 while (attribute
!= 0);
7616 get_TAG_name (unsigned long tag
)
7620 case DW_TAG_padding
: return "DW_TAG_padding";
7621 case DW_TAG_array_type
: return "DW_TAG_array_type";
7622 case DW_TAG_class_type
: return "DW_TAG_class_type";
7623 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7624 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7625 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7626 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7627 case DW_TAG_label
: return "DW_TAG_label";
7628 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7629 case DW_TAG_member
: return "DW_TAG_member";
7630 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7631 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7632 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7633 case DW_TAG_string_type
: return "DW_TAG_string_type";
7634 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7635 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7636 case DW_TAG_typedef
: return "DW_TAG_typedef";
7637 case DW_TAG_union_type
: return "DW_TAG_union_type";
7638 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7639 case DW_TAG_variant
: return "DW_TAG_variant";
7640 case DW_TAG_common_block
: return "DW_TAG_common_block";
7641 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7642 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7643 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7644 case DW_TAG_module
: return "DW_TAG_module";
7645 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7646 case DW_TAG_set_type
: return "DW_TAG_set_type";
7647 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7648 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7649 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7650 case DW_TAG_base_type
: return "DW_TAG_base_type";
7651 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7652 case DW_TAG_const_type
: return "DW_TAG_const_type";
7653 case DW_TAG_constant
: return "DW_TAG_constant";
7654 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7655 case DW_TAG_file_type
: return "DW_TAG_file_type";
7656 case DW_TAG_friend
: return "DW_TAG_friend";
7657 case DW_TAG_namelist
: return "DW_TAG_namelist";
7658 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7659 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7660 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7661 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7662 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7663 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7664 case DW_TAG_try_block
: return "DW_TAG_try_block";
7665 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7666 case DW_TAG_variable
: return "DW_TAG_variable";
7667 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7668 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7669 case DW_TAG_format_label
: return "DW_TAG_format_label";
7670 case DW_TAG_function_template
: return "DW_TAG_function_template";
7671 case DW_TAG_class_template
: return "DW_TAG_class_template";
7672 /* DWARF 2.1 values. */
7673 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7674 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7675 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7676 case DW_TAG_namespace
: return "DW_TAG_namespace";
7677 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7678 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7679 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7680 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7682 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7683 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7684 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7687 static char buffer
[100];
7689 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
7696 get_FORM_name (unsigned long form
)
7700 case DW_FORM_addr
: return "DW_FORM_addr";
7701 case DW_FORM_block2
: return "DW_FORM_block2";
7702 case DW_FORM_block4
: return "DW_FORM_block4";
7703 case DW_FORM_data2
: return "DW_FORM_data2";
7704 case DW_FORM_data4
: return "DW_FORM_data4";
7705 case DW_FORM_data8
: return "DW_FORM_data8";
7706 case DW_FORM_string
: return "DW_FORM_string";
7707 case DW_FORM_block
: return "DW_FORM_block";
7708 case DW_FORM_block1
: return "DW_FORM_block1";
7709 case DW_FORM_data1
: return "DW_FORM_data1";
7710 case DW_FORM_flag
: return "DW_FORM_flag";
7711 case DW_FORM_sdata
: return "DW_FORM_sdata";
7712 case DW_FORM_strp
: return "DW_FORM_strp";
7713 case DW_FORM_udata
: return "DW_FORM_udata";
7714 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7715 case DW_FORM_ref1
: return "DW_FORM_ref1";
7716 case DW_FORM_ref2
: return "DW_FORM_ref2";
7717 case DW_FORM_ref4
: return "DW_FORM_ref4";
7718 case DW_FORM_ref8
: return "DW_FORM_ref8";
7719 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7720 case DW_FORM_indirect
: return "DW_FORM_indirect";
7723 static char buffer
[100];
7725 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
7731 static unsigned char *
7732 display_block (unsigned char *data
, unsigned long length
)
7734 printf (_(" %lu byte block: "), length
);
7737 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7743 decode_location_expression (unsigned char * data
,
7744 unsigned int pointer_size
,
7745 unsigned long length
,
7746 unsigned long cu_offset
)
7749 unsigned int bytes_read
;
7750 unsigned long uvalue
;
7751 unsigned char *end
= data
+ length
;
7752 int need_frame_base
= 0;
7761 printf ("DW_OP_addr: %lx",
7762 (unsigned long) byte_get (data
, pointer_size
));
7763 data
+= pointer_size
;
7766 printf ("DW_OP_deref");
7769 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7772 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7775 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7779 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7783 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7787 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7791 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7792 (unsigned long) byte_get (data
+ 4, 4));
7796 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7797 (long) byte_get (data
+ 4, 4));
7801 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7805 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7809 printf ("DW_OP_dup");
7812 printf ("DW_OP_drop");
7815 printf ("DW_OP_over");
7818 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7821 printf ("DW_OP_swap");
7824 printf ("DW_OP_rot");
7827 printf ("DW_OP_xderef");
7830 printf ("DW_OP_abs");
7833 printf ("DW_OP_and");
7836 printf ("DW_OP_div");
7839 printf ("DW_OP_minus");
7842 printf ("DW_OP_mod");
7845 printf ("DW_OP_mul");
7848 printf ("DW_OP_neg");
7851 printf ("DW_OP_not");
7854 printf ("DW_OP_or");
7857 printf ("DW_OP_plus");
7859 case DW_OP_plus_uconst
:
7860 printf ("DW_OP_plus_uconst: %lu",
7861 read_leb128 (data
, &bytes_read
, 0));
7865 printf ("DW_OP_shl");
7868 printf ("DW_OP_shr");
7871 printf ("DW_OP_shra");
7874 printf ("DW_OP_xor");
7877 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7881 printf ("DW_OP_eq");
7884 printf ("DW_OP_ge");
7887 printf ("DW_OP_gt");
7890 printf ("DW_OP_le");
7893 printf ("DW_OP_lt");
7896 printf ("DW_OP_ne");
7899 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7935 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7970 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8005 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8006 read_leb128 (data
, &bytes_read
, 1));
8011 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8015 need_frame_base
= 1;
8016 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8020 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8022 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8023 read_leb128 (data
, &bytes_read
, 1));
8027 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8030 case DW_OP_deref_size
:
8031 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8033 case DW_OP_xderef_size
:
8034 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8037 printf ("DW_OP_nop");
8040 /* DWARF 3 extensions. */
8041 case DW_OP_push_object_address
:
8042 printf ("DW_OP_push_object_address");
8045 /* XXX: Strictly speaking for 64-bit DWARF3 files
8046 this ought to be an 8-byte wide computation. */
8047 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8051 /* XXX: Strictly speaking for 64-bit DWARF3 files
8052 this ought to be an 8-byte wide computation. */
8053 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8056 case DW_OP_call_ref
:
8057 printf ("DW_OP_call_ref");
8060 /* GNU extensions. */
8061 case DW_OP_GNU_push_tls_address
:
8062 printf ("DW_OP_GNU_push_tls_address");
8066 if (op
>= DW_OP_lo_user
8067 && op
<= DW_OP_hi_user
)
8068 printf (_("(User defined location op)"));
8070 printf (_("(Unknown location op)"));
8071 /* No way to tell where the next op is, so just bail. */
8072 return need_frame_base
;
8075 /* Separate the ops. */
8080 return need_frame_base
;
8083 /* This structure records the information that
8084 we extract from the.debug_info section. */
8087 unsigned int pointer_size
;
8088 unsigned long cu_offset
;
8089 unsigned long base_address
;
8090 /* This is an array of offsets to the location list table. */
8091 unsigned long *loc_offsets
;
8092 int *have_frame_base
;
8093 unsigned int num_loc_offsets
;
8094 unsigned int max_loc_offsets
;
8095 unsigned long *range_lists
;
8096 unsigned int num_range_lists
;
8097 unsigned int max_range_lists
;
8101 static debug_info
* debug_information
= NULL
;
8102 static unsigned int num_debug_info_entries
= 0;
8103 static unsigned int last_pointer_size
= 0;
8104 static int warned_about_missing_comp_units
= FALSE
;
8106 static unsigned char *
8107 read_and_display_attr_value (unsigned long attribute
,
8109 unsigned char *data
,
8110 unsigned long cu_offset
,
8111 unsigned long pointer_size
,
8112 unsigned long offset_size
,
8114 debug_info
*debug_info_p
,
8117 unsigned long uvalue
= 0;
8118 unsigned char *block_start
= NULL
;
8119 unsigned int bytes_read
;
8126 case DW_FORM_ref_addr
:
8127 if (dwarf_version
== 2)
8129 uvalue
= byte_get (data
, pointer_size
);
8130 data
+= pointer_size
;
8132 else if (dwarf_version
== 3)
8134 uvalue
= byte_get (data
, offset_size
);
8135 data
+= offset_size
;
8139 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8144 uvalue
= byte_get (data
, pointer_size
);
8145 data
+= pointer_size
;
8149 uvalue
= byte_get (data
, offset_size
);
8150 data
+= offset_size
;
8156 uvalue
= byte_get (data
++, 1);
8161 uvalue
= byte_get (data
, 2);
8167 uvalue
= byte_get (data
, 4);
8172 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8176 case DW_FORM_ref_udata
:
8178 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8182 case DW_FORM_indirect
:
8183 form
= read_leb128 (data
, & bytes_read
, 0);
8186 printf (" %s", get_FORM_name (form
));
8187 return read_and_display_attr_value (attribute
, form
, data
,
8188 cu_offset
, pointer_size
,
8189 offset_size
, dwarf_version
,
8190 debug_info_p
, do_loc
);
8195 case DW_FORM_ref_addr
:
8197 printf (" <#%lx>", uvalue
);
8203 case DW_FORM_ref_udata
:
8205 printf (" <%lx>", uvalue
+ cu_offset
);
8211 printf (" %#lx", uvalue
);
8220 printf (" %ld", uvalue
);
8227 uvalue
= byte_get (data
, 4);
8228 printf (" %lx", uvalue
);
8229 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8231 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8232 && num_debug_info_entries
== 0)
8234 if (sizeof (uvalue
) == 8)
8235 uvalue
= byte_get (data
, 8);
8237 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8242 case DW_FORM_string
:
8244 printf (" %s", data
);
8245 data
+= strlen ((char *) data
) + 1;
8249 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8250 block_start
= data
+ bytes_read
;
8252 data
= block_start
+ uvalue
;
8254 data
= display_block (block_start
, uvalue
);
8257 case DW_FORM_block1
:
8258 uvalue
= byte_get (data
, 1);
8259 block_start
= data
+ 1;
8261 data
= block_start
+ uvalue
;
8263 data
= display_block (block_start
, uvalue
);
8266 case DW_FORM_block2
:
8267 uvalue
= byte_get (data
, 2);
8268 block_start
= data
+ 2;
8270 data
= block_start
+ uvalue
;
8272 data
= display_block (block_start
, uvalue
);
8275 case DW_FORM_block4
:
8276 uvalue
= byte_get (data
, 4);
8277 block_start
= data
+ 4;
8279 data
= block_start
+ uvalue
;
8281 data
= display_block (block_start
, uvalue
);
8286 printf (_(" (indirect string, offset: 0x%lx): %s"),
8287 uvalue
, fetch_indirect_string (uvalue
));
8290 case DW_FORM_indirect
:
8291 /* Handled above. */
8295 warn (_("Unrecognized form: %d\n"), form
);
8299 /* For some attributes we can display further information. */
8300 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8301 && num_debug_info_entries
== 0)
8305 case DW_AT_frame_base
:
8306 have_frame_base
= 1;
8307 case DW_AT_location
:
8308 case DW_AT_data_member_location
:
8309 case DW_AT_vtable_elem_location
:
8310 case DW_AT_allocated
:
8311 case DW_AT_associated
:
8312 case DW_AT_data_location
:
8314 case DW_AT_upper_bound
:
8315 case DW_AT_lower_bound
:
8316 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8318 /* Process location list. */
8319 unsigned int max
= debug_info_p
->max_loc_offsets
;
8320 unsigned int num
= debug_info_p
->num_loc_offsets
;
8322 if (max
== 0 || num
>= max
)
8325 debug_info_p
->loc_offsets
8326 = xrealloc (debug_info_p
->loc_offsets
,
8327 max
* sizeof (*debug_info_p
->loc_offsets
));
8328 debug_info_p
->have_frame_base
8329 = xrealloc (debug_info_p
->have_frame_base
,
8330 max
* sizeof (*debug_info_p
->have_frame_base
));
8331 debug_info_p
->max_loc_offsets
= max
;
8333 debug_info_p
->loc_offsets
[num
] = uvalue
;
8334 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8335 debug_info_p
->num_loc_offsets
++;
8340 if (need_base_address
)
8341 debug_info_p
->base_address
= uvalue
;
8345 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8347 /* Process range list. */
8348 unsigned int max
= debug_info_p
->max_range_lists
;
8349 unsigned int num
= debug_info_p
->num_range_lists
;
8351 if (max
== 0 || num
>= max
)
8354 debug_info_p
->range_lists
8355 = xrealloc (debug_info_p
->range_lists
,
8356 max
* sizeof (*debug_info_p
->range_lists
));
8357 debug_info_p
->max_range_lists
= max
;
8359 debug_info_p
->range_lists
[num
] = uvalue
;
8360 debug_info_p
->num_range_lists
++;
8379 case DW_INL_not_inlined
:
8380 printf (_("(not inlined)"));
8382 case DW_INL_inlined
:
8383 printf (_("(inlined)"));
8385 case DW_INL_declared_not_inlined
:
8386 printf (_("(declared as inline but ignored)"));
8388 case DW_INL_declared_inlined
:
8389 printf (_("(declared as inline and inlined)"));
8392 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8397 case DW_AT_language
:
8400 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8401 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8402 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8403 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8404 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8405 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8406 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8407 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8408 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8409 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8410 /* DWARF 2.1 values. */
8411 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8412 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8413 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8414 /* MIPS extension. */
8415 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8416 /* UPC extension. */
8417 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8419 printf ("(Unknown: %lx)", uvalue
);
8424 case DW_AT_encoding
:
8427 case DW_ATE_void
: printf ("(void)"); break;
8428 case DW_ATE_address
: printf ("(machine address)"); break;
8429 case DW_ATE_boolean
: printf ("(boolean)"); break;
8430 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8431 case DW_ATE_float
: printf ("(float)"); break;
8432 case DW_ATE_signed
: printf ("(signed)"); break;
8433 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8434 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8435 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8436 /* DWARF 2.1 value. */
8437 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8438 /* GNU extension. */
8439 case DW_ATE_GNU_decimal_float
: printf ("(decimal float)"); break;
8441 if (uvalue
>= DW_ATE_lo_user
8442 && uvalue
<= DW_ATE_hi_user
)
8443 printf ("(user defined type)");
8445 printf ("(unknown type)");
8450 case DW_AT_accessibility
:
8453 case DW_ACCESS_public
: printf ("(public)"); break;
8454 case DW_ACCESS_protected
: printf ("(protected)"); break;
8455 case DW_ACCESS_private
: printf ("(private)"); break;
8457 printf ("(unknown accessibility)");
8462 case DW_AT_visibility
:
8465 case DW_VIS_local
: printf ("(local)"); break;
8466 case DW_VIS_exported
: printf ("(exported)"); break;
8467 case DW_VIS_qualified
: printf ("(qualified)"); break;
8468 default: printf ("(unknown visibility)"); break;
8472 case DW_AT_virtuality
:
8475 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8476 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8477 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8478 default: printf ("(unknown virtuality)"); break;
8482 case DW_AT_identifier_case
:
8485 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8486 case DW_ID_up_case
: printf ("(up_case)"); break;
8487 case DW_ID_down_case
: printf ("(down_case)"); break;
8488 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8489 default: printf ("(unknown case)"); break;
8493 case DW_AT_calling_convention
:
8496 case DW_CC_normal
: printf ("(normal)"); break;
8497 case DW_CC_program
: printf ("(program)"); break;
8498 case DW_CC_nocall
: printf ("(nocall)"); break;
8500 if (uvalue
>= DW_CC_lo_user
8501 && uvalue
<= DW_CC_hi_user
)
8502 printf ("(user defined)");
8504 printf ("(unknown convention)");
8508 case DW_AT_ordering
:
8511 case -1: printf ("(undefined)"); break;
8512 case 0: printf ("(row major)"); break;
8513 case 1: printf ("(column major)"); break;
8517 case DW_AT_frame_base
:
8518 have_frame_base
= 1;
8519 case DW_AT_location
:
8520 case DW_AT_data_member_location
:
8521 case DW_AT_vtable_elem_location
:
8522 case DW_AT_allocated
:
8523 case DW_AT_associated
:
8524 case DW_AT_data_location
:
8526 case DW_AT_upper_bound
:
8527 case DW_AT_lower_bound
:
8530 int need_frame_base
;
8533 need_frame_base
= decode_location_expression (block_start
,
8538 if (need_frame_base
&& !have_frame_base
)
8539 printf (_(" [without DW_AT_frame_base]"));
8541 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8542 printf (_("(location list)"));
8554 get_AT_name (unsigned long attribute
)
8558 case DW_AT_sibling
: return "DW_AT_sibling";
8559 case DW_AT_location
: return "DW_AT_location";
8560 case DW_AT_name
: return "DW_AT_name";
8561 case DW_AT_ordering
: return "DW_AT_ordering";
8562 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8563 case DW_AT_byte_size
: return "DW_AT_byte_size";
8564 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8565 case DW_AT_bit_size
: return "DW_AT_bit_size";
8566 case DW_AT_element_list
: return "DW_AT_element_list";
8567 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8568 case DW_AT_low_pc
: return "DW_AT_low_pc";
8569 case DW_AT_high_pc
: return "DW_AT_high_pc";
8570 case DW_AT_language
: return "DW_AT_language";
8571 case DW_AT_member
: return "DW_AT_member";
8572 case DW_AT_discr
: return "DW_AT_discr";
8573 case DW_AT_discr_value
: return "DW_AT_discr_value";
8574 case DW_AT_visibility
: return "DW_AT_visibility";
8575 case DW_AT_import
: return "DW_AT_import";
8576 case DW_AT_string_length
: return "DW_AT_string_length";
8577 case DW_AT_common_reference
: return "DW_AT_common_reference";
8578 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8579 case DW_AT_const_value
: return "DW_AT_const_value";
8580 case DW_AT_containing_type
: return "DW_AT_containing_type";
8581 case DW_AT_default_value
: return "DW_AT_default_value";
8582 case DW_AT_inline
: return "DW_AT_inline";
8583 case DW_AT_is_optional
: return "DW_AT_is_optional";
8584 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8585 case DW_AT_producer
: return "DW_AT_producer";
8586 case DW_AT_prototyped
: return "DW_AT_prototyped";
8587 case DW_AT_return_addr
: return "DW_AT_return_addr";
8588 case DW_AT_start_scope
: return "DW_AT_start_scope";
8589 case DW_AT_stride_size
: return "DW_AT_stride_size";
8590 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8591 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8592 case DW_AT_accessibility
: return "DW_AT_accessibility";
8593 case DW_AT_address_class
: return "DW_AT_address_class";
8594 case DW_AT_artificial
: return "DW_AT_artificial";
8595 case DW_AT_base_types
: return "DW_AT_base_types";
8596 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8597 case DW_AT_count
: return "DW_AT_count";
8598 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8599 case DW_AT_decl_column
: return "DW_AT_decl_column";
8600 case DW_AT_decl_file
: return "DW_AT_decl_file";
8601 case DW_AT_decl_line
: return "DW_AT_decl_line";
8602 case DW_AT_declaration
: return "DW_AT_declaration";
8603 case DW_AT_discr_list
: return "DW_AT_discr_list";
8604 case DW_AT_encoding
: return "DW_AT_encoding";
8605 case DW_AT_external
: return "DW_AT_external";
8606 case DW_AT_frame_base
: return "DW_AT_frame_base";
8607 case DW_AT_friend
: return "DW_AT_friend";
8608 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8609 case DW_AT_macro_info
: return "DW_AT_macro_info";
8610 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8611 case DW_AT_priority
: return "DW_AT_priority";
8612 case DW_AT_segment
: return "DW_AT_segment";
8613 case DW_AT_specification
: return "DW_AT_specification";
8614 case DW_AT_static_link
: return "DW_AT_static_link";
8615 case DW_AT_type
: return "DW_AT_type";
8616 case DW_AT_use_location
: return "DW_AT_use_location";
8617 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8618 case DW_AT_virtuality
: return "DW_AT_virtuality";
8619 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8620 /* DWARF 2.1 values. */
8621 case DW_AT_allocated
: return "DW_AT_allocated";
8622 case DW_AT_associated
: return "DW_AT_associated";
8623 case DW_AT_data_location
: return "DW_AT_data_location";
8624 case DW_AT_stride
: return "DW_AT_stride";
8625 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8626 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8627 case DW_AT_extension
: return "DW_AT_extension";
8628 case DW_AT_ranges
: return "DW_AT_ranges";
8629 case DW_AT_trampoline
: return "DW_AT_trampoline";
8630 case DW_AT_call_column
: return "DW_AT_call_column";
8631 case DW_AT_call_file
: return "DW_AT_call_file";
8632 case DW_AT_call_line
: return "DW_AT_call_line";
8633 /* SGI/MIPS extensions. */
8634 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8635 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8636 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8637 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8638 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8639 case DW_AT_MIPS_software_pipeline_depth
:
8640 return "DW_AT_MIPS_software_pipeline_depth";
8641 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8642 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8643 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8644 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8645 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8646 /* GNU extensions. */
8647 case DW_AT_sf_names
: return "DW_AT_sf_names";
8648 case DW_AT_src_info
: return "DW_AT_src_info";
8649 case DW_AT_mac_info
: return "DW_AT_mac_info";
8650 case DW_AT_src_coords
: return "DW_AT_src_coords";
8651 case DW_AT_body_begin
: return "DW_AT_body_begin";
8652 case DW_AT_body_end
: return "DW_AT_body_end";
8653 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8654 /* UPC extension. */
8655 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8658 static char buffer
[100];
8660 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8667 static unsigned char *
8668 read_and_display_attr (unsigned long attribute
,
8670 unsigned char *data
,
8671 unsigned long cu_offset
,
8672 unsigned long pointer_size
,
8673 unsigned long offset_size
,
8675 debug_info
*debug_info_p
,
8679 printf (" %-18s:", get_AT_name (attribute
));
8680 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8681 pointer_size
, offset_size
,
8682 dwarf_version
, debug_info_p
,
8690 /* Process the contents of a .debug_info section. If do_loc is non-zero
8691 then we are scanning for location lists and we do not want to display
8692 anything to the user. */
8695 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8696 FILE *file
, int do_loc
)
8698 unsigned char *end
= start
+ section
->sh_size
;
8699 unsigned char *section_begin
;
8701 unsigned int num_units
= 0;
8703 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8704 && num_debug_info_entries
== 0)
8706 unsigned long length
;
8708 /* First scan the section to get the number of comp units. */
8709 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8712 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8713 will be the length. For a 64-bit DWARF section, it'll be
8714 the escape code 0xffffffff followed by an 8 byte length. */
8715 length
= byte_get (section_begin
, 4);
8717 if (length
== 0xffffffff)
8719 length
= byte_get (section_begin
+ 4, 8);
8720 section_begin
+= length
+ 12;
8723 section_begin
+= length
+ 4;
8728 error (_("No comp units in .debug_info section ?"));
8732 /* Then allocate an array to hold the information. */
8733 debug_information
= malloc (num_units
*
8734 sizeof (* debug_information
));
8735 if (debug_information
== NULL
)
8737 error (_("Not enough memory for a debug info array of %u entries"),
8745 printf (_("The section %s contains:\n\n"),
8746 SECTION_NAME (section
));
8748 load_debug_str (file
);
8749 load_debug_loc (file
);
8750 load_debug_range (file
);
8753 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8755 DWARF2_Internal_CompUnit compunit
;
8756 unsigned char *hdrptr
;
8757 unsigned char *cu_abbrev_offset_ptr
;
8758 unsigned char *tags
;
8760 unsigned long cu_offset
;
8762 int initial_length_size
;
8766 compunit
.cu_length
= byte_get (hdrptr
, 4);
8769 if (compunit
.cu_length
== 0xffffffff)
8771 compunit
.cu_length
= byte_get (hdrptr
, 8);
8774 initial_length_size
= 12;
8779 initial_length_size
= 4;
8782 compunit
.cu_version
= byte_get (hdrptr
, 2);
8785 cu_offset
= start
- section_begin
;
8786 start
+= compunit
.cu_length
+ initial_length_size
;
8788 if (elf_header
.e_type
== ET_REL
8789 && !debug_apply_rela_addends (file
, section
, offset_size
,
8790 section_begin
, hdrptr
, start
))
8793 cu_abbrev_offset_ptr
= hdrptr
;
8794 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8795 hdrptr
+= offset_size
;
8797 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8799 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8800 && num_debug_info_entries
== 0)
8802 debug_information
[unit
].cu_offset
= cu_offset
;
8803 debug_information
[unit
].pointer_size
8804 = compunit
.cu_pointer_size
;
8805 debug_information
[unit
].base_address
= 0;
8806 debug_information
[unit
].loc_offsets
= NULL
;
8807 debug_information
[unit
].have_frame_base
= NULL
;
8808 debug_information
[unit
].max_loc_offsets
= 0;
8809 debug_information
[unit
].num_loc_offsets
= 0;
8810 debug_information
[unit
].range_lists
= NULL
;
8811 debug_information
[unit
].max_range_lists
= 0;
8812 debug_information
[unit
].num_range_lists
= 0;
8819 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
8820 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8821 printf (_(" Version: %d\n"), compunit
.cu_version
);
8822 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8823 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8826 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8828 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8834 /* Read in the abbrevs used by this compilation unit. */
8836 Elf_Internal_Shdr
*sec
;
8837 unsigned char *begin
;
8839 /* Locate the .debug_abbrev section and process it. */
8840 sec
= find_section (".debug_abbrev");
8843 warn (_("Unable to locate .debug_abbrev section!\n"));
8847 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8848 _("debug_abbrev section data"));
8852 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8853 begin
+ sec
->sh_size
);
8859 while (tags
< start
)
8861 unsigned int bytes_read
;
8862 unsigned long abbrev_number
;
8863 abbrev_entry
*entry
;
8866 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8869 /* A null DIE marks the end of a list of children. */
8870 if (abbrev_number
== 0)
8876 /* Scan through the abbreviation list until we reach the
8878 for (entry
= first_abbrev
;
8879 entry
&& entry
->entry
!= abbrev_number
;
8880 entry
= entry
->next
)
8885 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8891 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8893 (unsigned long) (tags
- section_begin
8896 get_TAG_name (entry
->tag
));
8901 need_base_address
= 0;
8903 case DW_TAG_compile_unit
:
8904 need_base_address
= 1;
8906 case DW_TAG_entry_point
:
8907 case DW_TAG_inlined_subroutine
:
8908 case DW_TAG_subprogram
:
8909 need_base_address
= 0;
8910 /* Assuming that there is no DW_AT_frame_base. */
8911 have_frame_base
= 0;
8915 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8916 tags
= read_and_display_attr (attr
->attribute
,
8919 compunit
.cu_pointer_size
,
8921 compunit
.cu_version
,
8922 &debug_information
[unit
],
8925 if (entry
->children
)
8930 /* Set num_debug_info_entries here so that it can be used to check if
8931 we need to process .debug_loc and .debug_ranges sections. */
8932 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8933 && num_debug_info_entries
== 0)
8934 num_debug_info_entries
= num_units
;
8938 free_debug_range ();
8948 /* Retrieve the pointer size associated with the given compilation unit.
8949 Optionally the offset of this unit into the .debug_info section is
8950 also retutned. If there is no .debug_info section then an error
8951 message is issued and 0 is returned. If the requested comp unit has
8952 not been defined in the .debug_info section then a warning message
8953 is issued and the last know pointer size is returned. This message
8954 is only issued once per section dumped per file dumped. */
8957 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8958 const char * section_name
,
8959 unsigned long * offset_return
)
8961 unsigned long offset
= 0;
8963 if (num_debug_info_entries
== 0)
8964 error (_("%s section needs a populated .debug_info section\n"),
8967 else if (comp_unit
>= num_debug_info_entries
)
8969 if (!warned_about_missing_comp_units
)
8971 warn (_("%s section has more comp units than .debug_info section\n"),
8973 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
8975 warned_about_missing_comp_units
= TRUE
;
8980 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
8981 offset
= debug_information
[comp_unit
].cu_offset
;
8984 if (offset_return
!= NULL
)
8985 * offset_return
= offset
;
8987 return last_pointer_size
;
8990 /* Locate and scan the .debug_info section in the file and record the pointer
8991 sizes and offsets for the compilation units in it. Usually an executable
8992 will have just one pointer size, but this is not guaranteed, and so we try
8993 not to make any assumptions. Returns zero upon failure, or the number of
8994 compilation units upon success. */
8997 get_debug_info (FILE * file
)
8999 Elf_Internal_Shdr
* section
;
9000 unsigned char * start
;
9003 /* Reset the last pointer size so that we can issue correct error
9004 messages if we are displaying the contents of more than one section. */
9005 last_pointer_size
= 0;
9006 warned_about_missing_comp_units
= FALSE
;
9008 /* If we already have the information there is nothing else to do. */
9009 if (num_debug_info_entries
> 0)
9010 return num_debug_info_entries
;
9012 section
= find_section (".debug_info");
9013 if (section
== NULL
)
9016 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9017 _("extracting information from .debug_info section"));
9021 ret
= process_debug_info (section
, start
, file
, 1);
9024 return ret
? num_debug_info_entries
: 0;
9028 display_debug_lines (Elf_Internal_Shdr
*section
,
9029 unsigned char *start
, FILE *file
)
9031 unsigned char *data
= start
;
9032 unsigned char *end
= start
+ section
->sh_size
;
9033 unsigned int comp_unit
= 0;
9035 printf (_("\nDump of debug contents of section %s:\n\n"),
9036 SECTION_NAME (section
));
9038 get_debug_info (file
);
9042 DWARF2_Internal_LineInfo info
;
9043 unsigned char *standard_opcodes
;
9044 unsigned char *end_of_sequence
;
9045 unsigned char *hdrptr
;
9046 unsigned int pointer_size
;
9047 int initial_length_size
;
9053 /* Check the length of the block. */
9054 info
.li_length
= byte_get (hdrptr
, 4);
9057 if (info
.li_length
== 0xffffffff)
9059 /* This section is 64-bit DWARF 3. */
9060 info
.li_length
= byte_get (hdrptr
, 8);
9063 initial_length_size
= 12;
9068 initial_length_size
= 4;
9071 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9074 (_("The line info appears to be corrupt - the section is too small\n"));
9078 /* Check its version number. */
9079 info
.li_version
= byte_get (hdrptr
, 2);
9081 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9083 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9087 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9088 hdrptr
+= offset_size
;
9089 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9091 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9093 info
.li_line_base
= byte_get (hdrptr
, 1);
9095 info
.li_line_range
= byte_get (hdrptr
, 1);
9097 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9100 /* Sign extend the line base field. */
9101 info
.li_line_base
<<= 24;
9102 info
.li_line_base
>>= 24;
9104 /* Get the pointer size from the comp unit associated
9105 with this block of line number information. */
9106 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9107 (comp_unit
, ".debug_line", NULL
);
9110 printf (_(" Length: %ld\n"), info
.li_length
);
9111 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9112 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9113 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9114 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9115 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9116 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9117 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9118 printf (_(" (Pointer size: %u)%s\n"),
9120 warned_about_missing_comp_units
? " [assumed]" : "" );
9122 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9124 reset_state_machine (info
.li_default_is_stmt
);
9126 /* Display the contents of the Opcodes table. */
9127 standard_opcodes
= hdrptr
;
9129 printf (_("\n Opcodes:\n"));
9131 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9132 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9134 /* Display the contents of the Directory table. */
9135 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9138 printf (_("\n The Directory Table is empty.\n"));
9141 printf (_("\n The Directory Table:\n"));
9145 printf (_(" %s\n"), data
);
9147 data
+= strlen ((char *) data
) + 1;
9151 /* Skip the NUL at the end of the table. */
9154 /* Display the contents of the File Name table. */
9156 printf (_("\n The File Name Table is empty.\n"));
9159 printf (_("\n The File Name Table:\n"));
9160 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9164 unsigned char *name
;
9165 unsigned int bytes_read
;
9167 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9170 data
+= strlen ((char *) data
) + 1;
9172 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9174 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9176 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9178 printf (_("%s\n"), name
);
9182 /* Skip the NUL at the end of the table. */
9185 /* Now display the statements. */
9186 printf (_("\n Line Number Statements:\n"));
9188 while (data
< end_of_sequence
)
9190 unsigned char op_code
;
9192 unsigned int bytes_read
;
9196 if (op_code
>= info
.li_opcode_base
)
9198 op_code
-= info
.li_opcode_base
;
9199 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9200 state_machine_regs
.address
+= adv
;
9201 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9202 op_code
, adv
, state_machine_regs
.address
);
9203 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9204 state_machine_regs
.line
+= adv
;
9205 printf (_(" and Line by %d to %d\n"),
9206 adv
, state_machine_regs
.line
);
9208 else switch (op_code
)
9210 case DW_LNS_extended_op
:
9211 if (pointer_size
== 0)
9213 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9217 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9222 printf (_(" Copy\n"));
9225 case DW_LNS_advance_pc
:
9226 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9228 state_machine_regs
.address
+= adv
;
9229 printf (_(" Advance PC by %d to %lx\n"), adv
,
9230 state_machine_regs
.address
);
9233 case DW_LNS_advance_line
:
9234 adv
= read_leb128 (data
, & bytes_read
, 1);
9236 state_machine_regs
.line
+= adv
;
9237 printf (_(" Advance Line by %d to %d\n"), adv
,
9238 state_machine_regs
.line
);
9241 case DW_LNS_set_file
:
9242 adv
= read_leb128 (data
, & bytes_read
, 0);
9244 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9246 state_machine_regs
.file
= adv
;
9249 case DW_LNS_set_column
:
9250 adv
= read_leb128 (data
, & bytes_read
, 0);
9252 printf (_(" Set column to %d\n"), adv
);
9253 state_machine_regs
.column
= adv
;
9256 case DW_LNS_negate_stmt
:
9257 adv
= state_machine_regs
.is_stmt
;
9259 printf (_(" Set is_stmt to %d\n"), adv
);
9260 state_machine_regs
.is_stmt
= adv
;
9263 case DW_LNS_set_basic_block
:
9264 printf (_(" Set basic block\n"));
9265 state_machine_regs
.basic_block
= 1;
9268 case DW_LNS_const_add_pc
:
9269 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9270 * info
.li_min_insn_length
);
9271 state_machine_regs
.address
+= adv
;
9272 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9273 state_machine_regs
.address
);
9276 case DW_LNS_fixed_advance_pc
:
9277 adv
= byte_get (data
, 2);
9279 state_machine_regs
.address
+= adv
;
9280 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9281 adv
, state_machine_regs
.address
);
9284 case DW_LNS_set_prologue_end
:
9285 printf (_(" Set prologue_end to true\n"));
9288 case DW_LNS_set_epilogue_begin
:
9289 printf (_(" Set epilogue_begin to true\n"));
9292 case DW_LNS_set_isa
:
9293 adv
= read_leb128 (data
, & bytes_read
, 0);
9295 printf (_(" Set ISA to %d\n"), adv
);
9299 printf (_(" Unknown opcode %d with operands: "), op_code
);
9301 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9303 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9304 i
== 1 ? "" : ", ");
9318 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9319 unsigned char *start
,
9320 FILE *file ATTRIBUTE_UNUSED
)
9322 DWARF2_Internal_PubNames pubnames
;
9325 end
= start
+ section
->sh_size
;
9327 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9331 unsigned char *data
;
9332 unsigned long offset
;
9333 int offset_size
, initial_length_size
;
9337 pubnames
.pn_length
= byte_get (data
, 4);
9339 if (pubnames
.pn_length
== 0xffffffff)
9341 pubnames
.pn_length
= byte_get (data
, 8);
9344 initial_length_size
= 12;
9349 initial_length_size
= 4;
9352 pubnames
.pn_version
= byte_get (data
, 2);
9354 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9355 data
+= offset_size
;
9356 pubnames
.pn_size
= byte_get (data
, offset_size
);
9357 data
+= offset_size
;
9359 start
+= pubnames
.pn_length
+ initial_length_size
;
9361 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9363 static int warned
= 0;
9367 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9374 printf (_(" Length: %ld\n"),
9375 pubnames
.pn_length
);
9376 printf (_(" Version: %d\n"),
9377 pubnames
.pn_version
);
9378 printf (_(" Offset into .debug_info section: %ld\n"),
9379 pubnames
.pn_offset
);
9380 printf (_(" Size of area in .debug_info section: %ld\n"),
9383 printf (_("\n Offset\tName\n"));
9387 offset
= byte_get (data
, offset_size
);
9391 data
+= offset_size
;
9392 printf (" %-6ld\t\t%s\n", offset
, data
);
9393 data
+= strlen ((char *) data
) + 1;
9396 while (offset
!= 0);
9404 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9405 unsigned char *start
,
9406 FILE *file ATTRIBUTE_UNUSED
)
9408 unsigned char *end
= start
+ section
->sh_size
;
9409 unsigned char *curr
= start
;
9410 unsigned int bytes_read
;
9411 enum dwarf_macinfo_record_type op
;
9413 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9417 unsigned int lineno
;
9425 case DW_MACINFO_start_file
:
9427 unsigned int filenum
;
9429 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9431 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9434 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9439 case DW_MACINFO_end_file
:
9440 printf (_(" DW_MACINFO_end_file\n"));
9443 case DW_MACINFO_define
:
9444 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9446 string
= (char *) curr
;
9447 curr
+= strlen (string
) + 1;
9448 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9452 case DW_MACINFO_undef
:
9453 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9455 string
= (char *) curr
;
9456 curr
+= strlen (string
) + 1;
9457 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9461 case DW_MACINFO_vendor_ext
:
9463 unsigned int constant
;
9465 constant
= read_leb128 (curr
, & bytes_read
, 0);
9467 string
= (char *) curr
;
9468 curr
+= strlen (string
) + 1;
9469 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9481 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9482 unsigned char *start
,
9483 FILE *file ATTRIBUTE_UNUSED
)
9485 abbrev_entry
*entry
;
9486 unsigned char *end
= start
+ section
->sh_size
;
9488 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9492 start
= process_abbrev_section (start
, end
);
9494 if (first_abbrev
== NULL
)
9497 printf (_(" Number TAG\n"));
9499 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9503 printf (_(" %ld %s [%s]\n"),
9505 get_TAG_name (entry
->tag
),
9506 entry
->children
? _("has children") : _("no children"));
9508 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9509 printf (_(" %-18s %s\n"),
9510 get_AT_name (attr
->attribute
),
9511 get_FORM_name (attr
->form
));
9524 display_debug_loc (Elf_Internal_Shdr
*section
,
9525 unsigned char *start
, FILE *file
)
9527 unsigned char *section_end
;
9528 unsigned long bytes
;
9529 unsigned char *section_begin
= start
;
9530 unsigned int num_loc_list
= 0;
9531 unsigned long last_offset
= 0;
9532 unsigned int first
= 0;
9535 int seen_first_offset
= 0;
9536 int use_debug_info
= 1;
9537 unsigned char *next
;
9539 bytes
= section
->sh_size
;
9540 section_end
= start
+ bytes
;
9544 printf (_("\nThe .debug_loc section is empty.\n"));
9548 get_debug_info (file
);
9550 /* Check the order of location list in .debug_info section. If
9551 offsets of location lists are in the ascending order, we can
9552 use `debug_information' directly. */
9553 for (i
= 0; i
< num_debug_info_entries
; i
++)
9557 num
= debug_information
[i
].num_loc_offsets
;
9558 num_loc_list
+= num
;
9560 /* Check if we can use `debug_information' directly. */
9561 if (use_debug_info
&& num
!= 0)
9563 if (!seen_first_offset
)
9565 /* This is the first location list. */
9566 last_offset
= debug_information
[i
].loc_offsets
[0];
9568 seen_first_offset
= 1;
9574 for (; j
< num
; j
++)
9577 debug_information
[i
].loc_offsets
[j
])
9582 last_offset
= debug_information
[i
].loc_offsets
[j
];
9587 if (!use_debug_info
)
9588 /* FIXME: Should we handle this case? */
9589 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9591 if (!seen_first_offset
)
9592 error (_("No location lists in .debug_info section!\n"));
9594 if (debug_information
[first
].loc_offsets
[0] != 0)
9595 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9596 debug_information
[first
].loc_offsets
[0]);
9598 printf (_("Contents of the .debug_loc section:\n\n"));
9599 printf (_(" Offset Begin End Expression\n"));
9601 seen_first_offset
= 0;
9602 for (i
= first
; i
< num_debug_info_entries
; i
++)
9604 unsigned long begin
;
9606 unsigned short length
;
9607 unsigned long offset
;
9608 unsigned int pointer_size
;
9609 unsigned long cu_offset
;
9610 unsigned long base_address
;
9611 int need_frame_base
;
9614 pointer_size
= debug_information
[i
].pointer_size
;
9615 cu_offset
= debug_information
[i
].cu_offset
;
9617 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9619 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9620 offset
= debug_information
[i
].loc_offsets
[j
];
9621 next
= section_begin
+ offset
;
9622 base_address
= debug_information
[i
].base_address
;
9624 if (!seen_first_offset
)
9625 seen_first_offset
= 1;
9629 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9630 start
- section_begin
, next
- section_begin
);
9631 else if (start
> next
)
9632 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9633 start
- section_begin
, next
- section_begin
);
9639 begin
= byte_get (start
, pointer_size
);
9640 start
+= pointer_size
;
9641 end
= byte_get (start
, pointer_size
);
9642 start
+= pointer_size
;
9644 if (begin
== 0 && end
== 0)
9646 printf (_(" %8.8lx <End of list>\n"), offset
);
9650 /* Check base address specifiers. */
9651 if (begin
== -1UL && end
!= -1UL)
9654 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9655 offset
, begin
, end
);
9659 length
= byte_get (start
, 2);
9662 printf (" %8.8lx %8.8lx %8.8lx (",
9663 offset
, begin
+ base_address
, end
+ base_address
);
9664 need_frame_base
= decode_location_expression (start
,
9670 if (need_frame_base
&& !has_frame_base
)
9671 printf (_(" [without DW_AT_frame_base]"));
9674 fputs (_(" (start == end)"), stdout
);
9675 else if (begin
> end
)
9676 fputs (_(" (start > end)"), stdout
);
9688 display_debug_str (Elf_Internal_Shdr
*section
,
9689 unsigned char *start
,
9690 FILE *file ATTRIBUTE_UNUSED
)
9692 unsigned long bytes
;
9695 addr
= section
->sh_addr
;
9696 bytes
= section
->sh_size
;
9700 printf (_("\nThe .debug_str section is empty.\n"));
9704 printf (_("Contents of the .debug_str section:\n\n"));
9712 lbytes
= (bytes
> 16 ? 16 : bytes
);
9714 printf (" 0x%8.8lx ", (unsigned long) addr
);
9716 for (j
= 0; j
< 16; j
++)
9719 printf ("%2.2x", start
[j
]);
9727 for (j
= 0; j
< lbytes
; j
++)
9730 if (k
>= ' ' && k
< 0x80)
9750 display_debug_info (Elf_Internal_Shdr
* section
,
9751 unsigned char * start
, FILE * file
)
9753 return process_debug_info (section
, start
, file
, 0);
9758 display_debug_aranges (Elf_Internal_Shdr
*section
,
9759 unsigned char *start
,
9760 FILE *file ATTRIBUTE_UNUSED
)
9762 unsigned char *end
= start
+ section
->sh_size
;
9764 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9768 unsigned char *hdrptr
;
9769 DWARF2_Internal_ARange arange
;
9770 unsigned char *ranges
;
9771 unsigned long length
;
9772 unsigned long address
;
9775 int initial_length_size
;
9779 arange
.ar_length
= byte_get (hdrptr
, 4);
9782 if (arange
.ar_length
== 0xffffffff)
9784 arange
.ar_length
= byte_get (hdrptr
, 8);
9787 initial_length_size
= 12;
9792 initial_length_size
= 4;
9795 arange
.ar_version
= byte_get (hdrptr
, 2);
9798 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9799 hdrptr
+= offset_size
;
9801 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9804 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9807 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9809 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9813 printf (_(" Length: %ld\n"), arange
.ar_length
);
9814 printf (_(" Version: %d\n"), arange
.ar_version
);
9815 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9816 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9817 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9819 printf (_("\n Address Length\n"));
9823 /* Must pad to an alignment boundary that is twice the pointer size. */
9824 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9826 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9830 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9832 ranges
+= arange
.ar_pointer_size
;
9834 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9836 ranges
+= arange
.ar_pointer_size
;
9838 /* A pair of zeros marks the end of the list. */
9839 if (address
== 0 && length
== 0)
9842 printf (" %8.8lx %lu\n", address
, length
);
9845 start
+= arange
.ar_length
+ initial_length_size
;
9854 display_debug_ranges (Elf_Internal_Shdr
*section
,
9855 unsigned char *start
,
9856 FILE *file ATTRIBUTE_UNUSED
)
9858 unsigned char *section_end
;
9859 unsigned long bytes
;
9860 unsigned char *section_begin
= start
;
9861 unsigned int num_range_list
= 0;
9862 unsigned long last_offset
= 0;
9863 unsigned int first
= 0;
9866 int seen_first_offset
= 0;
9867 int use_debug_info
= 1;
9868 unsigned char *next
;
9870 bytes
= section
->sh_size
;
9871 section_end
= start
+ bytes
;
9875 printf (_("\nThe .debug_ranges section is empty.\n"));
9879 get_debug_info (file
);
9881 /* Check the order of range list in .debug_info section. If
9882 offsets of range lists are in the ascending order, we can
9883 use `debug_information' directly. */
9884 for (i
= 0; i
< num_debug_info_entries
; i
++)
9888 num
= debug_information
[i
].num_range_lists
;
9889 num_range_list
+= num
;
9891 /* Check if we can use `debug_information' directly. */
9892 if (use_debug_info
&& num
!= 0)
9894 if (!seen_first_offset
)
9896 /* This is the first range list. */
9897 last_offset
= debug_information
[i
].range_lists
[0];
9899 seen_first_offset
= 1;
9905 for (; j
< num
; j
++)
9908 debug_information
[i
].range_lists
[j
])
9913 last_offset
= debug_information
[i
].range_lists
[j
];
9918 if (!use_debug_info
)
9919 /* FIXME: Should we handle this case? */
9920 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9922 if (!seen_first_offset
)
9923 error (_("No range lists in .debug_info section!\n"));
9925 if (debug_information
[first
].range_lists
[0] != 0)
9926 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9927 debug_information
[first
].range_lists
[0]);
9929 printf (_("Contents of the .debug_ranges section:\n\n"));
9930 printf (_(" Offset Begin End\n"));
9932 seen_first_offset
= 0;
9933 for (i
= first
; i
< num_debug_info_entries
; i
++)
9935 unsigned long begin
;
9937 unsigned long offset
;
9938 unsigned int pointer_size
;
9939 unsigned long base_address
;
9941 pointer_size
= debug_information
[i
].pointer_size
;
9943 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9945 offset
= debug_information
[i
].range_lists
[j
];
9946 next
= section_begin
+ offset
;
9947 base_address
= debug_information
[i
].base_address
;
9949 if (!seen_first_offset
)
9950 seen_first_offset
= 1;
9954 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9955 start
- section_begin
, next
- section_begin
);
9956 else if (start
> next
)
9957 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9958 start
- section_begin
, next
- section_begin
);
9964 begin
= byte_get (start
, pointer_size
);
9965 start
+= pointer_size
;
9966 end
= byte_get (start
, pointer_size
);
9967 start
+= pointer_size
;
9969 if (begin
== 0 && end
== 0)
9971 printf (_(" %8.8lx <End of list>\n"), offset
);
9975 /* Check base address specifiers. */
9976 if (begin
== -1UL && end
!= -1UL)
9979 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9980 offset
, begin
, end
);
9984 printf (" %8.8lx %8.8lx %8.8lx",
9985 offset
, begin
+ base_address
, end
+ base_address
);
9988 fputs (_(" (start == end)"), stdout
);
9989 else if (begin
> end
)
9990 fputs (_(" (start > end)"), stdout
);
10000 typedef struct Frame_Chunk
10002 struct Frame_Chunk
*next
;
10003 unsigned char *chunk_start
;
10005 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
10006 short int *col_type
;
10008 char *augmentation
;
10009 unsigned int code_factor
;
10011 unsigned long pc_begin
;
10012 unsigned long pc_range
;
10016 unsigned char fde_encoding
;
10017 unsigned char cfa_exp
;
10021 /* A marker for a col_type that means this column was never referenced
10022 in the frame info. */
10023 #define DW_CFA_unreferenced (-1)
10026 frame_need_space (Frame_Chunk
*fc
, int reg
)
10028 int prev
= fc
->ncols
;
10030 if (reg
< fc
->ncols
)
10033 fc
->ncols
= reg
+ 1;
10034 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
10035 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
10037 while (prev
< fc
->ncols
)
10039 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10040 fc
->col_offset
[prev
] = 0;
10046 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10051 if (*max_regs
< fc
->ncols
)
10052 *max_regs
= fc
->ncols
;
10054 if (*need_col_headers
)
10056 *need_col_headers
= 0;
10058 printf (" LOC CFA ");
10060 for (r
= 0; r
< *max_regs
; r
++)
10061 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10066 printf ("r%-4d", r
);
10072 printf ("%08lx ", fc
->pc_begin
);
10074 strcpy (tmp
, "exp");
10076 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10077 printf ("%-8s ", tmp
);
10079 for (r
= 0; r
< fc
->ncols
; r
++)
10081 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10083 switch (fc
->col_type
[r
])
10085 case DW_CFA_undefined
:
10088 case DW_CFA_same_value
:
10091 case DW_CFA_offset
:
10092 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10094 case DW_CFA_register
:
10095 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10097 case DW_CFA_expression
:
10098 strcpy (tmp
, "exp");
10101 strcpy (tmp
, "n/a");
10104 printf ("%-5s", tmp
);
10111 size_of_encoded_value (int encoding
)
10113 switch (encoding
& 0x7)
10116 case 0: return eh_addr_size
;
10124 get_encoded_value (unsigned char *data
, int encoding
)
10126 int size
= size_of_encoded_value (encoding
);
10127 if (encoding
& DW_EH_PE_signed
)
10128 return byte_get_signed (data
, size
);
10130 return byte_get (data
, size
);
10133 #define GET(N) byte_get (start, N); start += N
10134 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10135 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10138 display_debug_frames (Elf_Internal_Shdr
*section
,
10139 unsigned char *start
,
10140 FILE *file ATTRIBUTE_UNUSED
)
10142 unsigned char *end
= start
+ section
->sh_size
;
10143 unsigned char *section_start
= start
;
10144 Frame_Chunk
*chunks
= 0;
10145 Frame_Chunk
*remembered_state
= 0;
10147 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10148 unsigned int length_return
;
10151 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10153 while (start
< end
)
10155 unsigned char *saved_start
;
10156 unsigned char *block_end
;
10157 unsigned long length
;
10158 unsigned long cie_id
;
10161 int need_col_headers
= 1;
10162 unsigned char *augmentation_data
= NULL
;
10163 unsigned long augmentation_data_len
= 0;
10164 int encoded_ptr_size
= eh_addr_size
;
10166 int initial_length_size
;
10168 saved_start
= start
;
10169 length
= byte_get (start
, 4); start
+= 4;
10173 printf ("\n%08lx ZERO terminator\n\n",
10174 (unsigned long)(saved_start
- section_start
));
10178 if (length
== 0xffffffff)
10180 length
= byte_get (start
, 8);
10183 initial_length_size
= 12;
10188 initial_length_size
= 4;
10191 block_end
= saved_start
+ length
+ initial_length_size
;
10192 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10194 if (elf_header
.e_type
== ET_REL
10195 && !debug_apply_rela_addends (file
, section
, offset_size
,
10196 section_start
, start
, block_end
))
10199 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10203 fc
= xmalloc (sizeof (Frame_Chunk
));
10204 memset (fc
, 0, sizeof (Frame_Chunk
));
10208 fc
->chunk_start
= saved_start
;
10210 fc
->col_type
= xmalloc (sizeof (short int));
10211 fc
->col_offset
= xmalloc (sizeof (int));
10212 frame_need_space (fc
, max_regs
-1);
10214 version
= *start
++;
10216 fc
->augmentation
= (char *) start
;
10217 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10219 if (fc
->augmentation
[0] == 'z')
10221 fc
->code_factor
= LEB ();
10222 fc
->data_factor
= SLEB ();
10231 augmentation_data_len
= LEB ();
10232 augmentation_data
= start
;
10233 start
+= augmentation_data_len
;
10235 else if (streq (fc
->augmentation
, "eh"))
10237 start
+= eh_addr_size
;
10238 fc
->code_factor
= LEB ();
10239 fc
->data_factor
= SLEB ();
10251 fc
->code_factor
= LEB ();
10252 fc
->data_factor
= SLEB ();
10264 if (do_debug_frames_interp
)
10265 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10266 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10267 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10271 printf ("\n%08lx %08lx %08lx CIE\n",
10272 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10273 printf (" Version: %d\n", version
);
10274 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10275 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10276 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10277 printf (" Return address column: %d\n", fc
->ra
);
10279 if (augmentation_data_len
)
10282 printf (" Augmentation data: ");
10283 for (i
= 0; i
< augmentation_data_len
; ++i
)
10284 printf (" %02x", augmentation_data
[i
]);
10290 if (augmentation_data_len
)
10292 unsigned char *p
, *q
;
10293 p
= (unsigned char *) fc
->augmentation
+ 1;
10294 q
= augmentation_data
;
10300 else if (*p
== 'P')
10301 q
+= 1 + size_of_encoded_value (*q
);
10302 else if (*p
== 'R')
10303 fc
->fde_encoding
= *q
++;
10309 if (fc
->fde_encoding
)
10310 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10313 frame_need_space (fc
, fc
->ra
);
10317 unsigned char *look_for
;
10318 static Frame_Chunk fde_fc
;
10321 memset (fc
, 0, sizeof (Frame_Chunk
));
10323 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10325 for (cie
= chunks
; cie
; cie
= cie
->next
)
10326 if (cie
->chunk_start
== look_for
)
10331 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10332 cie_id
, saved_start
);
10335 fc
->col_type
= xmalloc (sizeof (short int));
10336 fc
->col_offset
= xmalloc (sizeof (int));
10337 frame_need_space (fc
, max_regs
- 1);
10339 fc
->augmentation
= "";
10340 fc
->fde_encoding
= 0;
10344 fc
->ncols
= cie
->ncols
;
10345 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10346 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10347 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10348 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10349 fc
->augmentation
= cie
->augmentation
;
10350 fc
->code_factor
= cie
->code_factor
;
10351 fc
->data_factor
= cie
->data_factor
;
10352 fc
->cfa_reg
= cie
->cfa_reg
;
10353 fc
->cfa_offset
= cie
->cfa_offset
;
10355 frame_need_space (fc
, max_regs
-1);
10356 fc
->fde_encoding
= cie
->fde_encoding
;
10359 if (fc
->fde_encoding
)
10360 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10362 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10363 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10364 /* Don't adjust for ET_REL since there's invariably a pcrel
10365 reloc here, which we haven't applied. */
10366 && elf_header
.e_type
!= ET_REL
)
10367 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10368 start
+= encoded_ptr_size
;
10369 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10370 start
+= encoded_ptr_size
;
10372 if (cie
->augmentation
[0] == 'z')
10374 augmentation_data_len
= LEB ();
10375 augmentation_data
= start
;
10376 start
+= augmentation_data_len
;
10379 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10380 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10381 (unsigned long)(cie
->chunk_start
- section_start
),
10382 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10383 if (! do_debug_frames_interp
&& augmentation_data_len
)
10387 printf (" Augmentation data: ");
10388 for (i
= 0; i
< augmentation_data_len
; ++i
)
10389 printf (" %02x", augmentation_data
[i
]);
10395 /* At this point, fc is the current chunk, cie (if any) is set, and
10396 we're about to interpret instructions for the chunk. */
10397 /* ??? At present we need to do this always, since this sizes the
10398 fc->col_type and fc->col_offset arrays, which we write into always.
10399 We should probably split the interpreted and non-interpreted bits
10400 into two different routines, since there's so much that doesn't
10401 really overlap between them. */
10402 if (1 || do_debug_frames_interp
)
10404 /* Start by making a pass over the chunk, allocating storage
10405 and taking note of what registers are used. */
10406 unsigned char *tmp
= start
;
10408 while (start
< block_end
)
10411 unsigned long reg
, tmp
;
10418 /* Warning: if you add any more cases to this switch, be
10419 sure to add them to the corresponding switch below. */
10422 case DW_CFA_advance_loc
:
10424 case DW_CFA_offset
:
10426 frame_need_space (fc
, opa
);
10427 fc
->col_type
[opa
] = DW_CFA_undefined
;
10429 case DW_CFA_restore
:
10430 frame_need_space (fc
, opa
);
10431 fc
->col_type
[opa
] = DW_CFA_undefined
;
10433 case DW_CFA_set_loc
:
10434 start
+= encoded_ptr_size
;
10436 case DW_CFA_advance_loc1
:
10439 case DW_CFA_advance_loc2
:
10442 case DW_CFA_advance_loc4
:
10445 case DW_CFA_offset_extended
:
10446 reg
= LEB (); LEB ();
10447 frame_need_space (fc
, reg
);
10448 fc
->col_type
[reg
] = DW_CFA_undefined
;
10450 case DW_CFA_restore_extended
:
10452 frame_need_space (fc
, reg
);
10453 fc
->col_type
[reg
] = DW_CFA_undefined
;
10455 case DW_CFA_undefined
:
10457 frame_need_space (fc
, reg
);
10458 fc
->col_type
[reg
] = DW_CFA_undefined
;
10460 case DW_CFA_same_value
:
10462 frame_need_space (fc
, reg
);
10463 fc
->col_type
[reg
] = DW_CFA_undefined
;
10465 case DW_CFA_register
:
10466 reg
= LEB (); LEB ();
10467 frame_need_space (fc
, reg
);
10468 fc
->col_type
[reg
] = DW_CFA_undefined
;
10470 case DW_CFA_def_cfa
:
10473 case DW_CFA_def_cfa_register
:
10476 case DW_CFA_def_cfa_offset
:
10479 case DW_CFA_def_cfa_expression
:
10483 case DW_CFA_expression
:
10487 frame_need_space (fc
, reg
);
10488 fc
->col_type
[reg
] = DW_CFA_undefined
;
10490 case DW_CFA_offset_extended_sf
:
10491 reg
= LEB (); SLEB ();
10492 frame_need_space (fc
, reg
);
10493 fc
->col_type
[reg
] = DW_CFA_undefined
;
10495 case DW_CFA_def_cfa_sf
:
10498 case DW_CFA_def_cfa_offset_sf
:
10501 case DW_CFA_MIPS_advance_loc8
:
10504 case DW_CFA_GNU_args_size
:
10507 case DW_CFA_GNU_negative_offset_extended
:
10508 reg
= LEB (); LEB ();
10509 frame_need_space (fc
, reg
);
10510 fc
->col_type
[reg
] = DW_CFA_undefined
;
10519 /* Now we know what registers are used, make a second pass over
10520 the chunk, this time actually printing out the info. */
10522 while (start
< block_end
)
10525 unsigned long ul
, reg
, roffs
;
10534 /* Warning: if you add any more cases to this switch, be
10535 sure to add them to the corresponding switch above. */
10538 case DW_CFA_advance_loc
:
10539 if (do_debug_frames_interp
)
10540 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10542 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10543 opa
* fc
->code_factor
,
10544 fc
->pc_begin
+ opa
* fc
->code_factor
);
10545 fc
->pc_begin
+= opa
* fc
->code_factor
;
10548 case DW_CFA_offset
:
10550 if (! do_debug_frames_interp
)
10551 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10552 opa
, roffs
* fc
->data_factor
);
10553 fc
->col_type
[opa
] = DW_CFA_offset
;
10554 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10557 case DW_CFA_restore
:
10558 if (! do_debug_frames_interp
)
10559 printf (" DW_CFA_restore: r%d\n", opa
);
10560 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10561 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10564 case DW_CFA_set_loc
:
10565 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10566 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10567 && elf_header
.e_type
!= ET_REL
)
10568 vma
+= section
->sh_addr
+ (start
- section_start
);
10569 start
+= encoded_ptr_size
;
10570 if (do_debug_frames_interp
)
10571 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10573 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10574 fc
->pc_begin
= vma
;
10577 case DW_CFA_advance_loc1
:
10578 ofs
= byte_get (start
, 1); start
+= 1;
10579 if (do_debug_frames_interp
)
10580 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10582 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10583 ofs
* fc
->code_factor
,
10584 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10585 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10588 case DW_CFA_advance_loc2
:
10589 ofs
= byte_get (start
, 2); start
+= 2;
10590 if (do_debug_frames_interp
)
10591 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10593 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10594 ofs
* fc
->code_factor
,
10595 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10596 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10599 case DW_CFA_advance_loc4
:
10600 ofs
= byte_get (start
, 4); start
+= 4;
10601 if (do_debug_frames_interp
)
10602 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10604 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10605 ofs
* fc
->code_factor
,
10606 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10607 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10610 case DW_CFA_offset_extended
:
10613 if (! do_debug_frames_interp
)
10614 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10615 reg
, roffs
* fc
->data_factor
);
10616 fc
->col_type
[reg
] = DW_CFA_offset
;
10617 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10620 case DW_CFA_restore_extended
:
10622 if (! do_debug_frames_interp
)
10623 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10624 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10625 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10628 case DW_CFA_undefined
:
10630 if (! do_debug_frames_interp
)
10631 printf (" DW_CFA_undefined: r%ld\n", reg
);
10632 fc
->col_type
[reg
] = DW_CFA_undefined
;
10633 fc
->col_offset
[reg
] = 0;
10636 case DW_CFA_same_value
:
10638 if (! do_debug_frames_interp
)
10639 printf (" DW_CFA_same_value: r%ld\n", reg
);
10640 fc
->col_type
[reg
] = DW_CFA_same_value
;
10641 fc
->col_offset
[reg
] = 0;
10644 case DW_CFA_register
:
10647 if (! do_debug_frames_interp
)
10648 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10649 fc
->col_type
[reg
] = DW_CFA_register
;
10650 fc
->col_offset
[reg
] = roffs
;
10653 case DW_CFA_remember_state
:
10654 if (! do_debug_frames_interp
)
10655 printf (" DW_CFA_remember_state\n");
10656 rs
= xmalloc (sizeof (Frame_Chunk
));
10657 rs
->ncols
= fc
->ncols
;
10658 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10659 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10660 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10661 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10662 rs
->next
= remembered_state
;
10663 remembered_state
= rs
;
10666 case DW_CFA_restore_state
:
10667 if (! do_debug_frames_interp
)
10668 printf (" DW_CFA_restore_state\n");
10669 rs
= remembered_state
;
10672 remembered_state
= rs
->next
;
10673 frame_need_space (fc
, rs
->ncols
-1);
10674 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10675 memcpy (fc
->col_offset
, rs
->col_offset
,
10676 rs
->ncols
* sizeof (int));
10677 free (rs
->col_type
);
10678 free (rs
->col_offset
);
10681 else if (do_debug_frames_interp
)
10682 printf ("Mismatched DW_CFA_restore_state\n");
10685 case DW_CFA_def_cfa
:
10686 fc
->cfa_reg
= LEB ();
10687 fc
->cfa_offset
= LEB ();
10689 if (! do_debug_frames_interp
)
10690 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10691 fc
->cfa_reg
, fc
->cfa_offset
);
10694 case DW_CFA_def_cfa_register
:
10695 fc
->cfa_reg
= LEB ();
10697 if (! do_debug_frames_interp
)
10698 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10701 case DW_CFA_def_cfa_offset
:
10702 fc
->cfa_offset
= LEB ();
10703 if (! do_debug_frames_interp
)
10704 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10708 if (! do_debug_frames_interp
)
10709 printf (" DW_CFA_nop\n");
10712 case DW_CFA_def_cfa_expression
:
10714 if (! do_debug_frames_interp
)
10716 printf (" DW_CFA_def_cfa_expression (");
10717 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10724 case DW_CFA_expression
:
10727 if (! do_debug_frames_interp
)
10729 printf (" DW_CFA_expression: r%ld (", reg
);
10730 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10733 fc
->col_type
[reg
] = DW_CFA_expression
;
10737 case DW_CFA_offset_extended_sf
:
10740 frame_need_space (fc
, reg
);
10741 if (! do_debug_frames_interp
)
10742 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10743 reg
, l
* fc
->data_factor
);
10744 fc
->col_type
[reg
] = DW_CFA_offset
;
10745 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10748 case DW_CFA_def_cfa_sf
:
10749 fc
->cfa_reg
= LEB ();
10750 fc
->cfa_offset
= SLEB ();
10751 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10753 if (! do_debug_frames_interp
)
10754 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10755 fc
->cfa_reg
, fc
->cfa_offset
);
10758 case DW_CFA_def_cfa_offset_sf
:
10759 fc
->cfa_offset
= SLEB ();
10760 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10761 if (! do_debug_frames_interp
)
10762 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10765 case DW_CFA_MIPS_advance_loc8
:
10766 ofs
= byte_get (start
, 8); start
+= 8;
10767 if (do_debug_frames_interp
)
10768 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10770 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10771 ofs
* fc
->code_factor
,
10772 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10773 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10776 case DW_CFA_GNU_window_save
:
10777 if (! do_debug_frames_interp
)
10778 printf (" DW_CFA_GNU_window_save\n");
10781 case DW_CFA_GNU_args_size
:
10783 if (! do_debug_frames_interp
)
10784 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10787 case DW_CFA_GNU_negative_offset_extended
:
10790 frame_need_space (fc
, reg
);
10791 if (! do_debug_frames_interp
)
10792 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10793 reg
, l
* fc
->data_factor
);
10794 fc
->col_type
[reg
] = DW_CFA_offset
;
10795 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10799 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10804 if (do_debug_frames_interp
)
10805 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10820 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10821 unsigned char *start ATTRIBUTE_UNUSED
,
10822 FILE *file ATTRIBUTE_UNUSED
)
10824 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10825 SECTION_NAME (section
));
10830 /* A structure containing the name of a debug section
10831 and a pointer to a function that can decode it. */
10834 const char *const name
;
10835 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10839 { ".debug_abbrev", display_debug_abbrev
},
10840 { ".debug_aranges", display_debug_aranges
},
10841 { ".debug_frame", display_debug_frames
},
10842 { ".debug_info", display_debug_info
},
10843 { ".debug_line", display_debug_lines
},
10844 { ".debug_pubnames", display_debug_pubnames
},
10845 { ".eh_frame", display_debug_frames
},
10846 { ".debug_macinfo", display_debug_macinfo
},
10847 { ".debug_str", display_debug_str
},
10848 { ".debug_loc", display_debug_loc
},
10849 { ".debug_pubtypes", display_debug_pubnames
},
10850 { ".debug_ranges", display_debug_ranges
},
10851 { ".debug_static_func", display_debug_not_supported
},
10852 { ".debug_static_vars", display_debug_not_supported
},
10853 { ".debug_types", display_debug_not_supported
},
10854 { ".debug_weaknames", display_debug_not_supported
}
10858 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10860 char *name
= SECTION_NAME (section
);
10861 bfd_size_type length
;
10865 length
= section
->sh_size
;
10868 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10872 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10873 name
= ".debug_info";
10875 /* See if we know how to display the contents of this section. */
10876 for (i
= NUM_ELEM (debug_displays
); i
--;)
10877 if (streq (debug_displays
[i
].name
, name
))
10879 unsigned char *start
;
10881 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10882 _("debug section data"));
10889 result
&= debug_displays
[i
].display (section
, start
, file
);
10892 /* If we loaded in the abbrev section
10893 at some point, we must release it here. */
10901 printf (_("Unrecognized debug section: %s\n"), name
);
10909 process_section_contents (FILE *file
)
10911 Elf_Internal_Shdr
*section
;
10917 for (i
= 0, section
= section_headers
;
10918 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10921 #ifdef SUPPORT_DISASSEMBLY
10922 if (dump_sects
[i
] & DISASS_DUMP
)
10923 disassemble_section (section
, file
);
10925 if (dump_sects
[i
] & HEX_DUMP
)
10926 dump_section (section
, file
);
10928 if (dump_sects
[i
] & DEBUG_DUMP
)
10929 display_debug_section (section
, file
);
10932 /* Check to see if the user requested a
10933 dump of a section that does not exist. */
10934 while (i
++ < num_dump_sects
)
10936 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10940 process_mips_fpe_exception (int mask
)
10945 if (mask
& OEX_FPU_INEX
)
10946 fputs ("INEX", stdout
), first
= 0;
10947 if (mask
& OEX_FPU_UFLO
)
10948 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10949 if (mask
& OEX_FPU_OFLO
)
10950 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10951 if (mask
& OEX_FPU_DIV0
)
10952 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10953 if (mask
& OEX_FPU_INVAL
)
10954 printf ("%sINVAL", first
? "" : "|");
10957 fputs ("0", stdout
);
10961 process_mips_specific (FILE *file
)
10963 Elf_Internal_Dyn
*entry
;
10964 size_t liblist_offset
= 0;
10965 size_t liblistno
= 0;
10966 size_t conflictsno
= 0;
10967 size_t options_offset
= 0;
10968 size_t conflicts_offset
= 0;
10970 /* We have a lot of special sections. Thanks SGI! */
10971 if (dynamic_section
== NULL
)
10972 /* No information available. */
10975 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10976 switch (entry
->d_tag
)
10978 case DT_MIPS_LIBLIST
:
10980 = offset_from_vma (file
, entry
->d_un
.d_val
,
10981 liblistno
* sizeof (Elf32_External_Lib
));
10983 case DT_MIPS_LIBLISTNO
:
10984 liblistno
= entry
->d_un
.d_val
;
10986 case DT_MIPS_OPTIONS
:
10987 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10989 case DT_MIPS_CONFLICT
:
10991 = offset_from_vma (file
, entry
->d_un
.d_val
,
10992 conflictsno
* sizeof (Elf32_External_Conflict
));
10994 case DT_MIPS_CONFLICTNO
:
10995 conflictsno
= entry
->d_un
.d_val
;
11001 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11003 Elf32_External_Lib
*elib
;
11006 elib
= get_data (NULL
, file
, liblist_offset
,
11007 liblistno
* sizeof (Elf32_External_Lib
),
11011 printf ("\nSection '.liblist' contains %lu entries:\n",
11012 (unsigned long) liblistno
);
11013 fputs (" Library Time Stamp Checksum Version Flags\n",
11016 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11023 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11024 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11025 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11026 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11027 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11029 tmp
= gmtime (&time
);
11030 snprintf (timebuf
, sizeof (timebuf
),
11031 "%04u-%02u-%02uT%02u:%02u:%02u",
11032 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11033 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11035 printf ("%3lu: ", (unsigned long) cnt
);
11036 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11037 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11039 printf ("<corrupt: %9ld>", liblist
.l_name
);
11040 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11041 liblist
.l_version
);
11043 if (liblist
.l_flags
== 0)
11047 static const struct
11054 { " EXACT_MATCH", LL_EXACT_MATCH
},
11055 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11056 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11057 { " EXPORTS", LL_EXPORTS
},
11058 { " DELAY_LOAD", LL_DELAY_LOAD
},
11059 { " DELTA", LL_DELTA
}
11061 int flags
= liblist
.l_flags
;
11065 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11067 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11069 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11070 flags
^= l_flags_vals
[fcnt
].bit
;
11073 printf (" %#x", (unsigned int) flags
);
11083 if (options_offset
!= 0)
11085 Elf_External_Options
*eopt
;
11086 Elf_Internal_Shdr
*sect
= section_headers
;
11087 Elf_Internal_Options
*iopt
;
11088 Elf_Internal_Options
*option
;
11092 /* Find the section header so that we get the size. */
11093 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11096 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
11100 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
11103 error (_("Out of memory"));
11110 while (offset
< sect
->sh_size
)
11112 Elf_External_Options
*eoption
;
11114 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11116 option
->kind
= BYTE_GET (eoption
->kind
);
11117 option
->size
= BYTE_GET (eoption
->size
);
11118 option
->section
= BYTE_GET (eoption
->section
);
11119 option
->info
= BYTE_GET (eoption
->info
);
11121 offset
+= option
->size
;
11127 printf (_("\nSection '%s' contains %d entries:\n"),
11128 SECTION_NAME (sect
), cnt
);
11136 switch (option
->kind
)
11139 /* This shouldn't happen. */
11140 printf (" NULL %d %lx", option
->section
, option
->info
);
11143 printf (" REGINFO ");
11144 if (elf_header
.e_machine
== EM_MIPS
)
11147 Elf32_External_RegInfo
*ereg
;
11148 Elf32_RegInfo reginfo
;
11150 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11151 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11152 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11153 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11154 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11155 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11156 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11158 printf ("GPR %08lx GP 0x%lx\n",
11159 reginfo
.ri_gprmask
,
11160 (unsigned long) reginfo
.ri_gp_value
);
11161 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11162 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11163 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11168 Elf64_External_RegInfo
*ereg
;
11169 Elf64_Internal_RegInfo reginfo
;
11171 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11172 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11173 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11174 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11175 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11176 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11177 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11179 printf ("GPR %08lx GP 0x",
11180 reginfo
.ri_gprmask
);
11181 printf_vma (reginfo
.ri_gp_value
);
11184 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11185 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11186 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11190 case ODK_EXCEPTIONS
:
11191 fputs (" EXCEPTIONS fpe_min(", stdout
);
11192 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11193 fputs (") fpe_max(", stdout
);
11194 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11195 fputs (")", stdout
);
11197 if (option
->info
& OEX_PAGE0
)
11198 fputs (" PAGE0", stdout
);
11199 if (option
->info
& OEX_SMM
)
11200 fputs (" SMM", stdout
);
11201 if (option
->info
& OEX_FPDBUG
)
11202 fputs (" FPDBUG", stdout
);
11203 if (option
->info
& OEX_DISMISS
)
11204 fputs (" DISMISS", stdout
);
11207 fputs (" PAD ", stdout
);
11208 if (option
->info
& OPAD_PREFIX
)
11209 fputs (" PREFIX", stdout
);
11210 if (option
->info
& OPAD_POSTFIX
)
11211 fputs (" POSTFIX", stdout
);
11212 if (option
->info
& OPAD_SYMBOL
)
11213 fputs (" SYMBOL", stdout
);
11216 fputs (" HWPATCH ", stdout
);
11217 if (option
->info
& OHW_R4KEOP
)
11218 fputs (" R4KEOP", stdout
);
11219 if (option
->info
& OHW_R8KPFETCH
)
11220 fputs (" R8KPFETCH", stdout
);
11221 if (option
->info
& OHW_R5KEOP
)
11222 fputs (" R5KEOP", stdout
);
11223 if (option
->info
& OHW_R5KCVTL
)
11224 fputs (" R5KCVTL", stdout
);
11227 fputs (" FILL ", stdout
);
11228 /* XXX Print content of info word? */
11231 fputs (" TAGS ", stdout
);
11232 /* XXX Print content of info word? */
11235 fputs (" HWAND ", stdout
);
11236 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11237 fputs (" R4KEOP_CHECKED", stdout
);
11238 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11239 fputs (" R4KEOP_CLEAN", stdout
);
11242 fputs (" HWOR ", stdout
);
11243 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11244 fputs (" R4KEOP_CHECKED", stdout
);
11245 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11246 fputs (" R4KEOP_CLEAN", stdout
);
11249 printf (" GP_GROUP %#06lx self-contained %#06lx",
11250 option
->info
& OGP_GROUP
,
11251 (option
->info
& OGP_SELF
) >> 16);
11254 printf (" IDENT %#06lx self-contained %#06lx",
11255 option
->info
& OGP_GROUP
,
11256 (option
->info
& OGP_SELF
) >> 16);
11259 /* This shouldn't happen. */
11260 printf (" %3d ??? %d %lx",
11261 option
->kind
, option
->section
, option
->info
);
11265 len
= sizeof (*eopt
);
11266 while (len
< option
->size
)
11267 if (((char *) option
)[len
] >= ' '
11268 && ((char *) option
)[len
] < 0x7f)
11269 printf ("%c", ((char *) option
)[len
++]);
11271 printf ("\\%03o", ((char *) option
)[len
++]);
11273 fputs ("\n", stdout
);
11281 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11283 Elf32_Conflict
*iconf
;
11286 if (dynamic_symbols
== NULL
)
11288 error (_("conflict list found without a dynamic symbol table"));
11292 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11295 error (_("Out of memory"));
11301 Elf32_External_Conflict
*econf32
;
11303 econf32
= get_data (NULL
, file
, conflicts_offset
,
11304 conflictsno
* sizeof (*econf32
), _("conflict"));
11308 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11309 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11315 Elf64_External_Conflict
*econf64
;
11317 econf64
= get_data (NULL
, file
, conflicts_offset
,
11318 conflictsno
* sizeof (*econf64
), _("conflict"));
11322 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11323 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11328 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11329 (unsigned long) conflictsno
);
11330 puts (_(" Num: Index Value Name"));
11332 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11334 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11336 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11337 print_vma (psym
->st_value
, FULL_HEX
);
11339 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11340 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11342 printf ("<corrupt: %14ld>", psym
->st_name
);
11353 process_gnu_liblist (FILE *file
)
11355 Elf_Internal_Shdr
*section
, *string_sec
;
11356 Elf32_External_Lib
*elib
;
11364 for (i
= 0, section
= section_headers
;
11365 i
< elf_header
.e_shnum
;
11368 switch (section
->sh_type
)
11370 case SHT_GNU_LIBLIST
:
11371 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11376 string_sec
= SECTION_HEADER (section
->sh_link
);
11378 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11379 string_sec
->sh_size
, _("liblist string table"));
11382 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11388 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11389 SECTION_NAME (section
),
11390 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11392 puts (" Library Time Stamp Checksum Version Flags");
11394 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11402 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11403 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11404 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11405 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11406 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11408 tmp
= gmtime (&time
);
11409 snprintf (timebuf
, sizeof (timebuf
),
11410 "%04u-%02u-%02uT%02u:%02u:%02u",
11411 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11412 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11414 printf ("%3lu: ", (unsigned long) cnt
);
11416 printf ("%-20s", strtab
+ liblist
.l_name
);
11418 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11419 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11420 liblist
.l_version
, liblist
.l_flags
);
11430 static const char *
11431 get_note_type (unsigned e_type
)
11433 static char buff
[64];
11435 if (elf_header
.e_type
== ET_CORE
)
11439 return _("NT_AUXV (auxiliary vector)");
11441 return _("NT_PRSTATUS (prstatus structure)");
11443 return _("NT_FPREGSET (floating point registers)");
11445 return _("NT_PRPSINFO (prpsinfo structure)");
11446 case NT_TASKSTRUCT
:
11447 return _("NT_TASKSTRUCT (task structure)");
11449 return _("NT_PRXFPREG (user_xfpregs structure)");
11451 return _("NT_PSTATUS (pstatus structure)");
11453 return _("NT_FPREGS (floating point registers)");
11455 return _("NT_PSINFO (psinfo structure)");
11457 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11459 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11460 case NT_WIN32PSTATUS
:
11461 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11469 return _("NT_VERSION (version)");
11471 return _("NT_ARCH (architecture)");
11476 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11480 static const char *
11481 get_netbsd_elfcore_note_type (unsigned e_type
)
11483 static char buff
[64];
11485 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11487 /* NetBSD core "procinfo" structure. */
11488 return _("NetBSD procinfo structure");
11491 /* As of Jan 2002 there are no other machine-independent notes
11492 defined for NetBSD core files. If the note type is less
11493 than the start of the machine-dependent note types, we don't
11496 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11498 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11502 switch (elf_header
.e_machine
)
11504 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11505 and PT_GETFPREGS == mach+2. */
11510 case EM_SPARC32PLUS
:
11514 case NT_NETBSDCORE_FIRSTMACH
+0:
11515 return _("PT_GETREGS (reg structure)");
11516 case NT_NETBSDCORE_FIRSTMACH
+2:
11517 return _("PT_GETFPREGS (fpreg structure)");
11523 /* On all other arch's, PT_GETREGS == mach+1 and
11524 PT_GETFPREGS == mach+3. */
11528 case NT_NETBSDCORE_FIRSTMACH
+1:
11529 return _("PT_GETREGS (reg structure)");
11530 case NT_NETBSDCORE_FIRSTMACH
+3:
11531 return _("PT_GETFPREGS (fpreg structure)");
11537 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11538 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11542 /* Note that by the ELF standard, the name field is already null byte
11543 terminated, and namesz includes the terminating null byte.
11544 I.E. the value of namesz for the name "FSF" is 4.
11546 If the value of namesz is zero, there is no name present. */
11548 process_note (Elf_Internal_Note
*pnote
)
11552 if (pnote
->namesz
== 0)
11553 /* If there is no note name, then use the default set of
11554 note type strings. */
11555 nt
= get_note_type (pnote
->type
);
11557 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11558 /* NetBSD-specific core file notes. */
11559 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11562 /* Don't recognize this note name; just use the default set of
11563 note type strings. */
11564 nt
= get_note_type (pnote
->type
);
11566 printf (" %s\t\t0x%08lx\t%s\n",
11567 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11568 pnote
->descsz
, nt
);
11574 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11576 Elf_External_Note
*pnotes
;
11577 Elf_External_Note
*external
;
11583 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11589 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11590 (unsigned long) offset
, (unsigned long) length
);
11591 printf (_(" Owner\t\tData size\tDescription\n"));
11593 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11595 Elf_External_Note
*next
;
11596 Elf_Internal_Note inote
;
11599 inote
.type
= BYTE_GET (external
->type
);
11600 inote
.namesz
= BYTE_GET (external
->namesz
);
11601 inote
.namedata
= external
->name
;
11602 inote
.descsz
= BYTE_GET (external
->descsz
);
11603 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11604 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11606 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11608 if (((char *) next
) > (((char *) pnotes
) + length
))
11610 warn (_("corrupt note found at offset %x into core notes\n"),
11611 ((char *) external
) - ((char *) pnotes
));
11612 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11613 inote
.type
, inote
.namesz
, inote
.descsz
);
11619 /* Verify that name is null terminated. It appears that at least
11620 one version of Linux (RedHat 6.0) generates corefiles that don't
11621 comply with the ELF spec by failing to include the null byte in
11623 if (inote
.namedata
[inote
.namesz
] != '\0')
11625 temp
= malloc (inote
.namesz
+ 1);
11629 error (_("Out of memory\n"));
11634 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11635 temp
[inote
.namesz
] = 0;
11637 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11638 inote
.namedata
= temp
;
11641 res
&= process_note (& inote
);
11656 process_corefile_note_segments (FILE *file
)
11658 Elf_Internal_Phdr
*segment
;
11662 if (! get_program_headers (file
))
11665 for (i
= 0, segment
= program_headers
;
11666 i
< elf_header
.e_phnum
;
11669 if (segment
->p_type
== PT_NOTE
)
11670 res
&= process_corefile_note_segment (file
,
11671 (bfd_vma
) segment
->p_offset
,
11672 (bfd_vma
) segment
->p_filesz
);
11679 process_note_sections (FILE *file
)
11681 Elf_Internal_Shdr
*section
;
11685 for (i
= 0, section
= section_headers
;
11686 i
< elf_header
.e_shnum
;
11688 if (section
->sh_type
== SHT_NOTE
)
11689 res
&= process_corefile_note_segment (file
,
11690 (bfd_vma
) section
->sh_offset
,
11691 (bfd_vma
) section
->sh_size
);
11697 process_notes (FILE *file
)
11699 /* If we have not been asked to display the notes then do nothing. */
11703 if (elf_header
.e_type
!= ET_CORE
)
11704 return process_note_sections (file
);
11706 /* No program headers means no NOTE segment. */
11707 if (elf_header
.e_phnum
> 0)
11708 return process_corefile_note_segments (file
);
11710 printf (_("No note segments present in the core file.\n"));
11715 process_arch_specific (FILE *file
)
11720 switch (elf_header
.e_machine
)
11723 case EM_MIPS_RS3_LE
:
11724 return process_mips_specific (file
);
11733 get_file_header (FILE *file
)
11735 /* Read in the identity array. */
11736 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11739 /* Determine how to read the rest of the header. */
11740 switch (elf_header
.e_ident
[EI_DATA
])
11742 default: /* fall through */
11743 case ELFDATANONE
: /* fall through */
11745 byte_get
= byte_get_little_endian
;
11746 byte_put
= byte_put_little_endian
;
11749 byte_get
= byte_get_big_endian
;
11750 byte_put
= byte_put_big_endian
;
11754 /* For now we only support 32 bit and 64 bit ELF files. */
11755 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11757 /* Read in the rest of the header. */
11760 Elf32_External_Ehdr ehdr32
;
11762 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11765 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11766 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11767 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11768 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11769 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11770 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11771 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11772 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11773 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11774 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11775 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11776 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11777 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11781 Elf64_External_Ehdr ehdr64
;
11783 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11784 we will not be able to cope with the 64bit data found in
11785 64 ELF files. Detect this now and abort before we start
11786 overwriting things. */
11787 if (sizeof (bfd_vma
) < 8)
11789 error (_("This instance of readelf has been built without support for a\n\
11790 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11794 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11797 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11798 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11799 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11800 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11801 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11802 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11803 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11804 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11805 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11806 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11807 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11808 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11809 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11812 if (elf_header
.e_shoff
)
11814 /* There may be some extensions in the first section header. Don't
11815 bomb if we can't read it. */
11817 get_32bit_section_headers (file
, 1);
11819 get_64bit_section_headers (file
, 1);
11825 /* Process one ELF object file according to the command line options.
11826 This file may actually be stored in an archive. The file is
11827 positioned at the start of the ELF object. */
11830 process_object (char *file_name
, FILE *file
)
11834 if (! get_file_header (file
))
11836 error (_("%s: Failed to read file header\n"), file_name
);
11840 /* Initialise per file variables. */
11841 for (i
= NUM_ELEM (version_info
); i
--;)
11842 version_info
[i
] = 0;
11844 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11845 dynamic_info
[i
] = 0;
11847 /* Process the file. */
11849 printf (_("\nFile: %s\n"), file_name
);
11851 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11852 Note we do this even if cmdline_dump_sects is empty because we
11853 must make sure that the dump_sets array is zeroed out before each
11854 object file is processed. */
11855 if (num_dump_sects
> num_cmdline_dump_sects
)
11856 memset (dump_sects
, 0, num_dump_sects
);
11858 if (num_cmdline_dump_sects
> 0)
11860 if (num_dump_sects
== 0)
11861 /* A sneaky way of allocating the dump_sects array. */
11862 request_dump (num_cmdline_dump_sects
, 0);
11864 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11865 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11868 if (! process_file_header ())
11871 if (! process_section_headers (file
))
11873 /* Without loaded section headers we cannot process lots of
11875 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11877 if (! do_using_dynamic
)
11878 do_syms
= do_reloc
= 0;
11881 if (! process_section_groups (file
))
11883 /* Without loaded section groups we cannot process unwind. */
11887 if (process_program_headers (file
))
11888 process_dynamic_section (file
);
11890 process_relocs (file
);
11892 process_unwind (file
);
11894 process_symbol_table (file
);
11896 process_syminfo (file
);
11898 process_version_sections (file
);
11900 process_section_contents (file
);
11902 process_notes (file
);
11904 process_gnu_liblist (file
);
11906 process_arch_specific (file
);
11908 if (program_headers
)
11910 free (program_headers
);
11911 program_headers
= NULL
;
11914 if (section_headers
)
11916 free (section_headers
);
11917 section_headers
= NULL
;
11922 free (string_table
);
11923 string_table
= NULL
;
11924 string_table_length
= 0;
11927 if (dynamic_strings
)
11929 free (dynamic_strings
);
11930 dynamic_strings
= NULL
;
11931 dynamic_strings_length
= 0;
11934 if (dynamic_symbols
)
11936 free (dynamic_symbols
);
11937 dynamic_symbols
= NULL
;
11938 num_dynamic_syms
= 0;
11941 if (dynamic_syminfo
)
11943 free (dynamic_syminfo
);
11944 dynamic_syminfo
= NULL
;
11947 if (section_headers_groups
)
11949 free (section_headers_groups
);
11950 section_headers_groups
= NULL
;
11953 if (section_groups
)
11955 struct group_list
*g
, *next
;
11957 for (i
= 0; i
< group_count
; i
++)
11959 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11966 free (section_groups
);
11967 section_groups
= NULL
;
11970 if (debug_information
)
11972 for (i
= 0; i
< num_debug_info_entries
; i
++)
11974 if (!debug_information
[i
].max_loc_offsets
)
11976 free (debug_information
[i
].loc_offsets
);
11977 free (debug_information
[i
].have_frame_base
);
11979 if (!debug_information
[i
].max_range_lists
)
11980 free (debug_information
[i
].range_lists
);
11982 free (debug_information
);
11983 debug_information
= NULL
;
11984 num_debug_info_entries
= 0;
11990 /* Process an ELF archive. The file is positioned just after the
11994 process_archive (char *file_name
, FILE *file
)
11996 struct ar_hdr arhdr
;
11998 unsigned long size
;
11999 char *longnames
= NULL
;
12000 unsigned long longnames_size
= 0;
12001 size_t file_name_size
;
12006 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12007 if (got
!= sizeof arhdr
)
12012 error (_("%s: failed to read archive header\n"), file_name
);
12016 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12018 /* This is the archive symbol table. Skip it.
12019 FIXME: We should have an option to dump it. */
12020 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12021 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12023 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12027 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12028 if (got
!= sizeof arhdr
)
12033 error (_("%s: failed to read archive header\n"), file_name
);
12038 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12040 /* This is the archive string table holding long member
12043 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12045 longnames
= malloc (longnames_size
);
12046 if (longnames
== NULL
)
12048 error (_("Out of memory\n"));
12052 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12055 error (_("%s: failed to read string table\n"), file_name
);
12059 if ((longnames_size
& 1) != 0)
12062 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12063 if (got
!= sizeof arhdr
)
12070 error (_("%s: failed to read archive header\n"), file_name
);
12075 file_name_size
= strlen (file_name
);
12084 if (arhdr
.ar_name
[0] == '/')
12088 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12089 if (off
>= longnames_size
)
12091 error (_("%s: invalid archive string table offset %lu\n"), off
);
12096 name
= longnames
+ off
;
12097 nameend
= memchr (name
, '/', longnames_size
- off
);
12101 name
= arhdr
.ar_name
;
12102 nameend
= memchr (name
, '/', 16);
12105 if (nameend
== NULL
)
12107 error (_("%s: bad archive file name\n"));
12112 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12113 if (namealc
== NULL
)
12115 error (_("Out of memory\n"));
12120 memcpy (namealc
, file_name
, file_name_size
);
12121 namealc
[file_name_size
] = '(';
12122 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12123 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12124 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12126 archive_file_offset
= ftell (file
);
12127 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12129 ret
|= process_object (namealc
, file
);
12134 (archive_file_offset
12135 + archive_file_size
12136 + (archive_file_size
& 1)),
12139 error (_("%s: failed to seek to next archive header\n"), file_name
);
12144 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12145 if (got
!= sizeof arhdr
)
12150 error (_("%s: failed to read archive header\n"), file_name
);
12156 if (longnames
!= 0)
12163 process_file (char *file_name
)
12166 struct stat statbuf
;
12167 char armag
[SARMAG
];
12170 if (stat (file_name
, &statbuf
) < 0)
12172 if (errno
== ENOENT
)
12173 error (_("'%s': No such file\n"), file_name
);
12175 error (_("Could not locate '%s'. System error message: %s\n"),
12176 file_name
, strerror (errno
));
12180 if (! S_ISREG (statbuf
.st_mode
))
12182 error (_("'%s' is not an ordinary file\n"), file_name
);
12186 file
= fopen (file_name
, "rb");
12189 error (_("Input file '%s' is not readable.\n"), file_name
);
12193 if (fread (armag
, SARMAG
, 1, file
) != 1)
12195 error (_("%s: Failed to read file header\n"), file_name
);
12200 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12201 ret
= process_archive (file_name
, file
);
12205 archive_file_size
= archive_file_offset
= 0;
12206 ret
= process_object (file_name
, file
);
12214 #ifdef SUPPORT_DISASSEMBLY
12215 /* Needed by the i386 disassembler. For extra credit, someone could
12216 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12220 print_address (unsigned int addr
, FILE *outfile
)
12222 fprintf (outfile
,"0x%8.8x", addr
);
12225 /* Needed by the i386 disassembler. */
12227 db_task_printsym (unsigned int addr
)
12229 print_address (addr
, stderr
);
12234 main (int argc
, char **argv
)
12238 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12239 setlocale (LC_MESSAGES
, "");
12241 #if defined (HAVE_SETLOCALE)
12242 setlocale (LC_CTYPE
, "");
12244 bindtextdomain (PACKAGE
, LOCALEDIR
);
12245 textdomain (PACKAGE
);
12247 parse_args (argc
, argv
);
12249 if (num_dump_sects
> 0)
12251 /* Make a copy of the dump_sects array. */
12252 cmdline_dump_sects
= malloc (num_dump_sects
);
12253 if (cmdline_dump_sects
== NULL
)
12254 error (_("Out of memory allocating dump request table."));
12257 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12258 num_cmdline_dump_sects
= num_dump_sects
;
12262 if (optind
< (argc
- 1))
12266 while (optind
< argc
)
12267 err
|= process_file (argv
[optind
++]);
12269 if (dump_sects
!= NULL
)
12271 if (cmdline_dump_sects
!= NULL
)
12272 free (cmdline_dump_sects
);