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
);
1246 if (elf_header
.e_machine
== EM_ALPHA
1247 && streq (rtype
, "R_ALPHA_LITUSE")
1250 switch (rels
[i
].r_addend
)
1252 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1253 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1254 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1255 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1256 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1257 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1258 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1259 default: rtype
= NULL
;
1262 printf (" (%s)", rtype
);
1266 printf (_("<unknown addend: %lx>"),
1267 (unsigned long) rels
[i
].r_addend
);
1270 else if (symtab_index
)
1272 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1273 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1276 Elf_Internal_Sym
*psym
;
1278 psym
= symtab
+ symtab_index
;
1281 print_vma (psym
->st_value
, LONG_HEX
);
1282 printf (is_32bit_elf
? " " : " ");
1284 if (psym
->st_name
== 0)
1286 const char *sec_name
= "<null>";
1289 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1291 bfd_vma sec_index
= (bfd_vma
) -1;
1293 if (psym
->st_shndx
< SHN_LORESERVE
)
1294 sec_index
= psym
->st_shndx
;
1295 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1296 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1299 if (sec_index
!= (bfd_vma
) -1)
1300 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1301 else if (psym
->st_shndx
== SHN_ABS
)
1303 else if (psym
->st_shndx
== SHN_COMMON
)
1304 sec_name
= "COMMON";
1305 else if (elf_header
.e_machine
== EM_IA_64
1306 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1307 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1308 sec_name
= "ANSI_COM";
1311 sprintf (name_buf
, "<section 0x%x>",
1312 (unsigned int) psym
->st_shndx
);
1313 sec_name
= name_buf
;
1316 print_symbol (22, sec_name
);
1318 else if (strtab
== NULL
)
1319 printf (_("<string table index: %3ld>"), psym
->st_name
);
1320 else if (psym
->st_name
> strtablen
)
1321 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1323 print_symbol (22, strtab
+ psym
->st_name
);
1326 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1331 printf ("%*c", is_32bit_elf
?
1332 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1333 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1336 if (elf_header
.e_machine
== EM_SPARCV9
&& streq (rtype
, "R_SPARC_OLO10"))
1337 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1341 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1343 printf (" Type2: ");
1346 #ifdef _bfd_int64_low
1347 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1349 printf (_("unrecognized: %-7lx"), type2
);
1352 printf ("%-17.17s", rtype2
);
1354 printf ("\n Type3: ");
1357 #ifdef _bfd_int64_low
1358 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1360 printf (_("unrecognized: %-7lx"), type3
);
1363 printf ("%-17.17s", rtype3
);
1375 get_mips_dynamic_type (unsigned long type
)
1379 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1380 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1381 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1382 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1383 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1384 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1385 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1386 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1387 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1388 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1389 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1390 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1391 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1392 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1393 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1394 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1395 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1396 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1397 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1398 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1399 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1400 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1401 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1402 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1403 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1404 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1405 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1406 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1407 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1408 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1409 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1410 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1411 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1412 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1413 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1414 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1415 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1416 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1417 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1418 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1419 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1420 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1421 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1428 get_sparc64_dynamic_type (unsigned long type
)
1432 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1439 get_ppc_dynamic_type (unsigned long type
)
1443 case DT_PPC_GOT
: return "PPC_GOT";
1450 get_ppc64_dynamic_type (unsigned long type
)
1454 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1455 case DT_PPC64_OPD
: return "PPC64_OPD";
1456 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1463 get_parisc_dynamic_type (unsigned long type
)
1467 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1468 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1469 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1470 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1471 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1472 case DT_HP_PREINIT
: return "HP_PREINIT";
1473 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1474 case DT_HP_NEEDED
: return "HP_NEEDED";
1475 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1476 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1477 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1478 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1479 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1486 get_ia64_dynamic_type (unsigned long type
)
1490 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1497 get_alpha_dynamic_type (unsigned long type
)
1501 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1508 get_dynamic_type (unsigned long type
)
1510 static char buff
[64];
1514 case DT_NULL
: return "NULL";
1515 case DT_NEEDED
: return "NEEDED";
1516 case DT_PLTRELSZ
: return "PLTRELSZ";
1517 case DT_PLTGOT
: return "PLTGOT";
1518 case DT_HASH
: return "HASH";
1519 case DT_STRTAB
: return "STRTAB";
1520 case DT_SYMTAB
: return "SYMTAB";
1521 case DT_RELA
: return "RELA";
1522 case DT_RELASZ
: return "RELASZ";
1523 case DT_RELAENT
: return "RELAENT";
1524 case DT_STRSZ
: return "STRSZ";
1525 case DT_SYMENT
: return "SYMENT";
1526 case DT_INIT
: return "INIT";
1527 case DT_FINI
: return "FINI";
1528 case DT_SONAME
: return "SONAME";
1529 case DT_RPATH
: return "RPATH";
1530 case DT_SYMBOLIC
: return "SYMBOLIC";
1531 case DT_REL
: return "REL";
1532 case DT_RELSZ
: return "RELSZ";
1533 case DT_RELENT
: return "RELENT";
1534 case DT_PLTREL
: return "PLTREL";
1535 case DT_DEBUG
: return "DEBUG";
1536 case DT_TEXTREL
: return "TEXTREL";
1537 case DT_JMPREL
: return "JMPREL";
1538 case DT_BIND_NOW
: return "BIND_NOW";
1539 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1540 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1541 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1542 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1543 case DT_RUNPATH
: return "RUNPATH";
1544 case DT_FLAGS
: return "FLAGS";
1546 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1547 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1549 case DT_CHECKSUM
: return "CHECKSUM";
1550 case DT_PLTPADSZ
: return "PLTPADSZ";
1551 case DT_MOVEENT
: return "MOVEENT";
1552 case DT_MOVESZ
: return "MOVESZ";
1553 case DT_FEATURE
: return "FEATURE";
1554 case DT_POSFLAG_1
: return "POSFLAG_1";
1555 case DT_SYMINSZ
: return "SYMINSZ";
1556 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1558 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1559 case DT_CONFIG
: return "CONFIG";
1560 case DT_DEPAUDIT
: return "DEPAUDIT";
1561 case DT_AUDIT
: return "AUDIT";
1562 case DT_PLTPAD
: return "PLTPAD";
1563 case DT_MOVETAB
: return "MOVETAB";
1564 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1566 case DT_VERSYM
: return "VERSYM";
1568 case DT_RELACOUNT
: return "RELACOUNT";
1569 case DT_RELCOUNT
: return "RELCOUNT";
1570 case DT_FLAGS_1
: return "FLAGS_1";
1571 case DT_VERDEF
: return "VERDEF";
1572 case DT_VERDEFNUM
: return "VERDEFNUM";
1573 case DT_VERNEED
: return "VERNEED";
1574 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1576 case DT_AUXILIARY
: return "AUXILIARY";
1577 case DT_USED
: return "USED";
1578 case DT_FILTER
: return "FILTER";
1580 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1581 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1582 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1583 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1584 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1587 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1591 switch (elf_header
.e_machine
)
1594 case EM_MIPS_RS3_LE
:
1595 result
= get_mips_dynamic_type (type
);
1598 result
= get_sparc64_dynamic_type (type
);
1601 result
= get_ppc_dynamic_type (type
);
1604 result
= get_ppc64_dynamic_type (type
);
1607 result
= get_ia64_dynamic_type (type
);
1610 result
= get_alpha_dynamic_type (type
);
1620 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1622 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1626 switch (elf_header
.e_machine
)
1629 result
= get_parisc_dynamic_type (type
);
1639 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1643 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1650 get_file_type (unsigned e_type
)
1652 static char buff
[32];
1656 case ET_NONE
: return _("NONE (None)");
1657 case ET_REL
: return _("REL (Relocatable file)");
1658 case ET_EXEC
: return _("EXEC (Executable file)");
1659 case ET_DYN
: return _("DYN (Shared object file)");
1660 case ET_CORE
: return _("CORE (Core file)");
1663 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1664 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1665 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1666 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1668 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1674 get_machine_name (unsigned e_machine
)
1676 static char buff
[64]; /* XXX */
1680 case EM_NONE
: return _("None");
1681 case EM_M32
: return "WE32100";
1682 case EM_SPARC
: return "Sparc";
1683 case EM_386
: return "Intel 80386";
1684 case EM_68K
: return "MC68000";
1685 case EM_88K
: return "MC88000";
1686 case EM_486
: return "Intel 80486";
1687 case EM_860
: return "Intel 80860";
1688 case EM_MIPS
: return "MIPS R3000";
1689 case EM_S370
: return "IBM System/370";
1690 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1691 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1692 case EM_PARISC
: return "HPPA";
1693 case EM_PPC_OLD
: return "Power PC (old)";
1694 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1695 case EM_960
: return "Intel 90860";
1696 case EM_PPC
: return "PowerPC";
1697 case EM_PPC64
: return "PowerPC64";
1698 case EM_V800
: return "NEC V800";
1699 case EM_FR20
: return "Fujitsu FR20";
1700 case EM_RH32
: return "TRW RH32";
1701 case EM_MCORE
: return "MCORE";
1702 case EM_ARM
: return "ARM";
1703 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1704 case EM_SH
: return "Renesas / SuperH SH";
1705 case EM_SPARCV9
: return "Sparc v9";
1706 case EM_TRICORE
: return "Siemens Tricore";
1707 case EM_ARC
: return "ARC";
1708 case EM_H8_300
: return "Renesas H8/300";
1709 case EM_H8_300H
: return "Renesas H8/300H";
1710 case EM_H8S
: return "Renesas H8S";
1711 case EM_H8_500
: return "Renesas H8/500";
1712 case EM_IA_64
: return "Intel IA-64";
1713 case EM_MIPS_X
: return "Stanford MIPS-X";
1714 case EM_COLDFIRE
: return "Motorola Coldfire";
1715 case EM_68HC12
: return "Motorola M68HC12";
1716 case EM_ALPHA
: return "Alpha";
1717 case EM_CYGNUS_D10V
:
1718 case EM_D10V
: return "d10v";
1719 case EM_CYGNUS_D30V
:
1720 case EM_D30V
: return "d30v";
1721 case EM_CYGNUS_M32R
:
1722 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1723 case EM_CYGNUS_V850
:
1724 case EM_V850
: return "NEC v850";
1725 case EM_CYGNUS_MN10300
:
1726 case EM_MN10300
: return "mn10300";
1727 case EM_CYGNUS_MN10200
:
1728 case EM_MN10200
: return "mn10200";
1729 case EM_CYGNUS_FR30
:
1730 case EM_FR30
: return "Fujitsu FR30";
1731 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1733 case EM_PJ
: return "picoJava";
1734 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1735 case EM_PCP
: return "Siemens PCP";
1736 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1737 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1738 case EM_STARCORE
: return "Motorola Star*Core processor";
1739 case EM_ME16
: return "Toyota ME16 processor";
1740 case EM_ST100
: return "STMicroelectronics ST100 processor";
1741 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1742 case EM_FX66
: return "Siemens FX66 microcontroller";
1743 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1744 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1745 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1746 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1747 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1748 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1749 case EM_SVX
: return "Silicon Graphics SVx";
1750 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1751 case EM_VAX
: return "Digital VAX";
1753 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1754 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1755 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1756 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1757 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1758 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1759 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1760 case EM_PRISM
: return "Vitesse Prism";
1761 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1763 case EM_S390
: return "IBM S/390";
1764 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1766 case EM_OR32
: return "OpenRISC";
1767 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1768 case EM_DLX
: return "OpenDLX";
1770 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1771 case EM_IQ2000
: return "Vitesse IQ2000";
1773 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1775 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1781 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1786 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1787 e_flags
&= ~ EF_ARM_EABIMASK
;
1789 /* Handle "generic" ARM flags. */
1790 if (e_flags
& EF_ARM_RELEXEC
)
1792 strcat (buf
, ", relocatable executable");
1793 e_flags
&= ~ EF_ARM_RELEXEC
;
1796 if (e_flags
& EF_ARM_HASENTRY
)
1798 strcat (buf
, ", has entry point");
1799 e_flags
&= ~ EF_ARM_HASENTRY
;
1802 /* Now handle EABI specific flags. */
1806 strcat (buf
, ", <unrecognized EABI>");
1811 case EF_ARM_EABI_VER1
:
1812 strcat (buf
, ", Version1 EABI");
1817 /* Process flags one bit at a time. */
1818 flag
= e_flags
& - e_flags
;
1823 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1824 strcat (buf
, ", sorted symbol tables");
1834 case EF_ARM_EABI_VER2
:
1835 strcat (buf
, ", Version2 EABI");
1840 /* Process flags one bit at a time. */
1841 flag
= e_flags
& - e_flags
;
1846 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1847 strcat (buf
, ", sorted symbol tables");
1850 case EF_ARM_DYNSYMSUSESEGIDX
:
1851 strcat (buf
, ", dynamic symbols use segment index");
1854 case EF_ARM_MAPSYMSFIRST
:
1855 strcat (buf
, ", mapping symbols precede others");
1865 case EF_ARM_EABI_VER3
:
1866 strcat (buf
, ", Version3 EABI");
1869 case EF_ARM_EABI_VER4
:
1870 strcat (buf
, ", Version4 EABI");
1875 /* Process flags one bit at a time. */
1876 flag
= e_flags
& - e_flags
;
1882 strcat (buf
, ", BE8");
1886 strcat (buf
, ", LE8");
1896 case EF_ARM_EABI_UNKNOWN
:
1897 strcat (buf
, ", GNU EABI");
1902 /* Process flags one bit at a time. */
1903 flag
= e_flags
& - e_flags
;
1908 case EF_ARM_INTERWORK
:
1909 strcat (buf
, ", interworking enabled");
1912 case EF_ARM_APCS_26
:
1913 strcat (buf
, ", uses APCS/26");
1916 case EF_ARM_APCS_FLOAT
:
1917 strcat (buf
, ", uses APCS/float");
1921 strcat (buf
, ", position independent");
1925 strcat (buf
, ", 8 bit structure alignment");
1928 case EF_ARM_NEW_ABI
:
1929 strcat (buf
, ", uses new ABI");
1932 case EF_ARM_OLD_ABI
:
1933 strcat (buf
, ", uses old ABI");
1936 case EF_ARM_SOFT_FLOAT
:
1937 strcat (buf
, ", software FP");
1940 case EF_ARM_VFP_FLOAT
:
1941 strcat (buf
, ", VFP");
1944 case EF_ARM_MAVERICK_FLOAT
:
1945 strcat (buf
, ", Maverick FP");
1956 strcat (buf
,", <unknown>");
1960 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1962 static char buf
[1024];
1974 decode_ARM_machine_flags (e_flags
, buf
);
1978 switch (e_flags
& EF_FRV_CPU_MASK
)
1980 case EF_FRV_CPU_GENERIC
:
1984 strcat (buf
, ", fr???");
1987 case EF_FRV_CPU_FR300
:
1988 strcat (buf
, ", fr300");
1991 case EF_FRV_CPU_FR400
:
1992 strcat (buf
, ", fr400");
1994 case EF_FRV_CPU_FR405
:
1995 strcat (buf
, ", fr405");
1998 case EF_FRV_CPU_FR450
:
1999 strcat (buf
, ", fr450");
2002 case EF_FRV_CPU_FR500
:
2003 strcat (buf
, ", fr500");
2005 case EF_FRV_CPU_FR550
:
2006 strcat (buf
, ", fr550");
2009 case EF_FRV_CPU_SIMPLE
:
2010 strcat (buf
, ", simple");
2012 case EF_FRV_CPU_TOMCAT
:
2013 strcat (buf
, ", tomcat");
2019 if (e_flags
& EF_CPU32
)
2020 strcat (buf
, ", cpu32");
2021 if (e_flags
& EF_M68000
)
2022 strcat (buf
, ", m68000");
2026 if (e_flags
& EF_PPC_EMB
)
2027 strcat (buf
, ", emb");
2029 if (e_flags
& EF_PPC_RELOCATABLE
)
2030 strcat (buf
, ", relocatable");
2032 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2033 strcat (buf
, ", relocatable-lib");
2037 case EM_CYGNUS_V850
:
2038 switch (e_flags
& EF_V850_ARCH
)
2041 strcat (buf
, ", v850e1");
2044 strcat (buf
, ", v850e");
2047 strcat (buf
, ", v850");
2050 strcat (buf
, ", unknown v850 architecture variant");
2056 case EM_CYGNUS_M32R
:
2057 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2058 strcat (buf
, ", m32r");
2063 case EM_MIPS_RS3_LE
:
2064 if (e_flags
& EF_MIPS_NOREORDER
)
2065 strcat (buf
, ", noreorder");
2067 if (e_flags
& EF_MIPS_PIC
)
2068 strcat (buf
, ", pic");
2070 if (e_flags
& EF_MIPS_CPIC
)
2071 strcat (buf
, ", cpic");
2073 if (e_flags
& EF_MIPS_UCODE
)
2074 strcat (buf
, ", ugen_reserved");
2076 if (e_flags
& EF_MIPS_ABI2
)
2077 strcat (buf
, ", abi2");
2079 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2080 strcat (buf
, ", odk first");
2082 if (e_flags
& EF_MIPS_32BITMODE
)
2083 strcat (buf
, ", 32bitmode");
2085 switch ((e_flags
& EF_MIPS_MACH
))
2087 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2088 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2089 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2090 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2091 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2092 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2093 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2094 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2095 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2096 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2098 /* We simply ignore the field in this case to avoid confusion:
2099 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2102 default: strcat (buf
, ", unknown CPU"); break;
2105 switch ((e_flags
& EF_MIPS_ABI
))
2107 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2108 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2109 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2110 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2112 /* We simply ignore the field in this case to avoid confusion:
2113 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2114 This means it is likely to be an o32 file, but not for
2117 default: strcat (buf
, ", unknown ABI"); break;
2120 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2121 strcat (buf
, ", mdmx");
2123 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2124 strcat (buf
, ", mips16");
2126 switch ((e_flags
& EF_MIPS_ARCH
))
2128 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2129 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2130 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2131 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2132 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2133 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2134 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2135 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2136 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2137 default: strcat (buf
, ", unknown ISA"); break;
2143 switch ((e_flags
& EF_SH_MACH_MASK
))
2145 case EF_SH1
: strcat (buf
, ", sh1"); break;
2146 case EF_SH2
: strcat (buf
, ", sh2"); break;
2147 case EF_SH3
: strcat (buf
, ", sh3"); break;
2148 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2149 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2150 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2151 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2152 case EF_SH4
: strcat (buf
, ", sh4"); break;
2153 case EF_SH5
: strcat (buf
, ", sh5"); break;
2154 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2155 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2156 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2157 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2158 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2159 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2160 default: strcat (buf
, ", unknown ISA"); break;
2166 if (e_flags
& EF_SPARC_32PLUS
)
2167 strcat (buf
, ", v8+");
2169 if (e_flags
& EF_SPARC_SUN_US1
)
2170 strcat (buf
, ", ultrasparcI");
2172 if (e_flags
& EF_SPARC_SUN_US3
)
2173 strcat (buf
, ", ultrasparcIII");
2175 if (e_flags
& EF_SPARC_HAL_R1
)
2176 strcat (buf
, ", halr1");
2178 if (e_flags
& EF_SPARC_LEDATA
)
2179 strcat (buf
, ", ledata");
2181 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2182 strcat (buf
, ", tso");
2184 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2185 strcat (buf
, ", pso");
2187 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2188 strcat (buf
, ", rmo");
2192 switch (e_flags
& EF_PARISC_ARCH
)
2194 case EFA_PARISC_1_0
:
2195 strcpy (buf
, ", PA-RISC 1.0");
2197 case EFA_PARISC_1_1
:
2198 strcpy (buf
, ", PA-RISC 1.1");
2200 case EFA_PARISC_2_0
:
2201 strcpy (buf
, ", PA-RISC 2.0");
2206 if (e_flags
& EF_PARISC_TRAPNIL
)
2207 strcat (buf
, ", trapnil");
2208 if (e_flags
& EF_PARISC_EXT
)
2209 strcat (buf
, ", ext");
2210 if (e_flags
& EF_PARISC_LSB
)
2211 strcat (buf
, ", lsb");
2212 if (e_flags
& EF_PARISC_WIDE
)
2213 strcat (buf
, ", wide");
2214 if (e_flags
& EF_PARISC_NO_KABP
)
2215 strcat (buf
, ", no kabp");
2216 if (e_flags
& EF_PARISC_LAZYSWAP
)
2217 strcat (buf
, ", lazyswap");
2222 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2223 strcat (buf
, ", new calling convention");
2225 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2226 strcat (buf
, ", gnu calling convention");
2230 if ((e_flags
& EF_IA_64_ABI64
))
2231 strcat (buf
, ", 64-bit");
2233 strcat (buf
, ", 32-bit");
2234 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2235 strcat (buf
, ", reduced fp model");
2236 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2237 strcat (buf
, ", no function descriptors, constant gp");
2238 else if ((e_flags
& EF_IA_64_CONS_GP
))
2239 strcat (buf
, ", constant gp");
2240 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2241 strcat (buf
, ", absolute");
2245 if ((e_flags
& EF_VAX_NONPIC
))
2246 strcat (buf
, ", non-PIC");
2247 if ((e_flags
& EF_VAX_DFLOAT
))
2248 strcat (buf
, ", D-Float");
2249 if ((e_flags
& EF_VAX_GFLOAT
))
2250 strcat (buf
, ", G-Float");
2259 get_osabi_name (unsigned int osabi
)
2261 static char buff
[32];
2265 case ELFOSABI_NONE
: return "UNIX - System V";
2266 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2267 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2268 case ELFOSABI_LINUX
: return "UNIX - Linux";
2269 case ELFOSABI_HURD
: return "GNU/Hurd";
2270 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2271 case ELFOSABI_AIX
: return "UNIX - AIX";
2272 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2273 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2274 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2275 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2276 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2277 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2278 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2279 case ELFOSABI_AROS
: return "Amiga Research OS";
2280 case ELFOSABI_STANDALONE
: return _("Standalone App");
2281 case ELFOSABI_ARM
: return "ARM";
2283 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2289 get_arm_segment_type (unsigned long type
)
2303 get_mips_segment_type (unsigned long type
)
2307 case PT_MIPS_REGINFO
:
2309 case PT_MIPS_RTPROC
:
2311 case PT_MIPS_OPTIONS
:
2321 get_parisc_segment_type (unsigned long type
)
2325 case PT_HP_TLS
: return "HP_TLS";
2326 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2327 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2328 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2329 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2330 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2331 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2332 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2333 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2334 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2335 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2336 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2337 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2338 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2347 get_ia64_segment_type (unsigned long type
)
2351 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2352 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2353 case PT_HP_TLS
: return "HP_TLS";
2354 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2355 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2356 case PT_IA_64_HP_STACK
: return "HP_STACK";
2365 get_segment_type (unsigned long p_type
)
2367 static char buff
[32];
2371 case PT_NULL
: return "NULL";
2372 case PT_LOAD
: return "LOAD";
2373 case PT_DYNAMIC
: return "DYNAMIC";
2374 case PT_INTERP
: return "INTERP";
2375 case PT_NOTE
: return "NOTE";
2376 case PT_SHLIB
: return "SHLIB";
2377 case PT_PHDR
: return "PHDR";
2378 case PT_TLS
: return "TLS";
2380 case PT_GNU_EH_FRAME
:
2381 return "GNU_EH_FRAME";
2382 case PT_GNU_STACK
: return "GNU_STACK";
2383 case PT_GNU_RELRO
: return "GNU_RELRO";
2386 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2390 switch (elf_header
.e_machine
)
2393 result
= get_arm_segment_type (p_type
);
2396 case EM_MIPS_RS3_LE
:
2397 result
= get_mips_segment_type (p_type
);
2400 result
= get_parisc_segment_type (p_type
);
2403 result
= get_ia64_segment_type (p_type
);
2413 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2415 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2419 switch (elf_header
.e_machine
)
2422 result
= get_parisc_segment_type (p_type
);
2425 result
= get_ia64_segment_type (p_type
);
2435 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2438 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2445 get_mips_section_type_name (unsigned int sh_type
)
2449 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2450 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2451 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2452 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2453 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2454 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2455 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2456 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2457 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2458 case SHT_MIPS_RELD
: return "MIPS_RELD";
2459 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2460 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2461 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2462 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2463 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2464 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2465 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2466 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2467 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2468 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2469 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2470 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2471 case SHT_MIPS_LINE
: return "MIPS_LINE";
2472 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2473 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2474 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2475 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2476 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2477 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2478 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2479 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2480 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2481 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2482 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2483 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2484 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2485 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2486 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2487 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2495 get_parisc_section_type_name (unsigned int sh_type
)
2499 case SHT_PARISC_EXT
: return "PARISC_EXT";
2500 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2501 case SHT_PARISC_DOC
: return "PARISC_DOC";
2509 get_ia64_section_type_name (unsigned int sh_type
)
2511 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2512 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2513 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2517 case SHT_IA_64_EXT
: return "IA_64_EXT";
2518 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2519 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2527 get_x86_64_section_type_name (unsigned int sh_type
)
2531 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2539 get_arm_section_type_name (unsigned int sh_type
)
2552 get_section_type_name (unsigned int sh_type
)
2554 static char buff
[32];
2558 case SHT_NULL
: return "NULL";
2559 case SHT_PROGBITS
: return "PROGBITS";
2560 case SHT_SYMTAB
: return "SYMTAB";
2561 case SHT_STRTAB
: return "STRTAB";
2562 case SHT_RELA
: return "RELA";
2563 case SHT_HASH
: return "HASH";
2564 case SHT_DYNAMIC
: return "DYNAMIC";
2565 case SHT_NOTE
: return "NOTE";
2566 case SHT_NOBITS
: return "NOBITS";
2567 case SHT_REL
: return "REL";
2568 case SHT_SHLIB
: return "SHLIB";
2569 case SHT_DYNSYM
: return "DYNSYM";
2570 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2571 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2572 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2573 case SHT_GROUP
: return "GROUP";
2574 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2575 case SHT_GNU_verdef
: return "VERDEF";
2576 case SHT_GNU_verneed
: return "VERNEED";
2577 case SHT_GNU_versym
: return "VERSYM";
2578 case 0x6ffffff0: return "VERSYM";
2579 case 0x6ffffffc: return "VERDEF";
2580 case 0x7ffffffd: return "AUXILIARY";
2581 case 0x7fffffff: return "FILTER";
2582 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2585 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2589 switch (elf_header
.e_machine
)
2592 case EM_MIPS_RS3_LE
:
2593 result
= get_mips_section_type_name (sh_type
);
2596 result
= get_parisc_section_type_name (sh_type
);
2599 result
= get_ia64_section_type_name (sh_type
);
2602 result
= get_x86_64_section_type_name (sh_type
);
2605 result
= get_arm_section_type_name (sh_type
);
2615 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2617 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2618 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2619 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2620 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2622 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2628 #define OPTION_DEBUG_DUMP 512
2630 static struct option options
[] =
2632 {"all", no_argument
, 0, 'a'},
2633 {"file-header", no_argument
, 0, 'h'},
2634 {"program-headers", no_argument
, 0, 'l'},
2635 {"headers", no_argument
, 0, 'e'},
2636 {"histogram", no_argument
, 0, 'I'},
2637 {"segments", no_argument
, 0, 'l'},
2638 {"sections", no_argument
, 0, 'S'},
2639 {"section-headers", no_argument
, 0, 'S'},
2640 {"section-groups", no_argument
, 0, 'g'},
2641 {"full-section-name",no_argument
, 0, 'N'},
2642 {"symbols", no_argument
, 0, 's'},
2643 {"syms", no_argument
, 0, 's'},
2644 {"relocs", no_argument
, 0, 'r'},
2645 {"notes", no_argument
, 0, 'n'},
2646 {"dynamic", no_argument
, 0, 'd'},
2647 {"arch-specific", no_argument
, 0, 'A'},
2648 {"version-info", no_argument
, 0, 'V'},
2649 {"use-dynamic", no_argument
, 0, 'D'},
2650 {"hex-dump", required_argument
, 0, 'x'},
2651 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2652 {"unwind", no_argument
, 0, 'u'},
2653 #ifdef SUPPORT_DISASSEMBLY
2654 {"instruction-dump", required_argument
, 0, 'i'},
2657 {"version", no_argument
, 0, 'v'},
2658 {"wide", no_argument
, 0, 'W'},
2659 {"help", no_argument
, 0, 'H'},
2660 {0, no_argument
, 0, 0}
2666 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2667 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2668 fprintf (stdout
, _(" Options are:\n\
2669 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2670 -h --file-header Display the ELF file header\n\
2671 -l --program-headers Display the program headers\n\
2672 --segments An alias for --program-headers\n\
2673 -S --section-headers Display the sections' header\n\
2674 --sections An alias for --section-headers\n\
2675 -g --section-groups Display the section groups\n\
2676 -N --full-section-name\n\
2677 Display the full section name\n\
2678 -e --headers Equivalent to: -h -l -S\n\
2679 -s --syms Display the symbol table\n\
2680 --symbols An alias for --syms\n\
2681 -n --notes Display the core notes (if present)\n\
2682 -r --relocs Display the relocations (if present)\n\
2683 -u --unwind Display the unwind info (if present)\n\
2684 -d --dynamic Display the dynamic section (if present)\n\
2685 -V --version-info Display the version sections (if present)\n\
2686 -A --arch-specific Display architecture specific information (if any).\n\
2687 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2688 -x --hex-dump=<number> Dump the contents of section <number>\n\
2689 -w[liaprmfFsoR] or\n\
2690 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2691 Display the contents of DWARF2 debug sections\n"));
2692 #ifdef SUPPORT_DISASSEMBLY
2693 fprintf (stdout
, _("\
2694 -i --instruction-dump=<number>\n\
2695 Disassemble the contents of section <number>\n"));
2697 fprintf (stdout
, _("\
2698 -I --histogram Display histogram of bucket list lengths\n\
2699 -W --wide Allow output width to exceed 80 characters\n\
2700 -H --help Display this information\n\
2701 -v --version Display the version number of readelf\n"));
2702 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2707 /* Record the fact that the user wants the contents of section number
2708 SECTION to be displayed using the method(s) encoded as flags bits
2709 in TYPE. Note, TYPE can be zero if we are creating the array for
2713 request_dump (unsigned int section
, int type
)
2715 if (section
>= num_dump_sects
)
2717 char *new_dump_sects
;
2719 new_dump_sects
= calloc (section
+ 1, 1);
2721 if (new_dump_sects
== NULL
)
2722 error (_("Out of memory allocating dump request table."));
2725 /* Copy current flag settings. */
2726 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2730 dump_sects
= new_dump_sects
;
2731 num_dump_sects
= section
+ 1;
2736 dump_sects
[section
] |= type
;
2742 parse_args (int argc
, char **argv
)
2749 while ((c
= getopt_long
2750 (argc
, argv
, "ersuahnldSDAINgw::x:i:vVWH", options
, NULL
)) != EOF
)
2771 do_section_groups
++;
2779 do_section_groups
++;
2782 do_full_section_name
++;
2824 section
= strtoul (optarg
, & cp
, 0);
2825 if (! *cp
&& section
>= 0)
2827 request_dump (section
, HEX_DUMP
);
2837 unsigned int index
= 0;
2841 while (optarg
[index
])
2842 switch (optarg
[index
++])
2851 do_debug_abbrevs
= 1;
2861 do_debug_pubnames
= 1;
2865 do_debug_aranges
= 1;
2869 do_debug_ranges
= 1;
2873 do_debug_frames_interp
= 1;
2875 do_debug_frames
= 1;
2880 do_debug_macinfo
= 1;
2894 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2899 case OPTION_DEBUG_DUMP
:
2907 const char * option
;
2910 debug_dump_long_opts
;
2912 debug_dump_long_opts opts_table
[] =
2914 /* Please keep this table alpha- sorted. */
2915 { "Ranges", & do_debug_ranges
},
2916 { "abbrev", & do_debug_abbrevs
},
2917 { "aranges", & do_debug_aranges
},
2918 { "frames", & do_debug_frames
},
2919 { "frames-interp", & do_debug_frames_interp
},
2920 { "info", & do_debug_info
},
2921 { "line", & do_debug_lines
},
2922 { "loc", & do_debug_loc
},
2923 { "macro", & do_debug_macinfo
},
2924 { "pubnames", & do_debug_pubnames
},
2925 /* This entry is for compatability
2926 with earlier versions of readelf. */
2927 { "ranges", & do_debug_aranges
},
2928 { "str", & do_debug_str
},
2939 debug_dump_long_opts
* entry
;
2941 for (entry
= opts_table
; entry
->option
; entry
++)
2943 size_t len
= strlen (entry
->option
);
2945 if (strneq (p
, entry
->option
, len
)
2946 && (p
[len
] == ',' || p
[len
] == '\0'))
2948 * entry
->variable
= 1;
2950 /* The --debug-dump=frames-interp option also
2951 enables the --debug-dump=frames option. */
2952 if (do_debug_frames_interp
)
2953 do_debug_frames
= 1;
2960 if (entry
->option
== NULL
)
2962 warn (_("Unrecognized debug option '%s'\n"), p
);
2963 p
= strchr (p
, ',');
2973 #ifdef SUPPORT_DISASSEMBLY
2976 section
= strtoul (optarg
, & cp
, 0);
2977 if (! *cp
&& section
>= 0)
2979 request_dump (section
, DISASS_DUMP
);
2985 print_version (program_name
);
2995 /* xgettext:c-format */
2996 error (_("Invalid option '-%c'\n"), c
);
3003 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3004 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3005 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3006 && !do_section_groups
)
3010 warn (_("Nothing to do.\n"));
3016 get_elf_class (unsigned int elf_class
)
3018 static char buff
[32];
3022 case ELFCLASSNONE
: return _("none");
3023 case ELFCLASS32
: return "ELF32";
3024 case ELFCLASS64
: return "ELF64";
3026 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3032 get_data_encoding (unsigned int encoding
)
3034 static char buff
[32];
3038 case ELFDATANONE
: return _("none");
3039 case ELFDATA2LSB
: return _("2's complement, little endian");
3040 case ELFDATA2MSB
: return _("2's complement, big endian");
3042 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3047 /* Decode the data held in 'elf_header'. */
3050 process_file_header (void)
3052 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3053 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3054 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3055 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3058 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3066 printf (_("ELF Header:\n"));
3067 printf (_(" Magic: "));
3068 for (i
= 0; i
< EI_NIDENT
; i
++)
3069 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3071 printf (_(" Class: %s\n"),
3072 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3073 printf (_(" Data: %s\n"),
3074 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3075 printf (_(" Version: %d %s\n"),
3076 elf_header
.e_ident
[EI_VERSION
],
3077 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3079 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3082 printf (_(" OS/ABI: %s\n"),
3083 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3084 printf (_(" ABI Version: %d\n"),
3085 elf_header
.e_ident
[EI_ABIVERSION
]);
3086 printf (_(" Type: %s\n"),
3087 get_file_type (elf_header
.e_type
));
3088 printf (_(" Machine: %s\n"),
3089 get_machine_name (elf_header
.e_machine
));
3090 printf (_(" Version: 0x%lx\n"),
3091 (unsigned long) elf_header
.e_version
);
3093 printf (_(" Entry point address: "));
3094 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3095 printf (_("\n Start of program headers: "));
3096 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3097 printf (_(" (bytes into file)\n Start of section headers: "));
3098 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3099 printf (_(" (bytes into file)\n"));
3101 printf (_(" Flags: 0x%lx%s\n"),
3102 (unsigned long) elf_header
.e_flags
,
3103 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3104 printf (_(" Size of this header: %ld (bytes)\n"),
3105 (long) elf_header
.e_ehsize
);
3106 printf (_(" Size of program headers: %ld (bytes)\n"),
3107 (long) elf_header
.e_phentsize
);
3108 printf (_(" Number of program headers: %ld\n"),
3109 (long) elf_header
.e_phnum
);
3110 printf (_(" Size of section headers: %ld (bytes)\n"),
3111 (long) elf_header
.e_shentsize
);
3112 printf (_(" Number of section headers: %ld"),
3113 (long) elf_header
.e_shnum
);
3114 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3115 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3116 putc ('\n', stdout
);
3117 printf (_(" Section header string table index: %ld"),
3118 (long) elf_header
.e_shstrndx
);
3119 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3120 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3121 putc ('\n', stdout
);
3124 if (section_headers
!= NULL
)
3126 if (elf_header
.e_shnum
== 0)
3127 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3128 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3129 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3130 free (section_headers
);
3131 section_headers
= NULL
;
3139 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3141 Elf32_External_Phdr
*phdrs
;
3142 Elf32_External_Phdr
*external
;
3143 Elf_Internal_Phdr
*internal
;
3146 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3147 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3148 _("program headers"));
3152 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3153 i
< elf_header
.e_phnum
;
3154 i
++, internal
++, external
++)
3156 internal
->p_type
= BYTE_GET (external
->p_type
);
3157 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3158 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3159 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3160 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3161 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3162 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3163 internal
->p_align
= BYTE_GET (external
->p_align
);
3172 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3174 Elf64_External_Phdr
*phdrs
;
3175 Elf64_External_Phdr
*external
;
3176 Elf_Internal_Phdr
*internal
;
3179 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3180 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3181 _("program headers"));
3185 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3186 i
< elf_header
.e_phnum
;
3187 i
++, internal
++, external
++)
3189 internal
->p_type
= BYTE_GET (external
->p_type
);
3190 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3191 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3192 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3193 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3194 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3195 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3196 internal
->p_align
= BYTE_GET (external
->p_align
);
3204 /* Returns 1 if the program headers were read into `program_headers'. */
3207 get_program_headers (FILE *file
)
3209 Elf_Internal_Phdr
*phdrs
;
3211 /* Check cache of prior read. */
3212 if (program_headers
!= NULL
)
3215 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3219 error (_("Out of memory\n"));
3224 ? get_32bit_program_headers (file
, phdrs
)
3225 : get_64bit_program_headers (file
, phdrs
))
3227 program_headers
= phdrs
;
3235 /* Returns 1 if the program headers were loaded. */
3238 process_program_headers (FILE *file
)
3240 Elf_Internal_Phdr
*segment
;
3243 if (elf_header
.e_phnum
== 0)
3246 printf (_("\nThere are no program headers in this file.\n"));
3250 if (do_segments
&& !do_header
)
3252 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3253 printf (_("Entry point "));
3254 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3255 printf (_("\nThere are %d program headers, starting at offset "),
3256 elf_header
.e_phnum
);
3257 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3261 if (! get_program_headers (file
))
3266 if (elf_header
.e_phnum
> 1)
3267 printf (_("\nProgram Headers:\n"));
3269 printf (_("\nProgram Headers:\n"));
3273 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3276 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3280 (_(" Type Offset VirtAddr PhysAddr\n"));
3282 (_(" FileSiz MemSiz Flags Align\n"));
3289 for (i
= 0, segment
= program_headers
;
3290 i
< elf_header
.e_phnum
;
3295 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3299 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3300 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3301 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3302 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3303 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3305 (segment
->p_flags
& PF_R
? 'R' : ' '),
3306 (segment
->p_flags
& PF_W
? 'W' : ' '),
3307 (segment
->p_flags
& PF_X
? 'E' : ' '));
3308 printf ("%#lx", (unsigned long) segment
->p_align
);
3312 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3313 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3316 print_vma (segment
->p_offset
, FULL_HEX
);
3320 print_vma (segment
->p_vaddr
, FULL_HEX
);
3322 print_vma (segment
->p_paddr
, FULL_HEX
);
3325 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3326 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3329 print_vma (segment
->p_filesz
, FULL_HEX
);
3333 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3334 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3337 print_vma (segment
->p_offset
, FULL_HEX
);
3341 (segment
->p_flags
& PF_R
? 'R' : ' '),
3342 (segment
->p_flags
& PF_W
? 'W' : ' '),
3343 (segment
->p_flags
& PF_X
? 'E' : ' '));
3345 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3346 printf ("%#lx", (unsigned long) segment
->p_align
);
3349 print_vma (segment
->p_align
, PREFIX_HEX
);
3354 print_vma (segment
->p_offset
, FULL_HEX
);
3356 print_vma (segment
->p_vaddr
, FULL_HEX
);
3358 print_vma (segment
->p_paddr
, FULL_HEX
);
3360 print_vma (segment
->p_filesz
, FULL_HEX
);
3362 print_vma (segment
->p_memsz
, FULL_HEX
);
3364 (segment
->p_flags
& PF_R
? 'R' : ' '),
3365 (segment
->p_flags
& PF_W
? 'W' : ' '),
3366 (segment
->p_flags
& PF_X
? 'E' : ' '));
3367 print_vma (segment
->p_align
, HEX
);
3371 switch (segment
->p_type
)
3375 error (_("more than one dynamic segment\n"));
3377 /* Try to locate the .dynamic section. If there is
3378 a section header table, we can easily locate it. */
3379 if (section_headers
!= NULL
)
3381 Elf_Internal_Shdr
*sec
;
3383 sec
= find_section (".dynamic");
3384 if (sec
== NULL
|| sec
->sh_size
== 0)
3386 error (_("no .dynamic section in the dynamic segment"));
3390 dynamic_addr
= sec
->sh_offset
;
3391 dynamic_size
= sec
->sh_size
;
3393 if (dynamic_addr
< segment
->p_offset
3394 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3395 warn (_("the .dynamic section is not contained within the dynamic segment"));
3396 else if (dynamic_addr
> segment
->p_offset
)
3397 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3401 /* Otherwise, we can only assume that the .dynamic
3402 section is the first section in the DYNAMIC segment. */
3403 dynamic_addr
= segment
->p_offset
;
3404 dynamic_size
= segment
->p_filesz
;
3409 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3411 error (_("Unable to find program interpreter name\n"));
3414 program_interpreter
[0] = 0;
3415 fscanf (file
, "%63s", program_interpreter
);
3418 printf (_("\n [Requesting program interpreter: %s]"),
3419 program_interpreter
);
3425 putc ('\n', stdout
);
3428 if (do_segments
&& section_headers
!= NULL
)
3430 printf (_("\n Section to Segment mapping:\n"));
3431 printf (_(" Segment Sections...\n"));
3433 assert (string_table
!= NULL
);
3435 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3438 Elf_Internal_Shdr
*section
;
3440 segment
= program_headers
+ i
;
3441 section
= section_headers
;
3443 printf (" %2.2d ", i
);
3445 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3447 if (section
->sh_size
> 0
3448 /* Compare allocated sections by VMA, unallocated
3449 sections by file offset. */
3450 && (section
->sh_flags
& SHF_ALLOC
3451 ? (section
->sh_addr
>= segment
->p_vaddr
3452 && section
->sh_addr
+ section
->sh_size
3453 <= segment
->p_vaddr
+ segment
->p_memsz
)
3454 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3455 && (section
->sh_offset
+ section
->sh_size
3456 <= segment
->p_offset
+ segment
->p_filesz
)))
3457 /* .tbss is special. It doesn't contribute memory space
3458 to normal segments. */
3459 && (!((section
->sh_flags
& SHF_TLS
) != 0
3460 && section
->sh_type
== SHT_NOBITS
)
3461 || segment
->p_type
== PT_TLS
))
3462 printf ("%s ", SECTION_NAME (section
));
3473 /* Find the file offset corresponding to VMA by using the program headers. */
3476 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3478 Elf_Internal_Phdr
*seg
;
3480 if (! get_program_headers (file
))
3482 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3486 for (seg
= program_headers
;
3487 seg
< program_headers
+ elf_header
.e_phnum
;
3490 if (seg
->p_type
!= PT_LOAD
)
3493 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3494 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3495 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3498 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3505 get_32bit_section_headers (FILE *file
, unsigned int num
)
3507 Elf32_External_Shdr
*shdrs
;
3508 Elf_Internal_Shdr
*internal
;
3511 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3512 elf_header
.e_shentsize
* num
, _("section headers"));
3516 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3518 if (section_headers
== NULL
)
3520 error (_("Out of memory\n"));
3524 for (i
= 0, internal
= section_headers
;
3528 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3529 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3530 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3531 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3532 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3533 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3534 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3535 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3536 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3537 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3546 get_64bit_section_headers (FILE *file
, unsigned int num
)
3548 Elf64_External_Shdr
*shdrs
;
3549 Elf_Internal_Shdr
*internal
;
3552 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3553 elf_header
.e_shentsize
* num
, _("section headers"));
3557 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3559 if (section_headers
== NULL
)
3561 error (_("Out of memory\n"));
3565 for (i
= 0, internal
= section_headers
;
3569 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3570 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3571 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3572 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3573 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3574 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3575 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3576 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3577 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3578 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3586 static Elf_Internal_Sym
*
3587 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3589 unsigned long number
;
3590 Elf32_External_Sym
*esyms
;
3591 Elf_External_Sym_Shndx
*shndx
;
3592 Elf_Internal_Sym
*isyms
;
3593 Elf_Internal_Sym
*psym
;
3596 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3602 if (symtab_shndx_hdr
!= NULL
3603 && (symtab_shndx_hdr
->sh_link
3604 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3606 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3607 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3615 number
= section
->sh_size
/ section
->sh_entsize
;
3616 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3620 error (_("Out of memory\n"));
3627 for (j
= 0, psym
= isyms
;
3631 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3632 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3633 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3634 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3635 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3637 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3638 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3639 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3649 static Elf_Internal_Sym
*
3650 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3652 unsigned long number
;
3653 Elf64_External_Sym
*esyms
;
3654 Elf_External_Sym_Shndx
*shndx
;
3655 Elf_Internal_Sym
*isyms
;
3656 Elf_Internal_Sym
*psym
;
3659 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3665 if (symtab_shndx_hdr
!= NULL
3666 && (symtab_shndx_hdr
->sh_link
3667 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3669 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3670 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3678 number
= section
->sh_size
/ section
->sh_entsize
;
3679 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3683 error (_("Out of memory\n"));
3690 for (j
= 0, psym
= isyms
;
3694 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3695 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3696 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3697 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3698 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3700 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3701 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3702 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3713 get_elf_section_flags (bfd_vma sh_flags
)
3715 static char buff
[33];
3722 flag
= sh_flags
& - sh_flags
;
3727 case SHF_WRITE
: *p
= 'W'; break;
3728 case SHF_ALLOC
: *p
= 'A'; break;
3729 case SHF_EXECINSTR
: *p
= 'X'; break;
3730 case SHF_MERGE
: *p
= 'M'; break;
3731 case SHF_STRINGS
: *p
= 'S'; break;
3732 case SHF_INFO_LINK
: *p
= 'I'; break;
3733 case SHF_LINK_ORDER
: *p
= 'L'; break;
3734 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3735 case SHF_GROUP
: *p
= 'G'; break;
3736 case SHF_TLS
: *p
= 'T'; break;
3739 if (flag
& SHF_MASKOS
)
3742 sh_flags
&= ~ SHF_MASKOS
;
3744 else if (flag
& SHF_MASKPROC
)
3747 sh_flags
&= ~ SHF_MASKPROC
;
3761 process_section_headers (FILE *file
)
3763 Elf_Internal_Shdr
*section
;
3766 section_headers
= NULL
;
3768 if (elf_header
.e_shnum
== 0)
3771 printf (_("\nThere are no sections in this file.\n"));
3776 if (do_sections
&& !do_header
)
3777 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3778 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3782 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3785 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3788 /* Read in the string table, so that we have names to display. */
3789 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3791 if (section
->sh_size
!= 0)
3793 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3794 section
->sh_size
, _("string table"));
3796 if (string_table
== NULL
)
3799 string_table_length
= section
->sh_size
;
3802 /* Scan the sections for the dynamic symbol table
3803 and dynamic string table and debug sections. */
3804 dynamic_symbols
= NULL
;
3805 dynamic_strings
= NULL
;
3806 dynamic_syminfo
= NULL
;
3807 symtab_shndx_hdr
= NULL
;
3809 eh_addr_size
= is_32bit_elf
? 4 : 8;
3810 switch (elf_header
.e_machine
)
3813 case EM_MIPS_RS3_LE
:
3814 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3815 FDE addresses. However, the ABI also has a semi-official ILP32
3816 variant for which the normal FDE address size rules apply.
3818 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3819 section, where XX is the size of longs in bits. Unfortunately,
3820 earlier compilers provided no way of distinguishing ILP32 objects
3821 from LP64 objects, so if there's any doubt, we should assume that
3822 the official LP64 form is being used. */
3823 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3824 && find_section (".gcc_compiled_long32") == NULL
)
3829 for (i
= 0, section
= section_headers
;
3830 i
< elf_header
.e_shnum
;
3833 char *name
= SECTION_NAME (section
);
3835 if (section
->sh_type
== SHT_DYNSYM
)
3837 if (dynamic_symbols
!= NULL
)
3839 error (_("File contains multiple dynamic symbol tables\n"));
3843 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3844 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3846 else if (section
->sh_type
== SHT_STRTAB
3847 && streq (name
, ".dynstr"))
3849 if (dynamic_strings
!= NULL
)
3851 error (_("File contains multiple dynamic string tables\n"));
3855 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3856 section
->sh_size
, _("dynamic strings"));
3857 dynamic_strings_length
= section
->sh_size
;
3859 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3861 if (symtab_shndx_hdr
!= NULL
)
3863 error (_("File contains multiple symtab shndx tables\n"));
3866 symtab_shndx_hdr
= section
;
3868 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3869 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3870 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3871 || do_debug_loc
|| do_debug_ranges
)
3872 && strneq (name
, ".debug_", 7))
3877 || (do_debug_info
&& streq (name
, "info"))
3878 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3879 || (do_debug_lines
&& streq (name
, "line"))
3880 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3881 || (do_debug_aranges
&& streq (name
, "aranges"))
3882 || (do_debug_ranges
&& streq (name
, "ranges"))
3883 || (do_debug_frames
&& streq (name
, "frame"))
3884 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3885 || (do_debug_str
&& streq (name
, "str"))
3886 || (do_debug_loc
&& streq (name
, "loc"))
3888 request_dump (i
, DEBUG_DUMP
);
3890 /* linkonce section to be combined with .debug_info at link time. */
3891 else if ((do_debugging
|| do_debug_info
)
3892 && strneq (name
, ".gnu.linkonce.wi.", 17))
3893 request_dump (i
, DEBUG_DUMP
);
3894 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3895 request_dump (i
, DEBUG_DUMP
);
3901 if (elf_header
.e_shnum
> 1)
3902 printf (_("\nSection Headers:\n"));
3904 printf (_("\nSection Header:\n"));
3908 if (do_full_section_name
)
3910 printf (_(" [Nr] Name\n"));
3911 printf (_(" Type Addr Off Size ES Flg Lk Inf Al\n"));
3915 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3919 if (do_full_section_name
)
3921 printf (_(" [Nr] Name\n"));
3922 printf (_(" Type Address Off Size ES Flg Lk Inf Al\n"));
3926 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3930 if (do_full_section_name
)
3932 printf (_(" [Nr] Name\n"));
3933 printf (_(" Flags Type Address Offset\n"));
3934 printf (_(" Size EntSize Link Info Align\n"));
3938 printf (_(" [Nr] Name Type Address Offset\n"));
3939 printf (_(" Size EntSize Flags Link Info Align\n"));
3943 for (i
= 0, section
= section_headers
;
3944 i
< elf_header
.e_shnum
;
3947 if (do_full_section_name
)
3949 printf (" [%2u] %s\n",
3950 SECTION_HEADER_NUM (i
),
3951 SECTION_NAME (section
));
3952 if (is_32bit_elf
|| do_wide
)
3953 printf (" %-15.15s ",
3954 get_section_type_name (section
->sh_type
));
3957 printf (" [%2u] %-17.17s %-15.15s ",
3958 SECTION_HEADER_NUM (i
),
3959 SECTION_NAME (section
),
3960 get_section_type_name (section
->sh_type
));
3964 print_vma (section
->sh_addr
, LONG_HEX
);
3966 printf ( " %6.6lx %6.6lx %2.2lx",
3967 (unsigned long) section
->sh_offset
,
3968 (unsigned long) section
->sh_size
,
3969 (unsigned long) section
->sh_entsize
);
3971 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3973 printf ("%2ld %3lu %2ld\n",
3974 (unsigned long) section
->sh_link
,
3975 (unsigned long) section
->sh_info
,
3976 (unsigned long) section
->sh_addralign
);
3980 print_vma (section
->sh_addr
, LONG_HEX
);
3982 if ((long) section
->sh_offset
== section
->sh_offset
)
3983 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3987 print_vma (section
->sh_offset
, LONG_HEX
);
3990 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3991 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3995 print_vma (section
->sh_size
, LONG_HEX
);
3998 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3999 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4003 print_vma (section
->sh_entsize
, LONG_HEX
);
4006 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4008 printf ("%2ld %3lu ",
4009 (unsigned long) section
->sh_link
,
4010 (unsigned long) section
->sh_info
);
4012 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4013 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4016 print_vma (section
->sh_addralign
, DEC
);
4020 else if (do_full_section_name
)
4022 printf (" %-15.15s %-15.15s ",
4023 get_elf_section_flags (section
->sh_flags
),
4024 get_section_type_name (section
->sh_type
));
4026 print_vma (section
->sh_addr
, LONG_HEX
);
4027 if ((long) section
->sh_offset
== section
->sh_offset
)
4028 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4032 print_vma (section
->sh_offset
, LONG_HEX
);
4035 print_vma (section
->sh_size
, LONG_HEX
);
4037 print_vma (section
->sh_entsize
, LONG_HEX
);
4039 printf (" %2ld %3lu %ld\n",
4040 (unsigned long) section
->sh_link
,
4041 (unsigned long) section
->sh_info
,
4042 (unsigned long) section
->sh_addralign
);
4047 print_vma (section
->sh_addr
, LONG_HEX
);
4048 if ((long) section
->sh_offset
== section
->sh_offset
)
4049 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4053 print_vma (section
->sh_offset
, LONG_HEX
);
4056 print_vma (section
->sh_size
, LONG_HEX
);
4058 print_vma (section
->sh_entsize
, LONG_HEX
);
4060 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4062 printf (" %2ld %3lu %ld\n",
4063 (unsigned long) section
->sh_link
,
4064 (unsigned long) section
->sh_info
,
4065 (unsigned long) section
->sh_addralign
);
4069 printf (_("Key to Flags:\n\
4070 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4071 I (info), L (link order), G (group), x (unknown)\n\
4072 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4078 get_group_flags (unsigned int flags
)
4080 static char buff
[32];
4087 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4094 process_section_groups (FILE *file
)
4096 Elf_Internal_Shdr
*section
;
4098 struct group
*group
;
4099 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4100 Elf_Internal_Sym
*symtab
;
4103 /* Don't process section groups unless needed. */
4104 if (!do_unwind
&& !do_section_groups
)
4107 if (elf_header
.e_shnum
== 0)
4109 if (do_section_groups
)
4110 printf (_("\nThere are no sections in this file.\n"));
4115 if (section_headers
== NULL
)
4117 error (_("Section headers are not available!\n"));
4121 section_headers_groups
= calloc (elf_header
.e_shnum
,
4122 sizeof (struct group
*));
4124 if (section_headers_groups
== NULL
)
4126 error (_("Out of memory\n"));
4130 /* Scan the sections for the group section. */
4132 for (i
= 0, section
= section_headers
;
4133 i
< elf_header
.e_shnum
;
4135 if (section
->sh_type
== SHT_GROUP
)
4138 if (group_count
== 0)
4140 if (do_section_groups
)
4141 printf (_("\nThere are no section groups in this file.\n"));
4146 section_groups
= calloc (group_count
, sizeof (struct group
));
4148 if (section_groups
== NULL
)
4150 error (_("Out of memory\n"));
4158 for (i
= 0, section
= section_headers
, group
= section_groups
;
4159 i
< elf_header
.e_shnum
;
4162 if (section
->sh_type
== SHT_GROUP
)
4164 char *name
= SECTION_NAME (section
);
4166 unsigned char *start
, *indices
;
4167 unsigned int entry
, j
, size
;
4168 Elf_Internal_Shdr
*sec
;
4169 Elf_Internal_Sym
*sym
;
4171 /* Get the symbol table. */
4172 sec
= SECTION_HEADER (section
->sh_link
);
4173 if (sec
->sh_type
!= SHT_SYMTAB
)
4175 error (_("Bad sh_link in group section `%s'\n"), name
);
4179 if (symtab_sec
!= sec
)
4184 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4187 sym
= symtab
+ section
->sh_info
;
4189 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4191 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4194 error (_("Bad sh_info in group section `%s'\n"), name
);
4198 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4203 /* Get the string table. */
4204 sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4205 if (strtab_sec
!= sec
)
4210 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4211 strtab_sec
->sh_size
,
4214 group_name
= strtab
+ sym
->st_name
;
4217 start
= get_data (NULL
, file
, section
->sh_offset
,
4218 section
->sh_size
, _("section data"));
4221 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4222 entry
= byte_get (indices
, 4);
4225 if (do_section_groups
)
4227 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4228 get_group_flags (entry
), i
, name
, group_name
, size
);
4230 printf (_(" [Index] Name\n"));
4233 group
->group_index
= i
;
4235 for (j
= 0; j
< size
; j
++)
4237 struct group_list
*g
;
4239 entry
= byte_get (indices
, 4);
4242 if (entry
>= elf_header
.e_shnum
)
4244 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4245 entry
, i
, elf_header
.e_shnum
- 1);
4248 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4250 error (_("invalid section [%5u] in group section [%5u]\n"),
4255 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4260 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4262 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4267 /* Intel C/C++ compiler may put section 0 in a
4268 section group. We just warn it the first time
4269 and ignore it afterwards. */
4270 static int warned
= 0;
4273 error (_("section 0 in group section [%5u]\n"),
4274 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4280 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4283 if (do_section_groups
)
4285 sec
= SECTION_HEADER (entry
);
4286 printf (" [%5u] %s\n",
4287 entry
, SECTION_NAME (sec
));
4290 g
= xmalloc (sizeof (struct group_list
));
4291 g
->section_index
= entry
;
4292 g
->next
= group
->root
;
4316 } dynamic_relocations
[] =
4318 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4319 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4320 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4323 /* Process the reloc section. */
4326 process_relocs (FILE *file
)
4328 unsigned long rel_size
;
4329 unsigned long rel_offset
;
4335 if (do_using_dynamic
)
4339 int has_dynamic_reloc
;
4342 has_dynamic_reloc
= 0;
4344 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4346 is_rela
= dynamic_relocations
[i
].rela
;
4347 name
= dynamic_relocations
[i
].name
;
4348 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4349 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4351 has_dynamic_reloc
|= rel_size
;
4353 if (is_rela
== UNKNOWN
)
4355 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4356 switch (dynamic_info
[DT_PLTREL
])
4370 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4371 name
, rel_offset
, rel_size
);
4373 dump_relocations (file
,
4374 offset_from_vma (file
, rel_offset
, rel_size
),
4376 dynamic_symbols
, num_dynamic_syms
,
4377 dynamic_strings
, dynamic_strings_length
, is_rela
);
4381 if (! has_dynamic_reloc
)
4382 printf (_("\nThere are no dynamic relocations in this file.\n"));
4386 Elf_Internal_Shdr
*section
;
4390 for (i
= 0, section
= section_headers
;
4391 i
< elf_header
.e_shnum
;
4394 if ( section
->sh_type
!= SHT_RELA
4395 && section
->sh_type
!= SHT_REL
)
4398 rel_offset
= section
->sh_offset
;
4399 rel_size
= section
->sh_size
;
4403 Elf_Internal_Shdr
*strsec
;
4406 printf (_("\nRelocation section "));
4408 if (string_table
== NULL
)
4409 printf ("%d", section
->sh_name
);
4411 printf (_("'%s'"), SECTION_NAME (section
));
4413 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4414 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4416 is_rela
= section
->sh_type
== SHT_RELA
;
4418 if (section
->sh_link
)
4420 Elf_Internal_Shdr
*symsec
;
4421 Elf_Internal_Sym
*symtab
;
4422 unsigned long nsyms
;
4423 unsigned long strtablen
;
4424 char *strtab
= NULL
;
4426 symsec
= SECTION_HEADER (section
->sh_link
);
4427 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4428 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4433 strsec
= SECTION_HEADER (symsec
->sh_link
);
4435 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4436 strsec
->sh_size
, _("string table"));
4437 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4439 dump_relocations (file
, rel_offset
, rel_size
,
4440 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4446 dump_relocations (file
, rel_offset
, rel_size
,
4447 NULL
, 0, NULL
, 0, is_rela
);
4454 printf (_("\nThere are no relocations in this file.\n"));
4460 /* Process the unwind section. */
4462 #include "unwind-ia64.h"
4464 /* An absolute address consists of a section and an offset. If the
4465 section is NULL, the offset itself is the address, otherwise, the
4466 address equals to LOAD_ADDRESS(section) + offset. */
4470 unsigned short section
;
4474 struct ia64_unw_aux_info
4476 struct ia64_unw_table_entry
4478 struct absaddr start
;
4480 struct absaddr info
;
4482 *table
; /* Unwind table. */
4483 unsigned long table_len
; /* Length of unwind table. */
4484 unsigned char *info
; /* Unwind info. */
4485 unsigned long info_size
; /* Size of unwind info. */
4486 bfd_vma info_addr
; /* starting address of unwind info. */
4487 bfd_vma seg_base
; /* Starting address of segment. */
4488 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4489 unsigned long nsyms
; /* Number of symbols. */
4490 char *strtab
; /* The string table. */
4491 unsigned long strtab_size
; /* Size of string table. */
4495 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4496 unsigned long nsyms
,
4498 unsigned long strtab_size
,
4499 struct absaddr addr
,
4500 const char **symname
,
4503 bfd_vma dist
= 0x100000;
4504 Elf_Internal_Sym
*sym
, *best
= NULL
;
4507 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4509 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4510 && sym
->st_name
!= 0
4511 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4512 && addr
.offset
>= sym
->st_value
4513 && addr
.offset
- sym
->st_value
< dist
)
4516 dist
= addr
.offset
- sym
->st_value
;
4523 *symname
= (best
->st_name
>= strtab_size
4524 ? "<corrupt>" : strtab
+ best
->st_name
);
4529 *offset
= addr
.offset
;
4533 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4535 struct ia64_unw_table_entry
*tp
;
4538 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4542 const unsigned char *dp
;
4543 const unsigned char *head
;
4544 const char *procname
;
4546 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4547 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4549 fputs ("\n<", stdout
);
4553 fputs (procname
, stdout
);
4556 printf ("+%lx", (unsigned long) offset
);
4559 fputs (">: [", stdout
);
4560 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4561 fputc ('-', stdout
);
4562 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4563 printf ("], info at +0x%lx\n",
4564 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4566 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4567 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4569 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4570 (unsigned) UNW_VER (stamp
),
4571 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4572 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4573 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4574 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4576 if (UNW_VER (stamp
) != 1)
4578 printf ("\tUnknown version.\n");
4583 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4584 dp
= unw_decode (dp
, in_body
, & in_body
);
4589 slurp_ia64_unwind_table (FILE *file
,
4590 struct ia64_unw_aux_info
*aux
,
4591 Elf_Internal_Shdr
*sec
)
4593 unsigned long size
, nrelas
, i
;
4594 Elf_Internal_Phdr
*seg
;
4595 struct ia64_unw_table_entry
*tep
;
4596 Elf_Internal_Shdr
*relsec
;
4597 Elf_Internal_Rela
*rela
, *rp
;
4598 unsigned char *table
, *tp
;
4599 Elf_Internal_Sym
*sym
;
4600 const char *relname
;
4602 /* First, find the starting address of the segment that includes
4605 if (elf_header
.e_phnum
)
4607 if (! get_program_headers (file
))
4610 for (seg
= program_headers
;
4611 seg
< program_headers
+ elf_header
.e_phnum
;
4614 if (seg
->p_type
!= PT_LOAD
)
4617 if (sec
->sh_addr
>= seg
->p_vaddr
4618 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4620 aux
->seg_base
= seg
->p_vaddr
;
4626 /* Second, build the unwind table from the contents of the unwind section: */
4627 size
= sec
->sh_size
;
4628 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4632 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4634 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4636 tep
->start
.section
= SHN_UNDEF
;
4637 tep
->end
.section
= SHN_UNDEF
;
4638 tep
->info
.section
= SHN_UNDEF
;
4641 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4642 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4643 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4647 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4648 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4649 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4651 tep
->start
.offset
+= aux
->seg_base
;
4652 tep
->end
.offset
+= aux
->seg_base
;
4653 tep
->info
.offset
+= aux
->seg_base
;
4657 /* Third, apply any relocations to the unwind table: */
4659 for (relsec
= section_headers
;
4660 relsec
< section_headers
+ elf_header
.e_shnum
;
4663 if (relsec
->sh_type
!= SHT_RELA
4664 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4667 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4671 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4675 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4676 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4680 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4681 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4684 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4686 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4690 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4692 switch (rp
->r_offset
/eh_addr_size
% 3)
4695 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4696 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4699 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4700 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4703 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4704 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4714 aux
->table_len
= size
/ (3 * eh_addr_size
);
4719 ia64_process_unwind (FILE *file
)
4721 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4722 unsigned long i
, unwcount
= 0, unwstart
= 0;
4723 struct ia64_unw_aux_info aux
;
4725 memset (& aux
, 0, sizeof (aux
));
4727 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4729 if (sec
->sh_type
== SHT_SYMTAB
)
4731 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4732 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4734 strsec
= SECTION_HEADER (sec
->sh_link
);
4735 aux
.strtab_size
= strsec
->sh_size
;
4736 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4737 aux
.strtab_size
, _("string table"));
4739 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4744 printf (_("\nThere are no unwind sections in this file.\n"));
4746 while (unwcount
-- > 0)
4751 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4752 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4753 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4760 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4762 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4764 /* We need to find which section group it is in. */
4765 struct group_list
*g
= section_headers_groups
[i
]->root
;
4767 for (; g
!= NULL
; g
= g
->next
)
4769 sec
= SECTION_HEADER (g
->section_index
);
4771 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4776 i
= elf_header
.e_shnum
;
4778 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4780 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4781 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4782 suffix
= SECTION_NAME (unwsec
) + len
;
4783 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4785 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4786 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4791 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4792 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4793 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4794 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4796 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4797 suffix
= SECTION_NAME (unwsec
) + len
;
4798 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4800 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4801 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4805 if (i
== elf_header
.e_shnum
)
4807 printf (_("\nCould not find unwind info section for "));
4809 if (string_table
== NULL
)
4810 printf ("%d", unwsec
->sh_name
);
4812 printf (_("'%s'"), SECTION_NAME (unwsec
));
4816 aux
.info_size
= sec
->sh_size
;
4817 aux
.info_addr
= sec
->sh_addr
;
4818 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4821 printf (_("\nUnwind section "));
4823 if (string_table
== NULL
)
4824 printf ("%d", unwsec
->sh_name
);
4826 printf (_("'%s'"), SECTION_NAME (unwsec
));
4828 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4829 (unsigned long) unwsec
->sh_offset
,
4830 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4832 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4834 if (aux
.table_len
> 0)
4835 dump_ia64_unwind (& aux
);
4838 free ((char *) aux
.table
);
4840 free ((char *) aux
.info
);
4849 free ((char *) aux
.strtab
);
4854 struct hppa_unw_aux_info
4856 struct hppa_unw_table_entry
4858 struct absaddr start
;
4860 unsigned int Cannot_unwind
:1; /* 0 */
4861 unsigned int Millicode
:1; /* 1 */
4862 unsigned int Millicode_save_sr0
:1; /* 2 */
4863 unsigned int Region_description
:2; /* 3..4 */
4864 unsigned int reserved1
:1; /* 5 */
4865 unsigned int Entry_SR
:1; /* 6 */
4866 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4867 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4868 unsigned int Args_stored
:1; /* 16 */
4869 unsigned int Variable_Frame
:1; /* 17 */
4870 unsigned int Separate_Package_Body
:1; /* 18 */
4871 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4872 unsigned int Stack_Overflow_Check
:1; /* 20 */
4873 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4874 unsigned int Ada_Region
:1; /* 22 */
4875 unsigned int cxx_info
:1; /* 23 */
4876 unsigned int cxx_try_catch
:1; /* 24 */
4877 unsigned int sched_entry_seq
:1; /* 25 */
4878 unsigned int reserved2
:1; /* 26 */
4879 unsigned int Save_SP
:1; /* 27 */
4880 unsigned int Save_RP
:1; /* 28 */
4881 unsigned int Save_MRP_in_frame
:1; /* 29 */
4882 unsigned int extn_ptr_defined
:1; /* 30 */
4883 unsigned int Cleanup_defined
:1; /* 31 */
4885 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4886 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4887 unsigned int Large_frame
:1; /* 2 */
4888 unsigned int Pseudo_SP_Set
:1; /* 3 */
4889 unsigned int reserved4
:1; /* 4 */
4890 unsigned int Total_frame_size
:27; /* 5..31 */
4892 *table
; /* Unwind table. */
4893 unsigned long table_len
; /* Length of unwind table. */
4894 bfd_vma seg_base
; /* Starting address of segment. */
4895 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4896 unsigned long nsyms
; /* Number of symbols. */
4897 char *strtab
; /* The string table. */
4898 unsigned long strtab_size
; /* Size of string table. */
4902 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4904 struct hppa_unw_table_entry
*tp
;
4906 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4909 const char *procname
;
4911 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4912 aux
->strtab_size
, tp
->start
, &procname
,
4915 fputs ("\n<", stdout
);
4919 fputs (procname
, stdout
);
4922 printf ("+%lx", (unsigned long) offset
);
4925 fputs (">: [", stdout
);
4926 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4927 fputc ('-', stdout
);
4928 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4931 #define PF(_m) if (tp->_m) printf (#_m " ");
4932 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4935 PF(Millicode_save_sr0
);
4936 /* PV(Region_description); */
4942 PF(Separate_Package_Body
);
4943 PF(Frame_Extension_Millicode
);
4944 PF(Stack_Overflow_Check
);
4945 PF(Two_Instruction_SP_Increment
);
4949 PF(sched_entry_seq
);
4952 PF(Save_MRP_in_frame
);
4953 PF(extn_ptr_defined
);
4954 PF(Cleanup_defined
);
4955 PF(MPE_XL_interrupt_marker
);
4956 PF(HP_UX_interrupt_marker
);
4959 PV(Total_frame_size
);
4968 slurp_hppa_unwind_table (FILE *file
,
4969 struct hppa_unw_aux_info
*aux
,
4970 Elf_Internal_Shdr
*sec
)
4972 unsigned long size
, unw_ent_size
, nrelas
, i
;
4973 Elf_Internal_Phdr
*seg
;
4974 struct hppa_unw_table_entry
*tep
;
4975 Elf_Internal_Shdr
*relsec
;
4976 Elf_Internal_Rela
*rela
, *rp
;
4977 unsigned char *table
, *tp
;
4978 Elf_Internal_Sym
*sym
;
4979 const char *relname
;
4981 /* First, find the starting address of the segment that includes
4984 if (elf_header
.e_phnum
)
4986 if (! get_program_headers (file
))
4989 for (seg
= program_headers
;
4990 seg
< program_headers
+ elf_header
.e_phnum
;
4993 if (seg
->p_type
!= PT_LOAD
)
4996 if (sec
->sh_addr
>= seg
->p_vaddr
4997 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4999 aux
->seg_base
= seg
->p_vaddr
;
5005 /* Second, build the unwind table from the contents of the unwind
5007 size
= sec
->sh_size
;
5008 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
5012 unw_ent_size
= 2 * eh_addr_size
+ 8;
5014 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
5016 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
5018 unsigned int tmp1
, tmp2
;
5020 tep
->start
.section
= SHN_UNDEF
;
5021 tep
->end
.section
= SHN_UNDEF
;
5025 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5026 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5027 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5028 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5032 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5033 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5034 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
5035 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
5038 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5039 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5040 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5041 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5042 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5043 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5044 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5045 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5046 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5047 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5048 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5049 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5050 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5051 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5052 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5053 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5054 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5055 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5056 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5057 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5058 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5059 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5060 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5061 tep
->Cleanup_defined
= tmp1
& 0x1;
5063 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5064 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5065 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5066 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5067 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5068 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5070 tep
->start
.offset
+= aux
->seg_base
;
5071 tep
->end
.offset
+= aux
->seg_base
;
5075 /* Third, apply any relocations to the unwind table. */
5077 for (relsec
= section_headers
;
5078 relsec
< section_headers
+ elf_header
.e_shnum
;
5081 if (relsec
->sh_type
!= SHT_RELA
5082 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5085 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5089 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5093 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
5094 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
5098 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
5099 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
5102 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5103 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
5105 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5109 i
= rp
->r_offset
/ unw_ent_size
;
5111 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5114 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5115 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5118 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5119 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5129 aux
->table_len
= size
/ unw_ent_size
;
5135 hppa_process_unwind (FILE *file
)
5137 struct hppa_unw_aux_info aux
;
5138 Elf_Internal_Shdr
*unwsec
= NULL
;
5139 Elf_Internal_Shdr
*strsec
;
5140 Elf_Internal_Shdr
*sec
;
5143 memset (& aux
, 0, sizeof (aux
));
5145 assert (string_table
!= NULL
);
5147 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5149 if (sec
->sh_type
== SHT_SYMTAB
)
5151 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5152 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5154 strsec
= SECTION_HEADER (sec
->sh_link
);
5155 aux
.strtab_size
= strsec
->sh_size
;
5156 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5157 aux
.strtab_size
, _("string table"));
5159 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5164 printf (_("\nThere are no unwind sections in this file.\n"));
5166 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5168 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5170 printf (_("\nUnwind section "));
5171 printf (_("'%s'"), SECTION_NAME (sec
));
5173 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5174 (unsigned long) sec
->sh_offset
,
5175 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5177 slurp_hppa_unwind_table (file
, &aux
, sec
);
5178 if (aux
.table_len
> 0)
5179 dump_hppa_unwind (&aux
);
5182 free ((char *) aux
.table
);
5190 free ((char *) aux
.strtab
);
5196 process_unwind (FILE *file
)
5198 struct unwind_handler
{
5200 int (*handler
)(FILE *file
);
5202 { EM_IA_64
, ia64_process_unwind
},
5203 { EM_PARISC
, hppa_process_unwind
},
5211 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5212 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5213 return handlers
[i
].handler (file
);
5215 printf (_("\nThere are no unwind sections in this file.\n"));
5220 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5222 switch (entry
->d_tag
)
5225 if (entry
->d_un
.d_val
== 0)
5229 static const char * opts
[] =
5231 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5232 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5233 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5234 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5239 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5240 if (entry
->d_un
.d_val
& (1 << cnt
))
5242 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5249 case DT_MIPS_IVERSION
:
5250 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5251 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5253 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5256 case DT_MIPS_TIME_STAMP
:
5261 time_t time
= entry
->d_un
.d_val
;
5262 tmp
= gmtime (&time
);
5263 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5264 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5265 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5266 printf ("Time Stamp: %s\n", timebuf
);
5270 case DT_MIPS_RLD_VERSION
:
5271 case DT_MIPS_LOCAL_GOTNO
:
5272 case DT_MIPS_CONFLICTNO
:
5273 case DT_MIPS_LIBLISTNO
:
5274 case DT_MIPS_SYMTABNO
:
5275 case DT_MIPS_UNREFEXTNO
:
5276 case DT_MIPS_HIPAGENO
:
5277 case DT_MIPS_DELTA_CLASS_NO
:
5278 case DT_MIPS_DELTA_INSTANCE_NO
:
5279 case DT_MIPS_DELTA_RELOC_NO
:
5280 case DT_MIPS_DELTA_SYM_NO
:
5281 case DT_MIPS_DELTA_CLASSSYM_NO
:
5282 case DT_MIPS_COMPACT_SIZE
:
5283 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5287 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5293 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5295 switch (entry
->d_tag
)
5297 case DT_HP_DLD_FLAGS
:
5306 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5307 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5308 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5309 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5310 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5311 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5312 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5313 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5314 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5315 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5316 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5320 bfd_vma val
= entry
->d_un
.d_val
;
5322 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5323 if (val
& flags
[cnt
].bit
)
5327 fputs (flags
[cnt
].str
, stdout
);
5329 val
^= flags
[cnt
].bit
;
5332 if (val
!= 0 || first
)
5336 print_vma (val
, HEX
);
5342 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5349 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5351 switch (entry
->d_tag
)
5353 case DT_IA_64_PLT_RESERVE
:
5354 /* First 3 slots reserved. */
5355 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5357 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5361 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5368 get_32bit_dynamic_section (FILE *file
)
5370 Elf32_External_Dyn
*edyn
, *ext
;
5371 Elf_Internal_Dyn
*entry
;
5373 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5374 _("dynamic section"));
5378 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5379 might not have the luxury of section headers. Look for the DT_NULL
5380 terminator to determine the number of entries. */
5381 for (ext
= edyn
, dynamic_nent
= 0;
5382 (char *) ext
< (char *) edyn
+ dynamic_size
;
5386 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5390 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5391 if (dynamic_section
== NULL
)
5393 error (_("Out of memory\n"));
5398 for (ext
= edyn
, entry
= dynamic_section
;
5399 entry
< dynamic_section
+ dynamic_nent
;
5402 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5403 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5412 get_64bit_dynamic_section (FILE *file
)
5414 Elf64_External_Dyn
*edyn
, *ext
;
5415 Elf_Internal_Dyn
*entry
;
5417 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5418 _("dynamic section"));
5422 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5423 might not have the luxury of section headers. Look for the DT_NULL
5424 terminator to determine the number of entries. */
5425 for (ext
= edyn
, dynamic_nent
= 0;
5426 (char *) ext
< (char *) edyn
+ dynamic_size
;
5430 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5434 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5435 if (dynamic_section
== NULL
)
5437 error (_("Out of memory\n"));
5442 for (ext
= edyn
, entry
= dynamic_section
;
5443 entry
< dynamic_section
+ dynamic_nent
;
5446 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5447 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5456 print_dynamic_flags (bfd_vma flags
)
5464 flag
= flags
& - flags
;
5474 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5475 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5476 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5477 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5478 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5479 default: fputs ("unknown", stdout
); break;
5485 /* Parse and display the contents of the dynamic section. */
5488 process_dynamic_section (FILE *file
)
5490 Elf_Internal_Dyn
*entry
;
5492 if (dynamic_size
== 0)
5495 printf (_("\nThere is no dynamic section in this file.\n"));
5502 if (! get_32bit_dynamic_section (file
))
5505 else if (! get_64bit_dynamic_section (file
))
5508 /* Find the appropriate symbol table. */
5509 if (dynamic_symbols
== NULL
)
5511 for (entry
= dynamic_section
;
5512 entry
< dynamic_section
+ dynamic_nent
;
5515 Elf_Internal_Shdr section
;
5517 if (entry
->d_tag
!= DT_SYMTAB
)
5520 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5522 /* Since we do not know how big the symbol table is,
5523 we default to reading in the entire file (!) and
5524 processing that. This is overkill, I know, but it
5526 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5528 if (archive_file_offset
!= 0)
5529 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5532 if (fseek (file
, 0, SEEK_END
))
5533 error (_("Unable to seek to end of file!"));
5535 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5539 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5541 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5543 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5544 if (num_dynamic_syms
< 1)
5546 error (_("Unable to determine the number of symbols to load\n"));
5550 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5554 /* Similarly find a string table. */
5555 if (dynamic_strings
== NULL
)
5557 for (entry
= dynamic_section
;
5558 entry
< dynamic_section
+ dynamic_nent
;
5561 unsigned long offset
;
5564 if (entry
->d_tag
!= DT_STRTAB
)
5567 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5569 /* Since we do not know how big the string table is,
5570 we default to reading in the entire file (!) and
5571 processing that. This is overkill, I know, but it
5574 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5576 if (archive_file_offset
!= 0)
5577 str_tab_len
= archive_file_size
- offset
;
5580 if (fseek (file
, 0, SEEK_END
))
5581 error (_("Unable to seek to end of file\n"));
5582 str_tab_len
= ftell (file
) - offset
;
5585 if (str_tab_len
< 1)
5588 (_("Unable to determine the length of the dynamic string table\n"));
5592 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5593 _("dynamic string table"));
5594 dynamic_strings_length
= str_tab_len
;
5599 /* And find the syminfo section if available. */
5600 if (dynamic_syminfo
== NULL
)
5602 unsigned long syminsz
= 0;
5604 for (entry
= dynamic_section
;
5605 entry
< dynamic_section
+ dynamic_nent
;
5608 if (entry
->d_tag
== DT_SYMINENT
)
5610 /* Note: these braces are necessary to avoid a syntax
5611 error from the SunOS4 C compiler. */
5612 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5614 else if (entry
->d_tag
== DT_SYMINSZ
)
5615 syminsz
= entry
->d_un
.d_val
;
5616 else if (entry
->d_tag
== DT_SYMINFO
)
5617 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5621 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5623 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5624 Elf_Internal_Syminfo
*syminfo
;
5626 /* There is a syminfo section. Read the data. */
5627 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5628 _("symbol information"));
5632 dynamic_syminfo
= malloc (syminsz
);
5633 if (dynamic_syminfo
== NULL
)
5635 error (_("Out of memory\n"));
5639 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5640 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5641 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5642 ++syminfo
, ++extsym
)
5644 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5645 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5652 if (do_dynamic
&& dynamic_addr
)
5653 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5654 dynamic_addr
, dynamic_nent
);
5656 printf (_(" Tag Type Name/Value\n"));
5658 for (entry
= dynamic_section
;
5659 entry
< dynamic_section
+ dynamic_nent
;
5667 print_vma (entry
->d_tag
, FULL_HEX
);
5668 dtype
= get_dynamic_type (entry
->d_tag
);
5669 printf (" (%s)%*s", dtype
,
5670 ((is_32bit_elf
? 27 : 19)
5671 - (int) strlen (dtype
)),
5675 switch (entry
->d_tag
)
5679 print_dynamic_flags (entry
->d_un
.d_val
);
5689 switch (entry
->d_tag
)
5692 printf (_("Auxiliary library"));
5696 printf (_("Filter library"));
5700 printf (_("Configuration file"));
5704 printf (_("Dependency audit library"));
5708 printf (_("Audit library"));
5712 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5713 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5717 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5726 printf (_("Flags:"));
5728 if (entry
->d_un
.d_val
== 0)
5729 printf (_(" None\n"));
5732 unsigned long int val
= entry
->d_un
.d_val
;
5734 if (val
& DTF_1_PARINIT
)
5736 printf (" PARINIT");
5737 val
^= DTF_1_PARINIT
;
5739 if (val
& DTF_1_CONFEXP
)
5741 printf (" CONFEXP");
5742 val
^= DTF_1_CONFEXP
;
5745 printf (" %lx", val
);
5754 printf (_("Flags:"));
5756 if (entry
->d_un
.d_val
== 0)
5757 printf (_(" None\n"));
5760 unsigned long int val
= entry
->d_un
.d_val
;
5762 if (val
& DF_P1_LAZYLOAD
)
5764 printf (" LAZYLOAD");
5765 val
^= DF_P1_LAZYLOAD
;
5767 if (val
& DF_P1_GROUPPERM
)
5769 printf (" GROUPPERM");
5770 val
^= DF_P1_GROUPPERM
;
5773 printf (" %lx", val
);
5782 printf (_("Flags:"));
5783 if (entry
->d_un
.d_val
== 0)
5784 printf (_(" None\n"));
5787 unsigned long int val
= entry
->d_un
.d_val
;
5794 if (val
& DF_1_GLOBAL
)
5799 if (val
& DF_1_GROUP
)
5804 if (val
& DF_1_NODELETE
)
5806 printf (" NODELETE");
5807 val
^= DF_1_NODELETE
;
5809 if (val
& DF_1_LOADFLTR
)
5811 printf (" LOADFLTR");
5812 val
^= DF_1_LOADFLTR
;
5814 if (val
& DF_1_INITFIRST
)
5816 printf (" INITFIRST");
5817 val
^= DF_1_INITFIRST
;
5819 if (val
& DF_1_NOOPEN
)
5824 if (val
& DF_1_ORIGIN
)
5829 if (val
& DF_1_DIRECT
)
5834 if (val
& DF_1_TRANS
)
5839 if (val
& DF_1_INTERPOSE
)
5841 printf (" INTERPOSE");
5842 val
^= DF_1_INTERPOSE
;
5844 if (val
& DF_1_NODEFLIB
)
5846 printf (" NODEFLIB");
5847 val
^= DF_1_NODEFLIB
;
5849 if (val
& DF_1_NODUMP
)
5854 if (val
& DF_1_CONLFAT
)
5856 printf (" CONLFAT");
5857 val
^= DF_1_CONLFAT
;
5860 printf (" %lx", val
);
5867 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5869 puts (get_dynamic_type (entry
->d_un
.d_val
));
5889 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5895 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5896 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5902 switch (entry
->d_tag
)
5905 printf (_("Shared library: [%s]"), name
);
5907 if (streq (name
, program_interpreter
))
5908 printf (_(" program interpreter"));
5912 printf (_("Library soname: [%s]"), name
);
5916 printf (_("Library rpath: [%s]"), name
);
5920 printf (_("Library runpath: [%s]"), name
);
5924 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5929 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5942 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5946 case DT_INIT_ARRAYSZ
:
5947 case DT_FINI_ARRAYSZ
:
5948 case DT_GNU_CONFLICTSZ
:
5949 case DT_GNU_LIBLISTSZ
:
5952 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5953 printf (" (bytes)\n");
5963 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5976 if (entry
->d_tag
== DT_USED
5977 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5979 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5983 printf (_("Not needed object: [%s]\n"), name
);
5988 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5994 /* The value of this entry is ignored. */
5999 case DT_GNU_PRELINKED
:
6003 time_t time
= entry
->d_un
.d_val
;
6005 tmp
= gmtime (&time
);
6006 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6007 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6008 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6014 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6015 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6020 switch (elf_header
.e_machine
)
6023 case EM_MIPS_RS3_LE
:
6024 dynamic_section_mips_val (entry
);
6027 dynamic_section_parisc_val (entry
);
6030 dynamic_section_ia64_val (entry
);
6033 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6045 get_ver_flags (unsigned int flags
)
6047 static char buff
[32];
6054 if (flags
& VER_FLG_BASE
)
6055 strcat (buff
, "BASE ");
6057 if (flags
& VER_FLG_WEAK
)
6059 if (flags
& VER_FLG_BASE
)
6060 strcat (buff
, "| ");
6062 strcat (buff
, "WEAK ");
6065 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6066 strcat (buff
, "| <unknown>");
6071 /* Display the contents of the version sections. */
6073 process_version_sections (FILE *file
)
6075 Elf_Internal_Shdr
*section
;
6082 for (i
= 0, section
= section_headers
;
6083 i
< elf_header
.e_shnum
;
6086 switch (section
->sh_type
)
6088 case SHT_GNU_verdef
:
6090 Elf_External_Verdef
*edefs
;
6097 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6098 SECTION_NAME (section
), section
->sh_info
);
6100 printf (_(" Addr: 0x"));
6101 printf_vma (section
->sh_addr
);
6102 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6103 (unsigned long) section
->sh_offset
, section
->sh_link
,
6104 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6106 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6107 _("version definition section"));
6111 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6114 Elf_External_Verdef
*edef
;
6115 Elf_Internal_Verdef ent
;
6116 Elf_External_Verdaux
*eaux
;
6117 Elf_Internal_Verdaux aux
;
6121 vstart
= ((char *) edefs
) + idx
;
6123 edef
= (Elf_External_Verdef
*) vstart
;
6125 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6126 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6127 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6128 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6129 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6130 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6131 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6133 printf (_(" %#06x: Rev: %d Flags: %s"),
6134 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6136 printf (_(" Index: %d Cnt: %d "),
6137 ent
.vd_ndx
, ent
.vd_cnt
);
6139 vstart
+= ent
.vd_aux
;
6141 eaux
= (Elf_External_Verdaux
*) vstart
;
6143 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6144 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6146 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6147 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6149 printf (_("Name index: %ld\n"), aux
.vda_name
);
6151 isum
= idx
+ ent
.vd_aux
;
6153 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6155 isum
+= aux
.vda_next
;
6156 vstart
+= aux
.vda_next
;
6158 eaux
= (Elf_External_Verdaux
*) vstart
;
6160 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6161 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6163 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6164 printf (_(" %#06x: Parent %d: %s\n"),
6165 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6167 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6168 isum
, j
, aux
.vda_name
);
6178 case SHT_GNU_verneed
:
6180 Elf_External_Verneed
*eneed
;
6186 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6187 SECTION_NAME (section
), section
->sh_info
);
6189 printf (_(" Addr: 0x"));
6190 printf_vma (section
->sh_addr
);
6191 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6192 (unsigned long) section
->sh_offset
, section
->sh_link
,
6193 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6195 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6196 _("version need section"));
6200 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6202 Elf_External_Verneed
*entry
;
6203 Elf_Internal_Verneed ent
;
6208 vstart
= ((char *) eneed
) + idx
;
6210 entry
= (Elf_External_Verneed
*) vstart
;
6212 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6213 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6214 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6215 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6216 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6218 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6220 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6221 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6223 printf (_(" File: %lx"), ent
.vn_file
);
6225 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6227 vstart
+= ent
.vn_aux
;
6229 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6231 Elf_External_Vernaux
*eaux
;
6232 Elf_Internal_Vernaux aux
;
6234 eaux
= (Elf_External_Vernaux
*) vstart
;
6236 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6237 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6238 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6239 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6240 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6242 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6243 printf (_(" %#06x: Name: %s"),
6244 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6246 printf (_(" %#06x: Name index: %lx"),
6247 isum
, aux
.vna_name
);
6249 printf (_(" Flags: %s Version: %d\n"),
6250 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6252 isum
+= aux
.vna_next
;
6253 vstart
+= aux
.vna_next
;
6263 case SHT_GNU_versym
:
6265 Elf_Internal_Shdr
*link_section
;
6268 unsigned char *edata
;
6269 unsigned short *data
;
6271 Elf_Internal_Sym
*symbols
;
6272 Elf_Internal_Shdr
*string_sec
;
6275 link_section
= SECTION_HEADER (section
->sh_link
);
6276 total
= section
->sh_size
/ section
->sh_entsize
;
6280 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6282 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6284 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6285 string_sec
->sh_size
, _("version string table"));
6289 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6290 SECTION_NAME (section
), total
);
6292 printf (_(" Addr: "));
6293 printf_vma (section
->sh_addr
);
6294 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6295 (unsigned long) section
->sh_offset
, section
->sh_link
,
6296 SECTION_NAME (link_section
));
6298 off
= offset_from_vma (file
,
6299 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6300 total
* sizeof (short));
6301 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6302 _("version symbol data"));
6309 data
= malloc (total
* sizeof (short));
6311 for (cnt
= total
; cnt
--;)
6312 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6317 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6320 int check_def
, check_need
;
6323 printf (" %03x:", cnt
);
6325 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6326 switch (data
[cnt
+ j
])
6329 fputs (_(" 0 (*local*) "), stdout
);
6333 fputs (_(" 1 (*global*) "), stdout
);
6337 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6338 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6342 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6345 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6352 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6354 Elf_Internal_Verneed ivn
;
6355 unsigned long offset
;
6357 offset
= offset_from_vma
6358 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6359 sizeof (Elf_External_Verneed
));
6363 Elf_Internal_Vernaux ivna
;
6364 Elf_External_Verneed evn
;
6365 Elf_External_Vernaux evna
;
6366 unsigned long a_off
;
6368 get_data (&evn
, file
, offset
, sizeof (evn
),
6371 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6372 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6374 a_off
= offset
+ ivn
.vn_aux
;
6378 get_data (&evna
, file
, a_off
, sizeof (evna
),
6379 _("version need aux (2)"));
6381 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6382 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6384 a_off
+= ivna
.vna_next
;
6386 while (ivna
.vna_other
!= data
[cnt
+ j
]
6387 && ivna
.vna_next
!= 0);
6389 if (ivna
.vna_other
== data
[cnt
+ j
])
6391 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6393 name
= strtab
+ ivna
.vna_name
;
6394 nn
+= printf ("(%s%-*s",
6396 12 - (int) strlen (name
),
6402 offset
+= ivn
.vn_next
;
6404 while (ivn
.vn_next
);
6407 if (check_def
&& data
[cnt
+ j
] != 0x8001
6408 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6410 Elf_Internal_Verdef ivd
;
6411 Elf_External_Verdef evd
;
6412 unsigned long offset
;
6414 offset
= offset_from_vma
6415 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6420 get_data (&evd
, file
, offset
, sizeof (evd
),
6423 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6424 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6426 offset
+= ivd
.vd_next
;
6428 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6429 && ivd
.vd_next
!= 0);
6431 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6433 Elf_External_Verdaux evda
;
6434 Elf_Internal_Verdaux ivda
;
6436 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6438 get_data (&evda
, file
,
6439 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6440 sizeof (evda
), _("version def aux"));
6442 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6444 name
= strtab
+ ivda
.vda_name
;
6445 nn
+= printf ("(%s%-*s",
6447 12 - (int) strlen (name
),
6453 printf ("%*c", 18 - nn
, ' ');
6471 printf (_("\nNo version information found in this file.\n"));
6477 get_symbol_binding (unsigned int binding
)
6479 static char buff
[32];
6483 case STB_LOCAL
: return "LOCAL";
6484 case STB_GLOBAL
: return "GLOBAL";
6485 case STB_WEAK
: return "WEAK";
6487 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6488 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6490 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6491 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6493 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6499 get_symbol_type (unsigned int type
)
6501 static char buff
[32];
6505 case STT_NOTYPE
: return "NOTYPE";
6506 case STT_OBJECT
: return "OBJECT";
6507 case STT_FUNC
: return "FUNC";
6508 case STT_SECTION
: return "SECTION";
6509 case STT_FILE
: return "FILE";
6510 case STT_COMMON
: return "COMMON";
6511 case STT_TLS
: return "TLS";
6513 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6515 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6516 return "THUMB_FUNC";
6518 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6521 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6522 return "PARISC_MILLI";
6524 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6526 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6528 if (elf_header
.e_machine
== EM_PARISC
)
6530 if (type
== STT_HP_OPAQUE
)
6532 if (type
== STT_HP_STUB
)
6536 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6539 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6545 get_symbol_visibility (unsigned int visibility
)
6549 case STV_DEFAULT
: return "DEFAULT";
6550 case STV_INTERNAL
: return "INTERNAL";
6551 case STV_HIDDEN
: return "HIDDEN";
6552 case STV_PROTECTED
: return "PROTECTED";
6558 get_symbol_index_type (unsigned int type
)
6560 static char buff
[32];
6564 case SHN_UNDEF
: return "UND";
6565 case SHN_ABS
: return "ABS";
6566 case SHN_COMMON
: return "COM";
6568 if (type
== SHN_IA_64_ANSI_COMMON
6569 && elf_header
.e_machine
== EM_IA_64
6570 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6572 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6573 sprintf (buff
, "PRC[0x%04x]", type
);
6574 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6575 sprintf (buff
, "OS [0x%04x]", type
);
6576 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6577 sprintf (buff
, "RSV[0x%04x]", type
);
6579 sprintf (buff
, "%3d", type
);
6587 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6589 unsigned char *e_data
;
6592 e_data
= malloc (number
* ent_size
);
6596 error (_("Out of memory\n"));
6600 if (fread (e_data
, ent_size
, number
, file
) != number
)
6602 error (_("Unable to read in dynamic data\n"));
6606 i_data
= malloc (number
* sizeof (*i_data
));
6610 error (_("Out of memory\n"));
6616 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6623 /* Dump the symbol table. */
6625 process_symbol_table (FILE *file
)
6627 Elf_Internal_Shdr
*section
;
6628 bfd_vma nbuckets
= 0;
6629 bfd_vma nchains
= 0;
6630 bfd_vma
*buckets
= NULL
;
6631 bfd_vma
*chains
= NULL
;
6633 if (! do_syms
&& !do_histogram
)
6636 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6639 unsigned char nb
[8];
6640 unsigned char nc
[8];
6641 int hash_ent_size
= 4;
6643 if ((elf_header
.e_machine
== EM_ALPHA
6644 || elf_header
.e_machine
== EM_S390
6645 || elf_header
.e_machine
== EM_S390_OLD
)
6646 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6650 (archive_file_offset
6651 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6652 sizeof nb
+ sizeof nc
)),
6655 error (_("Unable to seek to start of dynamic information"));
6659 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6661 error (_("Failed to read in number of buckets\n"));
6665 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6667 error (_("Failed to read in number of chains\n"));
6671 nbuckets
= byte_get (nb
, hash_ent_size
);
6672 nchains
= byte_get (nc
, hash_ent_size
);
6674 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6675 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6677 if (buckets
== NULL
|| chains
== NULL
)
6682 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6687 printf (_("\nSymbol table for image:\n"));
6689 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6691 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6693 for (hn
= 0; hn
< nbuckets
; hn
++)
6698 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6700 Elf_Internal_Sym
*psym
;
6703 psym
= dynamic_symbols
+ si
;
6705 n
= print_vma (si
, DEC_5
);
6707 fputs (" " + n
, stdout
);
6708 printf (" %3lu: ", hn
);
6709 print_vma (psym
->st_value
, LONG_HEX
);
6711 print_vma (psym
->st_size
, DEC_5
);
6713 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6714 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6715 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6716 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6717 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6718 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6720 printf (" <corrupt: %14ld>", psym
->st_name
);
6725 else if (do_syms
&& !do_using_dynamic
)
6729 for (i
= 0, section
= section_headers
;
6730 i
< elf_header
.e_shnum
;
6735 Elf_Internal_Sym
*symtab
;
6736 Elf_Internal_Sym
*psym
;
6739 if ( section
->sh_type
!= SHT_SYMTAB
6740 && section
->sh_type
!= SHT_DYNSYM
)
6743 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6744 SECTION_NAME (section
),
6745 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6747 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6749 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6751 symtab
= GET_ELF_SYMBOLS (file
, section
);
6755 if (section
->sh_link
== elf_header
.e_shstrndx
)
6756 strtab
= string_table
;
6759 Elf_Internal_Shdr
*string_sec
;
6761 string_sec
= SECTION_HEADER (section
->sh_link
);
6763 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6764 string_sec
->sh_size
, _("string table"));
6767 for (si
= 0, psym
= symtab
;
6768 si
< section
->sh_size
/ section
->sh_entsize
;
6771 printf ("%6d: ", si
);
6772 print_vma (psym
->st_value
, LONG_HEX
);
6774 print_vma (psym
->st_size
, DEC_5
);
6775 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6776 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6777 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6778 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6779 print_symbol (25, strtab
+ psym
->st_name
);
6781 if (section
->sh_type
== SHT_DYNSYM
&&
6782 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6784 unsigned char data
[2];
6785 unsigned short vers_data
;
6786 unsigned long offset
;
6790 offset
= offset_from_vma
6791 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6792 sizeof data
+ si
* sizeof (vers_data
));
6794 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6795 sizeof (data
), _("version data"));
6797 vers_data
= byte_get (data
, 2);
6799 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6802 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6804 if ((vers_data
& 0x8000) || vers_data
> 1)
6806 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6807 && (is_nobits
|| ! check_def
))
6809 Elf_External_Verneed evn
;
6810 Elf_Internal_Verneed ivn
;
6811 Elf_Internal_Vernaux ivna
;
6813 /* We must test both. */
6814 offset
= offset_from_vma
6815 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6820 unsigned long vna_off
;
6822 get_data (&evn
, file
, offset
, sizeof (evn
),
6825 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6826 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6828 vna_off
= offset
+ ivn
.vn_aux
;
6832 Elf_External_Vernaux evna
;
6834 get_data (&evna
, file
, vna_off
,
6836 _("version need aux (3)"));
6838 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6839 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6840 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6842 vna_off
+= ivna
.vna_next
;
6844 while (ivna
.vna_other
!= vers_data
6845 && ivna
.vna_next
!= 0);
6847 if (ivna
.vna_other
== vers_data
)
6850 offset
+= ivn
.vn_next
;
6852 while (ivn
.vn_next
!= 0);
6854 if (ivna
.vna_other
== vers_data
)
6857 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6860 else if (! is_nobits
)
6861 error (_("bad dynamic symbol"));
6868 if (vers_data
!= 0x8001
6869 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6871 Elf_Internal_Verdef ivd
;
6872 Elf_Internal_Verdaux ivda
;
6873 Elf_External_Verdaux evda
;
6874 unsigned long offset
;
6876 offset
= offset_from_vma
6878 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6879 sizeof (Elf_External_Verdef
));
6883 Elf_External_Verdef evd
;
6885 get_data (&evd
, file
, offset
, sizeof (evd
),
6888 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6889 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6890 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6892 offset
+= ivd
.vd_next
;
6894 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6895 && ivd
.vd_next
!= 0);
6897 offset
-= ivd
.vd_next
;
6898 offset
+= ivd
.vd_aux
;
6900 get_data (&evda
, file
, offset
, sizeof (evda
),
6901 _("version def aux"));
6903 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6905 if (psym
->st_name
!= ivda
.vda_name
)
6906 printf ((vers_data
& 0x8000)
6908 strtab
+ ivda
.vda_name
);
6918 if (strtab
!= string_table
)
6924 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6926 if (do_histogram
&& buckets
!= NULL
)
6928 unsigned long *lengths
;
6929 unsigned long *counts
;
6932 unsigned long maxlength
= 0;
6933 unsigned long nzero_counts
= 0;
6934 unsigned long nsyms
= 0;
6936 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
6937 (unsigned long) nbuckets
);
6938 printf (_(" Length Number %% of total Coverage\n"));
6940 lengths
= calloc (nbuckets
, sizeof (*lengths
));
6941 if (lengths
== NULL
)
6943 error (_("Out of memory"));
6946 for (hn
= 0; hn
< nbuckets
; ++hn
)
6948 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6951 if (maxlength
< ++lengths
[hn
])
6956 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
6959 error (_("Out of memory"));
6963 for (hn
= 0; hn
< nbuckets
; ++hn
)
6964 ++counts
[lengths
[hn
]];
6969 printf (" 0 %-10lu (%5.1f%%)\n",
6970 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6971 for (i
= 1; i
<= maxlength
; ++i
)
6973 nzero_counts
+= counts
[i
] * i
;
6974 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
6975 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
6976 (nzero_counts
* 100.0) / nsyms
);
6984 if (buckets
!= NULL
)
6994 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6998 if (dynamic_syminfo
== NULL
7000 /* No syminfo, this is ok. */
7003 /* There better should be a dynamic symbol section. */
7004 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7008 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7009 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7011 printf (_(" Num: Name BoundTo Flags\n"));
7012 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7014 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7016 printf ("%4d: ", i
);
7017 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7018 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7020 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7023 switch (dynamic_syminfo
[i
].si_boundto
)
7025 case SYMINFO_BT_SELF
:
7026 fputs ("SELF ", stdout
);
7028 case SYMINFO_BT_PARENT
:
7029 fputs ("PARENT ", stdout
);
7032 if (dynamic_syminfo
[i
].si_boundto
> 0
7033 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7034 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7036 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7040 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7044 if (flags
& SYMINFO_FLG_DIRECT
)
7046 if (flags
& SYMINFO_FLG_PASSTHRU
)
7047 printf (" PASSTHRU");
7048 if (flags
& SYMINFO_FLG_COPY
)
7050 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7051 printf (" LAZYLOAD");
7059 #ifdef SUPPORT_DISASSEMBLY
7061 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7063 printf (_("\nAssembly dump of section %s\n"),
7064 SECTION_NAME (section
));
7066 /* XXX -- to be done --- XXX */
7073 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
7075 bfd_size_type bytes
;
7077 unsigned char *data
;
7078 unsigned char *start
;
7080 bytes
= section
->sh_size
;
7082 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7084 printf (_("\nSection '%s' has no data to dump.\n"),
7085 SECTION_NAME (section
));
7089 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7091 addr
= section
->sh_addr
;
7093 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
7105 lbytes
= (bytes
> 16 ? 16 : bytes
);
7107 printf (" 0x%8.8lx ", (unsigned long) addr
);
7109 switch (elf_header
.e_ident
[EI_DATA
])
7113 for (j
= 15; j
>= 0; j
--)
7116 printf ("%2.2x", data
[j
]);
7126 for (j
= 0; j
< 16; j
++)
7129 printf ("%2.2x", data
[j
]);
7139 for (j
= 0; j
< lbytes
; j
++)
7142 if (k
>= ' ' && k
< 0x7f)
7161 static unsigned long int
7162 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7164 unsigned long int result
= 0;
7165 unsigned int num_read
= 0;
7166 unsigned int shift
= 0;
7174 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7179 while (byte
& 0x80);
7181 if (length_return
!= NULL
)
7182 *length_return
= num_read
;
7184 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7185 result
|= -1L << shift
;
7190 typedef struct State_Machine_Registers
7192 unsigned long address
;
7195 unsigned int column
;
7199 /* This variable hold the number of the last entry seen
7200 in the File Table. */
7201 unsigned int last_file_entry
;
7204 static SMR state_machine_regs
;
7207 reset_state_machine (int is_stmt
)
7209 state_machine_regs
.address
= 0;
7210 state_machine_regs
.file
= 1;
7211 state_machine_regs
.line
= 1;
7212 state_machine_regs
.column
= 0;
7213 state_machine_regs
.is_stmt
= is_stmt
;
7214 state_machine_regs
.basic_block
= 0;
7215 state_machine_regs
.end_sequence
= 0;
7216 state_machine_regs
.last_file_entry
= 0;
7219 /* Handled an extend line op.
7220 Returns the number of bytes read. */
7223 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7225 unsigned char op_code
;
7226 unsigned int bytes_read
;
7228 unsigned char *name
;
7231 len
= read_leb128 (data
, & bytes_read
, 0);
7236 warn (_("badly formed extended line op encountered!\n"));
7243 printf (_(" Extended opcode %d: "), op_code
);
7247 case DW_LNE_end_sequence
:
7248 printf (_("End of Sequence\n\n"));
7249 reset_state_machine (is_stmt
);
7252 case DW_LNE_set_address
:
7253 adr
= byte_get (data
, pointer_size
);
7254 printf (_("set Address to 0x%lx\n"), adr
);
7255 state_machine_regs
.address
= adr
;
7258 case DW_LNE_define_file
:
7259 printf (_(" define new File Table entry\n"));
7260 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7262 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7264 data
+= strlen ((char *) data
) + 1;
7265 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7267 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7269 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7270 printf (_("%s\n\n"), name
);
7274 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7281 static const char *debug_str_contents
;
7282 static bfd_vma debug_str_size
;
7285 load_debug_str (FILE *file
)
7287 Elf_Internal_Shdr
*sec
;
7289 /* If it is already loaded, do nothing. */
7290 if (debug_str_contents
!= NULL
)
7293 /* Locate the .debug_str section. */
7294 sec
= find_section (".debug_str");
7298 debug_str_size
= sec
->sh_size
;
7300 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7301 _("debug_str section data"));
7305 free_debug_str (void)
7307 if (debug_str_contents
== NULL
)
7310 free ((char *) debug_str_contents
);
7311 debug_str_contents
= NULL
;
7316 fetch_indirect_string (unsigned long offset
)
7318 if (debug_str_contents
== NULL
)
7319 return _("<no .debug_str section>");
7321 if (offset
> debug_str_size
)
7323 warn (_("DW_FORM_strp offset too big: %x\n"), offset
);
7324 return _("<offset is too big>");
7327 return debug_str_contents
+ offset
;
7330 static const char *debug_loc_contents
;
7331 static bfd_vma debug_loc_size
;
7334 load_debug_loc (FILE *file
)
7336 Elf_Internal_Shdr
*sec
;
7338 /* If it is already loaded, do nothing. */
7339 if (debug_loc_contents
!= NULL
)
7342 /* Locate the .debug_loc section. */
7343 sec
= find_section (".debug_loc");
7347 debug_loc_size
= sec
->sh_size
;
7349 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7350 _("debug_loc section data"));
7354 free_debug_loc (void)
7356 if (debug_loc_contents
== NULL
)
7359 free ((char *) debug_loc_contents
);
7360 debug_loc_contents
= NULL
;
7364 static const char * debug_range_contents
;
7365 static unsigned long debug_range_size
;
7368 load_debug_range (FILE *file
)
7370 Elf_Internal_Shdr
*sec
;
7372 /* If it is already loaded, do nothing. */
7373 if (debug_range_contents
!= NULL
)
7376 /* Locate the .debug_ranges section. */
7377 sec
= find_section (".debug_ranges");
7381 debug_range_size
= sec
->sh_size
;
7383 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7384 _("debug_range section data"));
7388 free_debug_range (void)
7390 if (debug_range_contents
== NULL
)
7393 free ((char *) debug_range_contents
);
7394 debug_range_contents
= NULL
;
7395 debug_range_size
= 0;
7398 /* Apply addends of RELA relocations. */
7401 debug_apply_rela_addends (FILE *file
,
7402 Elf_Internal_Shdr
*section
,
7404 unsigned char *sec_data
,
7405 unsigned char *start
,
7408 Elf_Internal_Shdr
*relsec
;
7410 if (end
- start
< reloc_size
)
7413 for (relsec
= section_headers
;
7414 relsec
< section_headers
+ elf_header
.e_shnum
;
7417 unsigned long nrelas
;
7418 Elf_Internal_Rela
*rela
, *rp
;
7419 Elf_Internal_Shdr
*symsec
;
7420 Elf_Internal_Sym
*symtab
;
7421 Elf_Internal_Sym
*sym
;
7423 if (relsec
->sh_type
!= SHT_RELA
7424 || SECTION_HEADER (relsec
->sh_info
) != section
7425 || relsec
->sh_size
== 0)
7428 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7432 symsec
= SECTION_HEADER (relsec
->sh_link
);
7433 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7435 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7439 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7440 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7441 loc
= sec_data
+ rp
->r_offset
;
7447 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7449 if (ELF32_R_SYM (rp
->r_info
) != 0
7450 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7451 /* Relocations against object symbols can happen,
7452 eg when referencing a global array. For an
7453 example of this see the _clz.o binary in libgcc.a. */
7454 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7456 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7457 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7458 SECTION_NAME (section
));
7464 /* In MIPS little-endian objects, r_info isn't really a
7465 64-bit little-endian value: it has a 32-bit little-endian
7466 symbol index followed by four individual byte fields.
7467 Reorder INFO accordingly. */
7468 if (elf_header
.e_machine
== EM_MIPS
7469 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
7470 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
7471 | ((rp
->r_info
>> 56) & 0xff)
7472 | ((rp
->r_info
>> 40) & 0xff00)
7473 | ((rp
->r_info
>> 24) & 0xff0000)
7474 | ((rp
->r_info
>> 8) & 0xff000000));
7476 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7478 if (ELF64_R_SYM (rp
->r_info
) != 0
7479 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7480 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7482 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7483 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7484 SECTION_NAME (section
));
7489 byte_put (loc
, rp
->r_addend
, reloc_size
);
7499 /* FIXME: There are better and more efficient ways to handle
7500 these structures. For now though, I just want something that
7501 is simple to implement. */
7502 typedef struct abbrev_attr
7504 unsigned long attribute
;
7506 struct abbrev_attr
*next
;
7510 typedef struct abbrev_entry
7512 unsigned long entry
;
7515 struct abbrev_attr
*first_attr
;
7516 struct abbrev_attr
*last_attr
;
7517 struct abbrev_entry
*next
;
7521 static abbrev_entry
*first_abbrev
= NULL
;
7522 static abbrev_entry
*last_abbrev
= NULL
;
7527 abbrev_entry
*abbrev
;
7529 for (abbrev
= first_abbrev
; abbrev
;)
7531 abbrev_entry
*next
= abbrev
->next
;
7534 for (attr
= abbrev
->first_attr
; attr
;)
7536 abbrev_attr
*next
= attr
->next
;
7546 last_abbrev
= first_abbrev
= NULL
;
7550 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7552 abbrev_entry
*entry
;
7554 entry
= malloc (sizeof (*entry
));
7560 entry
->entry
= number
;
7562 entry
->children
= children
;
7563 entry
->first_attr
= NULL
;
7564 entry
->last_attr
= NULL
;
7567 if (first_abbrev
== NULL
)
7568 first_abbrev
= entry
;
7570 last_abbrev
->next
= entry
;
7572 last_abbrev
= entry
;
7576 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7580 attr
= malloc (sizeof (*attr
));
7586 attr
->attribute
= attribute
;
7590 if (last_abbrev
->first_attr
== NULL
)
7591 last_abbrev
->first_attr
= attr
;
7593 last_abbrev
->last_attr
->next
= attr
;
7595 last_abbrev
->last_attr
= attr
;
7598 /* Processes the (partial) contents of a .debug_abbrev section.
7599 Returns NULL if the end of the section was encountered.
7600 Returns the address after the last byte read if the end of
7601 an abbreviation set was found. */
7603 static unsigned char *
7604 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7606 if (first_abbrev
!= NULL
)
7611 unsigned int bytes_read
;
7612 unsigned long entry
;
7614 unsigned long attribute
;
7617 entry
= read_leb128 (start
, & bytes_read
, 0);
7618 start
+= bytes_read
;
7620 /* A single zero is supposed to end the section according
7621 to the standard. If there's more, then signal that to
7624 return start
== end
? NULL
: start
;
7626 tag
= read_leb128 (start
, & bytes_read
, 0);
7627 start
+= bytes_read
;
7629 children
= *start
++;
7631 add_abbrev (entry
, tag
, children
);
7637 attribute
= read_leb128 (start
, & bytes_read
, 0);
7638 start
+= bytes_read
;
7640 form
= read_leb128 (start
, & bytes_read
, 0);
7641 start
+= bytes_read
;
7644 add_abbrev_attr (attribute
, form
);
7646 while (attribute
!= 0);
7653 get_TAG_name (unsigned long tag
)
7657 case DW_TAG_padding
: return "DW_TAG_padding";
7658 case DW_TAG_array_type
: return "DW_TAG_array_type";
7659 case DW_TAG_class_type
: return "DW_TAG_class_type";
7660 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7661 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7662 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7663 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7664 case DW_TAG_label
: return "DW_TAG_label";
7665 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7666 case DW_TAG_member
: return "DW_TAG_member";
7667 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7668 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7669 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7670 case DW_TAG_string_type
: return "DW_TAG_string_type";
7671 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7672 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7673 case DW_TAG_typedef
: return "DW_TAG_typedef";
7674 case DW_TAG_union_type
: return "DW_TAG_union_type";
7675 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7676 case DW_TAG_variant
: return "DW_TAG_variant";
7677 case DW_TAG_common_block
: return "DW_TAG_common_block";
7678 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7679 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7680 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7681 case DW_TAG_module
: return "DW_TAG_module";
7682 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7683 case DW_TAG_set_type
: return "DW_TAG_set_type";
7684 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7685 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7686 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7687 case DW_TAG_base_type
: return "DW_TAG_base_type";
7688 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7689 case DW_TAG_const_type
: return "DW_TAG_const_type";
7690 case DW_TAG_constant
: return "DW_TAG_constant";
7691 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7692 case DW_TAG_file_type
: return "DW_TAG_file_type";
7693 case DW_TAG_friend
: return "DW_TAG_friend";
7694 case DW_TAG_namelist
: return "DW_TAG_namelist";
7695 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7696 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7697 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7698 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7699 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7700 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7701 case DW_TAG_try_block
: return "DW_TAG_try_block";
7702 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7703 case DW_TAG_variable
: return "DW_TAG_variable";
7704 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7705 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7706 case DW_TAG_format_label
: return "DW_TAG_format_label";
7707 case DW_TAG_function_template
: return "DW_TAG_function_template";
7708 case DW_TAG_class_template
: return "DW_TAG_class_template";
7709 /* DWARF 2.1 values. */
7710 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7711 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7712 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7713 case DW_TAG_namespace
: return "DW_TAG_namespace";
7714 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7715 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7716 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7717 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7719 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7720 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7721 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7724 static char buffer
[100];
7726 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
7733 get_FORM_name (unsigned long form
)
7737 case DW_FORM_addr
: return "DW_FORM_addr";
7738 case DW_FORM_block2
: return "DW_FORM_block2";
7739 case DW_FORM_block4
: return "DW_FORM_block4";
7740 case DW_FORM_data2
: return "DW_FORM_data2";
7741 case DW_FORM_data4
: return "DW_FORM_data4";
7742 case DW_FORM_data8
: return "DW_FORM_data8";
7743 case DW_FORM_string
: return "DW_FORM_string";
7744 case DW_FORM_block
: return "DW_FORM_block";
7745 case DW_FORM_block1
: return "DW_FORM_block1";
7746 case DW_FORM_data1
: return "DW_FORM_data1";
7747 case DW_FORM_flag
: return "DW_FORM_flag";
7748 case DW_FORM_sdata
: return "DW_FORM_sdata";
7749 case DW_FORM_strp
: return "DW_FORM_strp";
7750 case DW_FORM_udata
: return "DW_FORM_udata";
7751 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7752 case DW_FORM_ref1
: return "DW_FORM_ref1";
7753 case DW_FORM_ref2
: return "DW_FORM_ref2";
7754 case DW_FORM_ref4
: return "DW_FORM_ref4";
7755 case DW_FORM_ref8
: return "DW_FORM_ref8";
7756 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7757 case DW_FORM_indirect
: return "DW_FORM_indirect";
7760 static char buffer
[100];
7762 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
7768 static unsigned char *
7769 display_block (unsigned char *data
, unsigned long length
)
7771 printf (_(" %lu byte block: "), length
);
7774 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7780 decode_location_expression (unsigned char * data
,
7781 unsigned int pointer_size
,
7782 unsigned long length
,
7783 unsigned long cu_offset
)
7786 unsigned int bytes_read
;
7787 unsigned long uvalue
;
7788 unsigned char *end
= data
+ length
;
7789 int need_frame_base
= 0;
7798 printf ("DW_OP_addr: %lx",
7799 (unsigned long) byte_get (data
, pointer_size
));
7800 data
+= pointer_size
;
7803 printf ("DW_OP_deref");
7806 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7809 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7812 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7816 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7820 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7824 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7828 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7829 (unsigned long) byte_get (data
+ 4, 4));
7833 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7834 (long) byte_get (data
+ 4, 4));
7838 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7842 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7846 printf ("DW_OP_dup");
7849 printf ("DW_OP_drop");
7852 printf ("DW_OP_over");
7855 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7858 printf ("DW_OP_swap");
7861 printf ("DW_OP_rot");
7864 printf ("DW_OP_xderef");
7867 printf ("DW_OP_abs");
7870 printf ("DW_OP_and");
7873 printf ("DW_OP_div");
7876 printf ("DW_OP_minus");
7879 printf ("DW_OP_mod");
7882 printf ("DW_OP_mul");
7885 printf ("DW_OP_neg");
7888 printf ("DW_OP_not");
7891 printf ("DW_OP_or");
7894 printf ("DW_OP_plus");
7896 case DW_OP_plus_uconst
:
7897 printf ("DW_OP_plus_uconst: %lu",
7898 read_leb128 (data
, &bytes_read
, 0));
7902 printf ("DW_OP_shl");
7905 printf ("DW_OP_shr");
7908 printf ("DW_OP_shra");
7911 printf ("DW_OP_xor");
7914 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7918 printf ("DW_OP_eq");
7921 printf ("DW_OP_ge");
7924 printf ("DW_OP_gt");
7927 printf ("DW_OP_le");
7930 printf ("DW_OP_lt");
7933 printf ("DW_OP_ne");
7936 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7972 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
8007 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
8042 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
8043 read_leb128 (data
, &bytes_read
, 1));
8048 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
8052 need_frame_base
= 1;
8053 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
8057 uvalue
= read_leb128 (data
, &bytes_read
, 0);
8059 printf ("DW_OP_bregx: %lu %ld", uvalue
,
8060 read_leb128 (data
, &bytes_read
, 1));
8064 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
8067 case DW_OP_deref_size
:
8068 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
8070 case DW_OP_xderef_size
:
8071 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
8074 printf ("DW_OP_nop");
8077 /* DWARF 3 extensions. */
8078 case DW_OP_push_object_address
:
8079 printf ("DW_OP_push_object_address");
8082 /* XXX: Strictly speaking for 64-bit DWARF3 files
8083 this ought to be an 8-byte wide computation. */
8084 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
8088 /* XXX: Strictly speaking for 64-bit DWARF3 files
8089 this ought to be an 8-byte wide computation. */
8090 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
8093 case DW_OP_call_ref
:
8094 printf ("DW_OP_call_ref");
8097 /* GNU extensions. */
8098 case DW_OP_GNU_push_tls_address
:
8099 printf ("DW_OP_GNU_push_tls_address");
8103 if (op
>= DW_OP_lo_user
8104 && op
<= DW_OP_hi_user
)
8105 printf (_("(User defined location op)"));
8107 printf (_("(Unknown location op)"));
8108 /* No way to tell where the next op is, so just bail. */
8109 return need_frame_base
;
8112 /* Separate the ops. */
8117 return need_frame_base
;
8120 /* This structure records the information that
8121 we extract from the.debug_info section. */
8124 unsigned int pointer_size
;
8125 unsigned long cu_offset
;
8126 unsigned long base_address
;
8127 /* This is an array of offsets to the location list table. */
8128 unsigned long *loc_offsets
;
8129 int *have_frame_base
;
8130 unsigned int num_loc_offsets
;
8131 unsigned int max_loc_offsets
;
8132 unsigned long *range_lists
;
8133 unsigned int num_range_lists
;
8134 unsigned int max_range_lists
;
8138 static debug_info
* debug_information
= NULL
;
8139 static unsigned int num_debug_info_entries
= 0;
8140 static unsigned int last_pointer_size
= 0;
8141 static int warned_about_missing_comp_units
= FALSE
;
8143 static unsigned char *
8144 read_and_display_attr_value (unsigned long attribute
,
8146 unsigned char *data
,
8147 unsigned long cu_offset
,
8148 unsigned long pointer_size
,
8149 unsigned long offset_size
,
8151 debug_info
*debug_info_p
,
8154 unsigned long uvalue
= 0;
8155 unsigned char *block_start
= NULL
;
8156 unsigned int bytes_read
;
8163 case DW_FORM_ref_addr
:
8164 if (dwarf_version
== 2)
8166 uvalue
= byte_get (data
, pointer_size
);
8167 data
+= pointer_size
;
8169 else if (dwarf_version
== 3)
8171 uvalue
= byte_get (data
, offset_size
);
8172 data
+= offset_size
;
8176 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8181 uvalue
= byte_get (data
, pointer_size
);
8182 data
+= pointer_size
;
8186 uvalue
= byte_get (data
, offset_size
);
8187 data
+= offset_size
;
8193 uvalue
= byte_get (data
++, 1);
8198 uvalue
= byte_get (data
, 2);
8204 uvalue
= byte_get (data
, 4);
8209 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8213 case DW_FORM_ref_udata
:
8215 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8219 case DW_FORM_indirect
:
8220 form
= read_leb128 (data
, & bytes_read
, 0);
8223 printf (" %s", get_FORM_name (form
));
8224 return read_and_display_attr_value (attribute
, form
, data
,
8225 cu_offset
, pointer_size
,
8226 offset_size
, dwarf_version
,
8227 debug_info_p
, do_loc
);
8232 case DW_FORM_ref_addr
:
8234 printf (" <#%lx>", uvalue
);
8240 case DW_FORM_ref_udata
:
8242 printf (" <%lx>", uvalue
+ cu_offset
);
8248 printf (" %#lx", uvalue
);
8257 printf (" %ld", uvalue
);
8264 uvalue
= byte_get (data
, 4);
8265 printf (" %lx", uvalue
);
8266 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8268 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8269 && num_debug_info_entries
== 0)
8271 if (sizeof (uvalue
) == 8)
8272 uvalue
= byte_get (data
, 8);
8274 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8279 case DW_FORM_string
:
8281 printf (" %s", data
);
8282 data
+= strlen ((char *) data
) + 1;
8286 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8287 block_start
= data
+ bytes_read
;
8289 data
= block_start
+ uvalue
;
8291 data
= display_block (block_start
, uvalue
);
8294 case DW_FORM_block1
:
8295 uvalue
= byte_get (data
, 1);
8296 block_start
= data
+ 1;
8298 data
= block_start
+ uvalue
;
8300 data
= display_block (block_start
, uvalue
);
8303 case DW_FORM_block2
:
8304 uvalue
= byte_get (data
, 2);
8305 block_start
= data
+ 2;
8307 data
= block_start
+ uvalue
;
8309 data
= display_block (block_start
, uvalue
);
8312 case DW_FORM_block4
:
8313 uvalue
= byte_get (data
, 4);
8314 block_start
= data
+ 4;
8316 data
= block_start
+ uvalue
;
8318 data
= display_block (block_start
, uvalue
);
8323 printf (_(" (indirect string, offset: 0x%lx): %s"),
8324 uvalue
, fetch_indirect_string (uvalue
));
8327 case DW_FORM_indirect
:
8328 /* Handled above. */
8332 warn (_("Unrecognized form: %d\n"), form
);
8336 /* For some attributes we can display further information. */
8337 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8338 && num_debug_info_entries
== 0)
8342 case DW_AT_frame_base
:
8343 have_frame_base
= 1;
8344 case DW_AT_location
:
8345 case DW_AT_data_member_location
:
8346 case DW_AT_vtable_elem_location
:
8347 case DW_AT_allocated
:
8348 case DW_AT_associated
:
8349 case DW_AT_data_location
:
8351 case DW_AT_upper_bound
:
8352 case DW_AT_lower_bound
:
8353 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8355 /* Process location list. */
8356 unsigned int max
= debug_info_p
->max_loc_offsets
;
8357 unsigned int num
= debug_info_p
->num_loc_offsets
;
8359 if (max
== 0 || num
>= max
)
8362 debug_info_p
->loc_offsets
8363 = xrealloc (debug_info_p
->loc_offsets
,
8364 max
* sizeof (*debug_info_p
->loc_offsets
));
8365 debug_info_p
->have_frame_base
8366 = xrealloc (debug_info_p
->have_frame_base
,
8367 max
* sizeof (*debug_info_p
->have_frame_base
));
8368 debug_info_p
->max_loc_offsets
= max
;
8370 debug_info_p
->loc_offsets
[num
] = uvalue
;
8371 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8372 debug_info_p
->num_loc_offsets
++;
8377 if (need_base_address
)
8378 debug_info_p
->base_address
= uvalue
;
8382 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8384 /* Process range list. */
8385 unsigned int max
= debug_info_p
->max_range_lists
;
8386 unsigned int num
= debug_info_p
->num_range_lists
;
8388 if (max
== 0 || num
>= max
)
8391 debug_info_p
->range_lists
8392 = xrealloc (debug_info_p
->range_lists
,
8393 max
* sizeof (*debug_info_p
->range_lists
));
8394 debug_info_p
->max_range_lists
= max
;
8396 debug_info_p
->range_lists
[num
] = uvalue
;
8397 debug_info_p
->num_range_lists
++;
8416 case DW_INL_not_inlined
:
8417 printf (_("(not inlined)"));
8419 case DW_INL_inlined
:
8420 printf (_("(inlined)"));
8422 case DW_INL_declared_not_inlined
:
8423 printf (_("(declared as inline but ignored)"));
8425 case DW_INL_declared_inlined
:
8426 printf (_("(declared as inline and inlined)"));
8429 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8434 case DW_AT_language
:
8437 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8438 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8439 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8440 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8441 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8442 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8443 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8444 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8445 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8446 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8447 /* DWARF 2.1 values. */
8448 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8449 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8450 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8451 /* MIPS extension. */
8452 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8453 /* UPC extension. */
8454 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8456 printf ("(Unknown: %lx)", uvalue
);
8461 case DW_AT_encoding
:
8464 case DW_ATE_void
: printf ("(void)"); break;
8465 case DW_ATE_address
: printf ("(machine address)"); break;
8466 case DW_ATE_boolean
: printf ("(boolean)"); break;
8467 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8468 case DW_ATE_float
: printf ("(float)"); break;
8469 case DW_ATE_signed
: printf ("(signed)"); break;
8470 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8471 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8472 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8473 /* DWARF 2.1 value. */
8474 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8475 /* GNU extension. */
8476 case DW_ATE_GNU_decimal_float
: printf ("(decimal float)"); break;
8478 if (uvalue
>= DW_ATE_lo_user
8479 && uvalue
<= DW_ATE_hi_user
)
8480 printf ("(user defined type)");
8482 printf ("(unknown type)");
8487 case DW_AT_accessibility
:
8490 case DW_ACCESS_public
: printf ("(public)"); break;
8491 case DW_ACCESS_protected
: printf ("(protected)"); break;
8492 case DW_ACCESS_private
: printf ("(private)"); break;
8494 printf ("(unknown accessibility)");
8499 case DW_AT_visibility
:
8502 case DW_VIS_local
: printf ("(local)"); break;
8503 case DW_VIS_exported
: printf ("(exported)"); break;
8504 case DW_VIS_qualified
: printf ("(qualified)"); break;
8505 default: printf ("(unknown visibility)"); break;
8509 case DW_AT_virtuality
:
8512 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8513 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8514 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8515 default: printf ("(unknown virtuality)"); break;
8519 case DW_AT_identifier_case
:
8522 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8523 case DW_ID_up_case
: printf ("(up_case)"); break;
8524 case DW_ID_down_case
: printf ("(down_case)"); break;
8525 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8526 default: printf ("(unknown case)"); break;
8530 case DW_AT_calling_convention
:
8533 case DW_CC_normal
: printf ("(normal)"); break;
8534 case DW_CC_program
: printf ("(program)"); break;
8535 case DW_CC_nocall
: printf ("(nocall)"); break;
8537 if (uvalue
>= DW_CC_lo_user
8538 && uvalue
<= DW_CC_hi_user
)
8539 printf ("(user defined)");
8541 printf ("(unknown convention)");
8545 case DW_AT_ordering
:
8548 case -1: printf ("(undefined)"); break;
8549 case 0: printf ("(row major)"); break;
8550 case 1: printf ("(column major)"); break;
8554 case DW_AT_frame_base
:
8555 have_frame_base
= 1;
8556 case DW_AT_location
:
8557 case DW_AT_data_member_location
:
8558 case DW_AT_vtable_elem_location
:
8559 case DW_AT_allocated
:
8560 case DW_AT_associated
:
8561 case DW_AT_data_location
:
8563 case DW_AT_upper_bound
:
8564 case DW_AT_lower_bound
:
8567 int need_frame_base
;
8570 need_frame_base
= decode_location_expression (block_start
,
8575 if (need_frame_base
&& !have_frame_base
)
8576 printf (_(" [without DW_AT_frame_base]"));
8578 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8579 printf (_("(location list)"));
8591 get_AT_name (unsigned long attribute
)
8595 case DW_AT_sibling
: return "DW_AT_sibling";
8596 case DW_AT_location
: return "DW_AT_location";
8597 case DW_AT_name
: return "DW_AT_name";
8598 case DW_AT_ordering
: return "DW_AT_ordering";
8599 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8600 case DW_AT_byte_size
: return "DW_AT_byte_size";
8601 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8602 case DW_AT_bit_size
: return "DW_AT_bit_size";
8603 case DW_AT_element_list
: return "DW_AT_element_list";
8604 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8605 case DW_AT_low_pc
: return "DW_AT_low_pc";
8606 case DW_AT_high_pc
: return "DW_AT_high_pc";
8607 case DW_AT_language
: return "DW_AT_language";
8608 case DW_AT_member
: return "DW_AT_member";
8609 case DW_AT_discr
: return "DW_AT_discr";
8610 case DW_AT_discr_value
: return "DW_AT_discr_value";
8611 case DW_AT_visibility
: return "DW_AT_visibility";
8612 case DW_AT_import
: return "DW_AT_import";
8613 case DW_AT_string_length
: return "DW_AT_string_length";
8614 case DW_AT_common_reference
: return "DW_AT_common_reference";
8615 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8616 case DW_AT_const_value
: return "DW_AT_const_value";
8617 case DW_AT_containing_type
: return "DW_AT_containing_type";
8618 case DW_AT_default_value
: return "DW_AT_default_value";
8619 case DW_AT_inline
: return "DW_AT_inline";
8620 case DW_AT_is_optional
: return "DW_AT_is_optional";
8621 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8622 case DW_AT_producer
: return "DW_AT_producer";
8623 case DW_AT_prototyped
: return "DW_AT_prototyped";
8624 case DW_AT_return_addr
: return "DW_AT_return_addr";
8625 case DW_AT_start_scope
: return "DW_AT_start_scope";
8626 case DW_AT_stride_size
: return "DW_AT_stride_size";
8627 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8628 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8629 case DW_AT_accessibility
: return "DW_AT_accessibility";
8630 case DW_AT_address_class
: return "DW_AT_address_class";
8631 case DW_AT_artificial
: return "DW_AT_artificial";
8632 case DW_AT_base_types
: return "DW_AT_base_types";
8633 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8634 case DW_AT_count
: return "DW_AT_count";
8635 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8636 case DW_AT_decl_column
: return "DW_AT_decl_column";
8637 case DW_AT_decl_file
: return "DW_AT_decl_file";
8638 case DW_AT_decl_line
: return "DW_AT_decl_line";
8639 case DW_AT_declaration
: return "DW_AT_declaration";
8640 case DW_AT_discr_list
: return "DW_AT_discr_list";
8641 case DW_AT_encoding
: return "DW_AT_encoding";
8642 case DW_AT_external
: return "DW_AT_external";
8643 case DW_AT_frame_base
: return "DW_AT_frame_base";
8644 case DW_AT_friend
: return "DW_AT_friend";
8645 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8646 case DW_AT_macro_info
: return "DW_AT_macro_info";
8647 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8648 case DW_AT_priority
: return "DW_AT_priority";
8649 case DW_AT_segment
: return "DW_AT_segment";
8650 case DW_AT_specification
: return "DW_AT_specification";
8651 case DW_AT_static_link
: return "DW_AT_static_link";
8652 case DW_AT_type
: return "DW_AT_type";
8653 case DW_AT_use_location
: return "DW_AT_use_location";
8654 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8655 case DW_AT_virtuality
: return "DW_AT_virtuality";
8656 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8657 /* DWARF 2.1 values. */
8658 case DW_AT_allocated
: return "DW_AT_allocated";
8659 case DW_AT_associated
: return "DW_AT_associated";
8660 case DW_AT_data_location
: return "DW_AT_data_location";
8661 case DW_AT_stride
: return "DW_AT_stride";
8662 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8663 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8664 case DW_AT_extension
: return "DW_AT_extension";
8665 case DW_AT_ranges
: return "DW_AT_ranges";
8666 case DW_AT_trampoline
: return "DW_AT_trampoline";
8667 case DW_AT_call_column
: return "DW_AT_call_column";
8668 case DW_AT_call_file
: return "DW_AT_call_file";
8669 case DW_AT_call_line
: return "DW_AT_call_line";
8670 /* SGI/MIPS extensions. */
8671 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8672 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8673 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8674 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8675 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8676 case DW_AT_MIPS_software_pipeline_depth
:
8677 return "DW_AT_MIPS_software_pipeline_depth";
8678 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8679 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8680 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8681 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8682 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8683 /* GNU extensions. */
8684 case DW_AT_sf_names
: return "DW_AT_sf_names";
8685 case DW_AT_src_info
: return "DW_AT_src_info";
8686 case DW_AT_mac_info
: return "DW_AT_mac_info";
8687 case DW_AT_src_coords
: return "DW_AT_src_coords";
8688 case DW_AT_body_begin
: return "DW_AT_body_begin";
8689 case DW_AT_body_end
: return "DW_AT_body_end";
8690 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8691 /* UPC extension. */
8692 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8695 static char buffer
[100];
8697 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8704 static unsigned char *
8705 read_and_display_attr (unsigned long attribute
,
8707 unsigned char *data
,
8708 unsigned long cu_offset
,
8709 unsigned long pointer_size
,
8710 unsigned long offset_size
,
8712 debug_info
*debug_info_p
,
8716 printf (" %-18s:", get_AT_name (attribute
));
8717 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8718 pointer_size
, offset_size
,
8719 dwarf_version
, debug_info_p
,
8727 /* Process the contents of a .debug_info section. If do_loc is non-zero
8728 then we are scanning for location lists and we do not want to display
8729 anything to the user. */
8732 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8733 FILE *file
, int do_loc
)
8735 unsigned char *end
= start
+ section
->sh_size
;
8736 unsigned char *section_begin
;
8738 unsigned int num_units
= 0;
8740 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8741 && num_debug_info_entries
== 0)
8743 unsigned long length
;
8745 /* First scan the section to get the number of comp units. */
8746 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8749 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8750 will be the length. For a 64-bit DWARF section, it'll be
8751 the escape code 0xffffffff followed by an 8 byte length. */
8752 length
= byte_get (section_begin
, 4);
8754 if (length
== 0xffffffff)
8756 length
= byte_get (section_begin
+ 4, 8);
8757 section_begin
+= length
+ 12;
8760 section_begin
+= length
+ 4;
8765 error (_("No comp units in .debug_info section ?"));
8769 /* Then allocate an array to hold the information. */
8770 debug_information
= malloc (num_units
*
8771 sizeof (* debug_information
));
8772 if (debug_information
== NULL
)
8774 error (_("Not enough memory for a debug info array of %u entries"),
8782 printf (_("The section %s contains:\n\n"),
8783 SECTION_NAME (section
));
8785 load_debug_str (file
);
8786 load_debug_loc (file
);
8787 load_debug_range (file
);
8790 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8792 DWARF2_Internal_CompUnit compunit
;
8793 unsigned char *hdrptr
;
8794 unsigned char *cu_abbrev_offset_ptr
;
8795 unsigned char *tags
;
8797 unsigned long cu_offset
;
8799 int initial_length_size
;
8803 compunit
.cu_length
= byte_get (hdrptr
, 4);
8806 if (compunit
.cu_length
== 0xffffffff)
8808 compunit
.cu_length
= byte_get (hdrptr
, 8);
8811 initial_length_size
= 12;
8816 initial_length_size
= 4;
8819 compunit
.cu_version
= byte_get (hdrptr
, 2);
8822 cu_offset
= start
- section_begin
;
8823 start
+= compunit
.cu_length
+ initial_length_size
;
8825 if (elf_header
.e_type
== ET_REL
8826 && !debug_apply_rela_addends (file
, section
, offset_size
,
8827 section_begin
, hdrptr
, start
))
8830 cu_abbrev_offset_ptr
= hdrptr
;
8831 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8832 hdrptr
+= offset_size
;
8834 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8836 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8837 && num_debug_info_entries
== 0)
8839 debug_information
[unit
].cu_offset
= cu_offset
;
8840 debug_information
[unit
].pointer_size
8841 = compunit
.cu_pointer_size
;
8842 debug_information
[unit
].base_address
= 0;
8843 debug_information
[unit
].loc_offsets
= NULL
;
8844 debug_information
[unit
].have_frame_base
= NULL
;
8845 debug_information
[unit
].max_loc_offsets
= 0;
8846 debug_information
[unit
].num_loc_offsets
= 0;
8847 debug_information
[unit
].range_lists
= NULL
;
8848 debug_information
[unit
].max_range_lists
= 0;
8849 debug_information
[unit
].num_range_lists
= 0;
8856 printf (_(" Compilation Unit @ offset 0x%lx:\n"), cu_offset
);
8857 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8858 printf (_(" Version: %d\n"), compunit
.cu_version
);
8859 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8860 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8863 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8865 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8871 /* Read in the abbrevs used by this compilation unit. */
8873 Elf_Internal_Shdr
*sec
;
8874 unsigned char *begin
;
8876 /* Locate the .debug_abbrev section and process it. */
8877 sec
= find_section (".debug_abbrev");
8880 warn (_("Unable to locate .debug_abbrev section!\n"));
8884 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8885 _("debug_abbrev section data"));
8889 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8890 begin
+ sec
->sh_size
);
8896 while (tags
< start
)
8898 unsigned int bytes_read
;
8899 unsigned long abbrev_number
;
8900 abbrev_entry
*entry
;
8903 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8906 /* A null DIE marks the end of a list of children. */
8907 if (abbrev_number
== 0)
8913 /* Scan through the abbreviation list until we reach the
8915 for (entry
= first_abbrev
;
8916 entry
&& entry
->entry
!= abbrev_number
;
8917 entry
= entry
->next
)
8922 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8928 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8930 (unsigned long) (tags
- section_begin
8933 get_TAG_name (entry
->tag
));
8938 need_base_address
= 0;
8940 case DW_TAG_compile_unit
:
8941 need_base_address
= 1;
8943 case DW_TAG_entry_point
:
8944 case DW_TAG_inlined_subroutine
:
8945 case DW_TAG_subprogram
:
8946 need_base_address
= 0;
8947 /* Assuming that there is no DW_AT_frame_base. */
8948 have_frame_base
= 0;
8952 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8953 tags
= read_and_display_attr (attr
->attribute
,
8956 compunit
.cu_pointer_size
,
8958 compunit
.cu_version
,
8959 &debug_information
[unit
],
8962 if (entry
->children
)
8967 /* Set num_debug_info_entries here so that it can be used to check if
8968 we need to process .debug_loc and .debug_ranges sections. */
8969 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8970 && num_debug_info_entries
== 0)
8971 num_debug_info_entries
= num_units
;
8975 free_debug_range ();
8985 /* Retrieve the pointer size associated with the given compilation unit.
8986 Optionally the offset of this unit into the .debug_info section is
8987 also retutned. If there is no .debug_info section then an error
8988 message is issued and 0 is returned. If the requested comp unit has
8989 not been defined in the .debug_info section then a warning message
8990 is issued and the last know pointer size is returned. This message
8991 is only issued once per section dumped per file dumped. */
8994 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8995 const char * section_name
,
8996 unsigned long * offset_return
)
8998 unsigned long offset
= 0;
9000 if (num_debug_info_entries
== 0)
9001 error (_("%s section needs a populated .debug_info section\n"),
9004 else if (comp_unit
>= num_debug_info_entries
)
9006 if (!warned_about_missing_comp_units
)
9008 warn (_("%s section has more comp units than .debug_info section\n"),
9010 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
9012 warned_about_missing_comp_units
= TRUE
;
9017 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
9018 offset
= debug_information
[comp_unit
].cu_offset
;
9021 if (offset_return
!= NULL
)
9022 * offset_return
= offset
;
9024 return last_pointer_size
;
9027 /* Locate and scan the .debug_info section in the file and record the pointer
9028 sizes and offsets for the compilation units in it. Usually an executable
9029 will have just one pointer size, but this is not guaranteed, and so we try
9030 not to make any assumptions. Returns zero upon failure, or the number of
9031 compilation units upon success. */
9034 get_debug_info (FILE * file
)
9036 Elf_Internal_Shdr
* section
;
9037 unsigned char * start
;
9040 /* Reset the last pointer size so that we can issue correct error
9041 messages if we are displaying the contents of more than one section. */
9042 last_pointer_size
= 0;
9043 warned_about_missing_comp_units
= FALSE
;
9045 /* If we already have the information there is nothing else to do. */
9046 if (num_debug_info_entries
> 0)
9047 return num_debug_info_entries
;
9049 section
= find_section (".debug_info");
9050 if (section
== NULL
)
9053 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9054 _("extracting information from .debug_info section"));
9058 ret
= process_debug_info (section
, start
, file
, 1);
9061 return ret
? num_debug_info_entries
: 0;
9065 display_debug_lines (Elf_Internal_Shdr
*section
,
9066 unsigned char *start
, FILE *file
)
9068 unsigned char *data
= start
;
9069 unsigned char *end
= start
+ section
->sh_size
;
9070 unsigned int comp_unit
= 0;
9072 printf (_("\nDump of debug contents of section %s:\n\n"),
9073 SECTION_NAME (section
));
9075 get_debug_info (file
);
9079 DWARF2_Internal_LineInfo info
;
9080 unsigned char *standard_opcodes
;
9081 unsigned char *end_of_sequence
;
9082 unsigned char *hdrptr
;
9083 unsigned int pointer_size
;
9084 int initial_length_size
;
9090 /* Check the length of the block. */
9091 info
.li_length
= byte_get (hdrptr
, 4);
9094 if (info
.li_length
== 0xffffffff)
9096 /* This section is 64-bit DWARF 3. */
9097 info
.li_length
= byte_get (hdrptr
, 8);
9100 initial_length_size
= 12;
9105 initial_length_size
= 4;
9108 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
9111 (_("The line info appears to be corrupt - the section is too small\n"));
9115 /* Check its version number. */
9116 info
.li_version
= byte_get (hdrptr
, 2);
9118 if (info
.li_version
!= 2 && info
.li_version
!= 3)
9120 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
9124 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
9125 hdrptr
+= offset_size
;
9126 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
9128 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
9130 info
.li_line_base
= byte_get (hdrptr
, 1);
9132 info
.li_line_range
= byte_get (hdrptr
, 1);
9134 info
.li_opcode_base
= byte_get (hdrptr
, 1);
9137 /* Sign extend the line base field. */
9138 info
.li_line_base
<<= 24;
9139 info
.li_line_base
>>= 24;
9141 /* Get the pointer size from the comp unit associated
9142 with this block of line number information. */
9143 pointer_size
= get_pointer_size_and_offset_of_comp_unit
9144 (comp_unit
, ".debug_line", NULL
);
9147 printf (_(" Length: %ld\n"), info
.li_length
);
9148 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9149 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9150 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9151 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9152 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9153 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9154 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9155 printf (_(" (Pointer size: %u)%s\n"),
9157 warned_about_missing_comp_units
? " [assumed]" : "" );
9159 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9161 reset_state_machine (info
.li_default_is_stmt
);
9163 /* Display the contents of the Opcodes table. */
9164 standard_opcodes
= hdrptr
;
9166 printf (_("\n Opcodes:\n"));
9168 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9169 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9171 /* Display the contents of the Directory table. */
9172 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9175 printf (_("\n The Directory Table is empty.\n"));
9178 printf (_("\n The Directory Table:\n"));
9182 printf (_(" %s\n"), data
);
9184 data
+= strlen ((char *) data
) + 1;
9188 /* Skip the NUL at the end of the table. */
9191 /* Display the contents of the File Name table. */
9193 printf (_("\n The File Name Table is empty.\n"));
9196 printf (_("\n The File Name Table:\n"));
9197 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9201 unsigned char *name
;
9202 unsigned int bytes_read
;
9204 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9207 data
+= strlen ((char *) data
) + 1;
9209 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9211 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9213 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9215 printf (_("%s\n"), name
);
9219 /* Skip the NUL at the end of the table. */
9222 /* Now display the statements. */
9223 printf (_("\n Line Number Statements:\n"));
9225 while (data
< end_of_sequence
)
9227 unsigned char op_code
;
9229 unsigned int bytes_read
;
9233 if (op_code
>= info
.li_opcode_base
)
9235 op_code
-= info
.li_opcode_base
;
9236 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9237 state_machine_regs
.address
+= adv
;
9238 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9239 op_code
, adv
, state_machine_regs
.address
);
9240 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9241 state_machine_regs
.line
+= adv
;
9242 printf (_(" and Line by %d to %d\n"),
9243 adv
, state_machine_regs
.line
);
9245 else switch (op_code
)
9247 case DW_LNS_extended_op
:
9248 if (pointer_size
== 0)
9250 warn (_("Extend line ops need a valid pointer size, guessing at 4\n"));
9254 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9259 printf (_(" Copy\n"));
9262 case DW_LNS_advance_pc
:
9263 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9265 state_machine_regs
.address
+= adv
;
9266 printf (_(" Advance PC by %d to %lx\n"), adv
,
9267 state_machine_regs
.address
);
9270 case DW_LNS_advance_line
:
9271 adv
= read_leb128 (data
, & bytes_read
, 1);
9273 state_machine_regs
.line
+= adv
;
9274 printf (_(" Advance Line by %d to %d\n"), adv
,
9275 state_machine_regs
.line
);
9278 case DW_LNS_set_file
:
9279 adv
= read_leb128 (data
, & bytes_read
, 0);
9281 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9283 state_machine_regs
.file
= adv
;
9286 case DW_LNS_set_column
:
9287 adv
= read_leb128 (data
, & bytes_read
, 0);
9289 printf (_(" Set column to %d\n"), adv
);
9290 state_machine_regs
.column
= adv
;
9293 case DW_LNS_negate_stmt
:
9294 adv
= state_machine_regs
.is_stmt
;
9296 printf (_(" Set is_stmt to %d\n"), adv
);
9297 state_machine_regs
.is_stmt
= adv
;
9300 case DW_LNS_set_basic_block
:
9301 printf (_(" Set basic block\n"));
9302 state_machine_regs
.basic_block
= 1;
9305 case DW_LNS_const_add_pc
:
9306 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9307 * info
.li_min_insn_length
);
9308 state_machine_regs
.address
+= adv
;
9309 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9310 state_machine_regs
.address
);
9313 case DW_LNS_fixed_advance_pc
:
9314 adv
= byte_get (data
, 2);
9316 state_machine_regs
.address
+= adv
;
9317 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9318 adv
, state_machine_regs
.address
);
9321 case DW_LNS_set_prologue_end
:
9322 printf (_(" Set prologue_end to true\n"));
9325 case DW_LNS_set_epilogue_begin
:
9326 printf (_(" Set epilogue_begin to true\n"));
9329 case DW_LNS_set_isa
:
9330 adv
= read_leb128 (data
, & bytes_read
, 0);
9332 printf (_(" Set ISA to %d\n"), adv
);
9336 printf (_(" Unknown opcode %d with operands: "), op_code
);
9338 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9340 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9341 i
== 1 ? "" : ", ");
9355 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9356 unsigned char *start
,
9357 FILE *file ATTRIBUTE_UNUSED
)
9359 DWARF2_Internal_PubNames pubnames
;
9362 end
= start
+ section
->sh_size
;
9364 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9368 unsigned char *data
;
9369 unsigned long offset
;
9370 int offset_size
, initial_length_size
;
9374 pubnames
.pn_length
= byte_get (data
, 4);
9376 if (pubnames
.pn_length
== 0xffffffff)
9378 pubnames
.pn_length
= byte_get (data
, 8);
9381 initial_length_size
= 12;
9386 initial_length_size
= 4;
9389 pubnames
.pn_version
= byte_get (data
, 2);
9391 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9392 data
+= offset_size
;
9393 pubnames
.pn_size
= byte_get (data
, offset_size
);
9394 data
+= offset_size
;
9396 start
+= pubnames
.pn_length
+ initial_length_size
;
9398 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9400 static int warned
= 0;
9404 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9411 printf (_(" Length: %ld\n"),
9412 pubnames
.pn_length
);
9413 printf (_(" Version: %d\n"),
9414 pubnames
.pn_version
);
9415 printf (_(" Offset into .debug_info section: %ld\n"),
9416 pubnames
.pn_offset
);
9417 printf (_(" Size of area in .debug_info section: %ld\n"),
9420 printf (_("\n Offset\tName\n"));
9424 offset
= byte_get (data
, offset_size
);
9428 data
+= offset_size
;
9429 printf (" %-6ld\t\t%s\n", offset
, data
);
9430 data
+= strlen ((char *) data
) + 1;
9433 while (offset
!= 0);
9441 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9442 unsigned char *start
,
9443 FILE *file ATTRIBUTE_UNUSED
)
9445 unsigned char *end
= start
+ section
->sh_size
;
9446 unsigned char *curr
= start
;
9447 unsigned int bytes_read
;
9448 enum dwarf_macinfo_record_type op
;
9450 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9454 unsigned int lineno
;
9462 case DW_MACINFO_start_file
:
9464 unsigned int filenum
;
9466 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9468 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9471 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9476 case DW_MACINFO_end_file
:
9477 printf (_(" DW_MACINFO_end_file\n"));
9480 case DW_MACINFO_define
:
9481 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9483 string
= (char *) curr
;
9484 curr
+= strlen (string
) + 1;
9485 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9489 case DW_MACINFO_undef
:
9490 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9492 string
= (char *) curr
;
9493 curr
+= strlen (string
) + 1;
9494 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9498 case DW_MACINFO_vendor_ext
:
9500 unsigned int constant
;
9502 constant
= read_leb128 (curr
, & bytes_read
, 0);
9504 string
= (char *) curr
;
9505 curr
+= strlen (string
) + 1;
9506 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9518 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9519 unsigned char *start
,
9520 FILE *file ATTRIBUTE_UNUSED
)
9522 abbrev_entry
*entry
;
9523 unsigned char *end
= start
+ section
->sh_size
;
9525 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9529 start
= process_abbrev_section (start
, end
);
9531 if (first_abbrev
== NULL
)
9534 printf (_(" Number TAG\n"));
9536 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9540 printf (_(" %ld %s [%s]\n"),
9542 get_TAG_name (entry
->tag
),
9543 entry
->children
? _("has children") : _("no children"));
9545 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9546 printf (_(" %-18s %s\n"),
9547 get_AT_name (attr
->attribute
),
9548 get_FORM_name (attr
->form
));
9561 display_debug_loc (Elf_Internal_Shdr
*section
,
9562 unsigned char *start
, FILE *file
)
9564 unsigned char *section_end
;
9565 unsigned long bytes
;
9566 unsigned char *section_begin
= start
;
9567 unsigned int num_loc_list
= 0;
9568 unsigned long last_offset
= 0;
9569 unsigned int first
= 0;
9572 int seen_first_offset
= 0;
9573 int use_debug_info
= 1;
9574 unsigned char *next
;
9576 bytes
= section
->sh_size
;
9577 section_end
= start
+ bytes
;
9581 printf (_("\nThe .debug_loc section is empty.\n"));
9585 get_debug_info (file
);
9587 /* Check the order of location list in .debug_info section. If
9588 offsets of location lists are in the ascending order, we can
9589 use `debug_information' directly. */
9590 for (i
= 0; i
< num_debug_info_entries
; i
++)
9594 num
= debug_information
[i
].num_loc_offsets
;
9595 num_loc_list
+= num
;
9597 /* Check if we can use `debug_information' directly. */
9598 if (use_debug_info
&& num
!= 0)
9600 if (!seen_first_offset
)
9602 /* This is the first location list. */
9603 last_offset
= debug_information
[i
].loc_offsets
[0];
9605 seen_first_offset
= 1;
9611 for (; j
< num
; j
++)
9614 debug_information
[i
].loc_offsets
[j
])
9619 last_offset
= debug_information
[i
].loc_offsets
[j
];
9624 if (!use_debug_info
)
9625 /* FIXME: Should we handle this case? */
9626 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9628 if (!seen_first_offset
)
9629 error (_("No location lists in .debug_info section!\n"));
9631 if (debug_information
[first
].loc_offsets
[0] != 0)
9632 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9633 debug_information
[first
].loc_offsets
[0]);
9635 printf (_("Contents of the .debug_loc section:\n\n"));
9636 printf (_(" Offset Begin End Expression\n"));
9638 seen_first_offset
= 0;
9639 for (i
= first
; i
< num_debug_info_entries
; i
++)
9641 unsigned long begin
;
9643 unsigned short length
;
9644 unsigned long offset
;
9645 unsigned int pointer_size
;
9646 unsigned long cu_offset
;
9647 unsigned long base_address
;
9648 int need_frame_base
;
9651 pointer_size
= debug_information
[i
].pointer_size
;
9652 cu_offset
= debug_information
[i
].cu_offset
;
9654 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9656 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9657 offset
= debug_information
[i
].loc_offsets
[j
];
9658 next
= section_begin
+ offset
;
9659 base_address
= debug_information
[i
].base_address
;
9661 if (!seen_first_offset
)
9662 seen_first_offset
= 1;
9666 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9667 start
- section_begin
, next
- section_begin
);
9668 else if (start
> next
)
9669 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9670 start
- section_begin
, next
- section_begin
);
9676 begin
= byte_get (start
, pointer_size
);
9677 start
+= pointer_size
;
9678 end
= byte_get (start
, pointer_size
);
9679 start
+= pointer_size
;
9681 if (begin
== 0 && end
== 0)
9683 printf (_(" %8.8lx <End of list>\n"), offset
);
9687 /* Check base address specifiers. */
9688 if (begin
== -1UL && end
!= -1UL)
9691 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9692 offset
, begin
, end
);
9696 length
= byte_get (start
, 2);
9699 printf (" %8.8lx %8.8lx %8.8lx (",
9700 offset
, begin
+ base_address
, end
+ base_address
);
9701 need_frame_base
= decode_location_expression (start
,
9707 if (need_frame_base
&& !has_frame_base
)
9708 printf (_(" [without DW_AT_frame_base]"));
9711 fputs (_(" (start == end)"), stdout
);
9712 else if (begin
> end
)
9713 fputs (_(" (start > end)"), stdout
);
9725 display_debug_str (Elf_Internal_Shdr
*section
,
9726 unsigned char *start
,
9727 FILE *file ATTRIBUTE_UNUSED
)
9729 unsigned long bytes
;
9732 addr
= section
->sh_addr
;
9733 bytes
= section
->sh_size
;
9737 printf (_("\nThe .debug_str section is empty.\n"));
9741 printf (_("Contents of the .debug_str section:\n\n"));
9749 lbytes
= (bytes
> 16 ? 16 : bytes
);
9751 printf (" 0x%8.8lx ", (unsigned long) addr
);
9753 for (j
= 0; j
< 16; j
++)
9756 printf ("%2.2x", start
[j
]);
9764 for (j
= 0; j
< lbytes
; j
++)
9767 if (k
>= ' ' && k
< 0x80)
9787 display_debug_info (Elf_Internal_Shdr
* section
,
9788 unsigned char * start
, FILE * file
)
9790 return process_debug_info (section
, start
, file
, 0);
9795 display_debug_aranges (Elf_Internal_Shdr
*section
,
9796 unsigned char *start
,
9797 FILE *file ATTRIBUTE_UNUSED
)
9799 unsigned char *end
= start
+ section
->sh_size
;
9801 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9805 unsigned char *hdrptr
;
9806 DWARF2_Internal_ARange arange
;
9807 unsigned char *ranges
;
9808 unsigned long length
;
9809 unsigned long address
;
9812 int initial_length_size
;
9816 arange
.ar_length
= byte_get (hdrptr
, 4);
9819 if (arange
.ar_length
== 0xffffffff)
9821 arange
.ar_length
= byte_get (hdrptr
, 8);
9824 initial_length_size
= 12;
9829 initial_length_size
= 4;
9832 arange
.ar_version
= byte_get (hdrptr
, 2);
9835 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9836 hdrptr
+= offset_size
;
9838 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9841 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9844 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9846 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9850 printf (_(" Length: %ld\n"), arange
.ar_length
);
9851 printf (_(" Version: %d\n"), arange
.ar_version
);
9852 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9853 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9854 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9856 printf (_("\n Address Length\n"));
9860 /* Must pad to an alignment boundary that is twice the pointer size. */
9861 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9863 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9867 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9869 ranges
+= arange
.ar_pointer_size
;
9871 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9873 ranges
+= arange
.ar_pointer_size
;
9875 /* A pair of zeros marks the end of the list. */
9876 if (address
== 0 && length
== 0)
9879 printf (" %8.8lx %lu\n", address
, length
);
9882 start
+= arange
.ar_length
+ initial_length_size
;
9891 display_debug_ranges (Elf_Internal_Shdr
*section
,
9892 unsigned char *start
,
9893 FILE *file ATTRIBUTE_UNUSED
)
9895 unsigned char *section_end
;
9896 unsigned long bytes
;
9897 unsigned char *section_begin
= start
;
9898 unsigned int num_range_list
= 0;
9899 unsigned long last_offset
= 0;
9900 unsigned int first
= 0;
9903 int seen_first_offset
= 0;
9904 int use_debug_info
= 1;
9905 unsigned char *next
;
9907 bytes
= section
->sh_size
;
9908 section_end
= start
+ bytes
;
9912 printf (_("\nThe .debug_ranges section is empty.\n"));
9916 get_debug_info (file
);
9918 /* Check the order of range list in .debug_info section. If
9919 offsets of range lists are in the ascending order, we can
9920 use `debug_information' directly. */
9921 for (i
= 0; i
< num_debug_info_entries
; i
++)
9925 num
= debug_information
[i
].num_range_lists
;
9926 num_range_list
+= num
;
9928 /* Check if we can use `debug_information' directly. */
9929 if (use_debug_info
&& num
!= 0)
9931 if (!seen_first_offset
)
9933 /* This is the first range list. */
9934 last_offset
= debug_information
[i
].range_lists
[0];
9936 seen_first_offset
= 1;
9942 for (; j
< num
; j
++)
9945 debug_information
[i
].range_lists
[j
])
9950 last_offset
= debug_information
[i
].range_lists
[j
];
9955 if (!use_debug_info
)
9956 /* FIXME: Should we handle this case? */
9957 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9959 if (!seen_first_offset
)
9960 error (_("No range lists in .debug_info section!\n"));
9962 if (debug_information
[first
].range_lists
[0] != 0)
9963 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9964 debug_information
[first
].range_lists
[0]);
9966 printf (_("Contents of the .debug_ranges section:\n\n"));
9967 printf (_(" Offset Begin End\n"));
9969 seen_first_offset
= 0;
9970 for (i
= first
; i
< num_debug_info_entries
; i
++)
9972 unsigned long begin
;
9974 unsigned long offset
;
9975 unsigned int pointer_size
;
9976 unsigned long base_address
;
9978 pointer_size
= debug_information
[i
].pointer_size
;
9980 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9982 offset
= debug_information
[i
].range_lists
[j
];
9983 next
= section_begin
+ offset
;
9984 base_address
= debug_information
[i
].base_address
;
9986 if (!seen_first_offset
)
9987 seen_first_offset
= 1;
9991 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9992 start
- section_begin
, next
- section_begin
);
9993 else if (start
> next
)
9994 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9995 start
- section_begin
, next
- section_begin
);
10001 begin
= byte_get (start
, pointer_size
);
10002 start
+= pointer_size
;
10003 end
= byte_get (start
, pointer_size
);
10004 start
+= pointer_size
;
10006 if (begin
== 0 && end
== 0)
10008 printf (_(" %8.8lx <End of list>\n"), offset
);
10012 /* Check base address specifiers. */
10013 if (begin
== -1UL && end
!= -1UL)
10015 base_address
= end
;
10016 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
10017 offset
, begin
, end
);
10021 printf (" %8.8lx %8.8lx %8.8lx",
10022 offset
, begin
+ base_address
, end
+ base_address
);
10025 fputs (_(" (start == end)"), stdout
);
10026 else if (begin
> end
)
10027 fputs (_(" (start > end)"), stdout
);
10037 typedef struct Frame_Chunk
10039 struct Frame_Chunk
*next
;
10040 unsigned char *chunk_start
;
10042 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
10043 short int *col_type
;
10045 char *augmentation
;
10046 unsigned int code_factor
;
10048 unsigned long pc_begin
;
10049 unsigned long pc_range
;
10053 unsigned char fde_encoding
;
10054 unsigned char cfa_exp
;
10058 /* A marker for a col_type that means this column was never referenced
10059 in the frame info. */
10060 #define DW_CFA_unreferenced (-1)
10063 frame_need_space (Frame_Chunk
*fc
, int reg
)
10065 int prev
= fc
->ncols
;
10067 if (reg
< fc
->ncols
)
10070 fc
->ncols
= reg
+ 1;
10071 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
10072 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
10074 while (prev
< fc
->ncols
)
10076 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
10077 fc
->col_offset
[prev
] = 0;
10083 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
10088 if (*max_regs
< fc
->ncols
)
10089 *max_regs
= fc
->ncols
;
10091 if (*need_col_headers
)
10093 *need_col_headers
= 0;
10095 printf (" LOC CFA ");
10097 for (r
= 0; r
< *max_regs
; r
++)
10098 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10103 printf ("r%-4d", r
);
10109 printf ("%08lx ", fc
->pc_begin
);
10111 strcpy (tmp
, "exp");
10113 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
10114 printf ("%-8s ", tmp
);
10116 for (r
= 0; r
< fc
->ncols
; r
++)
10118 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
10120 switch (fc
->col_type
[r
])
10122 case DW_CFA_undefined
:
10125 case DW_CFA_same_value
:
10128 case DW_CFA_offset
:
10129 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
10131 case DW_CFA_register
:
10132 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
10134 case DW_CFA_expression
:
10135 strcpy (tmp
, "exp");
10138 strcpy (tmp
, "n/a");
10141 printf ("%-5s", tmp
);
10148 size_of_encoded_value (int encoding
)
10150 switch (encoding
& 0x7)
10153 case 0: return eh_addr_size
;
10161 get_encoded_value (unsigned char *data
, int encoding
)
10163 int size
= size_of_encoded_value (encoding
);
10164 if (encoding
& DW_EH_PE_signed
)
10165 return byte_get_signed (data
, size
);
10167 return byte_get (data
, size
);
10170 #define GET(N) byte_get (start, N); start += N
10171 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10172 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10175 display_debug_frames (Elf_Internal_Shdr
*section
,
10176 unsigned char *start
,
10177 FILE *file ATTRIBUTE_UNUSED
)
10179 unsigned char *end
= start
+ section
->sh_size
;
10180 unsigned char *section_start
= start
;
10181 Frame_Chunk
*chunks
= 0;
10182 Frame_Chunk
*remembered_state
= 0;
10184 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10185 unsigned int length_return
;
10188 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10190 while (start
< end
)
10192 unsigned char *saved_start
;
10193 unsigned char *block_end
;
10194 unsigned long length
;
10195 unsigned long cie_id
;
10198 int need_col_headers
= 1;
10199 unsigned char *augmentation_data
= NULL
;
10200 unsigned long augmentation_data_len
= 0;
10201 int encoded_ptr_size
= eh_addr_size
;
10203 int initial_length_size
;
10205 saved_start
= start
;
10206 length
= byte_get (start
, 4); start
+= 4;
10210 printf ("\n%08lx ZERO terminator\n\n",
10211 (unsigned long)(saved_start
- section_start
));
10215 if (length
== 0xffffffff)
10217 length
= byte_get (start
, 8);
10220 initial_length_size
= 12;
10225 initial_length_size
= 4;
10228 block_end
= saved_start
+ length
+ initial_length_size
;
10229 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10231 if (elf_header
.e_type
== ET_REL
10232 && !debug_apply_rela_addends (file
, section
, offset_size
,
10233 section_start
, start
, block_end
))
10236 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10240 fc
= xmalloc (sizeof (Frame_Chunk
));
10241 memset (fc
, 0, sizeof (Frame_Chunk
));
10245 fc
->chunk_start
= saved_start
;
10247 fc
->col_type
= xmalloc (sizeof (short int));
10248 fc
->col_offset
= xmalloc (sizeof (int));
10249 frame_need_space (fc
, max_regs
-1);
10251 version
= *start
++;
10253 fc
->augmentation
= (char *) start
;
10254 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10256 if (fc
->augmentation
[0] == 'z')
10258 fc
->code_factor
= LEB ();
10259 fc
->data_factor
= SLEB ();
10268 augmentation_data_len
= LEB ();
10269 augmentation_data
= start
;
10270 start
+= augmentation_data_len
;
10272 else if (streq (fc
->augmentation
, "eh"))
10274 start
+= eh_addr_size
;
10275 fc
->code_factor
= LEB ();
10276 fc
->data_factor
= SLEB ();
10288 fc
->code_factor
= LEB ();
10289 fc
->data_factor
= SLEB ();
10301 if (do_debug_frames_interp
)
10302 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10303 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10304 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10308 printf ("\n%08lx %08lx %08lx CIE\n",
10309 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10310 printf (" Version: %d\n", version
);
10311 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10312 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10313 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10314 printf (" Return address column: %d\n", fc
->ra
);
10316 if (augmentation_data_len
)
10319 printf (" Augmentation data: ");
10320 for (i
= 0; i
< augmentation_data_len
; ++i
)
10321 printf (" %02x", augmentation_data
[i
]);
10327 if (augmentation_data_len
)
10329 unsigned char *p
, *q
;
10330 p
= (unsigned char *) fc
->augmentation
+ 1;
10331 q
= augmentation_data
;
10337 else if (*p
== 'P')
10338 q
+= 1 + size_of_encoded_value (*q
);
10339 else if (*p
== 'R')
10340 fc
->fde_encoding
= *q
++;
10346 if (fc
->fde_encoding
)
10347 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10350 frame_need_space (fc
, fc
->ra
);
10354 unsigned char *look_for
;
10355 static Frame_Chunk fde_fc
;
10358 memset (fc
, 0, sizeof (Frame_Chunk
));
10360 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10362 for (cie
= chunks
; cie
; cie
= cie
->next
)
10363 if (cie
->chunk_start
== look_for
)
10368 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10369 cie_id
, saved_start
);
10372 fc
->col_type
= xmalloc (sizeof (short int));
10373 fc
->col_offset
= xmalloc (sizeof (int));
10374 frame_need_space (fc
, max_regs
- 1);
10376 fc
->augmentation
= "";
10377 fc
->fde_encoding
= 0;
10381 fc
->ncols
= cie
->ncols
;
10382 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10383 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10384 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10385 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10386 fc
->augmentation
= cie
->augmentation
;
10387 fc
->code_factor
= cie
->code_factor
;
10388 fc
->data_factor
= cie
->data_factor
;
10389 fc
->cfa_reg
= cie
->cfa_reg
;
10390 fc
->cfa_offset
= cie
->cfa_offset
;
10392 frame_need_space (fc
, max_regs
-1);
10393 fc
->fde_encoding
= cie
->fde_encoding
;
10396 if (fc
->fde_encoding
)
10397 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10399 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10400 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10401 /* Don't adjust for ET_REL since there's invariably a pcrel
10402 reloc here, which we haven't applied. */
10403 && elf_header
.e_type
!= ET_REL
)
10404 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10405 start
+= encoded_ptr_size
;
10406 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10407 start
+= encoded_ptr_size
;
10409 if (cie
->augmentation
[0] == 'z')
10411 augmentation_data_len
= LEB ();
10412 augmentation_data
= start
;
10413 start
+= augmentation_data_len
;
10416 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10417 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10418 (unsigned long)(cie
->chunk_start
- section_start
),
10419 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10420 if (! do_debug_frames_interp
&& augmentation_data_len
)
10424 printf (" Augmentation data: ");
10425 for (i
= 0; i
< augmentation_data_len
; ++i
)
10426 printf (" %02x", augmentation_data
[i
]);
10432 /* At this point, fc is the current chunk, cie (if any) is set, and
10433 we're about to interpret instructions for the chunk. */
10434 /* ??? At present we need to do this always, since this sizes the
10435 fc->col_type and fc->col_offset arrays, which we write into always.
10436 We should probably split the interpreted and non-interpreted bits
10437 into two different routines, since there's so much that doesn't
10438 really overlap between them. */
10439 if (1 || do_debug_frames_interp
)
10441 /* Start by making a pass over the chunk, allocating storage
10442 and taking note of what registers are used. */
10443 unsigned char *tmp
= start
;
10445 while (start
< block_end
)
10448 unsigned long reg
, tmp
;
10455 /* Warning: if you add any more cases to this switch, be
10456 sure to add them to the corresponding switch below. */
10459 case DW_CFA_advance_loc
:
10461 case DW_CFA_offset
:
10463 frame_need_space (fc
, opa
);
10464 fc
->col_type
[opa
] = DW_CFA_undefined
;
10466 case DW_CFA_restore
:
10467 frame_need_space (fc
, opa
);
10468 fc
->col_type
[opa
] = DW_CFA_undefined
;
10470 case DW_CFA_set_loc
:
10471 start
+= encoded_ptr_size
;
10473 case DW_CFA_advance_loc1
:
10476 case DW_CFA_advance_loc2
:
10479 case DW_CFA_advance_loc4
:
10482 case DW_CFA_offset_extended
:
10483 reg
= LEB (); LEB ();
10484 frame_need_space (fc
, reg
);
10485 fc
->col_type
[reg
] = DW_CFA_undefined
;
10487 case DW_CFA_restore_extended
:
10489 frame_need_space (fc
, reg
);
10490 fc
->col_type
[reg
] = DW_CFA_undefined
;
10492 case DW_CFA_undefined
:
10494 frame_need_space (fc
, reg
);
10495 fc
->col_type
[reg
] = DW_CFA_undefined
;
10497 case DW_CFA_same_value
:
10499 frame_need_space (fc
, reg
);
10500 fc
->col_type
[reg
] = DW_CFA_undefined
;
10502 case DW_CFA_register
:
10503 reg
= LEB (); LEB ();
10504 frame_need_space (fc
, reg
);
10505 fc
->col_type
[reg
] = DW_CFA_undefined
;
10507 case DW_CFA_def_cfa
:
10510 case DW_CFA_def_cfa_register
:
10513 case DW_CFA_def_cfa_offset
:
10516 case DW_CFA_def_cfa_expression
:
10520 case DW_CFA_expression
:
10524 frame_need_space (fc
, reg
);
10525 fc
->col_type
[reg
] = DW_CFA_undefined
;
10527 case DW_CFA_offset_extended_sf
:
10528 reg
= LEB (); SLEB ();
10529 frame_need_space (fc
, reg
);
10530 fc
->col_type
[reg
] = DW_CFA_undefined
;
10532 case DW_CFA_def_cfa_sf
:
10535 case DW_CFA_def_cfa_offset_sf
:
10538 case DW_CFA_MIPS_advance_loc8
:
10541 case DW_CFA_GNU_args_size
:
10544 case DW_CFA_GNU_negative_offset_extended
:
10545 reg
= LEB (); LEB ();
10546 frame_need_space (fc
, reg
);
10547 fc
->col_type
[reg
] = DW_CFA_undefined
;
10556 /* Now we know what registers are used, make a second pass over
10557 the chunk, this time actually printing out the info. */
10559 while (start
< block_end
)
10562 unsigned long ul
, reg
, roffs
;
10571 /* Warning: if you add any more cases to this switch, be
10572 sure to add them to the corresponding switch above. */
10575 case DW_CFA_advance_loc
:
10576 if (do_debug_frames_interp
)
10577 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10579 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10580 opa
* fc
->code_factor
,
10581 fc
->pc_begin
+ opa
* fc
->code_factor
);
10582 fc
->pc_begin
+= opa
* fc
->code_factor
;
10585 case DW_CFA_offset
:
10587 if (! do_debug_frames_interp
)
10588 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10589 opa
, roffs
* fc
->data_factor
);
10590 fc
->col_type
[opa
] = DW_CFA_offset
;
10591 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10594 case DW_CFA_restore
:
10595 if (! do_debug_frames_interp
)
10596 printf (" DW_CFA_restore: r%d\n", opa
);
10597 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10598 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10601 case DW_CFA_set_loc
:
10602 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10603 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10604 && elf_header
.e_type
!= ET_REL
)
10605 vma
+= section
->sh_addr
+ (start
- section_start
);
10606 start
+= encoded_ptr_size
;
10607 if (do_debug_frames_interp
)
10608 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10610 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10611 fc
->pc_begin
= vma
;
10614 case DW_CFA_advance_loc1
:
10615 ofs
= byte_get (start
, 1); start
+= 1;
10616 if (do_debug_frames_interp
)
10617 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10619 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10620 ofs
* fc
->code_factor
,
10621 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10622 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10625 case DW_CFA_advance_loc2
:
10626 ofs
= byte_get (start
, 2); start
+= 2;
10627 if (do_debug_frames_interp
)
10628 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10630 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10631 ofs
* fc
->code_factor
,
10632 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10633 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10636 case DW_CFA_advance_loc4
:
10637 ofs
= byte_get (start
, 4); start
+= 4;
10638 if (do_debug_frames_interp
)
10639 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10641 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10642 ofs
* fc
->code_factor
,
10643 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10644 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10647 case DW_CFA_offset_extended
:
10650 if (! do_debug_frames_interp
)
10651 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10652 reg
, roffs
* fc
->data_factor
);
10653 fc
->col_type
[reg
] = DW_CFA_offset
;
10654 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10657 case DW_CFA_restore_extended
:
10659 if (! do_debug_frames_interp
)
10660 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10661 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10662 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10665 case DW_CFA_undefined
:
10667 if (! do_debug_frames_interp
)
10668 printf (" DW_CFA_undefined: r%ld\n", reg
);
10669 fc
->col_type
[reg
] = DW_CFA_undefined
;
10670 fc
->col_offset
[reg
] = 0;
10673 case DW_CFA_same_value
:
10675 if (! do_debug_frames_interp
)
10676 printf (" DW_CFA_same_value: r%ld\n", reg
);
10677 fc
->col_type
[reg
] = DW_CFA_same_value
;
10678 fc
->col_offset
[reg
] = 0;
10681 case DW_CFA_register
:
10684 if (! do_debug_frames_interp
)
10685 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10686 fc
->col_type
[reg
] = DW_CFA_register
;
10687 fc
->col_offset
[reg
] = roffs
;
10690 case DW_CFA_remember_state
:
10691 if (! do_debug_frames_interp
)
10692 printf (" DW_CFA_remember_state\n");
10693 rs
= xmalloc (sizeof (Frame_Chunk
));
10694 rs
->ncols
= fc
->ncols
;
10695 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10696 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10697 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10698 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10699 rs
->next
= remembered_state
;
10700 remembered_state
= rs
;
10703 case DW_CFA_restore_state
:
10704 if (! do_debug_frames_interp
)
10705 printf (" DW_CFA_restore_state\n");
10706 rs
= remembered_state
;
10709 remembered_state
= rs
->next
;
10710 frame_need_space (fc
, rs
->ncols
-1);
10711 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10712 memcpy (fc
->col_offset
, rs
->col_offset
,
10713 rs
->ncols
* sizeof (int));
10714 free (rs
->col_type
);
10715 free (rs
->col_offset
);
10718 else if (do_debug_frames_interp
)
10719 printf ("Mismatched DW_CFA_restore_state\n");
10722 case DW_CFA_def_cfa
:
10723 fc
->cfa_reg
= LEB ();
10724 fc
->cfa_offset
= LEB ();
10726 if (! do_debug_frames_interp
)
10727 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10728 fc
->cfa_reg
, fc
->cfa_offset
);
10731 case DW_CFA_def_cfa_register
:
10732 fc
->cfa_reg
= LEB ();
10734 if (! do_debug_frames_interp
)
10735 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10738 case DW_CFA_def_cfa_offset
:
10739 fc
->cfa_offset
= LEB ();
10740 if (! do_debug_frames_interp
)
10741 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10745 if (! do_debug_frames_interp
)
10746 printf (" DW_CFA_nop\n");
10749 case DW_CFA_def_cfa_expression
:
10751 if (! do_debug_frames_interp
)
10753 printf (" DW_CFA_def_cfa_expression (");
10754 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10761 case DW_CFA_expression
:
10764 if (! do_debug_frames_interp
)
10766 printf (" DW_CFA_expression: r%ld (", reg
);
10767 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10770 fc
->col_type
[reg
] = DW_CFA_expression
;
10774 case DW_CFA_offset_extended_sf
:
10777 frame_need_space (fc
, reg
);
10778 if (! do_debug_frames_interp
)
10779 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10780 reg
, l
* fc
->data_factor
);
10781 fc
->col_type
[reg
] = DW_CFA_offset
;
10782 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10785 case DW_CFA_def_cfa_sf
:
10786 fc
->cfa_reg
= LEB ();
10787 fc
->cfa_offset
= SLEB ();
10788 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10790 if (! do_debug_frames_interp
)
10791 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10792 fc
->cfa_reg
, fc
->cfa_offset
);
10795 case DW_CFA_def_cfa_offset_sf
:
10796 fc
->cfa_offset
= SLEB ();
10797 fc
->cfa_offset
= fc
->cfa_offset
* fc
->data_factor
;
10798 if (! do_debug_frames_interp
)
10799 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10802 case DW_CFA_MIPS_advance_loc8
:
10803 ofs
= byte_get (start
, 8); start
+= 8;
10804 if (do_debug_frames_interp
)
10805 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10807 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10808 ofs
* fc
->code_factor
,
10809 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10810 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10813 case DW_CFA_GNU_window_save
:
10814 if (! do_debug_frames_interp
)
10815 printf (" DW_CFA_GNU_window_save\n");
10818 case DW_CFA_GNU_args_size
:
10820 if (! do_debug_frames_interp
)
10821 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10824 case DW_CFA_GNU_negative_offset_extended
:
10827 frame_need_space (fc
, reg
);
10828 if (! do_debug_frames_interp
)
10829 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10830 reg
, l
* fc
->data_factor
);
10831 fc
->col_type
[reg
] = DW_CFA_offset
;
10832 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10836 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10841 if (do_debug_frames_interp
)
10842 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10857 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10858 unsigned char *start ATTRIBUTE_UNUSED
,
10859 FILE *file ATTRIBUTE_UNUSED
)
10861 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10862 SECTION_NAME (section
));
10867 /* A structure containing the name of a debug section
10868 and a pointer to a function that can decode it. */
10871 const char *const name
;
10872 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10876 { ".debug_abbrev", display_debug_abbrev
},
10877 { ".debug_aranges", display_debug_aranges
},
10878 { ".debug_frame", display_debug_frames
},
10879 { ".debug_info", display_debug_info
},
10880 { ".debug_line", display_debug_lines
},
10881 { ".debug_pubnames", display_debug_pubnames
},
10882 { ".eh_frame", display_debug_frames
},
10883 { ".debug_macinfo", display_debug_macinfo
},
10884 { ".debug_str", display_debug_str
},
10885 { ".debug_loc", display_debug_loc
},
10886 { ".debug_pubtypes", display_debug_pubnames
},
10887 { ".debug_ranges", display_debug_ranges
},
10888 { ".debug_static_func", display_debug_not_supported
},
10889 { ".debug_static_vars", display_debug_not_supported
},
10890 { ".debug_types", display_debug_not_supported
},
10891 { ".debug_weaknames", display_debug_not_supported
}
10895 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10897 char *name
= SECTION_NAME (section
);
10898 bfd_size_type length
;
10902 length
= section
->sh_size
;
10905 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10909 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10910 name
= ".debug_info";
10912 /* See if we know how to display the contents of this section. */
10913 for (i
= NUM_ELEM (debug_displays
); i
--;)
10914 if (streq (debug_displays
[i
].name
, name
))
10916 unsigned char *start
;
10918 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10919 _("debug section data"));
10926 result
&= debug_displays
[i
].display (section
, start
, file
);
10929 /* If we loaded in the abbrev section
10930 at some point, we must release it here. */
10938 printf (_("Unrecognized debug section: %s\n"), name
);
10946 process_section_contents (FILE *file
)
10948 Elf_Internal_Shdr
*section
;
10954 for (i
= 0, section
= section_headers
;
10955 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10958 #ifdef SUPPORT_DISASSEMBLY
10959 if (dump_sects
[i
] & DISASS_DUMP
)
10960 disassemble_section (section
, file
);
10962 if (dump_sects
[i
] & HEX_DUMP
)
10963 dump_section (section
, file
);
10965 if (dump_sects
[i
] & DEBUG_DUMP
)
10966 display_debug_section (section
, file
);
10969 /* Check to see if the user requested a
10970 dump of a section that does not exist. */
10971 while (i
++ < num_dump_sects
)
10973 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10977 process_mips_fpe_exception (int mask
)
10982 if (mask
& OEX_FPU_INEX
)
10983 fputs ("INEX", stdout
), first
= 0;
10984 if (mask
& OEX_FPU_UFLO
)
10985 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10986 if (mask
& OEX_FPU_OFLO
)
10987 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10988 if (mask
& OEX_FPU_DIV0
)
10989 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10990 if (mask
& OEX_FPU_INVAL
)
10991 printf ("%sINVAL", first
? "" : "|");
10994 fputs ("0", stdout
);
10998 process_mips_specific (FILE *file
)
11000 Elf_Internal_Dyn
*entry
;
11001 size_t liblist_offset
= 0;
11002 size_t liblistno
= 0;
11003 size_t conflictsno
= 0;
11004 size_t options_offset
= 0;
11005 size_t conflicts_offset
= 0;
11007 /* We have a lot of special sections. Thanks SGI! */
11008 if (dynamic_section
== NULL
)
11009 /* No information available. */
11012 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
11013 switch (entry
->d_tag
)
11015 case DT_MIPS_LIBLIST
:
11017 = offset_from_vma (file
, entry
->d_un
.d_val
,
11018 liblistno
* sizeof (Elf32_External_Lib
));
11020 case DT_MIPS_LIBLISTNO
:
11021 liblistno
= entry
->d_un
.d_val
;
11023 case DT_MIPS_OPTIONS
:
11024 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
11026 case DT_MIPS_CONFLICT
:
11028 = offset_from_vma (file
, entry
->d_un
.d_val
,
11029 conflictsno
* sizeof (Elf32_External_Conflict
));
11031 case DT_MIPS_CONFLICTNO
:
11032 conflictsno
= entry
->d_un
.d_val
;
11038 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11040 Elf32_External_Lib
*elib
;
11043 elib
= get_data (NULL
, file
, liblist_offset
,
11044 liblistno
* sizeof (Elf32_External_Lib
),
11048 printf ("\nSection '.liblist' contains %lu entries:\n",
11049 (unsigned long) liblistno
);
11050 fputs (" Library Time Stamp Checksum Version Flags\n",
11053 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11060 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11061 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11062 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11063 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11064 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11066 tmp
= gmtime (&time
);
11067 snprintf (timebuf
, sizeof (timebuf
),
11068 "%04u-%02u-%02uT%02u:%02u:%02u",
11069 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11070 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11072 printf ("%3lu: ", (unsigned long) cnt
);
11073 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11074 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11076 printf ("<corrupt: %9ld>", liblist
.l_name
);
11077 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11078 liblist
.l_version
);
11080 if (liblist
.l_flags
== 0)
11084 static const struct
11091 { " EXACT_MATCH", LL_EXACT_MATCH
},
11092 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11093 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11094 { " EXPORTS", LL_EXPORTS
},
11095 { " DELAY_LOAD", LL_DELAY_LOAD
},
11096 { " DELTA", LL_DELTA
}
11098 int flags
= liblist
.l_flags
;
11102 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
11104 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11106 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11107 flags
^= l_flags_vals
[fcnt
].bit
;
11110 printf (" %#x", (unsigned int) flags
);
11120 if (options_offset
!= 0)
11122 Elf_External_Options
*eopt
;
11123 Elf_Internal_Shdr
*sect
= section_headers
;
11124 Elf_Internal_Options
*iopt
;
11125 Elf_Internal_Options
*option
;
11129 /* Find the section header so that we get the size. */
11130 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11133 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
11137 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
11140 error (_("Out of memory"));
11147 while (offset
< sect
->sh_size
)
11149 Elf_External_Options
*eoption
;
11151 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11153 option
->kind
= BYTE_GET (eoption
->kind
);
11154 option
->size
= BYTE_GET (eoption
->size
);
11155 option
->section
= BYTE_GET (eoption
->section
);
11156 option
->info
= BYTE_GET (eoption
->info
);
11158 offset
+= option
->size
;
11164 printf (_("\nSection '%s' contains %d entries:\n"),
11165 SECTION_NAME (sect
), cnt
);
11173 switch (option
->kind
)
11176 /* This shouldn't happen. */
11177 printf (" NULL %d %lx", option
->section
, option
->info
);
11180 printf (" REGINFO ");
11181 if (elf_header
.e_machine
== EM_MIPS
)
11184 Elf32_External_RegInfo
*ereg
;
11185 Elf32_RegInfo reginfo
;
11187 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11188 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11189 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11190 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11191 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11192 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11193 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11195 printf ("GPR %08lx GP 0x%lx\n",
11196 reginfo
.ri_gprmask
,
11197 (unsigned long) reginfo
.ri_gp_value
);
11198 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11199 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11200 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11205 Elf64_External_RegInfo
*ereg
;
11206 Elf64_Internal_RegInfo reginfo
;
11208 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11209 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11210 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11211 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11212 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11213 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11214 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11216 printf ("GPR %08lx GP 0x",
11217 reginfo
.ri_gprmask
);
11218 printf_vma (reginfo
.ri_gp_value
);
11221 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11222 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11223 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11227 case ODK_EXCEPTIONS
:
11228 fputs (" EXCEPTIONS fpe_min(", stdout
);
11229 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11230 fputs (") fpe_max(", stdout
);
11231 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11232 fputs (")", stdout
);
11234 if (option
->info
& OEX_PAGE0
)
11235 fputs (" PAGE0", stdout
);
11236 if (option
->info
& OEX_SMM
)
11237 fputs (" SMM", stdout
);
11238 if (option
->info
& OEX_FPDBUG
)
11239 fputs (" FPDBUG", stdout
);
11240 if (option
->info
& OEX_DISMISS
)
11241 fputs (" DISMISS", stdout
);
11244 fputs (" PAD ", stdout
);
11245 if (option
->info
& OPAD_PREFIX
)
11246 fputs (" PREFIX", stdout
);
11247 if (option
->info
& OPAD_POSTFIX
)
11248 fputs (" POSTFIX", stdout
);
11249 if (option
->info
& OPAD_SYMBOL
)
11250 fputs (" SYMBOL", stdout
);
11253 fputs (" HWPATCH ", stdout
);
11254 if (option
->info
& OHW_R4KEOP
)
11255 fputs (" R4KEOP", stdout
);
11256 if (option
->info
& OHW_R8KPFETCH
)
11257 fputs (" R8KPFETCH", stdout
);
11258 if (option
->info
& OHW_R5KEOP
)
11259 fputs (" R5KEOP", stdout
);
11260 if (option
->info
& OHW_R5KCVTL
)
11261 fputs (" R5KCVTL", stdout
);
11264 fputs (" FILL ", stdout
);
11265 /* XXX Print content of info word? */
11268 fputs (" TAGS ", stdout
);
11269 /* XXX Print content of info word? */
11272 fputs (" HWAND ", stdout
);
11273 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11274 fputs (" R4KEOP_CHECKED", stdout
);
11275 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11276 fputs (" R4KEOP_CLEAN", stdout
);
11279 fputs (" HWOR ", stdout
);
11280 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11281 fputs (" R4KEOP_CHECKED", stdout
);
11282 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11283 fputs (" R4KEOP_CLEAN", stdout
);
11286 printf (" GP_GROUP %#06lx self-contained %#06lx",
11287 option
->info
& OGP_GROUP
,
11288 (option
->info
& OGP_SELF
) >> 16);
11291 printf (" IDENT %#06lx self-contained %#06lx",
11292 option
->info
& OGP_GROUP
,
11293 (option
->info
& OGP_SELF
) >> 16);
11296 /* This shouldn't happen. */
11297 printf (" %3d ??? %d %lx",
11298 option
->kind
, option
->section
, option
->info
);
11302 len
= sizeof (*eopt
);
11303 while (len
< option
->size
)
11304 if (((char *) option
)[len
] >= ' '
11305 && ((char *) option
)[len
] < 0x7f)
11306 printf ("%c", ((char *) option
)[len
++]);
11308 printf ("\\%03o", ((char *) option
)[len
++]);
11310 fputs ("\n", stdout
);
11318 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11320 Elf32_Conflict
*iconf
;
11323 if (dynamic_symbols
== NULL
)
11325 error (_("conflict list found without a dynamic symbol table"));
11329 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11332 error (_("Out of memory"));
11338 Elf32_External_Conflict
*econf32
;
11340 econf32
= get_data (NULL
, file
, conflicts_offset
,
11341 conflictsno
* sizeof (*econf32
), _("conflict"));
11345 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11346 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11352 Elf64_External_Conflict
*econf64
;
11354 econf64
= get_data (NULL
, file
, conflicts_offset
,
11355 conflictsno
* sizeof (*econf64
), _("conflict"));
11359 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11360 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11365 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11366 (unsigned long) conflictsno
);
11367 puts (_(" Num: Index Value Name"));
11369 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11371 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11373 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11374 print_vma (psym
->st_value
, FULL_HEX
);
11376 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11377 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11379 printf ("<corrupt: %14ld>", psym
->st_name
);
11390 process_gnu_liblist (FILE *file
)
11392 Elf_Internal_Shdr
*section
, *string_sec
;
11393 Elf32_External_Lib
*elib
;
11401 for (i
= 0, section
= section_headers
;
11402 i
< elf_header
.e_shnum
;
11405 switch (section
->sh_type
)
11407 case SHT_GNU_LIBLIST
:
11408 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11413 string_sec
= SECTION_HEADER (section
->sh_link
);
11415 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11416 string_sec
->sh_size
, _("liblist string table"));
11419 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11425 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11426 SECTION_NAME (section
),
11427 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11429 puts (" Library Time Stamp Checksum Version Flags");
11431 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11439 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11440 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11441 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11442 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11443 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11445 tmp
= gmtime (&time
);
11446 snprintf (timebuf
, sizeof (timebuf
),
11447 "%04u-%02u-%02uT%02u:%02u:%02u",
11448 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11449 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11451 printf ("%3lu: ", (unsigned long) cnt
);
11453 printf ("%-20s", strtab
+ liblist
.l_name
);
11455 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11456 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11457 liblist
.l_version
, liblist
.l_flags
);
11467 static const char *
11468 get_note_type (unsigned e_type
)
11470 static char buff
[64];
11472 if (elf_header
.e_type
== ET_CORE
)
11476 return _("NT_AUXV (auxiliary vector)");
11478 return _("NT_PRSTATUS (prstatus structure)");
11480 return _("NT_FPREGSET (floating point registers)");
11482 return _("NT_PRPSINFO (prpsinfo structure)");
11483 case NT_TASKSTRUCT
:
11484 return _("NT_TASKSTRUCT (task structure)");
11486 return _("NT_PRXFPREG (user_xfpregs structure)");
11488 return _("NT_PSTATUS (pstatus structure)");
11490 return _("NT_FPREGS (floating point registers)");
11492 return _("NT_PSINFO (psinfo structure)");
11494 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11496 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11497 case NT_WIN32PSTATUS
:
11498 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11506 return _("NT_VERSION (version)");
11508 return _("NT_ARCH (architecture)");
11513 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11517 static const char *
11518 get_netbsd_elfcore_note_type (unsigned e_type
)
11520 static char buff
[64];
11522 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11524 /* NetBSD core "procinfo" structure. */
11525 return _("NetBSD procinfo structure");
11528 /* As of Jan 2002 there are no other machine-independent notes
11529 defined for NetBSD core files. If the note type is less
11530 than the start of the machine-dependent note types, we don't
11533 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11535 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11539 switch (elf_header
.e_machine
)
11541 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11542 and PT_GETFPREGS == mach+2. */
11547 case EM_SPARC32PLUS
:
11551 case NT_NETBSDCORE_FIRSTMACH
+0:
11552 return _("PT_GETREGS (reg structure)");
11553 case NT_NETBSDCORE_FIRSTMACH
+2:
11554 return _("PT_GETFPREGS (fpreg structure)");
11560 /* On all other arch's, PT_GETREGS == mach+1 and
11561 PT_GETFPREGS == mach+3. */
11565 case NT_NETBSDCORE_FIRSTMACH
+1:
11566 return _("PT_GETREGS (reg structure)");
11567 case NT_NETBSDCORE_FIRSTMACH
+3:
11568 return _("PT_GETFPREGS (fpreg structure)");
11574 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11575 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11579 /* Note that by the ELF standard, the name field is already null byte
11580 terminated, and namesz includes the terminating null byte.
11581 I.E. the value of namesz for the name "FSF" is 4.
11583 If the value of namesz is zero, there is no name present. */
11585 process_note (Elf_Internal_Note
*pnote
)
11589 if (pnote
->namesz
== 0)
11590 /* If there is no note name, then use the default set of
11591 note type strings. */
11592 nt
= get_note_type (pnote
->type
);
11594 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11595 /* NetBSD-specific core file notes. */
11596 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11599 /* Don't recognize this note name; just use the default set of
11600 note type strings. */
11601 nt
= get_note_type (pnote
->type
);
11603 printf (" %s\t\t0x%08lx\t%s\n",
11604 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11605 pnote
->descsz
, nt
);
11611 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11613 Elf_External_Note
*pnotes
;
11614 Elf_External_Note
*external
;
11620 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11626 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11627 (unsigned long) offset
, (unsigned long) length
);
11628 printf (_(" Owner\t\tData size\tDescription\n"));
11630 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11632 Elf_External_Note
*next
;
11633 Elf_Internal_Note inote
;
11636 inote
.type
= BYTE_GET (external
->type
);
11637 inote
.namesz
= BYTE_GET (external
->namesz
);
11638 inote
.namedata
= external
->name
;
11639 inote
.descsz
= BYTE_GET (external
->descsz
);
11640 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11641 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11643 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11645 if (((char *) next
) > (((char *) pnotes
) + length
))
11647 warn (_("corrupt note found at offset %x into core notes\n"),
11648 ((char *) external
) - ((char *) pnotes
));
11649 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11650 inote
.type
, inote
.namesz
, inote
.descsz
);
11656 /* Verify that name is null terminated. It appears that at least
11657 one version of Linux (RedHat 6.0) generates corefiles that don't
11658 comply with the ELF spec by failing to include the null byte in
11660 if (inote
.namedata
[inote
.namesz
] != '\0')
11662 temp
= malloc (inote
.namesz
+ 1);
11666 error (_("Out of memory\n"));
11671 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11672 temp
[inote
.namesz
] = 0;
11674 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11675 inote
.namedata
= temp
;
11678 res
&= process_note (& inote
);
11693 process_corefile_note_segments (FILE *file
)
11695 Elf_Internal_Phdr
*segment
;
11699 if (! get_program_headers (file
))
11702 for (i
= 0, segment
= program_headers
;
11703 i
< elf_header
.e_phnum
;
11706 if (segment
->p_type
== PT_NOTE
)
11707 res
&= process_corefile_note_segment (file
,
11708 (bfd_vma
) segment
->p_offset
,
11709 (bfd_vma
) segment
->p_filesz
);
11716 process_note_sections (FILE *file
)
11718 Elf_Internal_Shdr
*section
;
11722 for (i
= 0, section
= section_headers
;
11723 i
< elf_header
.e_shnum
;
11725 if (section
->sh_type
== SHT_NOTE
)
11726 res
&= process_corefile_note_segment (file
,
11727 (bfd_vma
) section
->sh_offset
,
11728 (bfd_vma
) section
->sh_size
);
11734 process_notes (FILE *file
)
11736 /* If we have not been asked to display the notes then do nothing. */
11740 if (elf_header
.e_type
!= ET_CORE
)
11741 return process_note_sections (file
);
11743 /* No program headers means no NOTE segment. */
11744 if (elf_header
.e_phnum
> 0)
11745 return process_corefile_note_segments (file
);
11747 printf (_("No note segments present in the core file.\n"));
11752 process_arch_specific (FILE *file
)
11757 switch (elf_header
.e_machine
)
11760 case EM_MIPS_RS3_LE
:
11761 return process_mips_specific (file
);
11770 get_file_header (FILE *file
)
11772 /* Read in the identity array. */
11773 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11776 /* Determine how to read the rest of the header. */
11777 switch (elf_header
.e_ident
[EI_DATA
])
11779 default: /* fall through */
11780 case ELFDATANONE
: /* fall through */
11782 byte_get
= byte_get_little_endian
;
11783 byte_put
= byte_put_little_endian
;
11786 byte_get
= byte_get_big_endian
;
11787 byte_put
= byte_put_big_endian
;
11791 /* For now we only support 32 bit and 64 bit ELF files. */
11792 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11794 /* Read in the rest of the header. */
11797 Elf32_External_Ehdr ehdr32
;
11799 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11802 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11803 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11804 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11805 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11806 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11807 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11808 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11809 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11810 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11811 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11812 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11813 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11814 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11818 Elf64_External_Ehdr ehdr64
;
11820 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11821 we will not be able to cope with the 64bit data found in
11822 64 ELF files. Detect this now and abort before we start
11823 overwriting things. */
11824 if (sizeof (bfd_vma
) < 8)
11826 error (_("This instance of readelf has been built without support for a\n\
11827 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11831 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11834 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11835 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11836 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11837 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11838 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11839 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11840 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11841 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11842 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11843 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11844 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11845 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11846 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11849 if (elf_header
.e_shoff
)
11851 /* There may be some extensions in the first section header. Don't
11852 bomb if we can't read it. */
11854 get_32bit_section_headers (file
, 1);
11856 get_64bit_section_headers (file
, 1);
11862 /* Process one ELF object file according to the command line options.
11863 This file may actually be stored in an archive. The file is
11864 positioned at the start of the ELF object. */
11867 process_object (char *file_name
, FILE *file
)
11871 if (! get_file_header (file
))
11873 error (_("%s: Failed to read file header\n"), file_name
);
11877 /* Initialise per file variables. */
11878 for (i
= NUM_ELEM (version_info
); i
--;)
11879 version_info
[i
] = 0;
11881 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11882 dynamic_info
[i
] = 0;
11884 /* Process the file. */
11886 printf (_("\nFile: %s\n"), file_name
);
11888 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11889 Note we do this even if cmdline_dump_sects is empty because we
11890 must make sure that the dump_sets array is zeroed out before each
11891 object file is processed. */
11892 if (num_dump_sects
> num_cmdline_dump_sects
)
11893 memset (dump_sects
, 0, num_dump_sects
);
11895 if (num_cmdline_dump_sects
> 0)
11897 if (num_dump_sects
== 0)
11898 /* A sneaky way of allocating the dump_sects array. */
11899 request_dump (num_cmdline_dump_sects
, 0);
11901 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11902 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11905 if (! process_file_header ())
11908 if (! process_section_headers (file
))
11910 /* Without loaded section headers we cannot process lots of
11912 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11914 if (! do_using_dynamic
)
11915 do_syms
= do_reloc
= 0;
11918 if (! process_section_groups (file
))
11920 /* Without loaded section groups we cannot process unwind. */
11924 if (process_program_headers (file
))
11925 process_dynamic_section (file
);
11927 process_relocs (file
);
11929 process_unwind (file
);
11931 process_symbol_table (file
);
11933 process_syminfo (file
);
11935 process_version_sections (file
);
11937 process_section_contents (file
);
11939 process_notes (file
);
11941 process_gnu_liblist (file
);
11943 process_arch_specific (file
);
11945 if (program_headers
)
11947 free (program_headers
);
11948 program_headers
= NULL
;
11951 if (section_headers
)
11953 free (section_headers
);
11954 section_headers
= NULL
;
11959 free (string_table
);
11960 string_table
= NULL
;
11961 string_table_length
= 0;
11964 if (dynamic_strings
)
11966 free (dynamic_strings
);
11967 dynamic_strings
= NULL
;
11968 dynamic_strings_length
= 0;
11971 if (dynamic_symbols
)
11973 free (dynamic_symbols
);
11974 dynamic_symbols
= NULL
;
11975 num_dynamic_syms
= 0;
11978 if (dynamic_syminfo
)
11980 free (dynamic_syminfo
);
11981 dynamic_syminfo
= NULL
;
11984 if (section_headers_groups
)
11986 free (section_headers_groups
);
11987 section_headers_groups
= NULL
;
11990 if (section_groups
)
11992 struct group_list
*g
, *next
;
11994 for (i
= 0; i
< group_count
; i
++)
11996 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12003 free (section_groups
);
12004 section_groups
= NULL
;
12007 if (debug_information
)
12009 for (i
= 0; i
< num_debug_info_entries
; i
++)
12011 if (!debug_information
[i
].max_loc_offsets
)
12013 free (debug_information
[i
].loc_offsets
);
12014 free (debug_information
[i
].have_frame_base
);
12016 if (!debug_information
[i
].max_range_lists
)
12017 free (debug_information
[i
].range_lists
);
12019 free (debug_information
);
12020 debug_information
= NULL
;
12021 num_debug_info_entries
= 0;
12027 /* Process an ELF archive. The file is positioned just after the
12031 process_archive (char *file_name
, FILE *file
)
12033 struct ar_hdr arhdr
;
12035 unsigned long size
;
12036 char *longnames
= NULL
;
12037 unsigned long longnames_size
= 0;
12038 size_t file_name_size
;
12043 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12044 if (got
!= sizeof arhdr
)
12049 error (_("%s: failed to read archive header\n"), file_name
);
12053 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
12055 /* This is the archive symbol table. Skip it.
12056 FIXME: We should have an option to dump it. */
12057 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12058 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
12060 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12064 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12065 if (got
!= sizeof arhdr
)
12070 error (_("%s: failed to read archive header\n"), file_name
);
12075 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
12077 /* This is the archive string table holding long member
12080 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12082 longnames
= malloc (longnames_size
);
12083 if (longnames
== NULL
)
12085 error (_("Out of memory\n"));
12089 if (fread (longnames
, longnames_size
, 1, file
) != 1)
12092 error (_("%s: failed to read string table\n"), file_name
);
12096 if ((longnames_size
& 1) != 0)
12099 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12100 if (got
!= sizeof arhdr
)
12107 error (_("%s: failed to read archive header\n"), file_name
);
12112 file_name_size
= strlen (file_name
);
12121 if (arhdr
.ar_name
[0] == '/')
12125 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
12126 if (off
>= longnames_size
)
12128 error (_("%s: invalid archive string table offset %lu\n"), off
);
12133 name
= longnames
+ off
;
12134 nameend
= memchr (name
, '/', longnames_size
- off
);
12138 name
= arhdr
.ar_name
;
12139 nameend
= memchr (name
, '/', 16);
12142 if (nameend
== NULL
)
12144 error (_("%s: bad archive file name\n"));
12149 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
12150 if (namealc
== NULL
)
12152 error (_("Out of memory\n"));
12157 memcpy (namealc
, file_name
, file_name_size
);
12158 namealc
[file_name_size
] = '(';
12159 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12160 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12161 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12163 archive_file_offset
= ftell (file
);
12164 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12166 ret
|= process_object (namealc
, file
);
12171 (archive_file_offset
12172 + archive_file_size
12173 + (archive_file_size
& 1)),
12176 error (_("%s: failed to seek to next archive header\n"), file_name
);
12181 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12182 if (got
!= sizeof arhdr
)
12187 error (_("%s: failed to read archive header\n"), file_name
);
12193 if (longnames
!= 0)
12200 process_file (char *file_name
)
12203 struct stat statbuf
;
12204 char armag
[SARMAG
];
12207 if (stat (file_name
, &statbuf
) < 0)
12209 if (errno
== ENOENT
)
12210 error (_("'%s': No such file\n"), file_name
);
12212 error (_("Could not locate '%s'. System error message: %s\n"),
12213 file_name
, strerror (errno
));
12217 if (! S_ISREG (statbuf
.st_mode
))
12219 error (_("'%s' is not an ordinary file\n"), file_name
);
12223 file
= fopen (file_name
, "rb");
12226 error (_("Input file '%s' is not readable.\n"), file_name
);
12230 if (fread (armag
, SARMAG
, 1, file
) != 1)
12232 error (_("%s: Failed to read file header\n"), file_name
);
12237 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12238 ret
= process_archive (file_name
, file
);
12242 archive_file_size
= archive_file_offset
= 0;
12243 ret
= process_object (file_name
, file
);
12251 #ifdef SUPPORT_DISASSEMBLY
12252 /* Needed by the i386 disassembler. For extra credit, someone could
12253 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12257 print_address (unsigned int addr
, FILE *outfile
)
12259 fprintf (outfile
,"0x%8.8x", addr
);
12262 /* Needed by the i386 disassembler. */
12264 db_task_printsym (unsigned int addr
)
12266 print_address (addr
, stderr
);
12271 main (int argc
, char **argv
)
12275 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12276 setlocale (LC_MESSAGES
, "");
12278 #if defined (HAVE_SETLOCALE)
12279 setlocale (LC_CTYPE
, "");
12281 bindtextdomain (PACKAGE
, LOCALEDIR
);
12282 textdomain (PACKAGE
);
12284 parse_args (argc
, argv
);
12286 if (num_dump_sects
> 0)
12288 /* Make a copy of the dump_sects array. */
12289 cmdline_dump_sects
= malloc (num_dump_sects
);
12290 if (cmdline_dump_sects
== NULL
)
12291 error (_("Out of memory allocating dump request table."));
12294 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12295 num_cmdline_dump_sects
= num_dump_sects
;
12299 if (optind
< (argc
- 1))
12303 while (optind
< argc
)
12304 err
|= process_file (argv
[optind
++]);
12306 if (dump_sects
!= NULL
)
12308 if (cmdline_dump_sects
!= NULL
)
12309 free (cmdline_dump_sects
);