1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
45 #include <sys/types.h>
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
63 #include "elf/dwarf2.h"
65 /* The following headers use the elf/reloc-macros.h file to
66 automatically generate relocation recognition functions
67 such as elf_mips_reloc_type() */
69 #define RELOC_MACROS_GEN_FUNC
71 #include "elf/alpha.h"
91 #include "elf/m68hc11.h"
92 #include "elf/mcore.h"
95 #include "elf/mn10200.h"
96 #include "elf/mn10300.h"
97 #include "elf/msp430.h"
101 #include "elf/ppc64.h"
102 #include "elf/s390.h"
104 #include "elf/sparc.h"
105 #include "elf/v850.h"
107 #include "elf/x86-64.h"
108 #include "elf/xstormy16.h"
110 #include "elf/iq2000.h"
111 #include "elf/xtensa.h"
117 #include "libiberty.h"
119 char *program_name
= "readelf";
120 long archive_file_offset
;
121 unsigned long archive_file_size
;
122 unsigned long dynamic_addr
;
123 bfd_size_type dynamic_size
;
124 unsigned int dynamic_nent
;
125 char *dynamic_strings
;
126 unsigned long dynamic_strings_length
;
128 unsigned long string_table_length
;
129 unsigned long num_dynamic_syms
;
130 Elf_Internal_Sym
*dynamic_symbols
;
131 Elf_Internal_Syminfo
*dynamic_syminfo
;
132 unsigned long dynamic_syminfo_offset
;
133 unsigned int dynamic_syminfo_nent
;
134 char program_interpreter
[64];
135 bfd_vma dynamic_info
[DT_JMPREL
+ 1];
136 bfd_vma version_info
[16];
137 Elf_Internal_Ehdr elf_header
;
138 Elf_Internal_Shdr
*section_headers
;
139 Elf_Internal_Phdr
*program_headers
;
140 Elf_Internal_Dyn
*dynamic_section
;
141 Elf_Internal_Shdr
*symtab_shndx_hdr
;
147 int do_section_groups
;
150 int do_using_dynamic
;
158 int do_debug_abbrevs
;
160 int do_debug_pubnames
;
161 int do_debug_aranges
;
164 int do_debug_frames_interp
;
165 int do_debug_macinfo
;
172 int need_base_address
;
173 bfd_vma eh_addr_size
;
177 struct group_list
*next
;
178 unsigned int section_index
;
183 struct group_list
*root
;
184 unsigned int group_index
;
187 struct group
*section_groups
;
190 struct group
**section_headers_groups
;
192 /* A dynamic array of flags indicating for which sections a hex dump
193 has been requested (via the -x switch) and/or a disassembly dump
194 (via the -i switch). */
195 char *cmdline_dump_sects
= NULL
;
196 unsigned num_cmdline_dump_sects
= 0;
198 /* A dynamic array of flags indicating for which sections a dump of
199 some kind has been requested. It is reset on a per-object file
200 basis and then initialised from the cmdline_dump_sects array and
201 the results of interpreting the -w switch. */
202 char *dump_sects
= NULL
;
203 unsigned int num_dump_sects
= 0;
205 #define HEX_DUMP (1 << 0)
206 #define DISASS_DUMP (1 << 1)
207 #define DEBUG_DUMP (1 << 2)
209 /* How to rpint a vma value. */
210 typedef enum print_mode
222 static bfd_vma (*byte_get
) (unsigned char *, int);
223 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
227 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
228 ((X)->sh_name >= string_table_length \
229 ? "<corrupt>" : string_table + (X)->sh_name))
231 /* Given st_shndx I, map to section_headers index. */
232 #define SECTION_HEADER_INDEX(I) \
233 ((I) < SHN_LORESERVE \
235 : ((I) <= SHN_HIRESERVE \
237 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
239 /* Reverse of the above. */
240 #define SECTION_HEADER_NUM(N) \
241 ((N) < SHN_LORESERVE \
243 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
245 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
247 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
249 #define BYTE_GET(field) byte_get (field, sizeof (field))
251 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
253 #define GET_ELF_SYMBOLS(file, section) \
254 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
255 : get_64bit_elf_symbols (file, section))
257 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
258 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
259 already been called and verified that the string exists. */
260 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
262 /* This is just a bit of syntatic sugar. */
263 #define streq(a,b) (strcmp ((a), (b)) == 0)
264 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
267 error (const char *message
, ...)
271 va_start (args
, message
);
272 fprintf (stderr
, _("%s: Error: "), program_name
);
273 vfprintf (stderr
, message
, args
);
278 warn (const char *message
, ...)
282 va_start (args
, message
);
283 fprintf (stderr
, _("%s: Warning: "), program_name
);
284 vfprintf (stderr
, message
, args
);
289 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
296 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
298 error (_("Unable to seek to 0x%x for %s\n"),
299 archive_file_offset
+ offset
, reason
);
306 mvar
= malloc (size
);
310 error (_("Out of memory allocating 0x%x bytes for %s\n"),
316 if (fread (mvar
, size
, 1, file
) != 1)
318 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
328 byte_get_little_endian (unsigned char *field
, int size
)
336 return ((unsigned int) (field
[0]))
337 | (((unsigned int) (field
[1])) << 8);
341 /* We want to extract data from an 8 byte wide field and
342 place it into a 4 byte wide field. Since this is a little
343 endian source we can just use the 4 byte extraction code. */
347 return ((unsigned long) (field
[0]))
348 | (((unsigned long) (field
[1])) << 8)
349 | (((unsigned long) (field
[2])) << 16)
350 | (((unsigned long) (field
[3])) << 24);
354 return ((bfd_vma
) (field
[0]))
355 | (((bfd_vma
) (field
[1])) << 8)
356 | (((bfd_vma
) (field
[2])) << 16)
357 | (((bfd_vma
) (field
[3])) << 24)
358 | (((bfd_vma
) (field
[4])) << 32)
359 | (((bfd_vma
) (field
[5])) << 40)
360 | (((bfd_vma
) (field
[6])) << 48)
361 | (((bfd_vma
) (field
[7])) << 56);
364 error (_("Unhandled data length: %d\n"), size
);
370 byte_get_signed (unsigned char *field
, int size
)
372 bfd_vma x
= byte_get (field
, size
);
377 return (x
^ 0x80) - 0x80;
379 return (x
^ 0x8000) - 0x8000;
381 return (x
^ 0x80000000) - 0x80000000;
390 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
395 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
396 field
[6] = ((value
>> 24) >> 24) & 0xff;
397 field
[5] = ((value
>> 24) >> 16) & 0xff;
398 field
[4] = ((value
>> 24) >> 8) & 0xff;
401 field
[3] = (value
>> 24) & 0xff;
402 field
[2] = (value
>> 16) & 0xff;
405 field
[1] = (value
>> 8) & 0xff;
408 field
[0] = value
& 0xff;
412 error (_("Unhandled data length: %d\n"), size
);
417 #if defined BFD64 && !BFD_HOST_64BIT_LONG
419 print_dec_vma (bfd_vma vma
, int is_signed
)
425 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
434 *bufp
++ = '0' + vma
% 10;
446 print_hex_vma (bfd_vma vma
)
454 char digit
= '0' + (vma
& 0x0f);
456 digit
+= 'a' - '0' - 10;
469 /* Print a VMA value. */
471 print_vma (bfd_vma vma
, print_mode mode
)
480 return printf ("0x%8.8lx", (unsigned long) vma
);
483 return printf ("%8.8lx", (unsigned long) vma
);
487 return printf ("%5ld", (long) vma
);
491 return printf ("0x%lx", (unsigned long) vma
);
494 return printf ("%lx", (unsigned long) vma
);
497 return printf ("%ld", (unsigned long) vma
);
500 return printf ("%lu", (unsigned long) vma
);
523 #if BFD_HOST_64BIT_LONG
524 return nc
+ printf ("%lx", vma
);
526 return nc
+ print_hex_vma (vma
);
530 #if BFD_HOST_64BIT_LONG
531 return printf ("%ld", vma
);
533 return print_dec_vma (vma
, 1);
537 #if BFD_HOST_64BIT_LONG
539 return printf ("%5ld", vma
);
541 return printf ("%#lx", vma
);
544 return printf ("%5ld", _bfd_int64_low (vma
));
546 return print_hex_vma (vma
);
550 #if BFD_HOST_64BIT_LONG
551 return printf ("%lu", vma
);
553 return print_dec_vma (vma
, 0);
561 /* Display a symbol on stdout. If do_wide is not true then
562 format the symbol to be at most WIDTH characters,
563 truncating as necessary. If WIDTH is negative then
564 format the string to be exactly - WIDTH characters,
565 truncating or padding as necessary. */
568 print_symbol (int width
, const char *symbol
)
571 printf ("%s", symbol
);
573 printf ("%-*.*s", width
, width
, symbol
);
575 printf ("%-.*s", width
, symbol
);
579 byte_get_big_endian (unsigned char *field
, int size
)
587 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
591 /* Although we are extracing data from an 8 byte wide field,
592 we are returning only 4 bytes of data. */
597 return ((unsigned long) (field
[3]))
598 | (((unsigned long) (field
[2])) << 8)
599 | (((unsigned long) (field
[1])) << 16)
600 | (((unsigned long) (field
[0])) << 24);
604 return ((bfd_vma
) (field
[7]))
605 | (((bfd_vma
) (field
[6])) << 8)
606 | (((bfd_vma
) (field
[5])) << 16)
607 | (((bfd_vma
) (field
[4])) << 24)
608 | (((bfd_vma
) (field
[3])) << 32)
609 | (((bfd_vma
) (field
[2])) << 40)
610 | (((bfd_vma
) (field
[1])) << 48)
611 | (((bfd_vma
) (field
[0])) << 56);
615 error (_("Unhandled data length: %d\n"), size
);
621 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
626 field
[7] = value
& 0xff;
627 field
[6] = (value
>> 8) & 0xff;
628 field
[5] = (value
>> 16) & 0xff;
629 field
[4] = (value
>> 24) & 0xff;
634 field
[3] = value
& 0xff;
635 field
[2] = (value
>> 8) & 0xff;
639 field
[1] = value
& 0xff;
643 field
[0] = value
& 0xff;
647 error (_("Unhandled data length: %d\n"), size
);
652 /* Return a pointer to section NAME, or NULL if no such section exists. */
654 static Elf_Internal_Shdr
*
655 find_section (const char *name
)
659 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
660 if (streq (SECTION_NAME (section_headers
+ i
), name
))
661 return section_headers
+ i
;
666 /* Guess the relocation size commonly used by the specific machines. */
669 guess_is_rela (unsigned long e_machine
)
673 /* Targets that use REL relocations. */
688 /* Targets that use RELA relocations. */
703 case EM_CYGNUS_MN10200
:
705 case EM_CYGNUS_MN10300
:
752 warn (_("Don't know about relocations on this machine architecture\n"));
758 slurp_rela_relocs (FILE *file
,
759 unsigned long rel_offset
,
760 unsigned long rel_size
,
761 Elf_Internal_Rela
**relasp
,
762 unsigned long *nrelasp
)
764 Elf_Internal_Rela
*relas
;
765 unsigned long nrelas
;
770 Elf32_External_Rela
*erelas
;
772 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
776 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
778 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
782 error (_("out of memory parsing relocs"));
786 for (i
= 0; i
< nrelas
; i
++)
788 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
789 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
790 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
797 Elf64_External_Rela
*erelas
;
799 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
803 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
805 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
809 error (_("out of memory parsing relocs"));
813 for (i
= 0; i
< nrelas
; i
++)
815 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
816 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
817 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
828 slurp_rel_relocs (FILE *file
,
829 unsigned long rel_offset
,
830 unsigned long rel_size
,
831 Elf_Internal_Rela
**relsp
,
832 unsigned long *nrelsp
)
834 Elf_Internal_Rela
*rels
;
840 Elf32_External_Rel
*erels
;
842 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
846 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
848 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
852 error (_("out of memory parsing relocs"));
856 for (i
= 0; i
< nrels
; i
++)
858 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
859 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
860 rels
[i
].r_addend
= 0;
867 Elf64_External_Rel
*erels
;
869 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
873 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
875 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
879 error (_("out of memory parsing relocs"));
883 for (i
= 0; i
< nrels
; i
++)
885 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
886 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
887 rels
[i
].r_addend
= 0;
897 /* Display the contents of the relocation data found at the specified
901 dump_relocations (FILE *file
,
902 unsigned long rel_offset
,
903 unsigned long rel_size
,
904 Elf_Internal_Sym
*symtab
,
907 unsigned long strtablen
,
911 Elf_Internal_Rela
*rels
;
914 if (is_rela
== UNKNOWN
)
915 is_rela
= guess_is_rela (elf_header
.e_machine
);
919 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
924 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
933 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
935 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
940 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
942 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
950 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
952 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
957 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
959 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
963 for (i
= 0; i
< rel_size
; i
++)
966 const char *rtype2
= NULL
;
967 const char *rtype3
= NULL
;
970 bfd_vma symtab_index
;
975 offset
= rels
[i
].r_offset
;
976 info
= rels
[i
].r_info
;
980 type
= ELF32_R_TYPE (info
);
981 symtab_index
= ELF32_R_SYM (info
);
985 /* The #ifdef BFD64 below is to prevent a compile time warning.
986 We know that if we do not have a 64 bit data type that we
987 will never execute this code anyway. */
989 if (elf_header
.e_machine
== EM_MIPS
)
991 /* In little-endian objects, r_info isn't really a 64-bit
992 little-endian value: it has a 32-bit little-endian
993 symbol index followed by four individual byte fields.
994 Reorder INFO accordingly. */
995 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
996 info
= (((info
& 0xffffffff) << 32)
997 | ((info
>> 56) & 0xff)
998 | ((info
>> 40) & 0xff00)
999 | ((info
>> 24) & 0xff0000)
1000 | ((info
>> 8) & 0xff000000));
1001 type
= ELF64_MIPS_R_TYPE (info
);
1002 type2
= ELF64_MIPS_R_TYPE2 (info
);
1003 type3
= ELF64_MIPS_R_TYPE3 (info
);
1005 else if (elf_header
.e_machine
== EM_SPARCV9
)
1006 type
= ELF64_R_TYPE_ID (info
);
1008 type
= ELF64_R_TYPE (info
);
1010 symtab_index
= ELF64_R_SYM (info
);
1016 #ifdef _bfd_int64_low
1017 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
1019 printf ("%8.8lx %8.8lx ", offset
, info
);
1024 #ifdef _bfd_int64_low
1026 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1027 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1028 _bfd_int64_high (offset
),
1029 _bfd_int64_low (offset
),
1030 _bfd_int64_high (info
),
1031 _bfd_int64_low (info
));
1034 ? "%16.16lx %16.16lx "
1035 : "%12.12lx %12.12lx ",
1040 switch (elf_header
.e_machine
)
1047 case EM_CYGNUS_M32R
:
1048 rtype
= elf_m32r_reloc_type (type
);
1053 rtype
= elf_i386_reloc_type (type
);
1058 rtype
= elf_m68hc11_reloc_type (type
);
1062 rtype
= elf_m68k_reloc_type (type
);
1066 rtype
= elf_i960_reloc_type (type
);
1071 rtype
= elf_avr_reloc_type (type
);
1074 case EM_OLD_SPARCV9
:
1075 case EM_SPARC32PLUS
:
1078 rtype
= elf_sparc_reloc_type (type
);
1082 case EM_CYGNUS_V850
:
1083 rtype
= v850_reloc_type (type
);
1087 case EM_CYGNUS_D10V
:
1088 rtype
= elf_d10v_reloc_type (type
);
1092 case EM_CYGNUS_D30V
:
1093 rtype
= elf_d30v_reloc_type (type
);
1097 rtype
= elf_dlx_reloc_type (type
);
1101 rtype
= elf_sh_reloc_type (type
);
1105 case EM_CYGNUS_MN10300
:
1106 rtype
= elf_mn10300_reloc_type (type
);
1110 case EM_CYGNUS_MN10200
:
1111 rtype
= elf_mn10200_reloc_type (type
);
1115 case EM_CYGNUS_FR30
:
1116 rtype
= elf_fr30_reloc_type (type
);
1120 rtype
= elf_frv_reloc_type (type
);
1124 rtype
= elf_mcore_reloc_type (type
);
1128 rtype
= elf_mmix_reloc_type (type
);
1133 rtype
= elf_msp430_reloc_type (type
);
1137 rtype
= elf_ppc_reloc_type (type
);
1141 rtype
= elf_ppc64_reloc_type (type
);
1145 case EM_MIPS_RS3_LE
:
1146 rtype
= elf_mips_reloc_type (type
);
1149 rtype2
= elf_mips_reloc_type (type2
);
1150 rtype3
= elf_mips_reloc_type (type3
);
1155 rtype
= elf_alpha_reloc_type (type
);
1159 rtype
= elf_arm_reloc_type (type
);
1163 rtype
= elf_arc_reloc_type (type
);
1167 rtype
= elf_hppa_reloc_type (type
);
1173 rtype
= elf_h8_reloc_type (type
);
1178 rtype
= elf_or32_reloc_type (type
);
1183 rtype
= elf_pj_reloc_type (type
);
1186 rtype
= elf_ia64_reloc_type (type
);
1190 rtype
= elf_cris_reloc_type (type
);
1194 rtype
= elf_i860_reloc_type (type
);
1198 rtype
= elf_x86_64_reloc_type (type
);
1202 rtype
= i370_reloc_type (type
);
1207 rtype
= elf_s390_reloc_type (type
);
1211 rtype
= elf_xstormy16_reloc_type (type
);
1215 rtype
= elf_crx_reloc_type (type
);
1219 rtype
= elf_vax_reloc_type (type
);
1224 rtype
= elf_ip2k_reloc_type (type
);
1228 rtype
= elf_iq2000_reloc_type (type
);
1233 rtype
= elf_xtensa_reloc_type (type
);
1238 #ifdef _bfd_int64_low
1239 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1241 printf (_("unrecognized: %-7lx"), type
);
1244 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1248 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1249 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1252 Elf_Internal_Sym
*psym
;
1254 psym
= symtab
+ symtab_index
;
1257 print_vma (psym
->st_value
, LONG_HEX
);
1258 printf (is_32bit_elf
? " " : " ");
1260 if (psym
->st_name
== 0)
1262 const char *sec_name
= "<null>";
1265 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1267 bfd_vma sec_index
= (bfd_vma
) -1;
1269 if (psym
->st_shndx
< SHN_LORESERVE
)
1270 sec_index
= psym
->st_shndx
;
1271 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1272 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1275 if (sec_index
!= (bfd_vma
) -1)
1276 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1277 else if (psym
->st_shndx
== SHN_ABS
)
1279 else if (psym
->st_shndx
== SHN_COMMON
)
1280 sec_name
= "COMMON";
1281 else if (elf_header
.e_machine
== EM_IA_64
1282 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1283 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1284 sec_name
= "ANSI_COM";
1287 sprintf (name_buf
, "<section 0x%x>",
1288 (unsigned int) psym
->st_shndx
);
1289 sec_name
= name_buf
;
1292 print_symbol (22, sec_name
);
1294 else if (strtab
== NULL
)
1295 printf (_("<string table index: %3ld>"), psym
->st_name
);
1296 else if (psym
->st_name
> strtablen
)
1297 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1299 print_symbol (22, strtab
+ psym
->st_name
);
1302 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1307 printf ("%*c", is_32bit_elf
?
1308 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1309 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1312 if (elf_header
.e_machine
== EM_SPARCV9
1313 && streq (rtype
, "R_SPARC_OLO10"))
1314 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1318 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1320 printf (" Type2: ");
1323 #ifdef _bfd_int64_low
1324 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1326 printf (_("unrecognized: %-7lx"), type2
);
1329 printf ("%-17.17s", rtype2
);
1331 printf ("\n Type3: ");
1334 #ifdef _bfd_int64_low
1335 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1337 printf (_("unrecognized: %-7lx"), type3
);
1340 printf ("%-17.17s", rtype3
);
1352 get_mips_dynamic_type (unsigned long type
)
1356 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1357 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1358 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1359 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1360 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1361 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1362 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1363 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1364 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1365 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1366 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1367 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1368 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1369 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1370 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1371 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1372 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1373 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1374 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1375 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1376 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1377 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1378 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1379 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1380 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1381 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1382 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1383 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1384 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1385 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1386 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1387 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1388 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1389 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1390 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1391 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1392 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1393 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1394 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1395 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1396 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1397 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1398 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1405 get_sparc64_dynamic_type (unsigned long type
)
1409 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1416 get_ppc64_dynamic_type (unsigned long type
)
1420 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1421 case DT_PPC64_OPD
: return "PPC64_OPD";
1422 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1429 get_parisc_dynamic_type (unsigned long type
)
1433 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1434 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1435 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1436 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1437 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1438 case DT_HP_PREINIT
: return "HP_PREINIT";
1439 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1440 case DT_HP_NEEDED
: return "HP_NEEDED";
1441 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1442 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1443 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1444 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1445 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1452 get_ia64_dynamic_type (unsigned long type
)
1456 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1463 get_dynamic_type (unsigned long type
)
1465 static char buff
[32];
1469 case DT_NULL
: return "NULL";
1470 case DT_NEEDED
: return "NEEDED";
1471 case DT_PLTRELSZ
: return "PLTRELSZ";
1472 case DT_PLTGOT
: return "PLTGOT";
1473 case DT_HASH
: return "HASH";
1474 case DT_STRTAB
: return "STRTAB";
1475 case DT_SYMTAB
: return "SYMTAB";
1476 case DT_RELA
: return "RELA";
1477 case DT_RELASZ
: return "RELASZ";
1478 case DT_RELAENT
: return "RELAENT";
1479 case DT_STRSZ
: return "STRSZ";
1480 case DT_SYMENT
: return "SYMENT";
1481 case DT_INIT
: return "INIT";
1482 case DT_FINI
: return "FINI";
1483 case DT_SONAME
: return "SONAME";
1484 case DT_RPATH
: return "RPATH";
1485 case DT_SYMBOLIC
: return "SYMBOLIC";
1486 case DT_REL
: return "REL";
1487 case DT_RELSZ
: return "RELSZ";
1488 case DT_RELENT
: return "RELENT";
1489 case DT_PLTREL
: return "PLTREL";
1490 case DT_DEBUG
: return "DEBUG";
1491 case DT_TEXTREL
: return "TEXTREL";
1492 case DT_JMPREL
: return "JMPREL";
1493 case DT_BIND_NOW
: return "BIND_NOW";
1494 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1495 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1496 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1497 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1498 case DT_RUNPATH
: return "RUNPATH";
1499 case DT_FLAGS
: return "FLAGS";
1501 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1502 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1504 case DT_CHECKSUM
: return "CHECKSUM";
1505 case DT_PLTPADSZ
: return "PLTPADSZ";
1506 case DT_MOVEENT
: return "MOVEENT";
1507 case DT_MOVESZ
: return "MOVESZ";
1508 case DT_FEATURE
: return "FEATURE";
1509 case DT_POSFLAG_1
: return "POSFLAG_1";
1510 case DT_SYMINSZ
: return "SYMINSZ";
1511 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1513 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1514 case DT_CONFIG
: return "CONFIG";
1515 case DT_DEPAUDIT
: return "DEPAUDIT";
1516 case DT_AUDIT
: return "AUDIT";
1517 case DT_PLTPAD
: return "PLTPAD";
1518 case DT_MOVETAB
: return "MOVETAB";
1519 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1521 case DT_VERSYM
: return "VERSYM";
1523 case DT_RELACOUNT
: return "RELACOUNT";
1524 case DT_RELCOUNT
: return "RELCOUNT";
1525 case DT_FLAGS_1
: return "FLAGS_1";
1526 case DT_VERDEF
: return "VERDEF";
1527 case DT_VERDEFNUM
: return "VERDEFNUM";
1528 case DT_VERNEED
: return "VERNEED";
1529 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1531 case DT_AUXILIARY
: return "AUXILIARY";
1532 case DT_USED
: return "USED";
1533 case DT_FILTER
: return "FILTER";
1535 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1536 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1537 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1538 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1539 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1542 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1546 switch (elf_header
.e_machine
)
1549 case EM_MIPS_RS3_LE
:
1550 result
= get_mips_dynamic_type (type
);
1553 result
= get_sparc64_dynamic_type (type
);
1556 result
= get_ppc64_dynamic_type (type
);
1559 result
= get_ia64_dynamic_type (type
);
1569 sprintf (buff
, _("Processor Specific: %lx"), type
);
1571 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1575 switch (elf_header
.e_machine
)
1578 result
= get_parisc_dynamic_type (type
);
1588 sprintf (buff
, _("Operating System specific: %lx"), type
);
1591 sprintf (buff
, _("<unknown>: %lx"), type
);
1598 get_file_type (unsigned e_type
)
1600 static char buff
[32];
1604 case ET_NONE
: return _("NONE (None)");
1605 case ET_REL
: return _("REL (Relocatable file)");
1606 case ET_EXEC
: return _("EXEC (Executable file)");
1607 case ET_DYN
: return _("DYN (Shared object file)");
1608 case ET_CORE
: return _("CORE (Core file)");
1611 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1612 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1613 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1614 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1616 sprintf (buff
, _("<unknown>: %x"), e_type
);
1622 get_machine_name (unsigned e_machine
)
1624 static char buff
[64]; /* XXX */
1628 case EM_NONE
: return _("None");
1629 case EM_M32
: return "WE32100";
1630 case EM_SPARC
: return "Sparc";
1631 case EM_386
: return "Intel 80386";
1632 case EM_68K
: return "MC68000";
1633 case EM_88K
: return "MC88000";
1634 case EM_486
: return "Intel 80486";
1635 case EM_860
: return "Intel 80860";
1636 case EM_MIPS
: return "MIPS R3000";
1637 case EM_S370
: return "IBM System/370";
1638 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1639 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1640 case EM_PARISC
: return "HPPA";
1641 case EM_PPC_OLD
: return "Power PC (old)";
1642 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1643 case EM_960
: return "Intel 90860";
1644 case EM_PPC
: return "PowerPC";
1645 case EM_PPC64
: return "PowerPC64";
1646 case EM_V800
: return "NEC V800";
1647 case EM_FR20
: return "Fujitsu FR20";
1648 case EM_RH32
: return "TRW RH32";
1649 case EM_MCORE
: return "MCORE";
1650 case EM_ARM
: return "ARM";
1651 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1652 case EM_SH
: return "Renesas / SuperH SH";
1653 case EM_SPARCV9
: return "Sparc v9";
1654 case EM_TRICORE
: return "Siemens Tricore";
1655 case EM_ARC
: return "ARC";
1656 case EM_H8_300
: return "Renesas H8/300";
1657 case EM_H8_300H
: return "Renesas H8/300H";
1658 case EM_H8S
: return "Renesas H8S";
1659 case EM_H8_500
: return "Renesas H8/500";
1660 case EM_IA_64
: return "Intel IA-64";
1661 case EM_MIPS_X
: return "Stanford MIPS-X";
1662 case EM_COLDFIRE
: return "Motorola Coldfire";
1663 case EM_68HC12
: return "Motorola M68HC12";
1664 case EM_ALPHA
: return "Alpha";
1665 case EM_CYGNUS_D10V
:
1666 case EM_D10V
: return "d10v";
1667 case EM_CYGNUS_D30V
:
1668 case EM_D30V
: return "d30v";
1669 case EM_CYGNUS_M32R
:
1670 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1671 case EM_CYGNUS_V850
:
1672 case EM_V850
: return "NEC v850";
1673 case EM_CYGNUS_MN10300
:
1674 case EM_MN10300
: return "mn10300";
1675 case EM_CYGNUS_MN10200
:
1676 case EM_MN10200
: return "mn10200";
1677 case EM_CYGNUS_FR30
:
1678 case EM_FR30
: return "Fujitsu FR30";
1679 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1681 case EM_PJ
: return "picoJava";
1682 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1683 case EM_PCP
: return "Siemens PCP";
1684 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1685 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1686 case EM_STARCORE
: return "Motorola Star*Core processor";
1687 case EM_ME16
: return "Toyota ME16 processor";
1688 case EM_ST100
: return "STMicroelectronics ST100 processor";
1689 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1690 case EM_FX66
: return "Siemens FX66 microcontroller";
1691 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1692 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1693 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1694 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1695 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1696 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1697 case EM_SVX
: return "Silicon Graphics SVx";
1698 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1699 case EM_VAX
: return "Digital VAX";
1701 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1702 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1703 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1704 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1705 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1706 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1707 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1708 case EM_PRISM
: return "Vitesse Prism";
1709 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1711 case EM_S390
: return "IBM S/390";
1712 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1714 case EM_OR32
: return "OpenRISC";
1715 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1716 case EM_DLX
: return "OpenDLX";
1718 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1719 case EM_IQ2000
: return "Vitesse IQ2000";
1721 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1723 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1729 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1734 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1735 e_flags
&= ~ EF_ARM_EABIMASK
;
1737 /* Handle "generic" ARM flags. */
1738 if (e_flags
& EF_ARM_RELEXEC
)
1740 strcat (buf
, ", relocatable executable");
1741 e_flags
&= ~ EF_ARM_RELEXEC
;
1744 if (e_flags
& EF_ARM_HASENTRY
)
1746 strcat (buf
, ", has entry point");
1747 e_flags
&= ~ EF_ARM_HASENTRY
;
1750 /* Now handle EABI specific flags. */
1754 strcat (buf
, ", <unrecognized EABI>");
1759 case EF_ARM_EABI_VER1
:
1760 strcat (buf
, ", Version1 EABI");
1765 /* Process flags one bit at a time. */
1766 flag
= e_flags
& - e_flags
;
1771 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1772 strcat (buf
, ", sorted symbol tables");
1782 case EF_ARM_EABI_VER2
:
1783 strcat (buf
, ", Version2 EABI");
1788 /* Process flags one bit at a time. */
1789 flag
= e_flags
& - e_flags
;
1794 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1795 strcat (buf
, ", sorted symbol tables");
1798 case EF_ARM_DYNSYMSUSESEGIDX
:
1799 strcat (buf
, ", dynamic symbols use segment index");
1802 case EF_ARM_MAPSYMSFIRST
:
1803 strcat (buf
, ", mapping symbols precede others");
1813 case EF_ARM_EABI_VER3
:
1814 strcat (buf
, ", Version3 EABI");
1817 case EF_ARM_EABI_VER4
:
1818 strcat (buf
, ", Version4 EABI");
1823 /* Process flags one bit at a time. */
1824 flag
= e_flags
& - e_flags
;
1830 strcat (buf
, ", BE8");
1834 strcat (buf
, ", LE8");
1844 case EF_ARM_EABI_UNKNOWN
:
1845 strcat (buf
, ", GNU EABI");
1850 /* Process flags one bit at a time. */
1851 flag
= e_flags
& - e_flags
;
1856 case EF_ARM_INTERWORK
:
1857 strcat (buf
, ", interworking enabled");
1860 case EF_ARM_APCS_26
:
1861 strcat (buf
, ", uses APCS/26");
1864 case EF_ARM_APCS_FLOAT
:
1865 strcat (buf
, ", uses APCS/float");
1869 strcat (buf
, ", position independent");
1873 strcat (buf
, ", 8 bit structure alignment");
1876 case EF_ARM_NEW_ABI
:
1877 strcat (buf
, ", uses new ABI");
1880 case EF_ARM_OLD_ABI
:
1881 strcat (buf
, ", uses old ABI");
1884 case EF_ARM_SOFT_FLOAT
:
1885 strcat (buf
, ", software FP");
1888 case EF_ARM_VFP_FLOAT
:
1889 strcat (buf
, ", VFP");
1892 case EF_ARM_MAVERICK_FLOAT
:
1893 strcat (buf
, ", Maverick FP");
1904 strcat (buf
,", <unknown>");
1908 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1910 static char buf
[1024];
1922 decode_ARM_machine_flags (e_flags
, buf
);
1926 switch (e_flags
& EF_FRV_CPU_MASK
)
1928 case EF_FRV_CPU_GENERIC
:
1932 strcat (buf
, ", fr???");
1935 case EF_FRV_CPU_FR300
:
1936 strcat (buf
, ", fr300");
1939 case EF_FRV_CPU_FR400
:
1940 strcat (buf
, ", fr400");
1942 case EF_FRV_CPU_FR405
:
1943 strcat (buf
, ", fr405");
1946 case EF_FRV_CPU_FR450
:
1947 strcat (buf
, ", fr450");
1950 case EF_FRV_CPU_FR500
:
1951 strcat (buf
, ", fr500");
1953 case EF_FRV_CPU_FR550
:
1954 strcat (buf
, ", fr550");
1957 case EF_FRV_CPU_SIMPLE
:
1958 strcat (buf
, ", simple");
1960 case EF_FRV_CPU_TOMCAT
:
1961 strcat (buf
, ", tomcat");
1967 if (e_flags
& EF_CPU32
)
1968 strcat (buf
, ", cpu32");
1969 if (e_flags
& EF_M68000
)
1970 strcat (buf
, ", m68000");
1974 if (e_flags
& EF_PPC_EMB
)
1975 strcat (buf
, ", emb");
1977 if (e_flags
& EF_PPC_RELOCATABLE
)
1978 strcat (buf
, ", relocatable");
1980 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1981 strcat (buf
, ", relocatable-lib");
1985 case EM_CYGNUS_V850
:
1986 switch (e_flags
& EF_V850_ARCH
)
1989 strcat (buf
, ", v850e1");
1992 strcat (buf
, ", v850e");
1995 strcat (buf
, ", v850");
1998 strcat (buf
, ", unknown v850 architecture variant");
2004 case EM_CYGNUS_M32R
:
2005 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2006 strcat (buf
, ", m32r");
2011 case EM_MIPS_RS3_LE
:
2012 if (e_flags
& EF_MIPS_NOREORDER
)
2013 strcat (buf
, ", noreorder");
2015 if (e_flags
& EF_MIPS_PIC
)
2016 strcat (buf
, ", pic");
2018 if (e_flags
& EF_MIPS_CPIC
)
2019 strcat (buf
, ", cpic");
2021 if (e_flags
& EF_MIPS_UCODE
)
2022 strcat (buf
, ", ugen_reserved");
2024 if (e_flags
& EF_MIPS_ABI2
)
2025 strcat (buf
, ", abi2");
2027 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2028 strcat (buf
, ", odk first");
2030 if (e_flags
& EF_MIPS_32BITMODE
)
2031 strcat (buf
, ", 32bitmode");
2033 switch ((e_flags
& EF_MIPS_MACH
))
2035 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2036 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2037 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2038 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2039 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2040 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2041 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2042 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2043 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2044 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2046 /* We simply ignore the field in this case to avoid confusion:
2047 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2050 default: strcat (buf
, ", unknown CPU"); break;
2053 switch ((e_flags
& EF_MIPS_ABI
))
2055 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2056 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2057 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2058 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2060 /* We simply ignore the field in this case to avoid confusion:
2061 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2062 This means it is likely to be an o32 file, but not for
2065 default: strcat (buf
, ", unknown ABI"); break;
2068 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2069 strcat (buf
, ", mdmx");
2071 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2072 strcat (buf
, ", mips16");
2074 switch ((e_flags
& EF_MIPS_ARCH
))
2076 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2077 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2078 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2079 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2080 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2081 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2082 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2083 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2084 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2085 default: strcat (buf
, ", unknown ISA"); break;
2091 switch ((e_flags
& EF_SH_MACH_MASK
))
2093 case EF_SH1
: strcat (buf
, ", sh1"); break;
2094 case EF_SH2
: strcat (buf
, ", sh2"); break;
2095 case EF_SH3
: strcat (buf
, ", sh3"); break;
2096 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2097 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2098 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2099 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2100 case EF_SH4
: strcat (buf
, ", sh4"); break;
2101 case EF_SH5
: strcat (buf
, ", sh5"); break;
2102 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2103 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2104 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2105 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2106 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2107 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2108 default: strcat (buf
, ", unknown ISA"); break;
2114 if (e_flags
& EF_SPARC_32PLUS
)
2115 strcat (buf
, ", v8+");
2117 if (e_flags
& EF_SPARC_SUN_US1
)
2118 strcat (buf
, ", ultrasparcI");
2120 if (e_flags
& EF_SPARC_SUN_US3
)
2121 strcat (buf
, ", ultrasparcIII");
2123 if (e_flags
& EF_SPARC_HAL_R1
)
2124 strcat (buf
, ", halr1");
2126 if (e_flags
& EF_SPARC_LEDATA
)
2127 strcat (buf
, ", ledata");
2129 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2130 strcat (buf
, ", tso");
2132 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2133 strcat (buf
, ", pso");
2135 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2136 strcat (buf
, ", rmo");
2140 switch (e_flags
& EF_PARISC_ARCH
)
2142 case EFA_PARISC_1_0
:
2143 strcpy (buf
, ", PA-RISC 1.0");
2145 case EFA_PARISC_1_1
:
2146 strcpy (buf
, ", PA-RISC 1.1");
2148 case EFA_PARISC_2_0
:
2149 strcpy (buf
, ", PA-RISC 2.0");
2154 if (e_flags
& EF_PARISC_TRAPNIL
)
2155 strcat (buf
, ", trapnil");
2156 if (e_flags
& EF_PARISC_EXT
)
2157 strcat (buf
, ", ext");
2158 if (e_flags
& EF_PARISC_LSB
)
2159 strcat (buf
, ", lsb");
2160 if (e_flags
& EF_PARISC_WIDE
)
2161 strcat (buf
, ", wide");
2162 if (e_flags
& EF_PARISC_NO_KABP
)
2163 strcat (buf
, ", no kabp");
2164 if (e_flags
& EF_PARISC_LAZYSWAP
)
2165 strcat (buf
, ", lazyswap");
2170 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2171 strcat (buf
, ", new calling convention");
2173 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2174 strcat (buf
, ", gnu calling convention");
2178 if ((e_flags
& EF_IA_64_ABI64
))
2179 strcat (buf
, ", 64-bit");
2181 strcat (buf
, ", 32-bit");
2182 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2183 strcat (buf
, ", reduced fp model");
2184 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2185 strcat (buf
, ", no function descriptors, constant gp");
2186 else if ((e_flags
& EF_IA_64_CONS_GP
))
2187 strcat (buf
, ", constant gp");
2188 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2189 strcat (buf
, ", absolute");
2193 if ((e_flags
& EF_VAX_NONPIC
))
2194 strcat (buf
, ", non-PIC");
2195 if ((e_flags
& EF_VAX_DFLOAT
))
2196 strcat (buf
, ", D-Float");
2197 if ((e_flags
& EF_VAX_GFLOAT
))
2198 strcat (buf
, ", G-Float");
2207 get_osabi_name (unsigned int osabi
)
2209 static char buff
[32];
2213 case ELFOSABI_NONE
: return "UNIX - System V";
2214 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2215 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2216 case ELFOSABI_LINUX
: return "UNIX - Linux";
2217 case ELFOSABI_HURD
: return "GNU/Hurd";
2218 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2219 case ELFOSABI_AIX
: return "UNIX - AIX";
2220 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2221 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2222 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2223 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2224 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2225 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2226 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2227 case ELFOSABI_AROS
: return "Amiga Research OS";
2228 case ELFOSABI_STANDALONE
: return _("Standalone App");
2229 case ELFOSABI_ARM
: return "ARM";
2231 sprintf (buff
, _("<unknown: %x>"), osabi
);
2237 get_mips_segment_type (unsigned long type
)
2241 case PT_MIPS_REGINFO
:
2243 case PT_MIPS_RTPROC
:
2245 case PT_MIPS_OPTIONS
:
2255 get_parisc_segment_type (unsigned long type
)
2259 case PT_HP_TLS
: return "HP_TLS";
2260 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2261 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2262 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2263 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2264 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2265 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2266 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2267 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2268 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2269 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2270 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2271 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2272 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2281 get_ia64_segment_type (unsigned long type
)
2285 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2286 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2287 case PT_HP_TLS
: return "HP_TLS";
2288 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2289 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2290 case PT_IA_64_HP_STACK
: return "HP_STACK";
2299 get_segment_type (unsigned long p_type
)
2301 static char buff
[32];
2305 case PT_NULL
: return "NULL";
2306 case PT_LOAD
: return "LOAD";
2307 case PT_DYNAMIC
: return "DYNAMIC";
2308 case PT_INTERP
: return "INTERP";
2309 case PT_NOTE
: return "NOTE";
2310 case PT_SHLIB
: return "SHLIB";
2311 case PT_PHDR
: return "PHDR";
2312 case PT_TLS
: return "TLS";
2314 case PT_GNU_EH_FRAME
:
2315 return "GNU_EH_FRAME";
2316 case PT_GNU_STACK
: return "GNU_STACK";
2317 case PT_GNU_RELRO
: return "GNU_RELRO";
2320 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2324 switch (elf_header
.e_machine
)
2327 case EM_MIPS_RS3_LE
:
2328 result
= get_mips_segment_type (p_type
);
2331 result
= get_parisc_segment_type (p_type
);
2334 result
= get_ia64_segment_type (p_type
);
2344 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2346 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2350 switch (elf_header
.e_machine
)
2353 result
= get_parisc_segment_type (p_type
);
2356 result
= get_ia64_segment_type (p_type
);
2366 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2369 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2376 get_mips_section_type_name (unsigned int sh_type
)
2380 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2381 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2382 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2383 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2384 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2385 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2386 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2387 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2388 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2389 case SHT_MIPS_RELD
: return "MIPS_RELD";
2390 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2391 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2392 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2393 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2394 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2395 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2396 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2397 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2398 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2399 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2400 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2401 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2402 case SHT_MIPS_LINE
: return "MIPS_LINE";
2403 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2404 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2405 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2406 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2407 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2408 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2409 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2410 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2411 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2412 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2413 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2414 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2415 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2416 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2417 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2418 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2426 get_parisc_section_type_name (unsigned int sh_type
)
2430 case SHT_PARISC_EXT
: return "PARISC_EXT";
2431 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2432 case SHT_PARISC_DOC
: return "PARISC_DOC";
2440 get_ia64_section_type_name (unsigned int sh_type
)
2442 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2443 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2444 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2448 case SHT_IA_64_EXT
: return "IA_64_EXT";
2449 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2450 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2458 get_x86_64_section_type_name (unsigned int sh_type
)
2462 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2470 get_arm_section_type_name (unsigned int sh_type
)
2483 get_section_type_name (unsigned int sh_type
)
2485 static char buff
[32];
2489 case SHT_NULL
: return "NULL";
2490 case SHT_PROGBITS
: return "PROGBITS";
2491 case SHT_SYMTAB
: return "SYMTAB";
2492 case SHT_STRTAB
: return "STRTAB";
2493 case SHT_RELA
: return "RELA";
2494 case SHT_HASH
: return "HASH";
2495 case SHT_DYNAMIC
: return "DYNAMIC";
2496 case SHT_NOTE
: return "NOTE";
2497 case SHT_NOBITS
: return "NOBITS";
2498 case SHT_REL
: return "REL";
2499 case SHT_SHLIB
: return "SHLIB";
2500 case SHT_DYNSYM
: return "DYNSYM";
2501 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2502 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2503 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2504 case SHT_GROUP
: return "GROUP";
2505 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2506 case SHT_GNU_verdef
: return "VERDEF";
2507 case SHT_GNU_verneed
: return "VERNEED";
2508 case SHT_GNU_versym
: return "VERSYM";
2509 case 0x6ffffff0: return "VERSYM";
2510 case 0x6ffffffc: return "VERDEF";
2511 case 0x7ffffffd: return "AUXILIARY";
2512 case 0x7fffffff: return "FILTER";
2513 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2516 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2520 switch (elf_header
.e_machine
)
2523 case EM_MIPS_RS3_LE
:
2524 result
= get_mips_section_type_name (sh_type
);
2527 result
= get_parisc_section_type_name (sh_type
);
2530 result
= get_ia64_section_type_name (sh_type
);
2533 result
= get_x86_64_section_type_name (sh_type
);
2536 result
= get_arm_section_type_name (sh_type
);
2546 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2548 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2549 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2550 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2551 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2553 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2559 #define OPTION_DEBUG_DUMP 512
2561 struct option options
[] =
2563 {"all", no_argument
, 0, 'a'},
2564 {"file-header", no_argument
, 0, 'h'},
2565 {"program-headers", no_argument
, 0, 'l'},
2566 {"headers", no_argument
, 0, 'e'},
2567 {"histogram", no_argument
, 0, 'I'},
2568 {"segments", no_argument
, 0, 'l'},
2569 {"sections", no_argument
, 0, 'S'},
2570 {"section-headers", no_argument
, 0, 'S'},
2571 {"section-groups", no_argument
, 0, 'g'},
2572 {"symbols", no_argument
, 0, 's'},
2573 {"syms", no_argument
, 0, 's'},
2574 {"relocs", no_argument
, 0, 'r'},
2575 {"notes", no_argument
, 0, 'n'},
2576 {"dynamic", no_argument
, 0, 'd'},
2577 {"arch-specific", no_argument
, 0, 'A'},
2578 {"version-info", no_argument
, 0, 'V'},
2579 {"use-dynamic", no_argument
, 0, 'D'},
2580 {"hex-dump", required_argument
, 0, 'x'},
2581 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2582 {"unwind", no_argument
, 0, 'u'},
2583 #ifdef SUPPORT_DISASSEMBLY
2584 {"instruction-dump", required_argument
, 0, 'i'},
2587 {"version", no_argument
, 0, 'v'},
2588 {"wide", no_argument
, 0, 'W'},
2589 {"help", no_argument
, 0, 'H'},
2590 {0, no_argument
, 0, 0}
2596 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2597 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2598 fprintf (stdout
, _(" Options are:\n\
2599 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2600 -h --file-header Display the ELF file header\n\
2601 -l --program-headers Display the program headers\n\
2602 --segments An alias for --program-headers\n\
2603 -S --section-headers Display the sections' header\n\
2604 --sections An alias for --section-headers\n\
2605 -g --section-groups Display the section groups\n\
2606 -e --headers Equivalent to: -h -l -S\n\
2607 -s --syms Display the symbol table\n\
2608 --symbols An alias for --syms\n\
2609 -n --notes Display the core notes (if present)\n\
2610 -r --relocs Display the relocations (if present)\n\
2611 -u --unwind Display the unwind info (if present)\n\
2612 -d --dynamic Display the dynamic section (if present)\n\
2613 -V --version-info Display the version sections (if present)\n\
2614 -A --arch-specific Display architecture specific information (if any).\n\
2615 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2616 -x --hex-dump=<number> Dump the contents of section <number>\n\
2617 -w[liaprmfFsoR] or\n\
2618 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2619 Display the contents of DWARF2 debug sections\n"));
2620 #ifdef SUPPORT_DISASSEMBLY
2621 fprintf (stdout
, _("\
2622 -i --instruction-dump=<number>\n\
2623 Disassemble the contents of section <number>\n"));
2625 fprintf (stdout
, _("\
2626 -I --histogram Display histogram of bucket list lengths\n\
2627 -W --wide Allow output width to exceed 80 characters\n\
2628 -H --help Display this information\n\
2629 -v --version Display the version number of readelf\n"));
2630 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2635 /* Record the fact that the user wants the contents of section number
2636 SECTION to be displayed using the method(s) encoded as flags bits
2637 in TYPE. Note, TYPE can be zero if we are creating the array for
2641 request_dump (unsigned int section
, int type
)
2643 if (section
>= num_dump_sects
)
2645 char *new_dump_sects
;
2647 new_dump_sects
= calloc (section
+ 1, 1);
2649 if (new_dump_sects
== NULL
)
2650 error (_("Out of memory allocating dump request table."));
2653 /* Copy current flag settings. */
2654 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2658 dump_sects
= new_dump_sects
;
2659 num_dump_sects
= section
+ 1;
2664 dump_sects
[section
] |= type
;
2670 parse_args (int argc
, char **argv
)
2677 while ((c
= getopt_long
2678 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2699 do_section_groups
++;
2707 do_section_groups
++;
2749 section
= strtoul (optarg
, & cp
, 0);
2750 if (! *cp
&& section
>= 0)
2752 request_dump (section
, HEX_DUMP
);
2762 unsigned int index
= 0;
2766 while (optarg
[index
])
2767 switch (optarg
[index
++])
2776 do_debug_abbrevs
= 1;
2786 do_debug_pubnames
= 1;
2790 do_debug_aranges
= 1;
2794 do_debug_ranges
= 1;
2798 do_debug_frames_interp
= 1;
2800 do_debug_frames
= 1;
2805 do_debug_macinfo
= 1;
2819 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2824 case OPTION_DEBUG_DUMP
:
2832 const char * option
;
2835 debug_dump_long_opts
;
2837 debug_dump_long_opts opts_table
[] =
2839 /* Please keep this table alpha- sorted. */
2840 { "Ranges", & do_debug_ranges
},
2841 { "abbrev", & do_debug_abbrevs
},
2842 { "aranges", & do_debug_aranges
},
2843 { "frames", & do_debug_frames
},
2844 { "frames-interp", & do_debug_frames_interp
},
2845 { "info", & do_debug_info
},
2846 { "line", & do_debug_lines
},
2847 { "loc", & do_debug_loc
},
2848 { "macro", & do_debug_macinfo
},
2849 { "pubnames", & do_debug_pubnames
},
2850 /* This entry is for compatability
2851 with earlier versions of readelf. */
2852 { "ranges", & do_debug_aranges
},
2853 { "str", & do_debug_str
},
2864 debug_dump_long_opts
* entry
;
2866 for (entry
= opts_table
; entry
->option
; entry
++)
2868 size_t len
= strlen (entry
->option
);
2870 if (strneq (p
, entry
->option
, len
)
2871 && (p
[len
] == ',' || p
[len
] == '\0'))
2873 * entry
->variable
= 1;
2875 /* The --debug-dump=frames-interp option also
2876 enables the --debug-dump=frames option. */
2877 if (do_debug_frames_interp
)
2878 do_debug_frames
= 1;
2885 if (entry
->option
== NULL
)
2887 warn (_("Unrecognized debug option '%s'\n"), p
);
2888 p
= strchr (p
, ',');
2898 #ifdef SUPPORT_DISASSEMBLY
2901 section
= strtoul (optarg
, & cp
, 0);
2902 if (! *cp
&& section
>= 0)
2904 request_dump (section
, DISASS_DUMP
);
2910 print_version (program_name
);
2920 /* xgettext:c-format */
2921 error (_("Invalid option '-%c'\n"), c
);
2928 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2929 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2930 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2931 && !do_section_groups
)
2935 warn (_("Nothing to do.\n"));
2941 get_elf_class (unsigned int elf_class
)
2943 static char buff
[32];
2947 case ELFCLASSNONE
: return _("none");
2948 case ELFCLASS32
: return "ELF32";
2949 case ELFCLASS64
: return "ELF64";
2951 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2957 get_data_encoding (unsigned int encoding
)
2959 static char buff
[32];
2963 case ELFDATANONE
: return _("none");
2964 case ELFDATA2LSB
: return _("2's complement, little endian");
2965 case ELFDATA2MSB
: return _("2's complement, big endian");
2967 sprintf (buff
, _("<unknown: %x>"), encoding
);
2972 /* Decode the data held in 'elf_header'. */
2975 process_file_header (void)
2977 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2978 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2979 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2980 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2983 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2991 printf (_("ELF Header:\n"));
2992 printf (_(" Magic: "));
2993 for (i
= 0; i
< EI_NIDENT
; i
++)
2994 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2996 printf (_(" Class: %s\n"),
2997 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2998 printf (_(" Data: %s\n"),
2999 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3000 printf (_(" Version: %d %s\n"),
3001 elf_header
.e_ident
[EI_VERSION
],
3002 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3004 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3007 printf (_(" OS/ABI: %s\n"),
3008 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3009 printf (_(" ABI Version: %d\n"),
3010 elf_header
.e_ident
[EI_ABIVERSION
]);
3011 printf (_(" Type: %s\n"),
3012 get_file_type (elf_header
.e_type
));
3013 printf (_(" Machine: %s\n"),
3014 get_machine_name (elf_header
.e_machine
));
3015 printf (_(" Version: 0x%lx\n"),
3016 (unsigned long) elf_header
.e_version
);
3018 printf (_(" Entry point address: "));
3019 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3020 printf (_("\n Start of program headers: "));
3021 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3022 printf (_(" (bytes into file)\n Start of section headers: "));
3023 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3024 printf (_(" (bytes into file)\n"));
3026 printf (_(" Flags: 0x%lx%s\n"),
3027 (unsigned long) elf_header
.e_flags
,
3028 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3029 printf (_(" Size of this header: %ld (bytes)\n"),
3030 (long) elf_header
.e_ehsize
);
3031 printf (_(" Size of program headers: %ld (bytes)\n"),
3032 (long) elf_header
.e_phentsize
);
3033 printf (_(" Number of program headers: %ld\n"),
3034 (long) elf_header
.e_phnum
);
3035 printf (_(" Size of section headers: %ld (bytes)\n"),
3036 (long) elf_header
.e_shentsize
);
3037 printf (_(" Number of section headers: %ld"),
3038 (long) elf_header
.e_shnum
);
3039 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3040 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3041 putc ('\n', stdout
);
3042 printf (_(" Section header string table index: %ld"),
3043 (long) elf_header
.e_shstrndx
);
3044 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3045 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3046 putc ('\n', stdout
);
3049 if (section_headers
!= NULL
)
3051 if (elf_header
.e_shnum
== 0)
3052 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3053 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3054 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3055 free (section_headers
);
3056 section_headers
= NULL
;
3064 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3066 Elf32_External_Phdr
*phdrs
;
3067 Elf32_External_Phdr
*external
;
3068 Elf_Internal_Phdr
*internal
;
3071 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3072 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3073 _("program headers"));
3077 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3078 i
< elf_header
.e_phnum
;
3079 i
++, internal
++, external
++)
3081 internal
->p_type
= BYTE_GET (external
->p_type
);
3082 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3083 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3084 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3085 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3086 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3087 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3088 internal
->p_align
= BYTE_GET (external
->p_align
);
3097 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3099 Elf64_External_Phdr
*phdrs
;
3100 Elf64_External_Phdr
*external
;
3101 Elf_Internal_Phdr
*internal
;
3104 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3105 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3106 _("program headers"));
3110 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3111 i
< elf_header
.e_phnum
;
3112 i
++, internal
++, external
++)
3114 internal
->p_type
= BYTE_GET (external
->p_type
);
3115 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3116 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3117 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3118 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3119 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3120 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3121 internal
->p_align
= BYTE_GET (external
->p_align
);
3129 /* Returns 1 if the program headers were read into `program_headers'. */
3132 get_program_headers (FILE *file
)
3134 Elf_Internal_Phdr
*phdrs
;
3136 /* Check cache of prior read. */
3137 if (program_headers
!= NULL
)
3140 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3144 error (_("Out of memory\n"));
3149 ? get_32bit_program_headers (file
, phdrs
)
3150 : get_64bit_program_headers (file
, phdrs
))
3152 program_headers
= phdrs
;
3160 /* Returns 1 if the program headers were loaded. */
3163 process_program_headers (FILE *file
)
3165 Elf_Internal_Phdr
*segment
;
3168 if (elf_header
.e_phnum
== 0)
3171 printf (_("\nThere are no program headers in this file.\n"));
3175 if (do_segments
&& !do_header
)
3177 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3178 printf (_("Entry point "));
3179 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3180 printf (_("\nThere are %d program headers, starting at offset "),
3181 elf_header
.e_phnum
);
3182 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3186 if (! get_program_headers (file
))
3191 if (elf_header
.e_phnum
> 1)
3192 printf (_("\nProgram Headers:\n"));
3194 printf (_("\nProgram Headers:\n"));
3198 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3201 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3205 (_(" Type Offset VirtAddr PhysAddr\n"));
3207 (_(" FileSiz MemSiz Flags Align\n"));
3214 for (i
= 0, segment
= program_headers
;
3215 i
< elf_header
.e_phnum
;
3220 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3224 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3225 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3226 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3227 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3228 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3230 (segment
->p_flags
& PF_R
? 'R' : ' '),
3231 (segment
->p_flags
& PF_W
? 'W' : ' '),
3232 (segment
->p_flags
& PF_X
? 'E' : ' '));
3233 printf ("%#lx", (unsigned long) segment
->p_align
);
3237 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3238 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3241 print_vma (segment
->p_offset
, FULL_HEX
);
3245 print_vma (segment
->p_vaddr
, FULL_HEX
);
3247 print_vma (segment
->p_paddr
, FULL_HEX
);
3250 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3251 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3254 print_vma (segment
->p_filesz
, FULL_HEX
);
3258 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3259 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3262 print_vma (segment
->p_offset
, FULL_HEX
);
3266 (segment
->p_flags
& PF_R
? 'R' : ' '),
3267 (segment
->p_flags
& PF_W
? 'W' : ' '),
3268 (segment
->p_flags
& PF_X
? 'E' : ' '));
3270 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3271 printf ("%#lx", (unsigned long) segment
->p_align
);
3274 print_vma (segment
->p_align
, PREFIX_HEX
);
3279 print_vma (segment
->p_offset
, FULL_HEX
);
3281 print_vma (segment
->p_vaddr
, FULL_HEX
);
3283 print_vma (segment
->p_paddr
, FULL_HEX
);
3285 print_vma (segment
->p_filesz
, FULL_HEX
);
3287 print_vma (segment
->p_memsz
, FULL_HEX
);
3289 (segment
->p_flags
& PF_R
? 'R' : ' '),
3290 (segment
->p_flags
& PF_W
? 'W' : ' '),
3291 (segment
->p_flags
& PF_X
? 'E' : ' '));
3292 print_vma (segment
->p_align
, HEX
);
3296 switch (segment
->p_type
)
3300 error (_("more than one dynamic segment\n"));
3302 /* Try to locate the .dynamic section. If there is
3303 a section header table, we can easily locate it. */
3304 if (section_headers
!= NULL
)
3306 Elf_Internal_Shdr
*sec
;
3308 sec
= find_section (".dynamic");
3309 if (sec
== NULL
|| sec
->sh_size
== 0)
3311 error (_("no .dynamic section in the dynamic segment"));
3315 dynamic_addr
= sec
->sh_offset
;
3316 dynamic_size
= sec
->sh_size
;
3318 if (dynamic_addr
< segment
->p_offset
3319 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3320 warn (_("the .dynamic section is not contained within the dynamic segment"));
3321 else if (dynamic_addr
> segment
->p_offset
)
3322 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3326 /* Otherwise, we can only assume that the .dynamic
3327 section is the first section in the DYNAMIC segment. */
3328 dynamic_addr
= segment
->p_offset
;
3329 dynamic_size
= segment
->p_filesz
;
3334 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3336 error (_("Unable to find program interpreter name\n"));
3339 program_interpreter
[0] = 0;
3340 fscanf (file
, "%63s", program_interpreter
);
3343 printf (_("\n [Requesting program interpreter: %s]"),
3344 program_interpreter
);
3350 putc ('\n', stdout
);
3353 if (do_segments
&& section_headers
!= NULL
)
3355 printf (_("\n Section to Segment mapping:\n"));
3356 printf (_(" Segment Sections...\n"));
3358 assert (string_table
!= NULL
);
3360 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3363 Elf_Internal_Shdr
*section
;
3365 segment
= program_headers
+ i
;
3366 section
= section_headers
;
3368 printf (" %2.2d ", i
);
3370 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3372 if (section
->sh_size
> 0
3373 /* Compare allocated sections by VMA, unallocated
3374 sections by file offset. */
3375 && (section
->sh_flags
& SHF_ALLOC
3376 ? (section
->sh_addr
>= segment
->p_vaddr
3377 && section
->sh_addr
+ section
->sh_size
3378 <= segment
->p_vaddr
+ segment
->p_memsz
)
3379 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3380 && (section
->sh_offset
+ section
->sh_size
3381 <= segment
->p_offset
+ segment
->p_filesz
)))
3382 /* .tbss is special. It doesn't contribute memory space
3383 to normal segments. */
3384 && (!((section
->sh_flags
& SHF_TLS
) != 0
3385 && section
->sh_type
== SHT_NOBITS
)
3386 || segment
->p_type
== PT_TLS
))
3387 printf ("%s ", SECTION_NAME (section
));
3398 /* Find the file offset corresponding to VMA by using the program headers. */
3401 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3403 Elf_Internal_Phdr
*seg
;
3405 if (! get_program_headers (file
))
3407 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3411 for (seg
= program_headers
;
3412 seg
< program_headers
+ elf_header
.e_phnum
;
3415 if (seg
->p_type
!= PT_LOAD
)
3418 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3419 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3420 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3423 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3430 get_32bit_section_headers (FILE *file
, unsigned int num
)
3432 Elf32_External_Shdr
*shdrs
;
3433 Elf_Internal_Shdr
*internal
;
3436 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3437 elf_header
.e_shentsize
* num
, _("section headers"));
3441 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3443 if (section_headers
== NULL
)
3445 error (_("Out of memory\n"));
3449 for (i
= 0, internal
= section_headers
;
3453 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3454 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3455 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3456 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3457 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3458 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3459 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3460 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3461 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3462 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3471 get_64bit_section_headers (FILE *file
, unsigned int num
)
3473 Elf64_External_Shdr
*shdrs
;
3474 Elf_Internal_Shdr
*internal
;
3477 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3478 elf_header
.e_shentsize
* num
, _("section headers"));
3482 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3484 if (section_headers
== NULL
)
3486 error (_("Out of memory\n"));
3490 for (i
= 0, internal
= section_headers
;
3494 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3495 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3496 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3497 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3498 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3499 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3500 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3501 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3502 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3503 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3511 static Elf_Internal_Sym
*
3512 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3514 unsigned long number
;
3515 Elf32_External_Sym
*esyms
;
3516 Elf_External_Sym_Shndx
*shndx
;
3517 Elf_Internal_Sym
*isyms
;
3518 Elf_Internal_Sym
*psym
;
3521 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3527 if (symtab_shndx_hdr
!= NULL
3528 && (symtab_shndx_hdr
->sh_link
3529 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3531 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3532 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3540 number
= section
->sh_size
/ section
->sh_entsize
;
3541 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3545 error (_("Out of memory\n"));
3552 for (j
= 0, psym
= isyms
;
3556 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3557 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3558 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3559 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3560 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3562 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3563 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3564 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3574 static Elf_Internal_Sym
*
3575 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3577 unsigned long number
;
3578 Elf64_External_Sym
*esyms
;
3579 Elf_External_Sym_Shndx
*shndx
;
3580 Elf_Internal_Sym
*isyms
;
3581 Elf_Internal_Sym
*psym
;
3584 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3590 if (symtab_shndx_hdr
!= NULL
3591 && (symtab_shndx_hdr
->sh_link
3592 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3594 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3595 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3603 number
= section
->sh_size
/ section
->sh_entsize
;
3604 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3608 error (_("Out of memory\n"));
3615 for (j
= 0, psym
= isyms
;
3619 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3620 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3621 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3622 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3623 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3625 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3626 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3627 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3638 get_elf_section_flags (bfd_vma sh_flags
)
3640 static char buff
[32];
3648 flag
= sh_flags
& - sh_flags
;
3653 case SHF_WRITE
: strcat (buff
, "W"); break;
3654 case SHF_ALLOC
: strcat (buff
, "A"); break;
3655 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3656 case SHF_MERGE
: strcat (buff
, "M"); break;
3657 case SHF_STRINGS
: strcat (buff
, "S"); break;
3658 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3659 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3660 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3661 case SHF_GROUP
: strcat (buff
, "G"); break;
3662 case SHF_TLS
: strcat (buff
, "T"); break;
3665 if (flag
& SHF_MASKOS
)
3668 sh_flags
&= ~ SHF_MASKOS
;
3670 else if (flag
& SHF_MASKPROC
)
3673 sh_flags
&= ~ SHF_MASKPROC
;
3685 process_section_headers (FILE *file
)
3687 Elf_Internal_Shdr
*section
;
3690 section_headers
= NULL
;
3692 if (elf_header
.e_shnum
== 0)
3695 printf (_("\nThere are no sections in this file.\n"));
3700 if (do_sections
&& !do_header
)
3701 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3702 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3706 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3709 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3712 /* Read in the string table, so that we have names to display. */
3713 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3715 if (section
->sh_size
!= 0)
3717 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3718 section
->sh_size
, _("string table"));
3720 if (string_table
== NULL
)
3723 string_table_length
= section
->sh_size
;
3726 /* Scan the sections for the dynamic symbol table
3727 and dynamic string table and debug sections. */
3728 dynamic_symbols
= NULL
;
3729 dynamic_strings
= NULL
;
3730 dynamic_syminfo
= NULL
;
3731 symtab_shndx_hdr
= NULL
;
3733 eh_addr_size
= is_32bit_elf
? 4 : 8;
3734 switch (elf_header
.e_machine
)
3737 case EM_MIPS_RS3_LE
:
3738 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3739 FDE addresses. However, the ABI also has a semi-official ILP32
3740 variant for which the normal FDE address size rules apply.
3742 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3743 section, where XX is the size of longs in bits. Unfortunately,
3744 earlier compilers provided no way of distinguishing ILP32 objects
3745 from LP64 objects, so if there's any doubt, we should assume that
3746 the official LP64 form is being used. */
3747 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3748 && find_section (".gcc_compiled_long32") == NULL
)
3753 for (i
= 0, section
= section_headers
;
3754 i
< elf_header
.e_shnum
;
3757 char *name
= SECTION_NAME (section
);
3759 if (section
->sh_type
== SHT_DYNSYM
)
3761 if (dynamic_symbols
!= NULL
)
3763 error (_("File contains multiple dynamic symbol tables\n"));
3767 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3768 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3770 else if (section
->sh_type
== SHT_STRTAB
3771 && streq (name
, ".dynstr"))
3773 if (dynamic_strings
!= NULL
)
3775 error (_("File contains multiple dynamic string tables\n"));
3779 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3780 section
->sh_size
, _("dynamic strings"));
3781 dynamic_strings_length
= section
->sh_size
;
3783 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3785 if (symtab_shndx_hdr
!= NULL
)
3787 error (_("File contains multiple symtab shndx tables\n"));
3790 symtab_shndx_hdr
= section
;
3792 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3793 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3794 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3795 || do_debug_loc
|| do_debug_ranges
)
3796 && strneq (name
, ".debug_", 7))
3801 || (do_debug_info
&& streq (name
, "info"))
3802 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3803 || (do_debug_lines
&& streq (name
, "line"))
3804 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3805 || (do_debug_aranges
&& streq (name
, "aranges"))
3806 || (do_debug_ranges
&& streq (name
, "ranges"))
3807 || (do_debug_frames
&& streq (name
, "frame"))
3808 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3809 || (do_debug_str
&& streq (name
, "str"))
3810 || (do_debug_loc
&& streq (name
, "loc"))
3812 request_dump (i
, DEBUG_DUMP
);
3814 /* linkonce section to be combined with .debug_info at link time. */
3815 else if ((do_debugging
|| do_debug_info
)
3816 && strneq (name
, ".gnu.linkonce.wi.", 17))
3817 request_dump (i
, DEBUG_DUMP
);
3818 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3819 request_dump (i
, DEBUG_DUMP
);
3825 if (elf_header
.e_shnum
> 1)
3826 printf (_("\nSection Headers:\n"));
3828 printf (_("\nSection Header:\n"));
3832 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3835 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3838 printf (_(" [Nr] Name Type Address Offset\n"));
3839 printf (_(" Size EntSize Flags Link Info Align\n"));
3842 for (i
= 0, section
= section_headers
;
3843 i
< elf_header
.e_shnum
;
3846 printf (" [%2u] %-17.17s %-15.15s ",
3847 SECTION_HEADER_NUM (i
),
3848 SECTION_NAME (section
),
3849 get_section_type_name (section
->sh_type
));
3853 print_vma (section
->sh_addr
, LONG_HEX
);
3855 printf ( " %6.6lx %6.6lx %2.2lx",
3856 (unsigned long) section
->sh_offset
,
3857 (unsigned long) section
->sh_size
,
3858 (unsigned long) section
->sh_entsize
);
3860 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3862 printf ("%2ld %3lu %2ld\n",
3863 (unsigned long) section
->sh_link
,
3864 (unsigned long) section
->sh_info
,
3865 (unsigned long) section
->sh_addralign
);
3869 print_vma (section
->sh_addr
, LONG_HEX
);
3871 if ((long) section
->sh_offset
== section
->sh_offset
)
3872 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3876 print_vma (section
->sh_offset
, LONG_HEX
);
3879 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3880 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3884 print_vma (section
->sh_size
, LONG_HEX
);
3887 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3888 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3892 print_vma (section
->sh_entsize
, LONG_HEX
);
3895 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3897 printf ("%2ld %3lu ",
3898 (unsigned long) section
->sh_link
,
3899 (unsigned long) section
->sh_info
);
3901 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3902 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3905 print_vma (section
->sh_addralign
, DEC
);
3912 print_vma (section
->sh_addr
, LONG_HEX
);
3913 if ((long) section
->sh_offset
== section
->sh_offset
)
3914 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3918 print_vma (section
->sh_offset
, LONG_HEX
);
3921 print_vma (section
->sh_size
, LONG_HEX
);
3923 print_vma (section
->sh_entsize
, LONG_HEX
);
3925 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3927 printf (" %2ld %3lu %ld\n",
3928 (unsigned long) section
->sh_link
,
3929 (unsigned long) section
->sh_info
,
3930 (unsigned long) section
->sh_addralign
);
3934 printf (_("Key to Flags:\n\
3935 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3936 I (info), L (link order), G (group), x (unknown)\n\
3937 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3943 get_group_flags (unsigned int flags
)
3945 static char buff
[32];
3952 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3959 process_section_groups (FILE *file
)
3961 Elf_Internal_Shdr
*section
;
3963 struct group
*group
;
3964 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
3965 Elf_Internal_Sym
*symtab
;
3968 /* Don't process section groups unless needed. */
3969 if (!do_unwind
&& !do_section_groups
)
3972 if (elf_header
.e_shnum
== 0)
3974 if (do_section_groups
)
3975 printf (_("\nThere are no sections in this file.\n"));
3980 if (section_headers
== NULL
)
3982 error (_("Section headers are not available!\n"));
3986 section_headers_groups
= calloc (elf_header
.e_shnum
,
3987 sizeof (struct group
*));
3989 if (section_headers_groups
== NULL
)
3991 error (_("Out of memory\n"));
3995 /* Scan the sections for the group section. */
3997 for (i
= 0, section
= section_headers
;
3998 i
< elf_header
.e_shnum
;
4000 if (section
->sh_type
== SHT_GROUP
)
4003 if (group_count
== 0)
4005 if (do_section_groups
)
4006 printf (_("\nThere are no section groups in this file.\n"));
4011 section_groups
= calloc (group_count
, sizeof (struct group
));
4013 if (section_groups
== NULL
)
4015 error (_("Out of memory\n"));
4023 for (i
= 0, section
= section_headers
, group
= section_groups
;
4024 i
< elf_header
.e_shnum
;
4027 if (section
->sh_type
== SHT_GROUP
)
4029 char *name
= SECTION_NAME (section
);
4030 char *group_name
, *start
, *indices
;
4031 unsigned int entry
, j
, size
;
4032 Elf_Internal_Shdr
*sec
;
4033 Elf_Internal_Sym
*sym
;
4035 /* Get the symbol table. */
4036 sec
= SECTION_HEADER (section
->sh_link
);
4037 if (sec
->sh_type
!= SHT_SYMTAB
)
4039 error (_("Bad sh_link in group section `%s'\n"), name
);
4043 if (symtab_sec
!= sec
)
4048 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4051 sym
= symtab
+ section
->sh_info
;
4053 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4055 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4058 error (_("Bad sh_info in group section `%s'\n"), name
);
4062 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4067 /* Get the string table. */
4068 sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4069 if (strtab_sec
!= sec
)
4074 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4075 strtab_sec
->sh_size
,
4078 group_name
= strtab
+ sym
->st_name
;
4081 start
= get_data (NULL
, file
, section
->sh_offset
,
4082 section
->sh_size
, _("section data"));
4085 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4086 entry
= byte_get (indices
, 4);
4089 if (do_section_groups
)
4091 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4092 get_group_flags (entry
), name
, group_name
, size
);
4094 printf (_(" [Index] Name\n"));
4097 group
->group_index
= i
;
4099 for (j
= 0; j
< size
; j
++)
4101 struct group_list
*g
;
4103 entry
= byte_get (indices
, 4);
4106 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4111 error (_("section [%5u] already in group section [%5u]\n"),
4113 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4118 /* Intel C/C++ compiler may put section 0 in a
4119 section group. We just warn it the first time
4120 and ignore it afterwards. */
4121 static int warned
= 0;
4124 error (_("section 0 in group section [%5u]\n"),
4125 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4131 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4134 if (do_section_groups
)
4136 sec
= SECTION_HEADER (entry
);
4137 printf (" [%5u] %s\n",
4138 entry
, SECTION_NAME (sec
));
4141 g
= xmalloc (sizeof (struct group_list
));
4142 g
->section_index
= entry
;
4143 g
->next
= group
->root
;
4167 } dynamic_relocations
[] =
4169 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4170 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4171 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4174 /* Process the reloc section. */
4177 process_relocs (FILE *file
)
4179 unsigned long rel_size
;
4180 unsigned long rel_offset
;
4186 if (do_using_dynamic
)
4190 int has_dynamic_reloc
;
4193 has_dynamic_reloc
= 0;
4195 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4197 is_rela
= dynamic_relocations
[i
].rela
;
4198 name
= dynamic_relocations
[i
].name
;
4199 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4200 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4202 has_dynamic_reloc
|= rel_size
;
4204 if (is_rela
== UNKNOWN
)
4206 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4207 switch (dynamic_info
[DT_PLTREL
])
4221 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4222 name
, rel_offset
, rel_size
);
4224 dump_relocations (file
,
4225 offset_from_vma (file
, rel_offset
, rel_size
),
4227 dynamic_symbols
, num_dynamic_syms
,
4228 dynamic_strings
, dynamic_strings_length
, is_rela
);
4232 if (! has_dynamic_reloc
)
4233 printf (_("\nThere are no dynamic relocations in this file.\n"));
4237 Elf_Internal_Shdr
*section
;
4241 for (i
= 0, section
= section_headers
;
4242 i
< elf_header
.e_shnum
;
4245 if ( section
->sh_type
!= SHT_RELA
4246 && section
->sh_type
!= SHT_REL
)
4249 rel_offset
= section
->sh_offset
;
4250 rel_size
= section
->sh_size
;
4254 Elf_Internal_Shdr
*strsec
;
4257 printf (_("\nRelocation section "));
4259 if (string_table
== NULL
)
4260 printf ("%d", section
->sh_name
);
4262 printf (_("'%s'"), SECTION_NAME (section
));
4264 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4265 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4267 is_rela
= section
->sh_type
== SHT_RELA
;
4269 if (section
->sh_link
)
4271 Elf_Internal_Shdr
*symsec
;
4272 Elf_Internal_Sym
*symtab
;
4273 unsigned long nsyms
;
4274 unsigned long strtablen
;
4275 char *strtab
= NULL
;
4277 symsec
= SECTION_HEADER (section
->sh_link
);
4278 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4279 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4284 strsec
= SECTION_HEADER (symsec
->sh_link
);
4286 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4287 strsec
->sh_size
, _("string table"));
4288 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4290 dump_relocations (file
, rel_offset
, rel_size
,
4291 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4297 dump_relocations (file
, rel_offset
, rel_size
,
4298 NULL
, 0, NULL
, 0, is_rela
);
4305 printf (_("\nThere are no relocations in this file.\n"));
4311 /* Process the unwind section. */
4313 #include "unwind-ia64.h"
4315 /* An absolute address consists of a section and an offset. If the
4316 section is NULL, the offset itself is the address, otherwise, the
4317 address equals to LOAD_ADDRESS(section) + offset. */
4321 unsigned short section
;
4325 struct ia64_unw_aux_info
4327 struct ia64_unw_table_entry
4329 struct absaddr start
;
4331 struct absaddr info
;
4333 *table
; /* Unwind table. */
4334 unsigned long table_len
; /* Length of unwind table. */
4335 unsigned char *info
; /* Unwind info. */
4336 unsigned long info_size
; /* Size of unwind info. */
4337 bfd_vma info_addr
; /* starting address of unwind info. */
4338 bfd_vma seg_base
; /* Starting address of segment. */
4339 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4340 unsigned long nsyms
; /* Number of symbols. */
4341 char *strtab
; /* The string table. */
4342 unsigned long strtab_size
; /* Size of string table. */
4346 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4347 unsigned long nsyms
,
4349 unsigned long strtab_size
,
4350 struct absaddr addr
,
4351 const char **symname
,
4354 bfd_vma dist
= 0x100000;
4355 Elf_Internal_Sym
*sym
, *best
= NULL
;
4358 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4360 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4361 && sym
->st_name
!= 0
4362 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4363 && addr
.offset
>= sym
->st_value
4364 && addr
.offset
- sym
->st_value
< dist
)
4367 dist
= addr
.offset
- sym
->st_value
;
4374 *symname
= (best
->st_name
>= strtab_size
4375 ? "<corrupt>" : strtab
+ best
->st_name
);
4380 *offset
= addr
.offset
;
4384 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4386 struct ia64_unw_table_entry
*tp
;
4389 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4393 const unsigned char *dp
;
4394 const unsigned char *head
;
4395 const char *procname
;
4397 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4398 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4400 fputs ("\n<", stdout
);
4404 fputs (procname
, stdout
);
4407 printf ("+%lx", (unsigned long) offset
);
4410 fputs (">: [", stdout
);
4411 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4412 fputc ('-', stdout
);
4413 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4414 printf ("], info at +0x%lx\n",
4415 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4417 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4418 stamp
= BYTE_GET ((unsigned char *) head
);
4420 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4421 (unsigned) UNW_VER (stamp
),
4422 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4423 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4424 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4425 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4427 if (UNW_VER (stamp
) != 1)
4429 printf ("\tUnknown version.\n");
4434 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4435 dp
= unw_decode (dp
, in_body
, & in_body
);
4440 slurp_ia64_unwind_table (FILE *file
,
4441 struct ia64_unw_aux_info
*aux
,
4442 Elf_Internal_Shdr
*sec
)
4444 unsigned long size
, nrelas
, i
;
4445 Elf_Internal_Phdr
*seg
;
4446 struct ia64_unw_table_entry
*tep
;
4447 Elf_Internal_Shdr
*relsec
;
4448 Elf_Internal_Rela
*rela
, *rp
;
4449 unsigned char *table
, *tp
;
4450 Elf_Internal_Sym
*sym
;
4451 const char *relname
;
4453 /* First, find the starting address of the segment that includes
4456 if (elf_header
.e_phnum
)
4458 if (! get_program_headers (file
))
4461 for (seg
= program_headers
;
4462 seg
< program_headers
+ elf_header
.e_phnum
;
4465 if (seg
->p_type
!= PT_LOAD
)
4468 if (sec
->sh_addr
>= seg
->p_vaddr
4469 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4471 aux
->seg_base
= seg
->p_vaddr
;
4477 /* Second, build the unwind table from the contents of the unwind section: */
4478 size
= sec
->sh_size
;
4479 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4483 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4485 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4487 tep
->start
.section
= SHN_UNDEF
;
4488 tep
->end
.section
= SHN_UNDEF
;
4489 tep
->info
.section
= SHN_UNDEF
;
4492 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4493 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4494 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4498 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4499 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4500 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4502 tep
->start
.offset
+= aux
->seg_base
;
4503 tep
->end
.offset
+= aux
->seg_base
;
4504 tep
->info
.offset
+= aux
->seg_base
;
4508 /* Third, apply any relocations to the unwind table: */
4510 for (relsec
= section_headers
;
4511 relsec
< section_headers
+ elf_header
.e_shnum
;
4514 if (relsec
->sh_type
!= SHT_RELA
4515 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4518 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4522 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4526 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4527 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4531 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4532 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4535 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4537 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4541 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4543 switch (rp
->r_offset
/eh_addr_size
% 3)
4546 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4547 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4550 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4551 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4554 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4555 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4565 aux
->table_len
= size
/ (3 * eh_addr_size
);
4570 ia64_process_unwind (FILE *file
)
4572 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4573 unsigned long i
, unwcount
= 0, unwstart
= 0;
4574 struct ia64_unw_aux_info aux
;
4576 memset (& aux
, 0, sizeof (aux
));
4578 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4580 if (sec
->sh_type
== SHT_SYMTAB
)
4582 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4583 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4585 strsec
= SECTION_HEADER (sec
->sh_link
);
4586 aux
.strtab_size
= strsec
->sh_size
;
4587 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4588 aux
.strtab_size
, _("string table"));
4590 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4595 printf (_("\nThere are no unwind sections in this file.\n"));
4597 while (unwcount
-- > 0)
4602 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4603 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4604 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4611 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4613 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4615 /* We need to find which section group it is in. */
4616 struct group_list
*g
= section_headers_groups
[i
]->root
;
4618 for (; g
!= NULL
; g
= g
->next
)
4620 sec
= SECTION_HEADER (g
->section_index
);
4622 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4627 i
= elf_header
.e_shnum
;
4629 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4631 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4632 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4633 suffix
= SECTION_NAME (unwsec
) + len
;
4634 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4636 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4637 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4642 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4643 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4644 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4645 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4647 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4648 suffix
= SECTION_NAME (unwsec
) + len
;
4649 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4651 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4652 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4656 if (i
== elf_header
.e_shnum
)
4658 printf (_("\nCould not find unwind info section for "));
4660 if (string_table
== NULL
)
4661 printf ("%d", unwsec
->sh_name
);
4663 printf (_("'%s'"), SECTION_NAME (unwsec
));
4667 aux
.info_size
= sec
->sh_size
;
4668 aux
.info_addr
= sec
->sh_addr
;
4669 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4672 printf (_("\nUnwind section "));
4674 if (string_table
== NULL
)
4675 printf ("%d", unwsec
->sh_name
);
4677 printf (_("'%s'"), SECTION_NAME (unwsec
));
4679 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4680 (unsigned long) unwsec
->sh_offset
,
4681 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4683 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4685 if (aux
.table_len
> 0)
4686 dump_ia64_unwind (& aux
);
4689 free ((char *) aux
.table
);
4691 free ((char *) aux
.info
);
4700 free ((char *) aux
.strtab
);
4705 struct hppa_unw_aux_info
4707 struct hppa_unw_table_entry
4709 struct absaddr start
;
4711 unsigned int Cannot_unwind
:1; /* 0 */
4712 unsigned int Millicode
:1; /* 1 */
4713 unsigned int Millicode_save_sr0
:1; /* 2 */
4714 unsigned int Region_description
:2; /* 3..4 */
4715 unsigned int reserved1
:1; /* 5 */
4716 unsigned int Entry_SR
:1; /* 6 */
4717 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4718 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4719 unsigned int Args_stored
:1; /* 16 */
4720 unsigned int Variable_Frame
:1; /* 17 */
4721 unsigned int Separate_Package_Body
:1; /* 18 */
4722 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4723 unsigned int Stack_Overflow_Check
:1; /* 20 */
4724 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4725 unsigned int Ada_Region
:1; /* 22 */
4726 unsigned int cxx_info
:1; /* 23 */
4727 unsigned int cxx_try_catch
:1; /* 24 */
4728 unsigned int sched_entry_seq
:1; /* 25 */
4729 unsigned int reserved2
:1; /* 26 */
4730 unsigned int Save_SP
:1; /* 27 */
4731 unsigned int Save_RP
:1; /* 28 */
4732 unsigned int Save_MRP_in_frame
:1; /* 29 */
4733 unsigned int extn_ptr_defined
:1; /* 30 */
4734 unsigned int Cleanup_defined
:1; /* 31 */
4736 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4737 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4738 unsigned int Large_frame
:1; /* 2 */
4739 unsigned int Pseudo_SP_Set
:1; /* 3 */
4740 unsigned int reserved4
:1; /* 4 */
4741 unsigned int Total_frame_size
:27; /* 5..31 */
4743 *table
; /* Unwind table. */
4744 unsigned long table_len
; /* Length of unwind table. */
4745 bfd_vma seg_base
; /* Starting address of segment. */
4746 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4747 unsigned long nsyms
; /* Number of symbols. */
4748 char *strtab
; /* The string table. */
4749 unsigned long strtab_size
; /* Size of string table. */
4753 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4755 struct hppa_unw_table_entry
*tp
;
4757 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4760 const char *procname
;
4762 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4763 aux
->strtab_size
, tp
->start
, &procname
,
4766 fputs ("\n<", stdout
);
4770 fputs (procname
, stdout
);
4773 printf ("+%lx", (unsigned long) offset
);
4776 fputs (">: [", stdout
);
4777 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4778 fputc ('-', stdout
);
4779 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4782 #define PF(_m) if (tp->_m) printf (#_m " ");
4783 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4786 PF(Millicode_save_sr0
);
4787 /* PV(Region_description); */
4793 PF(Separate_Package_Body
);
4794 PF(Frame_Extension_Millicode
);
4795 PF(Stack_Overflow_Check
);
4796 PF(Two_Instruction_SP_Increment
);
4800 PF(sched_entry_seq
);
4803 PF(Save_MRP_in_frame
);
4804 PF(extn_ptr_defined
);
4805 PF(Cleanup_defined
);
4806 PF(MPE_XL_interrupt_marker
);
4807 PF(HP_UX_interrupt_marker
);
4810 PV(Total_frame_size
);
4819 slurp_hppa_unwind_table (FILE *file
,
4820 struct hppa_unw_aux_info
*aux
,
4821 Elf_Internal_Shdr
*sec
)
4823 unsigned long size
, unw_ent_size
, nrelas
, i
;
4824 Elf_Internal_Phdr
*seg
;
4825 struct hppa_unw_table_entry
*tep
;
4826 Elf_Internal_Shdr
*relsec
;
4827 Elf_Internal_Rela
*rela
, *rp
;
4828 unsigned char *table
, *tp
;
4829 Elf_Internal_Sym
*sym
;
4830 const char *relname
;
4832 /* First, find the starting address of the segment that includes
4835 if (elf_header
.e_phnum
)
4837 if (! get_program_headers (file
))
4840 for (seg
= program_headers
;
4841 seg
< program_headers
+ elf_header
.e_phnum
;
4844 if (seg
->p_type
!= PT_LOAD
)
4847 if (sec
->sh_addr
>= seg
->p_vaddr
4848 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4850 aux
->seg_base
= seg
->p_vaddr
;
4856 /* Second, build the unwind table from the contents of the unwind
4858 size
= sec
->sh_size
;
4859 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4863 unw_ent_size
= 2 * eh_addr_size
+ 8;
4865 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4867 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
4869 unsigned int tmp1
, tmp2
;
4871 tep
->start
.section
= SHN_UNDEF
;
4872 tep
->end
.section
= SHN_UNDEF
;
4876 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4877 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4878 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4879 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4883 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4884 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4885 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4886 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
4889 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
4890 tep
->Millicode
= (tmp1
>> 30) & 0x1;
4891 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
4892 tep
->Region_description
= (tmp1
>> 27) & 0x3;
4893 tep
->reserved1
= (tmp1
>> 26) & 0x1;
4894 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
4895 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
4896 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
4897 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
4898 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
4899 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
4900 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
4901 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
4902 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
4903 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
4904 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
4905 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
4906 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
4907 tep
->reserved2
= (tmp1
>> 5) & 0x1;
4908 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
4909 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
4910 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
4911 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
4912 tep
->Cleanup_defined
= tmp1
& 0x1;
4914 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
4915 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
4916 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
4917 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
4918 tep
->reserved4
= (tmp2
>> 27) & 0x1;
4919 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
4921 tep
->start
.offset
+= aux
->seg_base
;
4922 tep
->end
.offset
+= aux
->seg_base
;
4926 /* Third, apply any relocations to the unwind table. */
4928 for (relsec
= section_headers
;
4929 relsec
< section_headers
+ elf_header
.e_shnum
;
4932 if (relsec
->sh_type
!= SHT_RELA
4933 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4936 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4940 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4944 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4945 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4949 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4950 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4953 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
4954 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
4956 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4960 i
= rp
->r_offset
/ unw_ent_size
;
4962 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
4965 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4966 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
4969 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4970 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
4980 aux
->table_len
= size
/ unw_ent_size
;
4986 hppa_process_unwind (FILE *file
)
4988 struct hppa_unw_aux_info aux
;
4989 Elf_Internal_Shdr
*unwsec
= NULL
;
4990 Elf_Internal_Shdr
*strsec
;
4991 Elf_Internal_Shdr
*sec
;
4994 memset (& aux
, 0, sizeof (aux
));
4996 assert (string_table
!= NULL
);
4998 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5000 if (sec
->sh_type
== SHT_SYMTAB
)
5002 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5003 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5005 strsec
= SECTION_HEADER (sec
->sh_link
);
5006 aux
.strtab_size
= strsec
->sh_size
;
5007 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5008 aux
.strtab_size
, _("string table"));
5010 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5015 printf (_("\nThere are no unwind sections in this file.\n"));
5017 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5019 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5021 printf (_("\nUnwind section "));
5022 printf (_("'%s'"), SECTION_NAME (sec
));
5024 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5025 (unsigned long) sec
->sh_offset
,
5026 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5028 slurp_hppa_unwind_table (file
, &aux
, sec
);
5029 if (aux
.table_len
> 0)
5030 dump_hppa_unwind (&aux
);
5033 free ((char *) aux
.table
);
5041 free ((char *) aux
.strtab
);
5047 process_unwind (FILE *file
)
5049 struct unwind_handler
{
5051 int (*handler
)(FILE *file
);
5053 { EM_IA_64
, ia64_process_unwind
},
5054 { EM_PARISC
, hppa_process_unwind
},
5062 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5063 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5064 return handlers
[i
].handler (file
);
5066 printf (_("\nThere are no unwind sections in this file.\n"));
5071 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5073 switch (entry
->d_tag
)
5076 if (entry
->d_un
.d_val
== 0)
5080 static const char * opts
[] =
5082 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5083 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5084 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5085 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5090 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5091 if (entry
->d_un
.d_val
& (1 << cnt
))
5093 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5100 case DT_MIPS_IVERSION
:
5101 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5102 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5104 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5107 case DT_MIPS_TIME_STAMP
:
5112 time_t time
= entry
->d_un
.d_val
;
5113 tmp
= gmtime (&time
);
5114 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
5115 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5116 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5117 printf ("Time Stamp: %s\n", timebuf
);
5121 case DT_MIPS_RLD_VERSION
:
5122 case DT_MIPS_LOCAL_GOTNO
:
5123 case DT_MIPS_CONFLICTNO
:
5124 case DT_MIPS_LIBLISTNO
:
5125 case DT_MIPS_SYMTABNO
:
5126 case DT_MIPS_UNREFEXTNO
:
5127 case DT_MIPS_HIPAGENO
:
5128 case DT_MIPS_DELTA_CLASS_NO
:
5129 case DT_MIPS_DELTA_INSTANCE_NO
:
5130 case DT_MIPS_DELTA_RELOC_NO
:
5131 case DT_MIPS_DELTA_SYM_NO
:
5132 case DT_MIPS_DELTA_CLASSSYM_NO
:
5133 case DT_MIPS_COMPACT_SIZE
:
5134 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5138 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5144 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5146 switch (entry
->d_tag
)
5148 case DT_HP_DLD_FLAGS
:
5157 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5158 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5159 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5160 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5161 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5162 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5163 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5164 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5165 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5166 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5167 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5171 bfd_vma val
= entry
->d_un
.d_val
;
5173 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5174 if (val
& flags
[cnt
].bit
)
5178 fputs (flags
[cnt
].str
, stdout
);
5180 val
^= flags
[cnt
].bit
;
5183 if (val
!= 0 || first
)
5187 print_vma (val
, HEX
);
5193 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5200 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5202 switch (entry
->d_tag
)
5204 case DT_IA_64_PLT_RESERVE
:
5205 /* First 3 slots reserved. */
5206 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5208 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5212 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5219 get_32bit_dynamic_section (FILE *file
)
5221 Elf32_External_Dyn
*edyn
, *ext
;
5222 Elf_Internal_Dyn
*entry
;
5224 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5225 _("dynamic section"));
5229 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5230 might not have the luxury of section headers. Look for the DT_NULL
5231 terminator to determine the number of entries. */
5232 for (ext
= edyn
, dynamic_nent
= 0;
5233 (char *) ext
< (char *) edyn
+ dynamic_size
;
5237 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5241 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5242 if (dynamic_section
== NULL
)
5244 error (_("Out of memory\n"));
5249 for (ext
= edyn
, entry
= dynamic_section
;
5250 entry
< dynamic_section
+ dynamic_nent
;
5253 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5254 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5263 get_64bit_dynamic_section (FILE *file
)
5265 Elf64_External_Dyn
*edyn
, *ext
;
5266 Elf_Internal_Dyn
*entry
;
5268 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5269 _("dynamic section"));
5273 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5274 might not have the luxury of section headers. Look for the DT_NULL
5275 terminator to determine the number of entries. */
5276 for (ext
= edyn
, dynamic_nent
= 0;
5277 (char *) ext
< (char *) edyn
+ dynamic_size
;
5281 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5285 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5286 if (dynamic_section
== NULL
)
5288 error (_("Out of memory\n"));
5293 for (ext
= edyn
, entry
= dynamic_section
;
5294 entry
< dynamic_section
+ dynamic_nent
;
5297 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5298 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5307 get_dynamic_flags (bfd_vma flags
)
5309 static char buff
[128];
5317 flag
= flags
& - flags
;
5325 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
5326 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
5327 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
5328 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
5329 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
5330 default: strcpy (p
, "unknown"); break;
5333 p
= strchr (p
, '\0');
5338 /* Parse and display the contents of the dynamic section. */
5341 process_dynamic_section (FILE *file
)
5343 Elf_Internal_Dyn
*entry
;
5345 if (dynamic_size
== 0)
5348 printf (_("\nThere is no dynamic section in this file.\n"));
5355 if (! get_32bit_dynamic_section (file
))
5358 else if (! get_64bit_dynamic_section (file
))
5361 /* Find the appropriate symbol table. */
5362 if (dynamic_symbols
== NULL
)
5364 for (entry
= dynamic_section
;
5365 entry
< dynamic_section
+ dynamic_nent
;
5368 Elf_Internal_Shdr section
;
5370 if (entry
->d_tag
!= DT_SYMTAB
)
5373 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5375 /* Since we do not know how big the symbol table is,
5376 we default to reading in the entire file (!) and
5377 processing that. This is overkill, I know, but it
5379 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5381 if (archive_file_offset
!= 0)
5382 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5385 if (fseek (file
, 0, SEEK_END
))
5386 error (_("Unable to seek to end of file!"));
5388 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5392 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5394 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5396 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5397 if (num_dynamic_syms
< 1)
5399 error (_("Unable to determine the number of symbols to load\n"));
5403 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5407 /* Similarly find a string table. */
5408 if (dynamic_strings
== NULL
)
5410 for (entry
= dynamic_section
;
5411 entry
< dynamic_section
+ dynamic_nent
;
5414 unsigned long offset
;
5417 if (entry
->d_tag
!= DT_STRTAB
)
5420 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5422 /* Since we do not know how big the string table is,
5423 we default to reading in the entire file (!) and
5424 processing that. This is overkill, I know, but it
5427 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5429 if (archive_file_offset
!= 0)
5430 str_tab_len
= archive_file_size
- offset
;
5433 if (fseek (file
, 0, SEEK_END
))
5434 error (_("Unable to seek to end of file\n"));
5435 str_tab_len
= ftell (file
) - offset
;
5438 if (str_tab_len
< 1)
5441 (_("Unable to determine the length of the dynamic string table\n"));
5445 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5446 _("dynamic string table"));
5447 dynamic_strings_length
= str_tab_len
;
5452 /* And find the syminfo section if available. */
5453 if (dynamic_syminfo
== NULL
)
5455 unsigned long syminsz
= 0;
5457 for (entry
= dynamic_section
;
5458 entry
< dynamic_section
+ dynamic_nent
;
5461 if (entry
->d_tag
== DT_SYMINENT
)
5463 /* Note: these braces are necessary to avoid a syntax
5464 error from the SunOS4 C compiler. */
5465 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5467 else if (entry
->d_tag
== DT_SYMINSZ
)
5468 syminsz
= entry
->d_un
.d_val
;
5469 else if (entry
->d_tag
== DT_SYMINFO
)
5470 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5474 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5476 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5477 Elf_Internal_Syminfo
*syminfo
;
5479 /* There is a syminfo section. Read the data. */
5480 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5481 _("symbol information"));
5485 dynamic_syminfo
= malloc (syminsz
);
5486 if (dynamic_syminfo
== NULL
)
5488 error (_("Out of memory\n"));
5492 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5493 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5494 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5495 ++syminfo
, ++extsym
)
5497 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5498 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5505 if (do_dynamic
&& dynamic_addr
)
5506 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5507 dynamic_addr
, dynamic_nent
);
5509 printf (_(" Tag Type Name/Value\n"));
5511 for (entry
= dynamic_section
;
5512 entry
< dynamic_section
+ dynamic_nent
;
5520 print_vma (entry
->d_tag
, FULL_HEX
);
5521 dtype
= get_dynamic_type (entry
->d_tag
);
5522 printf (" (%s)%*s", dtype
,
5523 ((is_32bit_elf
? 27 : 19)
5524 - (int) strlen (dtype
)),
5528 switch (entry
->d_tag
)
5532 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5542 switch (entry
->d_tag
)
5545 printf (_("Auxiliary library"));
5549 printf (_("Filter library"));
5553 printf (_("Configuration file"));
5557 printf (_("Dependency audit library"));
5561 printf (_("Audit library"));
5565 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5566 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5570 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5579 printf (_("Flags:"));
5581 if (entry
->d_un
.d_val
== 0)
5582 printf (_(" None\n"));
5585 unsigned long int val
= entry
->d_un
.d_val
;
5587 if (val
& DTF_1_PARINIT
)
5589 printf (" PARINIT");
5590 val
^= DTF_1_PARINIT
;
5592 if (val
& DTF_1_CONFEXP
)
5594 printf (" CONFEXP");
5595 val
^= DTF_1_CONFEXP
;
5598 printf (" %lx", val
);
5607 printf (_("Flags:"));
5609 if (entry
->d_un
.d_val
== 0)
5610 printf (_(" None\n"));
5613 unsigned long int val
= entry
->d_un
.d_val
;
5615 if (val
& DF_P1_LAZYLOAD
)
5617 printf (" LAZYLOAD");
5618 val
^= DF_P1_LAZYLOAD
;
5620 if (val
& DF_P1_GROUPPERM
)
5622 printf (" GROUPPERM");
5623 val
^= DF_P1_GROUPPERM
;
5626 printf (" %lx", val
);
5635 printf (_("Flags:"));
5636 if (entry
->d_un
.d_val
== 0)
5637 printf (_(" None\n"));
5640 unsigned long int val
= entry
->d_un
.d_val
;
5647 if (val
& DF_1_GLOBAL
)
5652 if (val
& DF_1_GROUP
)
5657 if (val
& DF_1_NODELETE
)
5659 printf (" NODELETE");
5660 val
^= DF_1_NODELETE
;
5662 if (val
& DF_1_LOADFLTR
)
5664 printf (" LOADFLTR");
5665 val
^= DF_1_LOADFLTR
;
5667 if (val
& DF_1_INITFIRST
)
5669 printf (" INITFIRST");
5670 val
^= DF_1_INITFIRST
;
5672 if (val
& DF_1_NOOPEN
)
5677 if (val
& DF_1_ORIGIN
)
5682 if (val
& DF_1_DIRECT
)
5687 if (val
& DF_1_TRANS
)
5692 if (val
& DF_1_INTERPOSE
)
5694 printf (" INTERPOSE");
5695 val
^= DF_1_INTERPOSE
;
5697 if (val
& DF_1_NODEFLIB
)
5699 printf (" NODEFLIB");
5700 val
^= DF_1_NODEFLIB
;
5702 if (val
& DF_1_NODUMP
)
5707 if (val
& DF_1_CONLFAT
)
5709 printf (" CONLFAT");
5710 val
^= DF_1_CONLFAT
;
5713 printf (" %lx", val
);
5720 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5722 puts (get_dynamic_type (entry
->d_un
.d_val
));
5742 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5748 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5749 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5755 switch (entry
->d_tag
)
5758 printf (_("Shared library: [%s]"), name
);
5760 if (streq (name
, program_interpreter
))
5761 printf (_(" program interpreter"));
5765 printf (_("Library soname: [%s]"), name
);
5769 printf (_("Library rpath: [%s]"), name
);
5773 printf (_("Library runpath: [%s]"), name
);
5777 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5782 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5795 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5799 case DT_INIT_ARRAYSZ
:
5800 case DT_FINI_ARRAYSZ
:
5801 case DT_GNU_CONFLICTSZ
:
5802 case DT_GNU_LIBLISTSZ
:
5805 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5806 printf (" (bytes)\n");
5816 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5829 if (entry
->d_tag
== DT_USED
5830 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5832 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5836 printf (_("Not needed object: [%s]\n"), name
);
5841 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5847 /* The value of this entry is ignored. */
5852 case DT_GNU_PRELINKED
:
5856 time_t time
= entry
->d_un
.d_val
;
5858 tmp
= gmtime (&time
);
5859 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5860 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5861 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5867 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5868 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5873 switch (elf_header
.e_machine
)
5876 case EM_MIPS_RS3_LE
:
5877 dynamic_section_mips_val (entry
);
5880 dynamic_section_parisc_val (entry
);
5883 dynamic_section_ia64_val (entry
);
5886 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5898 get_ver_flags (unsigned int flags
)
5900 static char buff
[32];
5907 if (flags
& VER_FLG_BASE
)
5908 strcat (buff
, "BASE ");
5910 if (flags
& VER_FLG_WEAK
)
5912 if (flags
& VER_FLG_BASE
)
5913 strcat (buff
, "| ");
5915 strcat (buff
, "WEAK ");
5918 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5919 strcat (buff
, "| <unknown>");
5924 /* Display the contents of the version sections. */
5926 process_version_sections (FILE *file
)
5928 Elf_Internal_Shdr
*section
;
5935 for (i
= 0, section
= section_headers
;
5936 i
< elf_header
.e_shnum
;
5939 switch (section
->sh_type
)
5941 case SHT_GNU_verdef
:
5943 Elf_External_Verdef
*edefs
;
5950 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5951 SECTION_NAME (section
), section
->sh_info
);
5953 printf (_(" Addr: 0x"));
5954 printf_vma (section
->sh_addr
);
5955 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5956 (unsigned long) section
->sh_offset
, section
->sh_link
,
5957 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5959 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5960 _("version definition section"));
5964 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5967 Elf_External_Verdef
*edef
;
5968 Elf_Internal_Verdef ent
;
5969 Elf_External_Verdaux
*eaux
;
5970 Elf_Internal_Verdaux aux
;
5974 vstart
= ((char *) edefs
) + idx
;
5976 edef
= (Elf_External_Verdef
*) vstart
;
5978 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5979 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5980 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5981 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5982 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5983 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5984 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5986 printf (_(" %#06x: Rev: %d Flags: %s"),
5987 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5989 printf (_(" Index: %d Cnt: %d "),
5990 ent
.vd_ndx
, ent
.vd_cnt
);
5992 vstart
+= ent
.vd_aux
;
5994 eaux
= (Elf_External_Verdaux
*) vstart
;
5996 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5997 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5999 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6000 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6002 printf (_("Name index: %ld\n"), aux
.vda_name
);
6004 isum
= idx
+ ent
.vd_aux
;
6006 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6008 isum
+= aux
.vda_next
;
6009 vstart
+= aux
.vda_next
;
6011 eaux
= (Elf_External_Verdaux
*) vstart
;
6013 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6014 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6016 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6017 printf (_(" %#06x: Parent %d: %s\n"),
6018 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6020 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6021 isum
, j
, aux
.vda_name
);
6031 case SHT_GNU_verneed
:
6033 Elf_External_Verneed
*eneed
;
6039 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6040 SECTION_NAME (section
), section
->sh_info
);
6042 printf (_(" Addr: 0x"));
6043 printf_vma (section
->sh_addr
);
6044 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6045 (unsigned long) section
->sh_offset
, section
->sh_link
,
6046 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6048 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6049 _("version need section"));
6053 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6055 Elf_External_Verneed
*entry
;
6056 Elf_Internal_Verneed ent
;
6061 vstart
= ((char *) eneed
) + idx
;
6063 entry
= (Elf_External_Verneed
*) vstart
;
6065 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6066 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6067 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6068 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6069 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6071 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6073 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6074 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6076 printf (_(" File: %lx"), ent
.vn_file
);
6078 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6080 vstart
+= ent
.vn_aux
;
6082 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6084 Elf_External_Vernaux
*eaux
;
6085 Elf_Internal_Vernaux aux
;
6087 eaux
= (Elf_External_Vernaux
*) vstart
;
6089 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6090 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6091 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6092 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6093 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6095 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6096 printf (_(" %#06x: Name: %s"),
6097 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6099 printf (_(" %#06x: Name index: %lx"),
6100 isum
, aux
.vna_name
);
6102 printf (_(" Flags: %s Version: %d\n"),
6103 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6105 isum
+= aux
.vna_next
;
6106 vstart
+= aux
.vna_next
;
6116 case SHT_GNU_versym
:
6118 Elf_Internal_Shdr
*link_section
;
6121 unsigned char *edata
;
6122 unsigned short *data
;
6124 Elf_Internal_Sym
*symbols
;
6125 Elf_Internal_Shdr
*string_sec
;
6128 link_section
= SECTION_HEADER (section
->sh_link
);
6129 total
= section
->sh_size
/ section
->sh_entsize
;
6133 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6135 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6137 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6138 string_sec
->sh_size
, _("version string table"));
6142 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6143 SECTION_NAME (section
), total
);
6145 printf (_(" Addr: "));
6146 printf_vma (section
->sh_addr
);
6147 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6148 (unsigned long) section
->sh_offset
, section
->sh_link
,
6149 SECTION_NAME (link_section
));
6151 off
= offset_from_vma (file
,
6152 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6153 total
* sizeof (short));
6154 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6155 _("version symbol data"));
6162 data
= malloc (total
* sizeof (short));
6164 for (cnt
= total
; cnt
--;)
6165 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6170 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6173 int check_def
, check_need
;
6176 printf (" %03x:", cnt
);
6178 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6179 switch (data
[cnt
+ j
])
6182 fputs (_(" 0 (*local*) "), stdout
);
6186 fputs (_(" 1 (*global*) "), stdout
);
6190 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6191 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6195 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6198 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6205 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6207 Elf_Internal_Verneed ivn
;
6208 unsigned long offset
;
6210 offset
= offset_from_vma
6211 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6212 sizeof (Elf_External_Verneed
));
6216 Elf_Internal_Vernaux ivna
;
6217 Elf_External_Verneed evn
;
6218 Elf_External_Vernaux evna
;
6219 unsigned long a_off
;
6221 get_data (&evn
, file
, offset
, sizeof (evn
),
6224 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6225 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6227 a_off
= offset
+ ivn
.vn_aux
;
6231 get_data (&evna
, file
, a_off
, sizeof (evna
),
6232 _("version need aux (2)"));
6234 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6235 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6237 a_off
+= ivna
.vna_next
;
6239 while (ivna
.vna_other
!= data
[cnt
+ j
]
6240 && ivna
.vna_next
!= 0);
6242 if (ivna
.vna_other
== data
[cnt
+ j
])
6244 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6246 name
= strtab
+ ivna
.vna_name
;
6247 nn
+= printf ("(%s%-*s",
6249 12 - (int) strlen (name
),
6255 offset
+= ivn
.vn_next
;
6257 while (ivn
.vn_next
);
6260 if (check_def
&& data
[cnt
+ j
] != 0x8001
6261 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6263 Elf_Internal_Verdef ivd
;
6264 Elf_External_Verdef evd
;
6265 unsigned long offset
;
6267 offset
= offset_from_vma
6268 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6273 get_data (&evd
, file
, offset
, sizeof (evd
),
6276 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6277 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6279 offset
+= ivd
.vd_next
;
6281 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6282 && ivd
.vd_next
!= 0);
6284 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6286 Elf_External_Verdaux evda
;
6287 Elf_Internal_Verdaux ivda
;
6289 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6291 get_data (&evda
, file
,
6292 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6293 sizeof (evda
), _("version def aux"));
6295 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6297 name
= strtab
+ ivda
.vda_name
;
6298 nn
+= printf ("(%s%-*s",
6300 12 - (int) strlen (name
),
6306 printf ("%*c", 18 - nn
, ' ');
6324 printf (_("\nNo version information found in this file.\n"));
6330 get_symbol_binding (unsigned int binding
)
6332 static char buff
[32];
6336 case STB_LOCAL
: return "LOCAL";
6337 case STB_GLOBAL
: return "GLOBAL";
6338 case STB_WEAK
: return "WEAK";
6340 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6341 sprintf (buff
, _("<processor specific>: %d"), binding
);
6342 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6343 sprintf (buff
, _("<OS specific>: %d"), binding
);
6345 sprintf (buff
, _("<unknown>: %d"), binding
);
6351 get_symbol_type (unsigned int type
)
6353 static char buff
[32];
6357 case STT_NOTYPE
: return "NOTYPE";
6358 case STT_OBJECT
: return "OBJECT";
6359 case STT_FUNC
: return "FUNC";
6360 case STT_SECTION
: return "SECTION";
6361 case STT_FILE
: return "FILE";
6362 case STT_COMMON
: return "COMMON";
6363 case STT_TLS
: return "TLS";
6365 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6367 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6368 return "THUMB_FUNC";
6370 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6373 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6374 return "PARISC_MILLI";
6376 sprintf (buff
, _("<processor specific>: %d"), type
);
6378 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6380 if (elf_header
.e_machine
== EM_PARISC
)
6382 if (type
== STT_HP_OPAQUE
)
6384 if (type
== STT_HP_STUB
)
6388 sprintf (buff
, _("<OS specific>: %d"), type
);
6391 sprintf (buff
, _("<unknown>: %d"), type
);
6397 get_symbol_visibility (unsigned int visibility
)
6401 case STV_DEFAULT
: return "DEFAULT";
6402 case STV_INTERNAL
: return "INTERNAL";
6403 case STV_HIDDEN
: return "HIDDEN";
6404 case STV_PROTECTED
: return "PROTECTED";
6410 get_symbol_index_type (unsigned int type
)
6412 static char buff
[32];
6416 case SHN_UNDEF
: return "UND";
6417 case SHN_ABS
: return "ABS";
6418 case SHN_COMMON
: return "COM";
6420 if (type
== SHN_IA_64_ANSI_COMMON
6421 && elf_header
.e_machine
== EM_IA_64
6422 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6424 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6425 sprintf (buff
, "PRC[0x%04x]", type
);
6426 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6427 sprintf (buff
, "OS [0x%04x]", type
);
6428 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6429 sprintf (buff
, "RSV[0x%04x]", type
);
6431 sprintf (buff
, "%3d", type
);
6439 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6441 unsigned char *e_data
;
6444 e_data
= malloc (number
* ent_size
);
6448 error (_("Out of memory\n"));
6452 if (fread (e_data
, ent_size
, number
, file
) != number
)
6454 error (_("Unable to read in dynamic data\n"));
6458 i_data
= malloc (number
* sizeof (*i_data
));
6462 error (_("Out of memory\n"));
6468 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6475 /* Dump the symbol table. */
6477 process_symbol_table (FILE *file
)
6479 Elf_Internal_Shdr
*section
;
6480 bfd_vma nbuckets
= 0;
6481 bfd_vma nchains
= 0;
6482 bfd_vma
*buckets
= NULL
;
6483 bfd_vma
*chains
= NULL
;
6485 if (! do_syms
&& !do_histogram
)
6488 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6491 unsigned char nb
[8];
6492 unsigned char nc
[8];
6493 int hash_ent_size
= 4;
6495 if ((elf_header
.e_machine
== EM_ALPHA
6496 || elf_header
.e_machine
== EM_S390
6497 || elf_header
.e_machine
== EM_S390_OLD
)
6498 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6502 (archive_file_offset
6503 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6504 sizeof nb
+ sizeof nc
)),
6507 error (_("Unable to seek to start of dynamic information"));
6511 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6513 error (_("Failed to read in number of buckets\n"));
6517 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6519 error (_("Failed to read in number of chains\n"));
6523 nbuckets
= byte_get (nb
, hash_ent_size
);
6524 nchains
= byte_get (nc
, hash_ent_size
);
6526 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6527 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6529 if (buckets
== NULL
|| chains
== NULL
)
6534 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6539 printf (_("\nSymbol table for image:\n"));
6541 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6543 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6545 for (hn
= 0; hn
< nbuckets
; hn
++)
6550 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6552 Elf_Internal_Sym
*psym
;
6555 psym
= dynamic_symbols
+ si
;
6557 n
= print_vma (si
, DEC_5
);
6559 fputs (" " + n
, stdout
);
6560 printf (" %3lu: ", hn
);
6561 print_vma (psym
->st_value
, LONG_HEX
);
6563 print_vma (psym
->st_size
, DEC_5
);
6565 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6566 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6567 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6568 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6569 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6570 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6572 printf (" <corrupt: %14ld>", psym
->st_name
);
6577 else if (do_syms
&& !do_using_dynamic
)
6581 for (i
= 0, section
= section_headers
;
6582 i
< elf_header
.e_shnum
;
6587 Elf_Internal_Sym
*symtab
;
6588 Elf_Internal_Sym
*psym
;
6591 if ( section
->sh_type
!= SHT_SYMTAB
6592 && section
->sh_type
!= SHT_DYNSYM
)
6595 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6596 SECTION_NAME (section
),
6597 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6599 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6601 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6603 symtab
= GET_ELF_SYMBOLS (file
, section
);
6607 if (section
->sh_link
== elf_header
.e_shstrndx
)
6608 strtab
= string_table
;
6611 Elf_Internal_Shdr
*string_sec
;
6613 string_sec
= SECTION_HEADER (section
->sh_link
);
6615 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6616 string_sec
->sh_size
, _("string table"));
6619 for (si
= 0, psym
= symtab
;
6620 si
< section
->sh_size
/ section
->sh_entsize
;
6623 printf ("%6d: ", si
);
6624 print_vma (psym
->st_value
, LONG_HEX
);
6626 print_vma (psym
->st_size
, DEC_5
);
6627 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6628 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6629 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6630 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6631 print_symbol (25, strtab
+ psym
->st_name
);
6633 if (section
->sh_type
== SHT_DYNSYM
&&
6634 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6636 unsigned char data
[2];
6637 unsigned short vers_data
;
6638 unsigned long offset
;
6642 offset
= offset_from_vma
6643 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6644 sizeof data
+ si
* sizeof (vers_data
));
6646 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6647 sizeof (data
), _("version data"));
6649 vers_data
= byte_get (data
, 2);
6651 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6654 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6656 if ((vers_data
& 0x8000) || vers_data
> 1)
6658 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6659 && (is_nobits
|| ! check_def
))
6661 Elf_External_Verneed evn
;
6662 Elf_Internal_Verneed ivn
;
6663 Elf_Internal_Vernaux ivna
;
6665 /* We must test both. */
6666 offset
= offset_from_vma
6667 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6672 unsigned long vna_off
;
6674 get_data (&evn
, file
, offset
, sizeof (evn
),
6677 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6678 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6680 vna_off
= offset
+ ivn
.vn_aux
;
6684 Elf_External_Vernaux evna
;
6686 get_data (&evna
, file
, vna_off
,
6688 _("version need aux (3)"));
6690 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6691 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6692 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6694 vna_off
+= ivna
.vna_next
;
6696 while (ivna
.vna_other
!= vers_data
6697 && ivna
.vna_next
!= 0);
6699 if (ivna
.vna_other
== vers_data
)
6702 offset
+= ivn
.vn_next
;
6704 while (ivn
.vn_next
!= 0);
6706 if (ivna
.vna_other
== vers_data
)
6709 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6712 else if (! is_nobits
)
6713 error (_("bad dynamic symbol"));
6720 if (vers_data
!= 0x8001
6721 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6723 Elf_Internal_Verdef ivd
;
6724 Elf_Internal_Verdaux ivda
;
6725 Elf_External_Verdaux evda
;
6726 unsigned long offset
;
6728 offset
= offset_from_vma
6730 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6731 sizeof (Elf_External_Verdef
));
6735 Elf_External_Verdef evd
;
6737 get_data (&evd
, file
, offset
, sizeof (evd
),
6740 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6741 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6742 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6744 offset
+= ivd
.vd_next
;
6746 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6747 && ivd
.vd_next
!= 0);
6749 offset
-= ivd
.vd_next
;
6750 offset
+= ivd
.vd_aux
;
6752 get_data (&evda
, file
, offset
, sizeof (evda
),
6753 _("version def aux"));
6755 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6757 if (psym
->st_name
!= ivda
.vda_name
)
6758 printf ((vers_data
& 0x8000)
6760 strtab
+ ivda
.vda_name
);
6770 if (strtab
!= string_table
)
6776 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6778 if (do_histogram
&& buckets
!= NULL
)
6780 unsigned long *lengths
;
6781 unsigned long *counts
;
6784 unsigned long maxlength
= 0;
6785 unsigned long nzero_counts
= 0;
6786 unsigned long nsyms
= 0;
6788 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
6789 (unsigned long) nbuckets
);
6790 printf (_(" Length Number %% of total Coverage\n"));
6792 lengths
= calloc (nbuckets
, sizeof (*lengths
));
6793 if (lengths
== NULL
)
6795 error (_("Out of memory"));
6798 for (hn
= 0; hn
< nbuckets
; ++hn
)
6800 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6803 if (maxlength
< ++lengths
[hn
])
6808 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
6811 error (_("Out of memory"));
6815 for (hn
= 0; hn
< nbuckets
; ++hn
)
6816 ++counts
[lengths
[hn
]];
6821 printf (" 0 %-10lu (%5.1f%%)\n",
6822 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6823 for (i
= 1; i
<= maxlength
; ++i
)
6825 nzero_counts
+= counts
[i
] * i
;
6826 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
6827 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
6828 (nzero_counts
* 100.0) / nsyms
);
6836 if (buckets
!= NULL
)
6846 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6850 if (dynamic_syminfo
== NULL
6852 /* No syminfo, this is ok. */
6855 /* There better should be a dynamic symbol section. */
6856 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6860 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6861 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6863 printf (_(" Num: Name BoundTo Flags\n"));
6864 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6866 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6868 printf ("%4d: ", i
);
6869 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6870 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6872 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6875 switch (dynamic_syminfo
[i
].si_boundto
)
6877 case SYMINFO_BT_SELF
:
6878 fputs ("SELF ", stdout
);
6880 case SYMINFO_BT_PARENT
:
6881 fputs ("PARENT ", stdout
);
6884 if (dynamic_syminfo
[i
].si_boundto
> 0
6885 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6886 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6888 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6892 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6896 if (flags
& SYMINFO_FLG_DIRECT
)
6898 if (flags
& SYMINFO_FLG_PASSTHRU
)
6899 printf (" PASSTHRU");
6900 if (flags
& SYMINFO_FLG_COPY
)
6902 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6903 printf (" LAZYLOAD");
6911 #ifdef SUPPORT_DISASSEMBLY
6913 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6915 printf (_("\nAssembly dump of section %s\n"),
6916 SECTION_NAME (section
));
6918 /* XXX -- to be done --- XXX */
6925 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6927 bfd_size_type bytes
;
6929 unsigned char *data
;
6930 unsigned char *start
;
6932 bytes
= section
->sh_size
;
6934 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6936 printf (_("\nSection '%s' has no data to dump.\n"),
6937 SECTION_NAME (section
));
6941 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6943 addr
= section
->sh_addr
;
6945 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6957 lbytes
= (bytes
> 16 ? 16 : bytes
);
6959 printf (" 0x%8.8lx ", (unsigned long) addr
);
6961 switch (elf_header
.e_ident
[EI_DATA
])
6965 for (j
= 15; j
>= 0; j
--)
6968 printf ("%2.2x", data
[j
]);
6978 for (j
= 0; j
< 16; j
++)
6981 printf ("%2.2x", data
[j
]);
6991 for (j
= 0; j
< lbytes
; j
++)
6994 if (k
>= ' ' && k
< 0x7f)
7013 static unsigned long int
7014 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
7016 unsigned long int result
= 0;
7017 unsigned int num_read
= 0;
7018 unsigned int shift
= 0;
7026 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7031 while (byte
& 0x80);
7033 if (length_return
!= NULL
)
7034 *length_return
= num_read
;
7036 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7037 result
|= -1L << shift
;
7042 typedef struct State_Machine_Registers
7044 unsigned long address
;
7047 unsigned int column
;
7051 /* This variable hold the number of the last entry seen
7052 in the File Table. */
7053 unsigned int last_file_entry
;
7056 static SMR state_machine_regs
;
7059 reset_state_machine (int is_stmt
)
7061 state_machine_regs
.address
= 0;
7062 state_machine_regs
.file
= 1;
7063 state_machine_regs
.line
= 1;
7064 state_machine_regs
.column
= 0;
7065 state_machine_regs
.is_stmt
= is_stmt
;
7066 state_machine_regs
.basic_block
= 0;
7067 state_machine_regs
.end_sequence
= 0;
7068 state_machine_regs
.last_file_entry
= 0;
7071 /* Handled an extend line op. Returns true if this is the end
7075 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7077 unsigned char op_code
;
7080 unsigned char *name
;
7083 len
= read_leb128 (data
, & bytes_read
, 0);
7088 warn (_("badly formed extended line op encountered!\n"));
7095 printf (_(" Extended opcode %d: "), op_code
);
7099 case DW_LNE_end_sequence
:
7100 printf (_("End of Sequence\n\n"));
7101 reset_state_machine (is_stmt
);
7104 case DW_LNE_set_address
:
7105 adr
= byte_get (data
, pointer_size
);
7106 printf (_("set Address to 0x%lx\n"), adr
);
7107 state_machine_regs
.address
= adr
;
7110 case DW_LNE_define_file
:
7111 printf (_(" define new File Table entry\n"));
7112 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7114 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7116 data
+= strlen ((char *) data
) + 1;
7117 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7119 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7121 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7122 printf (_("%s\n\n"), name
);
7126 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7133 static const char *debug_str_contents
;
7134 static bfd_vma debug_str_size
;
7137 load_debug_str (FILE *file
)
7139 Elf_Internal_Shdr
*sec
;
7141 /* If it is already loaded, do nothing. */
7142 if (debug_str_contents
!= NULL
)
7145 /* Locate the .debug_str section. */
7146 sec
= find_section (".debug_str");
7150 debug_str_size
= sec
->sh_size
;
7152 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7153 _("debug_str section data"));
7157 free_debug_str (void)
7159 if (debug_str_contents
== NULL
)
7162 free ((char *) debug_str_contents
);
7163 debug_str_contents
= NULL
;
7168 fetch_indirect_string (unsigned long offset
)
7170 if (debug_str_contents
== NULL
)
7171 return _("<no .debug_str section>");
7173 if (offset
> debug_str_size
)
7174 return _("<offset is too big>");
7176 return debug_str_contents
+ offset
;
7179 static const char *debug_loc_contents
;
7180 static bfd_vma debug_loc_size
;
7183 load_debug_loc (FILE *file
)
7185 Elf_Internal_Shdr
*sec
;
7187 /* If it is already loaded, do nothing. */
7188 if (debug_loc_contents
!= NULL
)
7191 /* Locate the .debug_loc section. */
7192 sec
= find_section (".debug_loc");
7196 debug_loc_size
= sec
->sh_size
;
7198 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7199 _("debug_loc section data"));
7203 free_debug_loc (void)
7205 if (debug_loc_contents
== NULL
)
7208 free ((char *) debug_loc_contents
);
7209 debug_loc_contents
= NULL
;
7213 static const char * debug_range_contents
;
7214 static unsigned long debug_range_size
;
7217 load_debug_range (FILE *file
)
7219 Elf_Internal_Shdr
*sec
;
7221 /* If it is already loaded, do nothing. */
7222 if (debug_range_contents
!= NULL
)
7225 /* Locate the .debug_str section. */
7226 sec
= find_section (".debug_ranges");
7230 debug_range_size
= sec
->sh_size
;
7232 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7233 _("debug_range section data"));
7237 free_debug_range (void)
7239 if (debug_range_contents
== NULL
)
7242 free ((char *) debug_range_contents
);
7243 debug_range_contents
= NULL
;
7244 debug_range_size
= 0;
7247 /* Apply addends of RELA relocations. */
7250 debug_apply_rela_addends (FILE *file
,
7251 Elf_Internal_Shdr
*section
,
7253 unsigned char *sec_data
,
7254 unsigned char *start
,
7257 Elf_Internal_Shdr
*relsec
;
7259 if (end
- start
< reloc_size
)
7262 for (relsec
= section_headers
;
7263 relsec
< section_headers
+ elf_header
.e_shnum
;
7266 unsigned long nrelas
;
7267 Elf_Internal_Rela
*rela
, *rp
;
7268 Elf_Internal_Shdr
*symsec
;
7269 Elf_Internal_Sym
*symtab
;
7270 Elf_Internal_Sym
*sym
;
7272 if (relsec
->sh_type
!= SHT_RELA
7273 || SECTION_HEADER (relsec
->sh_info
) != section
7274 || relsec
->sh_size
== 0)
7277 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7281 symsec
= SECTION_HEADER (relsec
->sh_link
);
7282 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7284 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7288 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7289 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7290 loc
= sec_data
+ rp
->r_offset
;
7296 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7298 if (ELF32_R_SYM (rp
->r_info
) != 0
7299 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7300 /* Relocations against object symbols can happen,
7301 eg when referencing a global array. For an
7302 example of this see the _clz.o binary in libgcc.a. */
7303 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7305 warn (_("%s: skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7306 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7307 SECTION_NAME (section
));
7313 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7315 if (ELF64_R_SYM (rp
->r_info
) != 0
7316 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7317 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7319 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7320 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7321 SECTION_NAME (section
));
7326 byte_put (loc
, rp
->r_addend
, reloc_size
);
7336 /* FIXME: There are better and more efficient ways to handle
7337 these structures. For now though, I just want something that
7338 is simple to implement. */
7339 typedef struct abbrev_attr
7341 unsigned long attribute
;
7343 struct abbrev_attr
*next
;
7347 typedef struct abbrev_entry
7349 unsigned long entry
;
7352 struct abbrev_attr
*first_attr
;
7353 struct abbrev_attr
*last_attr
;
7354 struct abbrev_entry
*next
;
7358 static abbrev_entry
*first_abbrev
= NULL
;
7359 static abbrev_entry
*last_abbrev
= NULL
;
7364 abbrev_entry
*abbrev
;
7366 for (abbrev
= first_abbrev
; abbrev
;)
7368 abbrev_entry
*next
= abbrev
->next
;
7371 for (attr
= abbrev
->first_attr
; attr
;)
7373 abbrev_attr
*next
= attr
->next
;
7383 last_abbrev
= first_abbrev
= NULL
;
7387 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7389 abbrev_entry
*entry
;
7391 entry
= malloc (sizeof (*entry
));
7397 entry
->entry
= number
;
7399 entry
->children
= children
;
7400 entry
->first_attr
= NULL
;
7401 entry
->last_attr
= NULL
;
7404 if (first_abbrev
== NULL
)
7405 first_abbrev
= entry
;
7407 last_abbrev
->next
= entry
;
7409 last_abbrev
= entry
;
7413 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7417 attr
= malloc (sizeof (*attr
));
7423 attr
->attribute
= attribute
;
7427 if (last_abbrev
->first_attr
== NULL
)
7428 last_abbrev
->first_attr
= attr
;
7430 last_abbrev
->last_attr
->next
= attr
;
7432 last_abbrev
->last_attr
= attr
;
7435 /* Processes the (partial) contents of a .debug_abbrev section.
7436 Returns NULL if the end of the section was encountered.
7437 Returns the address after the last byte read if the end of
7438 an abbreviation set was found. */
7440 static unsigned char *
7441 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7443 if (first_abbrev
!= NULL
)
7449 unsigned long entry
;
7451 unsigned long attribute
;
7454 entry
= read_leb128 (start
, & bytes_read
, 0);
7455 start
+= bytes_read
;
7457 /* A single zero is supposed to end the section according
7458 to the standard. If there's more, then signal that to
7461 return start
== end
? NULL
: start
;
7463 tag
= read_leb128 (start
, & bytes_read
, 0);
7464 start
+= bytes_read
;
7466 children
= *start
++;
7468 add_abbrev (entry
, tag
, children
);
7474 attribute
= read_leb128 (start
, & bytes_read
, 0);
7475 start
+= bytes_read
;
7477 form
= read_leb128 (start
, & bytes_read
, 0);
7478 start
+= bytes_read
;
7481 add_abbrev_attr (attribute
, form
);
7483 while (attribute
!= 0);
7490 get_TAG_name (unsigned long tag
)
7494 case DW_TAG_padding
: return "DW_TAG_padding";
7495 case DW_TAG_array_type
: return "DW_TAG_array_type";
7496 case DW_TAG_class_type
: return "DW_TAG_class_type";
7497 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7498 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7499 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7500 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7501 case DW_TAG_label
: return "DW_TAG_label";
7502 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7503 case DW_TAG_member
: return "DW_TAG_member";
7504 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7505 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7506 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7507 case DW_TAG_string_type
: return "DW_TAG_string_type";
7508 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7509 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7510 case DW_TAG_typedef
: return "DW_TAG_typedef";
7511 case DW_TAG_union_type
: return "DW_TAG_union_type";
7512 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7513 case DW_TAG_variant
: return "DW_TAG_variant";
7514 case DW_TAG_common_block
: return "DW_TAG_common_block";
7515 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7516 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7517 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7518 case DW_TAG_module
: return "DW_TAG_module";
7519 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7520 case DW_TAG_set_type
: return "DW_TAG_set_type";
7521 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7522 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7523 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7524 case DW_TAG_base_type
: return "DW_TAG_base_type";
7525 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7526 case DW_TAG_const_type
: return "DW_TAG_const_type";
7527 case DW_TAG_constant
: return "DW_TAG_constant";
7528 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7529 case DW_TAG_file_type
: return "DW_TAG_file_type";
7530 case DW_TAG_friend
: return "DW_TAG_friend";
7531 case DW_TAG_namelist
: return "DW_TAG_namelist";
7532 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7533 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7534 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7535 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7536 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7537 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7538 case DW_TAG_try_block
: return "DW_TAG_try_block";
7539 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7540 case DW_TAG_variable
: return "DW_TAG_variable";
7541 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7542 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7543 case DW_TAG_format_label
: return "DW_TAG_format_label";
7544 case DW_TAG_function_template
: return "DW_TAG_function_template";
7545 case DW_TAG_class_template
: return "DW_TAG_class_template";
7546 /* DWARF 2.1 values. */
7547 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7548 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7549 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7550 case DW_TAG_namespace
: return "DW_TAG_namespace";
7551 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7552 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7553 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7554 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7556 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7557 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7558 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7561 static char buffer
[100];
7563 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7570 get_FORM_name (unsigned long form
)
7574 case DW_FORM_addr
: return "DW_FORM_addr";
7575 case DW_FORM_block2
: return "DW_FORM_block2";
7576 case DW_FORM_block4
: return "DW_FORM_block4";
7577 case DW_FORM_data2
: return "DW_FORM_data2";
7578 case DW_FORM_data4
: return "DW_FORM_data4";
7579 case DW_FORM_data8
: return "DW_FORM_data8";
7580 case DW_FORM_string
: return "DW_FORM_string";
7581 case DW_FORM_block
: return "DW_FORM_block";
7582 case DW_FORM_block1
: return "DW_FORM_block1";
7583 case DW_FORM_data1
: return "DW_FORM_data1";
7584 case DW_FORM_flag
: return "DW_FORM_flag";
7585 case DW_FORM_sdata
: return "DW_FORM_sdata";
7586 case DW_FORM_strp
: return "DW_FORM_strp";
7587 case DW_FORM_udata
: return "DW_FORM_udata";
7588 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7589 case DW_FORM_ref1
: return "DW_FORM_ref1";
7590 case DW_FORM_ref2
: return "DW_FORM_ref2";
7591 case DW_FORM_ref4
: return "DW_FORM_ref4";
7592 case DW_FORM_ref8
: return "DW_FORM_ref8";
7593 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7594 case DW_FORM_indirect
: return "DW_FORM_indirect";
7597 static char buffer
[100];
7599 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7605 static unsigned char *
7606 display_block (unsigned char *data
, unsigned long length
)
7608 printf (_(" %lu byte block: "), length
);
7611 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7617 decode_location_expression (unsigned char * data
,
7618 unsigned int pointer_size
,
7619 unsigned long length
,
7620 unsigned long cu_offset
)
7624 unsigned long uvalue
;
7625 unsigned char *end
= data
+ length
;
7626 int need_frame_base
= 0;
7635 printf ("DW_OP_addr: %lx",
7636 (unsigned long) byte_get (data
, pointer_size
));
7637 data
+= pointer_size
;
7640 printf ("DW_OP_deref");
7643 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7646 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7649 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7653 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7657 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7661 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7665 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7666 (unsigned long) byte_get (data
+ 4, 4));
7670 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7671 (long) byte_get (data
+ 4, 4));
7675 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7679 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7683 printf ("DW_OP_dup");
7686 printf ("DW_OP_drop");
7689 printf ("DW_OP_over");
7692 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7695 printf ("DW_OP_swap");
7698 printf ("DW_OP_rot");
7701 printf ("DW_OP_xderef");
7704 printf ("DW_OP_abs");
7707 printf ("DW_OP_and");
7710 printf ("DW_OP_div");
7713 printf ("DW_OP_minus");
7716 printf ("DW_OP_mod");
7719 printf ("DW_OP_mul");
7722 printf ("DW_OP_neg");
7725 printf ("DW_OP_not");
7728 printf ("DW_OP_or");
7731 printf ("DW_OP_plus");
7733 case DW_OP_plus_uconst
:
7734 printf ("DW_OP_plus_uconst: %lu",
7735 read_leb128 (data
, &bytes_read
, 0));
7739 printf ("DW_OP_shl");
7742 printf ("DW_OP_shr");
7745 printf ("DW_OP_shra");
7748 printf ("DW_OP_xor");
7751 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7755 printf ("DW_OP_eq");
7758 printf ("DW_OP_ge");
7761 printf ("DW_OP_gt");
7764 printf ("DW_OP_le");
7767 printf ("DW_OP_lt");
7770 printf ("DW_OP_ne");
7773 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7809 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7844 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7879 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7880 read_leb128 (data
, &bytes_read
, 1));
7885 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7889 need_frame_base
= 1;
7890 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7894 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7896 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7897 read_leb128 (data
, &bytes_read
, 1));
7901 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7904 case DW_OP_deref_size
:
7905 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7907 case DW_OP_xderef_size
:
7908 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7911 printf ("DW_OP_nop");
7914 /* DWARF 3 extensions. */
7915 case DW_OP_push_object_address
:
7916 printf ("DW_OP_push_object_address");
7919 /* XXX: Strictly speaking for 64-bit DWARF3 files
7920 this ought to be an 8-byte wide computation. */
7921 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
7925 /* XXX: Strictly speaking for 64-bit DWARF3 files
7926 this ought to be an 8-byte wide computation. */
7927 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
7930 case DW_OP_call_ref
:
7931 printf ("DW_OP_call_ref");
7934 /* GNU extensions. */
7935 case DW_OP_GNU_push_tls_address
:
7936 printf ("DW_OP_GNU_push_tls_address");
7940 if (op
>= DW_OP_lo_user
7941 && op
<= DW_OP_hi_user
)
7942 printf (_("(User defined location op)"));
7944 printf (_("(Unknown location op)"));
7945 /* No way to tell where the next op is, so just bail. */
7946 return need_frame_base
;
7949 /* Separate the ops. */
7954 return need_frame_base
;
7957 /* This structure records the information that
7958 we extract from the.debug_info section. */
7961 unsigned int pointer_size
;
7962 unsigned long cu_offset
;
7963 unsigned long base_address
;
7964 /* This is an array of offsets to the location list table. */
7965 unsigned long *loc_offsets
;
7966 int *have_frame_base
;
7967 unsigned int num_loc_offsets
;
7968 unsigned int max_loc_offsets
;
7969 unsigned long *range_lists
;
7970 unsigned int num_range_lists
;
7971 unsigned int max_range_lists
;
7975 static debug_info
* debug_information
= NULL
;
7976 static unsigned int num_debug_info_entries
= 0;
7977 static unsigned int last_pointer_size
= 0;
7978 static int warned_about_missing_comp_units
= FALSE
;
7980 static unsigned char *
7981 read_and_display_attr_value (unsigned long attribute
,
7983 unsigned char *data
,
7984 unsigned long cu_offset
,
7985 unsigned long pointer_size
,
7986 unsigned long offset_size
,
7988 debug_info
*debug_info_p
,
7991 unsigned long uvalue
= 0;
7992 unsigned char *block_start
= NULL
;
8000 case DW_FORM_ref_addr
:
8001 if (dwarf_version
== 2)
8003 uvalue
= byte_get (data
, pointer_size
);
8004 data
+= pointer_size
;
8006 else if (dwarf_version
== 3)
8008 uvalue
= byte_get (data
, offset_size
);
8009 data
+= offset_size
;
8013 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8018 uvalue
= byte_get (data
, pointer_size
);
8019 data
+= pointer_size
;
8023 uvalue
= byte_get (data
, offset_size
);
8024 data
+= offset_size
;
8030 uvalue
= byte_get (data
++, 1);
8035 uvalue
= byte_get (data
, 2);
8041 uvalue
= byte_get (data
, 4);
8046 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8050 case DW_FORM_ref_udata
:
8052 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8056 case DW_FORM_indirect
:
8057 form
= read_leb128 (data
, & bytes_read
, 0);
8060 printf (" %s", get_FORM_name (form
));
8061 return read_and_display_attr_value (attribute
, form
, data
,
8062 cu_offset
, pointer_size
,
8063 offset_size
, dwarf_version
,
8064 debug_info_p
, do_loc
);
8069 case DW_FORM_ref_addr
:
8071 printf (" <#%lx>", uvalue
);
8077 case DW_FORM_ref_udata
:
8079 printf (" <%lx>", uvalue
+ cu_offset
);
8085 printf (" %#lx", uvalue
);
8094 printf (" %ld", uvalue
);
8101 uvalue
= byte_get (data
, 4);
8102 printf (" %lx", uvalue
);
8103 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8105 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8106 && num_debug_info_entries
== 0)
8108 if (sizeof (uvalue
) == 8)
8109 uvalue
= byte_get (data
, 8);
8111 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8116 case DW_FORM_string
:
8118 printf (" %s", data
);
8119 data
+= strlen ((char *) data
) + 1;
8123 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8124 block_start
= data
+ bytes_read
;
8126 data
= block_start
+ uvalue
;
8128 data
= display_block (block_start
, uvalue
);
8131 case DW_FORM_block1
:
8132 uvalue
= byte_get (data
, 1);
8133 block_start
= data
+ 1;
8135 data
= block_start
+ uvalue
;
8137 data
= display_block (block_start
, uvalue
);
8140 case DW_FORM_block2
:
8141 uvalue
= byte_get (data
, 2);
8142 block_start
= data
+ 2;
8144 data
= block_start
+ uvalue
;
8146 data
= display_block (block_start
, uvalue
);
8149 case DW_FORM_block4
:
8150 uvalue
= byte_get (data
, 4);
8151 block_start
= data
+ 4;
8153 data
= block_start
+ uvalue
;
8155 data
= display_block (block_start
, uvalue
);
8160 printf (_(" (indirect string, offset: 0x%lx): %s"),
8161 uvalue
, fetch_indirect_string (uvalue
));
8164 case DW_FORM_indirect
:
8165 /* Handled above. */
8169 warn (_("Unrecognized form: %d\n"), form
);
8173 /* For some attributes we can display further information. */
8174 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8175 && num_debug_info_entries
== 0)
8179 case DW_AT_frame_base
:
8180 have_frame_base
= 1;
8181 case DW_AT_location
:
8182 case DW_AT_data_member_location
:
8183 case DW_AT_vtable_elem_location
:
8184 case DW_AT_allocated
:
8185 case DW_AT_associated
:
8186 case DW_AT_data_location
:
8188 case DW_AT_upper_bound
:
8189 case DW_AT_lower_bound
:
8190 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8192 /* Process location list. */
8193 unsigned int max
= debug_info_p
->max_loc_offsets
;
8194 unsigned int num
= debug_info_p
->num_loc_offsets
;
8196 if (max
== 0 || num
>= max
)
8199 debug_info_p
->loc_offsets
8200 = xrealloc (debug_info_p
->loc_offsets
,
8201 max
* sizeof (*debug_info_p
->loc_offsets
));
8202 debug_info_p
->have_frame_base
8203 = xrealloc (debug_info_p
->have_frame_base
,
8204 max
* sizeof (*debug_info_p
->have_frame_base
));
8205 debug_info_p
->max_loc_offsets
= max
;
8207 debug_info_p
->loc_offsets
[num
] = uvalue
;
8208 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8209 debug_info_p
->num_loc_offsets
++;
8214 if (need_base_address
)
8215 debug_info_p
->base_address
= uvalue
;
8219 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8221 /* Process range list. */
8222 unsigned int max
= debug_info_p
->max_range_lists
;
8223 unsigned int num
= debug_info_p
->num_range_lists
;
8225 if (max
== 0 || num
>= max
)
8228 debug_info_p
->range_lists
8229 = xrealloc (debug_info_p
->range_lists
,
8230 max
* sizeof (*debug_info_p
->range_lists
));
8231 debug_info_p
->max_range_lists
= max
;
8233 debug_info_p
->range_lists
[num
] = uvalue
;
8234 debug_info_p
->num_range_lists
++;
8253 case DW_INL_not_inlined
:
8254 printf (_("(not inlined)"));
8256 case DW_INL_inlined
:
8257 printf (_("(inlined)"));
8259 case DW_INL_declared_not_inlined
:
8260 printf (_("(declared as inline but ignored)"));
8262 case DW_INL_declared_inlined
:
8263 printf (_("(declared as inline and inlined)"));
8266 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8271 case DW_AT_language
:
8274 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8275 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8276 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8277 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8278 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8279 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8280 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8281 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8282 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8283 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8284 /* DWARF 2.1 values. */
8285 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8286 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8287 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8288 /* MIPS extension. */
8289 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8290 /* UPC extension. */
8291 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8293 printf ("(Unknown: %lx)", uvalue
);
8298 case DW_AT_encoding
:
8301 case DW_ATE_void
: printf ("(void)"); break;
8302 case DW_ATE_address
: printf ("(machine address)"); break;
8303 case DW_ATE_boolean
: printf ("(boolean)"); break;
8304 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8305 case DW_ATE_float
: printf ("(float)"); break;
8306 case DW_ATE_signed
: printf ("(signed)"); break;
8307 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8308 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8309 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8310 /* DWARF 2.1 value. */
8311 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8313 if (uvalue
>= DW_ATE_lo_user
8314 && uvalue
<= DW_ATE_hi_user
)
8315 printf ("(user defined type)");
8317 printf ("(unknown type)");
8322 case DW_AT_accessibility
:
8325 case DW_ACCESS_public
: printf ("(public)"); break;
8326 case DW_ACCESS_protected
: printf ("(protected)"); break;
8327 case DW_ACCESS_private
: printf ("(private)"); break;
8329 printf ("(unknown accessibility)");
8334 case DW_AT_visibility
:
8337 case DW_VIS_local
: printf ("(local)"); break;
8338 case DW_VIS_exported
: printf ("(exported)"); break;
8339 case DW_VIS_qualified
: printf ("(qualified)"); break;
8340 default: printf ("(unknown visibility)"); break;
8344 case DW_AT_virtuality
:
8347 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8348 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8349 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8350 default: printf ("(unknown virtuality)"); break;
8354 case DW_AT_identifier_case
:
8357 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8358 case DW_ID_up_case
: printf ("(up_case)"); break;
8359 case DW_ID_down_case
: printf ("(down_case)"); break;
8360 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8361 default: printf ("(unknown case)"); break;
8365 case DW_AT_calling_convention
:
8368 case DW_CC_normal
: printf ("(normal)"); break;
8369 case DW_CC_program
: printf ("(program)"); break;
8370 case DW_CC_nocall
: printf ("(nocall)"); break;
8372 if (uvalue
>= DW_CC_lo_user
8373 && uvalue
<= DW_CC_hi_user
)
8374 printf ("(user defined)");
8376 printf ("(unknown convention)");
8380 case DW_AT_ordering
:
8383 case -1: printf ("(undefined)"); break;
8384 case 0: printf ("(row major)"); break;
8385 case 1: printf ("(column major)"); break;
8389 case DW_AT_frame_base
:
8390 have_frame_base
= 1;
8391 case DW_AT_location
:
8392 case DW_AT_data_member_location
:
8393 case DW_AT_vtable_elem_location
:
8394 case DW_AT_allocated
:
8395 case DW_AT_associated
:
8396 case DW_AT_data_location
:
8398 case DW_AT_upper_bound
:
8399 case DW_AT_lower_bound
:
8402 int need_frame_base
;
8405 need_frame_base
= decode_location_expression (block_start
,
8410 if (need_frame_base
&& !have_frame_base
)
8411 printf (_(" [without DW_AT_frame_base]"));
8413 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8414 printf (_("(location list)"));
8426 get_AT_name (unsigned long attribute
)
8430 case DW_AT_sibling
: return "DW_AT_sibling";
8431 case DW_AT_location
: return "DW_AT_location";
8432 case DW_AT_name
: return "DW_AT_name";
8433 case DW_AT_ordering
: return "DW_AT_ordering";
8434 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8435 case DW_AT_byte_size
: return "DW_AT_byte_size";
8436 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8437 case DW_AT_bit_size
: return "DW_AT_bit_size";
8438 case DW_AT_element_list
: return "DW_AT_element_list";
8439 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8440 case DW_AT_low_pc
: return "DW_AT_low_pc";
8441 case DW_AT_high_pc
: return "DW_AT_high_pc";
8442 case DW_AT_language
: return "DW_AT_language";
8443 case DW_AT_member
: return "DW_AT_member";
8444 case DW_AT_discr
: return "DW_AT_discr";
8445 case DW_AT_discr_value
: return "DW_AT_discr_value";
8446 case DW_AT_visibility
: return "DW_AT_visibility";
8447 case DW_AT_import
: return "DW_AT_import";
8448 case DW_AT_string_length
: return "DW_AT_string_length";
8449 case DW_AT_common_reference
: return "DW_AT_common_reference";
8450 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8451 case DW_AT_const_value
: return "DW_AT_const_value";
8452 case DW_AT_containing_type
: return "DW_AT_containing_type";
8453 case DW_AT_default_value
: return "DW_AT_default_value";
8454 case DW_AT_inline
: return "DW_AT_inline";
8455 case DW_AT_is_optional
: return "DW_AT_is_optional";
8456 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8457 case DW_AT_producer
: return "DW_AT_producer";
8458 case DW_AT_prototyped
: return "DW_AT_prototyped";
8459 case DW_AT_return_addr
: return "DW_AT_return_addr";
8460 case DW_AT_start_scope
: return "DW_AT_start_scope";
8461 case DW_AT_stride_size
: return "DW_AT_stride_size";
8462 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8463 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8464 case DW_AT_accessibility
: return "DW_AT_accessibility";
8465 case DW_AT_address_class
: return "DW_AT_address_class";
8466 case DW_AT_artificial
: return "DW_AT_artificial";
8467 case DW_AT_base_types
: return "DW_AT_base_types";
8468 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8469 case DW_AT_count
: return "DW_AT_count";
8470 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8471 case DW_AT_decl_column
: return "DW_AT_decl_column";
8472 case DW_AT_decl_file
: return "DW_AT_decl_file";
8473 case DW_AT_decl_line
: return "DW_AT_decl_line";
8474 case DW_AT_declaration
: return "DW_AT_declaration";
8475 case DW_AT_discr_list
: return "DW_AT_discr_list";
8476 case DW_AT_encoding
: return "DW_AT_encoding";
8477 case DW_AT_external
: return "DW_AT_external";
8478 case DW_AT_frame_base
: return "DW_AT_frame_base";
8479 case DW_AT_friend
: return "DW_AT_friend";
8480 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8481 case DW_AT_macro_info
: return "DW_AT_macro_info";
8482 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8483 case DW_AT_priority
: return "DW_AT_priority";
8484 case DW_AT_segment
: return "DW_AT_segment";
8485 case DW_AT_specification
: return "DW_AT_specification";
8486 case DW_AT_static_link
: return "DW_AT_static_link";
8487 case DW_AT_type
: return "DW_AT_type";
8488 case DW_AT_use_location
: return "DW_AT_use_location";
8489 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8490 case DW_AT_virtuality
: return "DW_AT_virtuality";
8491 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8492 /* DWARF 2.1 values. */
8493 case DW_AT_allocated
: return "DW_AT_allocated";
8494 case DW_AT_associated
: return "DW_AT_associated";
8495 case DW_AT_data_location
: return "DW_AT_data_location";
8496 case DW_AT_stride
: return "DW_AT_stride";
8497 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8498 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8499 case DW_AT_extension
: return "DW_AT_extension";
8500 case DW_AT_ranges
: return "DW_AT_ranges";
8501 case DW_AT_trampoline
: return "DW_AT_trampoline";
8502 case DW_AT_call_column
: return "DW_AT_call_column";
8503 case DW_AT_call_file
: return "DW_AT_call_file";
8504 case DW_AT_call_line
: return "DW_AT_call_line";
8505 /* SGI/MIPS extensions. */
8506 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8507 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8508 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8509 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8510 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8511 case DW_AT_MIPS_software_pipeline_depth
:
8512 return "DW_AT_MIPS_software_pipeline_depth";
8513 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8514 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8515 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8516 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8517 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8518 /* GNU extensions. */
8519 case DW_AT_sf_names
: return "DW_AT_sf_names";
8520 case DW_AT_src_info
: return "DW_AT_src_info";
8521 case DW_AT_mac_info
: return "DW_AT_mac_info";
8522 case DW_AT_src_coords
: return "DW_AT_src_coords";
8523 case DW_AT_body_begin
: return "DW_AT_body_begin";
8524 case DW_AT_body_end
: return "DW_AT_body_end";
8525 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8526 /* UPC extension. */
8527 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8530 static char buffer
[100];
8532 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
8538 static unsigned char *
8539 read_and_display_attr (unsigned long attribute
,
8541 unsigned char *data
,
8542 unsigned long cu_offset
,
8543 unsigned long pointer_size
,
8544 unsigned long offset_size
,
8546 debug_info
*debug_info_p
,
8550 printf (" %-18s:", get_AT_name (attribute
));
8551 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8552 pointer_size
, offset_size
,
8553 dwarf_version
, debug_info_p
,
8561 /* Process the contents of a .debug_info section. If do_loc is non-zero
8562 then we are scanning for location lists and we do not want to display
8563 anything to the user. */
8566 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8567 FILE *file
, int do_loc
)
8569 unsigned char *end
= start
+ section
->sh_size
;
8570 unsigned char *section_begin
;
8572 unsigned int num_units
= 0;
8574 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8575 && num_debug_info_entries
== 0)
8577 unsigned long length
;
8579 /* First scan the section to get the number of comp units. */
8580 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8583 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8584 will be the length. For a 64-bit DWARF section, it'll be
8585 the escape code 0xffffffff followed by an 8 byte length. */
8586 length
= byte_get (section_begin
, 4);
8588 if (length
== 0xffffffff)
8590 length
= byte_get (section_begin
+ 4, 8);
8591 section_begin
+= length
+ 12;
8594 section_begin
+= length
+ 4;
8599 error (_("No comp units in .debug_info section ?"));
8603 /* Then allocate an array to hold the information. */
8604 debug_information
= malloc (num_units
*
8605 sizeof (* debug_information
));
8606 if (debug_information
== NULL
)
8608 error (_("Not enough memory for a debug info array of %u entries"),
8616 printf (_("The section %s contains:\n\n"),
8617 SECTION_NAME (section
));
8619 load_debug_str (file
);
8620 load_debug_loc (file
);
8621 load_debug_range (file
);
8624 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8626 DWARF2_Internal_CompUnit compunit
;
8627 unsigned char *hdrptr
;
8628 unsigned char *cu_abbrev_offset_ptr
;
8629 unsigned char *tags
;
8631 unsigned long cu_offset
;
8633 int initial_length_size
;
8637 compunit
.cu_length
= byte_get (hdrptr
, 4);
8640 if (compunit
.cu_length
== 0xffffffff)
8642 compunit
.cu_length
= byte_get (hdrptr
, 8);
8645 initial_length_size
= 12;
8650 initial_length_size
= 4;
8653 compunit
.cu_version
= byte_get (hdrptr
, 2);
8656 cu_offset
= start
- section_begin
;
8657 start
+= compunit
.cu_length
+ initial_length_size
;
8659 if (elf_header
.e_type
== ET_REL
8660 && !debug_apply_rela_addends (file
, section
, offset_size
,
8661 section_begin
, hdrptr
, start
))
8664 cu_abbrev_offset_ptr
= hdrptr
;
8665 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8666 hdrptr
+= offset_size
;
8668 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8670 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8671 && num_debug_info_entries
== 0)
8673 debug_information
[unit
].cu_offset
= cu_offset
;
8674 debug_information
[unit
].pointer_size
8675 = compunit
.cu_pointer_size
;
8676 debug_information
[unit
].base_address
= 0;
8677 debug_information
[unit
].loc_offsets
= NULL
;
8678 debug_information
[unit
].have_frame_base
= NULL
;
8679 debug_information
[unit
].max_loc_offsets
= 0;
8680 debug_information
[unit
].num_loc_offsets
= 0;
8681 debug_information
[unit
].range_lists
= NULL
;
8682 debug_information
[unit
].max_range_lists
= 0;
8683 debug_information
[unit
].num_range_lists
= 0;
8690 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8691 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8692 printf (_(" Version: %d\n"), compunit
.cu_version
);
8693 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8694 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8697 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8699 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8705 /* Read in the abbrevs used by this compilation unit. */
8707 Elf_Internal_Shdr
*sec
;
8708 unsigned char *begin
;
8710 /* Locate the .debug_abbrev section and process it. */
8711 sec
= find_section (".debug_abbrev");
8714 warn (_("Unable to locate .debug_abbrev section!\n"));
8718 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8719 _("debug_abbrev section data"));
8723 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8724 begin
+ sec
->sh_size
);
8730 while (tags
< start
)
8733 unsigned long abbrev_number
;
8734 abbrev_entry
*entry
;
8737 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8740 /* A null DIE marks the end of a list of children. */
8741 if (abbrev_number
== 0)
8747 /* Scan through the abbreviation list until we reach the
8749 for (entry
= first_abbrev
;
8750 entry
&& entry
->entry
!= abbrev_number
;
8751 entry
= entry
->next
)
8756 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8762 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8764 (unsigned long) (tags
- section_begin
8767 get_TAG_name (entry
->tag
));
8772 need_base_address
= 0;
8774 case DW_TAG_compile_unit
:
8775 need_base_address
= 1;
8777 case DW_TAG_entry_point
:
8778 case DW_TAG_inlined_subroutine
:
8779 case DW_TAG_subprogram
:
8780 need_base_address
= 0;
8781 /* Assuming that there is no DW_AT_frame_base. */
8782 have_frame_base
= 0;
8786 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8787 tags
= read_and_display_attr (attr
->attribute
,
8790 compunit
.cu_pointer_size
,
8792 compunit
.cu_version
,
8793 &debug_information
[unit
],
8796 if (entry
->children
)
8801 /* Set num_debug_info_entries here so that it can be used to check if
8802 we need to proecess .debug_loc and .debug_ranges sections. */
8803 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8804 && num_debug_info_entries
== 0)
8805 num_debug_info_entries
= num_units
;
8809 free_debug_range ();
8819 /* Retrieve the pointer size associated with the given compilation unit.
8820 Optionally the offset of this unit into the .debug_info section is
8821 also retutned. If there is no .debug_info section then an error
8822 message is issued and 0 is returned. If the requested comp unit has
8823 not been defined in the .debug_info section then a warning message
8824 is issued and the last know pointer size is returned. This message
8825 is only issued once per section dumped per file dumped. */
8828 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8829 const char * section_name
,
8830 unsigned long * offset_return
)
8832 unsigned long offset
= 0;
8834 if (num_debug_info_entries
== 0)
8835 error (_("%s section needs a populated .debug_info section\n"),
8838 else if (comp_unit
>= num_debug_info_entries
)
8840 if (!warned_about_missing_comp_units
)
8842 warn (_("%s section has more comp units than .debug_info section\n"),
8844 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
8846 warned_about_missing_comp_units
= TRUE
;
8851 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
8852 offset
= debug_information
[comp_unit
].cu_offset
;
8855 if (offset_return
!= NULL
)
8856 * offset_return
= offset
;
8858 return last_pointer_size
;
8861 /* Locate and scan the .debug_info section in the file and record the pointer
8862 sizes and offsets for the compilation units in it. Usually an executable
8863 will have just one pointer size, but this is not guaranteed, and so we try
8864 not to make any assumptions. Returns zero upon failure, or the number of
8865 compilation units upon success. */
8868 get_debug_info (FILE * file
)
8870 Elf_Internal_Shdr
* section
;
8871 unsigned char * start
;
8874 /* Reset the last pointer size so that we can issue correct error
8875 messages if we are displaying the contents of more than one section. */
8876 last_pointer_size
= 0;
8877 warned_about_missing_comp_units
= FALSE
;
8879 /* If we already have the information there is nothing else to do. */
8880 if (num_debug_info_entries
> 0)
8881 return num_debug_info_entries
;
8883 section
= find_section (".debug_info");
8884 if (section
== NULL
)
8887 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
8888 _("extracting information from .debug_info section"));
8892 ret
= process_debug_info (section
, start
, file
, 1);
8895 return ret
? num_debug_info_entries
: 0;
8899 display_debug_lines (Elf_Internal_Shdr
*section
,
8900 unsigned char *start
, FILE *file
)
8902 unsigned char *data
= start
;
8903 unsigned char *end
= start
+ section
->sh_size
;
8904 unsigned int comp_unit
= 0;
8906 printf (_("\nDump of debug contents of section %s:\n\n"),
8907 SECTION_NAME (section
));
8909 get_debug_info (file
);
8913 DWARF2_Internal_LineInfo info
;
8914 unsigned char *standard_opcodes
;
8915 unsigned char *end_of_sequence
;
8916 unsigned char *hdrptr
;
8917 unsigned int pointer_size
;
8918 int initial_length_size
;
8924 /* Check the length of the block. */
8925 info
.li_length
= byte_get (hdrptr
, 4);
8928 if (info
.li_length
== 0xffffffff)
8930 /* This section is 64-bit DWARF 3. */
8931 info
.li_length
= byte_get (hdrptr
, 8);
8934 initial_length_size
= 12;
8939 initial_length_size
= 4;
8942 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
8945 (_("The line info appears to be corrupt - the section is too small\n"));
8949 /* Check its version number. */
8950 info
.li_version
= byte_get (hdrptr
, 2);
8952 if (info
.li_version
!= 2 && info
.li_version
!= 3)
8954 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
8958 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
8959 hdrptr
+= offset_size
;
8960 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
8962 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
8964 info
.li_line_base
= byte_get (hdrptr
, 1);
8966 info
.li_line_range
= byte_get (hdrptr
, 1);
8968 info
.li_opcode_base
= byte_get (hdrptr
, 1);
8971 /* Sign extend the line base field. */
8972 info
.li_line_base
<<= 24;
8973 info
.li_line_base
>>= 24;
8975 /* Get the pointer size from the comp unit associated
8976 with this block of line number information. */
8977 pointer_size
= get_pointer_size_and_offset_of_comp_unit
8978 (comp_unit
, ".debug_lines", NULL
);
8981 printf (_(" Length: %ld\n"), info
.li_length
);
8982 printf (_(" DWARF Version: %d\n"), info
.li_version
);
8983 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
8984 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
8985 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
8986 printf (_(" Line Base: %d\n"), info
.li_line_base
);
8987 printf (_(" Line Range: %d\n"), info
.li_line_range
);
8988 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
8989 printf (_(" (Pointer size: %u)\n"), pointer_size
);
8991 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
8993 reset_state_machine (info
.li_default_is_stmt
);
8995 /* Display the contents of the Opcodes table. */
8996 standard_opcodes
= hdrptr
;
8998 printf (_("\n Opcodes:\n"));
9000 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9001 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9003 /* Display the contents of the Directory table. */
9004 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9007 printf (_("\n The Directory Table is empty.\n"));
9010 printf (_("\n The Directory Table:\n"));
9014 printf (_(" %s\n"), data
);
9016 data
+= strlen ((char *) data
) + 1;
9020 /* Skip the NUL at the end of the table. */
9023 /* Display the contents of the File Name table. */
9025 printf (_("\n The File Name Table is empty.\n"));
9028 printf (_("\n The File Name Table:\n"));
9029 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9033 unsigned char *name
;
9036 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9039 data
+= strlen ((char *) data
) + 1;
9041 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9043 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9045 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9047 printf (_("%s\n"), name
);
9051 /* Skip the NUL at the end of the table. */
9054 /* Now display the statements. */
9055 printf (_("\n Line Number Statements:\n"));
9057 while (data
< end_of_sequence
)
9059 unsigned char op_code
;
9065 if (op_code
>= info
.li_opcode_base
)
9067 op_code
-= info
.li_opcode_base
;
9068 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9069 state_machine_regs
.address
+= adv
;
9070 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9071 op_code
, adv
, state_machine_regs
.address
);
9072 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9073 state_machine_regs
.line
+= adv
;
9074 printf (_(" and Line by %d to %d\n"),
9075 adv
, state_machine_regs
.line
);
9077 else switch (op_code
)
9079 case DW_LNS_extended_op
:
9080 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9085 printf (_(" Copy\n"));
9088 case DW_LNS_advance_pc
:
9089 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9091 state_machine_regs
.address
+= adv
;
9092 printf (_(" Advance PC by %d to %lx\n"), adv
,
9093 state_machine_regs
.address
);
9096 case DW_LNS_advance_line
:
9097 adv
= read_leb128 (data
, & bytes_read
, 1);
9099 state_machine_regs
.line
+= adv
;
9100 printf (_(" Advance Line by %d to %d\n"), adv
,
9101 state_machine_regs
.line
);
9104 case DW_LNS_set_file
:
9105 adv
= read_leb128 (data
, & bytes_read
, 0);
9107 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9109 state_machine_regs
.file
= adv
;
9112 case DW_LNS_set_column
:
9113 adv
= read_leb128 (data
, & bytes_read
, 0);
9115 printf (_(" Set column to %d\n"), adv
);
9116 state_machine_regs
.column
= adv
;
9119 case DW_LNS_negate_stmt
:
9120 adv
= state_machine_regs
.is_stmt
;
9122 printf (_(" Set is_stmt to %d\n"), adv
);
9123 state_machine_regs
.is_stmt
= adv
;
9126 case DW_LNS_set_basic_block
:
9127 printf (_(" Set basic block\n"));
9128 state_machine_regs
.basic_block
= 1;
9131 case DW_LNS_const_add_pc
:
9132 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9133 * info
.li_min_insn_length
);
9134 state_machine_regs
.address
+= adv
;
9135 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9136 state_machine_regs
.address
);
9139 case DW_LNS_fixed_advance_pc
:
9140 adv
= byte_get (data
, 2);
9142 state_machine_regs
.address
+= adv
;
9143 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9144 adv
, state_machine_regs
.address
);
9147 case DW_LNS_set_prologue_end
:
9148 printf (_(" Set prologue_end to true\n"));
9151 case DW_LNS_set_epilogue_begin
:
9152 printf (_(" Set epilogue_begin to true\n"));
9155 case DW_LNS_set_isa
:
9156 adv
= read_leb128 (data
, & bytes_read
, 0);
9158 printf (_(" Set ISA to %d\n"), adv
);
9162 printf (_(" Unknown opcode %d with operands: "), op_code
);
9164 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9166 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9167 i
== 1 ? "" : ", ");
9181 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9182 unsigned char *start
,
9183 FILE *file ATTRIBUTE_UNUSED
)
9185 DWARF2_Internal_PubNames pubnames
;
9188 end
= start
+ section
->sh_size
;
9190 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9194 unsigned char *data
;
9195 unsigned long offset
;
9196 int offset_size
, initial_length_size
;
9200 pubnames
.pn_length
= byte_get (data
, 4);
9202 if (pubnames
.pn_length
== 0xffffffff)
9204 pubnames
.pn_length
= byte_get (data
, 8);
9207 initial_length_size
= 12;
9212 initial_length_size
= 4;
9215 pubnames
.pn_version
= byte_get (data
, 2);
9217 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9218 data
+= offset_size
;
9219 pubnames
.pn_size
= byte_get (data
, offset_size
);
9220 data
+= offset_size
;
9222 start
+= pubnames
.pn_length
+ initial_length_size
;
9224 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9226 static int warned
= 0;
9230 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9237 printf (_(" Length: %ld\n"),
9238 pubnames
.pn_length
);
9239 printf (_(" Version: %d\n"),
9240 pubnames
.pn_version
);
9241 printf (_(" Offset into .debug_info section: %ld\n"),
9242 pubnames
.pn_offset
);
9243 printf (_(" Size of area in .debug_info section: %ld\n"),
9246 printf (_("\n Offset\tName\n"));
9250 offset
= byte_get (data
, offset_size
);
9254 data
+= offset_size
;
9255 printf (" %-6ld\t\t%s\n", offset
, data
);
9256 data
+= strlen ((char *) data
) + 1;
9259 while (offset
!= 0);
9267 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9268 unsigned char *start
,
9269 FILE *file ATTRIBUTE_UNUSED
)
9271 unsigned char *end
= start
+ section
->sh_size
;
9272 unsigned char *curr
= start
;
9273 unsigned int bytes_read
;
9274 enum dwarf_macinfo_record_type op
;
9276 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9280 unsigned int lineno
;
9288 case DW_MACINFO_start_file
:
9290 unsigned int filenum
;
9292 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9294 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9297 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9302 case DW_MACINFO_end_file
:
9303 printf (_(" DW_MACINFO_end_file\n"));
9306 case DW_MACINFO_define
:
9307 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9310 curr
+= strlen (string
) + 1;
9311 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9315 case DW_MACINFO_undef
:
9316 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9319 curr
+= strlen (string
) + 1;
9320 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9324 case DW_MACINFO_vendor_ext
:
9326 unsigned int constant
;
9328 constant
= read_leb128 (curr
, & bytes_read
, 0);
9331 curr
+= strlen (string
) + 1;
9332 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9344 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9345 unsigned char *start
,
9346 FILE *file ATTRIBUTE_UNUSED
)
9348 abbrev_entry
*entry
;
9349 unsigned char *end
= start
+ section
->sh_size
;
9351 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9355 start
= process_abbrev_section (start
, end
);
9357 if (first_abbrev
== NULL
)
9360 printf (_(" Number TAG\n"));
9362 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9366 printf (_(" %ld %s [%s]\n"),
9368 get_TAG_name (entry
->tag
),
9369 entry
->children
? _("has children") : _("no children"));
9371 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9372 printf (_(" %-18s %s\n"),
9373 get_AT_name (attr
->attribute
),
9374 get_FORM_name (attr
->form
));
9387 display_debug_loc (Elf_Internal_Shdr
*section
,
9388 unsigned char *start
, FILE *file
)
9390 unsigned char *section_end
;
9391 unsigned long bytes
;
9392 unsigned char *section_begin
= start
;
9393 unsigned int num_loc_list
= 0;
9394 unsigned long last_offset
= 0;
9395 unsigned int first
= 0;
9398 int seen_first_offset
= 0;
9399 int use_debug_info
= 1;
9400 unsigned char *next
;
9402 bytes
= section
->sh_size
;
9403 section_end
= start
+ bytes
;
9407 printf (_("\nThe .debug_loc section is empty.\n"));
9411 get_debug_info (file
);
9413 /* Check the order of location list in .debug_info section. If
9414 offsets of location lists are in the ascending order, we can
9415 use `debug_information' directly. */
9416 for (i
= 0; i
< num_debug_info_entries
; i
++)
9420 num
= debug_information
[i
].num_loc_offsets
;
9421 num_loc_list
+= num
;
9423 /* Check if we can use `debug_information' directly. */
9424 if (use_debug_info
&& num
!= 0)
9426 if (!seen_first_offset
)
9428 /* This is the first location list. */
9429 last_offset
= debug_information
[i
].loc_offsets
[0];
9431 seen_first_offset
= 1;
9437 for (; j
< num
; j
++)
9440 debug_information
[i
].loc_offsets
[j
])
9445 last_offset
= debug_information
[i
].loc_offsets
[j
];
9450 if (!use_debug_info
)
9451 /* FIXME: Should we handle this case? */
9452 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9454 if (!seen_first_offset
)
9455 error (_("No location lists in .debug_info section!\n"));
9457 if (debug_information
[first
].loc_offsets
[0] != 0)
9458 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9459 debug_information
[first
].loc_offsets
[0]);
9461 printf (_("Contents of the .debug_loc section:\n\n"));
9462 printf (_(" Offset Begin End Expression\n"));
9464 seen_first_offset
= 0;
9465 for (i
= first
; i
< num_debug_info_entries
; i
++)
9467 unsigned long begin
;
9469 unsigned short length
;
9470 unsigned long offset
;
9471 unsigned int pointer_size
;
9472 unsigned long cu_offset
;
9473 unsigned long base_address
;
9474 int need_frame_base
;
9477 pointer_size
= debug_information
[i
].pointer_size
;
9478 cu_offset
= debug_information
[i
].cu_offset
;
9480 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9482 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9483 offset
= debug_information
[i
].loc_offsets
[j
];
9484 next
= section_begin
+ offset
;
9485 base_address
= debug_information
[i
].base_address
;
9487 if (!seen_first_offset
)
9488 seen_first_offset
= 1;
9492 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9493 start
- section_begin
, next
- section_begin
);
9494 else if (start
> next
)
9495 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9496 start
- section_begin
, next
- section_begin
);
9502 begin
= byte_get (start
, pointer_size
);
9503 start
+= pointer_size
;
9504 end
= byte_get (start
, pointer_size
);
9505 start
+= pointer_size
;
9507 if (begin
== 0 && end
== 0)
9509 printf (_(" %8.8lx <End of list>\n"), offset
);
9513 /* Check base address specifiers. */
9514 if (begin
== -1UL && end
!= -1UL)
9517 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9518 offset
, begin
, end
);
9522 length
= byte_get (start
, 2);
9525 printf (" %8.8lx %8.8lx %8.8lx (",
9526 offset
, begin
+ base_address
, end
+ base_address
);
9527 need_frame_base
= decode_location_expression (start
,
9533 if (need_frame_base
&& !has_frame_base
)
9534 printf (_(" [without DW_AT_frame_base]"));
9537 fputs (_(" (start == end)"), stdout
);
9538 else if (begin
> end
)
9539 fputs (_(" (start > end)"), stdout
);
9551 display_debug_str (Elf_Internal_Shdr
*section
,
9552 unsigned char *start
,
9553 FILE *file ATTRIBUTE_UNUSED
)
9555 unsigned long bytes
;
9558 addr
= section
->sh_addr
;
9559 bytes
= section
->sh_size
;
9563 printf (_("\nThe .debug_str section is empty.\n"));
9567 printf (_("Contents of the .debug_str section:\n\n"));
9575 lbytes
= (bytes
> 16 ? 16 : bytes
);
9577 printf (" 0x%8.8lx ", (unsigned long) addr
);
9579 for (j
= 0; j
< 16; j
++)
9582 printf ("%2.2x", start
[j
]);
9590 for (j
= 0; j
< lbytes
; j
++)
9593 if (k
>= ' ' && k
< 0x80)
9613 display_debug_info (Elf_Internal_Shdr
* section
,
9614 unsigned char * start
, FILE * file
)
9616 return process_debug_info (section
, start
, file
, 0);
9621 display_debug_aranges (Elf_Internal_Shdr
*section
,
9622 unsigned char *start
,
9623 FILE *file ATTRIBUTE_UNUSED
)
9625 unsigned char *end
= start
+ section
->sh_size
;
9627 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9631 unsigned char *hdrptr
;
9632 DWARF2_Internal_ARange arange
;
9633 unsigned char *ranges
;
9634 unsigned long length
;
9635 unsigned long address
;
9638 int initial_length_size
;
9642 arange
.ar_length
= byte_get (hdrptr
, 4);
9645 if (arange
.ar_length
== 0xffffffff)
9647 arange
.ar_length
= byte_get (hdrptr
, 8);
9650 initial_length_size
= 12;
9655 initial_length_size
= 4;
9658 arange
.ar_version
= byte_get (hdrptr
, 2);
9661 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9662 hdrptr
+= offset_size
;
9664 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9667 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9670 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9672 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9676 printf (_(" Length: %ld\n"), arange
.ar_length
);
9677 printf (_(" Version: %d\n"), arange
.ar_version
);
9678 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9679 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9680 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9682 printf (_("\n Address Length\n"));
9686 /* Must pad to an alignment boundary that is twice the pointer size. */
9687 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9689 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9693 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9695 ranges
+= arange
.ar_pointer_size
;
9697 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9699 ranges
+= arange
.ar_pointer_size
;
9701 /* A pair of zeros marks the end of the list. */
9702 if (address
== 0 && length
== 0)
9705 printf (" %8.8lx %lu\n", address
, length
);
9708 start
+= arange
.ar_length
+ initial_length_size
;
9717 display_debug_ranges (Elf_Internal_Shdr
*section
,
9718 unsigned char *start
,
9719 FILE *file ATTRIBUTE_UNUSED
)
9721 unsigned char *section_end
;
9722 unsigned long bytes
;
9723 unsigned char *section_begin
= start
;
9724 unsigned int num_range_list
= 0;
9725 unsigned long last_offset
= 0;
9726 unsigned int first
= 0;
9729 int seen_first_offset
= 0;
9730 int use_debug_info
= 1;
9731 unsigned char *next
;
9733 bytes
= section
->sh_size
;
9734 section_end
= start
+ bytes
;
9738 printf (_("\nThe .debug_ranges section is empty.\n"));
9742 get_debug_info (file
);
9744 /* Check the order of range list in .debug_info section. If
9745 offsets of range lists are in the ascending order, we can
9746 use `debug_information' directly. */
9747 for (i
= 0; i
< num_debug_info_entries
; i
++)
9751 num
= debug_information
[i
].num_range_lists
;
9752 num_range_list
+= num
;
9754 /* Check if we can use `debug_information' directly. */
9755 if (use_debug_info
&& num
!= 0)
9757 if (!seen_first_offset
)
9759 /* This is the first range list. */
9760 last_offset
= debug_information
[i
].range_lists
[0];
9762 seen_first_offset
= 1;
9768 for (; j
< num
; j
++)
9771 debug_information
[i
].range_lists
[j
])
9776 last_offset
= debug_information
[i
].range_lists
[j
];
9781 if (!use_debug_info
)
9782 /* FIXME: Should we handle this case? */
9783 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9785 if (!seen_first_offset
)
9786 error (_("No range lists in .debug_info section!\n"));
9788 if (debug_information
[first
].range_lists
[0] != 0)
9789 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9790 debug_information
[first
].range_lists
[0]);
9792 printf (_("Contents of the .debug_ranges section:\n\n"));
9793 printf (_(" Offset Begin End\n"));
9795 seen_first_offset
= 0;
9796 for (i
= first
; i
< num_debug_info_entries
; i
++)
9798 unsigned long begin
;
9800 unsigned long offset
;
9801 unsigned int pointer_size
;
9802 unsigned long base_address
;
9804 pointer_size
= debug_information
[i
].pointer_size
;
9806 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9808 offset
= debug_information
[i
].range_lists
[j
];
9809 next
= section_begin
+ offset
;
9810 base_address
= debug_information
[i
].base_address
;
9812 if (!seen_first_offset
)
9813 seen_first_offset
= 1;
9817 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9818 start
- section_begin
, next
- section_begin
);
9819 else if (start
> next
)
9820 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9821 start
- section_begin
, next
- section_begin
);
9827 begin
= byte_get (start
, pointer_size
);
9828 start
+= pointer_size
;
9829 end
= byte_get (start
, pointer_size
);
9830 start
+= pointer_size
;
9832 if (begin
== 0 && end
== 0)
9835 /* Check base address specifiers. */
9836 if (begin
== -1UL && end
!= -1UL)
9839 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9840 offset
, begin
, end
);
9844 printf (" %8.8lx %8.8lx %8.8lx",
9845 offset
, begin
+ base_address
, end
+ base_address
);
9848 fputs (_(" (start == end)"), stdout
);
9849 else if (begin
> end
)
9850 fputs (_(" (start > end)"), stdout
);
9854 fputs (_(" <End of list>\n"), stdout
);
9861 typedef struct Frame_Chunk
9863 struct Frame_Chunk
*next
;
9864 unsigned char *chunk_start
;
9866 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9867 short int *col_type
;
9870 unsigned int code_factor
;
9872 unsigned long pc_begin
;
9873 unsigned long pc_range
;
9877 unsigned char fde_encoding
;
9878 unsigned char cfa_exp
;
9882 /* A marker for a col_type that means this column was never referenced
9883 in the frame info. */
9884 #define DW_CFA_unreferenced (-1)
9887 frame_need_space (Frame_Chunk
*fc
, int reg
)
9889 int prev
= fc
->ncols
;
9891 if (reg
< fc
->ncols
)
9894 fc
->ncols
= reg
+ 1;
9895 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
9896 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
9898 while (prev
< fc
->ncols
)
9900 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
9901 fc
->col_offset
[prev
] = 0;
9907 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
9912 if (*max_regs
< fc
->ncols
)
9913 *max_regs
= fc
->ncols
;
9915 if (*need_col_headers
)
9917 *need_col_headers
= 0;
9919 printf (" LOC CFA ");
9921 for (r
= 0; r
< *max_regs
; r
++)
9922 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9927 printf ("r%-4d", r
);
9933 printf ("%08lx ", fc
->pc_begin
);
9935 strcpy (tmp
, "exp");
9937 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9938 printf ("%-8s ", tmp
);
9940 for (r
= 0; r
< fc
->ncols
; r
++)
9942 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9944 switch (fc
->col_type
[r
])
9946 case DW_CFA_undefined
:
9949 case DW_CFA_same_value
:
9953 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9955 case DW_CFA_register
:
9956 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9958 case DW_CFA_expression
:
9959 strcpy (tmp
, "exp");
9962 strcpy (tmp
, "n/a");
9965 printf ("%-5s", tmp
);
9972 size_of_encoded_value (int encoding
)
9974 switch (encoding
& 0x7)
9977 case 0: return eh_addr_size
;
9985 get_encoded_value (unsigned char *data
, int encoding
)
9987 int size
= size_of_encoded_value (encoding
);
9988 if (encoding
& DW_EH_PE_signed
)
9989 return byte_get_signed (data
, size
);
9991 return byte_get (data
, size
);
9994 #define GET(N) byte_get (start, N); start += N
9995 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9996 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9999 display_debug_frames (Elf_Internal_Shdr
*section
,
10000 unsigned char *start
,
10001 FILE *file ATTRIBUTE_UNUSED
)
10003 unsigned char *end
= start
+ section
->sh_size
;
10004 unsigned char *section_start
= start
;
10005 Frame_Chunk
*chunks
= 0;
10006 Frame_Chunk
*remembered_state
= 0;
10008 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10012 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10014 while (start
< end
)
10016 unsigned char *saved_start
;
10017 unsigned char *block_end
;
10018 unsigned long length
;
10019 unsigned long cie_id
;
10022 int need_col_headers
= 1;
10023 unsigned char *augmentation_data
= NULL
;
10024 unsigned long augmentation_data_len
= 0;
10025 int encoded_ptr_size
= eh_addr_size
;
10027 int initial_length_size
;
10029 saved_start
= start
;
10030 length
= byte_get (start
, 4); start
+= 4;
10034 printf ("\n%08lx ZERO terminator\n\n",
10035 (unsigned long)(saved_start
- section_start
));
10039 if (length
== 0xffffffff)
10041 length
= byte_get (start
, 8);
10044 initial_length_size
= 12;
10049 initial_length_size
= 4;
10052 block_end
= saved_start
+ length
+ initial_length_size
;
10053 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10055 if (elf_header
.e_type
== ET_REL
10056 && !debug_apply_rela_addends (file
, section
, offset_size
,
10057 section_start
, start
, block_end
))
10060 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10064 fc
= xmalloc (sizeof (Frame_Chunk
));
10065 memset (fc
, 0, sizeof (Frame_Chunk
));
10069 fc
->chunk_start
= saved_start
;
10071 fc
->col_type
= xmalloc (sizeof (short int));
10072 fc
->col_offset
= xmalloc (sizeof (int));
10073 frame_need_space (fc
, max_regs
-1);
10075 version
= *start
++;
10077 fc
->augmentation
= start
;
10078 start
= strchr (start
, '\0') + 1;
10080 if (fc
->augmentation
[0] == 'z')
10082 fc
->code_factor
= LEB ();
10083 fc
->data_factor
= SLEB ();
10092 augmentation_data_len
= LEB ();
10093 augmentation_data
= start
;
10094 start
+= augmentation_data_len
;
10096 else if (streq (fc
->augmentation
, "eh"))
10098 start
+= eh_addr_size
;
10099 fc
->code_factor
= LEB ();
10100 fc
->data_factor
= SLEB ();
10112 fc
->code_factor
= LEB ();
10113 fc
->data_factor
= SLEB ();
10125 if (do_debug_frames_interp
)
10126 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10127 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10128 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10132 printf ("\n%08lx %08lx %08lx CIE\n",
10133 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10134 printf (" Version: %d\n", version
);
10135 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10136 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10137 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10138 printf (" Return address column: %d\n", fc
->ra
);
10140 if (augmentation_data_len
)
10143 printf (" Augmentation data: ");
10144 for (i
= 0; i
< augmentation_data_len
; ++i
)
10145 printf (" %02x", augmentation_data
[i
]);
10151 if (augmentation_data_len
)
10153 unsigned char *p
, *q
;
10154 p
= fc
->augmentation
+ 1;
10155 q
= augmentation_data
;
10161 else if (*p
== 'P')
10162 q
+= 1 + size_of_encoded_value (*q
);
10163 else if (*p
== 'R')
10164 fc
->fde_encoding
= *q
++;
10170 if (fc
->fde_encoding
)
10171 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10174 frame_need_space (fc
, fc
->ra
);
10178 unsigned char *look_for
;
10179 static Frame_Chunk fde_fc
;
10182 memset (fc
, 0, sizeof (Frame_Chunk
));
10184 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10186 for (cie
= chunks
; cie
; cie
= cie
->next
)
10187 if (cie
->chunk_start
== look_for
)
10192 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10193 cie_id
, saved_start
);
10196 fc
->col_type
= xmalloc (sizeof (short int));
10197 fc
->col_offset
= xmalloc (sizeof (int));
10198 frame_need_space (fc
, max_regs
- 1);
10200 fc
->augmentation
= "";
10201 fc
->fde_encoding
= 0;
10205 fc
->ncols
= cie
->ncols
;
10206 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10207 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10208 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10209 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10210 fc
->augmentation
= cie
->augmentation
;
10211 fc
->code_factor
= cie
->code_factor
;
10212 fc
->data_factor
= cie
->data_factor
;
10213 fc
->cfa_reg
= cie
->cfa_reg
;
10214 fc
->cfa_offset
= cie
->cfa_offset
;
10216 frame_need_space (fc
, max_regs
-1);
10217 fc
->fde_encoding
= cie
->fde_encoding
;
10220 if (fc
->fde_encoding
)
10221 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10223 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10224 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10225 /* Don't adjust for ET_REL since there's invariably a pcrel
10226 reloc here, which we haven't applied. */
10227 && elf_header
.e_type
!= ET_REL
)
10228 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10229 start
+= encoded_ptr_size
;
10230 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10231 start
+= encoded_ptr_size
;
10233 if (cie
->augmentation
[0] == 'z')
10235 augmentation_data_len
= LEB ();
10236 augmentation_data
= start
;
10237 start
+= augmentation_data_len
;
10240 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10241 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10242 (unsigned long)(cie
->chunk_start
- section_start
),
10243 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10244 if (! do_debug_frames_interp
&& augmentation_data_len
)
10248 printf (" Augmentation data: ");
10249 for (i
= 0; i
< augmentation_data_len
; ++i
)
10250 printf (" %02x", augmentation_data
[i
]);
10256 /* At this point, fc is the current chunk, cie (if any) is set, and
10257 we're about to interpret instructions for the chunk. */
10258 /* ??? At present we need to do this always, since this sizes the
10259 fc->col_type and fc->col_offset arrays, which we write into always.
10260 We should probably split the interpreted and non-interpreted bits
10261 into two different routines, since there's so much that doesn't
10262 really overlap between them. */
10263 if (1 || do_debug_frames_interp
)
10265 /* Start by making a pass over the chunk, allocating storage
10266 and taking note of what registers are used. */
10267 unsigned char *tmp
= start
;
10269 while (start
< block_end
)
10272 unsigned long reg
, tmp
;
10279 /* Warning: if you add any more cases to this switch, be
10280 sure to add them to the corresponding switch below. */
10283 case DW_CFA_advance_loc
:
10285 case DW_CFA_offset
:
10287 frame_need_space (fc
, opa
);
10288 fc
->col_type
[opa
] = DW_CFA_undefined
;
10290 case DW_CFA_restore
:
10291 frame_need_space (fc
, opa
);
10292 fc
->col_type
[opa
] = DW_CFA_undefined
;
10294 case DW_CFA_set_loc
:
10295 start
+= encoded_ptr_size
;
10297 case DW_CFA_advance_loc1
:
10300 case DW_CFA_advance_loc2
:
10303 case DW_CFA_advance_loc4
:
10306 case DW_CFA_offset_extended
:
10307 reg
= LEB (); LEB ();
10308 frame_need_space (fc
, reg
);
10309 fc
->col_type
[reg
] = DW_CFA_undefined
;
10311 case DW_CFA_restore_extended
:
10313 frame_need_space (fc
, reg
);
10314 fc
->col_type
[reg
] = DW_CFA_undefined
;
10316 case DW_CFA_undefined
:
10318 frame_need_space (fc
, reg
);
10319 fc
->col_type
[reg
] = DW_CFA_undefined
;
10321 case DW_CFA_same_value
:
10323 frame_need_space (fc
, reg
);
10324 fc
->col_type
[reg
] = DW_CFA_undefined
;
10326 case DW_CFA_register
:
10327 reg
= LEB (); LEB ();
10328 frame_need_space (fc
, reg
);
10329 fc
->col_type
[reg
] = DW_CFA_undefined
;
10331 case DW_CFA_def_cfa
:
10334 case DW_CFA_def_cfa_register
:
10337 case DW_CFA_def_cfa_offset
:
10340 case DW_CFA_def_cfa_expression
:
10344 case DW_CFA_expression
:
10348 frame_need_space (fc
, reg
);
10349 fc
->col_type
[reg
] = DW_CFA_undefined
;
10351 case DW_CFA_offset_extended_sf
:
10352 reg
= LEB (); SLEB ();
10353 frame_need_space (fc
, reg
);
10354 fc
->col_type
[reg
] = DW_CFA_undefined
;
10356 case DW_CFA_def_cfa_sf
:
10359 case DW_CFA_def_cfa_offset_sf
:
10362 case DW_CFA_MIPS_advance_loc8
:
10365 case DW_CFA_GNU_args_size
:
10368 case DW_CFA_GNU_negative_offset_extended
:
10369 reg
= LEB (); LEB ();
10370 frame_need_space (fc
, reg
);
10371 fc
->col_type
[reg
] = DW_CFA_undefined
;
10380 /* Now we know what registers are used, make a second pass over
10381 the chunk, this time actually printing out the info. */
10383 while (start
< block_end
)
10386 unsigned long ul
, reg
, roffs
;
10395 /* Warning: if you add any more cases to this switch, be
10396 sure to add them to the corresponding switch above. */
10399 case DW_CFA_advance_loc
:
10400 if (do_debug_frames_interp
)
10401 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10403 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10404 opa
* fc
->code_factor
,
10405 fc
->pc_begin
+ opa
* fc
->code_factor
);
10406 fc
->pc_begin
+= opa
* fc
->code_factor
;
10409 case DW_CFA_offset
:
10411 if (! do_debug_frames_interp
)
10412 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10413 opa
, roffs
* fc
->data_factor
);
10414 fc
->col_type
[opa
] = DW_CFA_offset
;
10415 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10418 case DW_CFA_restore
:
10419 if (! do_debug_frames_interp
)
10420 printf (" DW_CFA_restore: r%d\n", opa
);
10421 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10422 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10425 case DW_CFA_set_loc
:
10426 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10427 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10428 && elf_header
.e_type
!= ET_REL
)
10429 vma
+= section
->sh_addr
+ (start
- section_start
);
10430 start
+= encoded_ptr_size
;
10431 if (do_debug_frames_interp
)
10432 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10434 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10435 fc
->pc_begin
= vma
;
10438 case DW_CFA_advance_loc1
:
10439 ofs
= byte_get (start
, 1); start
+= 1;
10440 if (do_debug_frames_interp
)
10441 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10443 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10444 ofs
* fc
->code_factor
,
10445 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10446 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10449 case DW_CFA_advance_loc2
:
10450 ofs
= byte_get (start
, 2); start
+= 2;
10451 if (do_debug_frames_interp
)
10452 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10454 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10455 ofs
* fc
->code_factor
,
10456 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10457 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10460 case DW_CFA_advance_loc4
:
10461 ofs
= byte_get (start
, 4); start
+= 4;
10462 if (do_debug_frames_interp
)
10463 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10465 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10466 ofs
* fc
->code_factor
,
10467 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10468 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10471 case DW_CFA_offset_extended
:
10474 if (! do_debug_frames_interp
)
10475 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10476 reg
, roffs
* fc
->data_factor
);
10477 fc
->col_type
[reg
] = DW_CFA_offset
;
10478 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10481 case DW_CFA_restore_extended
:
10483 if (! do_debug_frames_interp
)
10484 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10485 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10486 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10489 case DW_CFA_undefined
:
10491 if (! do_debug_frames_interp
)
10492 printf (" DW_CFA_undefined: r%ld\n", reg
);
10493 fc
->col_type
[reg
] = DW_CFA_undefined
;
10494 fc
->col_offset
[reg
] = 0;
10497 case DW_CFA_same_value
:
10499 if (! do_debug_frames_interp
)
10500 printf (" DW_CFA_same_value: r%ld\n", reg
);
10501 fc
->col_type
[reg
] = DW_CFA_same_value
;
10502 fc
->col_offset
[reg
] = 0;
10505 case DW_CFA_register
:
10508 if (! do_debug_frames_interp
)
10509 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10510 fc
->col_type
[reg
] = DW_CFA_register
;
10511 fc
->col_offset
[reg
] = roffs
;
10514 case DW_CFA_remember_state
:
10515 if (! do_debug_frames_interp
)
10516 printf (" DW_CFA_remember_state\n");
10517 rs
= xmalloc (sizeof (Frame_Chunk
));
10518 rs
->ncols
= fc
->ncols
;
10519 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10520 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10521 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10522 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10523 rs
->next
= remembered_state
;
10524 remembered_state
= rs
;
10527 case DW_CFA_restore_state
:
10528 if (! do_debug_frames_interp
)
10529 printf (" DW_CFA_restore_state\n");
10530 rs
= remembered_state
;
10533 remembered_state
= rs
->next
;
10534 frame_need_space (fc
, rs
->ncols
-1);
10535 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10536 memcpy (fc
->col_offset
, rs
->col_offset
,
10537 rs
->ncols
* sizeof (int));
10538 free (rs
->col_type
);
10539 free (rs
->col_offset
);
10542 else if (do_debug_frames_interp
)
10543 printf ("Mismatched DW_CFA_restore_state\n");
10546 case DW_CFA_def_cfa
:
10547 fc
->cfa_reg
= LEB ();
10548 fc
->cfa_offset
= LEB ();
10550 if (! do_debug_frames_interp
)
10551 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10552 fc
->cfa_reg
, fc
->cfa_offset
);
10555 case DW_CFA_def_cfa_register
:
10556 fc
->cfa_reg
= LEB ();
10558 if (! do_debug_frames_interp
)
10559 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10562 case DW_CFA_def_cfa_offset
:
10563 fc
->cfa_offset
= LEB ();
10564 if (! do_debug_frames_interp
)
10565 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10569 if (! do_debug_frames_interp
)
10570 printf (" DW_CFA_nop\n");
10573 case DW_CFA_def_cfa_expression
:
10575 if (! do_debug_frames_interp
)
10577 printf (" DW_CFA_def_cfa_expression (");
10578 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10585 case DW_CFA_expression
:
10588 if (! do_debug_frames_interp
)
10590 printf (" DW_CFA_expression: r%ld (", reg
);
10591 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10594 fc
->col_type
[reg
] = DW_CFA_expression
;
10598 case DW_CFA_offset_extended_sf
:
10601 frame_need_space (fc
, reg
);
10602 if (! do_debug_frames_interp
)
10603 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10604 reg
, l
* fc
->data_factor
);
10605 fc
->col_type
[reg
] = DW_CFA_offset
;
10606 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10609 case DW_CFA_def_cfa_sf
:
10610 fc
->cfa_reg
= LEB ();
10611 fc
->cfa_offset
= SLEB ();
10613 if (! do_debug_frames_interp
)
10614 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10615 fc
->cfa_reg
, fc
->cfa_offset
);
10618 case DW_CFA_def_cfa_offset_sf
:
10619 fc
->cfa_offset
= SLEB ();
10620 if (! do_debug_frames_interp
)
10621 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10624 case DW_CFA_MIPS_advance_loc8
:
10625 ofs
= byte_get (start
, 8); start
+= 8;
10626 if (do_debug_frames_interp
)
10627 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10629 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10630 ofs
* fc
->code_factor
,
10631 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10632 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10635 case DW_CFA_GNU_window_save
:
10636 if (! do_debug_frames_interp
)
10637 printf (" DW_CFA_GNU_window_save\n");
10640 case DW_CFA_GNU_args_size
:
10642 if (! do_debug_frames_interp
)
10643 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10646 case DW_CFA_GNU_negative_offset_extended
:
10649 frame_need_space (fc
, reg
);
10650 if (! do_debug_frames_interp
)
10651 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10652 reg
, l
* fc
->data_factor
);
10653 fc
->col_type
[reg
] = DW_CFA_offset
;
10654 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10658 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10663 if (do_debug_frames_interp
)
10664 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10679 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10680 unsigned char *start ATTRIBUTE_UNUSED
,
10681 FILE *file ATTRIBUTE_UNUSED
)
10683 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10684 SECTION_NAME (section
));
10689 /* A structure containing the name of a debug section
10690 and a pointer to a function that can decode it. */
10693 const char *const name
;
10694 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10698 { ".debug_abbrev", display_debug_abbrev
},
10699 { ".debug_aranges", display_debug_aranges
},
10700 { ".debug_frame", display_debug_frames
},
10701 { ".debug_info", display_debug_info
},
10702 { ".debug_line", display_debug_lines
},
10703 { ".debug_pubnames", display_debug_pubnames
},
10704 { ".eh_frame", display_debug_frames
},
10705 { ".debug_macinfo", display_debug_macinfo
},
10706 { ".debug_str", display_debug_str
},
10707 { ".debug_loc", display_debug_loc
},
10708 { ".debug_pubtypes", display_debug_pubnames
},
10709 { ".debug_ranges", display_debug_ranges
},
10710 { ".debug_static_func", display_debug_not_supported
},
10711 { ".debug_static_vars", display_debug_not_supported
},
10712 { ".debug_types", display_debug_not_supported
},
10713 { ".debug_weaknames", display_debug_not_supported
}
10717 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10719 char *name
= SECTION_NAME (section
);
10720 bfd_size_type length
;
10724 length
= section
->sh_size
;
10727 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10731 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10732 name
= ".debug_info";
10734 /* See if we know how to display the contents of this section. */
10735 for (i
= NUM_ELEM (debug_displays
); i
--;)
10736 if (streq (debug_displays
[i
].name
, name
))
10738 unsigned char *start
;
10740 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10741 _("debug section data"));
10748 result
&= debug_displays
[i
].display (section
, start
, file
);
10751 /* If we loaded in the abbrev section
10752 at some point, we must release it here. */
10760 printf (_("Unrecognized debug section: %s\n"), name
);
10768 process_section_contents (FILE *file
)
10770 Elf_Internal_Shdr
*section
;
10776 for (i
= 0, section
= section_headers
;
10777 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10780 #ifdef SUPPORT_DISASSEMBLY
10781 if (dump_sects
[i
] & DISASS_DUMP
)
10782 disassemble_section (section
, file
);
10784 if (dump_sects
[i
] & HEX_DUMP
)
10785 dump_section (section
, file
);
10787 if (dump_sects
[i
] & DEBUG_DUMP
)
10788 display_debug_section (section
, file
);
10791 /* Check to see if the user requested a
10792 dump of a section that does not exist. */
10793 while (i
++ < num_dump_sects
)
10795 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10799 process_mips_fpe_exception (int mask
)
10804 if (mask
& OEX_FPU_INEX
)
10805 fputs ("INEX", stdout
), first
= 0;
10806 if (mask
& OEX_FPU_UFLO
)
10807 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10808 if (mask
& OEX_FPU_OFLO
)
10809 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10810 if (mask
& OEX_FPU_DIV0
)
10811 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10812 if (mask
& OEX_FPU_INVAL
)
10813 printf ("%sINVAL", first
? "" : "|");
10816 fputs ("0", stdout
);
10820 process_mips_specific (FILE *file
)
10822 Elf_Internal_Dyn
*entry
;
10823 size_t liblist_offset
= 0;
10824 size_t liblistno
= 0;
10825 size_t conflictsno
= 0;
10826 size_t options_offset
= 0;
10827 size_t conflicts_offset
= 0;
10829 /* We have a lot of special sections. Thanks SGI! */
10830 if (dynamic_section
== NULL
)
10831 /* No information available. */
10834 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10835 switch (entry
->d_tag
)
10837 case DT_MIPS_LIBLIST
:
10839 = offset_from_vma (file
, entry
->d_un
.d_val
,
10840 liblistno
* sizeof (Elf32_External_Lib
));
10842 case DT_MIPS_LIBLISTNO
:
10843 liblistno
= entry
->d_un
.d_val
;
10845 case DT_MIPS_OPTIONS
:
10846 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10848 case DT_MIPS_CONFLICT
:
10850 = offset_from_vma (file
, entry
->d_un
.d_val
,
10851 conflictsno
* sizeof (Elf32_External_Conflict
));
10853 case DT_MIPS_CONFLICTNO
:
10854 conflictsno
= entry
->d_un
.d_val
;
10860 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10862 Elf32_External_Lib
*elib
;
10865 elib
= get_data (NULL
, file
, liblist_offset
,
10866 liblistno
* sizeof (Elf32_External_Lib
),
10870 printf ("\nSection '.liblist' contains %lu entries:\n",
10871 (unsigned long) liblistno
);
10872 fputs (" Library Time Stamp Checksum Version Flags\n",
10875 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10882 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10883 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10884 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10885 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10886 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10888 tmp
= gmtime (&time
);
10889 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10890 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10891 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10893 printf ("%3lu: ", (unsigned long) cnt
);
10894 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10895 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10897 printf ("<corrupt: %9ld>", liblist
.l_name
);
10898 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10899 liblist
.l_version
);
10901 if (liblist
.l_flags
== 0)
10905 static const struct
10912 { " EXACT_MATCH", LL_EXACT_MATCH
},
10913 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10914 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10915 { " EXPORTS", LL_EXPORTS
},
10916 { " DELAY_LOAD", LL_DELAY_LOAD
},
10917 { " DELTA", LL_DELTA
}
10919 int flags
= liblist
.l_flags
;
10923 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
10925 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10927 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10928 flags
^= l_flags_vals
[fcnt
].bit
;
10931 printf (" %#x", (unsigned int) flags
);
10941 if (options_offset
!= 0)
10943 Elf_External_Options
*eopt
;
10944 Elf_Internal_Shdr
*sect
= section_headers
;
10945 Elf_Internal_Options
*iopt
;
10946 Elf_Internal_Options
*option
;
10950 /* Find the section header so that we get the size. */
10951 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10954 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10958 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10961 error (_("Out of memory"));
10968 while (offset
< sect
->sh_size
)
10970 Elf_External_Options
*eoption
;
10972 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10974 option
->kind
= BYTE_GET (eoption
->kind
);
10975 option
->size
= BYTE_GET (eoption
->size
);
10976 option
->section
= BYTE_GET (eoption
->section
);
10977 option
->info
= BYTE_GET (eoption
->info
);
10979 offset
+= option
->size
;
10985 printf (_("\nSection '%s' contains %d entries:\n"),
10986 SECTION_NAME (sect
), cnt
);
10994 switch (option
->kind
)
10997 /* This shouldn't happen. */
10998 printf (" NULL %d %lx", option
->section
, option
->info
);
11001 printf (" REGINFO ");
11002 if (elf_header
.e_machine
== EM_MIPS
)
11005 Elf32_External_RegInfo
*ereg
;
11006 Elf32_RegInfo reginfo
;
11008 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11009 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11010 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11011 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11012 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11013 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11014 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11016 printf ("GPR %08lx GP 0x%lx\n",
11017 reginfo
.ri_gprmask
,
11018 (unsigned long) reginfo
.ri_gp_value
);
11019 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11020 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11021 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11026 Elf64_External_RegInfo
*ereg
;
11027 Elf64_Internal_RegInfo reginfo
;
11029 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11030 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11031 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11032 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11033 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11034 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11035 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11037 printf ("GPR %08lx GP 0x",
11038 reginfo
.ri_gprmask
);
11039 printf_vma (reginfo
.ri_gp_value
);
11042 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11043 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11044 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11048 case ODK_EXCEPTIONS
:
11049 fputs (" EXCEPTIONS fpe_min(", stdout
);
11050 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11051 fputs (") fpe_max(", stdout
);
11052 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11053 fputs (")", stdout
);
11055 if (option
->info
& OEX_PAGE0
)
11056 fputs (" PAGE0", stdout
);
11057 if (option
->info
& OEX_SMM
)
11058 fputs (" SMM", stdout
);
11059 if (option
->info
& OEX_FPDBUG
)
11060 fputs (" FPDBUG", stdout
);
11061 if (option
->info
& OEX_DISMISS
)
11062 fputs (" DISMISS", stdout
);
11065 fputs (" PAD ", stdout
);
11066 if (option
->info
& OPAD_PREFIX
)
11067 fputs (" PREFIX", stdout
);
11068 if (option
->info
& OPAD_POSTFIX
)
11069 fputs (" POSTFIX", stdout
);
11070 if (option
->info
& OPAD_SYMBOL
)
11071 fputs (" SYMBOL", stdout
);
11074 fputs (" HWPATCH ", stdout
);
11075 if (option
->info
& OHW_R4KEOP
)
11076 fputs (" R4KEOP", stdout
);
11077 if (option
->info
& OHW_R8KPFETCH
)
11078 fputs (" R8KPFETCH", stdout
);
11079 if (option
->info
& OHW_R5KEOP
)
11080 fputs (" R5KEOP", stdout
);
11081 if (option
->info
& OHW_R5KCVTL
)
11082 fputs (" R5KCVTL", stdout
);
11085 fputs (" FILL ", stdout
);
11086 /* XXX Print content of info word? */
11089 fputs (" TAGS ", stdout
);
11090 /* XXX Print content of info word? */
11093 fputs (" HWAND ", stdout
);
11094 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11095 fputs (" R4KEOP_CHECKED", stdout
);
11096 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11097 fputs (" R4KEOP_CLEAN", stdout
);
11100 fputs (" HWOR ", stdout
);
11101 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11102 fputs (" R4KEOP_CHECKED", stdout
);
11103 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11104 fputs (" R4KEOP_CLEAN", stdout
);
11107 printf (" GP_GROUP %#06lx self-contained %#06lx",
11108 option
->info
& OGP_GROUP
,
11109 (option
->info
& OGP_SELF
) >> 16);
11112 printf (" IDENT %#06lx self-contained %#06lx",
11113 option
->info
& OGP_GROUP
,
11114 (option
->info
& OGP_SELF
) >> 16);
11117 /* This shouldn't happen. */
11118 printf (" %3d ??? %d %lx",
11119 option
->kind
, option
->section
, option
->info
);
11123 len
= sizeof (*eopt
);
11124 while (len
< option
->size
)
11125 if (((char *) option
)[len
] >= ' '
11126 && ((char *) option
)[len
] < 0x7f)
11127 printf ("%c", ((char *) option
)[len
++]);
11129 printf ("\\%03o", ((char *) option
)[len
++]);
11131 fputs ("\n", stdout
);
11139 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11141 Elf32_Conflict
*iconf
;
11144 if (dynamic_symbols
== NULL
)
11146 error (_("conflict list found without a dynamic symbol table"));
11150 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11153 error (_("Out of memory"));
11159 Elf32_External_Conflict
*econf32
;
11161 econf32
= get_data (NULL
, file
, conflicts_offset
,
11162 conflictsno
* sizeof (*econf32
), _("conflict"));
11166 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11167 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11173 Elf64_External_Conflict
*econf64
;
11175 econf64
= get_data (NULL
, file
, conflicts_offset
,
11176 conflictsno
* sizeof (*econf64
), _("conflict"));
11180 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11181 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11186 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11187 (unsigned long) conflictsno
);
11188 puts (_(" Num: Index Value Name"));
11190 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11192 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11194 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11195 print_vma (psym
->st_value
, FULL_HEX
);
11197 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11198 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11200 printf ("<corrupt: %14ld>", psym
->st_name
);
11211 process_gnu_liblist (FILE *file
)
11213 Elf_Internal_Shdr
*section
, *string_sec
;
11214 Elf32_External_Lib
*elib
;
11222 for (i
= 0, section
= section_headers
;
11223 i
< elf_header
.e_shnum
;
11226 switch (section
->sh_type
)
11228 case SHT_GNU_LIBLIST
:
11229 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11234 string_sec
= SECTION_HEADER (section
->sh_link
);
11236 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11237 string_sec
->sh_size
, _("liblist string table"));
11240 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11246 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11247 SECTION_NAME (section
),
11248 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11250 puts (" Library Time Stamp Checksum Version Flags");
11252 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11260 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11261 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11262 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11263 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11264 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11266 tmp
= gmtime (&time
);
11267 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
11268 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11269 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11271 printf ("%3lu: ", (unsigned long) cnt
);
11273 printf ("%-20s", strtab
+ liblist
.l_name
);
11275 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11276 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11277 liblist
.l_version
, liblist
.l_flags
);
11287 static const char *
11288 get_note_type (unsigned e_type
)
11290 static char buff
[64];
11292 if (elf_header
.e_type
== ET_CORE
)
11296 return _("NT_AUXV (auxiliary vector)");
11298 return _("NT_PRSTATUS (prstatus structure)");
11300 return _("NT_FPREGSET (floating point registers)");
11302 return _("NT_PRPSINFO (prpsinfo structure)");
11303 case NT_TASKSTRUCT
:
11304 return _("NT_TASKSTRUCT (task structure)");
11306 return _("NT_PRXFPREG (user_xfpregs structure)");
11308 return _("NT_PSTATUS (pstatus structure)");
11310 return _("NT_FPREGS (floating point registers)");
11312 return _("NT_PSINFO (psinfo structure)");
11314 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11316 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11317 case NT_WIN32PSTATUS
:
11318 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11326 return _("NT_VERSION (version)");
11328 return _("NT_ARCH (architecture)");
11333 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11337 static const char *
11338 get_netbsd_elfcore_note_type (unsigned e_type
)
11340 static char buff
[64];
11342 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11344 /* NetBSD core "procinfo" structure. */
11345 return _("NetBSD procinfo structure");
11348 /* As of Jan 2002 there are no other machine-independent notes
11349 defined for NetBSD core files. If the note type is less
11350 than the start of the machine-dependent note types, we don't
11353 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11355 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
11359 switch (elf_header
.e_machine
)
11361 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11362 and PT_GETFPREGS == mach+2. */
11367 case EM_SPARC32PLUS
:
11371 case NT_NETBSDCORE_FIRSTMACH
+0:
11372 return _("PT_GETREGS (reg structure)");
11373 case NT_NETBSDCORE_FIRSTMACH
+2:
11374 return _("PT_GETFPREGS (fpreg structure)");
11380 /* On all other arch's, PT_GETREGS == mach+1 and
11381 PT_GETFPREGS == mach+3. */
11385 case NT_NETBSDCORE_FIRSTMACH
+1:
11386 return _("PT_GETREGS (reg structure)");
11387 case NT_NETBSDCORE_FIRSTMACH
+3:
11388 return _("PT_GETFPREGS (fpreg structure)");
11394 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
11398 /* Note that by the ELF standard, the name field is already null byte
11399 terminated, and namesz includes the terminating null byte.
11400 I.E. the value of namesz for the name "FSF" is 4.
11402 If the value of namesz is zero, there is no name present. */
11404 process_note (Elf_Internal_Note
*pnote
)
11408 if (pnote
->namesz
== 0)
11409 /* If there is no note name, then use the default set of
11410 note type strings. */
11411 nt
= get_note_type (pnote
->type
);
11413 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11414 /* NetBSD-specific core file notes. */
11415 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11418 /* Don't recognize this note name; just use the default set of
11419 note type strings. */
11420 nt
= get_note_type (pnote
->type
);
11422 printf (" %s\t\t0x%08lx\t%s\n",
11423 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11424 pnote
->descsz
, nt
);
11430 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11432 Elf_External_Note
*pnotes
;
11433 Elf_External_Note
*external
;
11439 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11445 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11446 (unsigned long) offset
, (unsigned long) length
);
11447 printf (_(" Owner\t\tData size\tDescription\n"));
11449 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11451 Elf_External_Note
*next
;
11452 Elf_Internal_Note inote
;
11455 inote
.type
= BYTE_GET (external
->type
);
11456 inote
.namesz
= BYTE_GET (external
->namesz
);
11457 inote
.namedata
= external
->name
;
11458 inote
.descsz
= BYTE_GET (external
->descsz
);
11459 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11460 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11462 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11464 if (((char *) next
) > (((char *) pnotes
) + length
))
11466 warn (_("corrupt note found at offset %x into core notes\n"),
11467 ((char *) external
) - ((char *) pnotes
));
11468 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11469 inote
.type
, inote
.namesz
, inote
.descsz
);
11475 /* Verify that name is null terminated. It appears that at least
11476 one version of Linux (RedHat 6.0) generates corefiles that don't
11477 comply with the ELF spec by failing to include the null byte in
11479 if (inote
.namedata
[inote
.namesz
] != '\0')
11481 temp
= malloc (inote
.namesz
+ 1);
11485 error (_("Out of memory\n"));
11490 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11491 temp
[inote
.namesz
] = 0;
11493 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11494 inote
.namedata
= temp
;
11497 res
&= process_note (& inote
);
11512 process_corefile_note_segments (FILE *file
)
11514 Elf_Internal_Phdr
*segment
;
11518 if (! get_program_headers (file
))
11521 for (i
= 0, segment
= program_headers
;
11522 i
< elf_header
.e_phnum
;
11525 if (segment
->p_type
== PT_NOTE
)
11526 res
&= process_corefile_note_segment (file
,
11527 (bfd_vma
) segment
->p_offset
,
11528 (bfd_vma
) segment
->p_filesz
);
11535 process_note_sections (FILE *file
)
11537 Elf_Internal_Shdr
*section
;
11541 for (i
= 0, section
= section_headers
;
11542 i
< elf_header
.e_shnum
;
11544 if (section
->sh_type
== SHT_NOTE
)
11545 res
&= process_corefile_note_segment (file
,
11546 (bfd_vma
) section
->sh_offset
,
11547 (bfd_vma
) section
->sh_size
);
11553 process_notes (FILE *file
)
11555 /* If we have not been asked to display the notes then do nothing. */
11559 if (elf_header
.e_type
!= ET_CORE
)
11560 return process_note_sections (file
);
11562 /* No program headers means no NOTE segment. */
11563 if (elf_header
.e_phnum
> 0)
11564 return process_corefile_note_segments (file
);
11566 printf (_("No note segments present in the core file.\n"));
11571 process_arch_specific (FILE *file
)
11576 switch (elf_header
.e_machine
)
11579 case EM_MIPS_RS3_LE
:
11580 return process_mips_specific (file
);
11589 get_file_header (FILE *file
)
11591 /* Read in the identity array. */
11592 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11595 /* Determine how to read the rest of the header. */
11596 switch (elf_header
.e_ident
[EI_DATA
])
11598 default: /* fall through */
11599 case ELFDATANONE
: /* fall through */
11601 byte_get
= byte_get_little_endian
;
11602 byte_put
= byte_put_little_endian
;
11605 byte_get
= byte_get_big_endian
;
11606 byte_put
= byte_put_big_endian
;
11610 /* For now we only support 32 bit and 64 bit ELF files. */
11611 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11613 /* Read in the rest of the header. */
11616 Elf32_External_Ehdr ehdr32
;
11618 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11621 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11622 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11623 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11624 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11625 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11626 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11627 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11628 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11629 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11630 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11631 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11632 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11633 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11637 Elf64_External_Ehdr ehdr64
;
11639 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11640 we will not be able to cope with the 64bit data found in
11641 64 ELF files. Detect this now and abort before we start
11642 overwriting things. */
11643 if (sizeof (bfd_vma
) < 8)
11645 error (_("This instance of readelf has been built without support for a\n\
11646 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11650 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11653 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11654 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11655 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11656 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11657 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11658 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11659 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11660 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11661 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11662 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11663 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11664 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11665 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11668 if (elf_header
.e_shoff
)
11670 /* There may be some extensions in the first section header. Don't
11671 bomb if we can't read it. */
11673 get_32bit_section_headers (file
, 1);
11675 get_64bit_section_headers (file
, 1);
11681 /* Process one ELF object file according to the command line options.
11682 This file may actually be stored in an archive. The file is
11683 positioned at the start of the ELF object. */
11686 process_object (char *file_name
, FILE *file
)
11690 if (! get_file_header (file
))
11692 error (_("%s: Failed to read file header\n"), file_name
);
11696 /* Initialise per file variables. */
11697 for (i
= NUM_ELEM (version_info
); i
--;)
11698 version_info
[i
] = 0;
11700 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11701 dynamic_info
[i
] = 0;
11703 /* Process the file. */
11705 printf (_("\nFile: %s\n"), file_name
);
11707 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11708 Note we do this even if cmdline_dump_sects is empty because we
11709 must make sure that the dump_sets array is zeroed out before each
11710 object file is processed. */
11711 if (num_dump_sects
> num_cmdline_dump_sects
)
11712 memset (dump_sects
, 0, num_dump_sects
);
11714 if (num_cmdline_dump_sects
> 0)
11716 if (num_dump_sects
== 0)
11717 /* A sneaky way of allocating the dump_sects array. */
11718 request_dump (num_cmdline_dump_sects
, 0);
11720 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11721 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11724 if (! process_file_header ())
11727 if (! process_section_headers (file
))
11729 /* Without loaded section headers we cannot process lots of
11731 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11733 if (! do_using_dynamic
)
11734 do_syms
= do_reloc
= 0;
11737 if (! process_section_groups (file
))
11739 /* Without loaded section groups we cannot process unwind. */
11743 if (process_program_headers (file
))
11744 process_dynamic_section (file
);
11746 process_relocs (file
);
11748 process_unwind (file
);
11750 process_symbol_table (file
);
11752 process_syminfo (file
);
11754 process_version_sections (file
);
11756 process_section_contents (file
);
11758 process_notes (file
);
11760 process_gnu_liblist (file
);
11762 process_arch_specific (file
);
11764 if (program_headers
)
11766 free (program_headers
);
11767 program_headers
= NULL
;
11770 if (section_headers
)
11772 free (section_headers
);
11773 section_headers
= NULL
;
11778 free (string_table
);
11779 string_table
= NULL
;
11780 string_table_length
= 0;
11783 if (dynamic_strings
)
11785 free (dynamic_strings
);
11786 dynamic_strings
= NULL
;
11787 dynamic_strings_length
= 0;
11790 if (dynamic_symbols
)
11792 free (dynamic_symbols
);
11793 dynamic_symbols
= NULL
;
11794 num_dynamic_syms
= 0;
11797 if (dynamic_syminfo
)
11799 free (dynamic_syminfo
);
11800 dynamic_syminfo
= NULL
;
11803 if (section_headers_groups
)
11805 free (section_headers_groups
);
11806 section_headers_groups
= NULL
;
11809 if (section_groups
)
11811 struct group_list
*g
, *next
;
11813 for (i
= 0; i
< group_count
; i
++)
11815 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11822 free (section_groups
);
11823 section_groups
= NULL
;
11826 if (debug_information
)
11828 for (i
= 0; i
< num_debug_info_entries
; i
++)
11830 if (!debug_information
[i
].max_loc_offsets
)
11832 free (debug_information
[i
].loc_offsets
);
11833 free (debug_information
[i
].have_frame_base
);
11835 if (!debug_information
[i
].max_range_lists
)
11836 free (debug_information
[i
].range_lists
);
11838 free (debug_information
);
11839 debug_information
= NULL
;
11840 num_debug_info_entries
= 0;
11846 /* Process an ELF archive. The file is positioned just after the
11850 process_archive (char *file_name
, FILE *file
)
11852 struct ar_hdr arhdr
;
11854 unsigned long size
;
11855 char *longnames
= NULL
;
11856 unsigned long longnames_size
= 0;
11857 size_t file_name_size
;
11862 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11863 if (got
!= sizeof arhdr
)
11868 error (_("%s: failed to read archive header\n"), file_name
);
11872 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
11874 /* This is the archive symbol table. Skip it.
11875 FIXME: We should have an option to dump it. */
11876 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11877 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
11879 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11883 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11884 if (got
!= sizeof arhdr
)
11889 error (_("%s: failed to read archive header\n"), file_name
);
11894 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
11896 /* This is the archive string table holding long member
11899 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11901 longnames
= malloc (longnames_size
);
11902 if (longnames
== NULL
)
11904 error (_("Out of memory\n"));
11908 if (fread (longnames
, longnames_size
, 1, file
) != 1)
11911 error (_("%s: failed to read string table\n"), file_name
);
11915 if ((longnames_size
& 1) != 0)
11918 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11919 if (got
!= sizeof arhdr
)
11926 error (_("%s: failed to read archive header\n"), file_name
);
11931 file_name_size
= strlen (file_name
);
11940 if (arhdr
.ar_name
[0] == '/')
11944 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
11945 if (off
>= longnames_size
)
11947 error (_("%s: invalid archive string table offset %lu\n"), off
);
11952 name
= longnames
+ off
;
11953 nameend
= memchr (name
, '/', longnames_size
- off
);
11957 name
= arhdr
.ar_name
;
11958 nameend
= memchr (name
, '/', 16);
11961 if (nameend
== NULL
)
11963 error (_("%s: bad archive file name\n"));
11968 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
11969 if (namealc
== NULL
)
11971 error (_("Out of memory\n"));
11976 memcpy (namealc
, file_name
, file_name_size
);
11977 namealc
[file_name_size
] = '(';
11978 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
11979 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
11980 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
11982 archive_file_offset
= ftell (file
);
11983 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11985 ret
|= process_object (namealc
, file
);
11990 (archive_file_offset
11991 + archive_file_size
11992 + (archive_file_size
& 1)),
11995 error (_("%s: failed to seek to next archive header\n"), file_name
);
12000 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12001 if (got
!= sizeof arhdr
)
12006 error (_("%s: failed to read archive header\n"), file_name
);
12012 if (longnames
!= 0)
12019 process_file (char *file_name
)
12022 struct stat statbuf
;
12023 char armag
[SARMAG
];
12026 if (stat (file_name
, &statbuf
) < 0)
12028 if (errno
== ENOENT
)
12029 error (_("'%s': No such file\n"), file_name
);
12031 error (_("Could not locate '%s'. System error message: %s\n"),
12032 file_name
, strerror (errno
));
12036 if (! S_ISREG (statbuf
.st_mode
))
12038 error (_("'%s' is not an ordinary file\n"), file_name
);
12042 file
= fopen (file_name
, "rb");
12045 error (_("Input file '%s' is not readable.\n"), file_name
);
12049 if (fread (armag
, SARMAG
, 1, file
) != 1)
12051 error (_("%s: Failed to read file header\n"), file_name
);
12056 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12057 ret
= process_archive (file_name
, file
);
12061 archive_file_size
= archive_file_offset
= 0;
12062 ret
= process_object (file_name
, file
);
12070 #ifdef SUPPORT_DISASSEMBLY
12071 /* Needed by the i386 disassembler. For extra credit, someone could
12072 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12076 print_address (unsigned int addr
, FILE *outfile
)
12078 fprintf (outfile
,"0x%8.8x", addr
);
12081 /* Needed by the i386 disassembler. */
12083 db_task_printsym (unsigned int addr
)
12085 print_address (addr
, stderr
);
12090 main (int argc
, char **argv
)
12094 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12095 setlocale (LC_MESSAGES
, "");
12097 #if defined (HAVE_SETLOCALE)
12098 setlocale (LC_CTYPE
, "");
12100 bindtextdomain (PACKAGE
, LOCALEDIR
);
12101 textdomain (PACKAGE
);
12103 parse_args (argc
, argv
);
12105 if (num_dump_sects
> 0)
12107 /* Make a copy of the dump_sects array. */
12108 cmdline_dump_sects
= malloc (num_dump_sects
);
12109 if (cmdline_dump_sects
== NULL
)
12110 error (_("Out of memory allocating dump request table."));
12113 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12114 num_cmdline_dump_sects
= num_dump_sects
;
12118 if (optind
< (argc
- 1))
12122 while (optind
< argc
)
12123 err
|= process_file (argv
[optind
++]);
12125 if (dump_sects
!= NULL
)
12127 if (cmdline_dump_sects
!= NULL
)
12128 free (cmdline_dump_sects
);