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
[64];
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 snprintf (buff
, sizeof (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 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1592 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1599 get_file_type (unsigned e_type
)
1601 static char buff
[32];
1605 case ET_NONE
: return _("NONE (None)");
1606 case ET_REL
: return _("REL (Relocatable file)");
1607 case ET_EXEC
: return _("EXEC (Executable file)");
1608 case ET_DYN
: return _("DYN (Shared object file)");
1609 case ET_CORE
: return _("CORE (Core file)");
1612 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1613 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1614 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1615 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1617 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1623 get_machine_name (unsigned e_machine
)
1625 static char buff
[64]; /* XXX */
1629 case EM_NONE
: return _("None");
1630 case EM_M32
: return "WE32100";
1631 case EM_SPARC
: return "Sparc";
1632 case EM_386
: return "Intel 80386";
1633 case EM_68K
: return "MC68000";
1634 case EM_88K
: return "MC88000";
1635 case EM_486
: return "Intel 80486";
1636 case EM_860
: return "Intel 80860";
1637 case EM_MIPS
: return "MIPS R3000";
1638 case EM_S370
: return "IBM System/370";
1639 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1640 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1641 case EM_PARISC
: return "HPPA";
1642 case EM_PPC_OLD
: return "Power PC (old)";
1643 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1644 case EM_960
: return "Intel 90860";
1645 case EM_PPC
: return "PowerPC";
1646 case EM_PPC64
: return "PowerPC64";
1647 case EM_V800
: return "NEC V800";
1648 case EM_FR20
: return "Fujitsu FR20";
1649 case EM_RH32
: return "TRW RH32";
1650 case EM_MCORE
: return "MCORE";
1651 case EM_ARM
: return "ARM";
1652 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1653 case EM_SH
: return "Renesas / SuperH SH";
1654 case EM_SPARCV9
: return "Sparc v9";
1655 case EM_TRICORE
: return "Siemens Tricore";
1656 case EM_ARC
: return "ARC";
1657 case EM_H8_300
: return "Renesas H8/300";
1658 case EM_H8_300H
: return "Renesas H8/300H";
1659 case EM_H8S
: return "Renesas H8S";
1660 case EM_H8_500
: return "Renesas H8/500";
1661 case EM_IA_64
: return "Intel IA-64";
1662 case EM_MIPS_X
: return "Stanford MIPS-X";
1663 case EM_COLDFIRE
: return "Motorola Coldfire";
1664 case EM_68HC12
: return "Motorola M68HC12";
1665 case EM_ALPHA
: return "Alpha";
1666 case EM_CYGNUS_D10V
:
1667 case EM_D10V
: return "d10v";
1668 case EM_CYGNUS_D30V
:
1669 case EM_D30V
: return "d30v";
1670 case EM_CYGNUS_M32R
:
1671 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1672 case EM_CYGNUS_V850
:
1673 case EM_V850
: return "NEC v850";
1674 case EM_CYGNUS_MN10300
:
1675 case EM_MN10300
: return "mn10300";
1676 case EM_CYGNUS_MN10200
:
1677 case EM_MN10200
: return "mn10200";
1678 case EM_CYGNUS_FR30
:
1679 case EM_FR30
: return "Fujitsu FR30";
1680 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1682 case EM_PJ
: return "picoJava";
1683 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1684 case EM_PCP
: return "Siemens PCP";
1685 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1686 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1687 case EM_STARCORE
: return "Motorola Star*Core processor";
1688 case EM_ME16
: return "Toyota ME16 processor";
1689 case EM_ST100
: return "STMicroelectronics ST100 processor";
1690 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1691 case EM_FX66
: return "Siemens FX66 microcontroller";
1692 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1693 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1694 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1695 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1696 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1697 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1698 case EM_SVX
: return "Silicon Graphics SVx";
1699 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1700 case EM_VAX
: return "Digital VAX";
1702 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1703 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1704 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1705 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1706 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1707 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1708 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1709 case EM_PRISM
: return "Vitesse Prism";
1710 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1712 case EM_S390
: return "IBM S/390";
1713 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1715 case EM_OR32
: return "OpenRISC";
1716 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1717 case EM_DLX
: return "OpenDLX";
1719 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1720 case EM_IQ2000
: return "Vitesse IQ2000";
1722 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1724 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_machine
);
1730 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1735 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1736 e_flags
&= ~ EF_ARM_EABIMASK
;
1738 /* Handle "generic" ARM flags. */
1739 if (e_flags
& EF_ARM_RELEXEC
)
1741 strcat (buf
, ", relocatable executable");
1742 e_flags
&= ~ EF_ARM_RELEXEC
;
1745 if (e_flags
& EF_ARM_HASENTRY
)
1747 strcat (buf
, ", has entry point");
1748 e_flags
&= ~ EF_ARM_HASENTRY
;
1751 /* Now handle EABI specific flags. */
1755 strcat (buf
, ", <unrecognized EABI>");
1760 case EF_ARM_EABI_VER1
:
1761 strcat (buf
, ", Version1 EABI");
1766 /* Process flags one bit at a time. */
1767 flag
= e_flags
& - e_flags
;
1772 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1773 strcat (buf
, ", sorted symbol tables");
1783 case EF_ARM_EABI_VER2
:
1784 strcat (buf
, ", Version2 EABI");
1789 /* Process flags one bit at a time. */
1790 flag
= e_flags
& - e_flags
;
1795 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1796 strcat (buf
, ", sorted symbol tables");
1799 case EF_ARM_DYNSYMSUSESEGIDX
:
1800 strcat (buf
, ", dynamic symbols use segment index");
1803 case EF_ARM_MAPSYMSFIRST
:
1804 strcat (buf
, ", mapping symbols precede others");
1814 case EF_ARM_EABI_VER3
:
1815 strcat (buf
, ", Version3 EABI");
1818 case EF_ARM_EABI_VER4
:
1819 strcat (buf
, ", Version4 EABI");
1824 /* Process flags one bit at a time. */
1825 flag
= e_flags
& - e_flags
;
1831 strcat (buf
, ", BE8");
1835 strcat (buf
, ", LE8");
1845 case EF_ARM_EABI_UNKNOWN
:
1846 strcat (buf
, ", GNU EABI");
1851 /* Process flags one bit at a time. */
1852 flag
= e_flags
& - e_flags
;
1857 case EF_ARM_INTERWORK
:
1858 strcat (buf
, ", interworking enabled");
1861 case EF_ARM_APCS_26
:
1862 strcat (buf
, ", uses APCS/26");
1865 case EF_ARM_APCS_FLOAT
:
1866 strcat (buf
, ", uses APCS/float");
1870 strcat (buf
, ", position independent");
1874 strcat (buf
, ", 8 bit structure alignment");
1877 case EF_ARM_NEW_ABI
:
1878 strcat (buf
, ", uses new ABI");
1881 case EF_ARM_OLD_ABI
:
1882 strcat (buf
, ", uses old ABI");
1885 case EF_ARM_SOFT_FLOAT
:
1886 strcat (buf
, ", software FP");
1889 case EF_ARM_VFP_FLOAT
:
1890 strcat (buf
, ", VFP");
1893 case EF_ARM_MAVERICK_FLOAT
:
1894 strcat (buf
, ", Maverick FP");
1905 strcat (buf
,", <unknown>");
1909 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1911 static char buf
[1024];
1923 decode_ARM_machine_flags (e_flags
, buf
);
1927 switch (e_flags
& EF_FRV_CPU_MASK
)
1929 case EF_FRV_CPU_GENERIC
:
1933 strcat (buf
, ", fr???");
1936 case EF_FRV_CPU_FR300
:
1937 strcat (buf
, ", fr300");
1940 case EF_FRV_CPU_FR400
:
1941 strcat (buf
, ", fr400");
1943 case EF_FRV_CPU_FR405
:
1944 strcat (buf
, ", fr405");
1947 case EF_FRV_CPU_FR450
:
1948 strcat (buf
, ", fr450");
1951 case EF_FRV_CPU_FR500
:
1952 strcat (buf
, ", fr500");
1954 case EF_FRV_CPU_FR550
:
1955 strcat (buf
, ", fr550");
1958 case EF_FRV_CPU_SIMPLE
:
1959 strcat (buf
, ", simple");
1961 case EF_FRV_CPU_TOMCAT
:
1962 strcat (buf
, ", tomcat");
1968 if (e_flags
& EF_CPU32
)
1969 strcat (buf
, ", cpu32");
1970 if (e_flags
& EF_M68000
)
1971 strcat (buf
, ", m68000");
1975 if (e_flags
& EF_PPC_EMB
)
1976 strcat (buf
, ", emb");
1978 if (e_flags
& EF_PPC_RELOCATABLE
)
1979 strcat (buf
, ", relocatable");
1981 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1982 strcat (buf
, ", relocatable-lib");
1986 case EM_CYGNUS_V850
:
1987 switch (e_flags
& EF_V850_ARCH
)
1990 strcat (buf
, ", v850e1");
1993 strcat (buf
, ", v850e");
1996 strcat (buf
, ", v850");
1999 strcat (buf
, ", unknown v850 architecture variant");
2005 case EM_CYGNUS_M32R
:
2006 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2007 strcat (buf
, ", m32r");
2012 case EM_MIPS_RS3_LE
:
2013 if (e_flags
& EF_MIPS_NOREORDER
)
2014 strcat (buf
, ", noreorder");
2016 if (e_flags
& EF_MIPS_PIC
)
2017 strcat (buf
, ", pic");
2019 if (e_flags
& EF_MIPS_CPIC
)
2020 strcat (buf
, ", cpic");
2022 if (e_flags
& EF_MIPS_UCODE
)
2023 strcat (buf
, ", ugen_reserved");
2025 if (e_flags
& EF_MIPS_ABI2
)
2026 strcat (buf
, ", abi2");
2028 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2029 strcat (buf
, ", odk first");
2031 if (e_flags
& EF_MIPS_32BITMODE
)
2032 strcat (buf
, ", 32bitmode");
2034 switch ((e_flags
& EF_MIPS_MACH
))
2036 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2037 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2038 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2039 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2040 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2041 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2042 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2043 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2044 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2045 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2047 /* We simply ignore the field in this case to avoid confusion:
2048 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2051 default: strcat (buf
, ", unknown CPU"); break;
2054 switch ((e_flags
& EF_MIPS_ABI
))
2056 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2057 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2058 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2059 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2061 /* We simply ignore the field in this case to avoid confusion:
2062 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2063 This means it is likely to be an o32 file, but not for
2066 default: strcat (buf
, ", unknown ABI"); break;
2069 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2070 strcat (buf
, ", mdmx");
2072 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2073 strcat (buf
, ", mips16");
2075 switch ((e_flags
& EF_MIPS_ARCH
))
2077 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2078 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2079 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2080 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2081 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2082 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2083 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2084 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2085 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2086 default: strcat (buf
, ", unknown ISA"); break;
2092 switch ((e_flags
& EF_SH_MACH_MASK
))
2094 case EF_SH1
: strcat (buf
, ", sh1"); break;
2095 case EF_SH2
: strcat (buf
, ", sh2"); break;
2096 case EF_SH3
: strcat (buf
, ", sh3"); break;
2097 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2098 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2099 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2100 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2101 case EF_SH4
: strcat (buf
, ", sh4"); break;
2102 case EF_SH5
: strcat (buf
, ", sh5"); break;
2103 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2104 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2105 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2106 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2107 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2108 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2109 default: strcat (buf
, ", unknown ISA"); break;
2115 if (e_flags
& EF_SPARC_32PLUS
)
2116 strcat (buf
, ", v8+");
2118 if (e_flags
& EF_SPARC_SUN_US1
)
2119 strcat (buf
, ", ultrasparcI");
2121 if (e_flags
& EF_SPARC_SUN_US3
)
2122 strcat (buf
, ", ultrasparcIII");
2124 if (e_flags
& EF_SPARC_HAL_R1
)
2125 strcat (buf
, ", halr1");
2127 if (e_flags
& EF_SPARC_LEDATA
)
2128 strcat (buf
, ", ledata");
2130 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2131 strcat (buf
, ", tso");
2133 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2134 strcat (buf
, ", pso");
2136 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2137 strcat (buf
, ", rmo");
2141 switch (e_flags
& EF_PARISC_ARCH
)
2143 case EFA_PARISC_1_0
:
2144 strcpy (buf
, ", PA-RISC 1.0");
2146 case EFA_PARISC_1_1
:
2147 strcpy (buf
, ", PA-RISC 1.1");
2149 case EFA_PARISC_2_0
:
2150 strcpy (buf
, ", PA-RISC 2.0");
2155 if (e_flags
& EF_PARISC_TRAPNIL
)
2156 strcat (buf
, ", trapnil");
2157 if (e_flags
& EF_PARISC_EXT
)
2158 strcat (buf
, ", ext");
2159 if (e_flags
& EF_PARISC_LSB
)
2160 strcat (buf
, ", lsb");
2161 if (e_flags
& EF_PARISC_WIDE
)
2162 strcat (buf
, ", wide");
2163 if (e_flags
& EF_PARISC_NO_KABP
)
2164 strcat (buf
, ", no kabp");
2165 if (e_flags
& EF_PARISC_LAZYSWAP
)
2166 strcat (buf
, ", lazyswap");
2171 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2172 strcat (buf
, ", new calling convention");
2174 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2175 strcat (buf
, ", gnu calling convention");
2179 if ((e_flags
& EF_IA_64_ABI64
))
2180 strcat (buf
, ", 64-bit");
2182 strcat (buf
, ", 32-bit");
2183 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2184 strcat (buf
, ", reduced fp model");
2185 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2186 strcat (buf
, ", no function descriptors, constant gp");
2187 else if ((e_flags
& EF_IA_64_CONS_GP
))
2188 strcat (buf
, ", constant gp");
2189 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2190 strcat (buf
, ", absolute");
2194 if ((e_flags
& EF_VAX_NONPIC
))
2195 strcat (buf
, ", non-PIC");
2196 if ((e_flags
& EF_VAX_DFLOAT
))
2197 strcat (buf
, ", D-Float");
2198 if ((e_flags
& EF_VAX_GFLOAT
))
2199 strcat (buf
, ", G-Float");
2208 get_osabi_name (unsigned int osabi
)
2210 static char buff
[32];
2214 case ELFOSABI_NONE
: return "UNIX - System V";
2215 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2216 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2217 case ELFOSABI_LINUX
: return "UNIX - Linux";
2218 case ELFOSABI_HURD
: return "GNU/Hurd";
2219 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2220 case ELFOSABI_AIX
: return "UNIX - AIX";
2221 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2222 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2223 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2224 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2225 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2226 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2227 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2228 case ELFOSABI_AROS
: return "Amiga Research OS";
2229 case ELFOSABI_STANDALONE
: return _("Standalone App");
2230 case ELFOSABI_ARM
: return "ARM";
2232 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2238 get_mips_segment_type (unsigned long type
)
2242 case PT_MIPS_REGINFO
:
2244 case PT_MIPS_RTPROC
:
2246 case PT_MIPS_OPTIONS
:
2256 get_parisc_segment_type (unsigned long type
)
2260 case PT_HP_TLS
: return "HP_TLS";
2261 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2262 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2263 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2264 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2265 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2266 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2267 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2268 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2269 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2270 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2271 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2272 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2273 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2282 get_ia64_segment_type (unsigned long type
)
2286 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2287 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2288 case PT_HP_TLS
: return "HP_TLS";
2289 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2290 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2291 case PT_IA_64_HP_STACK
: return "HP_STACK";
2300 get_segment_type (unsigned long p_type
)
2302 static char buff
[32];
2306 case PT_NULL
: return "NULL";
2307 case PT_LOAD
: return "LOAD";
2308 case PT_DYNAMIC
: return "DYNAMIC";
2309 case PT_INTERP
: return "INTERP";
2310 case PT_NOTE
: return "NOTE";
2311 case PT_SHLIB
: return "SHLIB";
2312 case PT_PHDR
: return "PHDR";
2313 case PT_TLS
: return "TLS";
2315 case PT_GNU_EH_FRAME
:
2316 return "GNU_EH_FRAME";
2317 case PT_GNU_STACK
: return "GNU_STACK";
2318 case PT_GNU_RELRO
: return "GNU_RELRO";
2321 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2325 switch (elf_header
.e_machine
)
2328 case EM_MIPS_RS3_LE
:
2329 result
= get_mips_segment_type (p_type
);
2332 result
= get_parisc_segment_type (p_type
);
2335 result
= get_ia64_segment_type (p_type
);
2345 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2347 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2351 switch (elf_header
.e_machine
)
2354 result
= get_parisc_segment_type (p_type
);
2357 result
= get_ia64_segment_type (p_type
);
2367 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2370 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2377 get_mips_section_type_name (unsigned int sh_type
)
2381 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2382 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2383 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2384 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2385 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2386 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2387 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2388 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2389 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2390 case SHT_MIPS_RELD
: return "MIPS_RELD";
2391 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2392 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2393 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2394 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2395 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2396 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2397 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2398 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2399 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2400 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2401 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2402 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2403 case SHT_MIPS_LINE
: return "MIPS_LINE";
2404 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2405 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2406 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2407 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2408 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2409 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2410 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2411 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2412 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2413 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2414 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2415 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2416 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2417 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2418 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2419 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2427 get_parisc_section_type_name (unsigned int sh_type
)
2431 case SHT_PARISC_EXT
: return "PARISC_EXT";
2432 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2433 case SHT_PARISC_DOC
: return "PARISC_DOC";
2441 get_ia64_section_type_name (unsigned int sh_type
)
2443 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2444 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2445 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2449 case SHT_IA_64_EXT
: return "IA_64_EXT";
2450 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2451 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2459 get_x86_64_section_type_name (unsigned int sh_type
)
2463 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2471 get_arm_section_type_name (unsigned int sh_type
)
2484 get_section_type_name (unsigned int sh_type
)
2486 static char buff
[32];
2490 case SHT_NULL
: return "NULL";
2491 case SHT_PROGBITS
: return "PROGBITS";
2492 case SHT_SYMTAB
: return "SYMTAB";
2493 case SHT_STRTAB
: return "STRTAB";
2494 case SHT_RELA
: return "RELA";
2495 case SHT_HASH
: return "HASH";
2496 case SHT_DYNAMIC
: return "DYNAMIC";
2497 case SHT_NOTE
: return "NOTE";
2498 case SHT_NOBITS
: return "NOBITS";
2499 case SHT_REL
: return "REL";
2500 case SHT_SHLIB
: return "SHLIB";
2501 case SHT_DYNSYM
: return "DYNSYM";
2502 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2503 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2504 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2505 case SHT_GROUP
: return "GROUP";
2506 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2507 case SHT_GNU_verdef
: return "VERDEF";
2508 case SHT_GNU_verneed
: return "VERNEED";
2509 case SHT_GNU_versym
: return "VERSYM";
2510 case 0x6ffffff0: return "VERSYM";
2511 case 0x6ffffffc: return "VERDEF";
2512 case 0x7ffffffd: return "AUXILIARY";
2513 case 0x7fffffff: return "FILTER";
2514 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2517 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2521 switch (elf_header
.e_machine
)
2524 case EM_MIPS_RS3_LE
:
2525 result
= get_mips_section_type_name (sh_type
);
2528 result
= get_parisc_section_type_name (sh_type
);
2531 result
= get_ia64_section_type_name (sh_type
);
2534 result
= get_x86_64_section_type_name (sh_type
);
2537 result
= get_arm_section_type_name (sh_type
);
2547 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2549 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2550 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2551 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2552 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2554 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2560 #define OPTION_DEBUG_DUMP 512
2562 struct option options
[] =
2564 {"all", no_argument
, 0, 'a'},
2565 {"file-header", no_argument
, 0, 'h'},
2566 {"program-headers", no_argument
, 0, 'l'},
2567 {"headers", no_argument
, 0, 'e'},
2568 {"histogram", no_argument
, 0, 'I'},
2569 {"segments", no_argument
, 0, 'l'},
2570 {"sections", no_argument
, 0, 'S'},
2571 {"section-headers", no_argument
, 0, 'S'},
2572 {"section-groups", no_argument
, 0, 'g'},
2573 {"symbols", no_argument
, 0, 's'},
2574 {"syms", no_argument
, 0, 's'},
2575 {"relocs", no_argument
, 0, 'r'},
2576 {"notes", no_argument
, 0, 'n'},
2577 {"dynamic", no_argument
, 0, 'd'},
2578 {"arch-specific", no_argument
, 0, 'A'},
2579 {"version-info", no_argument
, 0, 'V'},
2580 {"use-dynamic", no_argument
, 0, 'D'},
2581 {"hex-dump", required_argument
, 0, 'x'},
2582 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2583 {"unwind", no_argument
, 0, 'u'},
2584 #ifdef SUPPORT_DISASSEMBLY
2585 {"instruction-dump", required_argument
, 0, 'i'},
2588 {"version", no_argument
, 0, 'v'},
2589 {"wide", no_argument
, 0, 'W'},
2590 {"help", no_argument
, 0, 'H'},
2591 {0, no_argument
, 0, 0}
2597 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2598 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2599 fprintf (stdout
, _(" Options are:\n\
2600 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2601 -h --file-header Display the ELF file header\n\
2602 -l --program-headers Display the program headers\n\
2603 --segments An alias for --program-headers\n\
2604 -S --section-headers Display the sections' header\n\
2605 --sections An alias for --section-headers\n\
2606 -g --section-groups Display the section groups\n\
2607 -e --headers Equivalent to: -h -l -S\n\
2608 -s --syms Display the symbol table\n\
2609 --symbols An alias for --syms\n\
2610 -n --notes Display the core notes (if present)\n\
2611 -r --relocs Display the relocations (if present)\n\
2612 -u --unwind Display the unwind info (if present)\n\
2613 -d --dynamic Display the dynamic section (if present)\n\
2614 -V --version-info Display the version sections (if present)\n\
2615 -A --arch-specific Display architecture specific information (if any).\n\
2616 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2617 -x --hex-dump=<number> Dump the contents of section <number>\n\
2618 -w[liaprmfFsoR] or\n\
2619 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2620 Display the contents of DWARF2 debug sections\n"));
2621 #ifdef SUPPORT_DISASSEMBLY
2622 fprintf (stdout
, _("\
2623 -i --instruction-dump=<number>\n\
2624 Disassemble the contents of section <number>\n"));
2626 fprintf (stdout
, _("\
2627 -I --histogram Display histogram of bucket list lengths\n\
2628 -W --wide Allow output width to exceed 80 characters\n\
2629 -H --help Display this information\n\
2630 -v --version Display the version number of readelf\n"));
2631 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2636 /* Record the fact that the user wants the contents of section number
2637 SECTION to be displayed using the method(s) encoded as flags bits
2638 in TYPE. Note, TYPE can be zero if we are creating the array for
2642 request_dump (unsigned int section
, int type
)
2644 if (section
>= num_dump_sects
)
2646 char *new_dump_sects
;
2648 new_dump_sects
= calloc (section
+ 1, 1);
2650 if (new_dump_sects
== NULL
)
2651 error (_("Out of memory allocating dump request table."));
2654 /* Copy current flag settings. */
2655 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2659 dump_sects
= new_dump_sects
;
2660 num_dump_sects
= section
+ 1;
2665 dump_sects
[section
] |= type
;
2671 parse_args (int argc
, char **argv
)
2678 while ((c
= getopt_long
2679 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2700 do_section_groups
++;
2708 do_section_groups
++;
2750 section
= strtoul (optarg
, & cp
, 0);
2751 if (! *cp
&& section
>= 0)
2753 request_dump (section
, HEX_DUMP
);
2763 unsigned int index
= 0;
2767 while (optarg
[index
])
2768 switch (optarg
[index
++])
2777 do_debug_abbrevs
= 1;
2787 do_debug_pubnames
= 1;
2791 do_debug_aranges
= 1;
2795 do_debug_ranges
= 1;
2799 do_debug_frames_interp
= 1;
2801 do_debug_frames
= 1;
2806 do_debug_macinfo
= 1;
2820 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2825 case OPTION_DEBUG_DUMP
:
2833 const char * option
;
2836 debug_dump_long_opts
;
2838 debug_dump_long_opts opts_table
[] =
2840 /* Please keep this table alpha- sorted. */
2841 { "Ranges", & do_debug_ranges
},
2842 { "abbrev", & do_debug_abbrevs
},
2843 { "aranges", & do_debug_aranges
},
2844 { "frames", & do_debug_frames
},
2845 { "frames-interp", & do_debug_frames_interp
},
2846 { "info", & do_debug_info
},
2847 { "line", & do_debug_lines
},
2848 { "loc", & do_debug_loc
},
2849 { "macro", & do_debug_macinfo
},
2850 { "pubnames", & do_debug_pubnames
},
2851 /* This entry is for compatability
2852 with earlier versions of readelf. */
2853 { "ranges", & do_debug_aranges
},
2854 { "str", & do_debug_str
},
2865 debug_dump_long_opts
* entry
;
2867 for (entry
= opts_table
; entry
->option
; entry
++)
2869 size_t len
= strlen (entry
->option
);
2871 if (strneq (p
, entry
->option
, len
)
2872 && (p
[len
] == ',' || p
[len
] == '\0'))
2874 * entry
->variable
= 1;
2876 /* The --debug-dump=frames-interp option also
2877 enables the --debug-dump=frames option. */
2878 if (do_debug_frames_interp
)
2879 do_debug_frames
= 1;
2886 if (entry
->option
== NULL
)
2888 warn (_("Unrecognized debug option '%s'\n"), p
);
2889 p
= strchr (p
, ',');
2899 #ifdef SUPPORT_DISASSEMBLY
2902 section
= strtoul (optarg
, & cp
, 0);
2903 if (! *cp
&& section
>= 0)
2905 request_dump (section
, DISASS_DUMP
);
2911 print_version (program_name
);
2921 /* xgettext:c-format */
2922 error (_("Invalid option '-%c'\n"), c
);
2929 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2930 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2931 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2932 && !do_section_groups
)
2936 warn (_("Nothing to do.\n"));
2942 get_elf_class (unsigned int elf_class
)
2944 static char buff
[32];
2948 case ELFCLASSNONE
: return _("none");
2949 case ELFCLASS32
: return "ELF32";
2950 case ELFCLASS64
: return "ELF64";
2952 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
2958 get_data_encoding (unsigned int encoding
)
2960 static char buff
[32];
2964 case ELFDATANONE
: return _("none");
2965 case ELFDATA2LSB
: return _("2's complement, little endian");
2966 case ELFDATA2MSB
: return _("2's complement, big endian");
2968 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
2973 /* Decode the data held in 'elf_header'. */
2976 process_file_header (void)
2978 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2979 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2980 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2981 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2984 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2992 printf (_("ELF Header:\n"));
2993 printf (_(" Magic: "));
2994 for (i
= 0; i
< EI_NIDENT
; i
++)
2995 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2997 printf (_(" Class: %s\n"),
2998 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2999 printf (_(" Data: %s\n"),
3000 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3001 printf (_(" Version: %d %s\n"),
3002 elf_header
.e_ident
[EI_VERSION
],
3003 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3005 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3008 printf (_(" OS/ABI: %s\n"),
3009 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3010 printf (_(" ABI Version: %d\n"),
3011 elf_header
.e_ident
[EI_ABIVERSION
]);
3012 printf (_(" Type: %s\n"),
3013 get_file_type (elf_header
.e_type
));
3014 printf (_(" Machine: %s\n"),
3015 get_machine_name (elf_header
.e_machine
));
3016 printf (_(" Version: 0x%lx\n"),
3017 (unsigned long) elf_header
.e_version
);
3019 printf (_(" Entry point address: "));
3020 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3021 printf (_("\n Start of program headers: "));
3022 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3023 printf (_(" (bytes into file)\n Start of section headers: "));
3024 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3025 printf (_(" (bytes into file)\n"));
3027 printf (_(" Flags: 0x%lx%s\n"),
3028 (unsigned long) elf_header
.e_flags
,
3029 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3030 printf (_(" Size of this header: %ld (bytes)\n"),
3031 (long) elf_header
.e_ehsize
);
3032 printf (_(" Size of program headers: %ld (bytes)\n"),
3033 (long) elf_header
.e_phentsize
);
3034 printf (_(" Number of program headers: %ld\n"),
3035 (long) elf_header
.e_phnum
);
3036 printf (_(" Size of section headers: %ld (bytes)\n"),
3037 (long) elf_header
.e_shentsize
);
3038 printf (_(" Number of section headers: %ld"),
3039 (long) elf_header
.e_shnum
);
3040 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3041 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3042 putc ('\n', stdout
);
3043 printf (_(" Section header string table index: %ld"),
3044 (long) elf_header
.e_shstrndx
);
3045 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3046 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3047 putc ('\n', stdout
);
3050 if (section_headers
!= NULL
)
3052 if (elf_header
.e_shnum
== 0)
3053 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3054 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3055 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3056 free (section_headers
);
3057 section_headers
= NULL
;
3065 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3067 Elf32_External_Phdr
*phdrs
;
3068 Elf32_External_Phdr
*external
;
3069 Elf_Internal_Phdr
*internal
;
3072 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3073 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3074 _("program headers"));
3078 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3079 i
< elf_header
.e_phnum
;
3080 i
++, internal
++, external
++)
3082 internal
->p_type
= BYTE_GET (external
->p_type
);
3083 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3084 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3085 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3086 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3087 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3088 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3089 internal
->p_align
= BYTE_GET (external
->p_align
);
3098 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3100 Elf64_External_Phdr
*phdrs
;
3101 Elf64_External_Phdr
*external
;
3102 Elf_Internal_Phdr
*internal
;
3105 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3106 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3107 _("program headers"));
3111 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3112 i
< elf_header
.e_phnum
;
3113 i
++, internal
++, external
++)
3115 internal
->p_type
= BYTE_GET (external
->p_type
);
3116 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3117 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3118 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3119 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3120 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3121 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3122 internal
->p_align
= BYTE_GET (external
->p_align
);
3130 /* Returns 1 if the program headers were read into `program_headers'. */
3133 get_program_headers (FILE *file
)
3135 Elf_Internal_Phdr
*phdrs
;
3137 /* Check cache of prior read. */
3138 if (program_headers
!= NULL
)
3141 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3145 error (_("Out of memory\n"));
3150 ? get_32bit_program_headers (file
, phdrs
)
3151 : get_64bit_program_headers (file
, phdrs
))
3153 program_headers
= phdrs
;
3161 /* Returns 1 if the program headers were loaded. */
3164 process_program_headers (FILE *file
)
3166 Elf_Internal_Phdr
*segment
;
3169 if (elf_header
.e_phnum
== 0)
3172 printf (_("\nThere are no program headers in this file.\n"));
3176 if (do_segments
&& !do_header
)
3178 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3179 printf (_("Entry point "));
3180 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3181 printf (_("\nThere are %d program headers, starting at offset "),
3182 elf_header
.e_phnum
);
3183 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3187 if (! get_program_headers (file
))
3192 if (elf_header
.e_phnum
> 1)
3193 printf (_("\nProgram Headers:\n"));
3195 printf (_("\nProgram Headers:\n"));
3199 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3202 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3206 (_(" Type Offset VirtAddr PhysAddr\n"));
3208 (_(" FileSiz MemSiz Flags Align\n"));
3215 for (i
= 0, segment
= program_headers
;
3216 i
< elf_header
.e_phnum
;
3221 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3225 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3226 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3227 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3228 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3229 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3231 (segment
->p_flags
& PF_R
? 'R' : ' '),
3232 (segment
->p_flags
& PF_W
? 'W' : ' '),
3233 (segment
->p_flags
& PF_X
? 'E' : ' '));
3234 printf ("%#lx", (unsigned long) segment
->p_align
);
3238 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3239 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3242 print_vma (segment
->p_offset
, FULL_HEX
);
3246 print_vma (segment
->p_vaddr
, FULL_HEX
);
3248 print_vma (segment
->p_paddr
, FULL_HEX
);
3251 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3252 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3255 print_vma (segment
->p_filesz
, FULL_HEX
);
3259 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3260 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3263 print_vma (segment
->p_offset
, FULL_HEX
);
3267 (segment
->p_flags
& PF_R
? 'R' : ' '),
3268 (segment
->p_flags
& PF_W
? 'W' : ' '),
3269 (segment
->p_flags
& PF_X
? 'E' : ' '));
3271 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3272 printf ("%#lx", (unsigned long) segment
->p_align
);
3275 print_vma (segment
->p_align
, PREFIX_HEX
);
3280 print_vma (segment
->p_offset
, FULL_HEX
);
3282 print_vma (segment
->p_vaddr
, FULL_HEX
);
3284 print_vma (segment
->p_paddr
, FULL_HEX
);
3286 print_vma (segment
->p_filesz
, FULL_HEX
);
3288 print_vma (segment
->p_memsz
, FULL_HEX
);
3290 (segment
->p_flags
& PF_R
? 'R' : ' '),
3291 (segment
->p_flags
& PF_W
? 'W' : ' '),
3292 (segment
->p_flags
& PF_X
? 'E' : ' '));
3293 print_vma (segment
->p_align
, HEX
);
3297 switch (segment
->p_type
)
3301 error (_("more than one dynamic segment\n"));
3303 /* Try to locate the .dynamic section. If there is
3304 a section header table, we can easily locate it. */
3305 if (section_headers
!= NULL
)
3307 Elf_Internal_Shdr
*sec
;
3309 sec
= find_section (".dynamic");
3310 if (sec
== NULL
|| sec
->sh_size
== 0)
3312 error (_("no .dynamic section in the dynamic segment"));
3316 dynamic_addr
= sec
->sh_offset
;
3317 dynamic_size
= sec
->sh_size
;
3319 if (dynamic_addr
< segment
->p_offset
3320 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3321 warn (_("the .dynamic section is not contained within the dynamic segment"));
3322 else if (dynamic_addr
> segment
->p_offset
)
3323 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3327 /* Otherwise, we can only assume that the .dynamic
3328 section is the first section in the DYNAMIC segment. */
3329 dynamic_addr
= segment
->p_offset
;
3330 dynamic_size
= segment
->p_filesz
;
3335 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3337 error (_("Unable to find program interpreter name\n"));
3340 program_interpreter
[0] = 0;
3341 fscanf (file
, "%63s", program_interpreter
);
3344 printf (_("\n [Requesting program interpreter: %s]"),
3345 program_interpreter
);
3351 putc ('\n', stdout
);
3354 if (do_segments
&& section_headers
!= NULL
)
3356 printf (_("\n Section to Segment mapping:\n"));
3357 printf (_(" Segment Sections...\n"));
3359 assert (string_table
!= NULL
);
3361 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3364 Elf_Internal_Shdr
*section
;
3366 segment
= program_headers
+ i
;
3367 section
= section_headers
;
3369 printf (" %2.2d ", i
);
3371 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3373 if (section
->sh_size
> 0
3374 /* Compare allocated sections by VMA, unallocated
3375 sections by file offset. */
3376 && (section
->sh_flags
& SHF_ALLOC
3377 ? (section
->sh_addr
>= segment
->p_vaddr
3378 && section
->sh_addr
+ section
->sh_size
3379 <= segment
->p_vaddr
+ segment
->p_memsz
)
3380 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3381 && (section
->sh_offset
+ section
->sh_size
3382 <= segment
->p_offset
+ segment
->p_filesz
)))
3383 /* .tbss is special. It doesn't contribute memory space
3384 to normal segments. */
3385 && (!((section
->sh_flags
& SHF_TLS
) != 0
3386 && section
->sh_type
== SHT_NOBITS
)
3387 || segment
->p_type
== PT_TLS
))
3388 printf ("%s ", SECTION_NAME (section
));
3399 /* Find the file offset corresponding to VMA by using the program headers. */
3402 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3404 Elf_Internal_Phdr
*seg
;
3406 if (! get_program_headers (file
))
3408 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3412 for (seg
= program_headers
;
3413 seg
< program_headers
+ elf_header
.e_phnum
;
3416 if (seg
->p_type
!= PT_LOAD
)
3419 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3420 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3421 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3424 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3431 get_32bit_section_headers (FILE *file
, unsigned int num
)
3433 Elf32_External_Shdr
*shdrs
;
3434 Elf_Internal_Shdr
*internal
;
3437 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3438 elf_header
.e_shentsize
* num
, _("section headers"));
3442 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3444 if (section_headers
== NULL
)
3446 error (_("Out of memory\n"));
3450 for (i
= 0, internal
= section_headers
;
3454 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3455 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3456 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3457 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3458 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3459 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3460 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3461 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3462 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3463 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3472 get_64bit_section_headers (FILE *file
, unsigned int num
)
3474 Elf64_External_Shdr
*shdrs
;
3475 Elf_Internal_Shdr
*internal
;
3478 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3479 elf_header
.e_shentsize
* num
, _("section headers"));
3483 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3485 if (section_headers
== NULL
)
3487 error (_("Out of memory\n"));
3491 for (i
= 0, internal
= section_headers
;
3495 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3496 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3497 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3498 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3499 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3500 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3501 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3502 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3503 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3504 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3512 static Elf_Internal_Sym
*
3513 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3515 unsigned long number
;
3516 Elf32_External_Sym
*esyms
;
3517 Elf_External_Sym_Shndx
*shndx
;
3518 Elf_Internal_Sym
*isyms
;
3519 Elf_Internal_Sym
*psym
;
3522 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3528 if (symtab_shndx_hdr
!= NULL
3529 && (symtab_shndx_hdr
->sh_link
3530 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3532 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3533 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3541 number
= section
->sh_size
/ section
->sh_entsize
;
3542 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3546 error (_("Out of memory\n"));
3553 for (j
= 0, psym
= isyms
;
3557 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3558 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3559 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3560 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3561 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3563 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3564 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3565 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3575 static Elf_Internal_Sym
*
3576 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3578 unsigned long number
;
3579 Elf64_External_Sym
*esyms
;
3580 Elf_External_Sym_Shndx
*shndx
;
3581 Elf_Internal_Sym
*isyms
;
3582 Elf_Internal_Sym
*psym
;
3585 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3591 if (symtab_shndx_hdr
!= NULL
3592 && (symtab_shndx_hdr
->sh_link
3593 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3595 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3596 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3604 number
= section
->sh_size
/ section
->sh_entsize
;
3605 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3609 error (_("Out of memory\n"));
3616 for (j
= 0, psym
= isyms
;
3620 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3621 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3622 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3623 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3624 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3626 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3627 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3628 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3639 get_elf_section_flags (bfd_vma sh_flags
)
3641 static char buff
[33];
3648 flag
= sh_flags
& - sh_flags
;
3653 case SHF_WRITE
: *p
= 'W'; break;
3654 case SHF_ALLOC
: *p
= 'A'; break;
3655 case SHF_EXECINSTR
: *p
= 'X'; break;
3656 case SHF_MERGE
: *p
= 'M'; break;
3657 case SHF_STRINGS
: *p
= 'S'; break;
3658 case SHF_INFO_LINK
: *p
= 'I'; break;
3659 case SHF_LINK_ORDER
: *p
= 'L'; break;
3660 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3661 case SHF_GROUP
: *p
= 'G'; break;
3662 case SHF_TLS
: *p
= 'T'; break;
3665 if (flag
& SHF_MASKOS
)
3668 sh_flags
&= ~ SHF_MASKOS
;
3670 else if (flag
& SHF_MASKPROC
)
3673 sh_flags
&= ~ SHF_MASKPROC
;
3687 process_section_headers (FILE *file
)
3689 Elf_Internal_Shdr
*section
;
3692 section_headers
= NULL
;
3694 if (elf_header
.e_shnum
== 0)
3697 printf (_("\nThere are no sections in this file.\n"));
3702 if (do_sections
&& !do_header
)
3703 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3704 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3708 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3711 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3714 /* Read in the string table, so that we have names to display. */
3715 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3717 if (section
->sh_size
!= 0)
3719 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3720 section
->sh_size
, _("string table"));
3722 if (string_table
== NULL
)
3725 string_table_length
= section
->sh_size
;
3728 /* Scan the sections for the dynamic symbol table
3729 and dynamic string table and debug sections. */
3730 dynamic_symbols
= NULL
;
3731 dynamic_strings
= NULL
;
3732 dynamic_syminfo
= NULL
;
3733 symtab_shndx_hdr
= NULL
;
3735 eh_addr_size
= is_32bit_elf
? 4 : 8;
3736 switch (elf_header
.e_machine
)
3739 case EM_MIPS_RS3_LE
:
3740 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3741 FDE addresses. However, the ABI also has a semi-official ILP32
3742 variant for which the normal FDE address size rules apply.
3744 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3745 section, where XX is the size of longs in bits. Unfortunately,
3746 earlier compilers provided no way of distinguishing ILP32 objects
3747 from LP64 objects, so if there's any doubt, we should assume that
3748 the official LP64 form is being used. */
3749 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3750 && find_section (".gcc_compiled_long32") == NULL
)
3755 for (i
= 0, section
= section_headers
;
3756 i
< elf_header
.e_shnum
;
3759 char *name
= SECTION_NAME (section
);
3761 if (section
->sh_type
== SHT_DYNSYM
)
3763 if (dynamic_symbols
!= NULL
)
3765 error (_("File contains multiple dynamic symbol tables\n"));
3769 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3770 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3772 else if (section
->sh_type
== SHT_STRTAB
3773 && streq (name
, ".dynstr"))
3775 if (dynamic_strings
!= NULL
)
3777 error (_("File contains multiple dynamic string tables\n"));
3781 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3782 section
->sh_size
, _("dynamic strings"));
3783 dynamic_strings_length
= section
->sh_size
;
3785 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3787 if (symtab_shndx_hdr
!= NULL
)
3789 error (_("File contains multiple symtab shndx tables\n"));
3792 symtab_shndx_hdr
= section
;
3794 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3795 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3796 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3797 || do_debug_loc
|| do_debug_ranges
)
3798 && strneq (name
, ".debug_", 7))
3803 || (do_debug_info
&& streq (name
, "info"))
3804 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3805 || (do_debug_lines
&& streq (name
, "line"))
3806 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3807 || (do_debug_aranges
&& streq (name
, "aranges"))
3808 || (do_debug_ranges
&& streq (name
, "ranges"))
3809 || (do_debug_frames
&& streq (name
, "frame"))
3810 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3811 || (do_debug_str
&& streq (name
, "str"))
3812 || (do_debug_loc
&& streq (name
, "loc"))
3814 request_dump (i
, DEBUG_DUMP
);
3816 /* linkonce section to be combined with .debug_info at link time. */
3817 else if ((do_debugging
|| do_debug_info
)
3818 && strneq (name
, ".gnu.linkonce.wi.", 17))
3819 request_dump (i
, DEBUG_DUMP
);
3820 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3821 request_dump (i
, DEBUG_DUMP
);
3827 if (elf_header
.e_shnum
> 1)
3828 printf (_("\nSection Headers:\n"));
3830 printf (_("\nSection Header:\n"));
3834 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3837 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3840 printf (_(" [Nr] Name Type Address Offset\n"));
3841 printf (_(" Size EntSize Flags Link Info Align\n"));
3844 for (i
= 0, section
= section_headers
;
3845 i
< elf_header
.e_shnum
;
3848 printf (" [%2u] %-17.17s %-15.15s ",
3849 SECTION_HEADER_NUM (i
),
3850 SECTION_NAME (section
),
3851 get_section_type_name (section
->sh_type
));
3855 print_vma (section
->sh_addr
, LONG_HEX
);
3857 printf ( " %6.6lx %6.6lx %2.2lx",
3858 (unsigned long) section
->sh_offset
,
3859 (unsigned long) section
->sh_size
,
3860 (unsigned long) section
->sh_entsize
);
3862 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3864 printf ("%2ld %3lu %2ld\n",
3865 (unsigned long) section
->sh_link
,
3866 (unsigned long) section
->sh_info
,
3867 (unsigned long) section
->sh_addralign
);
3871 print_vma (section
->sh_addr
, LONG_HEX
);
3873 if ((long) section
->sh_offset
== section
->sh_offset
)
3874 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3878 print_vma (section
->sh_offset
, LONG_HEX
);
3881 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3882 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3886 print_vma (section
->sh_size
, LONG_HEX
);
3889 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3890 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3894 print_vma (section
->sh_entsize
, LONG_HEX
);
3897 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3899 printf ("%2ld %3lu ",
3900 (unsigned long) section
->sh_link
,
3901 (unsigned long) section
->sh_info
);
3903 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3904 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3907 print_vma (section
->sh_addralign
, DEC
);
3914 print_vma (section
->sh_addr
, LONG_HEX
);
3915 if ((long) section
->sh_offset
== section
->sh_offset
)
3916 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3920 print_vma (section
->sh_offset
, LONG_HEX
);
3923 print_vma (section
->sh_size
, LONG_HEX
);
3925 print_vma (section
->sh_entsize
, LONG_HEX
);
3927 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3929 printf (" %2ld %3lu %ld\n",
3930 (unsigned long) section
->sh_link
,
3931 (unsigned long) section
->sh_info
,
3932 (unsigned long) section
->sh_addralign
);
3936 printf (_("Key to Flags:\n\
3937 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3938 I (info), L (link order), G (group), x (unknown)\n\
3939 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3945 get_group_flags (unsigned int flags
)
3947 static char buff
[32];
3954 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
3961 process_section_groups (FILE *file
)
3963 Elf_Internal_Shdr
*section
;
3965 struct group
*group
;
3966 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
3967 Elf_Internal_Sym
*symtab
;
3970 /* Don't process section groups unless needed. */
3971 if (!do_unwind
&& !do_section_groups
)
3974 if (elf_header
.e_shnum
== 0)
3976 if (do_section_groups
)
3977 printf (_("\nThere are no sections in this file.\n"));
3982 if (section_headers
== NULL
)
3984 error (_("Section headers are not available!\n"));
3988 section_headers_groups
= calloc (elf_header
.e_shnum
,
3989 sizeof (struct group
*));
3991 if (section_headers_groups
== NULL
)
3993 error (_("Out of memory\n"));
3997 /* Scan the sections for the group section. */
3999 for (i
= 0, section
= section_headers
;
4000 i
< elf_header
.e_shnum
;
4002 if (section
->sh_type
== SHT_GROUP
)
4005 if (group_count
== 0)
4007 if (do_section_groups
)
4008 printf (_("\nThere are no section groups in this file.\n"));
4013 section_groups
= calloc (group_count
, sizeof (struct group
));
4015 if (section_groups
== NULL
)
4017 error (_("Out of memory\n"));
4025 for (i
= 0, section
= section_headers
, group
= section_groups
;
4026 i
< elf_header
.e_shnum
;
4029 if (section
->sh_type
== SHT_GROUP
)
4031 char *name
= SECTION_NAME (section
);
4033 unsigned char *start
, *indices
;
4034 unsigned int entry
, j
, size
;
4035 Elf_Internal_Shdr
*sec
;
4036 Elf_Internal_Sym
*sym
;
4038 /* Get the symbol table. */
4039 sec
= SECTION_HEADER (section
->sh_link
);
4040 if (sec
->sh_type
!= SHT_SYMTAB
)
4042 error (_("Bad sh_link in group section `%s'\n"), name
);
4046 if (symtab_sec
!= sec
)
4051 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4054 sym
= symtab
+ section
->sh_info
;
4056 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4058 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4061 error (_("Bad sh_info in group section `%s'\n"), name
);
4065 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4070 /* Get the string table. */
4071 sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4072 if (strtab_sec
!= sec
)
4077 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4078 strtab_sec
->sh_size
,
4081 group_name
= strtab
+ sym
->st_name
;
4084 start
= get_data (NULL
, file
, section
->sh_offset
,
4085 section
->sh_size
, _("section data"));
4088 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4089 entry
= byte_get (indices
, 4);
4092 if (do_section_groups
)
4094 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4095 get_group_flags (entry
), name
, group_name
, size
);
4097 printf (_(" [Index] Name\n"));
4100 group
->group_index
= i
;
4102 for (j
= 0; j
< size
; j
++)
4104 struct group_list
*g
;
4106 entry
= byte_get (indices
, 4);
4109 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4114 error (_("section [%5u] already in group section [%5u]\n"),
4116 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4121 /* Intel C/C++ compiler may put section 0 in a
4122 section group. We just warn it the first time
4123 and ignore it afterwards. */
4124 static int warned
= 0;
4127 error (_("section 0 in group section [%5u]\n"),
4128 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4134 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4137 if (do_section_groups
)
4139 sec
= SECTION_HEADER (entry
);
4140 printf (" [%5u] %s\n",
4141 entry
, SECTION_NAME (sec
));
4144 g
= xmalloc (sizeof (struct group_list
));
4145 g
->section_index
= entry
;
4146 g
->next
= group
->root
;
4170 } dynamic_relocations
[] =
4172 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4173 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4174 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4177 /* Process the reloc section. */
4180 process_relocs (FILE *file
)
4182 unsigned long rel_size
;
4183 unsigned long rel_offset
;
4189 if (do_using_dynamic
)
4193 int has_dynamic_reloc
;
4196 has_dynamic_reloc
= 0;
4198 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4200 is_rela
= dynamic_relocations
[i
].rela
;
4201 name
= dynamic_relocations
[i
].name
;
4202 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4203 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4205 has_dynamic_reloc
|= rel_size
;
4207 if (is_rela
== UNKNOWN
)
4209 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4210 switch (dynamic_info
[DT_PLTREL
])
4224 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4225 name
, rel_offset
, rel_size
);
4227 dump_relocations (file
,
4228 offset_from_vma (file
, rel_offset
, rel_size
),
4230 dynamic_symbols
, num_dynamic_syms
,
4231 dynamic_strings
, dynamic_strings_length
, is_rela
);
4235 if (! has_dynamic_reloc
)
4236 printf (_("\nThere are no dynamic relocations in this file.\n"));
4240 Elf_Internal_Shdr
*section
;
4244 for (i
= 0, section
= section_headers
;
4245 i
< elf_header
.e_shnum
;
4248 if ( section
->sh_type
!= SHT_RELA
4249 && section
->sh_type
!= SHT_REL
)
4252 rel_offset
= section
->sh_offset
;
4253 rel_size
= section
->sh_size
;
4257 Elf_Internal_Shdr
*strsec
;
4260 printf (_("\nRelocation section "));
4262 if (string_table
== NULL
)
4263 printf ("%d", section
->sh_name
);
4265 printf (_("'%s'"), SECTION_NAME (section
));
4267 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4268 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4270 is_rela
= section
->sh_type
== SHT_RELA
;
4272 if (section
->sh_link
)
4274 Elf_Internal_Shdr
*symsec
;
4275 Elf_Internal_Sym
*symtab
;
4276 unsigned long nsyms
;
4277 unsigned long strtablen
;
4278 char *strtab
= NULL
;
4280 symsec
= SECTION_HEADER (section
->sh_link
);
4281 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4282 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4287 strsec
= SECTION_HEADER (symsec
->sh_link
);
4289 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4290 strsec
->sh_size
, _("string table"));
4291 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4293 dump_relocations (file
, rel_offset
, rel_size
,
4294 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4300 dump_relocations (file
, rel_offset
, rel_size
,
4301 NULL
, 0, NULL
, 0, is_rela
);
4308 printf (_("\nThere are no relocations in this file.\n"));
4314 /* Process the unwind section. */
4316 #include "unwind-ia64.h"
4318 /* An absolute address consists of a section and an offset. If the
4319 section is NULL, the offset itself is the address, otherwise, the
4320 address equals to LOAD_ADDRESS(section) + offset. */
4324 unsigned short section
;
4328 struct ia64_unw_aux_info
4330 struct ia64_unw_table_entry
4332 struct absaddr start
;
4334 struct absaddr info
;
4336 *table
; /* Unwind table. */
4337 unsigned long table_len
; /* Length of unwind table. */
4338 unsigned char *info
; /* Unwind info. */
4339 unsigned long info_size
; /* Size of unwind info. */
4340 bfd_vma info_addr
; /* starting address of unwind info. */
4341 bfd_vma seg_base
; /* Starting address of segment. */
4342 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4343 unsigned long nsyms
; /* Number of symbols. */
4344 char *strtab
; /* The string table. */
4345 unsigned long strtab_size
; /* Size of string table. */
4349 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4350 unsigned long nsyms
,
4352 unsigned long strtab_size
,
4353 struct absaddr addr
,
4354 const char **symname
,
4357 bfd_vma dist
= 0x100000;
4358 Elf_Internal_Sym
*sym
, *best
= NULL
;
4361 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4363 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4364 && sym
->st_name
!= 0
4365 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4366 && addr
.offset
>= sym
->st_value
4367 && addr
.offset
- sym
->st_value
< dist
)
4370 dist
= addr
.offset
- sym
->st_value
;
4377 *symname
= (best
->st_name
>= strtab_size
4378 ? "<corrupt>" : strtab
+ best
->st_name
);
4383 *offset
= addr
.offset
;
4387 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4389 struct ia64_unw_table_entry
*tp
;
4392 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4396 const unsigned char *dp
;
4397 const unsigned char *head
;
4398 const char *procname
;
4400 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4401 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4403 fputs ("\n<", stdout
);
4407 fputs (procname
, stdout
);
4410 printf ("+%lx", (unsigned long) offset
);
4413 fputs (">: [", stdout
);
4414 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4415 fputc ('-', stdout
);
4416 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4417 printf ("], info at +0x%lx\n",
4418 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4420 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4421 stamp
= BYTE_GET ((unsigned char *) head
);
4423 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4424 (unsigned) UNW_VER (stamp
),
4425 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4426 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4427 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4428 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4430 if (UNW_VER (stamp
) != 1)
4432 printf ("\tUnknown version.\n");
4437 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4438 dp
= unw_decode (dp
, in_body
, & in_body
);
4443 slurp_ia64_unwind_table (FILE *file
,
4444 struct ia64_unw_aux_info
*aux
,
4445 Elf_Internal_Shdr
*sec
)
4447 unsigned long size
, nrelas
, i
;
4448 Elf_Internal_Phdr
*seg
;
4449 struct ia64_unw_table_entry
*tep
;
4450 Elf_Internal_Shdr
*relsec
;
4451 Elf_Internal_Rela
*rela
, *rp
;
4452 unsigned char *table
, *tp
;
4453 Elf_Internal_Sym
*sym
;
4454 const char *relname
;
4456 /* First, find the starting address of the segment that includes
4459 if (elf_header
.e_phnum
)
4461 if (! get_program_headers (file
))
4464 for (seg
= program_headers
;
4465 seg
< program_headers
+ elf_header
.e_phnum
;
4468 if (seg
->p_type
!= PT_LOAD
)
4471 if (sec
->sh_addr
>= seg
->p_vaddr
4472 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4474 aux
->seg_base
= seg
->p_vaddr
;
4480 /* Second, build the unwind table from the contents of the unwind section: */
4481 size
= sec
->sh_size
;
4482 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4486 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4488 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4490 tep
->start
.section
= SHN_UNDEF
;
4491 tep
->end
.section
= SHN_UNDEF
;
4492 tep
->info
.section
= SHN_UNDEF
;
4495 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4496 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4497 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4501 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4502 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4503 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4505 tep
->start
.offset
+= aux
->seg_base
;
4506 tep
->end
.offset
+= aux
->seg_base
;
4507 tep
->info
.offset
+= aux
->seg_base
;
4511 /* Third, apply any relocations to the unwind table: */
4513 for (relsec
= section_headers
;
4514 relsec
< section_headers
+ elf_header
.e_shnum
;
4517 if (relsec
->sh_type
!= SHT_RELA
4518 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4521 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4525 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4529 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4530 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4534 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4535 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4538 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4540 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4544 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4546 switch (rp
->r_offset
/eh_addr_size
% 3)
4549 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4550 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4553 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4554 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4557 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4558 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4568 aux
->table_len
= size
/ (3 * eh_addr_size
);
4573 ia64_process_unwind (FILE *file
)
4575 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4576 unsigned long i
, unwcount
= 0, unwstart
= 0;
4577 struct ia64_unw_aux_info aux
;
4579 memset (& aux
, 0, sizeof (aux
));
4581 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4583 if (sec
->sh_type
== SHT_SYMTAB
)
4585 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4586 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4588 strsec
= SECTION_HEADER (sec
->sh_link
);
4589 aux
.strtab_size
= strsec
->sh_size
;
4590 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4591 aux
.strtab_size
, _("string table"));
4593 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4598 printf (_("\nThere are no unwind sections in this file.\n"));
4600 while (unwcount
-- > 0)
4605 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4606 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4607 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4614 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4616 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4618 /* We need to find which section group it is in. */
4619 struct group_list
*g
= section_headers_groups
[i
]->root
;
4621 for (; g
!= NULL
; g
= g
->next
)
4623 sec
= SECTION_HEADER (g
->section_index
);
4625 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4630 i
= elf_header
.e_shnum
;
4632 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4634 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4635 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4636 suffix
= SECTION_NAME (unwsec
) + len
;
4637 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4639 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4640 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4645 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4646 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4647 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4648 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4650 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4651 suffix
= SECTION_NAME (unwsec
) + len
;
4652 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4654 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4655 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4659 if (i
== elf_header
.e_shnum
)
4661 printf (_("\nCould not find unwind info section for "));
4663 if (string_table
== NULL
)
4664 printf ("%d", unwsec
->sh_name
);
4666 printf (_("'%s'"), SECTION_NAME (unwsec
));
4670 aux
.info_size
= sec
->sh_size
;
4671 aux
.info_addr
= sec
->sh_addr
;
4672 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4675 printf (_("\nUnwind section "));
4677 if (string_table
== NULL
)
4678 printf ("%d", unwsec
->sh_name
);
4680 printf (_("'%s'"), SECTION_NAME (unwsec
));
4682 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4683 (unsigned long) unwsec
->sh_offset
,
4684 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4686 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4688 if (aux
.table_len
> 0)
4689 dump_ia64_unwind (& aux
);
4692 free ((char *) aux
.table
);
4694 free ((char *) aux
.info
);
4703 free ((char *) aux
.strtab
);
4708 struct hppa_unw_aux_info
4710 struct hppa_unw_table_entry
4712 struct absaddr start
;
4714 unsigned int Cannot_unwind
:1; /* 0 */
4715 unsigned int Millicode
:1; /* 1 */
4716 unsigned int Millicode_save_sr0
:1; /* 2 */
4717 unsigned int Region_description
:2; /* 3..4 */
4718 unsigned int reserved1
:1; /* 5 */
4719 unsigned int Entry_SR
:1; /* 6 */
4720 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4721 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4722 unsigned int Args_stored
:1; /* 16 */
4723 unsigned int Variable_Frame
:1; /* 17 */
4724 unsigned int Separate_Package_Body
:1; /* 18 */
4725 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4726 unsigned int Stack_Overflow_Check
:1; /* 20 */
4727 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4728 unsigned int Ada_Region
:1; /* 22 */
4729 unsigned int cxx_info
:1; /* 23 */
4730 unsigned int cxx_try_catch
:1; /* 24 */
4731 unsigned int sched_entry_seq
:1; /* 25 */
4732 unsigned int reserved2
:1; /* 26 */
4733 unsigned int Save_SP
:1; /* 27 */
4734 unsigned int Save_RP
:1; /* 28 */
4735 unsigned int Save_MRP_in_frame
:1; /* 29 */
4736 unsigned int extn_ptr_defined
:1; /* 30 */
4737 unsigned int Cleanup_defined
:1; /* 31 */
4739 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4740 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4741 unsigned int Large_frame
:1; /* 2 */
4742 unsigned int Pseudo_SP_Set
:1; /* 3 */
4743 unsigned int reserved4
:1; /* 4 */
4744 unsigned int Total_frame_size
:27; /* 5..31 */
4746 *table
; /* Unwind table. */
4747 unsigned long table_len
; /* Length of unwind table. */
4748 bfd_vma seg_base
; /* Starting address of segment. */
4749 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4750 unsigned long nsyms
; /* Number of symbols. */
4751 char *strtab
; /* The string table. */
4752 unsigned long strtab_size
; /* Size of string table. */
4756 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4758 struct hppa_unw_table_entry
*tp
;
4760 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4763 const char *procname
;
4765 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4766 aux
->strtab_size
, tp
->start
, &procname
,
4769 fputs ("\n<", stdout
);
4773 fputs (procname
, stdout
);
4776 printf ("+%lx", (unsigned long) offset
);
4779 fputs (">: [", stdout
);
4780 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4781 fputc ('-', stdout
);
4782 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4785 #define PF(_m) if (tp->_m) printf (#_m " ");
4786 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4789 PF(Millicode_save_sr0
);
4790 /* PV(Region_description); */
4796 PF(Separate_Package_Body
);
4797 PF(Frame_Extension_Millicode
);
4798 PF(Stack_Overflow_Check
);
4799 PF(Two_Instruction_SP_Increment
);
4803 PF(sched_entry_seq
);
4806 PF(Save_MRP_in_frame
);
4807 PF(extn_ptr_defined
);
4808 PF(Cleanup_defined
);
4809 PF(MPE_XL_interrupt_marker
);
4810 PF(HP_UX_interrupt_marker
);
4813 PV(Total_frame_size
);
4822 slurp_hppa_unwind_table (FILE *file
,
4823 struct hppa_unw_aux_info
*aux
,
4824 Elf_Internal_Shdr
*sec
)
4826 unsigned long size
, unw_ent_size
, nrelas
, i
;
4827 Elf_Internal_Phdr
*seg
;
4828 struct hppa_unw_table_entry
*tep
;
4829 Elf_Internal_Shdr
*relsec
;
4830 Elf_Internal_Rela
*rela
, *rp
;
4831 unsigned char *table
, *tp
;
4832 Elf_Internal_Sym
*sym
;
4833 const char *relname
;
4835 /* First, find the starting address of the segment that includes
4838 if (elf_header
.e_phnum
)
4840 if (! get_program_headers (file
))
4843 for (seg
= program_headers
;
4844 seg
< program_headers
+ elf_header
.e_phnum
;
4847 if (seg
->p_type
!= PT_LOAD
)
4850 if (sec
->sh_addr
>= seg
->p_vaddr
4851 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4853 aux
->seg_base
= seg
->p_vaddr
;
4859 /* Second, build the unwind table from the contents of the unwind
4861 size
= sec
->sh_size
;
4862 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4866 unw_ent_size
= 2 * eh_addr_size
+ 8;
4868 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4870 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
4872 unsigned int tmp1
, tmp2
;
4874 tep
->start
.section
= SHN_UNDEF
;
4875 tep
->end
.section
= SHN_UNDEF
;
4879 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4880 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4881 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4882 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4886 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4887 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4888 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4889 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
4892 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
4893 tep
->Millicode
= (tmp1
>> 30) & 0x1;
4894 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
4895 tep
->Region_description
= (tmp1
>> 27) & 0x3;
4896 tep
->reserved1
= (tmp1
>> 26) & 0x1;
4897 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
4898 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
4899 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
4900 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
4901 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
4902 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
4903 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
4904 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
4905 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
4906 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
4907 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
4908 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
4909 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
4910 tep
->reserved2
= (tmp1
>> 5) & 0x1;
4911 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
4912 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
4913 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
4914 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
4915 tep
->Cleanup_defined
= tmp1
& 0x1;
4917 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
4918 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
4919 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
4920 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
4921 tep
->reserved4
= (tmp2
>> 27) & 0x1;
4922 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
4924 tep
->start
.offset
+= aux
->seg_base
;
4925 tep
->end
.offset
+= aux
->seg_base
;
4929 /* Third, apply any relocations to the unwind table. */
4931 for (relsec
= section_headers
;
4932 relsec
< section_headers
+ elf_header
.e_shnum
;
4935 if (relsec
->sh_type
!= SHT_RELA
4936 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4939 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4943 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4947 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4948 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4952 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4953 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4956 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
4957 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
4959 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4963 i
= rp
->r_offset
/ unw_ent_size
;
4965 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
4968 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4969 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
4972 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4973 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
4983 aux
->table_len
= size
/ unw_ent_size
;
4989 hppa_process_unwind (FILE *file
)
4991 struct hppa_unw_aux_info aux
;
4992 Elf_Internal_Shdr
*unwsec
= NULL
;
4993 Elf_Internal_Shdr
*strsec
;
4994 Elf_Internal_Shdr
*sec
;
4997 memset (& aux
, 0, sizeof (aux
));
4999 assert (string_table
!= NULL
);
5001 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5003 if (sec
->sh_type
== SHT_SYMTAB
)
5005 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5006 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5008 strsec
= SECTION_HEADER (sec
->sh_link
);
5009 aux
.strtab_size
= strsec
->sh_size
;
5010 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5011 aux
.strtab_size
, _("string table"));
5013 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5018 printf (_("\nThere are no unwind sections in this file.\n"));
5020 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5022 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5024 printf (_("\nUnwind section "));
5025 printf (_("'%s'"), SECTION_NAME (sec
));
5027 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5028 (unsigned long) sec
->sh_offset
,
5029 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5031 slurp_hppa_unwind_table (file
, &aux
, sec
);
5032 if (aux
.table_len
> 0)
5033 dump_hppa_unwind (&aux
);
5036 free ((char *) aux
.table
);
5044 free ((char *) aux
.strtab
);
5050 process_unwind (FILE *file
)
5052 struct unwind_handler
{
5054 int (*handler
)(FILE *file
);
5056 { EM_IA_64
, ia64_process_unwind
},
5057 { EM_PARISC
, hppa_process_unwind
},
5065 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5066 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5067 return handlers
[i
].handler (file
);
5069 printf (_("\nThere are no unwind sections in this file.\n"));
5074 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5076 switch (entry
->d_tag
)
5079 if (entry
->d_un
.d_val
== 0)
5083 static const char * opts
[] =
5085 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5086 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5087 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5088 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5093 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5094 if (entry
->d_un
.d_val
& (1 << cnt
))
5096 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5103 case DT_MIPS_IVERSION
:
5104 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5105 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5107 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5110 case DT_MIPS_TIME_STAMP
:
5115 time_t time
= entry
->d_un
.d_val
;
5116 tmp
= gmtime (&time
);
5117 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5118 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5119 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5120 printf ("Time Stamp: %s\n", timebuf
);
5124 case DT_MIPS_RLD_VERSION
:
5125 case DT_MIPS_LOCAL_GOTNO
:
5126 case DT_MIPS_CONFLICTNO
:
5127 case DT_MIPS_LIBLISTNO
:
5128 case DT_MIPS_SYMTABNO
:
5129 case DT_MIPS_UNREFEXTNO
:
5130 case DT_MIPS_HIPAGENO
:
5131 case DT_MIPS_DELTA_CLASS_NO
:
5132 case DT_MIPS_DELTA_INSTANCE_NO
:
5133 case DT_MIPS_DELTA_RELOC_NO
:
5134 case DT_MIPS_DELTA_SYM_NO
:
5135 case DT_MIPS_DELTA_CLASSSYM_NO
:
5136 case DT_MIPS_COMPACT_SIZE
:
5137 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5141 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5147 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5149 switch (entry
->d_tag
)
5151 case DT_HP_DLD_FLAGS
:
5160 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5161 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5162 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5163 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5164 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5165 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5166 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5167 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5168 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5169 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5170 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5174 bfd_vma val
= entry
->d_un
.d_val
;
5176 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5177 if (val
& flags
[cnt
].bit
)
5181 fputs (flags
[cnt
].str
, stdout
);
5183 val
^= flags
[cnt
].bit
;
5186 if (val
!= 0 || first
)
5190 print_vma (val
, HEX
);
5196 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5203 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5205 switch (entry
->d_tag
)
5207 case DT_IA_64_PLT_RESERVE
:
5208 /* First 3 slots reserved. */
5209 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5211 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5215 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5222 get_32bit_dynamic_section (FILE *file
)
5224 Elf32_External_Dyn
*edyn
, *ext
;
5225 Elf_Internal_Dyn
*entry
;
5227 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5228 _("dynamic section"));
5232 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5233 might not have the luxury of section headers. Look for the DT_NULL
5234 terminator to determine the number of entries. */
5235 for (ext
= edyn
, dynamic_nent
= 0;
5236 (char *) ext
< (char *) edyn
+ dynamic_size
;
5240 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5244 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5245 if (dynamic_section
== NULL
)
5247 error (_("Out of memory\n"));
5252 for (ext
= edyn
, entry
= dynamic_section
;
5253 entry
< dynamic_section
+ dynamic_nent
;
5256 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5257 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5266 get_64bit_dynamic_section (FILE *file
)
5268 Elf64_External_Dyn
*edyn
, *ext
;
5269 Elf_Internal_Dyn
*entry
;
5271 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5272 _("dynamic section"));
5276 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5277 might not have the luxury of section headers. Look for the DT_NULL
5278 terminator to determine the number of entries. */
5279 for (ext
= edyn
, dynamic_nent
= 0;
5280 (char *) ext
< (char *) edyn
+ dynamic_size
;
5284 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5288 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5289 if (dynamic_section
== NULL
)
5291 error (_("Out of memory\n"));
5296 for (ext
= edyn
, entry
= dynamic_section
;
5297 entry
< dynamic_section
+ dynamic_nent
;
5300 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5301 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5310 print_dynamic_flags (bfd_vma flags
)
5318 flag
= flags
& - flags
;
5328 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5329 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5330 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5331 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5332 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5333 default: fputs ("unknown", stdout
); break;
5339 /* Parse and display the contents of the dynamic section. */
5342 process_dynamic_section (FILE *file
)
5344 Elf_Internal_Dyn
*entry
;
5346 if (dynamic_size
== 0)
5349 printf (_("\nThere is no dynamic section in this file.\n"));
5356 if (! get_32bit_dynamic_section (file
))
5359 else if (! get_64bit_dynamic_section (file
))
5362 /* Find the appropriate symbol table. */
5363 if (dynamic_symbols
== NULL
)
5365 for (entry
= dynamic_section
;
5366 entry
< dynamic_section
+ dynamic_nent
;
5369 Elf_Internal_Shdr section
;
5371 if (entry
->d_tag
!= DT_SYMTAB
)
5374 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5376 /* Since we do not know how big the symbol table is,
5377 we default to reading in the entire file (!) and
5378 processing that. This is overkill, I know, but it
5380 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5382 if (archive_file_offset
!= 0)
5383 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5386 if (fseek (file
, 0, SEEK_END
))
5387 error (_("Unable to seek to end of file!"));
5389 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5393 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5395 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5397 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5398 if (num_dynamic_syms
< 1)
5400 error (_("Unable to determine the number of symbols to load\n"));
5404 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5408 /* Similarly find a string table. */
5409 if (dynamic_strings
== NULL
)
5411 for (entry
= dynamic_section
;
5412 entry
< dynamic_section
+ dynamic_nent
;
5415 unsigned long offset
;
5418 if (entry
->d_tag
!= DT_STRTAB
)
5421 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5423 /* Since we do not know how big the string table is,
5424 we default to reading in the entire file (!) and
5425 processing that. This is overkill, I know, but it
5428 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5430 if (archive_file_offset
!= 0)
5431 str_tab_len
= archive_file_size
- offset
;
5434 if (fseek (file
, 0, SEEK_END
))
5435 error (_("Unable to seek to end of file\n"));
5436 str_tab_len
= ftell (file
) - offset
;
5439 if (str_tab_len
< 1)
5442 (_("Unable to determine the length of the dynamic string table\n"));
5446 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5447 _("dynamic string table"));
5448 dynamic_strings_length
= str_tab_len
;
5453 /* And find the syminfo section if available. */
5454 if (dynamic_syminfo
== NULL
)
5456 unsigned long syminsz
= 0;
5458 for (entry
= dynamic_section
;
5459 entry
< dynamic_section
+ dynamic_nent
;
5462 if (entry
->d_tag
== DT_SYMINENT
)
5464 /* Note: these braces are necessary to avoid a syntax
5465 error from the SunOS4 C compiler. */
5466 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5468 else if (entry
->d_tag
== DT_SYMINSZ
)
5469 syminsz
= entry
->d_un
.d_val
;
5470 else if (entry
->d_tag
== DT_SYMINFO
)
5471 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5475 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5477 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5478 Elf_Internal_Syminfo
*syminfo
;
5480 /* There is a syminfo section. Read the data. */
5481 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5482 _("symbol information"));
5486 dynamic_syminfo
= malloc (syminsz
);
5487 if (dynamic_syminfo
== NULL
)
5489 error (_("Out of memory\n"));
5493 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5494 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5495 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5496 ++syminfo
, ++extsym
)
5498 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5499 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5506 if (do_dynamic
&& dynamic_addr
)
5507 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5508 dynamic_addr
, dynamic_nent
);
5510 printf (_(" Tag Type Name/Value\n"));
5512 for (entry
= dynamic_section
;
5513 entry
< dynamic_section
+ dynamic_nent
;
5521 print_vma (entry
->d_tag
, FULL_HEX
);
5522 dtype
= get_dynamic_type (entry
->d_tag
);
5523 printf (" (%s)%*s", dtype
,
5524 ((is_32bit_elf
? 27 : 19)
5525 - (int) strlen (dtype
)),
5529 switch (entry
->d_tag
)
5533 print_dynamic_flags (entry
->d_un
.d_val
);
5543 switch (entry
->d_tag
)
5546 printf (_("Auxiliary library"));
5550 printf (_("Filter library"));
5554 printf (_("Configuration file"));
5558 printf (_("Dependency audit library"));
5562 printf (_("Audit library"));
5566 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5567 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5571 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5580 printf (_("Flags:"));
5582 if (entry
->d_un
.d_val
== 0)
5583 printf (_(" None\n"));
5586 unsigned long int val
= entry
->d_un
.d_val
;
5588 if (val
& DTF_1_PARINIT
)
5590 printf (" PARINIT");
5591 val
^= DTF_1_PARINIT
;
5593 if (val
& DTF_1_CONFEXP
)
5595 printf (" CONFEXP");
5596 val
^= DTF_1_CONFEXP
;
5599 printf (" %lx", val
);
5608 printf (_("Flags:"));
5610 if (entry
->d_un
.d_val
== 0)
5611 printf (_(" None\n"));
5614 unsigned long int val
= entry
->d_un
.d_val
;
5616 if (val
& DF_P1_LAZYLOAD
)
5618 printf (" LAZYLOAD");
5619 val
^= DF_P1_LAZYLOAD
;
5621 if (val
& DF_P1_GROUPPERM
)
5623 printf (" GROUPPERM");
5624 val
^= DF_P1_GROUPPERM
;
5627 printf (" %lx", val
);
5636 printf (_("Flags:"));
5637 if (entry
->d_un
.d_val
== 0)
5638 printf (_(" None\n"));
5641 unsigned long int val
= entry
->d_un
.d_val
;
5648 if (val
& DF_1_GLOBAL
)
5653 if (val
& DF_1_GROUP
)
5658 if (val
& DF_1_NODELETE
)
5660 printf (" NODELETE");
5661 val
^= DF_1_NODELETE
;
5663 if (val
& DF_1_LOADFLTR
)
5665 printf (" LOADFLTR");
5666 val
^= DF_1_LOADFLTR
;
5668 if (val
& DF_1_INITFIRST
)
5670 printf (" INITFIRST");
5671 val
^= DF_1_INITFIRST
;
5673 if (val
& DF_1_NOOPEN
)
5678 if (val
& DF_1_ORIGIN
)
5683 if (val
& DF_1_DIRECT
)
5688 if (val
& DF_1_TRANS
)
5693 if (val
& DF_1_INTERPOSE
)
5695 printf (" INTERPOSE");
5696 val
^= DF_1_INTERPOSE
;
5698 if (val
& DF_1_NODEFLIB
)
5700 printf (" NODEFLIB");
5701 val
^= DF_1_NODEFLIB
;
5703 if (val
& DF_1_NODUMP
)
5708 if (val
& DF_1_CONLFAT
)
5710 printf (" CONLFAT");
5711 val
^= DF_1_CONLFAT
;
5714 printf (" %lx", val
);
5721 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5723 puts (get_dynamic_type (entry
->d_un
.d_val
));
5743 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5749 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5750 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5756 switch (entry
->d_tag
)
5759 printf (_("Shared library: [%s]"), name
);
5761 if (streq (name
, program_interpreter
))
5762 printf (_(" program interpreter"));
5766 printf (_("Library soname: [%s]"), name
);
5770 printf (_("Library rpath: [%s]"), name
);
5774 printf (_("Library runpath: [%s]"), name
);
5778 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5783 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5796 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5800 case DT_INIT_ARRAYSZ
:
5801 case DT_FINI_ARRAYSZ
:
5802 case DT_GNU_CONFLICTSZ
:
5803 case DT_GNU_LIBLISTSZ
:
5806 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5807 printf (" (bytes)\n");
5817 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5830 if (entry
->d_tag
== DT_USED
5831 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5833 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5837 printf (_("Not needed object: [%s]\n"), name
);
5842 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5848 /* The value of this entry is ignored. */
5853 case DT_GNU_PRELINKED
:
5857 time_t time
= entry
->d_un
.d_val
;
5859 tmp
= gmtime (&time
);
5860 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5861 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5862 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5868 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5869 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5874 switch (elf_header
.e_machine
)
5877 case EM_MIPS_RS3_LE
:
5878 dynamic_section_mips_val (entry
);
5881 dynamic_section_parisc_val (entry
);
5884 dynamic_section_ia64_val (entry
);
5887 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5899 get_ver_flags (unsigned int flags
)
5901 static char buff
[32];
5908 if (flags
& VER_FLG_BASE
)
5909 strcat (buff
, "BASE ");
5911 if (flags
& VER_FLG_WEAK
)
5913 if (flags
& VER_FLG_BASE
)
5914 strcat (buff
, "| ");
5916 strcat (buff
, "WEAK ");
5919 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5920 strcat (buff
, "| <unknown>");
5925 /* Display the contents of the version sections. */
5927 process_version_sections (FILE *file
)
5929 Elf_Internal_Shdr
*section
;
5936 for (i
= 0, section
= section_headers
;
5937 i
< elf_header
.e_shnum
;
5940 switch (section
->sh_type
)
5942 case SHT_GNU_verdef
:
5944 Elf_External_Verdef
*edefs
;
5951 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5952 SECTION_NAME (section
), section
->sh_info
);
5954 printf (_(" Addr: 0x"));
5955 printf_vma (section
->sh_addr
);
5956 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5957 (unsigned long) section
->sh_offset
, section
->sh_link
,
5958 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5960 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5961 _("version definition section"));
5965 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5968 Elf_External_Verdef
*edef
;
5969 Elf_Internal_Verdef ent
;
5970 Elf_External_Verdaux
*eaux
;
5971 Elf_Internal_Verdaux aux
;
5975 vstart
= ((char *) edefs
) + idx
;
5977 edef
= (Elf_External_Verdef
*) vstart
;
5979 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5980 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5981 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5982 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5983 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5984 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5985 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5987 printf (_(" %#06x: Rev: %d Flags: %s"),
5988 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5990 printf (_(" Index: %d Cnt: %d "),
5991 ent
.vd_ndx
, ent
.vd_cnt
);
5993 vstart
+= ent
.vd_aux
;
5995 eaux
= (Elf_External_Verdaux
*) vstart
;
5997 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5998 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6000 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6001 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6003 printf (_("Name index: %ld\n"), aux
.vda_name
);
6005 isum
= idx
+ ent
.vd_aux
;
6007 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6009 isum
+= aux
.vda_next
;
6010 vstart
+= aux
.vda_next
;
6012 eaux
= (Elf_External_Verdaux
*) vstart
;
6014 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6015 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6017 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6018 printf (_(" %#06x: Parent %d: %s\n"),
6019 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6021 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6022 isum
, j
, aux
.vda_name
);
6032 case SHT_GNU_verneed
:
6034 Elf_External_Verneed
*eneed
;
6040 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6041 SECTION_NAME (section
), section
->sh_info
);
6043 printf (_(" Addr: 0x"));
6044 printf_vma (section
->sh_addr
);
6045 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6046 (unsigned long) section
->sh_offset
, section
->sh_link
,
6047 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6049 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6050 _("version need section"));
6054 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6056 Elf_External_Verneed
*entry
;
6057 Elf_Internal_Verneed ent
;
6062 vstart
= ((char *) eneed
) + idx
;
6064 entry
= (Elf_External_Verneed
*) vstart
;
6066 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6067 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6068 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6069 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6070 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6072 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6074 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6075 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6077 printf (_(" File: %lx"), ent
.vn_file
);
6079 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6081 vstart
+= ent
.vn_aux
;
6083 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6085 Elf_External_Vernaux
*eaux
;
6086 Elf_Internal_Vernaux aux
;
6088 eaux
= (Elf_External_Vernaux
*) vstart
;
6090 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6091 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6092 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6093 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6094 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6096 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6097 printf (_(" %#06x: Name: %s"),
6098 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6100 printf (_(" %#06x: Name index: %lx"),
6101 isum
, aux
.vna_name
);
6103 printf (_(" Flags: %s Version: %d\n"),
6104 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6106 isum
+= aux
.vna_next
;
6107 vstart
+= aux
.vna_next
;
6117 case SHT_GNU_versym
:
6119 Elf_Internal_Shdr
*link_section
;
6122 unsigned char *edata
;
6123 unsigned short *data
;
6125 Elf_Internal_Sym
*symbols
;
6126 Elf_Internal_Shdr
*string_sec
;
6129 link_section
= SECTION_HEADER (section
->sh_link
);
6130 total
= section
->sh_size
/ section
->sh_entsize
;
6134 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6136 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6138 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6139 string_sec
->sh_size
, _("version string table"));
6143 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6144 SECTION_NAME (section
), total
);
6146 printf (_(" Addr: "));
6147 printf_vma (section
->sh_addr
);
6148 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6149 (unsigned long) section
->sh_offset
, section
->sh_link
,
6150 SECTION_NAME (link_section
));
6152 off
= offset_from_vma (file
,
6153 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6154 total
* sizeof (short));
6155 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6156 _("version symbol data"));
6163 data
= malloc (total
* sizeof (short));
6165 for (cnt
= total
; cnt
--;)
6166 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6171 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6174 int check_def
, check_need
;
6177 printf (" %03x:", cnt
);
6179 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6180 switch (data
[cnt
+ j
])
6183 fputs (_(" 0 (*local*) "), stdout
);
6187 fputs (_(" 1 (*global*) "), stdout
);
6191 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6192 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6196 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6199 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6206 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6208 Elf_Internal_Verneed ivn
;
6209 unsigned long offset
;
6211 offset
= offset_from_vma
6212 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6213 sizeof (Elf_External_Verneed
));
6217 Elf_Internal_Vernaux ivna
;
6218 Elf_External_Verneed evn
;
6219 Elf_External_Vernaux evna
;
6220 unsigned long a_off
;
6222 get_data (&evn
, file
, offset
, sizeof (evn
),
6225 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6226 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6228 a_off
= offset
+ ivn
.vn_aux
;
6232 get_data (&evna
, file
, a_off
, sizeof (evna
),
6233 _("version need aux (2)"));
6235 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6236 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6238 a_off
+= ivna
.vna_next
;
6240 while (ivna
.vna_other
!= data
[cnt
+ j
]
6241 && ivna
.vna_next
!= 0);
6243 if (ivna
.vna_other
== data
[cnt
+ j
])
6245 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6247 name
= strtab
+ ivna
.vna_name
;
6248 nn
+= printf ("(%s%-*s",
6250 12 - (int) strlen (name
),
6256 offset
+= ivn
.vn_next
;
6258 while (ivn
.vn_next
);
6261 if (check_def
&& data
[cnt
+ j
] != 0x8001
6262 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6264 Elf_Internal_Verdef ivd
;
6265 Elf_External_Verdef evd
;
6266 unsigned long offset
;
6268 offset
= offset_from_vma
6269 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6274 get_data (&evd
, file
, offset
, sizeof (evd
),
6277 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6278 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6280 offset
+= ivd
.vd_next
;
6282 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6283 && ivd
.vd_next
!= 0);
6285 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6287 Elf_External_Verdaux evda
;
6288 Elf_Internal_Verdaux ivda
;
6290 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6292 get_data (&evda
, file
,
6293 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6294 sizeof (evda
), _("version def aux"));
6296 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6298 name
= strtab
+ ivda
.vda_name
;
6299 nn
+= printf ("(%s%-*s",
6301 12 - (int) strlen (name
),
6307 printf ("%*c", 18 - nn
, ' ');
6325 printf (_("\nNo version information found in this file.\n"));
6331 get_symbol_binding (unsigned int binding
)
6333 static char buff
[32];
6337 case STB_LOCAL
: return "LOCAL";
6338 case STB_GLOBAL
: return "GLOBAL";
6339 case STB_WEAK
: return "WEAK";
6341 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6342 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6344 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6345 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6347 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6353 get_symbol_type (unsigned int type
)
6355 static char buff
[32];
6359 case STT_NOTYPE
: return "NOTYPE";
6360 case STT_OBJECT
: return "OBJECT";
6361 case STT_FUNC
: return "FUNC";
6362 case STT_SECTION
: return "SECTION";
6363 case STT_FILE
: return "FILE";
6364 case STT_COMMON
: return "COMMON";
6365 case STT_TLS
: return "TLS";
6367 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6369 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6370 return "THUMB_FUNC";
6372 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6375 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6376 return "PARISC_MILLI";
6378 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6380 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6382 if (elf_header
.e_machine
== EM_PARISC
)
6384 if (type
== STT_HP_OPAQUE
)
6386 if (type
== STT_HP_STUB
)
6390 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6393 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6399 get_symbol_visibility (unsigned int visibility
)
6403 case STV_DEFAULT
: return "DEFAULT";
6404 case STV_INTERNAL
: return "INTERNAL";
6405 case STV_HIDDEN
: return "HIDDEN";
6406 case STV_PROTECTED
: return "PROTECTED";
6412 get_symbol_index_type (unsigned int type
)
6414 static char buff
[32];
6418 case SHN_UNDEF
: return "UND";
6419 case SHN_ABS
: return "ABS";
6420 case SHN_COMMON
: return "COM";
6422 if (type
== SHN_IA_64_ANSI_COMMON
6423 && elf_header
.e_machine
== EM_IA_64
6424 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6426 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6427 sprintf (buff
, "PRC[0x%04x]", type
);
6428 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6429 sprintf (buff
, "OS [0x%04x]", type
);
6430 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6431 sprintf (buff
, "RSV[0x%04x]", type
);
6433 sprintf (buff
, "%3d", type
);
6441 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6443 unsigned char *e_data
;
6446 e_data
= malloc (number
* ent_size
);
6450 error (_("Out of memory\n"));
6454 if (fread (e_data
, ent_size
, number
, file
) != number
)
6456 error (_("Unable to read in dynamic data\n"));
6460 i_data
= malloc (number
* sizeof (*i_data
));
6464 error (_("Out of memory\n"));
6470 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6477 /* Dump the symbol table. */
6479 process_symbol_table (FILE *file
)
6481 Elf_Internal_Shdr
*section
;
6482 bfd_vma nbuckets
= 0;
6483 bfd_vma nchains
= 0;
6484 bfd_vma
*buckets
= NULL
;
6485 bfd_vma
*chains
= NULL
;
6487 if (! do_syms
&& !do_histogram
)
6490 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6493 unsigned char nb
[8];
6494 unsigned char nc
[8];
6495 int hash_ent_size
= 4;
6497 if ((elf_header
.e_machine
== EM_ALPHA
6498 || elf_header
.e_machine
== EM_S390
6499 || elf_header
.e_machine
== EM_S390_OLD
)
6500 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6504 (archive_file_offset
6505 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6506 sizeof nb
+ sizeof nc
)),
6509 error (_("Unable to seek to start of dynamic information"));
6513 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6515 error (_("Failed to read in number of buckets\n"));
6519 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6521 error (_("Failed to read in number of chains\n"));
6525 nbuckets
= byte_get (nb
, hash_ent_size
);
6526 nchains
= byte_get (nc
, hash_ent_size
);
6528 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6529 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6531 if (buckets
== NULL
|| chains
== NULL
)
6536 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6541 printf (_("\nSymbol table for image:\n"));
6543 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6545 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6547 for (hn
= 0; hn
< nbuckets
; hn
++)
6552 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6554 Elf_Internal_Sym
*psym
;
6557 psym
= dynamic_symbols
+ si
;
6559 n
= print_vma (si
, DEC_5
);
6561 fputs (" " + n
, stdout
);
6562 printf (" %3lu: ", hn
);
6563 print_vma (psym
->st_value
, LONG_HEX
);
6565 print_vma (psym
->st_size
, DEC_5
);
6567 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6568 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6569 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6570 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6571 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6572 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6574 printf (" <corrupt: %14ld>", psym
->st_name
);
6579 else if (do_syms
&& !do_using_dynamic
)
6583 for (i
= 0, section
= section_headers
;
6584 i
< elf_header
.e_shnum
;
6589 Elf_Internal_Sym
*symtab
;
6590 Elf_Internal_Sym
*psym
;
6593 if ( section
->sh_type
!= SHT_SYMTAB
6594 && section
->sh_type
!= SHT_DYNSYM
)
6597 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6598 SECTION_NAME (section
),
6599 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6601 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6603 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6605 symtab
= GET_ELF_SYMBOLS (file
, section
);
6609 if (section
->sh_link
== elf_header
.e_shstrndx
)
6610 strtab
= string_table
;
6613 Elf_Internal_Shdr
*string_sec
;
6615 string_sec
= SECTION_HEADER (section
->sh_link
);
6617 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6618 string_sec
->sh_size
, _("string table"));
6621 for (si
= 0, psym
= symtab
;
6622 si
< section
->sh_size
/ section
->sh_entsize
;
6625 printf ("%6d: ", si
);
6626 print_vma (psym
->st_value
, LONG_HEX
);
6628 print_vma (psym
->st_size
, DEC_5
);
6629 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6630 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6631 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6632 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6633 print_symbol (25, strtab
+ psym
->st_name
);
6635 if (section
->sh_type
== SHT_DYNSYM
&&
6636 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6638 unsigned char data
[2];
6639 unsigned short vers_data
;
6640 unsigned long offset
;
6644 offset
= offset_from_vma
6645 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6646 sizeof data
+ si
* sizeof (vers_data
));
6648 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6649 sizeof (data
), _("version data"));
6651 vers_data
= byte_get (data
, 2);
6653 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6656 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6658 if ((vers_data
& 0x8000) || vers_data
> 1)
6660 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6661 && (is_nobits
|| ! check_def
))
6663 Elf_External_Verneed evn
;
6664 Elf_Internal_Verneed ivn
;
6665 Elf_Internal_Vernaux ivna
;
6667 /* We must test both. */
6668 offset
= offset_from_vma
6669 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6674 unsigned long vna_off
;
6676 get_data (&evn
, file
, offset
, sizeof (evn
),
6679 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6680 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6682 vna_off
= offset
+ ivn
.vn_aux
;
6686 Elf_External_Vernaux evna
;
6688 get_data (&evna
, file
, vna_off
,
6690 _("version need aux (3)"));
6692 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6693 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6694 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6696 vna_off
+= ivna
.vna_next
;
6698 while (ivna
.vna_other
!= vers_data
6699 && ivna
.vna_next
!= 0);
6701 if (ivna
.vna_other
== vers_data
)
6704 offset
+= ivn
.vn_next
;
6706 while (ivn
.vn_next
!= 0);
6708 if (ivna
.vna_other
== vers_data
)
6711 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6714 else if (! is_nobits
)
6715 error (_("bad dynamic symbol"));
6722 if (vers_data
!= 0x8001
6723 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6725 Elf_Internal_Verdef ivd
;
6726 Elf_Internal_Verdaux ivda
;
6727 Elf_External_Verdaux evda
;
6728 unsigned long offset
;
6730 offset
= offset_from_vma
6732 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6733 sizeof (Elf_External_Verdef
));
6737 Elf_External_Verdef evd
;
6739 get_data (&evd
, file
, offset
, sizeof (evd
),
6742 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6743 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6744 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6746 offset
+= ivd
.vd_next
;
6748 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6749 && ivd
.vd_next
!= 0);
6751 offset
-= ivd
.vd_next
;
6752 offset
+= ivd
.vd_aux
;
6754 get_data (&evda
, file
, offset
, sizeof (evda
),
6755 _("version def aux"));
6757 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6759 if (psym
->st_name
!= ivda
.vda_name
)
6760 printf ((vers_data
& 0x8000)
6762 strtab
+ ivda
.vda_name
);
6772 if (strtab
!= string_table
)
6778 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6780 if (do_histogram
&& buckets
!= NULL
)
6782 unsigned long *lengths
;
6783 unsigned long *counts
;
6786 unsigned long maxlength
= 0;
6787 unsigned long nzero_counts
= 0;
6788 unsigned long nsyms
= 0;
6790 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
6791 (unsigned long) nbuckets
);
6792 printf (_(" Length Number %% of total Coverage\n"));
6794 lengths
= calloc (nbuckets
, sizeof (*lengths
));
6795 if (lengths
== NULL
)
6797 error (_("Out of memory"));
6800 for (hn
= 0; hn
< nbuckets
; ++hn
)
6802 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6805 if (maxlength
< ++lengths
[hn
])
6810 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
6813 error (_("Out of memory"));
6817 for (hn
= 0; hn
< nbuckets
; ++hn
)
6818 ++counts
[lengths
[hn
]];
6823 printf (" 0 %-10lu (%5.1f%%)\n",
6824 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6825 for (i
= 1; i
<= maxlength
; ++i
)
6827 nzero_counts
+= counts
[i
] * i
;
6828 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
6829 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
6830 (nzero_counts
* 100.0) / nsyms
);
6838 if (buckets
!= NULL
)
6848 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6852 if (dynamic_syminfo
== NULL
6854 /* No syminfo, this is ok. */
6857 /* There better should be a dynamic symbol section. */
6858 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6862 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6863 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6865 printf (_(" Num: Name BoundTo Flags\n"));
6866 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6868 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6870 printf ("%4d: ", i
);
6871 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6872 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6874 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6877 switch (dynamic_syminfo
[i
].si_boundto
)
6879 case SYMINFO_BT_SELF
:
6880 fputs ("SELF ", stdout
);
6882 case SYMINFO_BT_PARENT
:
6883 fputs ("PARENT ", stdout
);
6886 if (dynamic_syminfo
[i
].si_boundto
> 0
6887 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6888 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6890 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6894 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6898 if (flags
& SYMINFO_FLG_DIRECT
)
6900 if (flags
& SYMINFO_FLG_PASSTHRU
)
6901 printf (" PASSTHRU");
6902 if (flags
& SYMINFO_FLG_COPY
)
6904 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6905 printf (" LAZYLOAD");
6913 #ifdef SUPPORT_DISASSEMBLY
6915 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6917 printf (_("\nAssembly dump of section %s\n"),
6918 SECTION_NAME (section
));
6920 /* XXX -- to be done --- XXX */
6927 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6929 bfd_size_type bytes
;
6931 unsigned char *data
;
6932 unsigned char *start
;
6934 bytes
= section
->sh_size
;
6936 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6938 printf (_("\nSection '%s' has no data to dump.\n"),
6939 SECTION_NAME (section
));
6943 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6945 addr
= section
->sh_addr
;
6947 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6959 lbytes
= (bytes
> 16 ? 16 : bytes
);
6961 printf (" 0x%8.8lx ", (unsigned long) addr
);
6963 switch (elf_header
.e_ident
[EI_DATA
])
6967 for (j
= 15; j
>= 0; j
--)
6970 printf ("%2.2x", data
[j
]);
6980 for (j
= 0; j
< 16; j
++)
6983 printf ("%2.2x", data
[j
]);
6993 for (j
= 0; j
< lbytes
; j
++)
6996 if (k
>= ' ' && k
< 0x7f)
7015 static unsigned long int
7016 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7018 unsigned long int result
= 0;
7019 unsigned int num_read
= 0;
7020 unsigned int shift
= 0;
7028 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7033 while (byte
& 0x80);
7035 if (length_return
!= NULL
)
7036 *length_return
= num_read
;
7038 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7039 result
|= -1L << shift
;
7044 typedef struct State_Machine_Registers
7046 unsigned long address
;
7049 unsigned int column
;
7053 /* This variable hold the number of the last entry seen
7054 in the File Table. */
7055 unsigned int last_file_entry
;
7058 static SMR state_machine_regs
;
7061 reset_state_machine (int is_stmt
)
7063 state_machine_regs
.address
= 0;
7064 state_machine_regs
.file
= 1;
7065 state_machine_regs
.line
= 1;
7066 state_machine_regs
.column
= 0;
7067 state_machine_regs
.is_stmt
= is_stmt
;
7068 state_machine_regs
.basic_block
= 0;
7069 state_machine_regs
.end_sequence
= 0;
7070 state_machine_regs
.last_file_entry
= 0;
7073 /* Handled an extend line op. Returns true if this is the end
7077 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7079 unsigned char op_code
;
7080 unsigned int bytes_read
;
7082 unsigned char *name
;
7085 len
= read_leb128 (data
, & bytes_read
, 0);
7090 warn (_("badly formed extended line op encountered!\n"));
7097 printf (_(" Extended opcode %d: "), op_code
);
7101 case DW_LNE_end_sequence
:
7102 printf (_("End of Sequence\n\n"));
7103 reset_state_machine (is_stmt
);
7106 case DW_LNE_set_address
:
7107 adr
= byte_get (data
, pointer_size
);
7108 printf (_("set Address to 0x%lx\n"), adr
);
7109 state_machine_regs
.address
= adr
;
7112 case DW_LNE_define_file
:
7113 printf (_(" define new File Table entry\n"));
7114 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7116 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7118 data
+= strlen ((char *) data
) + 1;
7119 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7121 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7123 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7124 printf (_("%s\n\n"), name
);
7128 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7135 static const char *debug_str_contents
;
7136 static bfd_vma debug_str_size
;
7139 load_debug_str (FILE *file
)
7141 Elf_Internal_Shdr
*sec
;
7143 /* If it is already loaded, do nothing. */
7144 if (debug_str_contents
!= NULL
)
7147 /* Locate the .debug_str section. */
7148 sec
= find_section (".debug_str");
7152 debug_str_size
= sec
->sh_size
;
7154 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7155 _("debug_str section data"));
7159 free_debug_str (void)
7161 if (debug_str_contents
== NULL
)
7164 free ((char *) debug_str_contents
);
7165 debug_str_contents
= NULL
;
7170 fetch_indirect_string (unsigned long offset
)
7172 if (debug_str_contents
== NULL
)
7173 return _("<no .debug_str section>");
7175 if (offset
> debug_str_size
)
7176 return _("<offset is too big>");
7178 return debug_str_contents
+ offset
;
7181 static const char *debug_loc_contents
;
7182 static bfd_vma debug_loc_size
;
7185 load_debug_loc (FILE *file
)
7187 Elf_Internal_Shdr
*sec
;
7189 /* If it is already loaded, do nothing. */
7190 if (debug_loc_contents
!= NULL
)
7193 /* Locate the .debug_loc section. */
7194 sec
= find_section (".debug_loc");
7198 debug_loc_size
= sec
->sh_size
;
7200 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7201 _("debug_loc section data"));
7205 free_debug_loc (void)
7207 if (debug_loc_contents
== NULL
)
7210 free ((char *) debug_loc_contents
);
7211 debug_loc_contents
= NULL
;
7215 static const char * debug_range_contents
;
7216 static unsigned long debug_range_size
;
7219 load_debug_range (FILE *file
)
7221 Elf_Internal_Shdr
*sec
;
7223 /* If it is already loaded, do nothing. */
7224 if (debug_range_contents
!= NULL
)
7227 /* Locate the .debug_str section. */
7228 sec
= find_section (".debug_ranges");
7232 debug_range_size
= sec
->sh_size
;
7234 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7235 _("debug_range section data"));
7239 free_debug_range (void)
7241 if (debug_range_contents
== NULL
)
7244 free ((char *) debug_range_contents
);
7245 debug_range_contents
= NULL
;
7246 debug_range_size
= 0;
7249 /* Apply addends of RELA relocations. */
7252 debug_apply_rela_addends (FILE *file
,
7253 Elf_Internal_Shdr
*section
,
7255 unsigned char *sec_data
,
7256 unsigned char *start
,
7259 Elf_Internal_Shdr
*relsec
;
7261 if (end
- start
< reloc_size
)
7264 for (relsec
= section_headers
;
7265 relsec
< section_headers
+ elf_header
.e_shnum
;
7268 unsigned long nrelas
;
7269 Elf_Internal_Rela
*rela
, *rp
;
7270 Elf_Internal_Shdr
*symsec
;
7271 Elf_Internal_Sym
*symtab
;
7272 Elf_Internal_Sym
*sym
;
7274 if (relsec
->sh_type
!= SHT_RELA
7275 || SECTION_HEADER (relsec
->sh_info
) != section
7276 || relsec
->sh_size
== 0)
7279 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7283 symsec
= SECTION_HEADER (relsec
->sh_link
);
7284 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7286 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7290 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7291 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7292 loc
= sec_data
+ rp
->r_offset
;
7298 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7300 if (ELF32_R_SYM (rp
->r_info
) != 0
7301 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7302 /* Relocations against object symbols can happen,
7303 eg when referencing a global array. For an
7304 example of this see the _clz.o binary in libgcc.a. */
7305 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7307 warn (_("%s: skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7308 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7309 SECTION_NAME (section
));
7315 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7317 if (ELF64_R_SYM (rp
->r_info
) != 0
7318 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7319 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7321 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7322 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7323 SECTION_NAME (section
));
7328 byte_put (loc
, rp
->r_addend
, reloc_size
);
7338 /* FIXME: There are better and more efficient ways to handle
7339 these structures. For now though, I just want something that
7340 is simple to implement. */
7341 typedef struct abbrev_attr
7343 unsigned long attribute
;
7345 struct abbrev_attr
*next
;
7349 typedef struct abbrev_entry
7351 unsigned long entry
;
7354 struct abbrev_attr
*first_attr
;
7355 struct abbrev_attr
*last_attr
;
7356 struct abbrev_entry
*next
;
7360 static abbrev_entry
*first_abbrev
= NULL
;
7361 static abbrev_entry
*last_abbrev
= NULL
;
7366 abbrev_entry
*abbrev
;
7368 for (abbrev
= first_abbrev
; abbrev
;)
7370 abbrev_entry
*next
= abbrev
->next
;
7373 for (attr
= abbrev
->first_attr
; attr
;)
7375 abbrev_attr
*next
= attr
->next
;
7385 last_abbrev
= first_abbrev
= NULL
;
7389 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7391 abbrev_entry
*entry
;
7393 entry
= malloc (sizeof (*entry
));
7399 entry
->entry
= number
;
7401 entry
->children
= children
;
7402 entry
->first_attr
= NULL
;
7403 entry
->last_attr
= NULL
;
7406 if (first_abbrev
== NULL
)
7407 first_abbrev
= entry
;
7409 last_abbrev
->next
= entry
;
7411 last_abbrev
= entry
;
7415 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7419 attr
= malloc (sizeof (*attr
));
7425 attr
->attribute
= attribute
;
7429 if (last_abbrev
->first_attr
== NULL
)
7430 last_abbrev
->first_attr
= attr
;
7432 last_abbrev
->last_attr
->next
= attr
;
7434 last_abbrev
->last_attr
= attr
;
7437 /* Processes the (partial) contents of a .debug_abbrev section.
7438 Returns NULL if the end of the section was encountered.
7439 Returns the address after the last byte read if the end of
7440 an abbreviation set was found. */
7442 static unsigned char *
7443 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7445 if (first_abbrev
!= NULL
)
7450 unsigned int bytes_read
;
7451 unsigned long entry
;
7453 unsigned long attribute
;
7456 entry
= read_leb128 (start
, & bytes_read
, 0);
7457 start
+= bytes_read
;
7459 /* A single zero is supposed to end the section according
7460 to the standard. If there's more, then signal that to
7463 return start
== end
? NULL
: start
;
7465 tag
= read_leb128 (start
, & bytes_read
, 0);
7466 start
+= bytes_read
;
7468 children
= *start
++;
7470 add_abbrev (entry
, tag
, children
);
7476 attribute
= read_leb128 (start
, & bytes_read
, 0);
7477 start
+= bytes_read
;
7479 form
= read_leb128 (start
, & bytes_read
, 0);
7480 start
+= bytes_read
;
7483 add_abbrev_attr (attribute
, form
);
7485 while (attribute
!= 0);
7492 get_TAG_name (unsigned long tag
)
7496 case DW_TAG_padding
: return "DW_TAG_padding";
7497 case DW_TAG_array_type
: return "DW_TAG_array_type";
7498 case DW_TAG_class_type
: return "DW_TAG_class_type";
7499 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7500 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7501 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7502 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7503 case DW_TAG_label
: return "DW_TAG_label";
7504 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7505 case DW_TAG_member
: return "DW_TAG_member";
7506 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7507 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7508 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7509 case DW_TAG_string_type
: return "DW_TAG_string_type";
7510 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7511 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7512 case DW_TAG_typedef
: return "DW_TAG_typedef";
7513 case DW_TAG_union_type
: return "DW_TAG_union_type";
7514 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7515 case DW_TAG_variant
: return "DW_TAG_variant";
7516 case DW_TAG_common_block
: return "DW_TAG_common_block";
7517 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7518 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7519 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7520 case DW_TAG_module
: return "DW_TAG_module";
7521 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7522 case DW_TAG_set_type
: return "DW_TAG_set_type";
7523 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7524 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7525 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7526 case DW_TAG_base_type
: return "DW_TAG_base_type";
7527 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7528 case DW_TAG_const_type
: return "DW_TAG_const_type";
7529 case DW_TAG_constant
: return "DW_TAG_constant";
7530 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7531 case DW_TAG_file_type
: return "DW_TAG_file_type";
7532 case DW_TAG_friend
: return "DW_TAG_friend";
7533 case DW_TAG_namelist
: return "DW_TAG_namelist";
7534 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7535 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7536 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7537 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7538 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7539 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7540 case DW_TAG_try_block
: return "DW_TAG_try_block";
7541 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7542 case DW_TAG_variable
: return "DW_TAG_variable";
7543 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7544 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7545 case DW_TAG_format_label
: return "DW_TAG_format_label";
7546 case DW_TAG_function_template
: return "DW_TAG_function_template";
7547 case DW_TAG_class_template
: return "DW_TAG_class_template";
7548 /* DWARF 2.1 values. */
7549 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7550 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7551 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7552 case DW_TAG_namespace
: return "DW_TAG_namespace";
7553 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7554 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7555 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7556 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7558 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7559 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7560 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7563 static char buffer
[100];
7565 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
7572 get_FORM_name (unsigned long form
)
7576 case DW_FORM_addr
: return "DW_FORM_addr";
7577 case DW_FORM_block2
: return "DW_FORM_block2";
7578 case DW_FORM_block4
: return "DW_FORM_block4";
7579 case DW_FORM_data2
: return "DW_FORM_data2";
7580 case DW_FORM_data4
: return "DW_FORM_data4";
7581 case DW_FORM_data8
: return "DW_FORM_data8";
7582 case DW_FORM_string
: return "DW_FORM_string";
7583 case DW_FORM_block
: return "DW_FORM_block";
7584 case DW_FORM_block1
: return "DW_FORM_block1";
7585 case DW_FORM_data1
: return "DW_FORM_data1";
7586 case DW_FORM_flag
: return "DW_FORM_flag";
7587 case DW_FORM_sdata
: return "DW_FORM_sdata";
7588 case DW_FORM_strp
: return "DW_FORM_strp";
7589 case DW_FORM_udata
: return "DW_FORM_udata";
7590 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7591 case DW_FORM_ref1
: return "DW_FORM_ref1";
7592 case DW_FORM_ref2
: return "DW_FORM_ref2";
7593 case DW_FORM_ref4
: return "DW_FORM_ref4";
7594 case DW_FORM_ref8
: return "DW_FORM_ref8";
7595 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7596 case DW_FORM_indirect
: return "DW_FORM_indirect";
7599 static char buffer
[100];
7601 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
7607 static unsigned char *
7608 display_block (unsigned char *data
, unsigned long length
)
7610 printf (_(" %lu byte block: "), length
);
7613 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7619 decode_location_expression (unsigned char * data
,
7620 unsigned int pointer_size
,
7621 unsigned long length
,
7622 unsigned long cu_offset
)
7625 unsigned int bytes_read
;
7626 unsigned long uvalue
;
7627 unsigned char *end
= data
+ length
;
7628 int need_frame_base
= 0;
7637 printf ("DW_OP_addr: %lx",
7638 (unsigned long) byte_get (data
, pointer_size
));
7639 data
+= pointer_size
;
7642 printf ("DW_OP_deref");
7645 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7648 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7651 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7655 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7659 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7663 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7667 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7668 (unsigned long) byte_get (data
+ 4, 4));
7672 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7673 (long) byte_get (data
+ 4, 4));
7677 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7681 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7685 printf ("DW_OP_dup");
7688 printf ("DW_OP_drop");
7691 printf ("DW_OP_over");
7694 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7697 printf ("DW_OP_swap");
7700 printf ("DW_OP_rot");
7703 printf ("DW_OP_xderef");
7706 printf ("DW_OP_abs");
7709 printf ("DW_OP_and");
7712 printf ("DW_OP_div");
7715 printf ("DW_OP_minus");
7718 printf ("DW_OP_mod");
7721 printf ("DW_OP_mul");
7724 printf ("DW_OP_neg");
7727 printf ("DW_OP_not");
7730 printf ("DW_OP_or");
7733 printf ("DW_OP_plus");
7735 case DW_OP_plus_uconst
:
7736 printf ("DW_OP_plus_uconst: %lu",
7737 read_leb128 (data
, &bytes_read
, 0));
7741 printf ("DW_OP_shl");
7744 printf ("DW_OP_shr");
7747 printf ("DW_OP_shra");
7750 printf ("DW_OP_xor");
7753 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7757 printf ("DW_OP_eq");
7760 printf ("DW_OP_ge");
7763 printf ("DW_OP_gt");
7766 printf ("DW_OP_le");
7769 printf ("DW_OP_lt");
7772 printf ("DW_OP_ne");
7775 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7811 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7846 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7881 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7882 read_leb128 (data
, &bytes_read
, 1));
7887 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7891 need_frame_base
= 1;
7892 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7896 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7898 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7899 read_leb128 (data
, &bytes_read
, 1));
7903 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7906 case DW_OP_deref_size
:
7907 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7909 case DW_OP_xderef_size
:
7910 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7913 printf ("DW_OP_nop");
7916 /* DWARF 3 extensions. */
7917 case DW_OP_push_object_address
:
7918 printf ("DW_OP_push_object_address");
7921 /* XXX: Strictly speaking for 64-bit DWARF3 files
7922 this ought to be an 8-byte wide computation. */
7923 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
7927 /* XXX: Strictly speaking for 64-bit DWARF3 files
7928 this ought to be an 8-byte wide computation. */
7929 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
7932 case DW_OP_call_ref
:
7933 printf ("DW_OP_call_ref");
7936 /* GNU extensions. */
7937 case DW_OP_GNU_push_tls_address
:
7938 printf ("DW_OP_GNU_push_tls_address");
7942 if (op
>= DW_OP_lo_user
7943 && op
<= DW_OP_hi_user
)
7944 printf (_("(User defined location op)"));
7946 printf (_("(Unknown location op)"));
7947 /* No way to tell where the next op is, so just bail. */
7948 return need_frame_base
;
7951 /* Separate the ops. */
7956 return need_frame_base
;
7959 /* This structure records the information that
7960 we extract from the.debug_info section. */
7963 unsigned int pointer_size
;
7964 unsigned long cu_offset
;
7965 unsigned long base_address
;
7966 /* This is an array of offsets to the location list table. */
7967 unsigned long *loc_offsets
;
7968 int *have_frame_base
;
7969 unsigned int num_loc_offsets
;
7970 unsigned int max_loc_offsets
;
7971 unsigned long *range_lists
;
7972 unsigned int num_range_lists
;
7973 unsigned int max_range_lists
;
7977 static debug_info
* debug_information
= NULL
;
7978 static unsigned int num_debug_info_entries
= 0;
7979 static unsigned int last_pointer_size
= 0;
7980 static int warned_about_missing_comp_units
= FALSE
;
7982 static unsigned char *
7983 read_and_display_attr_value (unsigned long attribute
,
7985 unsigned char *data
,
7986 unsigned long cu_offset
,
7987 unsigned long pointer_size
,
7988 unsigned long offset_size
,
7990 debug_info
*debug_info_p
,
7993 unsigned long uvalue
= 0;
7994 unsigned char *block_start
= NULL
;
7995 unsigned int bytes_read
;
8002 case DW_FORM_ref_addr
:
8003 if (dwarf_version
== 2)
8005 uvalue
= byte_get (data
, pointer_size
);
8006 data
+= pointer_size
;
8008 else if (dwarf_version
== 3)
8010 uvalue
= byte_get (data
, offset_size
);
8011 data
+= offset_size
;
8015 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8020 uvalue
= byte_get (data
, pointer_size
);
8021 data
+= pointer_size
;
8025 uvalue
= byte_get (data
, offset_size
);
8026 data
+= offset_size
;
8032 uvalue
= byte_get (data
++, 1);
8037 uvalue
= byte_get (data
, 2);
8043 uvalue
= byte_get (data
, 4);
8048 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8052 case DW_FORM_ref_udata
:
8054 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8058 case DW_FORM_indirect
:
8059 form
= read_leb128 (data
, & bytes_read
, 0);
8062 printf (" %s", get_FORM_name (form
));
8063 return read_and_display_attr_value (attribute
, form
, data
,
8064 cu_offset
, pointer_size
,
8065 offset_size
, dwarf_version
,
8066 debug_info_p
, do_loc
);
8071 case DW_FORM_ref_addr
:
8073 printf (" <#%lx>", uvalue
);
8079 case DW_FORM_ref_udata
:
8081 printf (" <%lx>", uvalue
+ cu_offset
);
8087 printf (" %#lx", uvalue
);
8096 printf (" %ld", uvalue
);
8103 uvalue
= byte_get (data
, 4);
8104 printf (" %lx", uvalue
);
8105 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8107 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8108 && num_debug_info_entries
== 0)
8110 if (sizeof (uvalue
) == 8)
8111 uvalue
= byte_get (data
, 8);
8113 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8118 case DW_FORM_string
:
8120 printf (" %s", data
);
8121 data
+= strlen ((char *) data
) + 1;
8125 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8126 block_start
= data
+ bytes_read
;
8128 data
= block_start
+ uvalue
;
8130 data
= display_block (block_start
, uvalue
);
8133 case DW_FORM_block1
:
8134 uvalue
= byte_get (data
, 1);
8135 block_start
= data
+ 1;
8137 data
= block_start
+ uvalue
;
8139 data
= display_block (block_start
, uvalue
);
8142 case DW_FORM_block2
:
8143 uvalue
= byte_get (data
, 2);
8144 block_start
= data
+ 2;
8146 data
= block_start
+ uvalue
;
8148 data
= display_block (block_start
, uvalue
);
8151 case DW_FORM_block4
:
8152 uvalue
= byte_get (data
, 4);
8153 block_start
= data
+ 4;
8155 data
= block_start
+ uvalue
;
8157 data
= display_block (block_start
, uvalue
);
8162 printf (_(" (indirect string, offset: 0x%lx): %s"),
8163 uvalue
, fetch_indirect_string (uvalue
));
8166 case DW_FORM_indirect
:
8167 /* Handled above. */
8171 warn (_("Unrecognized form: %d\n"), form
);
8175 /* For some attributes we can display further information. */
8176 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8177 && num_debug_info_entries
== 0)
8181 case DW_AT_frame_base
:
8182 have_frame_base
= 1;
8183 case DW_AT_location
:
8184 case DW_AT_data_member_location
:
8185 case DW_AT_vtable_elem_location
:
8186 case DW_AT_allocated
:
8187 case DW_AT_associated
:
8188 case DW_AT_data_location
:
8190 case DW_AT_upper_bound
:
8191 case DW_AT_lower_bound
:
8192 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8194 /* Process location list. */
8195 unsigned int max
= debug_info_p
->max_loc_offsets
;
8196 unsigned int num
= debug_info_p
->num_loc_offsets
;
8198 if (max
== 0 || num
>= max
)
8201 debug_info_p
->loc_offsets
8202 = xrealloc (debug_info_p
->loc_offsets
,
8203 max
* sizeof (*debug_info_p
->loc_offsets
));
8204 debug_info_p
->have_frame_base
8205 = xrealloc (debug_info_p
->have_frame_base
,
8206 max
* sizeof (*debug_info_p
->have_frame_base
));
8207 debug_info_p
->max_loc_offsets
= max
;
8209 debug_info_p
->loc_offsets
[num
] = uvalue
;
8210 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8211 debug_info_p
->num_loc_offsets
++;
8216 if (need_base_address
)
8217 debug_info_p
->base_address
= uvalue
;
8221 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8223 /* Process range list. */
8224 unsigned int max
= debug_info_p
->max_range_lists
;
8225 unsigned int num
= debug_info_p
->num_range_lists
;
8227 if (max
== 0 || num
>= max
)
8230 debug_info_p
->range_lists
8231 = xrealloc (debug_info_p
->range_lists
,
8232 max
* sizeof (*debug_info_p
->range_lists
));
8233 debug_info_p
->max_range_lists
= max
;
8235 debug_info_p
->range_lists
[num
] = uvalue
;
8236 debug_info_p
->num_range_lists
++;
8255 case DW_INL_not_inlined
:
8256 printf (_("(not inlined)"));
8258 case DW_INL_inlined
:
8259 printf (_("(inlined)"));
8261 case DW_INL_declared_not_inlined
:
8262 printf (_("(declared as inline but ignored)"));
8264 case DW_INL_declared_inlined
:
8265 printf (_("(declared as inline and inlined)"));
8268 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8273 case DW_AT_language
:
8276 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8277 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8278 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8279 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8280 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8281 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8282 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8283 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8284 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8285 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8286 /* DWARF 2.1 values. */
8287 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8288 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8289 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8290 /* MIPS extension. */
8291 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8292 /* UPC extension. */
8293 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8295 printf ("(Unknown: %lx)", uvalue
);
8300 case DW_AT_encoding
:
8303 case DW_ATE_void
: printf ("(void)"); break;
8304 case DW_ATE_address
: printf ("(machine address)"); break;
8305 case DW_ATE_boolean
: printf ("(boolean)"); break;
8306 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8307 case DW_ATE_float
: printf ("(float)"); break;
8308 case DW_ATE_signed
: printf ("(signed)"); break;
8309 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8310 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8311 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8312 /* DWARF 2.1 value. */
8313 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8315 if (uvalue
>= DW_ATE_lo_user
8316 && uvalue
<= DW_ATE_hi_user
)
8317 printf ("(user defined type)");
8319 printf ("(unknown type)");
8324 case DW_AT_accessibility
:
8327 case DW_ACCESS_public
: printf ("(public)"); break;
8328 case DW_ACCESS_protected
: printf ("(protected)"); break;
8329 case DW_ACCESS_private
: printf ("(private)"); break;
8331 printf ("(unknown accessibility)");
8336 case DW_AT_visibility
:
8339 case DW_VIS_local
: printf ("(local)"); break;
8340 case DW_VIS_exported
: printf ("(exported)"); break;
8341 case DW_VIS_qualified
: printf ("(qualified)"); break;
8342 default: printf ("(unknown visibility)"); break;
8346 case DW_AT_virtuality
:
8349 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8350 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8351 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8352 default: printf ("(unknown virtuality)"); break;
8356 case DW_AT_identifier_case
:
8359 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8360 case DW_ID_up_case
: printf ("(up_case)"); break;
8361 case DW_ID_down_case
: printf ("(down_case)"); break;
8362 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8363 default: printf ("(unknown case)"); break;
8367 case DW_AT_calling_convention
:
8370 case DW_CC_normal
: printf ("(normal)"); break;
8371 case DW_CC_program
: printf ("(program)"); break;
8372 case DW_CC_nocall
: printf ("(nocall)"); break;
8374 if (uvalue
>= DW_CC_lo_user
8375 && uvalue
<= DW_CC_hi_user
)
8376 printf ("(user defined)");
8378 printf ("(unknown convention)");
8382 case DW_AT_ordering
:
8385 case -1: printf ("(undefined)"); break;
8386 case 0: printf ("(row major)"); break;
8387 case 1: printf ("(column major)"); break;
8391 case DW_AT_frame_base
:
8392 have_frame_base
= 1;
8393 case DW_AT_location
:
8394 case DW_AT_data_member_location
:
8395 case DW_AT_vtable_elem_location
:
8396 case DW_AT_allocated
:
8397 case DW_AT_associated
:
8398 case DW_AT_data_location
:
8400 case DW_AT_upper_bound
:
8401 case DW_AT_lower_bound
:
8404 int need_frame_base
;
8407 need_frame_base
= decode_location_expression (block_start
,
8412 if (need_frame_base
&& !have_frame_base
)
8413 printf (_(" [without DW_AT_frame_base]"));
8415 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8416 printf (_("(location list)"));
8428 get_AT_name (unsigned long attribute
)
8432 case DW_AT_sibling
: return "DW_AT_sibling";
8433 case DW_AT_location
: return "DW_AT_location";
8434 case DW_AT_name
: return "DW_AT_name";
8435 case DW_AT_ordering
: return "DW_AT_ordering";
8436 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8437 case DW_AT_byte_size
: return "DW_AT_byte_size";
8438 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8439 case DW_AT_bit_size
: return "DW_AT_bit_size";
8440 case DW_AT_element_list
: return "DW_AT_element_list";
8441 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8442 case DW_AT_low_pc
: return "DW_AT_low_pc";
8443 case DW_AT_high_pc
: return "DW_AT_high_pc";
8444 case DW_AT_language
: return "DW_AT_language";
8445 case DW_AT_member
: return "DW_AT_member";
8446 case DW_AT_discr
: return "DW_AT_discr";
8447 case DW_AT_discr_value
: return "DW_AT_discr_value";
8448 case DW_AT_visibility
: return "DW_AT_visibility";
8449 case DW_AT_import
: return "DW_AT_import";
8450 case DW_AT_string_length
: return "DW_AT_string_length";
8451 case DW_AT_common_reference
: return "DW_AT_common_reference";
8452 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8453 case DW_AT_const_value
: return "DW_AT_const_value";
8454 case DW_AT_containing_type
: return "DW_AT_containing_type";
8455 case DW_AT_default_value
: return "DW_AT_default_value";
8456 case DW_AT_inline
: return "DW_AT_inline";
8457 case DW_AT_is_optional
: return "DW_AT_is_optional";
8458 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8459 case DW_AT_producer
: return "DW_AT_producer";
8460 case DW_AT_prototyped
: return "DW_AT_prototyped";
8461 case DW_AT_return_addr
: return "DW_AT_return_addr";
8462 case DW_AT_start_scope
: return "DW_AT_start_scope";
8463 case DW_AT_stride_size
: return "DW_AT_stride_size";
8464 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8465 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8466 case DW_AT_accessibility
: return "DW_AT_accessibility";
8467 case DW_AT_address_class
: return "DW_AT_address_class";
8468 case DW_AT_artificial
: return "DW_AT_artificial";
8469 case DW_AT_base_types
: return "DW_AT_base_types";
8470 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8471 case DW_AT_count
: return "DW_AT_count";
8472 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8473 case DW_AT_decl_column
: return "DW_AT_decl_column";
8474 case DW_AT_decl_file
: return "DW_AT_decl_file";
8475 case DW_AT_decl_line
: return "DW_AT_decl_line";
8476 case DW_AT_declaration
: return "DW_AT_declaration";
8477 case DW_AT_discr_list
: return "DW_AT_discr_list";
8478 case DW_AT_encoding
: return "DW_AT_encoding";
8479 case DW_AT_external
: return "DW_AT_external";
8480 case DW_AT_frame_base
: return "DW_AT_frame_base";
8481 case DW_AT_friend
: return "DW_AT_friend";
8482 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8483 case DW_AT_macro_info
: return "DW_AT_macro_info";
8484 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8485 case DW_AT_priority
: return "DW_AT_priority";
8486 case DW_AT_segment
: return "DW_AT_segment";
8487 case DW_AT_specification
: return "DW_AT_specification";
8488 case DW_AT_static_link
: return "DW_AT_static_link";
8489 case DW_AT_type
: return "DW_AT_type";
8490 case DW_AT_use_location
: return "DW_AT_use_location";
8491 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8492 case DW_AT_virtuality
: return "DW_AT_virtuality";
8493 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8494 /* DWARF 2.1 values. */
8495 case DW_AT_allocated
: return "DW_AT_allocated";
8496 case DW_AT_associated
: return "DW_AT_associated";
8497 case DW_AT_data_location
: return "DW_AT_data_location";
8498 case DW_AT_stride
: return "DW_AT_stride";
8499 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8500 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8501 case DW_AT_extension
: return "DW_AT_extension";
8502 case DW_AT_ranges
: return "DW_AT_ranges";
8503 case DW_AT_trampoline
: return "DW_AT_trampoline";
8504 case DW_AT_call_column
: return "DW_AT_call_column";
8505 case DW_AT_call_file
: return "DW_AT_call_file";
8506 case DW_AT_call_line
: return "DW_AT_call_line";
8507 /* SGI/MIPS extensions. */
8508 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8509 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8510 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8511 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8512 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8513 case DW_AT_MIPS_software_pipeline_depth
:
8514 return "DW_AT_MIPS_software_pipeline_depth";
8515 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8516 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8517 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8518 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8519 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8520 /* GNU extensions. */
8521 case DW_AT_sf_names
: return "DW_AT_sf_names";
8522 case DW_AT_src_info
: return "DW_AT_src_info";
8523 case DW_AT_mac_info
: return "DW_AT_mac_info";
8524 case DW_AT_src_coords
: return "DW_AT_src_coords";
8525 case DW_AT_body_begin
: return "DW_AT_body_begin";
8526 case DW_AT_body_end
: return "DW_AT_body_end";
8527 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8528 /* UPC extension. */
8529 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8532 static char buffer
[100];
8534 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8541 static unsigned char *
8542 read_and_display_attr (unsigned long attribute
,
8544 unsigned char *data
,
8545 unsigned long cu_offset
,
8546 unsigned long pointer_size
,
8547 unsigned long offset_size
,
8549 debug_info
*debug_info_p
,
8553 printf (" %-18s:", get_AT_name (attribute
));
8554 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8555 pointer_size
, offset_size
,
8556 dwarf_version
, debug_info_p
,
8564 /* Process the contents of a .debug_info section. If do_loc is non-zero
8565 then we are scanning for location lists and we do not want to display
8566 anything to the user. */
8569 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8570 FILE *file
, int do_loc
)
8572 unsigned char *end
= start
+ section
->sh_size
;
8573 unsigned char *section_begin
;
8575 unsigned int num_units
= 0;
8577 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8578 && num_debug_info_entries
== 0)
8580 unsigned long length
;
8582 /* First scan the section to get the number of comp units. */
8583 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8586 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8587 will be the length. For a 64-bit DWARF section, it'll be
8588 the escape code 0xffffffff followed by an 8 byte length. */
8589 length
= byte_get (section_begin
, 4);
8591 if (length
== 0xffffffff)
8593 length
= byte_get (section_begin
+ 4, 8);
8594 section_begin
+= length
+ 12;
8597 section_begin
+= length
+ 4;
8602 error (_("No comp units in .debug_info section ?"));
8606 /* Then allocate an array to hold the information. */
8607 debug_information
= malloc (num_units
*
8608 sizeof (* debug_information
));
8609 if (debug_information
== NULL
)
8611 error (_("Not enough memory for a debug info array of %u entries"),
8619 printf (_("The section %s contains:\n\n"),
8620 SECTION_NAME (section
));
8622 load_debug_str (file
);
8623 load_debug_loc (file
);
8624 load_debug_range (file
);
8627 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8629 DWARF2_Internal_CompUnit compunit
;
8630 unsigned char *hdrptr
;
8631 unsigned char *cu_abbrev_offset_ptr
;
8632 unsigned char *tags
;
8634 unsigned long cu_offset
;
8636 int initial_length_size
;
8640 compunit
.cu_length
= byte_get (hdrptr
, 4);
8643 if (compunit
.cu_length
== 0xffffffff)
8645 compunit
.cu_length
= byte_get (hdrptr
, 8);
8648 initial_length_size
= 12;
8653 initial_length_size
= 4;
8656 compunit
.cu_version
= byte_get (hdrptr
, 2);
8659 cu_offset
= start
- section_begin
;
8660 start
+= compunit
.cu_length
+ initial_length_size
;
8662 if (elf_header
.e_type
== ET_REL
8663 && !debug_apply_rela_addends (file
, section
, offset_size
,
8664 section_begin
, hdrptr
, start
))
8667 cu_abbrev_offset_ptr
= hdrptr
;
8668 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8669 hdrptr
+= offset_size
;
8671 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8673 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8674 && num_debug_info_entries
== 0)
8676 debug_information
[unit
].cu_offset
= cu_offset
;
8677 debug_information
[unit
].pointer_size
8678 = compunit
.cu_pointer_size
;
8679 debug_information
[unit
].base_address
= 0;
8680 debug_information
[unit
].loc_offsets
= NULL
;
8681 debug_information
[unit
].have_frame_base
= NULL
;
8682 debug_information
[unit
].max_loc_offsets
= 0;
8683 debug_information
[unit
].num_loc_offsets
= 0;
8684 debug_information
[unit
].range_lists
= NULL
;
8685 debug_information
[unit
].max_range_lists
= 0;
8686 debug_information
[unit
].num_range_lists
= 0;
8693 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8694 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8695 printf (_(" Version: %d\n"), compunit
.cu_version
);
8696 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8697 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8700 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8702 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8708 /* Read in the abbrevs used by this compilation unit. */
8710 Elf_Internal_Shdr
*sec
;
8711 unsigned char *begin
;
8713 /* Locate the .debug_abbrev section and process it. */
8714 sec
= find_section (".debug_abbrev");
8717 warn (_("Unable to locate .debug_abbrev section!\n"));
8721 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8722 _("debug_abbrev section data"));
8726 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8727 begin
+ sec
->sh_size
);
8733 while (tags
< start
)
8735 unsigned int bytes_read
;
8736 unsigned long abbrev_number
;
8737 abbrev_entry
*entry
;
8740 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8743 /* A null DIE marks the end of a list of children. */
8744 if (abbrev_number
== 0)
8750 /* Scan through the abbreviation list until we reach the
8752 for (entry
= first_abbrev
;
8753 entry
&& entry
->entry
!= abbrev_number
;
8754 entry
= entry
->next
)
8759 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8765 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8767 (unsigned long) (tags
- section_begin
8770 get_TAG_name (entry
->tag
));
8775 need_base_address
= 0;
8777 case DW_TAG_compile_unit
:
8778 need_base_address
= 1;
8780 case DW_TAG_entry_point
:
8781 case DW_TAG_inlined_subroutine
:
8782 case DW_TAG_subprogram
:
8783 need_base_address
= 0;
8784 /* Assuming that there is no DW_AT_frame_base. */
8785 have_frame_base
= 0;
8789 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8790 tags
= read_and_display_attr (attr
->attribute
,
8793 compunit
.cu_pointer_size
,
8795 compunit
.cu_version
,
8796 &debug_information
[unit
],
8799 if (entry
->children
)
8804 /* Set num_debug_info_entries here so that it can be used to check if
8805 we need to proecess .debug_loc and .debug_ranges sections. */
8806 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8807 && num_debug_info_entries
== 0)
8808 num_debug_info_entries
= num_units
;
8812 free_debug_range ();
8822 /* Retrieve the pointer size associated with the given compilation unit.
8823 Optionally the offset of this unit into the .debug_info section is
8824 also retutned. If there is no .debug_info section then an error
8825 message is issued and 0 is returned. If the requested comp unit has
8826 not been defined in the .debug_info section then a warning message
8827 is issued and the last know pointer size is returned. This message
8828 is only issued once per section dumped per file dumped. */
8831 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8832 const char * section_name
,
8833 unsigned long * offset_return
)
8835 unsigned long offset
= 0;
8837 if (num_debug_info_entries
== 0)
8838 error (_("%s section needs a populated .debug_info section\n"),
8841 else if (comp_unit
>= num_debug_info_entries
)
8843 if (!warned_about_missing_comp_units
)
8845 warn (_("%s section has more comp units than .debug_info section\n"),
8847 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
8849 warned_about_missing_comp_units
= TRUE
;
8854 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
8855 offset
= debug_information
[comp_unit
].cu_offset
;
8858 if (offset_return
!= NULL
)
8859 * offset_return
= offset
;
8861 return last_pointer_size
;
8864 /* Locate and scan the .debug_info section in the file and record the pointer
8865 sizes and offsets for the compilation units in it. Usually an executable
8866 will have just one pointer size, but this is not guaranteed, and so we try
8867 not to make any assumptions. Returns zero upon failure, or the number of
8868 compilation units upon success. */
8871 get_debug_info (FILE * file
)
8873 Elf_Internal_Shdr
* section
;
8874 unsigned char * start
;
8877 /* Reset the last pointer size so that we can issue correct error
8878 messages if we are displaying the contents of more than one section. */
8879 last_pointer_size
= 0;
8880 warned_about_missing_comp_units
= FALSE
;
8882 /* If we already have the information there is nothing else to do. */
8883 if (num_debug_info_entries
> 0)
8884 return num_debug_info_entries
;
8886 section
= find_section (".debug_info");
8887 if (section
== NULL
)
8890 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
8891 _("extracting information from .debug_info section"));
8895 ret
= process_debug_info (section
, start
, file
, 1);
8898 return ret
? num_debug_info_entries
: 0;
8902 display_debug_lines (Elf_Internal_Shdr
*section
,
8903 unsigned char *start
, FILE *file
)
8905 unsigned char *data
= start
;
8906 unsigned char *end
= start
+ section
->sh_size
;
8907 unsigned int comp_unit
= 0;
8909 printf (_("\nDump of debug contents of section %s:\n\n"),
8910 SECTION_NAME (section
));
8912 get_debug_info (file
);
8916 DWARF2_Internal_LineInfo info
;
8917 unsigned char *standard_opcodes
;
8918 unsigned char *end_of_sequence
;
8919 unsigned char *hdrptr
;
8920 unsigned int pointer_size
;
8921 int initial_length_size
;
8927 /* Check the length of the block. */
8928 info
.li_length
= byte_get (hdrptr
, 4);
8931 if (info
.li_length
== 0xffffffff)
8933 /* This section is 64-bit DWARF 3. */
8934 info
.li_length
= byte_get (hdrptr
, 8);
8937 initial_length_size
= 12;
8942 initial_length_size
= 4;
8945 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
8948 (_("The line info appears to be corrupt - the section is too small\n"));
8952 /* Check its version number. */
8953 info
.li_version
= byte_get (hdrptr
, 2);
8955 if (info
.li_version
!= 2 && info
.li_version
!= 3)
8957 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
8961 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
8962 hdrptr
+= offset_size
;
8963 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
8965 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
8967 info
.li_line_base
= byte_get (hdrptr
, 1);
8969 info
.li_line_range
= byte_get (hdrptr
, 1);
8971 info
.li_opcode_base
= byte_get (hdrptr
, 1);
8974 /* Sign extend the line base field. */
8975 info
.li_line_base
<<= 24;
8976 info
.li_line_base
>>= 24;
8978 /* Get the pointer size from the comp unit associated
8979 with this block of line number information. */
8980 pointer_size
= get_pointer_size_and_offset_of_comp_unit
8981 (comp_unit
, ".debug_lines", NULL
);
8984 printf (_(" Length: %ld\n"), info
.li_length
);
8985 printf (_(" DWARF Version: %d\n"), info
.li_version
);
8986 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
8987 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
8988 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
8989 printf (_(" Line Base: %d\n"), info
.li_line_base
);
8990 printf (_(" Line Range: %d\n"), info
.li_line_range
);
8991 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
8992 printf (_(" (Pointer size: %u)\n"), pointer_size
);
8994 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
8996 reset_state_machine (info
.li_default_is_stmt
);
8998 /* Display the contents of the Opcodes table. */
8999 standard_opcodes
= hdrptr
;
9001 printf (_("\n Opcodes:\n"));
9003 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9004 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9006 /* Display the contents of the Directory table. */
9007 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9010 printf (_("\n The Directory Table is empty.\n"));
9013 printf (_("\n The Directory Table:\n"));
9017 printf (_(" %s\n"), data
);
9019 data
+= strlen ((char *) data
) + 1;
9023 /* Skip the NUL at the end of the table. */
9026 /* Display the contents of the File Name table. */
9028 printf (_("\n The File Name Table is empty.\n"));
9031 printf (_("\n The File Name Table:\n"));
9032 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9036 unsigned char *name
;
9037 unsigned int bytes_read
;
9039 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9042 data
+= strlen ((char *) data
) + 1;
9044 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9046 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9048 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9050 printf (_("%s\n"), name
);
9054 /* Skip the NUL at the end of the table. */
9057 /* Now display the statements. */
9058 printf (_("\n Line Number Statements:\n"));
9060 while (data
< end_of_sequence
)
9062 unsigned char op_code
;
9064 unsigned int bytes_read
;
9068 if (op_code
>= info
.li_opcode_base
)
9070 op_code
-= info
.li_opcode_base
;
9071 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9072 state_machine_regs
.address
+= adv
;
9073 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9074 op_code
, adv
, state_machine_regs
.address
);
9075 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9076 state_machine_regs
.line
+= adv
;
9077 printf (_(" and Line by %d to %d\n"),
9078 adv
, state_machine_regs
.line
);
9080 else switch (op_code
)
9082 case DW_LNS_extended_op
:
9083 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9088 printf (_(" Copy\n"));
9091 case DW_LNS_advance_pc
:
9092 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9094 state_machine_regs
.address
+= adv
;
9095 printf (_(" Advance PC by %d to %lx\n"), adv
,
9096 state_machine_regs
.address
);
9099 case DW_LNS_advance_line
:
9100 adv
= read_leb128 (data
, & bytes_read
, 1);
9102 state_machine_regs
.line
+= adv
;
9103 printf (_(" Advance Line by %d to %d\n"), adv
,
9104 state_machine_regs
.line
);
9107 case DW_LNS_set_file
:
9108 adv
= read_leb128 (data
, & bytes_read
, 0);
9110 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9112 state_machine_regs
.file
= adv
;
9115 case DW_LNS_set_column
:
9116 adv
= read_leb128 (data
, & bytes_read
, 0);
9118 printf (_(" Set column to %d\n"), adv
);
9119 state_machine_regs
.column
= adv
;
9122 case DW_LNS_negate_stmt
:
9123 adv
= state_machine_regs
.is_stmt
;
9125 printf (_(" Set is_stmt to %d\n"), adv
);
9126 state_machine_regs
.is_stmt
= adv
;
9129 case DW_LNS_set_basic_block
:
9130 printf (_(" Set basic block\n"));
9131 state_machine_regs
.basic_block
= 1;
9134 case DW_LNS_const_add_pc
:
9135 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9136 * info
.li_min_insn_length
);
9137 state_machine_regs
.address
+= adv
;
9138 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9139 state_machine_regs
.address
);
9142 case DW_LNS_fixed_advance_pc
:
9143 adv
= byte_get (data
, 2);
9145 state_machine_regs
.address
+= adv
;
9146 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9147 adv
, state_machine_regs
.address
);
9150 case DW_LNS_set_prologue_end
:
9151 printf (_(" Set prologue_end to true\n"));
9154 case DW_LNS_set_epilogue_begin
:
9155 printf (_(" Set epilogue_begin to true\n"));
9158 case DW_LNS_set_isa
:
9159 adv
= read_leb128 (data
, & bytes_read
, 0);
9161 printf (_(" Set ISA to %d\n"), adv
);
9165 printf (_(" Unknown opcode %d with operands: "), op_code
);
9167 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9169 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9170 i
== 1 ? "" : ", ");
9184 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9185 unsigned char *start
,
9186 FILE *file ATTRIBUTE_UNUSED
)
9188 DWARF2_Internal_PubNames pubnames
;
9191 end
= start
+ section
->sh_size
;
9193 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9197 unsigned char *data
;
9198 unsigned long offset
;
9199 int offset_size
, initial_length_size
;
9203 pubnames
.pn_length
= byte_get (data
, 4);
9205 if (pubnames
.pn_length
== 0xffffffff)
9207 pubnames
.pn_length
= byte_get (data
, 8);
9210 initial_length_size
= 12;
9215 initial_length_size
= 4;
9218 pubnames
.pn_version
= byte_get (data
, 2);
9220 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9221 data
+= offset_size
;
9222 pubnames
.pn_size
= byte_get (data
, offset_size
);
9223 data
+= offset_size
;
9225 start
+= pubnames
.pn_length
+ initial_length_size
;
9227 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9229 static int warned
= 0;
9233 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9240 printf (_(" Length: %ld\n"),
9241 pubnames
.pn_length
);
9242 printf (_(" Version: %d\n"),
9243 pubnames
.pn_version
);
9244 printf (_(" Offset into .debug_info section: %ld\n"),
9245 pubnames
.pn_offset
);
9246 printf (_(" Size of area in .debug_info section: %ld\n"),
9249 printf (_("\n Offset\tName\n"));
9253 offset
= byte_get (data
, offset_size
);
9257 data
+= offset_size
;
9258 printf (" %-6ld\t\t%s\n", offset
, data
);
9259 data
+= strlen ((char *) data
) + 1;
9262 while (offset
!= 0);
9270 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9271 unsigned char *start
,
9272 FILE *file ATTRIBUTE_UNUSED
)
9274 unsigned char *end
= start
+ section
->sh_size
;
9275 unsigned char *curr
= start
;
9276 unsigned int bytes_read
;
9277 enum dwarf_macinfo_record_type op
;
9279 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9283 unsigned int lineno
;
9291 case DW_MACINFO_start_file
:
9293 unsigned int filenum
;
9295 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9297 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9300 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9305 case DW_MACINFO_end_file
:
9306 printf (_(" DW_MACINFO_end_file\n"));
9309 case DW_MACINFO_define
:
9310 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9312 string
= (char *) curr
;
9313 curr
+= strlen (string
) + 1;
9314 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9318 case DW_MACINFO_undef
:
9319 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9321 string
= (char *) curr
;
9322 curr
+= strlen (string
) + 1;
9323 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9327 case DW_MACINFO_vendor_ext
:
9329 unsigned int constant
;
9331 constant
= read_leb128 (curr
, & bytes_read
, 0);
9333 string
= (char *) curr
;
9334 curr
+= strlen (string
) + 1;
9335 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9347 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9348 unsigned char *start
,
9349 FILE *file ATTRIBUTE_UNUSED
)
9351 abbrev_entry
*entry
;
9352 unsigned char *end
= start
+ section
->sh_size
;
9354 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9358 start
= process_abbrev_section (start
, end
);
9360 if (first_abbrev
== NULL
)
9363 printf (_(" Number TAG\n"));
9365 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9369 printf (_(" %ld %s [%s]\n"),
9371 get_TAG_name (entry
->tag
),
9372 entry
->children
? _("has children") : _("no children"));
9374 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9375 printf (_(" %-18s %s\n"),
9376 get_AT_name (attr
->attribute
),
9377 get_FORM_name (attr
->form
));
9390 display_debug_loc (Elf_Internal_Shdr
*section
,
9391 unsigned char *start
, FILE *file
)
9393 unsigned char *section_end
;
9394 unsigned long bytes
;
9395 unsigned char *section_begin
= start
;
9396 unsigned int num_loc_list
= 0;
9397 unsigned long last_offset
= 0;
9398 unsigned int first
= 0;
9401 int seen_first_offset
= 0;
9402 int use_debug_info
= 1;
9403 unsigned char *next
;
9405 bytes
= section
->sh_size
;
9406 section_end
= start
+ bytes
;
9410 printf (_("\nThe .debug_loc section is empty.\n"));
9414 get_debug_info (file
);
9416 /* Check the order of location list in .debug_info section. If
9417 offsets of location lists are in the ascending order, we can
9418 use `debug_information' directly. */
9419 for (i
= 0; i
< num_debug_info_entries
; i
++)
9423 num
= debug_information
[i
].num_loc_offsets
;
9424 num_loc_list
+= num
;
9426 /* Check if we can use `debug_information' directly. */
9427 if (use_debug_info
&& num
!= 0)
9429 if (!seen_first_offset
)
9431 /* This is the first location list. */
9432 last_offset
= debug_information
[i
].loc_offsets
[0];
9434 seen_first_offset
= 1;
9440 for (; j
< num
; j
++)
9443 debug_information
[i
].loc_offsets
[j
])
9448 last_offset
= debug_information
[i
].loc_offsets
[j
];
9453 if (!use_debug_info
)
9454 /* FIXME: Should we handle this case? */
9455 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9457 if (!seen_first_offset
)
9458 error (_("No location lists in .debug_info section!\n"));
9460 if (debug_information
[first
].loc_offsets
[0] != 0)
9461 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9462 debug_information
[first
].loc_offsets
[0]);
9464 printf (_("Contents of the .debug_loc section:\n\n"));
9465 printf (_(" Offset Begin End Expression\n"));
9467 seen_first_offset
= 0;
9468 for (i
= first
; i
< num_debug_info_entries
; i
++)
9470 unsigned long begin
;
9472 unsigned short length
;
9473 unsigned long offset
;
9474 unsigned int pointer_size
;
9475 unsigned long cu_offset
;
9476 unsigned long base_address
;
9477 int need_frame_base
;
9480 pointer_size
= debug_information
[i
].pointer_size
;
9481 cu_offset
= debug_information
[i
].cu_offset
;
9483 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9485 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9486 offset
= debug_information
[i
].loc_offsets
[j
];
9487 next
= section_begin
+ offset
;
9488 base_address
= debug_information
[i
].base_address
;
9490 if (!seen_first_offset
)
9491 seen_first_offset
= 1;
9495 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9496 start
- section_begin
, next
- section_begin
);
9497 else if (start
> next
)
9498 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9499 start
- section_begin
, next
- section_begin
);
9505 begin
= byte_get (start
, pointer_size
);
9506 start
+= pointer_size
;
9507 end
= byte_get (start
, pointer_size
);
9508 start
+= pointer_size
;
9510 if (begin
== 0 && end
== 0)
9512 printf (_(" %8.8lx <End of list>\n"), offset
);
9516 /* Check base address specifiers. */
9517 if (begin
== -1UL && end
!= -1UL)
9520 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9521 offset
, begin
, end
);
9525 length
= byte_get (start
, 2);
9528 printf (" %8.8lx %8.8lx %8.8lx (",
9529 offset
, begin
+ base_address
, end
+ base_address
);
9530 need_frame_base
= decode_location_expression (start
,
9536 if (need_frame_base
&& !has_frame_base
)
9537 printf (_(" [without DW_AT_frame_base]"));
9540 fputs (_(" (start == end)"), stdout
);
9541 else if (begin
> end
)
9542 fputs (_(" (start > end)"), stdout
);
9554 display_debug_str (Elf_Internal_Shdr
*section
,
9555 unsigned char *start
,
9556 FILE *file ATTRIBUTE_UNUSED
)
9558 unsigned long bytes
;
9561 addr
= section
->sh_addr
;
9562 bytes
= section
->sh_size
;
9566 printf (_("\nThe .debug_str section is empty.\n"));
9570 printf (_("Contents of the .debug_str section:\n\n"));
9578 lbytes
= (bytes
> 16 ? 16 : bytes
);
9580 printf (" 0x%8.8lx ", (unsigned long) addr
);
9582 for (j
= 0; j
< 16; j
++)
9585 printf ("%2.2x", start
[j
]);
9593 for (j
= 0; j
< lbytes
; j
++)
9596 if (k
>= ' ' && k
< 0x80)
9616 display_debug_info (Elf_Internal_Shdr
* section
,
9617 unsigned char * start
, FILE * file
)
9619 return process_debug_info (section
, start
, file
, 0);
9624 display_debug_aranges (Elf_Internal_Shdr
*section
,
9625 unsigned char *start
,
9626 FILE *file ATTRIBUTE_UNUSED
)
9628 unsigned char *end
= start
+ section
->sh_size
;
9630 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9634 unsigned char *hdrptr
;
9635 DWARF2_Internal_ARange arange
;
9636 unsigned char *ranges
;
9637 unsigned long length
;
9638 unsigned long address
;
9641 int initial_length_size
;
9645 arange
.ar_length
= byte_get (hdrptr
, 4);
9648 if (arange
.ar_length
== 0xffffffff)
9650 arange
.ar_length
= byte_get (hdrptr
, 8);
9653 initial_length_size
= 12;
9658 initial_length_size
= 4;
9661 arange
.ar_version
= byte_get (hdrptr
, 2);
9664 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9665 hdrptr
+= offset_size
;
9667 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9670 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9673 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9675 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9679 printf (_(" Length: %ld\n"), arange
.ar_length
);
9680 printf (_(" Version: %d\n"), arange
.ar_version
);
9681 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9682 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9683 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9685 printf (_("\n Address Length\n"));
9689 /* Must pad to an alignment boundary that is twice the pointer size. */
9690 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9692 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9696 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9698 ranges
+= arange
.ar_pointer_size
;
9700 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9702 ranges
+= arange
.ar_pointer_size
;
9704 /* A pair of zeros marks the end of the list. */
9705 if (address
== 0 && length
== 0)
9708 printf (" %8.8lx %lu\n", address
, length
);
9711 start
+= arange
.ar_length
+ initial_length_size
;
9720 display_debug_ranges (Elf_Internal_Shdr
*section
,
9721 unsigned char *start
,
9722 FILE *file ATTRIBUTE_UNUSED
)
9724 unsigned char *section_end
;
9725 unsigned long bytes
;
9726 unsigned char *section_begin
= start
;
9727 unsigned int num_range_list
= 0;
9728 unsigned long last_offset
= 0;
9729 unsigned int first
= 0;
9732 int seen_first_offset
= 0;
9733 int use_debug_info
= 1;
9734 unsigned char *next
;
9736 bytes
= section
->sh_size
;
9737 section_end
= start
+ bytes
;
9741 printf (_("\nThe .debug_ranges section is empty.\n"));
9745 get_debug_info (file
);
9747 /* Check the order of range list in .debug_info section. If
9748 offsets of range lists are in the ascending order, we can
9749 use `debug_information' directly. */
9750 for (i
= 0; i
< num_debug_info_entries
; i
++)
9754 num
= debug_information
[i
].num_range_lists
;
9755 num_range_list
+= num
;
9757 /* Check if we can use `debug_information' directly. */
9758 if (use_debug_info
&& num
!= 0)
9760 if (!seen_first_offset
)
9762 /* This is the first range list. */
9763 last_offset
= debug_information
[i
].range_lists
[0];
9765 seen_first_offset
= 1;
9771 for (; j
< num
; j
++)
9774 debug_information
[i
].range_lists
[j
])
9779 last_offset
= debug_information
[i
].range_lists
[j
];
9784 if (!use_debug_info
)
9785 /* FIXME: Should we handle this case? */
9786 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9788 if (!seen_first_offset
)
9789 error (_("No range lists in .debug_info section!\n"));
9791 if (debug_information
[first
].range_lists
[0] != 0)
9792 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9793 debug_information
[first
].range_lists
[0]);
9795 printf (_("Contents of the .debug_ranges section:\n\n"));
9796 printf (_(" Offset Begin End\n"));
9798 seen_first_offset
= 0;
9799 for (i
= first
; i
< num_debug_info_entries
; i
++)
9801 unsigned long begin
;
9803 unsigned long offset
;
9804 unsigned int pointer_size
;
9805 unsigned long base_address
;
9807 pointer_size
= debug_information
[i
].pointer_size
;
9809 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9811 offset
= debug_information
[i
].range_lists
[j
];
9812 next
= section_begin
+ offset
;
9813 base_address
= debug_information
[i
].base_address
;
9815 if (!seen_first_offset
)
9816 seen_first_offset
= 1;
9820 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9821 start
- section_begin
, next
- section_begin
);
9822 else if (start
> next
)
9823 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9824 start
- section_begin
, next
- section_begin
);
9830 begin
= byte_get (start
, pointer_size
);
9831 start
+= pointer_size
;
9832 end
= byte_get (start
, pointer_size
);
9833 start
+= pointer_size
;
9835 if (begin
== 0 && end
== 0)
9837 printf (_(" %8.8lx <End of list>\n"), offset
);
9841 /* Check base address specifiers. */
9842 if (begin
== -1UL && end
!= -1UL)
9845 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9846 offset
, begin
, end
);
9850 printf (" %8.8lx %8.8lx %8.8lx",
9851 offset
, begin
+ base_address
, end
+ base_address
);
9854 fputs (_(" (start == end)"), stdout
);
9855 else if (begin
> end
)
9856 fputs (_(" (start > end)"), stdout
);
9866 typedef struct Frame_Chunk
9868 struct Frame_Chunk
*next
;
9869 unsigned char *chunk_start
;
9871 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9872 short int *col_type
;
9875 unsigned int code_factor
;
9877 unsigned long pc_begin
;
9878 unsigned long pc_range
;
9882 unsigned char fde_encoding
;
9883 unsigned char cfa_exp
;
9887 /* A marker for a col_type that means this column was never referenced
9888 in the frame info. */
9889 #define DW_CFA_unreferenced (-1)
9892 frame_need_space (Frame_Chunk
*fc
, int reg
)
9894 int prev
= fc
->ncols
;
9896 if (reg
< fc
->ncols
)
9899 fc
->ncols
= reg
+ 1;
9900 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
9901 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
9903 while (prev
< fc
->ncols
)
9905 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
9906 fc
->col_offset
[prev
] = 0;
9912 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
9917 if (*max_regs
< fc
->ncols
)
9918 *max_regs
= fc
->ncols
;
9920 if (*need_col_headers
)
9922 *need_col_headers
= 0;
9924 printf (" LOC CFA ");
9926 for (r
= 0; r
< *max_regs
; r
++)
9927 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9932 printf ("r%-4d", r
);
9938 printf ("%08lx ", fc
->pc_begin
);
9940 strcpy (tmp
, "exp");
9942 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9943 printf ("%-8s ", tmp
);
9945 for (r
= 0; r
< fc
->ncols
; r
++)
9947 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9949 switch (fc
->col_type
[r
])
9951 case DW_CFA_undefined
:
9954 case DW_CFA_same_value
:
9958 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9960 case DW_CFA_register
:
9961 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9963 case DW_CFA_expression
:
9964 strcpy (tmp
, "exp");
9967 strcpy (tmp
, "n/a");
9970 printf ("%-5s", tmp
);
9977 size_of_encoded_value (int encoding
)
9979 switch (encoding
& 0x7)
9982 case 0: return eh_addr_size
;
9990 get_encoded_value (unsigned char *data
, int encoding
)
9992 int size
= size_of_encoded_value (encoding
);
9993 if (encoding
& DW_EH_PE_signed
)
9994 return byte_get_signed (data
, size
);
9996 return byte_get (data
, size
);
9999 #define GET(N) byte_get (start, N); start += N
10000 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10001 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10004 display_debug_frames (Elf_Internal_Shdr
*section
,
10005 unsigned char *start
,
10006 FILE *file ATTRIBUTE_UNUSED
)
10008 unsigned char *end
= start
+ section
->sh_size
;
10009 unsigned char *section_start
= start
;
10010 Frame_Chunk
*chunks
= 0;
10011 Frame_Chunk
*remembered_state
= 0;
10013 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10014 unsigned int length_return
;
10017 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10019 while (start
< end
)
10021 unsigned char *saved_start
;
10022 unsigned char *block_end
;
10023 unsigned long length
;
10024 unsigned long cie_id
;
10027 int need_col_headers
= 1;
10028 unsigned char *augmentation_data
= NULL
;
10029 unsigned long augmentation_data_len
= 0;
10030 int encoded_ptr_size
= eh_addr_size
;
10032 int initial_length_size
;
10034 saved_start
= start
;
10035 length
= byte_get (start
, 4); start
+= 4;
10039 printf ("\n%08lx ZERO terminator\n\n",
10040 (unsigned long)(saved_start
- section_start
));
10044 if (length
== 0xffffffff)
10046 length
= byte_get (start
, 8);
10049 initial_length_size
= 12;
10054 initial_length_size
= 4;
10057 block_end
= saved_start
+ length
+ initial_length_size
;
10058 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10060 if (elf_header
.e_type
== ET_REL
10061 && !debug_apply_rela_addends (file
, section
, offset_size
,
10062 section_start
, start
, block_end
))
10065 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10069 fc
= xmalloc (sizeof (Frame_Chunk
));
10070 memset (fc
, 0, sizeof (Frame_Chunk
));
10074 fc
->chunk_start
= saved_start
;
10076 fc
->col_type
= xmalloc (sizeof (short int));
10077 fc
->col_offset
= xmalloc (sizeof (int));
10078 frame_need_space (fc
, max_regs
-1);
10080 version
= *start
++;
10082 fc
->augmentation
= (char *) start
;
10083 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10085 if (fc
->augmentation
[0] == 'z')
10087 fc
->code_factor
= LEB ();
10088 fc
->data_factor
= SLEB ();
10097 augmentation_data_len
= LEB ();
10098 augmentation_data
= start
;
10099 start
+= augmentation_data_len
;
10101 else if (streq (fc
->augmentation
, "eh"))
10103 start
+= eh_addr_size
;
10104 fc
->code_factor
= LEB ();
10105 fc
->data_factor
= SLEB ();
10117 fc
->code_factor
= LEB ();
10118 fc
->data_factor
= SLEB ();
10130 if (do_debug_frames_interp
)
10131 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10132 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10133 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10137 printf ("\n%08lx %08lx %08lx CIE\n",
10138 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10139 printf (" Version: %d\n", version
);
10140 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10141 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10142 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10143 printf (" Return address column: %d\n", fc
->ra
);
10145 if (augmentation_data_len
)
10148 printf (" Augmentation data: ");
10149 for (i
= 0; i
< augmentation_data_len
; ++i
)
10150 printf (" %02x", augmentation_data
[i
]);
10156 if (augmentation_data_len
)
10158 unsigned char *p
, *q
;
10159 p
= (unsigned char *) fc
->augmentation
+ 1;
10160 q
= augmentation_data
;
10166 else if (*p
== 'P')
10167 q
+= 1 + size_of_encoded_value (*q
);
10168 else if (*p
== 'R')
10169 fc
->fde_encoding
= *q
++;
10175 if (fc
->fde_encoding
)
10176 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10179 frame_need_space (fc
, fc
->ra
);
10183 unsigned char *look_for
;
10184 static Frame_Chunk fde_fc
;
10187 memset (fc
, 0, sizeof (Frame_Chunk
));
10189 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10191 for (cie
= chunks
; cie
; cie
= cie
->next
)
10192 if (cie
->chunk_start
== look_for
)
10197 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10198 cie_id
, saved_start
);
10201 fc
->col_type
= xmalloc (sizeof (short int));
10202 fc
->col_offset
= xmalloc (sizeof (int));
10203 frame_need_space (fc
, max_regs
- 1);
10205 fc
->augmentation
= "";
10206 fc
->fde_encoding
= 0;
10210 fc
->ncols
= cie
->ncols
;
10211 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10212 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10213 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10214 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10215 fc
->augmentation
= cie
->augmentation
;
10216 fc
->code_factor
= cie
->code_factor
;
10217 fc
->data_factor
= cie
->data_factor
;
10218 fc
->cfa_reg
= cie
->cfa_reg
;
10219 fc
->cfa_offset
= cie
->cfa_offset
;
10221 frame_need_space (fc
, max_regs
-1);
10222 fc
->fde_encoding
= cie
->fde_encoding
;
10225 if (fc
->fde_encoding
)
10226 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10228 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10229 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10230 /* Don't adjust for ET_REL since there's invariably a pcrel
10231 reloc here, which we haven't applied. */
10232 && elf_header
.e_type
!= ET_REL
)
10233 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10234 start
+= encoded_ptr_size
;
10235 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10236 start
+= encoded_ptr_size
;
10238 if (cie
->augmentation
[0] == 'z')
10240 augmentation_data_len
= LEB ();
10241 augmentation_data
= start
;
10242 start
+= augmentation_data_len
;
10245 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10246 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10247 (unsigned long)(cie
->chunk_start
- section_start
),
10248 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10249 if (! do_debug_frames_interp
&& augmentation_data_len
)
10253 printf (" Augmentation data: ");
10254 for (i
= 0; i
< augmentation_data_len
; ++i
)
10255 printf (" %02x", augmentation_data
[i
]);
10261 /* At this point, fc is the current chunk, cie (if any) is set, and
10262 we're about to interpret instructions for the chunk. */
10263 /* ??? At present we need to do this always, since this sizes the
10264 fc->col_type and fc->col_offset arrays, which we write into always.
10265 We should probably split the interpreted and non-interpreted bits
10266 into two different routines, since there's so much that doesn't
10267 really overlap between them. */
10268 if (1 || do_debug_frames_interp
)
10270 /* Start by making a pass over the chunk, allocating storage
10271 and taking note of what registers are used. */
10272 unsigned char *tmp
= start
;
10274 while (start
< block_end
)
10277 unsigned long reg
, tmp
;
10284 /* Warning: if you add any more cases to this switch, be
10285 sure to add them to the corresponding switch below. */
10288 case DW_CFA_advance_loc
:
10290 case DW_CFA_offset
:
10292 frame_need_space (fc
, opa
);
10293 fc
->col_type
[opa
] = DW_CFA_undefined
;
10295 case DW_CFA_restore
:
10296 frame_need_space (fc
, opa
);
10297 fc
->col_type
[opa
] = DW_CFA_undefined
;
10299 case DW_CFA_set_loc
:
10300 start
+= encoded_ptr_size
;
10302 case DW_CFA_advance_loc1
:
10305 case DW_CFA_advance_loc2
:
10308 case DW_CFA_advance_loc4
:
10311 case DW_CFA_offset_extended
:
10312 reg
= LEB (); LEB ();
10313 frame_need_space (fc
, reg
);
10314 fc
->col_type
[reg
] = DW_CFA_undefined
;
10316 case DW_CFA_restore_extended
:
10318 frame_need_space (fc
, reg
);
10319 fc
->col_type
[reg
] = DW_CFA_undefined
;
10321 case DW_CFA_undefined
:
10323 frame_need_space (fc
, reg
);
10324 fc
->col_type
[reg
] = DW_CFA_undefined
;
10326 case DW_CFA_same_value
:
10328 frame_need_space (fc
, reg
);
10329 fc
->col_type
[reg
] = DW_CFA_undefined
;
10331 case DW_CFA_register
:
10332 reg
= LEB (); LEB ();
10333 frame_need_space (fc
, reg
);
10334 fc
->col_type
[reg
] = DW_CFA_undefined
;
10336 case DW_CFA_def_cfa
:
10339 case DW_CFA_def_cfa_register
:
10342 case DW_CFA_def_cfa_offset
:
10345 case DW_CFA_def_cfa_expression
:
10349 case DW_CFA_expression
:
10353 frame_need_space (fc
, reg
);
10354 fc
->col_type
[reg
] = DW_CFA_undefined
;
10356 case DW_CFA_offset_extended_sf
:
10357 reg
= LEB (); SLEB ();
10358 frame_need_space (fc
, reg
);
10359 fc
->col_type
[reg
] = DW_CFA_undefined
;
10361 case DW_CFA_def_cfa_sf
:
10364 case DW_CFA_def_cfa_offset_sf
:
10367 case DW_CFA_MIPS_advance_loc8
:
10370 case DW_CFA_GNU_args_size
:
10373 case DW_CFA_GNU_negative_offset_extended
:
10374 reg
= LEB (); LEB ();
10375 frame_need_space (fc
, reg
);
10376 fc
->col_type
[reg
] = DW_CFA_undefined
;
10385 /* Now we know what registers are used, make a second pass over
10386 the chunk, this time actually printing out the info. */
10388 while (start
< block_end
)
10391 unsigned long ul
, reg
, roffs
;
10400 /* Warning: if you add any more cases to this switch, be
10401 sure to add them to the corresponding switch above. */
10404 case DW_CFA_advance_loc
:
10405 if (do_debug_frames_interp
)
10406 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10408 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10409 opa
* fc
->code_factor
,
10410 fc
->pc_begin
+ opa
* fc
->code_factor
);
10411 fc
->pc_begin
+= opa
* fc
->code_factor
;
10414 case DW_CFA_offset
:
10416 if (! do_debug_frames_interp
)
10417 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10418 opa
, roffs
* fc
->data_factor
);
10419 fc
->col_type
[opa
] = DW_CFA_offset
;
10420 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10423 case DW_CFA_restore
:
10424 if (! do_debug_frames_interp
)
10425 printf (" DW_CFA_restore: r%d\n", opa
);
10426 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10427 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10430 case DW_CFA_set_loc
:
10431 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10432 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10433 && elf_header
.e_type
!= ET_REL
)
10434 vma
+= section
->sh_addr
+ (start
- section_start
);
10435 start
+= encoded_ptr_size
;
10436 if (do_debug_frames_interp
)
10437 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10439 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10440 fc
->pc_begin
= vma
;
10443 case DW_CFA_advance_loc1
:
10444 ofs
= byte_get (start
, 1); start
+= 1;
10445 if (do_debug_frames_interp
)
10446 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10448 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10449 ofs
* fc
->code_factor
,
10450 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10451 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10454 case DW_CFA_advance_loc2
:
10455 ofs
= byte_get (start
, 2); start
+= 2;
10456 if (do_debug_frames_interp
)
10457 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10459 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10460 ofs
* fc
->code_factor
,
10461 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10462 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10465 case DW_CFA_advance_loc4
:
10466 ofs
= byte_get (start
, 4); start
+= 4;
10467 if (do_debug_frames_interp
)
10468 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10470 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10471 ofs
* fc
->code_factor
,
10472 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10473 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10476 case DW_CFA_offset_extended
:
10479 if (! do_debug_frames_interp
)
10480 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10481 reg
, roffs
* fc
->data_factor
);
10482 fc
->col_type
[reg
] = DW_CFA_offset
;
10483 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10486 case DW_CFA_restore_extended
:
10488 if (! do_debug_frames_interp
)
10489 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10490 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10491 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10494 case DW_CFA_undefined
:
10496 if (! do_debug_frames_interp
)
10497 printf (" DW_CFA_undefined: r%ld\n", reg
);
10498 fc
->col_type
[reg
] = DW_CFA_undefined
;
10499 fc
->col_offset
[reg
] = 0;
10502 case DW_CFA_same_value
:
10504 if (! do_debug_frames_interp
)
10505 printf (" DW_CFA_same_value: r%ld\n", reg
);
10506 fc
->col_type
[reg
] = DW_CFA_same_value
;
10507 fc
->col_offset
[reg
] = 0;
10510 case DW_CFA_register
:
10513 if (! do_debug_frames_interp
)
10514 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10515 fc
->col_type
[reg
] = DW_CFA_register
;
10516 fc
->col_offset
[reg
] = roffs
;
10519 case DW_CFA_remember_state
:
10520 if (! do_debug_frames_interp
)
10521 printf (" DW_CFA_remember_state\n");
10522 rs
= xmalloc (sizeof (Frame_Chunk
));
10523 rs
->ncols
= fc
->ncols
;
10524 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10525 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10526 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10527 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10528 rs
->next
= remembered_state
;
10529 remembered_state
= rs
;
10532 case DW_CFA_restore_state
:
10533 if (! do_debug_frames_interp
)
10534 printf (" DW_CFA_restore_state\n");
10535 rs
= remembered_state
;
10538 remembered_state
= rs
->next
;
10539 frame_need_space (fc
, rs
->ncols
-1);
10540 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10541 memcpy (fc
->col_offset
, rs
->col_offset
,
10542 rs
->ncols
* sizeof (int));
10543 free (rs
->col_type
);
10544 free (rs
->col_offset
);
10547 else if (do_debug_frames_interp
)
10548 printf ("Mismatched DW_CFA_restore_state\n");
10551 case DW_CFA_def_cfa
:
10552 fc
->cfa_reg
= LEB ();
10553 fc
->cfa_offset
= LEB ();
10555 if (! do_debug_frames_interp
)
10556 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10557 fc
->cfa_reg
, fc
->cfa_offset
);
10560 case DW_CFA_def_cfa_register
:
10561 fc
->cfa_reg
= LEB ();
10563 if (! do_debug_frames_interp
)
10564 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10567 case DW_CFA_def_cfa_offset
:
10568 fc
->cfa_offset
= LEB ();
10569 if (! do_debug_frames_interp
)
10570 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10574 if (! do_debug_frames_interp
)
10575 printf (" DW_CFA_nop\n");
10578 case DW_CFA_def_cfa_expression
:
10580 if (! do_debug_frames_interp
)
10582 printf (" DW_CFA_def_cfa_expression (");
10583 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10590 case DW_CFA_expression
:
10593 if (! do_debug_frames_interp
)
10595 printf (" DW_CFA_expression: r%ld (", reg
);
10596 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10599 fc
->col_type
[reg
] = DW_CFA_expression
;
10603 case DW_CFA_offset_extended_sf
:
10606 frame_need_space (fc
, reg
);
10607 if (! do_debug_frames_interp
)
10608 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10609 reg
, l
* fc
->data_factor
);
10610 fc
->col_type
[reg
] = DW_CFA_offset
;
10611 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10614 case DW_CFA_def_cfa_sf
:
10615 fc
->cfa_reg
= LEB ();
10616 fc
->cfa_offset
= SLEB ();
10618 if (! do_debug_frames_interp
)
10619 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10620 fc
->cfa_reg
, fc
->cfa_offset
);
10623 case DW_CFA_def_cfa_offset_sf
:
10624 fc
->cfa_offset
= SLEB ();
10625 if (! do_debug_frames_interp
)
10626 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10629 case DW_CFA_MIPS_advance_loc8
:
10630 ofs
= byte_get (start
, 8); start
+= 8;
10631 if (do_debug_frames_interp
)
10632 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10634 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10635 ofs
* fc
->code_factor
,
10636 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10637 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10640 case DW_CFA_GNU_window_save
:
10641 if (! do_debug_frames_interp
)
10642 printf (" DW_CFA_GNU_window_save\n");
10645 case DW_CFA_GNU_args_size
:
10647 if (! do_debug_frames_interp
)
10648 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10651 case DW_CFA_GNU_negative_offset_extended
:
10654 frame_need_space (fc
, reg
);
10655 if (! do_debug_frames_interp
)
10656 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10657 reg
, l
* fc
->data_factor
);
10658 fc
->col_type
[reg
] = DW_CFA_offset
;
10659 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10663 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10668 if (do_debug_frames_interp
)
10669 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10684 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10685 unsigned char *start ATTRIBUTE_UNUSED
,
10686 FILE *file ATTRIBUTE_UNUSED
)
10688 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10689 SECTION_NAME (section
));
10694 /* A structure containing the name of a debug section
10695 and a pointer to a function that can decode it. */
10698 const char *const name
;
10699 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10703 { ".debug_abbrev", display_debug_abbrev
},
10704 { ".debug_aranges", display_debug_aranges
},
10705 { ".debug_frame", display_debug_frames
},
10706 { ".debug_info", display_debug_info
},
10707 { ".debug_line", display_debug_lines
},
10708 { ".debug_pubnames", display_debug_pubnames
},
10709 { ".eh_frame", display_debug_frames
},
10710 { ".debug_macinfo", display_debug_macinfo
},
10711 { ".debug_str", display_debug_str
},
10712 { ".debug_loc", display_debug_loc
},
10713 { ".debug_pubtypes", display_debug_pubnames
},
10714 { ".debug_ranges", display_debug_ranges
},
10715 { ".debug_static_func", display_debug_not_supported
},
10716 { ".debug_static_vars", display_debug_not_supported
},
10717 { ".debug_types", display_debug_not_supported
},
10718 { ".debug_weaknames", display_debug_not_supported
}
10722 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10724 char *name
= SECTION_NAME (section
);
10725 bfd_size_type length
;
10729 length
= section
->sh_size
;
10732 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10736 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10737 name
= ".debug_info";
10739 /* See if we know how to display the contents of this section. */
10740 for (i
= NUM_ELEM (debug_displays
); i
--;)
10741 if (streq (debug_displays
[i
].name
, name
))
10743 unsigned char *start
;
10745 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10746 _("debug section data"));
10753 result
&= debug_displays
[i
].display (section
, start
, file
);
10756 /* If we loaded in the abbrev section
10757 at some point, we must release it here. */
10765 printf (_("Unrecognized debug section: %s\n"), name
);
10773 process_section_contents (FILE *file
)
10775 Elf_Internal_Shdr
*section
;
10781 for (i
= 0, section
= section_headers
;
10782 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10785 #ifdef SUPPORT_DISASSEMBLY
10786 if (dump_sects
[i
] & DISASS_DUMP
)
10787 disassemble_section (section
, file
);
10789 if (dump_sects
[i
] & HEX_DUMP
)
10790 dump_section (section
, file
);
10792 if (dump_sects
[i
] & DEBUG_DUMP
)
10793 display_debug_section (section
, file
);
10796 /* Check to see if the user requested a
10797 dump of a section that does not exist. */
10798 while (i
++ < num_dump_sects
)
10800 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10804 process_mips_fpe_exception (int mask
)
10809 if (mask
& OEX_FPU_INEX
)
10810 fputs ("INEX", stdout
), first
= 0;
10811 if (mask
& OEX_FPU_UFLO
)
10812 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10813 if (mask
& OEX_FPU_OFLO
)
10814 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10815 if (mask
& OEX_FPU_DIV0
)
10816 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10817 if (mask
& OEX_FPU_INVAL
)
10818 printf ("%sINVAL", first
? "" : "|");
10821 fputs ("0", stdout
);
10825 process_mips_specific (FILE *file
)
10827 Elf_Internal_Dyn
*entry
;
10828 size_t liblist_offset
= 0;
10829 size_t liblistno
= 0;
10830 size_t conflictsno
= 0;
10831 size_t options_offset
= 0;
10832 size_t conflicts_offset
= 0;
10834 /* We have a lot of special sections. Thanks SGI! */
10835 if (dynamic_section
== NULL
)
10836 /* No information available. */
10839 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10840 switch (entry
->d_tag
)
10842 case DT_MIPS_LIBLIST
:
10844 = offset_from_vma (file
, entry
->d_un
.d_val
,
10845 liblistno
* sizeof (Elf32_External_Lib
));
10847 case DT_MIPS_LIBLISTNO
:
10848 liblistno
= entry
->d_un
.d_val
;
10850 case DT_MIPS_OPTIONS
:
10851 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10853 case DT_MIPS_CONFLICT
:
10855 = offset_from_vma (file
, entry
->d_un
.d_val
,
10856 conflictsno
* sizeof (Elf32_External_Conflict
));
10858 case DT_MIPS_CONFLICTNO
:
10859 conflictsno
= entry
->d_un
.d_val
;
10865 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10867 Elf32_External_Lib
*elib
;
10870 elib
= get_data (NULL
, file
, liblist_offset
,
10871 liblistno
* sizeof (Elf32_External_Lib
),
10875 printf ("\nSection '.liblist' contains %lu entries:\n",
10876 (unsigned long) liblistno
);
10877 fputs (" Library Time Stamp Checksum Version Flags\n",
10880 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10887 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10888 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10889 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10890 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10891 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10893 tmp
= gmtime (&time
);
10894 snprintf (timebuf
, sizeof (timebuf
),
10895 "%04u-%02u-%02uT%02u:%02u:%02u",
10896 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10897 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10899 printf ("%3lu: ", (unsigned long) cnt
);
10900 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10901 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10903 printf ("<corrupt: %9ld>", liblist
.l_name
);
10904 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10905 liblist
.l_version
);
10907 if (liblist
.l_flags
== 0)
10911 static const struct
10918 { " EXACT_MATCH", LL_EXACT_MATCH
},
10919 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10920 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10921 { " EXPORTS", LL_EXPORTS
},
10922 { " DELAY_LOAD", LL_DELAY_LOAD
},
10923 { " DELTA", LL_DELTA
}
10925 int flags
= liblist
.l_flags
;
10929 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
10931 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10933 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10934 flags
^= l_flags_vals
[fcnt
].bit
;
10937 printf (" %#x", (unsigned int) flags
);
10947 if (options_offset
!= 0)
10949 Elf_External_Options
*eopt
;
10950 Elf_Internal_Shdr
*sect
= section_headers
;
10951 Elf_Internal_Options
*iopt
;
10952 Elf_Internal_Options
*option
;
10956 /* Find the section header so that we get the size. */
10957 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10960 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10964 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10967 error (_("Out of memory"));
10974 while (offset
< sect
->sh_size
)
10976 Elf_External_Options
*eoption
;
10978 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10980 option
->kind
= BYTE_GET (eoption
->kind
);
10981 option
->size
= BYTE_GET (eoption
->size
);
10982 option
->section
= BYTE_GET (eoption
->section
);
10983 option
->info
= BYTE_GET (eoption
->info
);
10985 offset
+= option
->size
;
10991 printf (_("\nSection '%s' contains %d entries:\n"),
10992 SECTION_NAME (sect
), cnt
);
11000 switch (option
->kind
)
11003 /* This shouldn't happen. */
11004 printf (" NULL %d %lx", option
->section
, option
->info
);
11007 printf (" REGINFO ");
11008 if (elf_header
.e_machine
== EM_MIPS
)
11011 Elf32_External_RegInfo
*ereg
;
11012 Elf32_RegInfo reginfo
;
11014 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11015 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11016 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11017 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11018 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11019 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11020 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11022 printf ("GPR %08lx GP 0x%lx\n",
11023 reginfo
.ri_gprmask
,
11024 (unsigned long) reginfo
.ri_gp_value
);
11025 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11026 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11027 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11032 Elf64_External_RegInfo
*ereg
;
11033 Elf64_Internal_RegInfo reginfo
;
11035 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11036 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11037 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11038 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11039 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11040 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11041 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11043 printf ("GPR %08lx GP 0x",
11044 reginfo
.ri_gprmask
);
11045 printf_vma (reginfo
.ri_gp_value
);
11048 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11049 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11050 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11054 case ODK_EXCEPTIONS
:
11055 fputs (" EXCEPTIONS fpe_min(", stdout
);
11056 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11057 fputs (") fpe_max(", stdout
);
11058 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11059 fputs (")", stdout
);
11061 if (option
->info
& OEX_PAGE0
)
11062 fputs (" PAGE0", stdout
);
11063 if (option
->info
& OEX_SMM
)
11064 fputs (" SMM", stdout
);
11065 if (option
->info
& OEX_FPDBUG
)
11066 fputs (" FPDBUG", stdout
);
11067 if (option
->info
& OEX_DISMISS
)
11068 fputs (" DISMISS", stdout
);
11071 fputs (" PAD ", stdout
);
11072 if (option
->info
& OPAD_PREFIX
)
11073 fputs (" PREFIX", stdout
);
11074 if (option
->info
& OPAD_POSTFIX
)
11075 fputs (" POSTFIX", stdout
);
11076 if (option
->info
& OPAD_SYMBOL
)
11077 fputs (" SYMBOL", stdout
);
11080 fputs (" HWPATCH ", stdout
);
11081 if (option
->info
& OHW_R4KEOP
)
11082 fputs (" R4KEOP", stdout
);
11083 if (option
->info
& OHW_R8KPFETCH
)
11084 fputs (" R8KPFETCH", stdout
);
11085 if (option
->info
& OHW_R5KEOP
)
11086 fputs (" R5KEOP", stdout
);
11087 if (option
->info
& OHW_R5KCVTL
)
11088 fputs (" R5KCVTL", stdout
);
11091 fputs (" FILL ", stdout
);
11092 /* XXX Print content of info word? */
11095 fputs (" TAGS ", stdout
);
11096 /* XXX Print content of info word? */
11099 fputs (" HWAND ", stdout
);
11100 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11101 fputs (" R4KEOP_CHECKED", stdout
);
11102 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11103 fputs (" R4KEOP_CLEAN", stdout
);
11106 fputs (" HWOR ", stdout
);
11107 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11108 fputs (" R4KEOP_CHECKED", stdout
);
11109 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11110 fputs (" R4KEOP_CLEAN", stdout
);
11113 printf (" GP_GROUP %#06lx self-contained %#06lx",
11114 option
->info
& OGP_GROUP
,
11115 (option
->info
& OGP_SELF
) >> 16);
11118 printf (" IDENT %#06lx self-contained %#06lx",
11119 option
->info
& OGP_GROUP
,
11120 (option
->info
& OGP_SELF
) >> 16);
11123 /* This shouldn't happen. */
11124 printf (" %3d ??? %d %lx",
11125 option
->kind
, option
->section
, option
->info
);
11129 len
= sizeof (*eopt
);
11130 while (len
< option
->size
)
11131 if (((char *) option
)[len
] >= ' '
11132 && ((char *) option
)[len
] < 0x7f)
11133 printf ("%c", ((char *) option
)[len
++]);
11135 printf ("\\%03o", ((char *) option
)[len
++]);
11137 fputs ("\n", stdout
);
11145 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11147 Elf32_Conflict
*iconf
;
11150 if (dynamic_symbols
== NULL
)
11152 error (_("conflict list found without a dynamic symbol table"));
11156 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11159 error (_("Out of memory"));
11165 Elf32_External_Conflict
*econf32
;
11167 econf32
= get_data (NULL
, file
, conflicts_offset
,
11168 conflictsno
* sizeof (*econf32
), _("conflict"));
11172 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11173 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11179 Elf64_External_Conflict
*econf64
;
11181 econf64
= get_data (NULL
, file
, conflicts_offset
,
11182 conflictsno
* sizeof (*econf64
), _("conflict"));
11186 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11187 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11192 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11193 (unsigned long) conflictsno
);
11194 puts (_(" Num: Index Value Name"));
11196 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11198 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11200 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11201 print_vma (psym
->st_value
, FULL_HEX
);
11203 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11204 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11206 printf ("<corrupt: %14ld>", psym
->st_name
);
11217 process_gnu_liblist (FILE *file
)
11219 Elf_Internal_Shdr
*section
, *string_sec
;
11220 Elf32_External_Lib
*elib
;
11228 for (i
= 0, section
= section_headers
;
11229 i
< elf_header
.e_shnum
;
11232 switch (section
->sh_type
)
11234 case SHT_GNU_LIBLIST
:
11235 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11240 string_sec
= SECTION_HEADER (section
->sh_link
);
11242 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11243 string_sec
->sh_size
, _("liblist string table"));
11246 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11252 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11253 SECTION_NAME (section
),
11254 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11256 puts (" Library Time Stamp Checksum Version Flags");
11258 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11266 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11267 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11268 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11269 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11270 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11272 tmp
= gmtime (&time
);
11273 snprintf (timebuf
, sizeof (timebuf
),
11274 "%04u-%02u-%02uT%02u:%02u:%02u",
11275 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11276 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11278 printf ("%3lu: ", (unsigned long) cnt
);
11280 printf ("%-20s", strtab
+ liblist
.l_name
);
11282 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11283 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11284 liblist
.l_version
, liblist
.l_flags
);
11294 static const char *
11295 get_note_type (unsigned e_type
)
11297 static char buff
[64];
11299 if (elf_header
.e_type
== ET_CORE
)
11303 return _("NT_AUXV (auxiliary vector)");
11305 return _("NT_PRSTATUS (prstatus structure)");
11307 return _("NT_FPREGSET (floating point registers)");
11309 return _("NT_PRPSINFO (prpsinfo structure)");
11310 case NT_TASKSTRUCT
:
11311 return _("NT_TASKSTRUCT (task structure)");
11313 return _("NT_PRXFPREG (user_xfpregs structure)");
11315 return _("NT_PSTATUS (pstatus structure)");
11317 return _("NT_FPREGS (floating point registers)");
11319 return _("NT_PSINFO (psinfo structure)");
11321 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11323 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11324 case NT_WIN32PSTATUS
:
11325 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11333 return _("NT_VERSION (version)");
11335 return _("NT_ARCH (architecture)");
11340 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11344 static const char *
11345 get_netbsd_elfcore_note_type (unsigned e_type
)
11347 static char buff
[64];
11349 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11351 /* NetBSD core "procinfo" structure. */
11352 return _("NetBSD procinfo structure");
11355 /* As of Jan 2002 there are no other machine-independent notes
11356 defined for NetBSD core files. If the note type is less
11357 than the start of the machine-dependent note types, we don't
11360 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11362 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11366 switch (elf_header
.e_machine
)
11368 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11369 and PT_GETFPREGS == mach+2. */
11374 case EM_SPARC32PLUS
:
11378 case NT_NETBSDCORE_FIRSTMACH
+0:
11379 return _("PT_GETREGS (reg structure)");
11380 case NT_NETBSDCORE_FIRSTMACH
+2:
11381 return _("PT_GETFPREGS (fpreg structure)");
11387 /* On all other arch's, PT_GETREGS == mach+1 and
11388 PT_GETFPREGS == mach+3. */
11392 case NT_NETBSDCORE_FIRSTMACH
+1:
11393 return _("PT_GETREGS (reg structure)");
11394 case NT_NETBSDCORE_FIRSTMACH
+3:
11395 return _("PT_GETFPREGS (fpreg structure)");
11401 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11402 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11406 /* Note that by the ELF standard, the name field is already null byte
11407 terminated, and namesz includes the terminating null byte.
11408 I.E. the value of namesz for the name "FSF" is 4.
11410 If the value of namesz is zero, there is no name present. */
11412 process_note (Elf_Internal_Note
*pnote
)
11416 if (pnote
->namesz
== 0)
11417 /* If there is no note name, then use the default set of
11418 note type strings. */
11419 nt
= get_note_type (pnote
->type
);
11421 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11422 /* NetBSD-specific core file notes. */
11423 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11426 /* Don't recognize this note name; just use the default set of
11427 note type strings. */
11428 nt
= get_note_type (pnote
->type
);
11430 printf (" %s\t\t0x%08lx\t%s\n",
11431 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11432 pnote
->descsz
, nt
);
11438 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11440 Elf_External_Note
*pnotes
;
11441 Elf_External_Note
*external
;
11447 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11453 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11454 (unsigned long) offset
, (unsigned long) length
);
11455 printf (_(" Owner\t\tData size\tDescription\n"));
11457 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11459 Elf_External_Note
*next
;
11460 Elf_Internal_Note inote
;
11463 inote
.type
= BYTE_GET (external
->type
);
11464 inote
.namesz
= BYTE_GET (external
->namesz
);
11465 inote
.namedata
= external
->name
;
11466 inote
.descsz
= BYTE_GET (external
->descsz
);
11467 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11468 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11470 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11472 if (((char *) next
) > (((char *) pnotes
) + length
))
11474 warn (_("corrupt note found at offset %x into core notes\n"),
11475 ((char *) external
) - ((char *) pnotes
));
11476 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11477 inote
.type
, inote
.namesz
, inote
.descsz
);
11483 /* Verify that name is null terminated. It appears that at least
11484 one version of Linux (RedHat 6.0) generates corefiles that don't
11485 comply with the ELF spec by failing to include the null byte in
11487 if (inote
.namedata
[inote
.namesz
] != '\0')
11489 temp
= malloc (inote
.namesz
+ 1);
11493 error (_("Out of memory\n"));
11498 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11499 temp
[inote
.namesz
] = 0;
11501 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11502 inote
.namedata
= temp
;
11505 res
&= process_note (& inote
);
11520 process_corefile_note_segments (FILE *file
)
11522 Elf_Internal_Phdr
*segment
;
11526 if (! get_program_headers (file
))
11529 for (i
= 0, segment
= program_headers
;
11530 i
< elf_header
.e_phnum
;
11533 if (segment
->p_type
== PT_NOTE
)
11534 res
&= process_corefile_note_segment (file
,
11535 (bfd_vma
) segment
->p_offset
,
11536 (bfd_vma
) segment
->p_filesz
);
11543 process_note_sections (FILE *file
)
11545 Elf_Internal_Shdr
*section
;
11549 for (i
= 0, section
= section_headers
;
11550 i
< elf_header
.e_shnum
;
11552 if (section
->sh_type
== SHT_NOTE
)
11553 res
&= process_corefile_note_segment (file
,
11554 (bfd_vma
) section
->sh_offset
,
11555 (bfd_vma
) section
->sh_size
);
11561 process_notes (FILE *file
)
11563 /* If we have not been asked to display the notes then do nothing. */
11567 if (elf_header
.e_type
!= ET_CORE
)
11568 return process_note_sections (file
);
11570 /* No program headers means no NOTE segment. */
11571 if (elf_header
.e_phnum
> 0)
11572 return process_corefile_note_segments (file
);
11574 printf (_("No note segments present in the core file.\n"));
11579 process_arch_specific (FILE *file
)
11584 switch (elf_header
.e_machine
)
11587 case EM_MIPS_RS3_LE
:
11588 return process_mips_specific (file
);
11597 get_file_header (FILE *file
)
11599 /* Read in the identity array. */
11600 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11603 /* Determine how to read the rest of the header. */
11604 switch (elf_header
.e_ident
[EI_DATA
])
11606 default: /* fall through */
11607 case ELFDATANONE
: /* fall through */
11609 byte_get
= byte_get_little_endian
;
11610 byte_put
= byte_put_little_endian
;
11613 byte_get
= byte_get_big_endian
;
11614 byte_put
= byte_put_big_endian
;
11618 /* For now we only support 32 bit and 64 bit ELF files. */
11619 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11621 /* Read in the rest of the header. */
11624 Elf32_External_Ehdr ehdr32
;
11626 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11629 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11630 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11631 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11632 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11633 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11634 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11635 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11636 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11637 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11638 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11639 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11640 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11641 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11645 Elf64_External_Ehdr ehdr64
;
11647 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11648 we will not be able to cope with the 64bit data found in
11649 64 ELF files. Detect this now and abort before we start
11650 overwriting things. */
11651 if (sizeof (bfd_vma
) < 8)
11653 error (_("This instance of readelf has been built without support for a\n\
11654 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11658 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11661 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11662 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11663 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11664 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11665 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11666 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11667 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11668 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11669 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11670 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11671 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11672 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11673 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11676 if (elf_header
.e_shoff
)
11678 /* There may be some extensions in the first section header. Don't
11679 bomb if we can't read it. */
11681 get_32bit_section_headers (file
, 1);
11683 get_64bit_section_headers (file
, 1);
11689 /* Process one ELF object file according to the command line options.
11690 This file may actually be stored in an archive. The file is
11691 positioned at the start of the ELF object. */
11694 process_object (char *file_name
, FILE *file
)
11698 if (! get_file_header (file
))
11700 error (_("%s: Failed to read file header\n"), file_name
);
11704 /* Initialise per file variables. */
11705 for (i
= NUM_ELEM (version_info
); i
--;)
11706 version_info
[i
] = 0;
11708 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11709 dynamic_info
[i
] = 0;
11711 /* Process the file. */
11713 printf (_("\nFile: %s\n"), file_name
);
11715 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11716 Note we do this even if cmdline_dump_sects is empty because we
11717 must make sure that the dump_sets array is zeroed out before each
11718 object file is processed. */
11719 if (num_dump_sects
> num_cmdline_dump_sects
)
11720 memset (dump_sects
, 0, num_dump_sects
);
11722 if (num_cmdline_dump_sects
> 0)
11724 if (num_dump_sects
== 0)
11725 /* A sneaky way of allocating the dump_sects array. */
11726 request_dump (num_cmdline_dump_sects
, 0);
11728 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11729 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11732 if (! process_file_header ())
11735 if (! process_section_headers (file
))
11737 /* Without loaded section headers we cannot process lots of
11739 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11741 if (! do_using_dynamic
)
11742 do_syms
= do_reloc
= 0;
11745 if (! process_section_groups (file
))
11747 /* Without loaded section groups we cannot process unwind. */
11751 if (process_program_headers (file
))
11752 process_dynamic_section (file
);
11754 process_relocs (file
);
11756 process_unwind (file
);
11758 process_symbol_table (file
);
11760 process_syminfo (file
);
11762 process_version_sections (file
);
11764 process_section_contents (file
);
11766 process_notes (file
);
11768 process_gnu_liblist (file
);
11770 process_arch_specific (file
);
11772 if (program_headers
)
11774 free (program_headers
);
11775 program_headers
= NULL
;
11778 if (section_headers
)
11780 free (section_headers
);
11781 section_headers
= NULL
;
11786 free (string_table
);
11787 string_table
= NULL
;
11788 string_table_length
= 0;
11791 if (dynamic_strings
)
11793 free (dynamic_strings
);
11794 dynamic_strings
= NULL
;
11795 dynamic_strings_length
= 0;
11798 if (dynamic_symbols
)
11800 free (dynamic_symbols
);
11801 dynamic_symbols
= NULL
;
11802 num_dynamic_syms
= 0;
11805 if (dynamic_syminfo
)
11807 free (dynamic_syminfo
);
11808 dynamic_syminfo
= NULL
;
11811 if (section_headers_groups
)
11813 free (section_headers_groups
);
11814 section_headers_groups
= NULL
;
11817 if (section_groups
)
11819 struct group_list
*g
, *next
;
11821 for (i
= 0; i
< group_count
; i
++)
11823 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11830 free (section_groups
);
11831 section_groups
= NULL
;
11834 if (debug_information
)
11836 for (i
= 0; i
< num_debug_info_entries
; i
++)
11838 if (!debug_information
[i
].max_loc_offsets
)
11840 free (debug_information
[i
].loc_offsets
);
11841 free (debug_information
[i
].have_frame_base
);
11843 if (!debug_information
[i
].max_range_lists
)
11844 free (debug_information
[i
].range_lists
);
11846 free (debug_information
);
11847 debug_information
= NULL
;
11848 num_debug_info_entries
= 0;
11854 /* Process an ELF archive. The file is positioned just after the
11858 process_archive (char *file_name
, FILE *file
)
11860 struct ar_hdr arhdr
;
11862 unsigned long size
;
11863 char *longnames
= NULL
;
11864 unsigned long longnames_size
= 0;
11865 size_t file_name_size
;
11870 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11871 if (got
!= sizeof arhdr
)
11876 error (_("%s: failed to read archive header\n"), file_name
);
11880 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
11882 /* This is the archive symbol table. Skip it.
11883 FIXME: We should have an option to dump it. */
11884 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11885 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
11887 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11891 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11892 if (got
!= sizeof arhdr
)
11897 error (_("%s: failed to read archive header\n"), file_name
);
11902 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
11904 /* This is the archive string table holding long member
11907 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11909 longnames
= malloc (longnames_size
);
11910 if (longnames
== NULL
)
11912 error (_("Out of memory\n"));
11916 if (fread (longnames
, longnames_size
, 1, file
) != 1)
11919 error (_("%s: failed to read string table\n"), file_name
);
11923 if ((longnames_size
& 1) != 0)
11926 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11927 if (got
!= sizeof arhdr
)
11934 error (_("%s: failed to read archive header\n"), file_name
);
11939 file_name_size
= strlen (file_name
);
11948 if (arhdr
.ar_name
[0] == '/')
11952 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
11953 if (off
>= longnames_size
)
11955 error (_("%s: invalid archive string table offset %lu\n"), off
);
11960 name
= longnames
+ off
;
11961 nameend
= memchr (name
, '/', longnames_size
- off
);
11965 name
= arhdr
.ar_name
;
11966 nameend
= memchr (name
, '/', 16);
11969 if (nameend
== NULL
)
11971 error (_("%s: bad archive file name\n"));
11976 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
11977 if (namealc
== NULL
)
11979 error (_("Out of memory\n"));
11984 memcpy (namealc
, file_name
, file_name_size
);
11985 namealc
[file_name_size
] = '(';
11986 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
11987 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
11988 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
11990 archive_file_offset
= ftell (file
);
11991 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11993 ret
|= process_object (namealc
, file
);
11998 (archive_file_offset
11999 + archive_file_size
12000 + (archive_file_size
& 1)),
12003 error (_("%s: failed to seek to next archive header\n"), file_name
);
12008 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12009 if (got
!= sizeof arhdr
)
12014 error (_("%s: failed to read archive header\n"), file_name
);
12020 if (longnames
!= 0)
12027 process_file (char *file_name
)
12030 struct stat statbuf
;
12031 char armag
[SARMAG
];
12034 if (stat (file_name
, &statbuf
) < 0)
12036 if (errno
== ENOENT
)
12037 error (_("'%s': No such file\n"), file_name
);
12039 error (_("Could not locate '%s'. System error message: %s\n"),
12040 file_name
, strerror (errno
));
12044 if (! S_ISREG (statbuf
.st_mode
))
12046 error (_("'%s' is not an ordinary file\n"), file_name
);
12050 file
= fopen (file_name
, "rb");
12053 error (_("Input file '%s' is not readable.\n"), file_name
);
12057 if (fread (armag
, SARMAG
, 1, file
) != 1)
12059 error (_("%s: Failed to read file header\n"), file_name
);
12064 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12065 ret
= process_archive (file_name
, file
);
12069 archive_file_size
= archive_file_offset
= 0;
12070 ret
= process_object (file_name
, file
);
12078 #ifdef SUPPORT_DISASSEMBLY
12079 /* Needed by the i386 disassembler. For extra credit, someone could
12080 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12084 print_address (unsigned int addr
, FILE *outfile
)
12086 fprintf (outfile
,"0x%8.8x", addr
);
12089 /* Needed by the i386 disassembler. */
12091 db_task_printsym (unsigned int addr
)
12093 print_address (addr
, stderr
);
12098 main (int argc
, char **argv
)
12102 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12103 setlocale (LC_MESSAGES
, "");
12105 #if defined (HAVE_SETLOCALE)
12106 setlocale (LC_CTYPE
, "");
12108 bindtextdomain (PACKAGE
, LOCALEDIR
);
12109 textdomain (PACKAGE
);
12111 parse_args (argc
, argv
);
12113 if (num_dump_sects
> 0)
12115 /* Make a copy of the dump_sects array. */
12116 cmdline_dump_sects
= malloc (num_dump_sects
);
12117 if (cmdline_dump_sects
== NULL
)
12118 error (_("Out of memory allocating dump request table."));
12121 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12122 num_cmdline_dump_sects
= num_dump_sects
;
12126 if (optind
< (argc
- 1))
12130 while (optind
< argc
)
12131 err
|= process_file (argv
[optind
++]);
12133 if (dump_sects
!= NULL
)
12135 if (cmdline_dump_sects
!= NULL
)
12136 free (cmdline_dump_sects
);