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_arm_segment_type (unsigned long type
)
2252 get_mips_segment_type (unsigned long type
)
2256 case PT_MIPS_REGINFO
:
2258 case PT_MIPS_RTPROC
:
2260 case PT_MIPS_OPTIONS
:
2270 get_parisc_segment_type (unsigned long type
)
2274 case PT_HP_TLS
: return "HP_TLS";
2275 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2276 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2277 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2278 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2279 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2280 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2281 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2282 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2283 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2284 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2285 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2286 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2287 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2296 get_ia64_segment_type (unsigned long type
)
2300 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2301 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2302 case PT_HP_TLS
: return "HP_TLS";
2303 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2304 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2305 case PT_IA_64_HP_STACK
: return "HP_STACK";
2314 get_segment_type (unsigned long p_type
)
2316 static char buff
[32];
2320 case PT_NULL
: return "NULL";
2321 case PT_LOAD
: return "LOAD";
2322 case PT_DYNAMIC
: return "DYNAMIC";
2323 case PT_INTERP
: return "INTERP";
2324 case PT_NOTE
: return "NOTE";
2325 case PT_SHLIB
: return "SHLIB";
2326 case PT_PHDR
: return "PHDR";
2327 case PT_TLS
: return "TLS";
2329 case PT_GNU_EH_FRAME
:
2330 return "GNU_EH_FRAME";
2331 case PT_GNU_STACK
: return "GNU_STACK";
2332 case PT_GNU_RELRO
: return "GNU_RELRO";
2335 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2339 switch (elf_header
.e_machine
)
2342 result
= get_arm_segment_type (p_type
);
2345 case EM_MIPS_RS3_LE
:
2346 result
= get_mips_segment_type (p_type
);
2349 result
= get_parisc_segment_type (p_type
);
2352 result
= get_ia64_segment_type (p_type
);
2362 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2364 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2368 switch (elf_header
.e_machine
)
2371 result
= get_parisc_segment_type (p_type
);
2374 result
= get_ia64_segment_type (p_type
);
2384 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2387 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2394 get_mips_section_type_name (unsigned int sh_type
)
2398 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2399 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2400 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2401 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2402 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2403 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2404 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2405 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2406 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2407 case SHT_MIPS_RELD
: return "MIPS_RELD";
2408 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2409 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2410 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2411 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2412 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2413 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2414 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2415 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2416 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2417 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2418 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2419 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2420 case SHT_MIPS_LINE
: return "MIPS_LINE";
2421 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2422 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2423 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2424 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2425 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2426 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2427 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2428 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2429 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2430 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2431 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2432 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2433 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2434 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2435 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2436 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2444 get_parisc_section_type_name (unsigned int sh_type
)
2448 case SHT_PARISC_EXT
: return "PARISC_EXT";
2449 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2450 case SHT_PARISC_DOC
: return "PARISC_DOC";
2458 get_ia64_section_type_name (unsigned int sh_type
)
2460 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2461 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2462 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2466 case SHT_IA_64_EXT
: return "IA_64_EXT";
2467 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2468 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2476 get_x86_64_section_type_name (unsigned int sh_type
)
2480 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2488 get_arm_section_type_name (unsigned int sh_type
)
2501 get_section_type_name (unsigned int sh_type
)
2503 static char buff
[32];
2507 case SHT_NULL
: return "NULL";
2508 case SHT_PROGBITS
: return "PROGBITS";
2509 case SHT_SYMTAB
: return "SYMTAB";
2510 case SHT_STRTAB
: return "STRTAB";
2511 case SHT_RELA
: return "RELA";
2512 case SHT_HASH
: return "HASH";
2513 case SHT_DYNAMIC
: return "DYNAMIC";
2514 case SHT_NOTE
: return "NOTE";
2515 case SHT_NOBITS
: return "NOBITS";
2516 case SHT_REL
: return "REL";
2517 case SHT_SHLIB
: return "SHLIB";
2518 case SHT_DYNSYM
: return "DYNSYM";
2519 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2520 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2521 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2522 case SHT_GROUP
: return "GROUP";
2523 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2524 case SHT_GNU_verdef
: return "VERDEF";
2525 case SHT_GNU_verneed
: return "VERNEED";
2526 case SHT_GNU_versym
: return "VERSYM";
2527 case 0x6ffffff0: return "VERSYM";
2528 case 0x6ffffffc: return "VERDEF";
2529 case 0x7ffffffd: return "AUXILIARY";
2530 case 0x7fffffff: return "FILTER";
2531 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2534 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2538 switch (elf_header
.e_machine
)
2541 case EM_MIPS_RS3_LE
:
2542 result
= get_mips_section_type_name (sh_type
);
2545 result
= get_parisc_section_type_name (sh_type
);
2548 result
= get_ia64_section_type_name (sh_type
);
2551 result
= get_x86_64_section_type_name (sh_type
);
2554 result
= get_arm_section_type_name (sh_type
);
2564 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2566 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2567 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2568 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2569 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2571 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2577 #define OPTION_DEBUG_DUMP 512
2579 struct option options
[] =
2581 {"all", no_argument
, 0, 'a'},
2582 {"file-header", no_argument
, 0, 'h'},
2583 {"program-headers", no_argument
, 0, 'l'},
2584 {"headers", no_argument
, 0, 'e'},
2585 {"histogram", no_argument
, 0, 'I'},
2586 {"segments", no_argument
, 0, 'l'},
2587 {"sections", no_argument
, 0, 'S'},
2588 {"section-headers", no_argument
, 0, 'S'},
2589 {"section-groups", no_argument
, 0, 'g'},
2590 {"symbols", no_argument
, 0, 's'},
2591 {"syms", no_argument
, 0, 's'},
2592 {"relocs", no_argument
, 0, 'r'},
2593 {"notes", no_argument
, 0, 'n'},
2594 {"dynamic", no_argument
, 0, 'd'},
2595 {"arch-specific", no_argument
, 0, 'A'},
2596 {"version-info", no_argument
, 0, 'V'},
2597 {"use-dynamic", no_argument
, 0, 'D'},
2598 {"hex-dump", required_argument
, 0, 'x'},
2599 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2600 {"unwind", no_argument
, 0, 'u'},
2601 #ifdef SUPPORT_DISASSEMBLY
2602 {"instruction-dump", required_argument
, 0, 'i'},
2605 {"version", no_argument
, 0, 'v'},
2606 {"wide", no_argument
, 0, 'W'},
2607 {"help", no_argument
, 0, 'H'},
2608 {0, no_argument
, 0, 0}
2614 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2615 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2616 fprintf (stdout
, _(" Options are:\n\
2617 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2618 -h --file-header Display the ELF file header\n\
2619 -l --program-headers Display the program headers\n\
2620 --segments An alias for --program-headers\n\
2621 -S --section-headers Display the sections' header\n\
2622 --sections An alias for --section-headers\n\
2623 -g --section-groups Display the section groups\n\
2624 -e --headers Equivalent to: -h -l -S\n\
2625 -s --syms Display the symbol table\n\
2626 --symbols An alias for --syms\n\
2627 -n --notes Display the core notes (if present)\n\
2628 -r --relocs Display the relocations (if present)\n\
2629 -u --unwind Display the unwind info (if present)\n\
2630 -d --dynamic Display the dynamic section (if present)\n\
2631 -V --version-info Display the version sections (if present)\n\
2632 -A --arch-specific Display architecture specific information (if any).\n\
2633 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2634 -x --hex-dump=<number> Dump the contents of section <number>\n\
2635 -w[liaprmfFsoR] or\n\
2636 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2637 Display the contents of DWARF2 debug sections\n"));
2638 #ifdef SUPPORT_DISASSEMBLY
2639 fprintf (stdout
, _("\
2640 -i --instruction-dump=<number>\n\
2641 Disassemble the contents of section <number>\n"));
2643 fprintf (stdout
, _("\
2644 -I --histogram Display histogram of bucket list lengths\n\
2645 -W --wide Allow output width to exceed 80 characters\n\
2646 -H --help Display this information\n\
2647 -v --version Display the version number of readelf\n"));
2648 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2653 /* Record the fact that the user wants the contents of section number
2654 SECTION to be displayed using the method(s) encoded as flags bits
2655 in TYPE. Note, TYPE can be zero if we are creating the array for
2659 request_dump (unsigned int section
, int type
)
2661 if (section
>= num_dump_sects
)
2663 char *new_dump_sects
;
2665 new_dump_sects
= calloc (section
+ 1, 1);
2667 if (new_dump_sects
== NULL
)
2668 error (_("Out of memory allocating dump request table."));
2671 /* Copy current flag settings. */
2672 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2676 dump_sects
= new_dump_sects
;
2677 num_dump_sects
= section
+ 1;
2682 dump_sects
[section
] |= type
;
2688 parse_args (int argc
, char **argv
)
2695 while ((c
= getopt_long
2696 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2717 do_section_groups
++;
2725 do_section_groups
++;
2767 section
= strtoul (optarg
, & cp
, 0);
2768 if (! *cp
&& section
>= 0)
2770 request_dump (section
, HEX_DUMP
);
2780 unsigned int index
= 0;
2784 while (optarg
[index
])
2785 switch (optarg
[index
++])
2794 do_debug_abbrevs
= 1;
2804 do_debug_pubnames
= 1;
2808 do_debug_aranges
= 1;
2812 do_debug_ranges
= 1;
2816 do_debug_frames_interp
= 1;
2818 do_debug_frames
= 1;
2823 do_debug_macinfo
= 1;
2837 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2842 case OPTION_DEBUG_DUMP
:
2850 const char * option
;
2853 debug_dump_long_opts
;
2855 debug_dump_long_opts opts_table
[] =
2857 /* Please keep this table alpha- sorted. */
2858 { "Ranges", & do_debug_ranges
},
2859 { "abbrev", & do_debug_abbrevs
},
2860 { "aranges", & do_debug_aranges
},
2861 { "frames", & do_debug_frames
},
2862 { "frames-interp", & do_debug_frames_interp
},
2863 { "info", & do_debug_info
},
2864 { "line", & do_debug_lines
},
2865 { "loc", & do_debug_loc
},
2866 { "macro", & do_debug_macinfo
},
2867 { "pubnames", & do_debug_pubnames
},
2868 /* This entry is for compatability
2869 with earlier versions of readelf. */
2870 { "ranges", & do_debug_aranges
},
2871 { "str", & do_debug_str
},
2882 debug_dump_long_opts
* entry
;
2884 for (entry
= opts_table
; entry
->option
; entry
++)
2886 size_t len
= strlen (entry
->option
);
2888 if (strneq (p
, entry
->option
, len
)
2889 && (p
[len
] == ',' || p
[len
] == '\0'))
2891 * entry
->variable
= 1;
2893 /* The --debug-dump=frames-interp option also
2894 enables the --debug-dump=frames option. */
2895 if (do_debug_frames_interp
)
2896 do_debug_frames
= 1;
2903 if (entry
->option
== NULL
)
2905 warn (_("Unrecognized debug option '%s'\n"), p
);
2906 p
= strchr (p
, ',');
2916 #ifdef SUPPORT_DISASSEMBLY
2919 section
= strtoul (optarg
, & cp
, 0);
2920 if (! *cp
&& section
>= 0)
2922 request_dump (section
, DISASS_DUMP
);
2928 print_version (program_name
);
2938 /* xgettext:c-format */
2939 error (_("Invalid option '-%c'\n"), c
);
2946 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2947 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2948 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2949 && !do_section_groups
)
2953 warn (_("Nothing to do.\n"));
2959 get_elf_class (unsigned int elf_class
)
2961 static char buff
[32];
2965 case ELFCLASSNONE
: return _("none");
2966 case ELFCLASS32
: return "ELF32";
2967 case ELFCLASS64
: return "ELF64";
2969 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
2975 get_data_encoding (unsigned int encoding
)
2977 static char buff
[32];
2981 case ELFDATANONE
: return _("none");
2982 case ELFDATA2LSB
: return _("2's complement, little endian");
2983 case ELFDATA2MSB
: return _("2's complement, big endian");
2985 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
2990 /* Decode the data held in 'elf_header'. */
2993 process_file_header (void)
2995 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2996 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2997 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2998 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3001 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3009 printf (_("ELF Header:\n"));
3010 printf (_(" Magic: "));
3011 for (i
= 0; i
< EI_NIDENT
; i
++)
3012 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3014 printf (_(" Class: %s\n"),
3015 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3016 printf (_(" Data: %s\n"),
3017 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3018 printf (_(" Version: %d %s\n"),
3019 elf_header
.e_ident
[EI_VERSION
],
3020 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3022 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3025 printf (_(" OS/ABI: %s\n"),
3026 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3027 printf (_(" ABI Version: %d\n"),
3028 elf_header
.e_ident
[EI_ABIVERSION
]);
3029 printf (_(" Type: %s\n"),
3030 get_file_type (elf_header
.e_type
));
3031 printf (_(" Machine: %s\n"),
3032 get_machine_name (elf_header
.e_machine
));
3033 printf (_(" Version: 0x%lx\n"),
3034 (unsigned long) elf_header
.e_version
);
3036 printf (_(" Entry point address: "));
3037 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3038 printf (_("\n Start of program headers: "));
3039 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3040 printf (_(" (bytes into file)\n Start of section headers: "));
3041 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3042 printf (_(" (bytes into file)\n"));
3044 printf (_(" Flags: 0x%lx%s\n"),
3045 (unsigned long) elf_header
.e_flags
,
3046 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3047 printf (_(" Size of this header: %ld (bytes)\n"),
3048 (long) elf_header
.e_ehsize
);
3049 printf (_(" Size of program headers: %ld (bytes)\n"),
3050 (long) elf_header
.e_phentsize
);
3051 printf (_(" Number of program headers: %ld\n"),
3052 (long) elf_header
.e_phnum
);
3053 printf (_(" Size of section headers: %ld (bytes)\n"),
3054 (long) elf_header
.e_shentsize
);
3055 printf (_(" Number of section headers: %ld"),
3056 (long) elf_header
.e_shnum
);
3057 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3058 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3059 putc ('\n', stdout
);
3060 printf (_(" Section header string table index: %ld"),
3061 (long) elf_header
.e_shstrndx
);
3062 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3063 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3064 putc ('\n', stdout
);
3067 if (section_headers
!= NULL
)
3069 if (elf_header
.e_shnum
== 0)
3070 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3071 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3072 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3073 free (section_headers
);
3074 section_headers
= NULL
;
3082 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3084 Elf32_External_Phdr
*phdrs
;
3085 Elf32_External_Phdr
*external
;
3086 Elf_Internal_Phdr
*internal
;
3089 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3090 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3091 _("program headers"));
3095 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3096 i
< elf_header
.e_phnum
;
3097 i
++, internal
++, external
++)
3099 internal
->p_type
= BYTE_GET (external
->p_type
);
3100 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3101 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3102 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3103 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3104 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3105 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3106 internal
->p_align
= BYTE_GET (external
->p_align
);
3115 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3117 Elf64_External_Phdr
*phdrs
;
3118 Elf64_External_Phdr
*external
;
3119 Elf_Internal_Phdr
*internal
;
3122 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3123 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3124 _("program headers"));
3128 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3129 i
< elf_header
.e_phnum
;
3130 i
++, internal
++, external
++)
3132 internal
->p_type
= BYTE_GET (external
->p_type
);
3133 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3134 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3135 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3136 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3137 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3138 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3139 internal
->p_align
= BYTE_GET (external
->p_align
);
3147 /* Returns 1 if the program headers were read into `program_headers'. */
3150 get_program_headers (FILE *file
)
3152 Elf_Internal_Phdr
*phdrs
;
3154 /* Check cache of prior read. */
3155 if (program_headers
!= NULL
)
3158 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3162 error (_("Out of memory\n"));
3167 ? get_32bit_program_headers (file
, phdrs
)
3168 : get_64bit_program_headers (file
, phdrs
))
3170 program_headers
= phdrs
;
3178 /* Returns 1 if the program headers were loaded. */
3181 process_program_headers (FILE *file
)
3183 Elf_Internal_Phdr
*segment
;
3186 if (elf_header
.e_phnum
== 0)
3189 printf (_("\nThere are no program headers in this file.\n"));
3193 if (do_segments
&& !do_header
)
3195 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3196 printf (_("Entry point "));
3197 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3198 printf (_("\nThere are %d program headers, starting at offset "),
3199 elf_header
.e_phnum
);
3200 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3204 if (! get_program_headers (file
))
3209 if (elf_header
.e_phnum
> 1)
3210 printf (_("\nProgram Headers:\n"));
3212 printf (_("\nProgram Headers:\n"));
3216 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3219 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3223 (_(" Type Offset VirtAddr PhysAddr\n"));
3225 (_(" FileSiz MemSiz Flags Align\n"));
3232 for (i
= 0, segment
= program_headers
;
3233 i
< elf_header
.e_phnum
;
3238 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3242 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3243 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3244 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3245 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3246 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3248 (segment
->p_flags
& PF_R
? 'R' : ' '),
3249 (segment
->p_flags
& PF_W
? 'W' : ' '),
3250 (segment
->p_flags
& PF_X
? 'E' : ' '));
3251 printf ("%#lx", (unsigned long) segment
->p_align
);
3255 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3256 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3259 print_vma (segment
->p_offset
, FULL_HEX
);
3263 print_vma (segment
->p_vaddr
, FULL_HEX
);
3265 print_vma (segment
->p_paddr
, FULL_HEX
);
3268 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3269 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3272 print_vma (segment
->p_filesz
, FULL_HEX
);
3276 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3277 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3280 print_vma (segment
->p_offset
, FULL_HEX
);
3284 (segment
->p_flags
& PF_R
? 'R' : ' '),
3285 (segment
->p_flags
& PF_W
? 'W' : ' '),
3286 (segment
->p_flags
& PF_X
? 'E' : ' '));
3288 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3289 printf ("%#lx", (unsigned long) segment
->p_align
);
3292 print_vma (segment
->p_align
, PREFIX_HEX
);
3297 print_vma (segment
->p_offset
, FULL_HEX
);
3299 print_vma (segment
->p_vaddr
, FULL_HEX
);
3301 print_vma (segment
->p_paddr
, FULL_HEX
);
3303 print_vma (segment
->p_filesz
, FULL_HEX
);
3305 print_vma (segment
->p_memsz
, FULL_HEX
);
3307 (segment
->p_flags
& PF_R
? 'R' : ' '),
3308 (segment
->p_flags
& PF_W
? 'W' : ' '),
3309 (segment
->p_flags
& PF_X
? 'E' : ' '));
3310 print_vma (segment
->p_align
, HEX
);
3314 switch (segment
->p_type
)
3318 error (_("more than one dynamic segment\n"));
3320 /* Try to locate the .dynamic section. If there is
3321 a section header table, we can easily locate it. */
3322 if (section_headers
!= NULL
)
3324 Elf_Internal_Shdr
*sec
;
3326 sec
= find_section (".dynamic");
3327 if (sec
== NULL
|| sec
->sh_size
== 0)
3329 error (_("no .dynamic section in the dynamic segment"));
3333 dynamic_addr
= sec
->sh_offset
;
3334 dynamic_size
= sec
->sh_size
;
3336 if (dynamic_addr
< segment
->p_offset
3337 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3338 warn (_("the .dynamic section is not contained within the dynamic segment"));
3339 else if (dynamic_addr
> segment
->p_offset
)
3340 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3344 /* Otherwise, we can only assume that the .dynamic
3345 section is the first section in the DYNAMIC segment. */
3346 dynamic_addr
= segment
->p_offset
;
3347 dynamic_size
= segment
->p_filesz
;
3352 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3354 error (_("Unable to find program interpreter name\n"));
3357 program_interpreter
[0] = 0;
3358 fscanf (file
, "%63s", program_interpreter
);
3361 printf (_("\n [Requesting program interpreter: %s]"),
3362 program_interpreter
);
3368 putc ('\n', stdout
);
3371 if (do_segments
&& section_headers
!= NULL
)
3373 printf (_("\n Section to Segment mapping:\n"));
3374 printf (_(" Segment Sections...\n"));
3376 assert (string_table
!= NULL
);
3378 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3381 Elf_Internal_Shdr
*section
;
3383 segment
= program_headers
+ i
;
3384 section
= section_headers
;
3386 printf (" %2.2d ", i
);
3388 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3390 if (section
->sh_size
> 0
3391 /* Compare allocated sections by VMA, unallocated
3392 sections by file offset. */
3393 && (section
->sh_flags
& SHF_ALLOC
3394 ? (section
->sh_addr
>= segment
->p_vaddr
3395 && section
->sh_addr
+ section
->sh_size
3396 <= segment
->p_vaddr
+ segment
->p_memsz
)
3397 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3398 && (section
->sh_offset
+ section
->sh_size
3399 <= segment
->p_offset
+ segment
->p_filesz
)))
3400 /* .tbss is special. It doesn't contribute memory space
3401 to normal segments. */
3402 && (!((section
->sh_flags
& SHF_TLS
) != 0
3403 && section
->sh_type
== SHT_NOBITS
)
3404 || segment
->p_type
== PT_TLS
))
3405 printf ("%s ", SECTION_NAME (section
));
3416 /* Find the file offset corresponding to VMA by using the program headers. */
3419 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3421 Elf_Internal_Phdr
*seg
;
3423 if (! get_program_headers (file
))
3425 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3429 for (seg
= program_headers
;
3430 seg
< program_headers
+ elf_header
.e_phnum
;
3433 if (seg
->p_type
!= PT_LOAD
)
3436 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3437 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3438 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3441 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3448 get_32bit_section_headers (FILE *file
, unsigned int num
)
3450 Elf32_External_Shdr
*shdrs
;
3451 Elf_Internal_Shdr
*internal
;
3454 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3455 elf_header
.e_shentsize
* num
, _("section headers"));
3459 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3461 if (section_headers
== NULL
)
3463 error (_("Out of memory\n"));
3467 for (i
= 0, internal
= section_headers
;
3471 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3472 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3473 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3474 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3475 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3476 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3477 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3478 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3479 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3480 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3489 get_64bit_section_headers (FILE *file
, unsigned int num
)
3491 Elf64_External_Shdr
*shdrs
;
3492 Elf_Internal_Shdr
*internal
;
3495 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3496 elf_header
.e_shentsize
* num
, _("section headers"));
3500 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3502 if (section_headers
== NULL
)
3504 error (_("Out of memory\n"));
3508 for (i
= 0, internal
= section_headers
;
3512 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3513 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3514 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3515 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3516 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3517 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3518 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3519 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3520 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3521 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3529 static Elf_Internal_Sym
*
3530 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3532 unsigned long number
;
3533 Elf32_External_Sym
*esyms
;
3534 Elf_External_Sym_Shndx
*shndx
;
3535 Elf_Internal_Sym
*isyms
;
3536 Elf_Internal_Sym
*psym
;
3539 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3545 if (symtab_shndx_hdr
!= NULL
3546 && (symtab_shndx_hdr
->sh_link
3547 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3549 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3550 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3558 number
= section
->sh_size
/ section
->sh_entsize
;
3559 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3563 error (_("Out of memory\n"));
3570 for (j
= 0, psym
= isyms
;
3574 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3575 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3576 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3577 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3578 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3580 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3581 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3582 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3592 static Elf_Internal_Sym
*
3593 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3595 unsigned long number
;
3596 Elf64_External_Sym
*esyms
;
3597 Elf_External_Sym_Shndx
*shndx
;
3598 Elf_Internal_Sym
*isyms
;
3599 Elf_Internal_Sym
*psym
;
3602 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3608 if (symtab_shndx_hdr
!= NULL
3609 && (symtab_shndx_hdr
->sh_link
3610 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3612 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3613 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3621 number
= section
->sh_size
/ section
->sh_entsize
;
3622 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3626 error (_("Out of memory\n"));
3633 for (j
= 0, psym
= isyms
;
3637 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3638 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3639 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3640 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3641 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3643 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3644 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3645 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3656 get_elf_section_flags (bfd_vma sh_flags
)
3658 static char buff
[33];
3665 flag
= sh_flags
& - sh_flags
;
3670 case SHF_WRITE
: *p
= 'W'; break;
3671 case SHF_ALLOC
: *p
= 'A'; break;
3672 case SHF_EXECINSTR
: *p
= 'X'; break;
3673 case SHF_MERGE
: *p
= 'M'; break;
3674 case SHF_STRINGS
: *p
= 'S'; break;
3675 case SHF_INFO_LINK
: *p
= 'I'; break;
3676 case SHF_LINK_ORDER
: *p
= 'L'; break;
3677 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3678 case SHF_GROUP
: *p
= 'G'; break;
3679 case SHF_TLS
: *p
= 'T'; break;
3682 if (flag
& SHF_MASKOS
)
3685 sh_flags
&= ~ SHF_MASKOS
;
3687 else if (flag
& SHF_MASKPROC
)
3690 sh_flags
&= ~ SHF_MASKPROC
;
3704 process_section_headers (FILE *file
)
3706 Elf_Internal_Shdr
*section
;
3709 section_headers
= NULL
;
3711 if (elf_header
.e_shnum
== 0)
3714 printf (_("\nThere are no sections in this file.\n"));
3719 if (do_sections
&& !do_header
)
3720 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3721 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3725 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3728 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3731 /* Read in the string table, so that we have names to display. */
3732 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3734 if (section
->sh_size
!= 0)
3736 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3737 section
->sh_size
, _("string table"));
3739 if (string_table
== NULL
)
3742 string_table_length
= section
->sh_size
;
3745 /* Scan the sections for the dynamic symbol table
3746 and dynamic string table and debug sections. */
3747 dynamic_symbols
= NULL
;
3748 dynamic_strings
= NULL
;
3749 dynamic_syminfo
= NULL
;
3750 symtab_shndx_hdr
= NULL
;
3752 eh_addr_size
= is_32bit_elf
? 4 : 8;
3753 switch (elf_header
.e_machine
)
3756 case EM_MIPS_RS3_LE
:
3757 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
3758 FDE addresses. However, the ABI also has a semi-official ILP32
3759 variant for which the normal FDE address size rules apply.
3761 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
3762 section, where XX is the size of longs in bits. Unfortunately,
3763 earlier compilers provided no way of distinguishing ILP32 objects
3764 from LP64 objects, so if there's any doubt, we should assume that
3765 the official LP64 form is being used. */
3766 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
3767 && find_section (".gcc_compiled_long32") == NULL
)
3772 for (i
= 0, section
= section_headers
;
3773 i
< elf_header
.e_shnum
;
3776 char *name
= SECTION_NAME (section
);
3778 if (section
->sh_type
== SHT_DYNSYM
)
3780 if (dynamic_symbols
!= NULL
)
3782 error (_("File contains multiple dynamic symbol tables\n"));
3786 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3787 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3789 else if (section
->sh_type
== SHT_STRTAB
3790 && streq (name
, ".dynstr"))
3792 if (dynamic_strings
!= NULL
)
3794 error (_("File contains multiple dynamic string tables\n"));
3798 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3799 section
->sh_size
, _("dynamic strings"));
3800 dynamic_strings_length
= section
->sh_size
;
3802 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3804 if (symtab_shndx_hdr
!= NULL
)
3806 error (_("File contains multiple symtab shndx tables\n"));
3809 symtab_shndx_hdr
= section
;
3811 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3812 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3813 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3814 || do_debug_loc
|| do_debug_ranges
)
3815 && strneq (name
, ".debug_", 7))
3820 || (do_debug_info
&& streq (name
, "info"))
3821 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
3822 || (do_debug_lines
&& streq (name
, "line"))
3823 || (do_debug_pubnames
&& streq (name
, "pubnames"))
3824 || (do_debug_aranges
&& streq (name
, "aranges"))
3825 || (do_debug_ranges
&& streq (name
, "ranges"))
3826 || (do_debug_frames
&& streq (name
, "frame"))
3827 || (do_debug_macinfo
&& streq (name
, "macinfo"))
3828 || (do_debug_str
&& streq (name
, "str"))
3829 || (do_debug_loc
&& streq (name
, "loc"))
3831 request_dump (i
, DEBUG_DUMP
);
3833 /* linkonce section to be combined with .debug_info at link time. */
3834 else if ((do_debugging
|| do_debug_info
)
3835 && strneq (name
, ".gnu.linkonce.wi.", 17))
3836 request_dump (i
, DEBUG_DUMP
);
3837 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
3838 request_dump (i
, DEBUG_DUMP
);
3844 if (elf_header
.e_shnum
> 1)
3845 printf (_("\nSection Headers:\n"));
3847 printf (_("\nSection Header:\n"));
3851 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3854 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3857 printf (_(" [Nr] Name Type Address Offset\n"));
3858 printf (_(" Size EntSize Flags Link Info Align\n"));
3861 for (i
= 0, section
= section_headers
;
3862 i
< elf_header
.e_shnum
;
3865 printf (" [%2u] %-17.17s %-15.15s ",
3866 SECTION_HEADER_NUM (i
),
3867 SECTION_NAME (section
),
3868 get_section_type_name (section
->sh_type
));
3872 print_vma (section
->sh_addr
, LONG_HEX
);
3874 printf ( " %6.6lx %6.6lx %2.2lx",
3875 (unsigned long) section
->sh_offset
,
3876 (unsigned long) section
->sh_size
,
3877 (unsigned long) section
->sh_entsize
);
3879 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3881 printf ("%2ld %3lu %2ld\n",
3882 (unsigned long) section
->sh_link
,
3883 (unsigned long) section
->sh_info
,
3884 (unsigned long) section
->sh_addralign
);
3888 print_vma (section
->sh_addr
, LONG_HEX
);
3890 if ((long) section
->sh_offset
== section
->sh_offset
)
3891 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3895 print_vma (section
->sh_offset
, LONG_HEX
);
3898 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3899 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3903 print_vma (section
->sh_size
, LONG_HEX
);
3906 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3907 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3911 print_vma (section
->sh_entsize
, LONG_HEX
);
3914 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3916 printf ("%2ld %3lu ",
3917 (unsigned long) section
->sh_link
,
3918 (unsigned long) section
->sh_info
);
3920 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3921 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3924 print_vma (section
->sh_addralign
, DEC
);
3931 print_vma (section
->sh_addr
, LONG_HEX
);
3932 if ((long) section
->sh_offset
== section
->sh_offset
)
3933 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3937 print_vma (section
->sh_offset
, LONG_HEX
);
3940 print_vma (section
->sh_size
, LONG_HEX
);
3942 print_vma (section
->sh_entsize
, LONG_HEX
);
3944 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3946 printf (" %2ld %3lu %ld\n",
3947 (unsigned long) section
->sh_link
,
3948 (unsigned long) section
->sh_info
,
3949 (unsigned long) section
->sh_addralign
);
3953 printf (_("Key to Flags:\n\
3954 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3955 I (info), L (link order), G (group), x (unknown)\n\
3956 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3962 get_group_flags (unsigned int flags
)
3964 static char buff
[32];
3971 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
3978 process_section_groups (FILE *file
)
3980 Elf_Internal_Shdr
*section
;
3982 struct group
*group
;
3983 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
3984 Elf_Internal_Sym
*symtab
;
3987 /* Don't process section groups unless needed. */
3988 if (!do_unwind
&& !do_section_groups
)
3991 if (elf_header
.e_shnum
== 0)
3993 if (do_section_groups
)
3994 printf (_("\nThere are no sections in this file.\n"));
3999 if (section_headers
== NULL
)
4001 error (_("Section headers are not available!\n"));
4005 section_headers_groups
= calloc (elf_header
.e_shnum
,
4006 sizeof (struct group
*));
4008 if (section_headers_groups
== NULL
)
4010 error (_("Out of memory\n"));
4014 /* Scan the sections for the group section. */
4016 for (i
= 0, section
= section_headers
;
4017 i
< elf_header
.e_shnum
;
4019 if (section
->sh_type
== SHT_GROUP
)
4022 if (group_count
== 0)
4024 if (do_section_groups
)
4025 printf (_("\nThere are no section groups in this file.\n"));
4030 section_groups
= calloc (group_count
, sizeof (struct group
));
4032 if (section_groups
== NULL
)
4034 error (_("Out of memory\n"));
4042 for (i
= 0, section
= section_headers
, group
= section_groups
;
4043 i
< elf_header
.e_shnum
;
4046 if (section
->sh_type
== SHT_GROUP
)
4048 char *name
= SECTION_NAME (section
);
4050 unsigned char *start
, *indices
;
4051 unsigned int entry
, j
, size
;
4052 Elf_Internal_Shdr
*sec
;
4053 Elf_Internal_Sym
*sym
;
4055 /* Get the symbol table. */
4056 sec
= SECTION_HEADER (section
->sh_link
);
4057 if (sec
->sh_type
!= SHT_SYMTAB
)
4059 error (_("Bad sh_link in group section `%s'\n"), name
);
4063 if (symtab_sec
!= sec
)
4068 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4071 sym
= symtab
+ section
->sh_info
;
4073 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4075 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4078 error (_("Bad sh_info in group section `%s'\n"), name
);
4082 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4087 /* Get the string table. */
4088 sec
= SECTION_HEADER (symtab_sec
->sh_link
);
4089 if (strtab_sec
!= sec
)
4094 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4095 strtab_sec
->sh_size
,
4098 group_name
= strtab
+ sym
->st_name
;
4101 start
= get_data (NULL
, file
, section
->sh_offset
,
4102 section
->sh_size
, _("section data"));
4105 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4106 entry
= byte_get (indices
, 4);
4109 if (do_section_groups
)
4111 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
4112 get_group_flags (entry
), name
, group_name
, size
);
4114 printf (_(" [Index] Name\n"));
4117 group
->group_index
= i
;
4119 for (j
= 0; j
< size
; j
++)
4121 struct group_list
*g
;
4123 entry
= byte_get (indices
, 4);
4126 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4131 error (_("section [%5u] already in group section [%5u]\n"),
4133 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4138 /* Intel C/C++ compiler may put section 0 in a
4139 section group. We just warn it the first time
4140 and ignore it afterwards. */
4141 static int warned
= 0;
4144 error (_("section 0 in group section [%5u]\n"),
4145 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4151 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4154 if (do_section_groups
)
4156 sec
= SECTION_HEADER (entry
);
4157 printf (" [%5u] %s\n",
4158 entry
, SECTION_NAME (sec
));
4161 g
= xmalloc (sizeof (struct group_list
));
4162 g
->section_index
= entry
;
4163 g
->next
= group
->root
;
4187 } dynamic_relocations
[] =
4189 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4190 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4191 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4194 /* Process the reloc section. */
4197 process_relocs (FILE *file
)
4199 unsigned long rel_size
;
4200 unsigned long rel_offset
;
4206 if (do_using_dynamic
)
4210 int has_dynamic_reloc
;
4213 has_dynamic_reloc
= 0;
4215 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4217 is_rela
= dynamic_relocations
[i
].rela
;
4218 name
= dynamic_relocations
[i
].name
;
4219 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4220 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4222 has_dynamic_reloc
|= rel_size
;
4224 if (is_rela
== UNKNOWN
)
4226 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4227 switch (dynamic_info
[DT_PLTREL
])
4241 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4242 name
, rel_offset
, rel_size
);
4244 dump_relocations (file
,
4245 offset_from_vma (file
, rel_offset
, rel_size
),
4247 dynamic_symbols
, num_dynamic_syms
,
4248 dynamic_strings
, dynamic_strings_length
, is_rela
);
4252 if (! has_dynamic_reloc
)
4253 printf (_("\nThere are no dynamic relocations in this file.\n"));
4257 Elf_Internal_Shdr
*section
;
4261 for (i
= 0, section
= section_headers
;
4262 i
< elf_header
.e_shnum
;
4265 if ( section
->sh_type
!= SHT_RELA
4266 && section
->sh_type
!= SHT_REL
)
4269 rel_offset
= section
->sh_offset
;
4270 rel_size
= section
->sh_size
;
4274 Elf_Internal_Shdr
*strsec
;
4277 printf (_("\nRelocation section "));
4279 if (string_table
== NULL
)
4280 printf ("%d", section
->sh_name
);
4282 printf (_("'%s'"), SECTION_NAME (section
));
4284 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4285 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4287 is_rela
= section
->sh_type
== SHT_RELA
;
4289 if (section
->sh_link
)
4291 Elf_Internal_Shdr
*symsec
;
4292 Elf_Internal_Sym
*symtab
;
4293 unsigned long nsyms
;
4294 unsigned long strtablen
;
4295 char *strtab
= NULL
;
4297 symsec
= SECTION_HEADER (section
->sh_link
);
4298 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4299 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4304 strsec
= SECTION_HEADER (symsec
->sh_link
);
4306 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4307 strsec
->sh_size
, _("string table"));
4308 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4310 dump_relocations (file
, rel_offset
, rel_size
,
4311 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4317 dump_relocations (file
, rel_offset
, rel_size
,
4318 NULL
, 0, NULL
, 0, is_rela
);
4325 printf (_("\nThere are no relocations in this file.\n"));
4331 /* Process the unwind section. */
4333 #include "unwind-ia64.h"
4335 /* An absolute address consists of a section and an offset. If the
4336 section is NULL, the offset itself is the address, otherwise, the
4337 address equals to LOAD_ADDRESS(section) + offset. */
4341 unsigned short section
;
4345 struct ia64_unw_aux_info
4347 struct ia64_unw_table_entry
4349 struct absaddr start
;
4351 struct absaddr info
;
4353 *table
; /* Unwind table. */
4354 unsigned long table_len
; /* Length of unwind table. */
4355 unsigned char *info
; /* Unwind info. */
4356 unsigned long info_size
; /* Size of unwind info. */
4357 bfd_vma info_addr
; /* starting address of unwind info. */
4358 bfd_vma seg_base
; /* Starting address of segment. */
4359 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4360 unsigned long nsyms
; /* Number of symbols. */
4361 char *strtab
; /* The string table. */
4362 unsigned long strtab_size
; /* Size of string table. */
4366 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4367 unsigned long nsyms
,
4369 unsigned long strtab_size
,
4370 struct absaddr addr
,
4371 const char **symname
,
4374 bfd_vma dist
= 0x100000;
4375 Elf_Internal_Sym
*sym
, *best
= NULL
;
4378 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4380 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4381 && sym
->st_name
!= 0
4382 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4383 && addr
.offset
>= sym
->st_value
4384 && addr
.offset
- sym
->st_value
< dist
)
4387 dist
= addr
.offset
- sym
->st_value
;
4394 *symname
= (best
->st_name
>= strtab_size
4395 ? "<corrupt>" : strtab
+ best
->st_name
);
4400 *offset
= addr
.offset
;
4404 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4406 struct ia64_unw_table_entry
*tp
;
4409 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4413 const unsigned char *dp
;
4414 const unsigned char *head
;
4415 const char *procname
;
4417 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4418 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4420 fputs ("\n<", stdout
);
4424 fputs (procname
, stdout
);
4427 printf ("+%lx", (unsigned long) offset
);
4430 fputs (">: [", stdout
);
4431 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4432 fputc ('-', stdout
);
4433 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4434 printf ("], info at +0x%lx\n",
4435 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4437 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4438 stamp
= BYTE_GET ((unsigned char *) head
);
4440 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4441 (unsigned) UNW_VER (stamp
),
4442 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4443 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4444 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4445 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4447 if (UNW_VER (stamp
) != 1)
4449 printf ("\tUnknown version.\n");
4454 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4455 dp
= unw_decode (dp
, in_body
, & in_body
);
4460 slurp_ia64_unwind_table (FILE *file
,
4461 struct ia64_unw_aux_info
*aux
,
4462 Elf_Internal_Shdr
*sec
)
4464 unsigned long size
, nrelas
, i
;
4465 Elf_Internal_Phdr
*seg
;
4466 struct ia64_unw_table_entry
*tep
;
4467 Elf_Internal_Shdr
*relsec
;
4468 Elf_Internal_Rela
*rela
, *rp
;
4469 unsigned char *table
, *tp
;
4470 Elf_Internal_Sym
*sym
;
4471 const char *relname
;
4473 /* First, find the starting address of the segment that includes
4476 if (elf_header
.e_phnum
)
4478 if (! get_program_headers (file
))
4481 for (seg
= program_headers
;
4482 seg
< program_headers
+ elf_header
.e_phnum
;
4485 if (seg
->p_type
!= PT_LOAD
)
4488 if (sec
->sh_addr
>= seg
->p_vaddr
4489 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4491 aux
->seg_base
= seg
->p_vaddr
;
4497 /* Second, build the unwind table from the contents of the unwind section: */
4498 size
= sec
->sh_size
;
4499 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4503 aux
->table
= xmalloc (size
/ (3 * eh_addr_size
) * sizeof (aux
->table
[0]));
4505 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
4507 tep
->start
.section
= SHN_UNDEF
;
4508 tep
->end
.section
= SHN_UNDEF
;
4509 tep
->info
.section
= SHN_UNDEF
;
4512 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4513 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4514 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4518 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4519 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4520 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
4522 tep
->start
.offset
+= aux
->seg_base
;
4523 tep
->end
.offset
+= aux
->seg_base
;
4524 tep
->info
.offset
+= aux
->seg_base
;
4528 /* Third, apply any relocations to the unwind table: */
4530 for (relsec
= section_headers
;
4531 relsec
< section_headers
+ elf_header
.e_shnum
;
4534 if (relsec
->sh_type
!= SHT_RELA
4535 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4538 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4542 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4546 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4547 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4551 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4552 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4555 if (! strneq (relname
, "R_IA64_SEGREL", 13))
4557 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4561 i
= rp
->r_offset
/ (3 * eh_addr_size
);
4563 switch (rp
->r_offset
/eh_addr_size
% 3)
4566 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4567 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
4570 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4571 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
4574 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4575 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
4585 aux
->table_len
= size
/ (3 * eh_addr_size
);
4590 ia64_process_unwind (FILE *file
)
4592 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4593 unsigned long i
, unwcount
= 0, unwstart
= 0;
4594 struct ia64_unw_aux_info aux
;
4596 memset (& aux
, 0, sizeof (aux
));
4598 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4600 if (sec
->sh_type
== SHT_SYMTAB
)
4602 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4603 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4605 strsec
= SECTION_HEADER (sec
->sh_link
);
4606 aux
.strtab_size
= strsec
->sh_size
;
4607 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4608 aux
.strtab_size
, _("string table"));
4610 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4615 printf (_("\nThere are no unwind sections in this file.\n"));
4617 while (unwcount
-- > 0)
4622 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4623 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4624 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4631 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4633 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4635 /* We need to find which section group it is in. */
4636 struct group_list
*g
= section_headers_groups
[i
]->root
;
4638 for (; g
!= NULL
; g
= g
->next
)
4640 sec
= SECTION_HEADER (g
->section_index
);
4642 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
4647 i
= elf_header
.e_shnum
;
4649 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
4651 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
4652 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4653 suffix
= SECTION_NAME (unwsec
) + len
;
4654 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4656 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
4657 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4662 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4663 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
4664 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4665 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4667 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
4668 suffix
= SECTION_NAME (unwsec
) + len
;
4669 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4671 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
4672 && streq (SECTION_NAME (sec
) + len2
, suffix
))
4676 if (i
== elf_header
.e_shnum
)
4678 printf (_("\nCould not find unwind info section for "));
4680 if (string_table
== NULL
)
4681 printf ("%d", unwsec
->sh_name
);
4683 printf (_("'%s'"), SECTION_NAME (unwsec
));
4687 aux
.info_size
= sec
->sh_size
;
4688 aux
.info_addr
= sec
->sh_addr
;
4689 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4692 printf (_("\nUnwind section "));
4694 if (string_table
== NULL
)
4695 printf ("%d", unwsec
->sh_name
);
4697 printf (_("'%s'"), SECTION_NAME (unwsec
));
4699 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4700 (unsigned long) unwsec
->sh_offset
,
4701 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
4703 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4705 if (aux
.table_len
> 0)
4706 dump_ia64_unwind (& aux
);
4709 free ((char *) aux
.table
);
4711 free ((char *) aux
.info
);
4720 free ((char *) aux
.strtab
);
4725 struct hppa_unw_aux_info
4727 struct hppa_unw_table_entry
4729 struct absaddr start
;
4731 unsigned int Cannot_unwind
:1; /* 0 */
4732 unsigned int Millicode
:1; /* 1 */
4733 unsigned int Millicode_save_sr0
:1; /* 2 */
4734 unsigned int Region_description
:2; /* 3..4 */
4735 unsigned int reserved1
:1; /* 5 */
4736 unsigned int Entry_SR
:1; /* 6 */
4737 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
4738 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
4739 unsigned int Args_stored
:1; /* 16 */
4740 unsigned int Variable_Frame
:1; /* 17 */
4741 unsigned int Separate_Package_Body
:1; /* 18 */
4742 unsigned int Frame_Extension_Millicode
:1; /* 19 */
4743 unsigned int Stack_Overflow_Check
:1; /* 20 */
4744 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
4745 unsigned int Ada_Region
:1; /* 22 */
4746 unsigned int cxx_info
:1; /* 23 */
4747 unsigned int cxx_try_catch
:1; /* 24 */
4748 unsigned int sched_entry_seq
:1; /* 25 */
4749 unsigned int reserved2
:1; /* 26 */
4750 unsigned int Save_SP
:1; /* 27 */
4751 unsigned int Save_RP
:1; /* 28 */
4752 unsigned int Save_MRP_in_frame
:1; /* 29 */
4753 unsigned int extn_ptr_defined
:1; /* 30 */
4754 unsigned int Cleanup_defined
:1; /* 31 */
4756 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
4757 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
4758 unsigned int Large_frame
:1; /* 2 */
4759 unsigned int Pseudo_SP_Set
:1; /* 3 */
4760 unsigned int reserved4
:1; /* 4 */
4761 unsigned int Total_frame_size
:27; /* 5..31 */
4763 *table
; /* Unwind table. */
4764 unsigned long table_len
; /* Length of unwind table. */
4765 bfd_vma seg_base
; /* Starting address of segment. */
4766 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4767 unsigned long nsyms
; /* Number of symbols. */
4768 char *strtab
; /* The string table. */
4769 unsigned long strtab_size
; /* Size of string table. */
4773 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
4775 struct hppa_unw_table_entry
*tp
;
4777 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4780 const char *procname
;
4782 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4783 aux
->strtab_size
, tp
->start
, &procname
,
4786 fputs ("\n<", stdout
);
4790 fputs (procname
, stdout
);
4793 printf ("+%lx", (unsigned long) offset
);
4796 fputs (">: [", stdout
);
4797 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4798 fputc ('-', stdout
);
4799 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4802 #define PF(_m) if (tp->_m) printf (#_m " ");
4803 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
4806 PF(Millicode_save_sr0
);
4807 /* PV(Region_description); */
4813 PF(Separate_Package_Body
);
4814 PF(Frame_Extension_Millicode
);
4815 PF(Stack_Overflow_Check
);
4816 PF(Two_Instruction_SP_Increment
);
4820 PF(sched_entry_seq
);
4823 PF(Save_MRP_in_frame
);
4824 PF(extn_ptr_defined
);
4825 PF(Cleanup_defined
);
4826 PF(MPE_XL_interrupt_marker
);
4827 PF(HP_UX_interrupt_marker
);
4830 PV(Total_frame_size
);
4839 slurp_hppa_unwind_table (FILE *file
,
4840 struct hppa_unw_aux_info
*aux
,
4841 Elf_Internal_Shdr
*sec
)
4843 unsigned long size
, unw_ent_size
, nrelas
, i
;
4844 Elf_Internal_Phdr
*seg
;
4845 struct hppa_unw_table_entry
*tep
;
4846 Elf_Internal_Shdr
*relsec
;
4847 Elf_Internal_Rela
*rela
, *rp
;
4848 unsigned char *table
, *tp
;
4849 Elf_Internal_Sym
*sym
;
4850 const char *relname
;
4852 /* First, find the starting address of the segment that includes
4855 if (elf_header
.e_phnum
)
4857 if (! get_program_headers (file
))
4860 for (seg
= program_headers
;
4861 seg
< program_headers
+ elf_header
.e_phnum
;
4864 if (seg
->p_type
!= PT_LOAD
)
4867 if (sec
->sh_addr
>= seg
->p_vaddr
4868 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4870 aux
->seg_base
= seg
->p_vaddr
;
4876 /* Second, build the unwind table from the contents of the unwind
4878 size
= sec
->sh_size
;
4879 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4883 unw_ent_size
= 2 * eh_addr_size
+ 8;
4885 tep
= aux
->table
= xmalloc (size
/ unw_ent_size
* sizeof (aux
->table
[0]));
4887 for (tp
= table
; tp
< table
+ size
; tp
+= (2 * eh_addr_size
+ 8), ++tep
)
4889 unsigned int tmp1
, tmp2
;
4891 tep
->start
.section
= SHN_UNDEF
;
4892 tep
->end
.section
= SHN_UNDEF
;
4896 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4897 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4898 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
4899 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
4903 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
4904 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
4905 tmp1
= byte_get ((unsigned char *) tp
+ 16, 4);
4906 tmp2
= byte_get ((unsigned char *) tp
+ 20, 4);
4909 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
4910 tep
->Millicode
= (tmp1
>> 30) & 0x1;
4911 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
4912 tep
->Region_description
= (tmp1
>> 27) & 0x3;
4913 tep
->reserved1
= (tmp1
>> 26) & 0x1;
4914 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
4915 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
4916 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
4917 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
4918 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
4919 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
4920 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
4921 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
4922 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
4923 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
4924 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
4925 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
4926 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
4927 tep
->reserved2
= (tmp1
>> 5) & 0x1;
4928 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
4929 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
4930 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
4931 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
4932 tep
->Cleanup_defined
= tmp1
& 0x1;
4934 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
4935 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
4936 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
4937 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
4938 tep
->reserved4
= (tmp2
>> 27) & 0x1;
4939 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
4941 tep
->start
.offset
+= aux
->seg_base
;
4942 tep
->end
.offset
+= aux
->seg_base
;
4946 /* Third, apply any relocations to the unwind table. */
4948 for (relsec
= section_headers
;
4949 relsec
< section_headers
+ elf_header
.e_shnum
;
4952 if (relsec
->sh_type
!= SHT_RELA
4953 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4956 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4960 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4964 relname
= elf_hppa_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4965 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4969 relname
= elf_hppa_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4970 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4973 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
4974 if (strncmp (relname
, "R_PARISC_SEGREL", 15) != 0)
4976 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4980 i
= rp
->r_offset
/ unw_ent_size
;
4982 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
4985 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4986 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
4989 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4990 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5000 aux
->table_len
= size
/ unw_ent_size
;
5006 hppa_process_unwind (FILE *file
)
5008 struct hppa_unw_aux_info aux
;
5009 Elf_Internal_Shdr
*unwsec
= NULL
;
5010 Elf_Internal_Shdr
*strsec
;
5011 Elf_Internal_Shdr
*sec
;
5014 memset (& aux
, 0, sizeof (aux
));
5016 assert (string_table
!= NULL
);
5018 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5020 if (sec
->sh_type
== SHT_SYMTAB
)
5022 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5023 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5025 strsec
= SECTION_HEADER (sec
->sh_link
);
5026 aux
.strtab_size
= strsec
->sh_size
;
5027 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5028 aux
.strtab_size
, _("string table"));
5030 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5035 printf (_("\nThere are no unwind sections in this file.\n"));
5037 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5039 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5041 printf (_("\nUnwind section "));
5042 printf (_("'%s'"), SECTION_NAME (sec
));
5044 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5045 (unsigned long) sec
->sh_offset
,
5046 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5048 slurp_hppa_unwind_table (file
, &aux
, sec
);
5049 if (aux
.table_len
> 0)
5050 dump_hppa_unwind (&aux
);
5053 free ((char *) aux
.table
);
5061 free ((char *) aux
.strtab
);
5067 process_unwind (FILE *file
)
5069 struct unwind_handler
{
5071 int (*handler
)(FILE *file
);
5073 { EM_IA_64
, ia64_process_unwind
},
5074 { EM_PARISC
, hppa_process_unwind
},
5082 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5083 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5084 return handlers
[i
].handler (file
);
5086 printf (_("\nThere are no unwind sections in this file.\n"));
5091 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5093 switch (entry
->d_tag
)
5096 if (entry
->d_un
.d_val
== 0)
5100 static const char * opts
[] =
5102 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5103 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5104 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5105 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5110 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
5111 if (entry
->d_un
.d_val
& (1 << cnt
))
5113 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5120 case DT_MIPS_IVERSION
:
5121 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5122 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5124 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5127 case DT_MIPS_TIME_STAMP
:
5132 time_t time
= entry
->d_un
.d_val
;
5133 tmp
= gmtime (&time
);
5134 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5135 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5136 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5137 printf ("Time Stamp: %s\n", timebuf
);
5141 case DT_MIPS_RLD_VERSION
:
5142 case DT_MIPS_LOCAL_GOTNO
:
5143 case DT_MIPS_CONFLICTNO
:
5144 case DT_MIPS_LIBLISTNO
:
5145 case DT_MIPS_SYMTABNO
:
5146 case DT_MIPS_UNREFEXTNO
:
5147 case DT_MIPS_HIPAGENO
:
5148 case DT_MIPS_DELTA_CLASS_NO
:
5149 case DT_MIPS_DELTA_INSTANCE_NO
:
5150 case DT_MIPS_DELTA_RELOC_NO
:
5151 case DT_MIPS_DELTA_SYM_NO
:
5152 case DT_MIPS_DELTA_CLASSSYM_NO
:
5153 case DT_MIPS_COMPACT_SIZE
:
5154 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5158 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5164 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5166 switch (entry
->d_tag
)
5168 case DT_HP_DLD_FLAGS
:
5177 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5178 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5179 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5180 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5181 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5182 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5183 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5184 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5185 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5186 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5187 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
5191 bfd_vma val
= entry
->d_un
.d_val
;
5193 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
5194 if (val
& flags
[cnt
].bit
)
5198 fputs (flags
[cnt
].str
, stdout
);
5200 val
^= flags
[cnt
].bit
;
5203 if (val
!= 0 || first
)
5207 print_vma (val
, HEX
);
5213 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5220 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5222 switch (entry
->d_tag
)
5224 case DT_IA_64_PLT_RESERVE
:
5225 /* First 3 slots reserved. */
5226 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5228 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5232 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5239 get_32bit_dynamic_section (FILE *file
)
5241 Elf32_External_Dyn
*edyn
, *ext
;
5242 Elf_Internal_Dyn
*entry
;
5244 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5245 _("dynamic section"));
5249 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5250 might not have the luxury of section headers. Look for the DT_NULL
5251 terminator to determine the number of entries. */
5252 for (ext
= edyn
, dynamic_nent
= 0;
5253 (char *) ext
< (char *) edyn
+ dynamic_size
;
5257 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5261 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5262 if (dynamic_section
== NULL
)
5264 error (_("Out of memory\n"));
5269 for (ext
= edyn
, entry
= dynamic_section
;
5270 entry
< dynamic_section
+ dynamic_nent
;
5273 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5274 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5283 get_64bit_dynamic_section (FILE *file
)
5285 Elf64_External_Dyn
*edyn
, *ext
;
5286 Elf_Internal_Dyn
*entry
;
5288 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
5289 _("dynamic section"));
5293 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5294 might not have the luxury of section headers. Look for the DT_NULL
5295 terminator to determine the number of entries. */
5296 for (ext
= edyn
, dynamic_nent
= 0;
5297 (char *) ext
< (char *) edyn
+ dynamic_size
;
5301 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5305 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
5306 if (dynamic_section
== NULL
)
5308 error (_("Out of memory\n"));
5313 for (ext
= edyn
, entry
= dynamic_section
;
5314 entry
< dynamic_section
+ dynamic_nent
;
5317 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5318 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5327 print_dynamic_flags (bfd_vma flags
)
5335 flag
= flags
& - flags
;
5345 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5346 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5347 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5348 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5349 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5350 default: fputs ("unknown", stdout
); break;
5356 /* Parse and display the contents of the dynamic section. */
5359 process_dynamic_section (FILE *file
)
5361 Elf_Internal_Dyn
*entry
;
5363 if (dynamic_size
== 0)
5366 printf (_("\nThere is no dynamic section in this file.\n"));
5373 if (! get_32bit_dynamic_section (file
))
5376 else if (! get_64bit_dynamic_section (file
))
5379 /* Find the appropriate symbol table. */
5380 if (dynamic_symbols
== NULL
)
5382 for (entry
= dynamic_section
;
5383 entry
< dynamic_section
+ dynamic_nent
;
5386 Elf_Internal_Shdr section
;
5388 if (entry
->d_tag
!= DT_SYMTAB
)
5391 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5393 /* Since we do not know how big the symbol table is,
5394 we default to reading in the entire file (!) and
5395 processing that. This is overkill, I know, but it
5397 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5399 if (archive_file_offset
!= 0)
5400 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5403 if (fseek (file
, 0, SEEK_END
))
5404 error (_("Unable to seek to end of file!"));
5406 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5410 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5412 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5414 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5415 if (num_dynamic_syms
< 1)
5417 error (_("Unable to determine the number of symbols to load\n"));
5421 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5425 /* Similarly find a string table. */
5426 if (dynamic_strings
== NULL
)
5428 for (entry
= dynamic_section
;
5429 entry
< dynamic_section
+ dynamic_nent
;
5432 unsigned long offset
;
5435 if (entry
->d_tag
!= DT_STRTAB
)
5438 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5440 /* Since we do not know how big the string table is,
5441 we default to reading in the entire file (!) and
5442 processing that. This is overkill, I know, but it
5445 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5447 if (archive_file_offset
!= 0)
5448 str_tab_len
= archive_file_size
- offset
;
5451 if (fseek (file
, 0, SEEK_END
))
5452 error (_("Unable to seek to end of file\n"));
5453 str_tab_len
= ftell (file
) - offset
;
5456 if (str_tab_len
< 1)
5459 (_("Unable to determine the length of the dynamic string table\n"));
5463 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
5464 _("dynamic string table"));
5465 dynamic_strings_length
= str_tab_len
;
5470 /* And find the syminfo section if available. */
5471 if (dynamic_syminfo
== NULL
)
5473 unsigned long syminsz
= 0;
5475 for (entry
= dynamic_section
;
5476 entry
< dynamic_section
+ dynamic_nent
;
5479 if (entry
->d_tag
== DT_SYMINENT
)
5481 /* Note: these braces are necessary to avoid a syntax
5482 error from the SunOS4 C compiler. */
5483 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5485 else if (entry
->d_tag
== DT_SYMINSZ
)
5486 syminsz
= entry
->d_un
.d_val
;
5487 else if (entry
->d_tag
== DT_SYMINFO
)
5488 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5492 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5494 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5495 Elf_Internal_Syminfo
*syminfo
;
5497 /* There is a syminfo section. Read the data. */
5498 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5499 _("symbol information"));
5503 dynamic_syminfo
= malloc (syminsz
);
5504 if (dynamic_syminfo
== NULL
)
5506 error (_("Out of memory\n"));
5510 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5511 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5512 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5513 ++syminfo
, ++extsym
)
5515 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5516 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5523 if (do_dynamic
&& dynamic_addr
)
5524 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5525 dynamic_addr
, dynamic_nent
);
5527 printf (_(" Tag Type Name/Value\n"));
5529 for (entry
= dynamic_section
;
5530 entry
< dynamic_section
+ dynamic_nent
;
5538 print_vma (entry
->d_tag
, FULL_HEX
);
5539 dtype
= get_dynamic_type (entry
->d_tag
);
5540 printf (" (%s)%*s", dtype
,
5541 ((is_32bit_elf
? 27 : 19)
5542 - (int) strlen (dtype
)),
5546 switch (entry
->d_tag
)
5550 print_dynamic_flags (entry
->d_un
.d_val
);
5560 switch (entry
->d_tag
)
5563 printf (_("Auxiliary library"));
5567 printf (_("Filter library"));
5571 printf (_("Configuration file"));
5575 printf (_("Dependency audit library"));
5579 printf (_("Audit library"));
5583 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5584 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5588 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5597 printf (_("Flags:"));
5599 if (entry
->d_un
.d_val
== 0)
5600 printf (_(" None\n"));
5603 unsigned long int val
= entry
->d_un
.d_val
;
5605 if (val
& DTF_1_PARINIT
)
5607 printf (" PARINIT");
5608 val
^= DTF_1_PARINIT
;
5610 if (val
& DTF_1_CONFEXP
)
5612 printf (" CONFEXP");
5613 val
^= DTF_1_CONFEXP
;
5616 printf (" %lx", val
);
5625 printf (_("Flags:"));
5627 if (entry
->d_un
.d_val
== 0)
5628 printf (_(" None\n"));
5631 unsigned long int val
= entry
->d_un
.d_val
;
5633 if (val
& DF_P1_LAZYLOAD
)
5635 printf (" LAZYLOAD");
5636 val
^= DF_P1_LAZYLOAD
;
5638 if (val
& DF_P1_GROUPPERM
)
5640 printf (" GROUPPERM");
5641 val
^= DF_P1_GROUPPERM
;
5644 printf (" %lx", val
);
5653 printf (_("Flags:"));
5654 if (entry
->d_un
.d_val
== 0)
5655 printf (_(" None\n"));
5658 unsigned long int val
= entry
->d_un
.d_val
;
5665 if (val
& DF_1_GLOBAL
)
5670 if (val
& DF_1_GROUP
)
5675 if (val
& DF_1_NODELETE
)
5677 printf (" NODELETE");
5678 val
^= DF_1_NODELETE
;
5680 if (val
& DF_1_LOADFLTR
)
5682 printf (" LOADFLTR");
5683 val
^= DF_1_LOADFLTR
;
5685 if (val
& DF_1_INITFIRST
)
5687 printf (" INITFIRST");
5688 val
^= DF_1_INITFIRST
;
5690 if (val
& DF_1_NOOPEN
)
5695 if (val
& DF_1_ORIGIN
)
5700 if (val
& DF_1_DIRECT
)
5705 if (val
& DF_1_TRANS
)
5710 if (val
& DF_1_INTERPOSE
)
5712 printf (" INTERPOSE");
5713 val
^= DF_1_INTERPOSE
;
5715 if (val
& DF_1_NODEFLIB
)
5717 printf (" NODEFLIB");
5718 val
^= DF_1_NODEFLIB
;
5720 if (val
& DF_1_NODUMP
)
5725 if (val
& DF_1_CONLFAT
)
5727 printf (" CONLFAT");
5728 val
^= DF_1_CONLFAT
;
5731 printf (" %lx", val
);
5738 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5740 puts (get_dynamic_type (entry
->d_un
.d_val
));
5760 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5766 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5767 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5773 switch (entry
->d_tag
)
5776 printf (_("Shared library: [%s]"), name
);
5778 if (streq (name
, program_interpreter
))
5779 printf (_(" program interpreter"));
5783 printf (_("Library soname: [%s]"), name
);
5787 printf (_("Library rpath: [%s]"), name
);
5791 printf (_("Library runpath: [%s]"), name
);
5795 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5800 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5813 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5817 case DT_INIT_ARRAYSZ
:
5818 case DT_FINI_ARRAYSZ
:
5819 case DT_GNU_CONFLICTSZ
:
5820 case DT_GNU_LIBLISTSZ
:
5823 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5824 printf (" (bytes)\n");
5834 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5847 if (entry
->d_tag
== DT_USED
5848 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5850 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
5854 printf (_("Not needed object: [%s]\n"), name
);
5859 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5865 /* The value of this entry is ignored. */
5870 case DT_GNU_PRELINKED
:
5874 time_t time
= entry
->d_un
.d_val
;
5876 tmp
= gmtime (&time
);
5877 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5878 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5879 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5885 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5886 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5891 switch (elf_header
.e_machine
)
5894 case EM_MIPS_RS3_LE
:
5895 dynamic_section_mips_val (entry
);
5898 dynamic_section_parisc_val (entry
);
5901 dynamic_section_ia64_val (entry
);
5904 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5916 get_ver_flags (unsigned int flags
)
5918 static char buff
[32];
5925 if (flags
& VER_FLG_BASE
)
5926 strcat (buff
, "BASE ");
5928 if (flags
& VER_FLG_WEAK
)
5930 if (flags
& VER_FLG_BASE
)
5931 strcat (buff
, "| ");
5933 strcat (buff
, "WEAK ");
5936 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5937 strcat (buff
, "| <unknown>");
5942 /* Display the contents of the version sections. */
5944 process_version_sections (FILE *file
)
5946 Elf_Internal_Shdr
*section
;
5953 for (i
= 0, section
= section_headers
;
5954 i
< elf_header
.e_shnum
;
5957 switch (section
->sh_type
)
5959 case SHT_GNU_verdef
:
5961 Elf_External_Verdef
*edefs
;
5968 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5969 SECTION_NAME (section
), section
->sh_info
);
5971 printf (_(" Addr: 0x"));
5972 printf_vma (section
->sh_addr
);
5973 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5974 (unsigned long) section
->sh_offset
, section
->sh_link
,
5975 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5977 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5978 _("version definition section"));
5982 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5985 Elf_External_Verdef
*edef
;
5986 Elf_Internal_Verdef ent
;
5987 Elf_External_Verdaux
*eaux
;
5988 Elf_Internal_Verdaux aux
;
5992 vstart
= ((char *) edefs
) + idx
;
5994 edef
= (Elf_External_Verdef
*) vstart
;
5996 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5997 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5998 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5999 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6000 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6001 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6002 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6004 printf (_(" %#06x: Rev: %d Flags: %s"),
6005 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6007 printf (_(" Index: %d Cnt: %d "),
6008 ent
.vd_ndx
, ent
.vd_cnt
);
6010 vstart
+= ent
.vd_aux
;
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 (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6020 printf (_("Name index: %ld\n"), aux
.vda_name
);
6022 isum
= idx
+ ent
.vd_aux
;
6024 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6026 isum
+= aux
.vda_next
;
6027 vstart
+= aux
.vda_next
;
6029 eaux
= (Elf_External_Verdaux
*) vstart
;
6031 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6032 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6034 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6035 printf (_(" %#06x: Parent %d: %s\n"),
6036 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6038 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6039 isum
, j
, aux
.vda_name
);
6049 case SHT_GNU_verneed
:
6051 Elf_External_Verneed
*eneed
;
6057 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6058 SECTION_NAME (section
), section
->sh_info
);
6060 printf (_(" Addr: 0x"));
6061 printf_vma (section
->sh_addr
);
6062 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6063 (unsigned long) section
->sh_offset
, section
->sh_link
,
6064 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
6066 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6067 _("version need section"));
6071 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6073 Elf_External_Verneed
*entry
;
6074 Elf_Internal_Verneed ent
;
6079 vstart
= ((char *) eneed
) + idx
;
6081 entry
= (Elf_External_Verneed
*) vstart
;
6083 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6084 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6085 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6086 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6087 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6089 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6091 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6092 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6094 printf (_(" File: %lx"), ent
.vn_file
);
6096 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6098 vstart
+= ent
.vn_aux
;
6100 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6102 Elf_External_Vernaux
*eaux
;
6103 Elf_Internal_Vernaux aux
;
6105 eaux
= (Elf_External_Vernaux
*) vstart
;
6107 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6108 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6109 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6110 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6111 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6113 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6114 printf (_(" %#06x: Name: %s"),
6115 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6117 printf (_(" %#06x: Name index: %lx"),
6118 isum
, aux
.vna_name
);
6120 printf (_(" Flags: %s Version: %d\n"),
6121 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6123 isum
+= aux
.vna_next
;
6124 vstart
+= aux
.vna_next
;
6134 case SHT_GNU_versym
:
6136 Elf_Internal_Shdr
*link_section
;
6139 unsigned char *edata
;
6140 unsigned short *data
;
6142 Elf_Internal_Sym
*symbols
;
6143 Elf_Internal_Shdr
*string_sec
;
6146 link_section
= SECTION_HEADER (section
->sh_link
);
6147 total
= section
->sh_size
/ section
->sh_entsize
;
6151 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6153 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6155 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6156 string_sec
->sh_size
, _("version string table"));
6160 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6161 SECTION_NAME (section
), total
);
6163 printf (_(" Addr: "));
6164 printf_vma (section
->sh_addr
);
6165 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6166 (unsigned long) section
->sh_offset
, section
->sh_link
,
6167 SECTION_NAME (link_section
));
6169 off
= offset_from_vma (file
,
6170 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6171 total
* sizeof (short));
6172 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
6173 _("version symbol data"));
6180 data
= malloc (total
* sizeof (short));
6182 for (cnt
= total
; cnt
--;)
6183 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6188 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6191 int check_def
, check_need
;
6194 printf (" %03x:", cnt
);
6196 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6197 switch (data
[cnt
+ j
])
6200 fputs (_(" 0 (*local*) "), stdout
);
6204 fputs (_(" 1 (*global*) "), stdout
);
6208 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6209 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6213 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6216 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6223 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6225 Elf_Internal_Verneed ivn
;
6226 unsigned long offset
;
6228 offset
= offset_from_vma
6229 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6230 sizeof (Elf_External_Verneed
));
6234 Elf_Internal_Vernaux ivna
;
6235 Elf_External_Verneed evn
;
6236 Elf_External_Vernaux evna
;
6237 unsigned long a_off
;
6239 get_data (&evn
, file
, offset
, sizeof (evn
),
6242 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6243 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6245 a_off
= offset
+ ivn
.vn_aux
;
6249 get_data (&evna
, file
, a_off
, sizeof (evna
),
6250 _("version need aux (2)"));
6252 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6253 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6255 a_off
+= ivna
.vna_next
;
6257 while (ivna
.vna_other
!= data
[cnt
+ j
]
6258 && ivna
.vna_next
!= 0);
6260 if (ivna
.vna_other
== data
[cnt
+ j
])
6262 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6264 name
= strtab
+ ivna
.vna_name
;
6265 nn
+= printf ("(%s%-*s",
6267 12 - (int) strlen (name
),
6273 offset
+= ivn
.vn_next
;
6275 while (ivn
.vn_next
);
6278 if (check_def
&& data
[cnt
+ j
] != 0x8001
6279 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6281 Elf_Internal_Verdef ivd
;
6282 Elf_External_Verdef evd
;
6283 unsigned long offset
;
6285 offset
= offset_from_vma
6286 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6291 get_data (&evd
, file
, offset
, sizeof (evd
),
6294 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6295 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6297 offset
+= ivd
.vd_next
;
6299 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6300 && ivd
.vd_next
!= 0);
6302 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6304 Elf_External_Verdaux evda
;
6305 Elf_Internal_Verdaux ivda
;
6307 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6309 get_data (&evda
, file
,
6310 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6311 sizeof (evda
), _("version def aux"));
6313 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6315 name
= strtab
+ ivda
.vda_name
;
6316 nn
+= printf ("(%s%-*s",
6318 12 - (int) strlen (name
),
6324 printf ("%*c", 18 - nn
, ' ');
6342 printf (_("\nNo version information found in this file.\n"));
6348 get_symbol_binding (unsigned int binding
)
6350 static char buff
[32];
6354 case STB_LOCAL
: return "LOCAL";
6355 case STB_GLOBAL
: return "GLOBAL";
6356 case STB_WEAK
: return "WEAK";
6358 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6359 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6361 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6362 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6364 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6370 get_symbol_type (unsigned int type
)
6372 static char buff
[32];
6376 case STT_NOTYPE
: return "NOTYPE";
6377 case STT_OBJECT
: return "OBJECT";
6378 case STT_FUNC
: return "FUNC";
6379 case STT_SECTION
: return "SECTION";
6380 case STT_FILE
: return "FILE";
6381 case STT_COMMON
: return "COMMON";
6382 case STT_TLS
: return "TLS";
6384 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6386 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6387 return "THUMB_FUNC";
6389 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6392 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6393 return "PARISC_MILLI";
6395 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6397 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6399 if (elf_header
.e_machine
== EM_PARISC
)
6401 if (type
== STT_HP_OPAQUE
)
6403 if (type
== STT_HP_STUB
)
6407 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6410 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6416 get_symbol_visibility (unsigned int visibility
)
6420 case STV_DEFAULT
: return "DEFAULT";
6421 case STV_INTERNAL
: return "INTERNAL";
6422 case STV_HIDDEN
: return "HIDDEN";
6423 case STV_PROTECTED
: return "PROTECTED";
6429 get_symbol_index_type (unsigned int type
)
6431 static char buff
[32];
6435 case SHN_UNDEF
: return "UND";
6436 case SHN_ABS
: return "ABS";
6437 case SHN_COMMON
: return "COM";
6439 if (type
== SHN_IA_64_ANSI_COMMON
6440 && elf_header
.e_machine
== EM_IA_64
6441 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
6443 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
6444 sprintf (buff
, "PRC[0x%04x]", type
);
6445 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
6446 sprintf (buff
, "OS [0x%04x]", type
);
6447 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
6448 sprintf (buff
, "RSV[0x%04x]", type
);
6450 sprintf (buff
, "%3d", type
);
6458 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
6460 unsigned char *e_data
;
6463 e_data
= malloc (number
* ent_size
);
6467 error (_("Out of memory\n"));
6471 if (fread (e_data
, ent_size
, number
, file
) != number
)
6473 error (_("Unable to read in dynamic data\n"));
6477 i_data
= malloc (number
* sizeof (*i_data
));
6481 error (_("Out of memory\n"));
6487 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
6494 /* Dump the symbol table. */
6496 process_symbol_table (FILE *file
)
6498 Elf_Internal_Shdr
*section
;
6499 bfd_vma nbuckets
= 0;
6500 bfd_vma nchains
= 0;
6501 bfd_vma
*buckets
= NULL
;
6502 bfd_vma
*chains
= NULL
;
6504 if (! do_syms
&& !do_histogram
)
6507 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6510 unsigned char nb
[8];
6511 unsigned char nc
[8];
6512 int hash_ent_size
= 4;
6514 if ((elf_header
.e_machine
== EM_ALPHA
6515 || elf_header
.e_machine
== EM_S390
6516 || elf_header
.e_machine
== EM_S390_OLD
)
6517 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
6521 (archive_file_offset
6522 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6523 sizeof nb
+ sizeof nc
)),
6526 error (_("Unable to seek to start of dynamic information"));
6530 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
6532 error (_("Failed to read in number of buckets\n"));
6536 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
6538 error (_("Failed to read in number of chains\n"));
6542 nbuckets
= byte_get (nb
, hash_ent_size
);
6543 nchains
= byte_get (nc
, hash_ent_size
);
6545 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
6546 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
6548 if (buckets
== NULL
|| chains
== NULL
)
6553 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6558 printf (_("\nSymbol table for image:\n"));
6560 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6562 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6564 for (hn
= 0; hn
< nbuckets
; hn
++)
6569 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6571 Elf_Internal_Sym
*psym
;
6574 psym
= dynamic_symbols
+ si
;
6576 n
= print_vma (si
, DEC_5
);
6578 fputs (" " + n
, stdout
);
6579 printf (" %3lu: ", hn
);
6580 print_vma (psym
->st_value
, LONG_HEX
);
6582 print_vma (psym
->st_size
, DEC_5
);
6584 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6585 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6586 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6587 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6588 if (VALID_DYNAMIC_NAME (psym
->st_name
))
6589 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
6591 printf (" <corrupt: %14ld>", psym
->st_name
);
6596 else if (do_syms
&& !do_using_dynamic
)
6600 for (i
= 0, section
= section_headers
;
6601 i
< elf_header
.e_shnum
;
6606 Elf_Internal_Sym
*symtab
;
6607 Elf_Internal_Sym
*psym
;
6610 if ( section
->sh_type
!= SHT_SYMTAB
6611 && section
->sh_type
!= SHT_DYNSYM
)
6614 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6615 SECTION_NAME (section
),
6616 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6618 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6620 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6622 symtab
= GET_ELF_SYMBOLS (file
, section
);
6626 if (section
->sh_link
== elf_header
.e_shstrndx
)
6627 strtab
= string_table
;
6630 Elf_Internal_Shdr
*string_sec
;
6632 string_sec
= SECTION_HEADER (section
->sh_link
);
6634 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6635 string_sec
->sh_size
, _("string table"));
6638 for (si
= 0, psym
= symtab
;
6639 si
< section
->sh_size
/ section
->sh_entsize
;
6642 printf ("%6d: ", si
);
6643 print_vma (psym
->st_value
, LONG_HEX
);
6645 print_vma (psym
->st_size
, DEC_5
);
6646 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6647 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6648 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6649 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6650 print_symbol (25, strtab
+ psym
->st_name
);
6652 if (section
->sh_type
== SHT_DYNSYM
&&
6653 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6655 unsigned char data
[2];
6656 unsigned short vers_data
;
6657 unsigned long offset
;
6661 offset
= offset_from_vma
6662 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6663 sizeof data
+ si
* sizeof (vers_data
));
6665 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6666 sizeof (data
), _("version data"));
6668 vers_data
= byte_get (data
, 2);
6670 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6673 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6675 if ((vers_data
& 0x8000) || vers_data
> 1)
6677 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6678 && (is_nobits
|| ! check_def
))
6680 Elf_External_Verneed evn
;
6681 Elf_Internal_Verneed ivn
;
6682 Elf_Internal_Vernaux ivna
;
6684 /* We must test both. */
6685 offset
= offset_from_vma
6686 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6691 unsigned long vna_off
;
6693 get_data (&evn
, file
, offset
, sizeof (evn
),
6696 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6697 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6699 vna_off
= offset
+ ivn
.vn_aux
;
6703 Elf_External_Vernaux evna
;
6705 get_data (&evna
, file
, vna_off
,
6707 _("version need aux (3)"));
6709 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6710 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6711 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6713 vna_off
+= ivna
.vna_next
;
6715 while (ivna
.vna_other
!= vers_data
6716 && ivna
.vna_next
!= 0);
6718 if (ivna
.vna_other
== vers_data
)
6721 offset
+= ivn
.vn_next
;
6723 while (ivn
.vn_next
!= 0);
6725 if (ivna
.vna_other
== vers_data
)
6728 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6731 else if (! is_nobits
)
6732 error (_("bad dynamic symbol"));
6739 if (vers_data
!= 0x8001
6740 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6742 Elf_Internal_Verdef ivd
;
6743 Elf_Internal_Verdaux ivda
;
6744 Elf_External_Verdaux evda
;
6745 unsigned long offset
;
6747 offset
= offset_from_vma
6749 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6750 sizeof (Elf_External_Verdef
));
6754 Elf_External_Verdef evd
;
6756 get_data (&evd
, file
, offset
, sizeof (evd
),
6759 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6760 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6761 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6763 offset
+= ivd
.vd_next
;
6765 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6766 && ivd
.vd_next
!= 0);
6768 offset
-= ivd
.vd_next
;
6769 offset
+= ivd
.vd_aux
;
6771 get_data (&evda
, file
, offset
, sizeof (evda
),
6772 _("version def aux"));
6774 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6776 if (psym
->st_name
!= ivda
.vda_name
)
6777 printf ((vers_data
& 0x8000)
6779 strtab
+ ivda
.vda_name
);
6789 if (strtab
!= string_table
)
6795 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6797 if (do_histogram
&& buckets
!= NULL
)
6799 unsigned long *lengths
;
6800 unsigned long *counts
;
6803 unsigned long maxlength
= 0;
6804 unsigned long nzero_counts
= 0;
6805 unsigned long nsyms
= 0;
6807 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
6808 (unsigned long) nbuckets
);
6809 printf (_(" Length Number %% of total Coverage\n"));
6811 lengths
= calloc (nbuckets
, sizeof (*lengths
));
6812 if (lengths
== NULL
)
6814 error (_("Out of memory"));
6817 for (hn
= 0; hn
< nbuckets
; ++hn
)
6819 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6822 if (maxlength
< ++lengths
[hn
])
6827 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
6830 error (_("Out of memory"));
6834 for (hn
= 0; hn
< nbuckets
; ++hn
)
6835 ++counts
[lengths
[hn
]];
6840 printf (" 0 %-10lu (%5.1f%%)\n",
6841 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6842 for (i
= 1; i
<= maxlength
; ++i
)
6844 nzero_counts
+= counts
[i
] * i
;
6845 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
6846 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
6847 (nzero_counts
* 100.0) / nsyms
);
6855 if (buckets
!= NULL
)
6865 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6869 if (dynamic_syminfo
== NULL
6871 /* No syminfo, this is ok. */
6874 /* There better should be a dynamic symbol section. */
6875 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6879 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6880 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6882 printf (_(" Num: Name BoundTo Flags\n"));
6883 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6885 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6887 printf ("%4d: ", i
);
6888 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
6889 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
6891 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
6894 switch (dynamic_syminfo
[i
].si_boundto
)
6896 case SYMINFO_BT_SELF
:
6897 fputs ("SELF ", stdout
);
6899 case SYMINFO_BT_PARENT
:
6900 fputs ("PARENT ", stdout
);
6903 if (dynamic_syminfo
[i
].si_boundto
> 0
6904 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
6905 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
6907 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6911 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6915 if (flags
& SYMINFO_FLG_DIRECT
)
6917 if (flags
& SYMINFO_FLG_PASSTHRU
)
6918 printf (" PASSTHRU");
6919 if (flags
& SYMINFO_FLG_COPY
)
6921 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6922 printf (" LAZYLOAD");
6930 #ifdef SUPPORT_DISASSEMBLY
6932 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6934 printf (_("\nAssembly dump of section %s\n"),
6935 SECTION_NAME (section
));
6937 /* XXX -- to be done --- XXX */
6944 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6946 bfd_size_type bytes
;
6948 unsigned char *data
;
6949 unsigned char *start
;
6951 bytes
= section
->sh_size
;
6953 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6955 printf (_("\nSection '%s' has no data to dump.\n"),
6956 SECTION_NAME (section
));
6960 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6962 addr
= section
->sh_addr
;
6964 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6976 lbytes
= (bytes
> 16 ? 16 : bytes
);
6978 printf (" 0x%8.8lx ", (unsigned long) addr
);
6980 switch (elf_header
.e_ident
[EI_DATA
])
6984 for (j
= 15; j
>= 0; j
--)
6987 printf ("%2.2x", data
[j
]);
6997 for (j
= 0; j
< 16; j
++)
7000 printf ("%2.2x", data
[j
]);
7010 for (j
= 0; j
< lbytes
; j
++)
7013 if (k
>= ' ' && k
< 0x7f)
7032 static unsigned long int
7033 read_leb128 (unsigned char *data
, unsigned int *length_return
, int sign
)
7035 unsigned long int result
= 0;
7036 unsigned int num_read
= 0;
7037 unsigned int shift
= 0;
7045 result
|= ((unsigned long int) (byte
& 0x7f)) << shift
;
7050 while (byte
& 0x80);
7052 if (length_return
!= NULL
)
7053 *length_return
= num_read
;
7055 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
7056 result
|= -1L << shift
;
7061 typedef struct State_Machine_Registers
7063 unsigned long address
;
7066 unsigned int column
;
7070 /* This variable hold the number of the last entry seen
7071 in the File Table. */
7072 unsigned int last_file_entry
;
7075 static SMR state_machine_regs
;
7078 reset_state_machine (int is_stmt
)
7080 state_machine_regs
.address
= 0;
7081 state_machine_regs
.file
= 1;
7082 state_machine_regs
.line
= 1;
7083 state_machine_regs
.column
= 0;
7084 state_machine_regs
.is_stmt
= is_stmt
;
7085 state_machine_regs
.basic_block
= 0;
7086 state_machine_regs
.end_sequence
= 0;
7087 state_machine_regs
.last_file_entry
= 0;
7090 /* Handled an extend line op. Returns true if this is the end
7094 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
7096 unsigned char op_code
;
7097 unsigned int bytes_read
;
7099 unsigned char *name
;
7102 len
= read_leb128 (data
, & bytes_read
, 0);
7107 warn (_("badly formed extended line op encountered!\n"));
7114 printf (_(" Extended opcode %d: "), op_code
);
7118 case DW_LNE_end_sequence
:
7119 printf (_("End of Sequence\n\n"));
7120 reset_state_machine (is_stmt
);
7123 case DW_LNE_set_address
:
7124 adr
= byte_get (data
, pointer_size
);
7125 printf (_("set Address to 0x%lx\n"), adr
);
7126 state_machine_regs
.address
= adr
;
7129 case DW_LNE_define_file
:
7130 printf (_(" define new File Table entry\n"));
7131 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
7133 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
7135 data
+= strlen ((char *) data
) + 1;
7136 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7138 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7140 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
7141 printf (_("%s\n\n"), name
);
7145 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
7152 static const char *debug_str_contents
;
7153 static bfd_vma debug_str_size
;
7156 load_debug_str (FILE *file
)
7158 Elf_Internal_Shdr
*sec
;
7160 /* If it is already loaded, do nothing. */
7161 if (debug_str_contents
!= NULL
)
7164 /* Locate the .debug_str section. */
7165 sec
= find_section (".debug_str");
7169 debug_str_size
= sec
->sh_size
;
7171 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7172 _("debug_str section data"));
7176 free_debug_str (void)
7178 if (debug_str_contents
== NULL
)
7181 free ((char *) debug_str_contents
);
7182 debug_str_contents
= NULL
;
7187 fetch_indirect_string (unsigned long offset
)
7189 if (debug_str_contents
== NULL
)
7190 return _("<no .debug_str section>");
7192 if (offset
> debug_str_size
)
7193 return _("<offset is too big>");
7195 return debug_str_contents
+ offset
;
7198 static const char *debug_loc_contents
;
7199 static bfd_vma debug_loc_size
;
7202 load_debug_loc (FILE *file
)
7204 Elf_Internal_Shdr
*sec
;
7206 /* If it is already loaded, do nothing. */
7207 if (debug_loc_contents
!= NULL
)
7210 /* Locate the .debug_loc section. */
7211 sec
= find_section (".debug_loc");
7215 debug_loc_size
= sec
->sh_size
;
7217 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7218 _("debug_loc section data"));
7222 free_debug_loc (void)
7224 if (debug_loc_contents
== NULL
)
7227 free ((char *) debug_loc_contents
);
7228 debug_loc_contents
= NULL
;
7232 static const char * debug_range_contents
;
7233 static unsigned long debug_range_size
;
7236 load_debug_range (FILE *file
)
7238 Elf_Internal_Shdr
*sec
;
7240 /* If it is already loaded, do nothing. */
7241 if (debug_range_contents
!= NULL
)
7244 /* Locate the .debug_str section. */
7245 sec
= find_section (".debug_ranges");
7249 debug_range_size
= sec
->sh_size
;
7251 debug_range_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7252 _("debug_range section data"));
7256 free_debug_range (void)
7258 if (debug_range_contents
== NULL
)
7261 free ((char *) debug_range_contents
);
7262 debug_range_contents
= NULL
;
7263 debug_range_size
= 0;
7266 /* Apply addends of RELA relocations. */
7269 debug_apply_rela_addends (FILE *file
,
7270 Elf_Internal_Shdr
*section
,
7272 unsigned char *sec_data
,
7273 unsigned char *start
,
7276 Elf_Internal_Shdr
*relsec
;
7278 if (end
- start
< reloc_size
)
7281 for (relsec
= section_headers
;
7282 relsec
< section_headers
+ elf_header
.e_shnum
;
7285 unsigned long nrelas
;
7286 Elf_Internal_Rela
*rela
, *rp
;
7287 Elf_Internal_Shdr
*symsec
;
7288 Elf_Internal_Sym
*symtab
;
7289 Elf_Internal_Sym
*sym
;
7291 if (relsec
->sh_type
!= SHT_RELA
7292 || SECTION_HEADER (relsec
->sh_info
) != section
7293 || relsec
->sh_size
== 0)
7296 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7300 symsec
= SECTION_HEADER (relsec
->sh_link
);
7301 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
7303 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7307 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
7308 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
7309 loc
= sec_data
+ rp
->r_offset
;
7315 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7317 if (ELF32_R_SYM (rp
->r_info
) != 0
7318 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
7319 /* Relocations against object symbols can happen,
7320 eg when referencing a global array. For an
7321 example of this see the _clz.o binary in libgcc.a. */
7322 && ELF32_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7324 warn (_("%s: skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7325 get_symbol_type (ELF32_ST_TYPE (sym
->st_info
)),
7326 SECTION_NAME (section
));
7332 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7334 if (ELF64_R_SYM (rp
->r_info
) != 0
7335 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
7336 && ELF64_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
7338 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7339 get_symbol_type (ELF64_ST_TYPE (sym
->st_info
)),
7340 SECTION_NAME (section
));
7345 byte_put (loc
, rp
->r_addend
, reloc_size
);
7355 /* FIXME: There are better and more efficient ways to handle
7356 these structures. For now though, I just want something that
7357 is simple to implement. */
7358 typedef struct abbrev_attr
7360 unsigned long attribute
;
7362 struct abbrev_attr
*next
;
7366 typedef struct abbrev_entry
7368 unsigned long entry
;
7371 struct abbrev_attr
*first_attr
;
7372 struct abbrev_attr
*last_attr
;
7373 struct abbrev_entry
*next
;
7377 static abbrev_entry
*first_abbrev
= NULL
;
7378 static abbrev_entry
*last_abbrev
= NULL
;
7383 abbrev_entry
*abbrev
;
7385 for (abbrev
= first_abbrev
; abbrev
;)
7387 abbrev_entry
*next
= abbrev
->next
;
7390 for (attr
= abbrev
->first_attr
; attr
;)
7392 abbrev_attr
*next
= attr
->next
;
7402 last_abbrev
= first_abbrev
= NULL
;
7406 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7408 abbrev_entry
*entry
;
7410 entry
= malloc (sizeof (*entry
));
7416 entry
->entry
= number
;
7418 entry
->children
= children
;
7419 entry
->first_attr
= NULL
;
7420 entry
->last_attr
= NULL
;
7423 if (first_abbrev
== NULL
)
7424 first_abbrev
= entry
;
7426 last_abbrev
->next
= entry
;
7428 last_abbrev
= entry
;
7432 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7436 attr
= malloc (sizeof (*attr
));
7442 attr
->attribute
= attribute
;
7446 if (last_abbrev
->first_attr
== NULL
)
7447 last_abbrev
->first_attr
= attr
;
7449 last_abbrev
->last_attr
->next
= attr
;
7451 last_abbrev
->last_attr
= attr
;
7454 /* Processes the (partial) contents of a .debug_abbrev section.
7455 Returns NULL if the end of the section was encountered.
7456 Returns the address after the last byte read if the end of
7457 an abbreviation set was found. */
7459 static unsigned char *
7460 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7462 if (first_abbrev
!= NULL
)
7467 unsigned int bytes_read
;
7468 unsigned long entry
;
7470 unsigned long attribute
;
7473 entry
= read_leb128 (start
, & bytes_read
, 0);
7474 start
+= bytes_read
;
7476 /* A single zero is supposed to end the section according
7477 to the standard. If there's more, then signal that to
7480 return start
== end
? NULL
: start
;
7482 tag
= read_leb128 (start
, & bytes_read
, 0);
7483 start
+= bytes_read
;
7485 children
= *start
++;
7487 add_abbrev (entry
, tag
, children
);
7493 attribute
= read_leb128 (start
, & bytes_read
, 0);
7494 start
+= bytes_read
;
7496 form
= read_leb128 (start
, & bytes_read
, 0);
7497 start
+= bytes_read
;
7500 add_abbrev_attr (attribute
, form
);
7502 while (attribute
!= 0);
7509 get_TAG_name (unsigned long tag
)
7513 case DW_TAG_padding
: return "DW_TAG_padding";
7514 case DW_TAG_array_type
: return "DW_TAG_array_type";
7515 case DW_TAG_class_type
: return "DW_TAG_class_type";
7516 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7517 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7518 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7519 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7520 case DW_TAG_label
: return "DW_TAG_label";
7521 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7522 case DW_TAG_member
: return "DW_TAG_member";
7523 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7524 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7525 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7526 case DW_TAG_string_type
: return "DW_TAG_string_type";
7527 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7528 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7529 case DW_TAG_typedef
: return "DW_TAG_typedef";
7530 case DW_TAG_union_type
: return "DW_TAG_union_type";
7531 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7532 case DW_TAG_variant
: return "DW_TAG_variant";
7533 case DW_TAG_common_block
: return "DW_TAG_common_block";
7534 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7535 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7536 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7537 case DW_TAG_module
: return "DW_TAG_module";
7538 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7539 case DW_TAG_set_type
: return "DW_TAG_set_type";
7540 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7541 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7542 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7543 case DW_TAG_base_type
: return "DW_TAG_base_type";
7544 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7545 case DW_TAG_const_type
: return "DW_TAG_const_type";
7546 case DW_TAG_constant
: return "DW_TAG_constant";
7547 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7548 case DW_TAG_file_type
: return "DW_TAG_file_type";
7549 case DW_TAG_friend
: return "DW_TAG_friend";
7550 case DW_TAG_namelist
: return "DW_TAG_namelist";
7551 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7552 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7553 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7554 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7555 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7556 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7557 case DW_TAG_try_block
: return "DW_TAG_try_block";
7558 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7559 case DW_TAG_variable
: return "DW_TAG_variable";
7560 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7561 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7562 case DW_TAG_format_label
: return "DW_TAG_format_label";
7563 case DW_TAG_function_template
: return "DW_TAG_function_template";
7564 case DW_TAG_class_template
: return "DW_TAG_class_template";
7565 /* DWARF 2.1 values. */
7566 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7567 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7568 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7569 case DW_TAG_namespace
: return "DW_TAG_namespace";
7570 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7571 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7572 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7573 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7575 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7576 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7577 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7580 static char buffer
[100];
7582 snprintf (buffer
, sizeof (buffer
), _("Unknown TAG value: %lx"), tag
);
7589 get_FORM_name (unsigned long form
)
7593 case DW_FORM_addr
: return "DW_FORM_addr";
7594 case DW_FORM_block2
: return "DW_FORM_block2";
7595 case DW_FORM_block4
: return "DW_FORM_block4";
7596 case DW_FORM_data2
: return "DW_FORM_data2";
7597 case DW_FORM_data4
: return "DW_FORM_data4";
7598 case DW_FORM_data8
: return "DW_FORM_data8";
7599 case DW_FORM_string
: return "DW_FORM_string";
7600 case DW_FORM_block
: return "DW_FORM_block";
7601 case DW_FORM_block1
: return "DW_FORM_block1";
7602 case DW_FORM_data1
: return "DW_FORM_data1";
7603 case DW_FORM_flag
: return "DW_FORM_flag";
7604 case DW_FORM_sdata
: return "DW_FORM_sdata";
7605 case DW_FORM_strp
: return "DW_FORM_strp";
7606 case DW_FORM_udata
: return "DW_FORM_udata";
7607 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7608 case DW_FORM_ref1
: return "DW_FORM_ref1";
7609 case DW_FORM_ref2
: return "DW_FORM_ref2";
7610 case DW_FORM_ref4
: return "DW_FORM_ref4";
7611 case DW_FORM_ref8
: return "DW_FORM_ref8";
7612 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7613 case DW_FORM_indirect
: return "DW_FORM_indirect";
7616 static char buffer
[100];
7618 snprintf (buffer
, sizeof (buffer
), _("Unknown FORM value: %lx"), form
);
7624 static unsigned char *
7625 display_block (unsigned char *data
, unsigned long length
)
7627 printf (_(" %lu byte block: "), length
);
7630 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7636 decode_location_expression (unsigned char * data
,
7637 unsigned int pointer_size
,
7638 unsigned long length
,
7639 unsigned long cu_offset
)
7642 unsigned int bytes_read
;
7643 unsigned long uvalue
;
7644 unsigned char *end
= data
+ length
;
7645 int need_frame_base
= 0;
7654 printf ("DW_OP_addr: %lx",
7655 (unsigned long) byte_get (data
, pointer_size
));
7656 data
+= pointer_size
;
7659 printf ("DW_OP_deref");
7662 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7665 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7668 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7672 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7676 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7680 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7684 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7685 (unsigned long) byte_get (data
+ 4, 4));
7689 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7690 (long) byte_get (data
+ 4, 4));
7694 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7698 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7702 printf ("DW_OP_dup");
7705 printf ("DW_OP_drop");
7708 printf ("DW_OP_over");
7711 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7714 printf ("DW_OP_swap");
7717 printf ("DW_OP_rot");
7720 printf ("DW_OP_xderef");
7723 printf ("DW_OP_abs");
7726 printf ("DW_OP_and");
7729 printf ("DW_OP_div");
7732 printf ("DW_OP_minus");
7735 printf ("DW_OP_mod");
7738 printf ("DW_OP_mul");
7741 printf ("DW_OP_neg");
7744 printf ("DW_OP_not");
7747 printf ("DW_OP_or");
7750 printf ("DW_OP_plus");
7752 case DW_OP_plus_uconst
:
7753 printf ("DW_OP_plus_uconst: %lu",
7754 read_leb128 (data
, &bytes_read
, 0));
7758 printf ("DW_OP_shl");
7761 printf ("DW_OP_shr");
7764 printf ("DW_OP_shra");
7767 printf ("DW_OP_xor");
7770 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7774 printf ("DW_OP_eq");
7777 printf ("DW_OP_ge");
7780 printf ("DW_OP_gt");
7783 printf ("DW_OP_le");
7786 printf ("DW_OP_lt");
7789 printf ("DW_OP_ne");
7792 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7828 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7863 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7898 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7899 read_leb128 (data
, &bytes_read
, 1));
7904 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7908 need_frame_base
= 1;
7909 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7913 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7915 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7916 read_leb128 (data
, &bytes_read
, 1));
7920 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7923 case DW_OP_deref_size
:
7924 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7926 case DW_OP_xderef_size
:
7927 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7930 printf ("DW_OP_nop");
7933 /* DWARF 3 extensions. */
7934 case DW_OP_push_object_address
:
7935 printf ("DW_OP_push_object_address");
7938 /* XXX: Strictly speaking for 64-bit DWARF3 files
7939 this ought to be an 8-byte wide computation. */
7940 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2) + cu_offset
);
7944 /* XXX: Strictly speaking for 64-bit DWARF3 files
7945 this ought to be an 8-byte wide computation. */
7946 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4) + cu_offset
);
7949 case DW_OP_call_ref
:
7950 printf ("DW_OP_call_ref");
7953 /* GNU extensions. */
7954 case DW_OP_GNU_push_tls_address
:
7955 printf ("DW_OP_GNU_push_tls_address");
7959 if (op
>= DW_OP_lo_user
7960 && op
<= DW_OP_hi_user
)
7961 printf (_("(User defined location op)"));
7963 printf (_("(Unknown location op)"));
7964 /* No way to tell where the next op is, so just bail. */
7965 return need_frame_base
;
7968 /* Separate the ops. */
7973 return need_frame_base
;
7976 /* This structure records the information that
7977 we extract from the.debug_info section. */
7980 unsigned int pointer_size
;
7981 unsigned long cu_offset
;
7982 unsigned long base_address
;
7983 /* This is an array of offsets to the location list table. */
7984 unsigned long *loc_offsets
;
7985 int *have_frame_base
;
7986 unsigned int num_loc_offsets
;
7987 unsigned int max_loc_offsets
;
7988 unsigned long *range_lists
;
7989 unsigned int num_range_lists
;
7990 unsigned int max_range_lists
;
7994 static debug_info
* debug_information
= NULL
;
7995 static unsigned int num_debug_info_entries
= 0;
7996 static unsigned int last_pointer_size
= 0;
7997 static int warned_about_missing_comp_units
= FALSE
;
7999 static unsigned char *
8000 read_and_display_attr_value (unsigned long attribute
,
8002 unsigned char *data
,
8003 unsigned long cu_offset
,
8004 unsigned long pointer_size
,
8005 unsigned long offset_size
,
8007 debug_info
*debug_info_p
,
8010 unsigned long uvalue
= 0;
8011 unsigned char *block_start
= NULL
;
8012 unsigned int bytes_read
;
8019 case DW_FORM_ref_addr
:
8020 if (dwarf_version
== 2)
8022 uvalue
= byte_get (data
, pointer_size
);
8023 data
+= pointer_size
;
8025 else if (dwarf_version
== 3)
8027 uvalue
= byte_get (data
, offset_size
);
8028 data
+= offset_size
;
8032 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8037 uvalue
= byte_get (data
, pointer_size
);
8038 data
+= pointer_size
;
8042 uvalue
= byte_get (data
, offset_size
);
8043 data
+= offset_size
;
8049 uvalue
= byte_get (data
++, 1);
8054 uvalue
= byte_get (data
, 2);
8060 uvalue
= byte_get (data
, 4);
8065 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8069 case DW_FORM_ref_udata
:
8071 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8075 case DW_FORM_indirect
:
8076 form
= read_leb128 (data
, & bytes_read
, 0);
8079 printf (" %s", get_FORM_name (form
));
8080 return read_and_display_attr_value (attribute
, form
, data
,
8081 cu_offset
, pointer_size
,
8082 offset_size
, dwarf_version
,
8083 debug_info_p
, do_loc
);
8088 case DW_FORM_ref_addr
:
8090 printf (" <#%lx>", uvalue
);
8096 case DW_FORM_ref_udata
:
8098 printf (" <%lx>", uvalue
+ cu_offset
);
8104 printf (" %#lx", uvalue
);
8113 printf (" %ld", uvalue
);
8120 uvalue
= byte_get (data
, 4);
8121 printf (" %lx", uvalue
);
8122 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8124 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8125 && num_debug_info_entries
== 0)
8127 if (sizeof (uvalue
) == 8)
8128 uvalue
= byte_get (data
, 8);
8130 error (_("DW_FORM_data8 is unsupported when sizeof (unsigned long) != 8\n"));
8135 case DW_FORM_string
:
8137 printf (" %s", data
);
8138 data
+= strlen ((char *) data
) + 1;
8142 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8143 block_start
= data
+ bytes_read
;
8145 data
= block_start
+ uvalue
;
8147 data
= display_block (block_start
, uvalue
);
8150 case DW_FORM_block1
:
8151 uvalue
= byte_get (data
, 1);
8152 block_start
= data
+ 1;
8154 data
= block_start
+ uvalue
;
8156 data
= display_block (block_start
, uvalue
);
8159 case DW_FORM_block2
:
8160 uvalue
= byte_get (data
, 2);
8161 block_start
= data
+ 2;
8163 data
= block_start
+ uvalue
;
8165 data
= display_block (block_start
, uvalue
);
8168 case DW_FORM_block4
:
8169 uvalue
= byte_get (data
, 4);
8170 block_start
= data
+ 4;
8172 data
= block_start
+ uvalue
;
8174 data
= display_block (block_start
, uvalue
);
8179 printf (_(" (indirect string, offset: 0x%lx): %s"),
8180 uvalue
, fetch_indirect_string (uvalue
));
8183 case DW_FORM_indirect
:
8184 /* Handled above. */
8188 warn (_("Unrecognized form: %d\n"), form
);
8192 /* For some attributes we can display further information. */
8193 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8194 && num_debug_info_entries
== 0)
8198 case DW_AT_frame_base
:
8199 have_frame_base
= 1;
8200 case DW_AT_location
:
8201 case DW_AT_data_member_location
:
8202 case DW_AT_vtable_elem_location
:
8203 case DW_AT_allocated
:
8204 case DW_AT_associated
:
8205 case DW_AT_data_location
:
8207 case DW_AT_upper_bound
:
8208 case DW_AT_lower_bound
:
8209 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8211 /* Process location list. */
8212 unsigned int max
= debug_info_p
->max_loc_offsets
;
8213 unsigned int num
= debug_info_p
->num_loc_offsets
;
8215 if (max
== 0 || num
>= max
)
8218 debug_info_p
->loc_offsets
8219 = xrealloc (debug_info_p
->loc_offsets
,
8220 max
* sizeof (*debug_info_p
->loc_offsets
));
8221 debug_info_p
->have_frame_base
8222 = xrealloc (debug_info_p
->have_frame_base
,
8223 max
* sizeof (*debug_info_p
->have_frame_base
));
8224 debug_info_p
->max_loc_offsets
= max
;
8226 debug_info_p
->loc_offsets
[num
] = uvalue
;
8227 debug_info_p
->have_frame_base
[num
] = have_frame_base
;
8228 debug_info_p
->num_loc_offsets
++;
8233 if (need_base_address
)
8234 debug_info_p
->base_address
= uvalue
;
8238 if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8240 /* Process range list. */
8241 unsigned int max
= debug_info_p
->max_range_lists
;
8242 unsigned int num
= debug_info_p
->num_range_lists
;
8244 if (max
== 0 || num
>= max
)
8247 debug_info_p
->range_lists
8248 = xrealloc (debug_info_p
->range_lists
,
8249 max
* sizeof (*debug_info_p
->range_lists
));
8250 debug_info_p
->max_range_lists
= max
;
8252 debug_info_p
->range_lists
[num
] = uvalue
;
8253 debug_info_p
->num_range_lists
++;
8272 case DW_INL_not_inlined
:
8273 printf (_("(not inlined)"));
8275 case DW_INL_inlined
:
8276 printf (_("(inlined)"));
8278 case DW_INL_declared_not_inlined
:
8279 printf (_("(declared as inline but ignored)"));
8281 case DW_INL_declared_inlined
:
8282 printf (_("(declared as inline and inlined)"));
8285 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8290 case DW_AT_language
:
8293 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8294 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8295 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8296 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8297 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8298 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8299 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8300 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8301 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8302 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8303 /* DWARF 2.1 values. */
8304 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8305 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8306 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8307 /* MIPS extension. */
8308 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8309 /* UPC extension. */
8310 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8312 printf ("(Unknown: %lx)", uvalue
);
8317 case DW_AT_encoding
:
8320 case DW_ATE_void
: printf ("(void)"); break;
8321 case DW_ATE_address
: printf ("(machine address)"); break;
8322 case DW_ATE_boolean
: printf ("(boolean)"); break;
8323 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8324 case DW_ATE_float
: printf ("(float)"); break;
8325 case DW_ATE_signed
: printf ("(signed)"); break;
8326 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8327 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8328 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8329 /* DWARF 2.1 value. */
8330 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8332 if (uvalue
>= DW_ATE_lo_user
8333 && uvalue
<= DW_ATE_hi_user
)
8334 printf ("(user defined type)");
8336 printf ("(unknown type)");
8341 case DW_AT_accessibility
:
8344 case DW_ACCESS_public
: printf ("(public)"); break;
8345 case DW_ACCESS_protected
: printf ("(protected)"); break;
8346 case DW_ACCESS_private
: printf ("(private)"); break;
8348 printf ("(unknown accessibility)");
8353 case DW_AT_visibility
:
8356 case DW_VIS_local
: printf ("(local)"); break;
8357 case DW_VIS_exported
: printf ("(exported)"); break;
8358 case DW_VIS_qualified
: printf ("(qualified)"); break;
8359 default: printf ("(unknown visibility)"); break;
8363 case DW_AT_virtuality
:
8366 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8367 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8368 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8369 default: printf ("(unknown virtuality)"); break;
8373 case DW_AT_identifier_case
:
8376 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8377 case DW_ID_up_case
: printf ("(up_case)"); break;
8378 case DW_ID_down_case
: printf ("(down_case)"); break;
8379 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8380 default: printf ("(unknown case)"); break;
8384 case DW_AT_calling_convention
:
8387 case DW_CC_normal
: printf ("(normal)"); break;
8388 case DW_CC_program
: printf ("(program)"); break;
8389 case DW_CC_nocall
: printf ("(nocall)"); break;
8391 if (uvalue
>= DW_CC_lo_user
8392 && uvalue
<= DW_CC_hi_user
)
8393 printf ("(user defined)");
8395 printf ("(unknown convention)");
8399 case DW_AT_ordering
:
8402 case -1: printf ("(undefined)"); break;
8403 case 0: printf ("(row major)"); break;
8404 case 1: printf ("(column major)"); break;
8408 case DW_AT_frame_base
:
8409 have_frame_base
= 1;
8410 case DW_AT_location
:
8411 case DW_AT_data_member_location
:
8412 case DW_AT_vtable_elem_location
:
8413 case DW_AT_allocated
:
8414 case DW_AT_associated
:
8415 case DW_AT_data_location
:
8417 case DW_AT_upper_bound
:
8418 case DW_AT_lower_bound
:
8421 int need_frame_base
;
8424 need_frame_base
= decode_location_expression (block_start
,
8429 if (need_frame_base
&& !have_frame_base
)
8430 printf (_(" [without DW_AT_frame_base]"));
8432 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8433 printf (_("(location list)"));
8445 get_AT_name (unsigned long attribute
)
8449 case DW_AT_sibling
: return "DW_AT_sibling";
8450 case DW_AT_location
: return "DW_AT_location";
8451 case DW_AT_name
: return "DW_AT_name";
8452 case DW_AT_ordering
: return "DW_AT_ordering";
8453 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
8454 case DW_AT_byte_size
: return "DW_AT_byte_size";
8455 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
8456 case DW_AT_bit_size
: return "DW_AT_bit_size";
8457 case DW_AT_element_list
: return "DW_AT_element_list";
8458 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
8459 case DW_AT_low_pc
: return "DW_AT_low_pc";
8460 case DW_AT_high_pc
: return "DW_AT_high_pc";
8461 case DW_AT_language
: return "DW_AT_language";
8462 case DW_AT_member
: return "DW_AT_member";
8463 case DW_AT_discr
: return "DW_AT_discr";
8464 case DW_AT_discr_value
: return "DW_AT_discr_value";
8465 case DW_AT_visibility
: return "DW_AT_visibility";
8466 case DW_AT_import
: return "DW_AT_import";
8467 case DW_AT_string_length
: return "DW_AT_string_length";
8468 case DW_AT_common_reference
: return "DW_AT_common_reference";
8469 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
8470 case DW_AT_const_value
: return "DW_AT_const_value";
8471 case DW_AT_containing_type
: return "DW_AT_containing_type";
8472 case DW_AT_default_value
: return "DW_AT_default_value";
8473 case DW_AT_inline
: return "DW_AT_inline";
8474 case DW_AT_is_optional
: return "DW_AT_is_optional";
8475 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
8476 case DW_AT_producer
: return "DW_AT_producer";
8477 case DW_AT_prototyped
: return "DW_AT_prototyped";
8478 case DW_AT_return_addr
: return "DW_AT_return_addr";
8479 case DW_AT_start_scope
: return "DW_AT_start_scope";
8480 case DW_AT_stride_size
: return "DW_AT_stride_size";
8481 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
8482 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
8483 case DW_AT_accessibility
: return "DW_AT_accessibility";
8484 case DW_AT_address_class
: return "DW_AT_address_class";
8485 case DW_AT_artificial
: return "DW_AT_artificial";
8486 case DW_AT_base_types
: return "DW_AT_base_types";
8487 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
8488 case DW_AT_count
: return "DW_AT_count";
8489 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
8490 case DW_AT_decl_column
: return "DW_AT_decl_column";
8491 case DW_AT_decl_file
: return "DW_AT_decl_file";
8492 case DW_AT_decl_line
: return "DW_AT_decl_line";
8493 case DW_AT_declaration
: return "DW_AT_declaration";
8494 case DW_AT_discr_list
: return "DW_AT_discr_list";
8495 case DW_AT_encoding
: return "DW_AT_encoding";
8496 case DW_AT_external
: return "DW_AT_external";
8497 case DW_AT_frame_base
: return "DW_AT_frame_base";
8498 case DW_AT_friend
: return "DW_AT_friend";
8499 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
8500 case DW_AT_macro_info
: return "DW_AT_macro_info";
8501 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
8502 case DW_AT_priority
: return "DW_AT_priority";
8503 case DW_AT_segment
: return "DW_AT_segment";
8504 case DW_AT_specification
: return "DW_AT_specification";
8505 case DW_AT_static_link
: return "DW_AT_static_link";
8506 case DW_AT_type
: return "DW_AT_type";
8507 case DW_AT_use_location
: return "DW_AT_use_location";
8508 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
8509 case DW_AT_virtuality
: return "DW_AT_virtuality";
8510 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
8511 /* DWARF 2.1 values. */
8512 case DW_AT_allocated
: return "DW_AT_allocated";
8513 case DW_AT_associated
: return "DW_AT_associated";
8514 case DW_AT_data_location
: return "DW_AT_data_location";
8515 case DW_AT_stride
: return "DW_AT_stride";
8516 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
8517 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
8518 case DW_AT_extension
: return "DW_AT_extension";
8519 case DW_AT_ranges
: return "DW_AT_ranges";
8520 case DW_AT_trampoline
: return "DW_AT_trampoline";
8521 case DW_AT_call_column
: return "DW_AT_call_column";
8522 case DW_AT_call_file
: return "DW_AT_call_file";
8523 case DW_AT_call_line
: return "DW_AT_call_line";
8524 /* SGI/MIPS extensions. */
8525 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
8526 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
8527 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
8528 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
8529 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
8530 case DW_AT_MIPS_software_pipeline_depth
:
8531 return "DW_AT_MIPS_software_pipeline_depth";
8532 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
8533 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
8534 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
8535 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
8536 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
8537 /* GNU extensions. */
8538 case DW_AT_sf_names
: return "DW_AT_sf_names";
8539 case DW_AT_src_info
: return "DW_AT_src_info";
8540 case DW_AT_mac_info
: return "DW_AT_mac_info";
8541 case DW_AT_src_coords
: return "DW_AT_src_coords";
8542 case DW_AT_body_begin
: return "DW_AT_body_begin";
8543 case DW_AT_body_end
: return "DW_AT_body_end";
8544 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
8545 /* UPC extension. */
8546 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
8549 static char buffer
[100];
8551 snprintf (buffer
, sizeof (buffer
), _("Unknown AT value: %lx"),
8558 static unsigned char *
8559 read_and_display_attr (unsigned long attribute
,
8561 unsigned char *data
,
8562 unsigned long cu_offset
,
8563 unsigned long pointer_size
,
8564 unsigned long offset_size
,
8566 debug_info
*debug_info_p
,
8570 printf (" %-18s:", get_AT_name (attribute
));
8571 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8572 pointer_size
, offset_size
,
8573 dwarf_version
, debug_info_p
,
8581 /* Process the contents of a .debug_info section. If do_loc is non-zero
8582 then we are scanning for location lists and we do not want to display
8583 anything to the user. */
8586 process_debug_info (Elf_Internal_Shdr
*section
, unsigned char *start
,
8587 FILE *file
, int do_loc
)
8589 unsigned char *end
= start
+ section
->sh_size
;
8590 unsigned char *section_begin
;
8592 unsigned int num_units
= 0;
8594 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8595 && num_debug_info_entries
== 0)
8597 unsigned long length
;
8599 /* First scan the section to get the number of comp units. */
8600 for (section_begin
= start
, num_units
= 0; section_begin
< end
;
8603 /* Read the first 4 bytes. For a 32-bit DWARF section, this
8604 will be the length. For a 64-bit DWARF section, it'll be
8605 the escape code 0xffffffff followed by an 8 byte length. */
8606 length
= byte_get (section_begin
, 4);
8608 if (length
== 0xffffffff)
8610 length
= byte_get (section_begin
+ 4, 8);
8611 section_begin
+= length
+ 12;
8614 section_begin
+= length
+ 4;
8619 error (_("No comp units in .debug_info section ?"));
8623 /* Then allocate an array to hold the information. */
8624 debug_information
= malloc (num_units
*
8625 sizeof (* debug_information
));
8626 if (debug_information
== NULL
)
8628 error (_("Not enough memory for a debug info array of %u entries"),
8636 printf (_("The section %s contains:\n\n"),
8637 SECTION_NAME (section
));
8639 load_debug_str (file
);
8640 load_debug_loc (file
);
8641 load_debug_range (file
);
8644 for (section_begin
= start
, unit
= 0; start
< end
; unit
++)
8646 DWARF2_Internal_CompUnit compunit
;
8647 unsigned char *hdrptr
;
8648 unsigned char *cu_abbrev_offset_ptr
;
8649 unsigned char *tags
;
8651 unsigned long cu_offset
;
8653 int initial_length_size
;
8657 compunit
.cu_length
= byte_get (hdrptr
, 4);
8660 if (compunit
.cu_length
== 0xffffffff)
8662 compunit
.cu_length
= byte_get (hdrptr
, 8);
8665 initial_length_size
= 12;
8670 initial_length_size
= 4;
8673 compunit
.cu_version
= byte_get (hdrptr
, 2);
8676 cu_offset
= start
- section_begin
;
8677 start
+= compunit
.cu_length
+ initial_length_size
;
8679 if (elf_header
.e_type
== ET_REL
8680 && !debug_apply_rela_addends (file
, section
, offset_size
,
8681 section_begin
, hdrptr
, start
))
8684 cu_abbrev_offset_ptr
= hdrptr
;
8685 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8686 hdrptr
+= offset_size
;
8688 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8690 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8691 && num_debug_info_entries
== 0)
8693 debug_information
[unit
].cu_offset
= cu_offset
;
8694 debug_information
[unit
].pointer_size
8695 = compunit
.cu_pointer_size
;
8696 debug_information
[unit
].base_address
= 0;
8697 debug_information
[unit
].loc_offsets
= NULL
;
8698 debug_information
[unit
].have_frame_base
= NULL
;
8699 debug_information
[unit
].max_loc_offsets
= 0;
8700 debug_information
[unit
].num_loc_offsets
= 0;
8701 debug_information
[unit
].range_lists
= NULL
;
8702 debug_information
[unit
].max_range_lists
= 0;
8703 debug_information
[unit
].num_range_lists
= 0;
8710 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8711 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8712 printf (_(" Version: %d\n"), compunit
.cu_version
);
8713 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8714 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8717 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8719 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8725 /* Read in the abbrevs used by this compilation unit. */
8727 Elf_Internal_Shdr
*sec
;
8728 unsigned char *begin
;
8730 /* Locate the .debug_abbrev section and process it. */
8731 sec
= find_section (".debug_abbrev");
8734 warn (_("Unable to locate .debug_abbrev section!\n"));
8738 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8739 _("debug_abbrev section data"));
8743 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8744 begin
+ sec
->sh_size
);
8750 while (tags
< start
)
8752 unsigned int bytes_read
;
8753 unsigned long abbrev_number
;
8754 abbrev_entry
*entry
;
8757 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8760 /* A null DIE marks the end of a list of children. */
8761 if (abbrev_number
== 0)
8767 /* Scan through the abbreviation list until we reach the
8769 for (entry
= first_abbrev
;
8770 entry
&& entry
->entry
!= abbrev_number
;
8771 entry
= entry
->next
)
8776 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8782 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8784 (unsigned long) (tags
- section_begin
8787 get_TAG_name (entry
->tag
));
8792 need_base_address
= 0;
8794 case DW_TAG_compile_unit
:
8795 need_base_address
= 1;
8797 case DW_TAG_entry_point
:
8798 case DW_TAG_inlined_subroutine
:
8799 case DW_TAG_subprogram
:
8800 need_base_address
= 0;
8801 /* Assuming that there is no DW_AT_frame_base. */
8802 have_frame_base
= 0;
8806 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8807 tags
= read_and_display_attr (attr
->attribute
,
8810 compunit
.cu_pointer_size
,
8812 compunit
.cu_version
,
8813 &debug_information
[unit
],
8816 if (entry
->children
)
8821 /* Set num_debug_info_entries here so that it can be used to check if
8822 we need to proecess .debug_loc and .debug_ranges sections. */
8823 if ((do_loc
|| do_debug_loc
|| do_debug_ranges
)
8824 && num_debug_info_entries
== 0)
8825 num_debug_info_entries
= num_units
;
8829 free_debug_range ();
8839 /* Retrieve the pointer size associated with the given compilation unit.
8840 Optionally the offset of this unit into the .debug_info section is
8841 also retutned. If there is no .debug_info section then an error
8842 message is issued and 0 is returned. If the requested comp unit has
8843 not been defined in the .debug_info section then a warning message
8844 is issued and the last know pointer size is returned. This message
8845 is only issued once per section dumped per file dumped. */
8848 get_pointer_size_and_offset_of_comp_unit (unsigned int comp_unit
,
8849 const char * section_name
,
8850 unsigned long * offset_return
)
8852 unsigned long offset
= 0;
8854 if (num_debug_info_entries
== 0)
8855 error (_("%s section needs a populated .debug_info section\n"),
8858 else if (comp_unit
>= num_debug_info_entries
)
8860 if (!warned_about_missing_comp_units
)
8862 warn (_("%s section has more comp units than .debug_info section\n"),
8864 warn (_("assuming that the pointer size is %d, from the last comp unit in .debug_info\n\n"),
8866 warned_about_missing_comp_units
= TRUE
;
8871 last_pointer_size
= debug_information
[comp_unit
].pointer_size
;
8872 offset
= debug_information
[comp_unit
].cu_offset
;
8875 if (offset_return
!= NULL
)
8876 * offset_return
= offset
;
8878 return last_pointer_size
;
8881 /* Locate and scan the .debug_info section in the file and record the pointer
8882 sizes and offsets for the compilation units in it. Usually an executable
8883 will have just one pointer size, but this is not guaranteed, and so we try
8884 not to make any assumptions. Returns zero upon failure, or the number of
8885 compilation units upon success. */
8888 get_debug_info (FILE * file
)
8890 Elf_Internal_Shdr
* section
;
8891 unsigned char * start
;
8894 /* Reset the last pointer size so that we can issue correct error
8895 messages if we are displaying the contents of more than one section. */
8896 last_pointer_size
= 0;
8897 warned_about_missing_comp_units
= FALSE
;
8899 /* If we already have the information there is nothing else to do. */
8900 if (num_debug_info_entries
> 0)
8901 return num_debug_info_entries
;
8903 section
= find_section (".debug_info");
8904 if (section
== NULL
)
8907 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
8908 _("extracting information from .debug_info section"));
8912 ret
= process_debug_info (section
, start
, file
, 1);
8915 return ret
? num_debug_info_entries
: 0;
8919 display_debug_lines (Elf_Internal_Shdr
*section
,
8920 unsigned char *start
, FILE *file
)
8922 unsigned char *data
= start
;
8923 unsigned char *end
= start
+ section
->sh_size
;
8924 unsigned int comp_unit
= 0;
8926 printf (_("\nDump of debug contents of section %s:\n\n"),
8927 SECTION_NAME (section
));
8929 get_debug_info (file
);
8933 DWARF2_Internal_LineInfo info
;
8934 unsigned char *standard_opcodes
;
8935 unsigned char *end_of_sequence
;
8936 unsigned char *hdrptr
;
8937 unsigned int pointer_size
;
8938 int initial_length_size
;
8944 /* Check the length of the block. */
8945 info
.li_length
= byte_get (hdrptr
, 4);
8948 if (info
.li_length
== 0xffffffff)
8950 /* This section is 64-bit DWARF 3. */
8951 info
.li_length
= byte_get (hdrptr
, 8);
8954 initial_length_size
= 12;
8959 initial_length_size
= 4;
8962 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
8965 (_("The line info appears to be corrupt - the section is too small\n"));
8969 /* Check its version number. */
8970 info
.li_version
= byte_get (hdrptr
, 2);
8972 if (info
.li_version
!= 2 && info
.li_version
!= 3)
8974 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
8978 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
8979 hdrptr
+= offset_size
;
8980 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
8982 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
8984 info
.li_line_base
= byte_get (hdrptr
, 1);
8986 info
.li_line_range
= byte_get (hdrptr
, 1);
8988 info
.li_opcode_base
= byte_get (hdrptr
, 1);
8991 /* Sign extend the line base field. */
8992 info
.li_line_base
<<= 24;
8993 info
.li_line_base
>>= 24;
8995 /* Get the pointer size from the comp unit associated
8996 with this block of line number information. */
8997 pointer_size
= get_pointer_size_and_offset_of_comp_unit
8998 (comp_unit
, ".debug_lines", NULL
);
9001 printf (_(" Length: %ld\n"), info
.li_length
);
9002 printf (_(" DWARF Version: %d\n"), info
.li_version
);
9003 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
9004 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
9005 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
9006 printf (_(" Line Base: %d\n"), info
.li_line_base
);
9007 printf (_(" Line Range: %d\n"), info
.li_line_range
);
9008 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
9009 printf (_(" (Pointer size: %u)\n"), pointer_size
);
9011 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
9013 reset_state_machine (info
.li_default_is_stmt
);
9015 /* Display the contents of the Opcodes table. */
9016 standard_opcodes
= hdrptr
;
9018 printf (_("\n Opcodes:\n"));
9020 for (i
= 1; i
< info
.li_opcode_base
; i
++)
9021 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
9023 /* Display the contents of the Directory table. */
9024 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
9027 printf (_("\n The Directory Table is empty.\n"));
9030 printf (_("\n The Directory Table:\n"));
9034 printf (_(" %s\n"), data
);
9036 data
+= strlen ((char *) data
) + 1;
9040 /* Skip the NUL at the end of the table. */
9043 /* Display the contents of the File Name table. */
9045 printf (_("\n The File Name Table is empty.\n"));
9048 printf (_("\n The File Name Table:\n"));
9049 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
9053 unsigned char *name
;
9054 unsigned int bytes_read
;
9056 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
9059 data
+= strlen ((char *) data
) + 1;
9061 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9063 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9065 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
9067 printf (_("%s\n"), name
);
9071 /* Skip the NUL at the end of the table. */
9074 /* Now display the statements. */
9075 printf (_("\n Line Number Statements:\n"));
9077 while (data
< end_of_sequence
)
9079 unsigned char op_code
;
9081 unsigned int bytes_read
;
9085 if (op_code
>= info
.li_opcode_base
)
9087 op_code
-= info
.li_opcode_base
;
9088 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
9089 state_machine_regs
.address
+= adv
;
9090 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
9091 op_code
, adv
, state_machine_regs
.address
);
9092 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
9093 state_machine_regs
.line
+= adv
;
9094 printf (_(" and Line by %d to %d\n"),
9095 adv
, state_machine_regs
.line
);
9097 else switch (op_code
)
9099 case DW_LNS_extended_op
:
9100 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
9105 printf (_(" Copy\n"));
9108 case DW_LNS_advance_pc
:
9109 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
9111 state_machine_regs
.address
+= adv
;
9112 printf (_(" Advance PC by %d to %lx\n"), adv
,
9113 state_machine_regs
.address
);
9116 case DW_LNS_advance_line
:
9117 adv
= read_leb128 (data
, & bytes_read
, 1);
9119 state_machine_regs
.line
+= adv
;
9120 printf (_(" Advance Line by %d to %d\n"), adv
,
9121 state_machine_regs
.line
);
9124 case DW_LNS_set_file
:
9125 adv
= read_leb128 (data
, & bytes_read
, 0);
9127 printf (_(" Set File Name to entry %d in the File Name Table\n"),
9129 state_machine_regs
.file
= adv
;
9132 case DW_LNS_set_column
:
9133 adv
= read_leb128 (data
, & bytes_read
, 0);
9135 printf (_(" Set column to %d\n"), adv
);
9136 state_machine_regs
.column
= adv
;
9139 case DW_LNS_negate_stmt
:
9140 adv
= state_machine_regs
.is_stmt
;
9142 printf (_(" Set is_stmt to %d\n"), adv
);
9143 state_machine_regs
.is_stmt
= adv
;
9146 case DW_LNS_set_basic_block
:
9147 printf (_(" Set basic block\n"));
9148 state_machine_regs
.basic_block
= 1;
9151 case DW_LNS_const_add_pc
:
9152 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
9153 * info
.li_min_insn_length
);
9154 state_machine_regs
.address
+= adv
;
9155 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
9156 state_machine_regs
.address
);
9159 case DW_LNS_fixed_advance_pc
:
9160 adv
= byte_get (data
, 2);
9162 state_machine_regs
.address
+= adv
;
9163 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
9164 adv
, state_machine_regs
.address
);
9167 case DW_LNS_set_prologue_end
:
9168 printf (_(" Set prologue_end to true\n"));
9171 case DW_LNS_set_epilogue_begin
:
9172 printf (_(" Set epilogue_begin to true\n"));
9175 case DW_LNS_set_isa
:
9176 adv
= read_leb128 (data
, & bytes_read
, 0);
9178 printf (_(" Set ISA to %d\n"), adv
);
9182 printf (_(" Unknown opcode %d with operands: "), op_code
);
9184 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
9186 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
9187 i
== 1 ? "" : ", ");
9201 display_debug_pubnames (Elf_Internal_Shdr
*section
,
9202 unsigned char *start
,
9203 FILE *file ATTRIBUTE_UNUSED
)
9205 DWARF2_Internal_PubNames pubnames
;
9208 end
= start
+ section
->sh_size
;
9210 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9214 unsigned char *data
;
9215 unsigned long offset
;
9216 int offset_size
, initial_length_size
;
9220 pubnames
.pn_length
= byte_get (data
, 4);
9222 if (pubnames
.pn_length
== 0xffffffff)
9224 pubnames
.pn_length
= byte_get (data
, 8);
9227 initial_length_size
= 12;
9232 initial_length_size
= 4;
9235 pubnames
.pn_version
= byte_get (data
, 2);
9237 pubnames
.pn_offset
= byte_get (data
, offset_size
);
9238 data
+= offset_size
;
9239 pubnames
.pn_size
= byte_get (data
, offset_size
);
9240 data
+= offset_size
;
9242 start
+= pubnames
.pn_length
+ initial_length_size
;
9244 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
9246 static int warned
= 0;
9250 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
9257 printf (_(" Length: %ld\n"),
9258 pubnames
.pn_length
);
9259 printf (_(" Version: %d\n"),
9260 pubnames
.pn_version
);
9261 printf (_(" Offset into .debug_info section: %ld\n"),
9262 pubnames
.pn_offset
);
9263 printf (_(" Size of area in .debug_info section: %ld\n"),
9266 printf (_("\n Offset\tName\n"));
9270 offset
= byte_get (data
, offset_size
);
9274 data
+= offset_size
;
9275 printf (" %-6ld\t\t%s\n", offset
, data
);
9276 data
+= strlen ((char *) data
) + 1;
9279 while (offset
!= 0);
9287 display_debug_macinfo (Elf_Internal_Shdr
*section
,
9288 unsigned char *start
,
9289 FILE *file ATTRIBUTE_UNUSED
)
9291 unsigned char *end
= start
+ section
->sh_size
;
9292 unsigned char *curr
= start
;
9293 unsigned int bytes_read
;
9294 enum dwarf_macinfo_record_type op
;
9296 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9300 unsigned int lineno
;
9308 case DW_MACINFO_start_file
:
9310 unsigned int filenum
;
9312 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9314 filenum
= read_leb128 (curr
, & bytes_read
, 0);
9317 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"),
9322 case DW_MACINFO_end_file
:
9323 printf (_(" DW_MACINFO_end_file\n"));
9326 case DW_MACINFO_define
:
9327 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9329 string
= (char *) curr
;
9330 curr
+= strlen (string
) + 1;
9331 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"),
9335 case DW_MACINFO_undef
:
9336 lineno
= read_leb128 (curr
, & bytes_read
, 0);
9338 string
= (char *) curr
;
9339 curr
+= strlen (string
) + 1;
9340 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"),
9344 case DW_MACINFO_vendor_ext
:
9346 unsigned int constant
;
9348 constant
= read_leb128 (curr
, & bytes_read
, 0);
9350 string
= (char *) curr
;
9351 curr
+= strlen (string
) + 1;
9352 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"),
9364 display_debug_abbrev (Elf_Internal_Shdr
*section
,
9365 unsigned char *start
,
9366 FILE *file ATTRIBUTE_UNUSED
)
9368 abbrev_entry
*entry
;
9369 unsigned char *end
= start
+ section
->sh_size
;
9371 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
9375 start
= process_abbrev_section (start
, end
);
9377 if (first_abbrev
== NULL
)
9380 printf (_(" Number TAG\n"));
9382 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
9386 printf (_(" %ld %s [%s]\n"),
9388 get_TAG_name (entry
->tag
),
9389 entry
->children
? _("has children") : _("no children"));
9391 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
9392 printf (_(" %-18s %s\n"),
9393 get_AT_name (attr
->attribute
),
9394 get_FORM_name (attr
->form
));
9407 display_debug_loc (Elf_Internal_Shdr
*section
,
9408 unsigned char *start
, FILE *file
)
9410 unsigned char *section_end
;
9411 unsigned long bytes
;
9412 unsigned char *section_begin
= start
;
9413 unsigned int num_loc_list
= 0;
9414 unsigned long last_offset
= 0;
9415 unsigned int first
= 0;
9418 int seen_first_offset
= 0;
9419 int use_debug_info
= 1;
9420 unsigned char *next
;
9422 bytes
= section
->sh_size
;
9423 section_end
= start
+ bytes
;
9427 printf (_("\nThe .debug_loc section is empty.\n"));
9431 get_debug_info (file
);
9433 /* Check the order of location list in .debug_info section. If
9434 offsets of location lists are in the ascending order, we can
9435 use `debug_information' directly. */
9436 for (i
= 0; i
< num_debug_info_entries
; i
++)
9440 num
= debug_information
[i
].num_loc_offsets
;
9441 num_loc_list
+= num
;
9443 /* Check if we can use `debug_information' directly. */
9444 if (use_debug_info
&& num
!= 0)
9446 if (!seen_first_offset
)
9448 /* This is the first location list. */
9449 last_offset
= debug_information
[i
].loc_offsets
[0];
9451 seen_first_offset
= 1;
9457 for (; j
< num
; j
++)
9460 debug_information
[i
].loc_offsets
[j
])
9465 last_offset
= debug_information
[i
].loc_offsets
[j
];
9470 if (!use_debug_info
)
9471 /* FIXME: Should we handle this case? */
9472 error (_("Location lists in .debug_info section aren't in ascending order!\n"));
9474 if (!seen_first_offset
)
9475 error (_("No location lists in .debug_info section!\n"));
9477 if (debug_information
[first
].loc_offsets
[0] != 0)
9478 warn (_("Location lists in .debug_loc section start at 0x%lx\n"),
9479 debug_information
[first
].loc_offsets
[0]);
9481 printf (_("Contents of the .debug_loc section:\n\n"));
9482 printf (_(" Offset Begin End Expression\n"));
9484 seen_first_offset
= 0;
9485 for (i
= first
; i
< num_debug_info_entries
; i
++)
9487 unsigned long begin
;
9489 unsigned short length
;
9490 unsigned long offset
;
9491 unsigned int pointer_size
;
9492 unsigned long cu_offset
;
9493 unsigned long base_address
;
9494 int need_frame_base
;
9497 pointer_size
= debug_information
[i
].pointer_size
;
9498 cu_offset
= debug_information
[i
].cu_offset
;
9500 for (j
= 0; j
< debug_information
[i
].num_loc_offsets
; j
++)
9502 has_frame_base
= debug_information
[i
].have_frame_base
[j
];
9503 offset
= debug_information
[i
].loc_offsets
[j
];
9504 next
= section_begin
+ offset
;
9505 base_address
= debug_information
[i
].base_address
;
9507 if (!seen_first_offset
)
9508 seen_first_offset
= 1;
9512 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"),
9513 start
- section_begin
, next
- section_begin
);
9514 else if (start
> next
)
9515 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"),
9516 start
- section_begin
, next
- section_begin
);
9522 begin
= byte_get (start
, pointer_size
);
9523 start
+= pointer_size
;
9524 end
= byte_get (start
, pointer_size
);
9525 start
+= pointer_size
;
9527 if (begin
== 0 && end
== 0)
9529 printf (_(" %8.8lx <End of list>\n"), offset
);
9533 /* Check base address specifiers. */
9534 if (begin
== -1UL && end
!= -1UL)
9537 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9538 offset
, begin
, end
);
9542 length
= byte_get (start
, 2);
9545 printf (" %8.8lx %8.8lx %8.8lx (",
9546 offset
, begin
+ base_address
, end
+ base_address
);
9547 need_frame_base
= decode_location_expression (start
,
9553 if (need_frame_base
&& !has_frame_base
)
9554 printf (_(" [without DW_AT_frame_base]"));
9557 fputs (_(" (start == end)"), stdout
);
9558 else if (begin
> end
)
9559 fputs (_(" (start > end)"), stdout
);
9571 display_debug_str (Elf_Internal_Shdr
*section
,
9572 unsigned char *start
,
9573 FILE *file ATTRIBUTE_UNUSED
)
9575 unsigned long bytes
;
9578 addr
= section
->sh_addr
;
9579 bytes
= section
->sh_size
;
9583 printf (_("\nThe .debug_str section is empty.\n"));
9587 printf (_("Contents of the .debug_str section:\n\n"));
9595 lbytes
= (bytes
> 16 ? 16 : bytes
);
9597 printf (" 0x%8.8lx ", (unsigned long) addr
);
9599 for (j
= 0; j
< 16; j
++)
9602 printf ("%2.2x", start
[j
]);
9610 for (j
= 0; j
< lbytes
; j
++)
9613 if (k
>= ' ' && k
< 0x80)
9633 display_debug_info (Elf_Internal_Shdr
* section
,
9634 unsigned char * start
, FILE * file
)
9636 return process_debug_info (section
, start
, file
, 0);
9641 display_debug_aranges (Elf_Internal_Shdr
*section
,
9642 unsigned char *start
,
9643 FILE *file ATTRIBUTE_UNUSED
)
9645 unsigned char *end
= start
+ section
->sh_size
;
9647 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
9651 unsigned char *hdrptr
;
9652 DWARF2_Internal_ARange arange
;
9653 unsigned char *ranges
;
9654 unsigned long length
;
9655 unsigned long address
;
9658 int initial_length_size
;
9662 arange
.ar_length
= byte_get (hdrptr
, 4);
9665 if (arange
.ar_length
== 0xffffffff)
9667 arange
.ar_length
= byte_get (hdrptr
, 8);
9670 initial_length_size
= 12;
9675 initial_length_size
= 4;
9678 arange
.ar_version
= byte_get (hdrptr
, 2);
9681 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
9682 hdrptr
+= offset_size
;
9684 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
9687 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
9690 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
9692 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
9696 printf (_(" Length: %ld\n"), arange
.ar_length
);
9697 printf (_(" Version: %d\n"), arange
.ar_version
);
9698 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
9699 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
9700 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
9702 printf (_("\n Address Length\n"));
9706 /* Must pad to an alignment boundary that is twice the pointer size. */
9707 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
9709 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
9713 address
= byte_get (ranges
, arange
.ar_pointer_size
);
9715 ranges
+= arange
.ar_pointer_size
;
9717 length
= byte_get (ranges
, arange
.ar_pointer_size
);
9719 ranges
+= arange
.ar_pointer_size
;
9721 /* A pair of zeros marks the end of the list. */
9722 if (address
== 0 && length
== 0)
9725 printf (" %8.8lx %lu\n", address
, length
);
9728 start
+= arange
.ar_length
+ initial_length_size
;
9737 display_debug_ranges (Elf_Internal_Shdr
*section
,
9738 unsigned char *start
,
9739 FILE *file ATTRIBUTE_UNUSED
)
9741 unsigned char *section_end
;
9742 unsigned long bytes
;
9743 unsigned char *section_begin
= start
;
9744 unsigned int num_range_list
= 0;
9745 unsigned long last_offset
= 0;
9746 unsigned int first
= 0;
9749 int seen_first_offset
= 0;
9750 int use_debug_info
= 1;
9751 unsigned char *next
;
9753 bytes
= section
->sh_size
;
9754 section_end
= start
+ bytes
;
9758 printf (_("\nThe .debug_ranges section is empty.\n"));
9762 get_debug_info (file
);
9764 /* Check the order of range list in .debug_info section. If
9765 offsets of range lists are in the ascending order, we can
9766 use `debug_information' directly. */
9767 for (i
= 0; i
< num_debug_info_entries
; i
++)
9771 num
= debug_information
[i
].num_range_lists
;
9772 num_range_list
+= num
;
9774 /* Check if we can use `debug_information' directly. */
9775 if (use_debug_info
&& num
!= 0)
9777 if (!seen_first_offset
)
9779 /* This is the first range list. */
9780 last_offset
= debug_information
[i
].range_lists
[0];
9782 seen_first_offset
= 1;
9788 for (; j
< num
; j
++)
9791 debug_information
[i
].range_lists
[j
])
9796 last_offset
= debug_information
[i
].range_lists
[j
];
9801 if (!use_debug_info
)
9802 /* FIXME: Should we handle this case? */
9803 error (_("Range lists in .debug_info section aren't in ascending order!\n"));
9805 if (!seen_first_offset
)
9806 error (_("No range lists in .debug_info section!\n"));
9808 if (debug_information
[first
].range_lists
[0] != 0)
9809 warn (_("Range lists in .debug_ranges section start at 0x%lx\n"),
9810 debug_information
[first
].range_lists
[0]);
9812 printf (_("Contents of the .debug_ranges section:\n\n"));
9813 printf (_(" Offset Begin End\n"));
9815 seen_first_offset
= 0;
9816 for (i
= first
; i
< num_debug_info_entries
; i
++)
9818 unsigned long begin
;
9820 unsigned long offset
;
9821 unsigned int pointer_size
;
9822 unsigned long base_address
;
9824 pointer_size
= debug_information
[i
].pointer_size
;
9826 for (j
= 0; j
< debug_information
[i
].num_range_lists
; j
++)
9828 offset
= debug_information
[i
].range_lists
[j
];
9829 next
= section_begin
+ offset
;
9830 base_address
= debug_information
[i
].base_address
;
9832 if (!seen_first_offset
)
9833 seen_first_offset
= 1;
9837 warn (_("There is a hole [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9838 start
- section_begin
, next
- section_begin
);
9839 else if (start
> next
)
9840 warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_ranges section.\n"),
9841 start
- section_begin
, next
- section_begin
);
9847 begin
= byte_get (start
, pointer_size
);
9848 start
+= pointer_size
;
9849 end
= byte_get (start
, pointer_size
);
9850 start
+= pointer_size
;
9852 if (begin
== 0 && end
== 0)
9854 printf (_(" %8.8lx <End of list>\n"), offset
);
9858 /* Check base address specifiers. */
9859 if (begin
== -1UL && end
!= -1UL)
9862 printf (" %8.8lx %8.8lx %8.8lx (base address)\n",
9863 offset
, begin
, end
);
9867 printf (" %8.8lx %8.8lx %8.8lx",
9868 offset
, begin
+ base_address
, end
+ base_address
);
9871 fputs (_(" (start == end)"), stdout
);
9872 else if (begin
> end
)
9873 fputs (_(" (start > end)"), stdout
);
9883 typedef struct Frame_Chunk
9885 struct Frame_Chunk
*next
;
9886 unsigned char *chunk_start
;
9888 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
9889 short int *col_type
;
9892 unsigned int code_factor
;
9894 unsigned long pc_begin
;
9895 unsigned long pc_range
;
9899 unsigned char fde_encoding
;
9900 unsigned char cfa_exp
;
9904 /* A marker for a col_type that means this column was never referenced
9905 in the frame info. */
9906 #define DW_CFA_unreferenced (-1)
9909 frame_need_space (Frame_Chunk
*fc
, int reg
)
9911 int prev
= fc
->ncols
;
9913 if (reg
< fc
->ncols
)
9916 fc
->ncols
= reg
+ 1;
9917 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
9918 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
9920 while (prev
< fc
->ncols
)
9922 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
9923 fc
->col_offset
[prev
] = 0;
9929 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
9934 if (*max_regs
< fc
->ncols
)
9935 *max_regs
= fc
->ncols
;
9937 if (*need_col_headers
)
9939 *need_col_headers
= 0;
9941 printf (" LOC CFA ");
9943 for (r
= 0; r
< *max_regs
; r
++)
9944 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9949 printf ("r%-4d", r
);
9955 printf ("%08lx ", fc
->pc_begin
);
9957 strcpy (tmp
, "exp");
9959 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9960 printf ("%-8s ", tmp
);
9962 for (r
= 0; r
< fc
->ncols
; r
++)
9964 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9966 switch (fc
->col_type
[r
])
9968 case DW_CFA_undefined
:
9971 case DW_CFA_same_value
:
9975 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9977 case DW_CFA_register
:
9978 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9980 case DW_CFA_expression
:
9981 strcpy (tmp
, "exp");
9984 strcpy (tmp
, "n/a");
9987 printf ("%-5s", tmp
);
9994 size_of_encoded_value (int encoding
)
9996 switch (encoding
& 0x7)
9999 case 0: return eh_addr_size
;
10007 get_encoded_value (unsigned char *data
, int encoding
)
10009 int size
= size_of_encoded_value (encoding
);
10010 if (encoding
& DW_EH_PE_signed
)
10011 return byte_get_signed (data
, size
);
10013 return byte_get (data
, size
);
10016 #define GET(N) byte_get (start, N); start += N
10017 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
10018 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
10021 display_debug_frames (Elf_Internal_Shdr
*section
,
10022 unsigned char *start
,
10023 FILE *file ATTRIBUTE_UNUSED
)
10025 unsigned char *end
= start
+ section
->sh_size
;
10026 unsigned char *section_start
= start
;
10027 Frame_Chunk
*chunks
= 0;
10028 Frame_Chunk
*remembered_state
= 0;
10030 int is_eh
= streq (SECTION_NAME (section
), ".eh_frame");
10031 unsigned int length_return
;
10034 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
10036 while (start
< end
)
10038 unsigned char *saved_start
;
10039 unsigned char *block_end
;
10040 unsigned long length
;
10041 unsigned long cie_id
;
10044 int need_col_headers
= 1;
10045 unsigned char *augmentation_data
= NULL
;
10046 unsigned long augmentation_data_len
= 0;
10047 int encoded_ptr_size
= eh_addr_size
;
10049 int initial_length_size
;
10051 saved_start
= start
;
10052 length
= byte_get (start
, 4); start
+= 4;
10056 printf ("\n%08lx ZERO terminator\n\n",
10057 (unsigned long)(saved_start
- section_start
));
10061 if (length
== 0xffffffff)
10063 length
= byte_get (start
, 8);
10066 initial_length_size
= 12;
10071 initial_length_size
= 4;
10074 block_end
= saved_start
+ length
+ initial_length_size
;
10075 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
10077 if (elf_header
.e_type
== ET_REL
10078 && !debug_apply_rela_addends (file
, section
, offset_size
,
10079 section_start
, start
, block_end
))
10082 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
10086 fc
= xmalloc (sizeof (Frame_Chunk
));
10087 memset (fc
, 0, sizeof (Frame_Chunk
));
10091 fc
->chunk_start
= saved_start
;
10093 fc
->col_type
= xmalloc (sizeof (short int));
10094 fc
->col_offset
= xmalloc (sizeof (int));
10095 frame_need_space (fc
, max_regs
-1);
10097 version
= *start
++;
10099 fc
->augmentation
= (char *) start
;
10100 start
= (unsigned char *) strchr ((char *) start
, '\0') + 1;
10102 if (fc
->augmentation
[0] == 'z')
10104 fc
->code_factor
= LEB ();
10105 fc
->data_factor
= SLEB ();
10114 augmentation_data_len
= LEB ();
10115 augmentation_data
= start
;
10116 start
+= augmentation_data_len
;
10118 else if (streq (fc
->augmentation
, "eh"))
10120 start
+= eh_addr_size
;
10121 fc
->code_factor
= LEB ();
10122 fc
->data_factor
= SLEB ();
10134 fc
->code_factor
= LEB ();
10135 fc
->data_factor
= SLEB ();
10147 if (do_debug_frames_interp
)
10148 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
10149 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10150 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
10154 printf ("\n%08lx %08lx %08lx CIE\n",
10155 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
10156 printf (" Version: %d\n", version
);
10157 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
10158 printf (" Code alignment factor: %u\n", fc
->code_factor
);
10159 printf (" Data alignment factor: %d\n", fc
->data_factor
);
10160 printf (" Return address column: %d\n", fc
->ra
);
10162 if (augmentation_data_len
)
10165 printf (" Augmentation data: ");
10166 for (i
= 0; i
< augmentation_data_len
; ++i
)
10167 printf (" %02x", augmentation_data
[i
]);
10173 if (augmentation_data_len
)
10175 unsigned char *p
, *q
;
10176 p
= (unsigned char *) fc
->augmentation
+ 1;
10177 q
= augmentation_data
;
10183 else if (*p
== 'P')
10184 q
+= 1 + size_of_encoded_value (*q
);
10185 else if (*p
== 'R')
10186 fc
->fde_encoding
= *q
++;
10192 if (fc
->fde_encoding
)
10193 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10196 frame_need_space (fc
, fc
->ra
);
10200 unsigned char *look_for
;
10201 static Frame_Chunk fde_fc
;
10204 memset (fc
, 0, sizeof (Frame_Chunk
));
10206 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
10208 for (cie
= chunks
; cie
; cie
= cie
->next
)
10209 if (cie
->chunk_start
== look_for
)
10214 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
10215 cie_id
, saved_start
);
10218 fc
->col_type
= xmalloc (sizeof (short int));
10219 fc
->col_offset
= xmalloc (sizeof (int));
10220 frame_need_space (fc
, max_regs
- 1);
10222 fc
->augmentation
= "";
10223 fc
->fde_encoding
= 0;
10227 fc
->ncols
= cie
->ncols
;
10228 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
10229 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
10230 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
10231 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
10232 fc
->augmentation
= cie
->augmentation
;
10233 fc
->code_factor
= cie
->code_factor
;
10234 fc
->data_factor
= cie
->data_factor
;
10235 fc
->cfa_reg
= cie
->cfa_reg
;
10236 fc
->cfa_offset
= cie
->cfa_offset
;
10238 frame_need_space (fc
, max_regs
-1);
10239 fc
->fde_encoding
= cie
->fde_encoding
;
10242 if (fc
->fde_encoding
)
10243 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
10245 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
10246 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10247 /* Don't adjust for ET_REL since there's invariably a pcrel
10248 reloc here, which we haven't applied. */
10249 && elf_header
.e_type
!= ET_REL
)
10250 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
10251 start
+= encoded_ptr_size
;
10252 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
10253 start
+= encoded_ptr_size
;
10255 if (cie
->augmentation
[0] == 'z')
10257 augmentation_data_len
= LEB ();
10258 augmentation_data
= start
;
10259 start
+= augmentation_data_len
;
10262 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
10263 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
10264 (unsigned long)(cie
->chunk_start
- section_start
),
10265 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
10266 if (! do_debug_frames_interp
&& augmentation_data_len
)
10270 printf (" Augmentation data: ");
10271 for (i
= 0; i
< augmentation_data_len
; ++i
)
10272 printf (" %02x", augmentation_data
[i
]);
10278 /* At this point, fc is the current chunk, cie (if any) is set, and
10279 we're about to interpret instructions for the chunk. */
10280 /* ??? At present we need to do this always, since this sizes the
10281 fc->col_type and fc->col_offset arrays, which we write into always.
10282 We should probably split the interpreted and non-interpreted bits
10283 into two different routines, since there's so much that doesn't
10284 really overlap between them. */
10285 if (1 || do_debug_frames_interp
)
10287 /* Start by making a pass over the chunk, allocating storage
10288 and taking note of what registers are used. */
10289 unsigned char *tmp
= start
;
10291 while (start
< block_end
)
10294 unsigned long reg
, tmp
;
10301 /* Warning: if you add any more cases to this switch, be
10302 sure to add them to the corresponding switch below. */
10305 case DW_CFA_advance_loc
:
10307 case DW_CFA_offset
:
10309 frame_need_space (fc
, opa
);
10310 fc
->col_type
[opa
] = DW_CFA_undefined
;
10312 case DW_CFA_restore
:
10313 frame_need_space (fc
, opa
);
10314 fc
->col_type
[opa
] = DW_CFA_undefined
;
10316 case DW_CFA_set_loc
:
10317 start
+= encoded_ptr_size
;
10319 case DW_CFA_advance_loc1
:
10322 case DW_CFA_advance_loc2
:
10325 case DW_CFA_advance_loc4
:
10328 case DW_CFA_offset_extended
:
10329 reg
= LEB (); LEB ();
10330 frame_need_space (fc
, reg
);
10331 fc
->col_type
[reg
] = DW_CFA_undefined
;
10333 case DW_CFA_restore_extended
:
10335 frame_need_space (fc
, reg
);
10336 fc
->col_type
[reg
] = DW_CFA_undefined
;
10338 case DW_CFA_undefined
:
10340 frame_need_space (fc
, reg
);
10341 fc
->col_type
[reg
] = DW_CFA_undefined
;
10343 case DW_CFA_same_value
:
10345 frame_need_space (fc
, reg
);
10346 fc
->col_type
[reg
] = DW_CFA_undefined
;
10348 case DW_CFA_register
:
10349 reg
= LEB (); LEB ();
10350 frame_need_space (fc
, reg
);
10351 fc
->col_type
[reg
] = DW_CFA_undefined
;
10353 case DW_CFA_def_cfa
:
10356 case DW_CFA_def_cfa_register
:
10359 case DW_CFA_def_cfa_offset
:
10362 case DW_CFA_def_cfa_expression
:
10366 case DW_CFA_expression
:
10370 frame_need_space (fc
, reg
);
10371 fc
->col_type
[reg
] = DW_CFA_undefined
;
10373 case DW_CFA_offset_extended_sf
:
10374 reg
= LEB (); SLEB ();
10375 frame_need_space (fc
, reg
);
10376 fc
->col_type
[reg
] = DW_CFA_undefined
;
10378 case DW_CFA_def_cfa_sf
:
10381 case DW_CFA_def_cfa_offset_sf
:
10384 case DW_CFA_MIPS_advance_loc8
:
10387 case DW_CFA_GNU_args_size
:
10390 case DW_CFA_GNU_negative_offset_extended
:
10391 reg
= LEB (); LEB ();
10392 frame_need_space (fc
, reg
);
10393 fc
->col_type
[reg
] = DW_CFA_undefined
;
10402 /* Now we know what registers are used, make a second pass over
10403 the chunk, this time actually printing out the info. */
10405 while (start
< block_end
)
10408 unsigned long ul
, reg
, roffs
;
10417 /* Warning: if you add any more cases to this switch, be
10418 sure to add them to the corresponding switch above. */
10421 case DW_CFA_advance_loc
:
10422 if (do_debug_frames_interp
)
10423 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10425 printf (" DW_CFA_advance_loc: %d to %08lx\n",
10426 opa
* fc
->code_factor
,
10427 fc
->pc_begin
+ opa
* fc
->code_factor
);
10428 fc
->pc_begin
+= opa
* fc
->code_factor
;
10431 case DW_CFA_offset
:
10433 if (! do_debug_frames_interp
)
10434 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
10435 opa
, roffs
* fc
->data_factor
);
10436 fc
->col_type
[opa
] = DW_CFA_offset
;
10437 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
10440 case DW_CFA_restore
:
10441 if (! do_debug_frames_interp
)
10442 printf (" DW_CFA_restore: r%d\n", opa
);
10443 fc
->col_type
[opa
] = cie
->col_type
[opa
];
10444 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
10447 case DW_CFA_set_loc
:
10448 vma
= get_encoded_value (start
, fc
->fde_encoding
);
10449 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
10450 && elf_header
.e_type
!= ET_REL
)
10451 vma
+= section
->sh_addr
+ (start
- section_start
);
10452 start
+= encoded_ptr_size
;
10453 if (do_debug_frames_interp
)
10454 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10456 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
10457 fc
->pc_begin
= vma
;
10460 case DW_CFA_advance_loc1
:
10461 ofs
= byte_get (start
, 1); start
+= 1;
10462 if (do_debug_frames_interp
)
10463 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10465 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
10466 ofs
* fc
->code_factor
,
10467 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10468 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10471 case DW_CFA_advance_loc2
:
10472 ofs
= byte_get (start
, 2); start
+= 2;
10473 if (do_debug_frames_interp
)
10474 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10476 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
10477 ofs
* fc
->code_factor
,
10478 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10479 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10482 case DW_CFA_advance_loc4
:
10483 ofs
= byte_get (start
, 4); start
+= 4;
10484 if (do_debug_frames_interp
)
10485 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10487 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
10488 ofs
* fc
->code_factor
,
10489 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10490 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10493 case DW_CFA_offset_extended
:
10496 if (! do_debug_frames_interp
)
10497 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
10498 reg
, roffs
* fc
->data_factor
);
10499 fc
->col_type
[reg
] = DW_CFA_offset
;
10500 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
10503 case DW_CFA_restore_extended
:
10505 if (! do_debug_frames_interp
)
10506 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
10507 fc
->col_type
[reg
] = cie
->col_type
[reg
];
10508 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
10511 case DW_CFA_undefined
:
10513 if (! do_debug_frames_interp
)
10514 printf (" DW_CFA_undefined: r%ld\n", reg
);
10515 fc
->col_type
[reg
] = DW_CFA_undefined
;
10516 fc
->col_offset
[reg
] = 0;
10519 case DW_CFA_same_value
:
10521 if (! do_debug_frames_interp
)
10522 printf (" DW_CFA_same_value: r%ld\n", reg
);
10523 fc
->col_type
[reg
] = DW_CFA_same_value
;
10524 fc
->col_offset
[reg
] = 0;
10527 case DW_CFA_register
:
10530 if (! do_debug_frames_interp
)
10531 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
10532 fc
->col_type
[reg
] = DW_CFA_register
;
10533 fc
->col_offset
[reg
] = roffs
;
10536 case DW_CFA_remember_state
:
10537 if (! do_debug_frames_interp
)
10538 printf (" DW_CFA_remember_state\n");
10539 rs
= xmalloc (sizeof (Frame_Chunk
));
10540 rs
->ncols
= fc
->ncols
;
10541 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
10542 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
10543 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
10544 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
10545 rs
->next
= remembered_state
;
10546 remembered_state
= rs
;
10549 case DW_CFA_restore_state
:
10550 if (! do_debug_frames_interp
)
10551 printf (" DW_CFA_restore_state\n");
10552 rs
= remembered_state
;
10555 remembered_state
= rs
->next
;
10556 frame_need_space (fc
, rs
->ncols
-1);
10557 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
10558 memcpy (fc
->col_offset
, rs
->col_offset
,
10559 rs
->ncols
* sizeof (int));
10560 free (rs
->col_type
);
10561 free (rs
->col_offset
);
10564 else if (do_debug_frames_interp
)
10565 printf ("Mismatched DW_CFA_restore_state\n");
10568 case DW_CFA_def_cfa
:
10569 fc
->cfa_reg
= LEB ();
10570 fc
->cfa_offset
= LEB ();
10572 if (! do_debug_frames_interp
)
10573 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
10574 fc
->cfa_reg
, fc
->cfa_offset
);
10577 case DW_CFA_def_cfa_register
:
10578 fc
->cfa_reg
= LEB ();
10580 if (! do_debug_frames_interp
)
10581 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
10584 case DW_CFA_def_cfa_offset
:
10585 fc
->cfa_offset
= LEB ();
10586 if (! do_debug_frames_interp
)
10587 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
10591 if (! do_debug_frames_interp
)
10592 printf (" DW_CFA_nop\n");
10595 case DW_CFA_def_cfa_expression
:
10597 if (! do_debug_frames_interp
)
10599 printf (" DW_CFA_def_cfa_expression (");
10600 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10607 case DW_CFA_expression
:
10610 if (! do_debug_frames_interp
)
10612 printf (" DW_CFA_expression: r%ld (", reg
);
10613 decode_location_expression (start
, eh_addr_size
, ul
, 0);
10616 fc
->col_type
[reg
] = DW_CFA_expression
;
10620 case DW_CFA_offset_extended_sf
:
10623 frame_need_space (fc
, reg
);
10624 if (! do_debug_frames_interp
)
10625 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
10626 reg
, l
* fc
->data_factor
);
10627 fc
->col_type
[reg
] = DW_CFA_offset
;
10628 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10631 case DW_CFA_def_cfa_sf
:
10632 fc
->cfa_reg
= LEB ();
10633 fc
->cfa_offset
= SLEB ();
10635 if (! do_debug_frames_interp
)
10636 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
10637 fc
->cfa_reg
, fc
->cfa_offset
);
10640 case DW_CFA_def_cfa_offset_sf
:
10641 fc
->cfa_offset
= SLEB ();
10642 if (! do_debug_frames_interp
)
10643 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
10646 case DW_CFA_MIPS_advance_loc8
:
10647 ofs
= byte_get (start
, 8); start
+= 8;
10648 if (do_debug_frames_interp
)
10649 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10651 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
10652 ofs
* fc
->code_factor
,
10653 fc
->pc_begin
+ ofs
* fc
->code_factor
);
10654 fc
->pc_begin
+= ofs
* fc
->code_factor
;
10657 case DW_CFA_GNU_window_save
:
10658 if (! do_debug_frames_interp
)
10659 printf (" DW_CFA_GNU_window_save\n");
10662 case DW_CFA_GNU_args_size
:
10664 if (! do_debug_frames_interp
)
10665 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
10668 case DW_CFA_GNU_negative_offset_extended
:
10671 frame_need_space (fc
, reg
);
10672 if (! do_debug_frames_interp
)
10673 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
10674 reg
, l
* fc
->data_factor
);
10675 fc
->col_type
[reg
] = DW_CFA_offset
;
10676 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
10680 warn (_("unsupported or unknown DW_CFA_%d\n"), op
);
10685 if (do_debug_frames_interp
)
10686 frame_display_row (fc
, &need_col_headers
, &max_regs
);
10701 display_debug_not_supported (Elf_Internal_Shdr
*section
,
10702 unsigned char *start ATTRIBUTE_UNUSED
,
10703 FILE *file ATTRIBUTE_UNUSED
)
10705 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
10706 SECTION_NAME (section
));
10711 /* A structure containing the name of a debug section
10712 and a pointer to a function that can decode it. */
10715 const char *const name
;
10716 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
10720 { ".debug_abbrev", display_debug_abbrev
},
10721 { ".debug_aranges", display_debug_aranges
},
10722 { ".debug_frame", display_debug_frames
},
10723 { ".debug_info", display_debug_info
},
10724 { ".debug_line", display_debug_lines
},
10725 { ".debug_pubnames", display_debug_pubnames
},
10726 { ".eh_frame", display_debug_frames
},
10727 { ".debug_macinfo", display_debug_macinfo
},
10728 { ".debug_str", display_debug_str
},
10729 { ".debug_loc", display_debug_loc
},
10730 { ".debug_pubtypes", display_debug_pubnames
},
10731 { ".debug_ranges", display_debug_ranges
},
10732 { ".debug_static_func", display_debug_not_supported
},
10733 { ".debug_static_vars", display_debug_not_supported
},
10734 { ".debug_types", display_debug_not_supported
},
10735 { ".debug_weaknames", display_debug_not_supported
}
10739 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
10741 char *name
= SECTION_NAME (section
);
10742 bfd_size_type length
;
10746 length
= section
->sh_size
;
10749 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10753 if (strneq (name
, ".gnu.linkonce.wi.", 17))
10754 name
= ".debug_info";
10756 /* See if we know how to display the contents of this section. */
10757 for (i
= NUM_ELEM (debug_displays
); i
--;)
10758 if (streq (debug_displays
[i
].name
, name
))
10760 unsigned char *start
;
10762 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
10763 _("debug section data"));
10770 result
&= debug_displays
[i
].display (section
, start
, file
);
10773 /* If we loaded in the abbrev section
10774 at some point, we must release it here. */
10782 printf (_("Unrecognized debug section: %s\n"), name
);
10790 process_section_contents (FILE *file
)
10792 Elf_Internal_Shdr
*section
;
10798 for (i
= 0, section
= section_headers
;
10799 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10802 #ifdef SUPPORT_DISASSEMBLY
10803 if (dump_sects
[i
] & DISASS_DUMP
)
10804 disassemble_section (section
, file
);
10806 if (dump_sects
[i
] & HEX_DUMP
)
10807 dump_section (section
, file
);
10809 if (dump_sects
[i
] & DEBUG_DUMP
)
10810 display_debug_section (section
, file
);
10813 /* Check to see if the user requested a
10814 dump of a section that does not exist. */
10815 while (i
++ < num_dump_sects
)
10817 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10821 process_mips_fpe_exception (int mask
)
10826 if (mask
& OEX_FPU_INEX
)
10827 fputs ("INEX", stdout
), first
= 0;
10828 if (mask
& OEX_FPU_UFLO
)
10829 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10830 if (mask
& OEX_FPU_OFLO
)
10831 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10832 if (mask
& OEX_FPU_DIV0
)
10833 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10834 if (mask
& OEX_FPU_INVAL
)
10835 printf ("%sINVAL", first
? "" : "|");
10838 fputs ("0", stdout
);
10842 process_mips_specific (FILE *file
)
10844 Elf_Internal_Dyn
*entry
;
10845 size_t liblist_offset
= 0;
10846 size_t liblistno
= 0;
10847 size_t conflictsno
= 0;
10848 size_t options_offset
= 0;
10849 size_t conflicts_offset
= 0;
10851 /* We have a lot of special sections. Thanks SGI! */
10852 if (dynamic_section
== NULL
)
10853 /* No information available. */
10856 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10857 switch (entry
->d_tag
)
10859 case DT_MIPS_LIBLIST
:
10861 = offset_from_vma (file
, entry
->d_un
.d_val
,
10862 liblistno
* sizeof (Elf32_External_Lib
));
10864 case DT_MIPS_LIBLISTNO
:
10865 liblistno
= entry
->d_un
.d_val
;
10867 case DT_MIPS_OPTIONS
:
10868 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10870 case DT_MIPS_CONFLICT
:
10872 = offset_from_vma (file
, entry
->d_un
.d_val
,
10873 conflictsno
* sizeof (Elf32_External_Conflict
));
10875 case DT_MIPS_CONFLICTNO
:
10876 conflictsno
= entry
->d_un
.d_val
;
10882 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
10884 Elf32_External_Lib
*elib
;
10887 elib
= get_data (NULL
, file
, liblist_offset
,
10888 liblistno
* sizeof (Elf32_External_Lib
),
10892 printf ("\nSection '.liblist' contains %lu entries:\n",
10893 (unsigned long) liblistno
);
10894 fputs (" Library Time Stamp Checksum Version Flags\n",
10897 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
10904 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10905 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10906 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10907 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10908 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10910 tmp
= gmtime (&time
);
10911 snprintf (timebuf
, sizeof (timebuf
),
10912 "%04u-%02u-%02uT%02u:%02u:%02u",
10913 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10914 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10916 printf ("%3lu: ", (unsigned long) cnt
);
10917 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
10918 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
10920 printf ("<corrupt: %9ld>", liblist
.l_name
);
10921 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
10922 liblist
.l_version
);
10924 if (liblist
.l_flags
== 0)
10928 static const struct
10935 { " EXACT_MATCH", LL_EXACT_MATCH
},
10936 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
10937 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
10938 { " EXPORTS", LL_EXPORTS
},
10939 { " DELAY_LOAD", LL_DELAY_LOAD
},
10940 { " DELTA", LL_DELTA
}
10942 int flags
= liblist
.l_flags
;
10946 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
10948 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
10950 fputs (l_flags_vals
[fcnt
].name
, stdout
);
10951 flags
^= l_flags_vals
[fcnt
].bit
;
10954 printf (" %#x", (unsigned int) flags
);
10964 if (options_offset
!= 0)
10966 Elf_External_Options
*eopt
;
10967 Elf_Internal_Shdr
*sect
= section_headers
;
10968 Elf_Internal_Options
*iopt
;
10969 Elf_Internal_Options
*option
;
10973 /* Find the section header so that we get the size. */
10974 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10977 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10981 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10984 error (_("Out of memory"));
10991 while (offset
< sect
->sh_size
)
10993 Elf_External_Options
*eoption
;
10995 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10997 option
->kind
= BYTE_GET (eoption
->kind
);
10998 option
->size
= BYTE_GET (eoption
->size
);
10999 option
->section
= BYTE_GET (eoption
->section
);
11000 option
->info
= BYTE_GET (eoption
->info
);
11002 offset
+= option
->size
;
11008 printf (_("\nSection '%s' contains %d entries:\n"),
11009 SECTION_NAME (sect
), cnt
);
11017 switch (option
->kind
)
11020 /* This shouldn't happen. */
11021 printf (" NULL %d %lx", option
->section
, option
->info
);
11024 printf (" REGINFO ");
11025 if (elf_header
.e_machine
== EM_MIPS
)
11028 Elf32_External_RegInfo
*ereg
;
11029 Elf32_RegInfo reginfo
;
11031 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11032 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11033 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11034 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11035 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11036 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11037 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11039 printf ("GPR %08lx GP 0x%lx\n",
11040 reginfo
.ri_gprmask
,
11041 (unsigned long) reginfo
.ri_gp_value
);
11042 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11043 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11044 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11049 Elf64_External_RegInfo
*ereg
;
11050 Elf64_Internal_RegInfo reginfo
;
11052 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11053 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11054 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11055 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11056 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11057 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11058 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11060 printf ("GPR %08lx GP 0x",
11061 reginfo
.ri_gprmask
);
11062 printf_vma (reginfo
.ri_gp_value
);
11065 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11066 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11067 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11071 case ODK_EXCEPTIONS
:
11072 fputs (" EXCEPTIONS fpe_min(", stdout
);
11073 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11074 fputs (") fpe_max(", stdout
);
11075 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11076 fputs (")", stdout
);
11078 if (option
->info
& OEX_PAGE0
)
11079 fputs (" PAGE0", stdout
);
11080 if (option
->info
& OEX_SMM
)
11081 fputs (" SMM", stdout
);
11082 if (option
->info
& OEX_FPDBUG
)
11083 fputs (" FPDBUG", stdout
);
11084 if (option
->info
& OEX_DISMISS
)
11085 fputs (" DISMISS", stdout
);
11088 fputs (" PAD ", stdout
);
11089 if (option
->info
& OPAD_PREFIX
)
11090 fputs (" PREFIX", stdout
);
11091 if (option
->info
& OPAD_POSTFIX
)
11092 fputs (" POSTFIX", stdout
);
11093 if (option
->info
& OPAD_SYMBOL
)
11094 fputs (" SYMBOL", stdout
);
11097 fputs (" HWPATCH ", stdout
);
11098 if (option
->info
& OHW_R4KEOP
)
11099 fputs (" R4KEOP", stdout
);
11100 if (option
->info
& OHW_R8KPFETCH
)
11101 fputs (" R8KPFETCH", stdout
);
11102 if (option
->info
& OHW_R5KEOP
)
11103 fputs (" R5KEOP", stdout
);
11104 if (option
->info
& OHW_R5KCVTL
)
11105 fputs (" R5KCVTL", stdout
);
11108 fputs (" FILL ", stdout
);
11109 /* XXX Print content of info word? */
11112 fputs (" TAGS ", stdout
);
11113 /* XXX Print content of info word? */
11116 fputs (" HWAND ", stdout
);
11117 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11118 fputs (" R4KEOP_CHECKED", stdout
);
11119 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11120 fputs (" R4KEOP_CLEAN", stdout
);
11123 fputs (" HWOR ", stdout
);
11124 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11125 fputs (" R4KEOP_CHECKED", stdout
);
11126 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11127 fputs (" R4KEOP_CLEAN", stdout
);
11130 printf (" GP_GROUP %#06lx self-contained %#06lx",
11131 option
->info
& OGP_GROUP
,
11132 (option
->info
& OGP_SELF
) >> 16);
11135 printf (" IDENT %#06lx self-contained %#06lx",
11136 option
->info
& OGP_GROUP
,
11137 (option
->info
& OGP_SELF
) >> 16);
11140 /* This shouldn't happen. */
11141 printf (" %3d ??? %d %lx",
11142 option
->kind
, option
->section
, option
->info
);
11146 len
= sizeof (*eopt
);
11147 while (len
< option
->size
)
11148 if (((char *) option
)[len
] >= ' '
11149 && ((char *) option
)[len
] < 0x7f)
11150 printf ("%c", ((char *) option
)[len
++]);
11152 printf ("\\%03o", ((char *) option
)[len
++]);
11154 fputs ("\n", stdout
);
11162 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11164 Elf32_Conflict
*iconf
;
11167 if (dynamic_symbols
== NULL
)
11169 error (_("conflict list found without a dynamic symbol table"));
11173 iconf
= malloc (conflictsno
* sizeof (*iconf
));
11176 error (_("Out of memory"));
11182 Elf32_External_Conflict
*econf32
;
11184 econf32
= get_data (NULL
, file
, conflicts_offset
,
11185 conflictsno
* sizeof (*econf32
), _("conflict"));
11189 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11190 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11196 Elf64_External_Conflict
*econf64
;
11198 econf64
= get_data (NULL
, file
, conflicts_offset
,
11199 conflictsno
* sizeof (*econf64
), _("conflict"));
11203 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11204 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11209 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11210 (unsigned long) conflictsno
);
11211 puts (_(" Num: Index Value Name"));
11213 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11215 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
11217 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11218 print_vma (psym
->st_value
, FULL_HEX
);
11220 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11221 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11223 printf ("<corrupt: %14ld>", psym
->st_name
);
11234 process_gnu_liblist (FILE *file
)
11236 Elf_Internal_Shdr
*section
, *string_sec
;
11237 Elf32_External_Lib
*elib
;
11245 for (i
= 0, section
= section_headers
;
11246 i
< elf_header
.e_shnum
;
11249 switch (section
->sh_type
)
11251 case SHT_GNU_LIBLIST
:
11252 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
11257 string_sec
= SECTION_HEADER (section
->sh_link
);
11259 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
11260 string_sec
->sh_size
, _("liblist string table"));
11263 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11269 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11270 SECTION_NAME (section
),
11271 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11273 puts (" Library Time Stamp Checksum Version Flags");
11275 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11283 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11284 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11285 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11286 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11287 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11289 tmp
= gmtime (&time
);
11290 snprintf (timebuf
, sizeof (timebuf
),
11291 "%04u-%02u-%02uT%02u:%02u:%02u",
11292 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11293 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11295 printf ("%3lu: ", (unsigned long) cnt
);
11297 printf ("%-20s", strtab
+ liblist
.l_name
);
11299 printf ("%-20.20s", strtab
+ liblist
.l_name
);
11300 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11301 liblist
.l_version
, liblist
.l_flags
);
11311 static const char *
11312 get_note_type (unsigned e_type
)
11314 static char buff
[64];
11316 if (elf_header
.e_type
== ET_CORE
)
11320 return _("NT_AUXV (auxiliary vector)");
11322 return _("NT_PRSTATUS (prstatus structure)");
11324 return _("NT_FPREGSET (floating point registers)");
11326 return _("NT_PRPSINFO (prpsinfo structure)");
11327 case NT_TASKSTRUCT
:
11328 return _("NT_TASKSTRUCT (task structure)");
11330 return _("NT_PRXFPREG (user_xfpregs structure)");
11332 return _("NT_PSTATUS (pstatus structure)");
11334 return _("NT_FPREGS (floating point registers)");
11336 return _("NT_PSINFO (psinfo structure)");
11338 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11340 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11341 case NT_WIN32PSTATUS
:
11342 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11350 return _("NT_VERSION (version)");
11352 return _("NT_ARCH (architecture)");
11357 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11361 static const char *
11362 get_netbsd_elfcore_note_type (unsigned e_type
)
11364 static char buff
[64];
11366 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11368 /* NetBSD core "procinfo" structure. */
11369 return _("NetBSD procinfo structure");
11372 /* As of Jan 2002 there are no other machine-independent notes
11373 defined for NetBSD core files. If the note type is less
11374 than the start of the machine-dependent note types, we don't
11377 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11379 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11383 switch (elf_header
.e_machine
)
11385 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11386 and PT_GETFPREGS == mach+2. */
11391 case EM_SPARC32PLUS
:
11395 case NT_NETBSDCORE_FIRSTMACH
+0:
11396 return _("PT_GETREGS (reg structure)");
11397 case NT_NETBSDCORE_FIRSTMACH
+2:
11398 return _("PT_GETFPREGS (fpreg structure)");
11404 /* On all other arch's, PT_GETREGS == mach+1 and
11405 PT_GETFPREGS == mach+3. */
11409 case NT_NETBSDCORE_FIRSTMACH
+1:
11410 return _("PT_GETREGS (reg structure)");
11411 case NT_NETBSDCORE_FIRSTMACH
+3:
11412 return _("PT_GETFPREGS (fpreg structure)");
11418 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11419 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11423 /* Note that by the ELF standard, the name field is already null byte
11424 terminated, and namesz includes the terminating null byte.
11425 I.E. the value of namesz for the name "FSF" is 4.
11427 If the value of namesz is zero, there is no name present. */
11429 process_note (Elf_Internal_Note
*pnote
)
11433 if (pnote
->namesz
== 0)
11434 /* If there is no note name, then use the default set of
11435 note type strings. */
11436 nt
= get_note_type (pnote
->type
);
11438 else if (strneq (pnote
->namedata
, "NetBSD-CORE", 11))
11439 /* NetBSD-specific core file notes. */
11440 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11443 /* Don't recognize this note name; just use the default set of
11444 note type strings. */
11445 nt
= get_note_type (pnote
->type
);
11447 printf (" %s\t\t0x%08lx\t%s\n",
11448 pnote
->namesz
? pnote
->namedata
: "(NONE)",
11449 pnote
->descsz
, nt
);
11455 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
11457 Elf_External_Note
*pnotes
;
11458 Elf_External_Note
*external
;
11464 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
11470 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11471 (unsigned long) offset
, (unsigned long) length
);
11472 printf (_(" Owner\t\tData size\tDescription\n"));
11474 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
11476 Elf_External_Note
*next
;
11477 Elf_Internal_Note inote
;
11480 inote
.type
= BYTE_GET (external
->type
);
11481 inote
.namesz
= BYTE_GET (external
->namesz
);
11482 inote
.namedata
= external
->name
;
11483 inote
.descsz
= BYTE_GET (external
->descsz
);
11484 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11485 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11487 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
11489 if (((char *) next
) > (((char *) pnotes
) + length
))
11491 warn (_("corrupt note found at offset %x into core notes\n"),
11492 ((char *) external
) - ((char *) pnotes
));
11493 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
11494 inote
.type
, inote
.namesz
, inote
.descsz
);
11500 /* Verify that name is null terminated. It appears that at least
11501 one version of Linux (RedHat 6.0) generates corefiles that don't
11502 comply with the ELF spec by failing to include the null byte in
11504 if (inote
.namedata
[inote
.namesz
] != '\0')
11506 temp
= malloc (inote
.namesz
+ 1);
11510 error (_("Out of memory\n"));
11515 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11516 temp
[inote
.namesz
] = 0;
11518 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11519 inote
.namedata
= temp
;
11522 res
&= process_note (& inote
);
11537 process_corefile_note_segments (FILE *file
)
11539 Elf_Internal_Phdr
*segment
;
11543 if (! get_program_headers (file
))
11546 for (i
= 0, segment
= program_headers
;
11547 i
< elf_header
.e_phnum
;
11550 if (segment
->p_type
== PT_NOTE
)
11551 res
&= process_corefile_note_segment (file
,
11552 (bfd_vma
) segment
->p_offset
,
11553 (bfd_vma
) segment
->p_filesz
);
11560 process_note_sections (FILE *file
)
11562 Elf_Internal_Shdr
*section
;
11566 for (i
= 0, section
= section_headers
;
11567 i
< elf_header
.e_shnum
;
11569 if (section
->sh_type
== SHT_NOTE
)
11570 res
&= process_corefile_note_segment (file
,
11571 (bfd_vma
) section
->sh_offset
,
11572 (bfd_vma
) section
->sh_size
);
11578 process_notes (FILE *file
)
11580 /* If we have not been asked to display the notes then do nothing. */
11584 if (elf_header
.e_type
!= ET_CORE
)
11585 return process_note_sections (file
);
11587 /* No program headers means no NOTE segment. */
11588 if (elf_header
.e_phnum
> 0)
11589 return process_corefile_note_segments (file
);
11591 printf (_("No note segments present in the core file.\n"));
11596 process_arch_specific (FILE *file
)
11601 switch (elf_header
.e_machine
)
11604 case EM_MIPS_RS3_LE
:
11605 return process_mips_specific (file
);
11614 get_file_header (FILE *file
)
11616 /* Read in the identity array. */
11617 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11620 /* Determine how to read the rest of the header. */
11621 switch (elf_header
.e_ident
[EI_DATA
])
11623 default: /* fall through */
11624 case ELFDATANONE
: /* fall through */
11626 byte_get
= byte_get_little_endian
;
11627 byte_put
= byte_put_little_endian
;
11630 byte_get
= byte_get_big_endian
;
11631 byte_put
= byte_put_big_endian
;
11635 /* For now we only support 32 bit and 64 bit ELF files. */
11636 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11638 /* Read in the rest of the header. */
11641 Elf32_External_Ehdr ehdr32
;
11643 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11646 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11647 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11648 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11649 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11650 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11651 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11652 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11653 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11654 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11655 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11656 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11657 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11658 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
11662 Elf64_External_Ehdr ehdr64
;
11664 /* If we have been compiled with sizeof (bfd_vma) == 4, then
11665 we will not be able to cope with the 64bit data found in
11666 64 ELF files. Detect this now and abort before we start
11667 overwriting things. */
11668 if (sizeof (bfd_vma
) < 8)
11670 error (_("This instance of readelf has been built without support for a\n\
11671 64 bit data type and so it cannot read 64 bit ELF files.\n"));
11675 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
11678 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
11679 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
11680 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
11681 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
11682 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
11683 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
11684 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
11685 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
11686 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
11687 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
11688 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
11689 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
11690 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
11693 if (elf_header
.e_shoff
)
11695 /* There may be some extensions in the first section header. Don't
11696 bomb if we can't read it. */
11698 get_32bit_section_headers (file
, 1);
11700 get_64bit_section_headers (file
, 1);
11706 /* Process one ELF object file according to the command line options.
11707 This file may actually be stored in an archive. The file is
11708 positioned at the start of the ELF object. */
11711 process_object (char *file_name
, FILE *file
)
11715 if (! get_file_header (file
))
11717 error (_("%s: Failed to read file header\n"), file_name
);
11721 /* Initialise per file variables. */
11722 for (i
= NUM_ELEM (version_info
); i
--;)
11723 version_info
[i
] = 0;
11725 for (i
= NUM_ELEM (dynamic_info
); i
--;)
11726 dynamic_info
[i
] = 0;
11728 /* Process the file. */
11730 printf (_("\nFile: %s\n"), file_name
);
11732 /* Initialise the dump_sects array from the cmdline_dump_sects array.
11733 Note we do this even if cmdline_dump_sects is empty because we
11734 must make sure that the dump_sets array is zeroed out before each
11735 object file is processed. */
11736 if (num_dump_sects
> num_cmdline_dump_sects
)
11737 memset (dump_sects
, 0, num_dump_sects
);
11739 if (num_cmdline_dump_sects
> 0)
11741 if (num_dump_sects
== 0)
11742 /* A sneaky way of allocating the dump_sects array. */
11743 request_dump (num_cmdline_dump_sects
, 0);
11745 assert (num_dump_sects
>= num_cmdline_dump_sects
);
11746 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11749 if (! process_file_header ())
11752 if (! process_section_headers (file
))
11754 /* Without loaded section headers we cannot process lots of
11756 do_unwind
= do_version
= do_dump
= do_arch
= 0;
11758 if (! do_using_dynamic
)
11759 do_syms
= do_reloc
= 0;
11762 if (! process_section_groups (file
))
11764 /* Without loaded section groups we cannot process unwind. */
11768 if (process_program_headers (file
))
11769 process_dynamic_section (file
);
11771 process_relocs (file
);
11773 process_unwind (file
);
11775 process_symbol_table (file
);
11777 process_syminfo (file
);
11779 process_version_sections (file
);
11781 process_section_contents (file
);
11783 process_notes (file
);
11785 process_gnu_liblist (file
);
11787 process_arch_specific (file
);
11789 if (program_headers
)
11791 free (program_headers
);
11792 program_headers
= NULL
;
11795 if (section_headers
)
11797 free (section_headers
);
11798 section_headers
= NULL
;
11803 free (string_table
);
11804 string_table
= NULL
;
11805 string_table_length
= 0;
11808 if (dynamic_strings
)
11810 free (dynamic_strings
);
11811 dynamic_strings
= NULL
;
11812 dynamic_strings_length
= 0;
11815 if (dynamic_symbols
)
11817 free (dynamic_symbols
);
11818 dynamic_symbols
= NULL
;
11819 num_dynamic_syms
= 0;
11822 if (dynamic_syminfo
)
11824 free (dynamic_syminfo
);
11825 dynamic_syminfo
= NULL
;
11828 if (section_headers_groups
)
11830 free (section_headers_groups
);
11831 section_headers_groups
= NULL
;
11834 if (section_groups
)
11836 struct group_list
*g
, *next
;
11838 for (i
= 0; i
< group_count
; i
++)
11840 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
11847 free (section_groups
);
11848 section_groups
= NULL
;
11851 if (debug_information
)
11853 for (i
= 0; i
< num_debug_info_entries
; i
++)
11855 if (!debug_information
[i
].max_loc_offsets
)
11857 free (debug_information
[i
].loc_offsets
);
11858 free (debug_information
[i
].have_frame_base
);
11860 if (!debug_information
[i
].max_range_lists
)
11861 free (debug_information
[i
].range_lists
);
11863 free (debug_information
);
11864 debug_information
= NULL
;
11865 num_debug_info_entries
= 0;
11871 /* Process an ELF archive. The file is positioned just after the
11875 process_archive (char *file_name
, FILE *file
)
11877 struct ar_hdr arhdr
;
11879 unsigned long size
;
11880 char *longnames
= NULL
;
11881 unsigned long longnames_size
= 0;
11882 size_t file_name_size
;
11887 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11888 if (got
!= sizeof arhdr
)
11893 error (_("%s: failed to read archive header\n"), file_name
);
11897 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
11899 /* This is the archive symbol table. Skip it.
11900 FIXME: We should have an option to dump it. */
11901 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11902 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
11904 error (_("%s: failed to skip archive symbol table\n"), file_name
);
11908 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11909 if (got
!= sizeof arhdr
)
11914 error (_("%s: failed to read archive header\n"), file_name
);
11919 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
11921 /* This is the archive string table holding long member
11924 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
11926 longnames
= malloc (longnames_size
);
11927 if (longnames
== NULL
)
11929 error (_("Out of memory\n"));
11933 if (fread (longnames
, longnames_size
, 1, file
) != 1)
11936 error (_("%s: failed to read string table\n"), file_name
);
11940 if ((longnames_size
& 1) != 0)
11943 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
11944 if (got
!= sizeof arhdr
)
11951 error (_("%s: failed to read archive header\n"), file_name
);
11956 file_name_size
= strlen (file_name
);
11965 if (arhdr
.ar_name
[0] == '/')
11969 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
11970 if (off
>= longnames_size
)
11972 error (_("%s: invalid archive string table offset %lu\n"), off
);
11977 name
= longnames
+ off
;
11978 nameend
= memchr (name
, '/', longnames_size
- off
);
11982 name
= arhdr
.ar_name
;
11983 nameend
= memchr (name
, '/', 16);
11986 if (nameend
== NULL
)
11988 error (_("%s: bad archive file name\n"));
11993 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
11994 if (namealc
== NULL
)
11996 error (_("Out of memory\n"));
12001 memcpy (namealc
, file_name
, file_name_size
);
12002 namealc
[file_name_size
] = '(';
12003 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
12004 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
12005 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
12007 archive_file_offset
= ftell (file
);
12008 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
12010 ret
|= process_object (namealc
, file
);
12015 (archive_file_offset
12016 + archive_file_size
12017 + (archive_file_size
& 1)),
12020 error (_("%s: failed to seek to next archive header\n"), file_name
);
12025 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
12026 if (got
!= sizeof arhdr
)
12031 error (_("%s: failed to read archive header\n"), file_name
);
12037 if (longnames
!= 0)
12044 process_file (char *file_name
)
12047 struct stat statbuf
;
12048 char armag
[SARMAG
];
12051 if (stat (file_name
, &statbuf
) < 0)
12053 if (errno
== ENOENT
)
12054 error (_("'%s': No such file\n"), file_name
);
12056 error (_("Could not locate '%s'. System error message: %s\n"),
12057 file_name
, strerror (errno
));
12061 if (! S_ISREG (statbuf
.st_mode
))
12063 error (_("'%s' is not an ordinary file\n"), file_name
);
12067 file
= fopen (file_name
, "rb");
12070 error (_("Input file '%s' is not readable.\n"), file_name
);
12074 if (fread (armag
, SARMAG
, 1, file
) != 1)
12076 error (_("%s: Failed to read file header\n"), file_name
);
12081 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12082 ret
= process_archive (file_name
, file
);
12086 archive_file_size
= archive_file_offset
= 0;
12087 ret
= process_object (file_name
, file
);
12095 #ifdef SUPPORT_DISASSEMBLY
12096 /* Needed by the i386 disassembler. For extra credit, someone could
12097 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12101 print_address (unsigned int addr
, FILE *outfile
)
12103 fprintf (outfile
,"0x%8.8x", addr
);
12106 /* Needed by the i386 disassembler. */
12108 db_task_printsym (unsigned int addr
)
12110 print_address (addr
, stderr
);
12115 main (int argc
, char **argv
)
12119 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12120 setlocale (LC_MESSAGES
, "");
12122 #if defined (HAVE_SETLOCALE)
12123 setlocale (LC_CTYPE
, "");
12125 bindtextdomain (PACKAGE
, LOCALEDIR
);
12126 textdomain (PACKAGE
);
12128 parse_args (argc
, argv
);
12130 if (num_dump_sects
> 0)
12132 /* Make a copy of the dump_sects array. */
12133 cmdline_dump_sects
= malloc (num_dump_sects
);
12134 if (cmdline_dump_sects
== NULL
)
12135 error (_("Out of memory allocating dump request table."));
12138 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
12139 num_cmdline_dump_sects
= num_dump_sects
;
12143 if (optind
< (argc
- 1))
12147 while (optind
< argc
)
12148 err
|= process_file (argv
[optind
++]);
12150 if (dump_sects
!= NULL
)
12152 if (cmdline_dump_sects
!= NULL
)
12153 free (cmdline_dump_sects
);