1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capabale of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
44 #include <sys/types.h>
50 /* Define BFD64 here, even if our default architecture is 32 bit ELF
51 as this will allow us to read in and parse 64bit and 32bit ELF files.
52 Only do this if we believe that the compiler can support a 64 bit
53 data type. For now we only rely on GCC being able to do this. */
59 #include "elf/common.h"
60 #include "elf/external.h"
61 #include "elf/internal.h"
62 #include "elf/dwarf2.h"
64 /* The following headers use the elf/reloc-macros.h file to
65 automatically generate relocation recognition functions
66 such as elf_mips_reloc_type() */
68 #define RELOC_MACROS_GEN_FUNC
70 #include "elf/alpha.h"
90 #include "elf/m68hc11.h"
91 #include "elf/mcore.h"
94 #include "elf/mn10200.h"
95 #include "elf/mn10300.h"
96 #include "elf/msp430.h"
100 #include "elf/ppc64.h"
101 #include "elf/s390.h"
103 #include "elf/sparc.h"
104 #include "elf/v850.h"
106 #include "elf/x86-64.h"
107 #include "elf/xstormy16.h"
109 #include "elf/iq2000.h"
110 #include "elf/xtensa.h"
116 #include "libiberty.h"
118 char *program_name
= "readelf";
119 long archive_file_offset
;
120 unsigned long archive_file_size
;
121 unsigned long dynamic_addr
;
122 bfd_size_type dynamic_size
;
123 unsigned int dynamic_nent
;
124 char *dynamic_strings
;
126 unsigned long string_table_length
;
127 unsigned long num_dynamic_syms
;
128 Elf_Internal_Sym
*dynamic_symbols
;
129 Elf_Internal_Syminfo
*dynamic_syminfo
;
130 unsigned long dynamic_syminfo_offset
;
131 unsigned int dynamic_syminfo_nent
;
132 char program_interpreter
[64];
133 bfd_vma dynamic_info
[DT_JMPREL
+ 1];
134 bfd_vma version_info
[16];
135 Elf_Internal_Ehdr elf_header
;
136 Elf_Internal_Shdr
*section_headers
;
137 Elf_Internal_Phdr
*program_headers
;
138 Elf_Internal_Dyn
*dynamic_section
;
139 Elf_Internal_Shdr
*symtab_shndx_hdr
;
145 int do_section_groups
;
148 int do_using_dynamic
;
156 int do_debug_abbrevs
;
158 int do_debug_pubnames
;
159 int do_debug_aranges
;
161 int do_debug_frames_interp
;
162 int do_debug_macinfo
;
171 struct group_list
*next
;
172 unsigned int section_index
;
177 struct group_list
*root
;
178 unsigned int group_index
;
181 struct group
*section_groups
;
182 size_t group_count
= 0;
184 struct group
**section_headers_groups
;
186 /* A dynamic array of flags indicating which sections require dumping. */
187 char *dump_sects
= NULL
;
188 unsigned int num_dump_sects
= 0;
190 #define HEX_DUMP (1 << 0)
191 #define DISASS_DUMP (1 << 1)
192 #define DEBUG_DUMP (1 << 2)
194 /* How to rpint a vma value. */
195 typedef enum print_mode
207 static bfd_vma (*byte_get
) (unsigned char *, int);
208 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
212 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
213 ((X)->sh_name >= string_table_length \
214 ? "<corrupt>" : string_table + (X)->sh_name))
216 /* Given st_shndx I, map to section_headers index. */
217 #define SECTION_HEADER_INDEX(I) \
218 ((I) < SHN_LORESERVE \
220 : ((I) <= SHN_HIRESERVE \
222 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
224 /* Reverse of the above. */
225 #define SECTION_HEADER_NUM(N) \
226 ((N) < SHN_LORESERVE \
228 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
230 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
232 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
234 #define BYTE_GET(field) byte_get (field, sizeof (field))
236 /* If we can support a 64 bit data type then BFD64 should be defined
237 and sizeof (bfd_vma) == 8. In this case when translating from an
238 external 8 byte field to an internal field, we can assume that the
239 internal field is also 8 bytes wide and so we can extract all the data.
240 If, however, BFD64 is not defined, then we must assume that the
241 internal data structure only has 4 byte wide fields that are the
242 equivalent of the 8 byte wide external counterparts, and so we must
243 truncate the data. */
245 #define BYTE_GET8(field) byte_get (field, -8)
247 #define BYTE_GET8(field) byte_get (field, 8)
250 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
252 #define GET_ELF_SYMBOLS(file, section) \
253 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
254 : get_64bit_elf_symbols (file, section))
258 error (const char *message
, ...)
262 va_start (args
, message
);
263 fprintf (stderr
, _("%s: Error: "), program_name
);
264 vfprintf (stderr
, message
, args
);
269 warn (const char *message
, ...)
273 va_start (args
, message
);
274 fprintf (stderr
, _("%s: Warning: "), program_name
);
275 vfprintf (stderr
, message
, args
);
280 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
287 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
289 error (_("Unable to seek to 0x%x for %s\n"),
290 archive_file_offset
+ offset
, reason
);
297 mvar
= malloc (size
);
301 error (_("Out of memory allocating 0x%x bytes for %s\n"),
307 if (fread (mvar
, size
, 1, file
) != 1)
309 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
319 byte_get_little_endian (unsigned char *field
, int size
)
327 return ((unsigned int) (field
[0]))
328 | (((unsigned int) (field
[1])) << 8);
332 /* We want to extract data from an 8 byte wide field and
333 place it into a 4 byte wide field. Since this is a little
334 endian source we can just use the 4 byte extraction code. */
338 return ((unsigned long) (field
[0]))
339 | (((unsigned long) (field
[1])) << 8)
340 | (((unsigned long) (field
[2])) << 16)
341 | (((unsigned long) (field
[3])) << 24);
346 /* This is a special case, generated by the BYTE_GET8 macro.
347 It means that we are loading an 8 byte value from a field
348 in an external structure into an 8 byte value in a field
349 in an internal structure. */
350 return ((bfd_vma
) (field
[0]))
351 | (((bfd_vma
) (field
[1])) << 8)
352 | (((bfd_vma
) (field
[2])) << 16)
353 | (((bfd_vma
) (field
[3])) << 24)
354 | (((bfd_vma
) (field
[4])) << 32)
355 | (((bfd_vma
) (field
[5])) << 40)
356 | (((bfd_vma
) (field
[6])) << 48)
357 | (((bfd_vma
) (field
[7])) << 56);
360 error (_("Unhandled data length: %d\n"), size
);
366 byte_get_signed (unsigned char *field
, int size
)
368 bfd_vma x
= byte_get (field
, size
);
373 return (x
^ 0x80) - 0x80;
375 return (x
^ 0x8000) - 0x8000;
377 return (x
^ 0x80000000) - 0x80000000;
387 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
392 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
393 field
[6] = ((value
>> 24) >> 24) & 0xff;
394 field
[5] = ((value
>> 24) >> 16) & 0xff;
395 field
[4] = ((value
>> 24) >> 8) & 0xff;
398 field
[3] = (value
>> 24) & 0xff;
399 field
[2] = (value
>> 16) & 0xff;
402 field
[1] = (value
>> 8) & 0xff;
405 field
[0] = value
& 0xff;
409 error (_("Unhandled data length: %d\n"), size
);
414 /* Print a VMA value. */
416 print_vma (bfd_vma vma
, print_mode mode
)
428 printf ("%8.8lx", (unsigned long) vma
);
434 printf ("%5ld", (long) vma
);
442 printf ("%lx", (unsigned long) vma
);
446 printf ("%ld", (unsigned long) vma
);
450 printf ("%lu", (unsigned long) vma
);
472 #if BFD_HOST_64BIT_LONG
475 if (_bfd_int64_high (vma
))
476 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
478 printf ("%lx", _bfd_int64_low (vma
));
483 #if BFD_HOST_64BIT_LONG
486 if (_bfd_int64_high (vma
))
488 printf ("++%ld", _bfd_int64_low (vma
));
490 printf ("%ld", _bfd_int64_low (vma
));
495 #if BFD_HOST_64BIT_LONG
497 printf ("%5ld", vma
);
499 printf ("%#lx", vma
);
501 if (_bfd_int64_high (vma
))
503 printf ("++%ld", _bfd_int64_low (vma
));
504 else if (vma
<= 99999)
505 printf ("%5ld", _bfd_int64_low (vma
));
507 printf ("%#lx", _bfd_int64_low (vma
));
512 #if BFD_HOST_64BIT_LONG
515 if (_bfd_int64_high (vma
))
517 printf ("++%lu", _bfd_int64_low (vma
));
519 printf ("%lu", _bfd_int64_low (vma
));
527 /* Display a symbol on stdout. If do_wide is not true then
528 format the symbol to be at most WIDTH characters,
529 truncating as necessary. If WIDTH is negative then
530 format the string to be exactly - WIDTH characters,
531 truncating or padding as necessary. */
534 print_symbol (int width
, const char *symbol
)
537 printf ("%s", symbol
);
539 printf ("%-*.*s", width
, width
, symbol
);
541 printf ("%-.*s", width
, symbol
);
545 byte_get_big_endian (unsigned char *field
, int size
)
553 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
556 return ((unsigned long) (field
[3]))
557 | (((unsigned long) (field
[2])) << 8)
558 | (((unsigned long) (field
[1])) << 16)
559 | (((unsigned long) (field
[0])) << 24);
563 /* Although we are extracing data from an 8 byte wide field, we
564 are returning only 4 bytes of data. */
565 return ((unsigned long) (field
[7]))
566 | (((unsigned long) (field
[6])) << 8)
567 | (((unsigned long) (field
[5])) << 16)
568 | (((unsigned long) (field
[4])) << 24);
572 /* This is a special case, generated by the BYTE_GET8 macro.
573 It means that we are loading an 8 byte value from a field
574 in an external structure into an 8 byte value in a field
575 in an internal structure. */
576 return ((bfd_vma
) (field
[7]))
577 | (((bfd_vma
) (field
[6])) << 8)
578 | (((bfd_vma
) (field
[5])) << 16)
579 | (((bfd_vma
) (field
[4])) << 24)
580 | (((bfd_vma
) (field
[3])) << 32)
581 | (((bfd_vma
) (field
[2])) << 40)
582 | (((bfd_vma
) (field
[1])) << 48)
583 | (((bfd_vma
) (field
[0])) << 56);
587 error (_("Unhandled data length: %d\n"), size
);
593 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
598 field
[7] = value
& 0xff;
599 field
[6] = (value
>> 8) & 0xff;
600 field
[5] = (value
>> 16) & 0xff;
601 field
[4] = (value
>> 24) & 0xff;
606 field
[3] = value
& 0xff;
607 field
[2] = (value
>> 8) & 0xff;
611 field
[1] = value
& 0xff;
615 field
[0] = value
& 0xff;
619 error (_("Unhandled data length: %d\n"), size
);
624 /* Guess the relocation size commonly used by the specific machines. */
627 guess_is_rela (unsigned long e_machine
)
631 /* Targets that use REL relocations. */
646 /* Targets that use RELA relocations. */
661 case EM_CYGNUS_MN10200
:
663 case EM_CYGNUS_MN10300
:
710 warn (_("Don't know about relocations on this machine architecture\n"));
716 slurp_rela_relocs (FILE *file
,
717 unsigned long rel_offset
,
718 unsigned long rel_size
,
719 Elf_Internal_Rela
**relasp
,
720 unsigned long *nrelasp
)
722 Elf_Internal_Rela
*relas
;
723 unsigned long nrelas
;
728 Elf32_External_Rela
*erelas
;
730 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
734 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
736 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
740 error(_("out of memory parsing relocs"));
744 for (i
= 0; i
< nrelas
; i
++)
746 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
747 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
748 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
755 Elf64_External_Rela
*erelas
;
757 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
761 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
763 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
767 error(_("out of memory parsing relocs"));
771 for (i
= 0; i
< nrelas
; i
++)
773 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
774 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
775 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
786 slurp_rel_relocs (FILE *file
,
787 unsigned long rel_offset
,
788 unsigned long rel_size
,
789 Elf_Internal_Rela
**relsp
,
790 unsigned long *nrelsp
)
792 Elf_Internal_Rela
*rels
;
798 Elf32_External_Rel
*erels
;
800 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
804 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
806 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
810 error(_("out of memory parsing relocs"));
814 for (i
= 0; i
< nrels
; i
++)
816 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
817 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
818 rels
[i
].r_addend
= 0;
825 Elf64_External_Rel
*erels
;
827 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
831 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
833 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
837 error(_("out of memory parsing relocs"));
841 for (i
= 0; i
< nrels
; i
++)
843 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
844 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
845 rels
[i
].r_addend
= 0;
855 /* Display the contents of the relocation data found at the specified
859 dump_relocations (FILE *file
,
860 unsigned long rel_offset
,
861 unsigned long rel_size
,
862 Elf_Internal_Sym
*symtab
,
868 Elf_Internal_Rela
*rels
;
871 if (is_rela
== UNKNOWN
)
872 is_rela
= guess_is_rela (elf_header
.e_machine
);
876 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
881 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
890 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
892 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
897 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
899 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
907 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
909 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
914 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
916 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
920 for (i
= 0; i
< rel_size
; i
++)
923 const char *rtype2
= NULL
;
924 const char *rtype3
= NULL
;
927 bfd_vma symtab_index
;
932 offset
= rels
[i
].r_offset
;
933 info
= rels
[i
].r_info
;
937 type
= ELF32_R_TYPE (info
);
938 symtab_index
= ELF32_R_SYM (info
);
942 /* The #ifdef BFD64 below is to prevent a compile time warning.
943 We know that if we do not have a 64 bit data type that we
944 will never execute this code anyway. */
946 if (elf_header
.e_machine
== EM_MIPS
)
948 /* In little-endian objects, r_info isn't really a 64-bit
949 little-endian value: it has a 32-bit little-endian
950 symbol index followed by four individual byte fields.
951 Reorder INFO accordingly. */
952 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
953 info
= (((info
& 0xffffffff) << 32)
954 | ((info
>> 56) & 0xff)
955 | ((info
>> 40) & 0xff00)
956 | ((info
>> 24) & 0xff0000)
957 | ((info
>> 8) & 0xff000000));
958 type
= ELF64_MIPS_R_TYPE (info
);
959 type2
= ELF64_MIPS_R_TYPE2 (info
);
960 type3
= ELF64_MIPS_R_TYPE3 (info
);
962 else if (elf_header
.e_machine
== EM_SPARCV9
)
963 type
= ELF64_R_TYPE_ID (info
);
965 type
= ELF64_R_TYPE (info
);
967 symtab_index
= ELF64_R_SYM (info
);
973 #ifdef _bfd_int64_low
974 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
976 printf ("%8.8lx %8.8lx ", offset
, info
);
981 #ifdef _bfd_int64_low
983 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
984 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
985 _bfd_int64_high (offset
),
986 _bfd_int64_low (offset
),
987 _bfd_int64_high (info
),
988 _bfd_int64_low (info
));
991 ? "%16.16lx %16.16lx "
992 : "%12.12lx %12.12lx ",
997 switch (elf_header
.e_machine
)
1004 case EM_CYGNUS_M32R
:
1005 rtype
= elf_m32r_reloc_type (type
);
1010 rtype
= elf_i386_reloc_type (type
);
1015 rtype
= elf_m68hc11_reloc_type (type
);
1019 rtype
= elf_m68k_reloc_type (type
);
1023 rtype
= elf_i960_reloc_type (type
);
1028 rtype
= elf_avr_reloc_type (type
);
1031 case EM_OLD_SPARCV9
:
1032 case EM_SPARC32PLUS
:
1035 rtype
= elf_sparc_reloc_type (type
);
1039 case EM_CYGNUS_V850
:
1040 rtype
= v850_reloc_type (type
);
1044 case EM_CYGNUS_D10V
:
1045 rtype
= elf_d10v_reloc_type (type
);
1049 case EM_CYGNUS_D30V
:
1050 rtype
= elf_d30v_reloc_type (type
);
1054 rtype
= elf_dlx_reloc_type (type
);
1058 rtype
= elf_sh_reloc_type (type
);
1062 case EM_CYGNUS_MN10300
:
1063 rtype
= elf_mn10300_reloc_type (type
);
1067 case EM_CYGNUS_MN10200
:
1068 rtype
= elf_mn10200_reloc_type (type
);
1072 case EM_CYGNUS_FR30
:
1073 rtype
= elf_fr30_reloc_type (type
);
1077 rtype
= elf_frv_reloc_type (type
);
1081 rtype
= elf_mcore_reloc_type (type
);
1085 rtype
= elf_mmix_reloc_type (type
);
1090 rtype
= elf_msp430_reloc_type (type
);
1094 rtype
= elf_ppc_reloc_type (type
);
1098 rtype
= elf_ppc64_reloc_type (type
);
1102 case EM_MIPS_RS3_LE
:
1103 rtype
= elf_mips_reloc_type (type
);
1106 rtype2
= elf_mips_reloc_type (type2
);
1107 rtype3
= elf_mips_reloc_type (type3
);
1112 rtype
= elf_alpha_reloc_type (type
);
1116 rtype
= elf_arm_reloc_type (type
);
1120 rtype
= elf_arc_reloc_type (type
);
1124 rtype
= elf_hppa_reloc_type (type
);
1130 rtype
= elf_h8_reloc_type (type
);
1135 rtype
= elf_or32_reloc_type (type
);
1140 rtype
= elf_pj_reloc_type (type
);
1143 rtype
= elf_ia64_reloc_type (type
);
1147 rtype
= elf_cris_reloc_type (type
);
1151 rtype
= elf_i860_reloc_type (type
);
1155 rtype
= elf_x86_64_reloc_type (type
);
1159 rtype
= i370_reloc_type (type
);
1164 rtype
= elf_s390_reloc_type (type
);
1168 rtype
= elf_xstormy16_reloc_type (type
);
1172 rtype
= elf_crx_reloc_type (type
);
1176 rtype
= elf_vax_reloc_type (type
);
1181 rtype
= elf_ip2k_reloc_type (type
);
1185 rtype
= elf_iq2000_reloc_type (type
);
1190 rtype
= elf_xtensa_reloc_type (type
);
1195 #ifdef _bfd_int64_low
1196 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1198 printf (_("unrecognized: %-7lx"), type
);
1201 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1205 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1206 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1209 Elf_Internal_Sym
*psym
;
1211 psym
= symtab
+ symtab_index
;
1214 print_vma (psym
->st_value
, LONG_HEX
);
1215 printf (is_32bit_elf
? " " : " ");
1217 if (psym
->st_name
== 0)
1219 const char *sec_name
= "<null>";
1222 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1224 bfd_vma sec_index
= (bfd_vma
) -1;
1226 if (psym
->st_shndx
< SHN_LORESERVE
)
1227 sec_index
= psym
->st_shndx
;
1228 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1229 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1232 if (sec_index
!= (bfd_vma
) -1)
1233 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1234 else if (psym
->st_shndx
== SHN_ABS
)
1236 else if (psym
->st_shndx
== SHN_COMMON
)
1237 sec_name
= "COMMON";
1238 else if (elf_header
.e_machine
== EM_IA_64
1239 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1240 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1241 sec_name
= "ANSI_COM";
1244 sprintf (name_buf
, "<section 0x%x>",
1245 (unsigned int) psym
->st_shndx
);
1246 sec_name
= name_buf
;
1249 print_symbol (22, sec_name
);
1251 else if (strtab
== NULL
)
1252 printf (_("<string table index %3ld>"), psym
->st_name
);
1254 print_symbol (22, strtab
+ psym
->st_name
);
1257 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1262 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1263 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1266 if (elf_header
.e_machine
== EM_SPARCV9
1267 && !strcmp (rtype
, "R_SPARC_OLO10"))
1268 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1272 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1274 printf (" Type2: ");
1277 #ifdef _bfd_int64_low
1278 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1280 printf (_("unrecognized: %-7lx"), type2
);
1283 printf ("%-17.17s", rtype2
);
1285 printf("\n Type3: ");
1288 #ifdef _bfd_int64_low
1289 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1291 printf (_("unrecognized: %-7lx"), type3
);
1294 printf ("%-17.17s", rtype3
);
1306 get_mips_dynamic_type (unsigned long type
)
1310 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1311 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1312 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1313 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1314 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1315 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1316 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1317 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1318 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1319 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1320 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1321 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1322 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1323 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1324 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1325 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1326 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1327 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1328 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1329 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1330 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1331 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1332 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1333 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1334 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1335 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1336 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1337 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1338 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1339 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1340 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1341 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1342 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1343 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1344 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1345 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1346 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1347 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1348 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1349 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1350 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1351 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1352 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1359 get_sparc64_dynamic_type (unsigned long type
)
1363 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1370 get_ppc64_dynamic_type (unsigned long type
)
1374 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1375 case DT_PPC64_OPD
: return "PPC64_OPD";
1376 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1383 get_parisc_dynamic_type (unsigned long type
)
1387 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1388 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1389 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1390 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1391 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1392 case DT_HP_PREINIT
: return "HP_PREINIT";
1393 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1394 case DT_HP_NEEDED
: return "HP_NEEDED";
1395 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1396 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1397 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1398 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1399 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1406 get_ia64_dynamic_type (unsigned long type
)
1410 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1417 get_dynamic_type (unsigned long type
)
1419 static char buff
[32];
1423 case DT_NULL
: return "NULL";
1424 case DT_NEEDED
: return "NEEDED";
1425 case DT_PLTRELSZ
: return "PLTRELSZ";
1426 case DT_PLTGOT
: return "PLTGOT";
1427 case DT_HASH
: return "HASH";
1428 case DT_STRTAB
: return "STRTAB";
1429 case DT_SYMTAB
: return "SYMTAB";
1430 case DT_RELA
: return "RELA";
1431 case DT_RELASZ
: return "RELASZ";
1432 case DT_RELAENT
: return "RELAENT";
1433 case DT_STRSZ
: return "STRSZ";
1434 case DT_SYMENT
: return "SYMENT";
1435 case DT_INIT
: return "INIT";
1436 case DT_FINI
: return "FINI";
1437 case DT_SONAME
: return "SONAME";
1438 case DT_RPATH
: return "RPATH";
1439 case DT_SYMBOLIC
: return "SYMBOLIC";
1440 case DT_REL
: return "REL";
1441 case DT_RELSZ
: return "RELSZ";
1442 case DT_RELENT
: return "RELENT";
1443 case DT_PLTREL
: return "PLTREL";
1444 case DT_DEBUG
: return "DEBUG";
1445 case DT_TEXTREL
: return "TEXTREL";
1446 case DT_JMPREL
: return "JMPREL";
1447 case DT_BIND_NOW
: return "BIND_NOW";
1448 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1449 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1450 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1451 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1452 case DT_RUNPATH
: return "RUNPATH";
1453 case DT_FLAGS
: return "FLAGS";
1455 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1456 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1458 case DT_CHECKSUM
: return "CHECKSUM";
1459 case DT_PLTPADSZ
: return "PLTPADSZ";
1460 case DT_MOVEENT
: return "MOVEENT";
1461 case DT_MOVESZ
: return "MOVESZ";
1462 case DT_FEATURE
: return "FEATURE";
1463 case DT_POSFLAG_1
: return "POSFLAG_1";
1464 case DT_SYMINSZ
: return "SYMINSZ";
1465 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1467 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1468 case DT_CONFIG
: return "CONFIG";
1469 case DT_DEPAUDIT
: return "DEPAUDIT";
1470 case DT_AUDIT
: return "AUDIT";
1471 case DT_PLTPAD
: return "PLTPAD";
1472 case DT_MOVETAB
: return "MOVETAB";
1473 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1475 case DT_VERSYM
: return "VERSYM";
1477 case DT_RELACOUNT
: return "RELACOUNT";
1478 case DT_RELCOUNT
: return "RELCOUNT";
1479 case DT_FLAGS_1
: return "FLAGS_1";
1480 case DT_VERDEF
: return "VERDEF";
1481 case DT_VERDEFNUM
: return "VERDEFNUM";
1482 case DT_VERNEED
: return "VERNEED";
1483 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1485 case DT_AUXILIARY
: return "AUXILIARY";
1486 case DT_USED
: return "USED";
1487 case DT_FILTER
: return "FILTER";
1489 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1490 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1491 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1492 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1493 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1496 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1500 switch (elf_header
.e_machine
)
1503 case EM_MIPS_RS3_LE
:
1504 result
= get_mips_dynamic_type (type
);
1507 result
= get_sparc64_dynamic_type (type
);
1510 result
= get_ppc64_dynamic_type (type
);
1513 result
= get_ia64_dynamic_type (type
);
1523 sprintf (buff
, _("Processor Specific: %lx"), type
);
1525 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1529 switch (elf_header
.e_machine
)
1532 result
= get_parisc_dynamic_type (type
);
1542 sprintf (buff
, _("Operating System specific: %lx"), type
);
1545 sprintf (buff
, _("<unknown>: %lx"), type
);
1552 get_file_type (unsigned e_type
)
1554 static char buff
[32];
1558 case ET_NONE
: return _("NONE (None)");
1559 case ET_REL
: return _("REL (Relocatable file)");
1560 case ET_EXEC
: return _("EXEC (Executable file)");
1561 case ET_DYN
: return _("DYN (Shared object file)");
1562 case ET_CORE
: return _("CORE (Core file)");
1565 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1566 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1567 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1568 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1570 sprintf (buff
, _("<unknown>: %x"), e_type
);
1576 get_machine_name (unsigned e_machine
)
1578 static char buff
[64]; /* XXX */
1582 case EM_NONE
: return _("None");
1583 case EM_M32
: return "WE32100";
1584 case EM_SPARC
: return "Sparc";
1585 case EM_386
: return "Intel 80386";
1586 case EM_68K
: return "MC68000";
1587 case EM_88K
: return "MC88000";
1588 case EM_486
: return "Intel 80486";
1589 case EM_860
: return "Intel 80860";
1590 case EM_MIPS
: return "MIPS R3000";
1591 case EM_S370
: return "IBM System/370";
1592 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1593 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1594 case EM_PARISC
: return "HPPA";
1595 case EM_PPC_OLD
: return "Power PC (old)";
1596 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1597 case EM_960
: return "Intel 90860";
1598 case EM_PPC
: return "PowerPC";
1599 case EM_PPC64
: return "PowerPC64";
1600 case EM_V800
: return "NEC V800";
1601 case EM_FR20
: return "Fujitsu FR20";
1602 case EM_RH32
: return "TRW RH32";
1603 case EM_MCORE
: return "MCORE";
1604 case EM_ARM
: return "ARM";
1605 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1606 case EM_SH
: return "Renesas / SuperH SH";
1607 case EM_SPARCV9
: return "Sparc v9";
1608 case EM_TRICORE
: return "Siemens Tricore";
1609 case EM_ARC
: return "ARC";
1610 case EM_H8_300
: return "Renesas H8/300";
1611 case EM_H8_300H
: return "Renesas H8/300H";
1612 case EM_H8S
: return "Renesas H8S";
1613 case EM_H8_500
: return "Renesas H8/500";
1614 case EM_IA_64
: return "Intel IA-64";
1615 case EM_MIPS_X
: return "Stanford MIPS-X";
1616 case EM_COLDFIRE
: return "Motorola Coldfire";
1617 case EM_68HC12
: return "Motorola M68HC12";
1618 case EM_ALPHA
: return "Alpha";
1619 case EM_CYGNUS_D10V
:
1620 case EM_D10V
: return "d10v";
1621 case EM_CYGNUS_D30V
:
1622 case EM_D30V
: return "d30v";
1623 case EM_CYGNUS_M32R
:
1624 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1625 case EM_CYGNUS_V850
:
1626 case EM_V850
: return "NEC v850";
1627 case EM_CYGNUS_MN10300
:
1628 case EM_MN10300
: return "mn10300";
1629 case EM_CYGNUS_MN10200
:
1630 case EM_MN10200
: return "mn10200";
1631 case EM_CYGNUS_FR30
:
1632 case EM_FR30
: return "Fujitsu FR30";
1633 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1635 case EM_PJ
: return "picoJava";
1636 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1637 case EM_PCP
: return "Siemens PCP";
1638 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1639 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1640 case EM_STARCORE
: return "Motorola Star*Core processor";
1641 case EM_ME16
: return "Toyota ME16 processor";
1642 case EM_ST100
: return "STMicroelectronics ST100 processor";
1643 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1644 case EM_FX66
: return "Siemens FX66 microcontroller";
1645 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1646 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1647 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1648 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1649 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1650 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1651 case EM_SVX
: return "Silicon Graphics SVx";
1652 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1653 case EM_VAX
: return "Digital VAX";
1655 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1656 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1657 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1658 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1659 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1660 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1661 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1662 case EM_PRISM
: return "Vitesse Prism";
1663 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1665 case EM_S390
: return "IBM S/390";
1666 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1668 case EM_OR32
: return "OpenRISC";
1669 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1670 case EM_DLX
: return "OpenDLX";
1672 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1673 case EM_IQ2000
: return "Vitesse IQ2000";
1675 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1677 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1683 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1688 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1689 e_flags
&= ~ EF_ARM_EABIMASK
;
1691 /* Handle "generic" ARM flags. */
1692 if (e_flags
& EF_ARM_RELEXEC
)
1694 strcat (buf
, ", relocatable executable");
1695 e_flags
&= ~ EF_ARM_RELEXEC
;
1698 if (e_flags
& EF_ARM_HASENTRY
)
1700 strcat (buf
, ", has entry point");
1701 e_flags
&= ~ EF_ARM_HASENTRY
;
1704 /* Now handle EABI specific flags. */
1708 strcat (buf
, ", <unrecognized EABI>");
1713 case EF_ARM_EABI_VER1
:
1714 strcat (buf
, ", Version1 EABI");
1719 /* Process flags one bit at a time. */
1720 flag
= e_flags
& - e_flags
;
1725 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1726 strcat (buf
, ", sorted symbol tables");
1736 case EF_ARM_EABI_VER2
:
1737 strcat (buf
, ", Version2 EABI");
1742 /* Process flags one bit at a time. */
1743 flag
= e_flags
& - e_flags
;
1748 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1749 strcat (buf
, ", sorted symbol tables");
1752 case EF_ARM_DYNSYMSUSESEGIDX
:
1753 strcat (buf
, ", dynamic symbols use segment index");
1756 case EF_ARM_MAPSYMSFIRST
:
1757 strcat (buf
, ", mapping symbols precede others");
1767 case EF_ARM_EABI_VER3
:
1768 strcat (buf
, ", Version3 EABI");
1773 /* Process flags one bit at a time. */
1774 flag
= e_flags
& - e_flags
;
1780 strcat (buf
, ", BE8");
1784 strcat (buf
, ", LE8");
1794 case EF_ARM_EABI_UNKNOWN
:
1795 strcat (buf
, ", GNU EABI");
1800 /* Process flags one bit at a time. */
1801 flag
= e_flags
& - e_flags
;
1806 case EF_ARM_INTERWORK
:
1807 strcat (buf
, ", interworking enabled");
1810 case EF_ARM_APCS_26
:
1811 strcat (buf
, ", uses APCS/26");
1814 case EF_ARM_APCS_FLOAT
:
1815 strcat (buf
, ", uses APCS/float");
1819 strcat (buf
, ", position independent");
1823 strcat (buf
, ", 8 bit structure alignment");
1826 case EF_ARM_NEW_ABI
:
1827 strcat (buf
, ", uses new ABI");
1830 case EF_ARM_OLD_ABI
:
1831 strcat (buf
, ", uses old ABI");
1834 case EF_ARM_SOFT_FLOAT
:
1835 strcat (buf
, ", software FP");
1838 case EF_ARM_VFP_FLOAT
:
1839 strcat (buf
, ", VFP");
1842 case EF_ARM_MAVERICK_FLOAT
:
1843 strcat (buf
, ", Maverick FP");
1854 strcat (buf
,", <unknown>");
1858 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1860 static char buf
[1024];
1872 decode_ARM_machine_flags (e_flags
, buf
);
1876 if (e_flags
& EF_CPU32
)
1877 strcat (buf
, ", cpu32");
1878 if (e_flags
& EF_M68000
)
1879 strcat (buf
, ", m68000");
1883 if (e_flags
& EF_PPC_EMB
)
1884 strcat (buf
, ", emb");
1886 if (e_flags
& EF_PPC_RELOCATABLE
)
1887 strcat (buf
, ", relocatable");
1889 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1890 strcat (buf
, ", relocatable-lib");
1894 case EM_CYGNUS_V850
:
1895 switch (e_flags
& EF_V850_ARCH
)
1898 strcat (buf
, ", v850e1");
1901 strcat (buf
, ", v850e");
1904 strcat (buf
, ", v850");
1907 strcat (buf
, ", unknown v850 architecture variant");
1913 case EM_CYGNUS_M32R
:
1914 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1915 strcat (buf
, ", m32r");
1920 case EM_MIPS_RS3_LE
:
1921 if (e_flags
& EF_MIPS_NOREORDER
)
1922 strcat (buf
, ", noreorder");
1924 if (e_flags
& EF_MIPS_PIC
)
1925 strcat (buf
, ", pic");
1927 if (e_flags
& EF_MIPS_CPIC
)
1928 strcat (buf
, ", cpic");
1930 if (e_flags
& EF_MIPS_UCODE
)
1931 strcat (buf
, ", ugen_reserved");
1933 if (e_flags
& EF_MIPS_ABI2
)
1934 strcat (buf
, ", abi2");
1936 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1937 strcat (buf
, ", odk first");
1939 if (e_flags
& EF_MIPS_32BITMODE
)
1940 strcat (buf
, ", 32bitmode");
1942 switch ((e_flags
& EF_MIPS_MACH
))
1944 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1945 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1946 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1947 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1948 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1949 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1950 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1951 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1952 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1954 /* We simply ignore the field in this case to avoid confusion:
1955 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1958 default: strcat (buf
, ", unknown CPU"); break;
1961 switch ((e_flags
& EF_MIPS_ABI
))
1963 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1964 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1965 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1966 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1968 /* We simply ignore the field in this case to avoid confusion:
1969 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1970 This means it is likely to be an o32 file, but not for
1973 default: strcat (buf
, ", unknown ABI"); break;
1976 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1977 strcat (buf
, ", mdmx");
1979 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1980 strcat (buf
, ", mips16");
1982 switch ((e_flags
& EF_MIPS_ARCH
))
1984 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1985 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1986 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1987 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1988 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1989 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1990 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
1991 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1992 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
1993 default: strcat (buf
, ", unknown ISA"); break;
1999 switch ((e_flags
& EF_SH_MACH_MASK
))
2001 case EF_SH1
: strcat (buf
, ", sh1"); break;
2002 case EF_SH2
: strcat (buf
, ", sh2"); break;
2003 case EF_SH3
: strcat (buf
, ", sh3"); break;
2004 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2005 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2006 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2007 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2008 case EF_SH4
: strcat (buf
, ", sh4"); break;
2009 case EF_SH5
: strcat (buf
, ", sh5"); break;
2010 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2011 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2012 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2013 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2014 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2015 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2016 default: strcat (buf
, ", unknown ISA"); break;
2022 if (e_flags
& EF_SPARC_32PLUS
)
2023 strcat (buf
, ", v8+");
2025 if (e_flags
& EF_SPARC_SUN_US1
)
2026 strcat (buf
, ", ultrasparcI");
2028 if (e_flags
& EF_SPARC_SUN_US3
)
2029 strcat (buf
, ", ultrasparcIII");
2031 if (e_flags
& EF_SPARC_HAL_R1
)
2032 strcat (buf
, ", halr1");
2034 if (e_flags
& EF_SPARC_LEDATA
)
2035 strcat (buf
, ", ledata");
2037 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2038 strcat (buf
, ", tso");
2040 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2041 strcat (buf
, ", pso");
2043 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2044 strcat (buf
, ", rmo");
2048 switch (e_flags
& EF_PARISC_ARCH
)
2050 case EFA_PARISC_1_0
:
2051 strcpy (buf
, ", PA-RISC 1.0");
2053 case EFA_PARISC_1_1
:
2054 strcpy (buf
, ", PA-RISC 1.1");
2056 case EFA_PARISC_2_0
:
2057 strcpy (buf
, ", PA-RISC 2.0");
2062 if (e_flags
& EF_PARISC_TRAPNIL
)
2063 strcat (buf
, ", trapnil");
2064 if (e_flags
& EF_PARISC_EXT
)
2065 strcat (buf
, ", ext");
2066 if (e_flags
& EF_PARISC_LSB
)
2067 strcat (buf
, ", lsb");
2068 if (e_flags
& EF_PARISC_WIDE
)
2069 strcat (buf
, ", wide");
2070 if (e_flags
& EF_PARISC_NO_KABP
)
2071 strcat (buf
, ", no kabp");
2072 if (e_flags
& EF_PARISC_LAZYSWAP
)
2073 strcat (buf
, ", lazyswap");
2078 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2079 strcat (buf
, ", new calling convention");
2081 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2082 strcat (buf
, ", gnu calling convention");
2086 if ((e_flags
& EF_IA_64_ABI64
))
2087 strcat (buf
, ", 64-bit");
2089 strcat (buf
, ", 32-bit");
2090 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2091 strcat (buf
, ", reduced fp model");
2092 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2093 strcat (buf
, ", no function descriptors, constant gp");
2094 else if ((e_flags
& EF_IA_64_CONS_GP
))
2095 strcat (buf
, ", constant gp");
2096 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2097 strcat (buf
, ", absolute");
2101 if ((e_flags
& EF_VAX_NONPIC
))
2102 strcat (buf
, ", non-PIC");
2103 if ((e_flags
& EF_VAX_DFLOAT
))
2104 strcat (buf
, ", D-Float");
2105 if ((e_flags
& EF_VAX_GFLOAT
))
2106 strcat (buf
, ", G-Float");
2115 get_osabi_name (unsigned int osabi
)
2117 static char buff
[32];
2121 case ELFOSABI_NONE
: return "UNIX - System V";
2122 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2123 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2124 case ELFOSABI_LINUX
: return "UNIX - Linux";
2125 case ELFOSABI_HURD
: return "GNU/Hurd";
2126 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2127 case ELFOSABI_AIX
: return "UNIX - AIX";
2128 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2129 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2130 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2131 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2132 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2133 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2134 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2135 case ELFOSABI_AROS
: return "Amiga Research OS";
2136 case ELFOSABI_STANDALONE
: return _("Standalone App");
2137 case ELFOSABI_ARM
: return "ARM";
2139 sprintf (buff
, _("<unknown: %x>"), osabi
);
2145 get_mips_segment_type (unsigned long type
)
2149 case PT_MIPS_REGINFO
:
2151 case PT_MIPS_RTPROC
:
2153 case PT_MIPS_OPTIONS
:
2163 get_parisc_segment_type (unsigned long type
)
2167 case PT_HP_TLS
: return "HP_TLS";
2168 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2169 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2170 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2171 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2172 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2173 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2174 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2175 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2176 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2177 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2178 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2179 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2180 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2189 get_ia64_segment_type (unsigned long type
)
2193 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2194 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2195 case PT_HP_TLS
: return "HP_TLS";
2196 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2197 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2198 case PT_IA_64_HP_STACK
: return "HP_STACK";
2207 get_segment_type (unsigned long p_type
)
2209 static char buff
[32];
2213 case PT_NULL
: return "NULL";
2214 case PT_LOAD
: return "LOAD";
2215 case PT_DYNAMIC
: return "DYNAMIC";
2216 case PT_INTERP
: return "INTERP";
2217 case PT_NOTE
: return "NOTE";
2218 case PT_SHLIB
: return "SHLIB";
2219 case PT_PHDR
: return "PHDR";
2220 case PT_TLS
: return "TLS";
2222 case PT_GNU_EH_FRAME
:
2223 return "GNU_EH_FRAME";
2224 case PT_GNU_STACK
: return "GNU_STACK";
2225 case PT_GNU_RELRO
: return "GNU_RELRO";
2228 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2232 switch (elf_header
.e_machine
)
2235 case EM_MIPS_RS3_LE
:
2236 result
= get_mips_segment_type (p_type
);
2239 result
= get_parisc_segment_type (p_type
);
2242 result
= get_ia64_segment_type (p_type
);
2252 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2254 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2258 switch (elf_header
.e_machine
)
2261 result
= get_parisc_segment_type (p_type
);
2264 result
= get_ia64_segment_type (p_type
);
2274 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2277 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2284 get_mips_section_type_name (unsigned int sh_type
)
2288 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2289 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2290 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2291 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2292 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2293 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2294 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2295 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2296 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2297 case SHT_MIPS_RELD
: return "MIPS_RELD";
2298 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2299 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2300 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2301 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2302 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2303 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2304 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2305 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2306 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2307 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2308 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2309 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2310 case SHT_MIPS_LINE
: return "MIPS_LINE";
2311 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2312 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2313 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2314 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2315 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2316 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2317 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2318 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2319 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2320 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2321 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2322 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2323 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2324 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2325 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2326 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2334 get_parisc_section_type_name (unsigned int sh_type
)
2338 case SHT_PARISC_EXT
: return "PARISC_EXT";
2339 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2340 case SHT_PARISC_DOC
: return "PARISC_DOC";
2348 get_ia64_section_type_name (unsigned int sh_type
)
2350 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2351 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2352 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2356 case SHT_IA_64_EXT
: return "IA_64_EXT";
2357 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2358 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2366 get_section_type_name (unsigned int sh_type
)
2368 static char buff
[32];
2372 case SHT_NULL
: return "NULL";
2373 case SHT_PROGBITS
: return "PROGBITS";
2374 case SHT_SYMTAB
: return "SYMTAB";
2375 case SHT_STRTAB
: return "STRTAB";
2376 case SHT_RELA
: return "RELA";
2377 case SHT_HASH
: return "HASH";
2378 case SHT_DYNAMIC
: return "DYNAMIC";
2379 case SHT_NOTE
: return "NOTE";
2380 case SHT_NOBITS
: return "NOBITS";
2381 case SHT_REL
: return "REL";
2382 case SHT_SHLIB
: return "SHLIB";
2383 case SHT_DYNSYM
: return "DYNSYM";
2384 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2385 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2386 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2387 case SHT_GROUP
: return "GROUP";
2388 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2389 case SHT_GNU_verdef
: return "VERDEF";
2390 case SHT_GNU_verneed
: return "VERNEED";
2391 case SHT_GNU_versym
: return "VERSYM";
2392 case 0x6ffffff0: return "VERSYM";
2393 case 0x6ffffffc: return "VERDEF";
2394 case 0x7ffffffd: return "AUXILIARY";
2395 case 0x7fffffff: return "FILTER";
2396 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2399 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2403 switch (elf_header
.e_machine
)
2406 case EM_MIPS_RS3_LE
:
2407 result
= get_mips_section_type_name (sh_type
);
2410 result
= get_parisc_section_type_name (sh_type
);
2413 result
= get_ia64_section_type_name (sh_type
);
2423 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2425 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2426 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2427 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2428 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2430 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2436 #define OPTION_DEBUG_DUMP 512
2438 struct option options
[] =
2440 {"all", no_argument
, 0, 'a'},
2441 {"file-header", no_argument
, 0, 'h'},
2442 {"program-headers", no_argument
, 0, 'l'},
2443 {"headers", no_argument
, 0, 'e'},
2444 {"histogram", no_argument
, 0, 'I'},
2445 {"segments", no_argument
, 0, 'l'},
2446 {"sections", no_argument
, 0, 'S'},
2447 {"section-headers", no_argument
, 0, 'S'},
2448 {"section-groups", no_argument
, 0, 'g'},
2449 {"symbols", no_argument
, 0, 's'},
2450 {"syms", no_argument
, 0, 's'},
2451 {"relocs", no_argument
, 0, 'r'},
2452 {"notes", no_argument
, 0, 'n'},
2453 {"dynamic", no_argument
, 0, 'd'},
2454 {"arch-specific", no_argument
, 0, 'A'},
2455 {"version-info", no_argument
, 0, 'V'},
2456 {"use-dynamic", no_argument
, 0, 'D'},
2457 {"hex-dump", required_argument
, 0, 'x'},
2458 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2459 {"unwind", no_argument
, 0, 'u'},
2460 #ifdef SUPPORT_DISASSEMBLY
2461 {"instruction-dump", required_argument
, 0, 'i'},
2464 {"version", no_argument
, 0, 'v'},
2465 {"wide", no_argument
, 0, 'W'},
2466 {"help", no_argument
, 0, 'H'},
2467 {0, no_argument
, 0, 0}
2473 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2474 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2475 fprintf (stdout
, _(" Options are:\n\
2476 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2477 -h --file-header Display the ELF file header\n\
2478 -l --program-headers Display the program headers\n\
2479 --segments An alias for --program-headers\n\
2480 -S --section-headers Display the sections' header\n\
2481 --sections An alias for --section-headers\n\
2482 -g --section-groups Display the section groups\n\
2483 -e --headers Equivalent to: -h -l -S\n\
2484 -s --syms Display the symbol table\n\
2485 --symbols An alias for --syms\n\
2486 -n --notes Display the core notes (if present)\n\
2487 -r --relocs Display the relocations (if present)\n\
2488 -u --unwind Display the unwind info (if present)\n\
2489 -d --dynamic Display the dynamic section (if present)\n\
2490 -V --version-info Display the version sections (if present)\n\
2491 -A --arch-specific Display architecture specific information (if any).\n\
2492 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2493 -x --hex-dump=<number> Dump the contents of section <number>\n\
2494 -w[liaprmfFso] or\n\
2495 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2496 Display the contents of DWARF2 debug sections\n"));
2497 #ifdef SUPPORT_DISASSEMBLY
2498 fprintf (stdout
, _("\
2499 -i --instruction-dump=<number>\n\
2500 Disassemble the contents of section <number>\n"));
2502 fprintf (stdout
, _("\
2503 -I --histogram Display histogram of bucket list lengths\n\
2504 -W --wide Allow output width to exceed 80 characters\n\
2505 -H --help Display this information\n\
2506 -v --version Display the version number of readelf\n"));
2507 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2513 request_dump (unsigned int section
, int type
)
2515 if (section
>= num_dump_sects
)
2517 char *new_dump_sects
;
2519 new_dump_sects
= calloc (section
+ 1, 1);
2521 if (new_dump_sects
== NULL
)
2522 error (_("Out of memory allocating dump request table."));
2525 /* Copy current flag settings. */
2526 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2530 dump_sects
= new_dump_sects
;
2531 num_dump_sects
= section
+ 1;
2536 dump_sects
[section
] |= type
;
2542 parse_args (int argc
, char **argv
)
2549 while ((c
= getopt_long
2550 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2571 do_section_groups
++;
2579 do_section_groups
++;
2621 section
= strtoul (optarg
, & cp
, 0);
2622 if (! *cp
&& section
>= 0)
2624 request_dump (section
, HEX_DUMP
);
2634 unsigned int index
= 0;
2638 while (optarg
[index
])
2639 switch (optarg
[index
++])
2648 do_debug_abbrevs
= 1;
2658 do_debug_pubnames
= 1;
2663 do_debug_aranges
= 1;
2667 do_debug_frames_interp
= 1;
2669 do_debug_frames
= 1;
2674 do_debug_macinfo
= 1;
2688 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2693 case OPTION_DEBUG_DUMP
:
2699 static const char *debug_dump_opt
[]
2700 = { "line", "info", "abbrev", "pubnames", "ranges",
2701 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2710 for (index
= 0; debug_dump_opt
[index
]; index
++)
2712 size_t len
= strlen (debug_dump_opt
[index
]);
2714 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2715 && (p
[len
] == ',' || p
[len
] == '\0'))
2724 do_debug_abbrevs
= 1;
2735 do_debug_pubnames
= 1;
2739 do_debug_aranges
= 1;
2744 do_debug_frames_interp
= 1;
2745 do_debug_frames
= 1;
2749 do_debug_macinfo
= 1;
2762 if (debug_dump_opt
[index
] == NULL
)
2764 warn (_("Unrecognized debug option '%s'\n"), p
);
2765 p
= strchr (p
, ',');
2775 #ifdef SUPPORT_DISASSEMBLY
2778 section
= strtoul (optarg
, & cp
, 0);
2779 if (! *cp
&& section
>= 0)
2781 request_dump (section
, DISASS_DUMP
);
2787 print_version (program_name
);
2797 /* xgettext:c-format */
2798 error (_("Invalid option '-%c'\n"), c
);
2805 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2806 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2807 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2808 && !do_section_groups
)
2812 warn (_("Nothing to do.\n"));
2818 get_elf_class (unsigned int elf_class
)
2820 static char buff
[32];
2824 case ELFCLASSNONE
: return _("none");
2825 case ELFCLASS32
: return "ELF32";
2826 case ELFCLASS64
: return "ELF64";
2828 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2834 get_data_encoding (unsigned int encoding
)
2836 static char buff
[32];
2840 case ELFDATANONE
: return _("none");
2841 case ELFDATA2LSB
: return _("2's complement, little endian");
2842 case ELFDATA2MSB
: return _("2's complement, big endian");
2844 sprintf (buff
, _("<unknown: %x>"), encoding
);
2849 /* Decode the data held in 'elf_header'. */
2852 process_file_header (void)
2854 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2855 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2856 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2857 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2860 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2868 printf (_("ELF Header:\n"));
2869 printf (_(" Magic: "));
2870 for (i
= 0; i
< EI_NIDENT
; i
++)
2871 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2873 printf (_(" Class: %s\n"),
2874 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2875 printf (_(" Data: %s\n"),
2876 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2877 printf (_(" Version: %d %s\n"),
2878 elf_header
.e_ident
[EI_VERSION
],
2879 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2881 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2884 printf (_(" OS/ABI: %s\n"),
2885 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2886 printf (_(" ABI Version: %d\n"),
2887 elf_header
.e_ident
[EI_ABIVERSION
]);
2888 printf (_(" Type: %s\n"),
2889 get_file_type (elf_header
.e_type
));
2890 printf (_(" Machine: %s\n"),
2891 get_machine_name (elf_header
.e_machine
));
2892 printf (_(" Version: 0x%lx\n"),
2893 (unsigned long) elf_header
.e_version
);
2895 printf (_(" Entry point address: "));
2896 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2897 printf (_("\n Start of program headers: "));
2898 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2899 printf (_(" (bytes into file)\n Start of section headers: "));
2900 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2901 printf (_(" (bytes into file)\n"));
2903 printf (_(" Flags: 0x%lx%s\n"),
2904 (unsigned long) elf_header
.e_flags
,
2905 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2906 printf (_(" Size of this header: %ld (bytes)\n"),
2907 (long) elf_header
.e_ehsize
);
2908 printf (_(" Size of program headers: %ld (bytes)\n"),
2909 (long) elf_header
.e_phentsize
);
2910 printf (_(" Number of program headers: %ld\n"),
2911 (long) elf_header
.e_phnum
);
2912 printf (_(" Size of section headers: %ld (bytes)\n"),
2913 (long) elf_header
.e_shentsize
);
2914 printf (_(" Number of section headers: %ld"),
2915 (long) elf_header
.e_shnum
);
2916 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2917 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2918 putc ('\n', stdout
);
2919 printf (_(" Section header string table index: %ld"),
2920 (long) elf_header
.e_shstrndx
);
2921 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2922 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2923 putc ('\n', stdout
);
2926 if (section_headers
!= NULL
)
2928 if (elf_header
.e_shnum
== 0)
2929 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2930 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2931 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2932 free (section_headers
);
2933 section_headers
= NULL
;
2941 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
2943 Elf32_External_Phdr
*phdrs
;
2944 Elf32_External_Phdr
*external
;
2945 Elf_Internal_Phdr
*internal
;
2948 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
2949 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2950 _("program headers"));
2954 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2955 i
< elf_header
.e_phnum
;
2956 i
++, internal
++, external
++)
2958 internal
->p_type
= BYTE_GET (external
->p_type
);
2959 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2960 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2961 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2962 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2963 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2964 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2965 internal
->p_align
= BYTE_GET (external
->p_align
);
2974 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
2976 Elf64_External_Phdr
*phdrs
;
2977 Elf64_External_Phdr
*external
;
2978 Elf_Internal_Phdr
*internal
;
2981 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
2982 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2983 _("program headers"));
2987 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2988 i
< elf_header
.e_phnum
;
2989 i
++, internal
++, external
++)
2991 internal
->p_type
= BYTE_GET (external
->p_type
);
2992 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2993 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2994 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2995 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2996 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2997 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2998 internal
->p_align
= BYTE_GET8 (external
->p_align
);
3006 /* Returns 1 if the program headers were read into `program_headers'. */
3009 get_program_headers (FILE *file
)
3011 Elf_Internal_Phdr
*phdrs
;
3013 /* Check cache of prior read. */
3014 if (program_headers
!= NULL
)
3017 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3021 error (_("Out of memory\n"));
3026 ? get_32bit_program_headers (file
, phdrs
)
3027 : get_64bit_program_headers (file
, phdrs
))
3029 program_headers
= phdrs
;
3037 /* Returns 1 if the program headers were loaded. */
3040 process_program_headers (FILE *file
)
3042 Elf_Internal_Phdr
*segment
;
3045 if (elf_header
.e_phnum
== 0)
3048 printf (_("\nThere are no program headers in this file.\n"));
3052 if (do_segments
&& !do_header
)
3054 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3055 printf (_("Entry point "));
3056 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3057 printf (_("\nThere are %d program headers, starting at offset "),
3058 elf_header
.e_phnum
);
3059 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3063 if (! get_program_headers (file
))
3068 if (elf_header
.e_phnum
> 1)
3069 printf (_("\nProgram Headers:\n"));
3071 printf (_("\nProgram Headers:\n"));
3075 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3078 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3082 (_(" Type Offset VirtAddr PhysAddr\n"));
3084 (_(" FileSiz MemSiz Flags Align\n"));
3091 for (i
= 0, segment
= program_headers
;
3092 i
< elf_header
.e_phnum
;
3097 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3101 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3102 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3103 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3104 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3105 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3107 (segment
->p_flags
& PF_R
? 'R' : ' '),
3108 (segment
->p_flags
& PF_W
? 'W' : ' '),
3109 (segment
->p_flags
& PF_X
? 'E' : ' '));
3110 printf ("%#lx", (unsigned long) segment
->p_align
);
3114 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3115 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3118 print_vma (segment
->p_offset
, FULL_HEX
);
3122 print_vma (segment
->p_vaddr
, FULL_HEX
);
3124 print_vma (segment
->p_paddr
, FULL_HEX
);
3127 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3128 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3131 print_vma (segment
->p_filesz
, FULL_HEX
);
3135 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3136 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3139 print_vma (segment
->p_offset
, FULL_HEX
);
3143 (segment
->p_flags
& PF_R
? 'R' : ' '),
3144 (segment
->p_flags
& PF_W
? 'W' : ' '),
3145 (segment
->p_flags
& PF_X
? 'E' : ' '));
3147 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3148 printf ("%#lx", (unsigned long) segment
->p_align
);
3151 print_vma (segment
->p_align
, PREFIX_HEX
);
3156 print_vma (segment
->p_offset
, FULL_HEX
);
3158 print_vma (segment
->p_vaddr
, FULL_HEX
);
3160 print_vma (segment
->p_paddr
, FULL_HEX
);
3162 print_vma (segment
->p_filesz
, FULL_HEX
);
3164 print_vma (segment
->p_memsz
, FULL_HEX
);
3166 (segment
->p_flags
& PF_R
? 'R' : ' '),
3167 (segment
->p_flags
& PF_W
? 'W' : ' '),
3168 (segment
->p_flags
& PF_X
? 'E' : ' '));
3169 print_vma (segment
->p_align
, HEX
);
3173 switch (segment
->p_type
)
3177 error (_("more than one dynamic segment\n"));
3179 /* Try to locate the .dynamic section. If there is
3180 a section header table, we can easily locate it. */
3181 if (section_headers
!= NULL
)
3183 Elf_Internal_Shdr
*sec
;
3186 for (j
= 0, sec
= section_headers
;
3187 j
< elf_header
.e_shnum
;
3189 if (strcmp (SECTION_NAME (sec
), ".dynamic") == 0)
3192 if (j
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
3194 error (_("no .dynamic section in the dynamic segment"));
3198 dynamic_addr
= sec
->sh_offset
;
3199 dynamic_size
= sec
->sh_size
;
3201 if (dynamic_addr
< segment
->p_offset
3202 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3203 warn (_("the .dynamic section is not contained within the dynamic segment"));
3204 else if (dynamic_addr
> segment
->p_offset
)
3205 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3209 /* Otherwise, we can only assume that the .dynamic
3210 section is the first section in the DYNAMIC segment. */
3211 dynamic_addr
= segment
->p_offset
;
3212 dynamic_size
= segment
->p_filesz
;
3217 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3219 error (_("Unable to find program interpreter name\n"));
3222 program_interpreter
[0] = 0;
3223 fscanf (file
, "%63s", program_interpreter
);
3226 printf (_("\n [Requesting program interpreter: %s]"),
3227 program_interpreter
);
3233 putc ('\n', stdout
);
3236 if (do_segments
&& section_headers
!= NULL
)
3238 printf (_("\n Section to Segment mapping:\n"));
3239 printf (_(" Segment Sections...\n"));
3241 assert (string_table
!= NULL
);
3243 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3246 Elf_Internal_Shdr
*section
;
3248 segment
= program_headers
+ i
;
3249 section
= section_headers
;
3251 printf (" %2.2d ", i
);
3253 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3255 if (section
->sh_size
> 0
3256 /* Compare allocated sections by VMA, unallocated
3257 sections by file offset. */
3258 && (section
->sh_flags
& SHF_ALLOC
3259 ? (section
->sh_addr
>= segment
->p_vaddr
3260 && section
->sh_addr
+ section
->sh_size
3261 <= segment
->p_vaddr
+ segment
->p_memsz
)
3262 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3263 && (section
->sh_offset
+ section
->sh_size
3264 <= segment
->p_offset
+ segment
->p_filesz
))))
3265 printf ("%s ", SECTION_NAME (section
));
3276 /* Find the file offset corresponding to VMA by using the program headers. */
3279 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3281 Elf_Internal_Phdr
*seg
;
3283 if (! get_program_headers (file
))
3285 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3289 for (seg
= program_headers
;
3290 seg
< program_headers
+ elf_header
.e_phnum
;
3293 if (seg
->p_type
!= PT_LOAD
)
3296 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3297 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3298 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3301 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3308 get_32bit_section_headers (FILE *file
, unsigned int num
)
3310 Elf32_External_Shdr
*shdrs
;
3311 Elf_Internal_Shdr
*internal
;
3314 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3315 elf_header
.e_shentsize
* num
, _("section headers"));
3319 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3321 if (section_headers
== NULL
)
3323 error (_("Out of memory\n"));
3327 for (i
= 0, internal
= section_headers
;
3331 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3332 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3333 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3334 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3335 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3336 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3337 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3338 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3339 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3340 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3349 get_64bit_section_headers (FILE *file
, unsigned int num
)
3351 Elf64_External_Shdr
*shdrs
;
3352 Elf_Internal_Shdr
*internal
;
3355 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3356 elf_header
.e_shentsize
* num
, _("section headers"));
3360 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3362 if (section_headers
== NULL
)
3364 error (_("Out of memory\n"));
3368 for (i
= 0, internal
= section_headers
;
3372 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3373 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3374 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3375 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3376 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3377 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3378 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3379 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3380 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3381 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3389 static Elf_Internal_Sym
*
3390 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3392 unsigned long number
;
3393 Elf32_External_Sym
*esyms
;
3394 Elf_External_Sym_Shndx
*shndx
;
3395 Elf_Internal_Sym
*isyms
;
3396 Elf_Internal_Sym
*psym
;
3399 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3405 if (symtab_shndx_hdr
!= NULL
3406 && (symtab_shndx_hdr
->sh_link
3407 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3409 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3410 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3418 number
= section
->sh_size
/ section
->sh_entsize
;
3419 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3423 error (_("Out of memory\n"));
3430 for (j
= 0, psym
= isyms
;
3434 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3435 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3436 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3437 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3438 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3440 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3441 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3442 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3452 static Elf_Internal_Sym
*
3453 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3455 unsigned long number
;
3456 Elf64_External_Sym
*esyms
;
3457 Elf_External_Sym_Shndx
*shndx
;
3458 Elf_Internal_Sym
*isyms
;
3459 Elf_Internal_Sym
*psym
;
3462 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3468 if (symtab_shndx_hdr
!= NULL
3469 && (symtab_shndx_hdr
->sh_link
3470 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3472 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3473 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3481 number
= section
->sh_size
/ section
->sh_entsize
;
3482 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3486 error (_("Out of memory\n"));
3493 for (j
= 0, psym
= isyms
;
3497 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3498 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3499 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3500 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3501 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3503 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3504 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3505 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3516 get_elf_section_flags (bfd_vma sh_flags
)
3518 static char buff
[32];
3526 flag
= sh_flags
& - sh_flags
;
3531 case SHF_WRITE
: strcat (buff
, "W"); break;
3532 case SHF_ALLOC
: strcat (buff
, "A"); break;
3533 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3534 case SHF_MERGE
: strcat (buff
, "M"); break;
3535 case SHF_STRINGS
: strcat (buff
, "S"); break;
3536 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3537 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3538 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3539 case SHF_GROUP
: strcat (buff
, "G"); break;
3540 case SHF_TLS
: strcat (buff
, "T"); break;
3543 if (flag
& SHF_MASKOS
)
3546 sh_flags
&= ~ SHF_MASKOS
;
3548 else if (flag
& SHF_MASKPROC
)
3551 sh_flags
&= ~ SHF_MASKPROC
;
3563 process_section_headers (FILE *file
)
3565 Elf_Internal_Shdr
*section
;
3568 section_headers
= NULL
;
3570 if (elf_header
.e_shnum
== 0)
3573 printf (_("\nThere are no sections in this file.\n"));
3578 if (do_sections
&& !do_header
)
3579 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3580 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3584 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3587 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3590 /* Read in the string table, so that we have names to display. */
3591 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3593 if (section
->sh_size
!= 0)
3595 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3596 section
->sh_size
, _("string table"));
3598 if (string_table
== NULL
)
3601 string_table_length
= section
->sh_size
;
3604 /* Scan the sections for the dynamic symbol table
3605 and dynamic string table and debug sections. */
3606 dynamic_symbols
= NULL
;
3607 dynamic_strings
= NULL
;
3608 dynamic_syminfo
= NULL
;
3609 symtab_shndx_hdr
= NULL
;
3611 for (i
= 0, section
= section_headers
;
3612 i
< elf_header
.e_shnum
;
3615 char *name
= SECTION_NAME (section
);
3617 if (section
->sh_type
== SHT_DYNSYM
)
3619 if (dynamic_symbols
!= NULL
)
3621 error (_("File contains multiple dynamic symbol tables\n"));
3625 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3626 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3628 else if (section
->sh_type
== SHT_STRTAB
3629 && strcmp (name
, ".dynstr") == 0)
3631 if (dynamic_strings
!= NULL
)
3633 error (_("File contains multiple dynamic string tables\n"));
3637 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3638 section
->sh_size
, _("dynamic strings"));
3640 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3642 if (symtab_shndx_hdr
!= NULL
)
3644 error (_("File contains multiple symtab shndx tables\n"));
3647 symtab_shndx_hdr
= section
;
3649 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3650 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3651 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3653 && strncmp (name
, ".debug_", 7) == 0)
3658 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3659 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3660 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3661 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3662 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3663 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3664 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3665 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3666 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3668 request_dump (i
, DEBUG_DUMP
);
3670 /* linkonce section to be combined with .debug_info at link time. */
3671 else if ((do_debugging
|| do_debug_info
)
3672 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3673 request_dump (i
, DEBUG_DUMP
);
3674 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3675 request_dump (i
, DEBUG_DUMP
);
3681 if (elf_header
.e_shnum
> 1)
3682 printf (_("\nSection Headers:\n"));
3684 printf (_("\nSection Header:\n"));
3688 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3691 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3694 printf (_(" [Nr] Name Type Address Offset\n"));
3695 printf (_(" Size EntSize Flags Link Info Align\n"));
3698 for (i
= 0, section
= section_headers
;
3699 i
< elf_header
.e_shnum
;
3702 printf (" [%2u] %-17.17s %-15.15s ",
3703 SECTION_HEADER_NUM (i
),
3704 SECTION_NAME (section
),
3705 get_section_type_name (section
->sh_type
));
3709 print_vma (section
->sh_addr
, LONG_HEX
);
3711 printf ( " %6.6lx %6.6lx %2.2lx",
3712 (unsigned long) section
->sh_offset
,
3713 (unsigned long) section
->sh_size
,
3714 (unsigned long) section
->sh_entsize
);
3716 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3718 printf ("%2ld %3lu %2ld\n",
3719 (unsigned long) section
->sh_link
,
3720 (unsigned long) section
->sh_info
,
3721 (unsigned long) section
->sh_addralign
);
3725 print_vma (section
->sh_addr
, LONG_HEX
);
3727 if ((long) section
->sh_offset
== section
->sh_offset
)
3728 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3732 print_vma (section
->sh_offset
, LONG_HEX
);
3735 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3736 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3740 print_vma (section
->sh_size
, LONG_HEX
);
3743 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3744 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3748 print_vma (section
->sh_entsize
, LONG_HEX
);
3751 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3753 printf ("%2ld %3lu ",
3754 (unsigned long) section
->sh_link
,
3755 (unsigned long) section
->sh_info
);
3757 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3758 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3761 print_vma (section
->sh_addralign
, DEC
);
3768 print_vma (section
->sh_addr
, LONG_HEX
);
3769 if ((long) section
->sh_offset
== section
->sh_offset
)
3770 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3774 print_vma (section
->sh_offset
, LONG_HEX
);
3777 print_vma (section
->sh_size
, LONG_HEX
);
3779 print_vma (section
->sh_entsize
, LONG_HEX
);
3781 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3783 printf (" %2ld %3lu %ld\n",
3784 (unsigned long) section
->sh_link
,
3785 (unsigned long) section
->sh_info
,
3786 (unsigned long) section
->sh_addralign
);
3790 printf (_("Key to Flags:\n\
3791 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3792 I (info), L (link order), G (group), x (unknown)\n\
3793 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3799 get_group_flags (unsigned int flags
)
3801 static char buff
[32];
3808 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3815 process_section_groups (FILE *file
)
3817 Elf_Internal_Shdr
*section
;
3819 struct group
*group
;
3821 if (elf_header
.e_shnum
== 0)
3823 if (do_section_groups
)
3824 printf (_("\nThere are no section groups in this file.\n"));
3829 if (section_headers
== NULL
)
3831 error (_("Section headers are not available!\n"));
3835 section_headers_groups
= calloc (elf_header
.e_shnum
,
3836 sizeof (struct group
*));
3838 if (section_headers_groups
== NULL
)
3840 error (_("Out of memory\n"));
3844 /* Scan the sections for the group section. */
3845 for (i
= 0, section
= section_headers
;
3846 i
< elf_header
.e_shnum
;
3848 if (section
->sh_type
== SHT_GROUP
)
3851 section_groups
= calloc (group_count
, sizeof (struct group
));
3853 if (section_groups
== NULL
)
3855 error (_("Out of memory\n"));
3859 for (i
= 0, section
= section_headers
, group
= section_groups
;
3860 i
< elf_header
.e_shnum
;
3863 if (section
->sh_type
== SHT_GROUP
)
3865 char *name
= SECTION_NAME (section
);
3866 char *group_name
, *strtab
, *start
, *indices
;
3867 unsigned int entry
, j
, size
;
3868 Elf_Internal_Sym
*sym
;
3869 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
, *sec
;
3870 Elf_Internal_Sym
*symtab
;
3872 /* Get the symbol table. */
3873 symtab_sec
= SECTION_HEADER (section
->sh_link
);
3874 if (symtab_sec
->sh_type
!= SHT_SYMTAB
)
3876 error (_("Bad sh_link in group section `%s'\n"), name
);
3879 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
3881 sym
= symtab
+ section
->sh_info
;
3883 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3885 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
3888 error (_("Bad sh_info in group section `%s'\n"), name
);
3892 group_name
= SECTION_NAME (section_headers
+ sec_index
);
3897 /* Get the string table. */
3898 strtab_sec
= SECTION_HEADER (symtab_sec
->sh_link
);
3899 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
3900 strtab_sec
->sh_size
,
3903 group_name
= strtab
+ sym
->st_name
;
3906 start
= get_data (NULL
, file
, section
->sh_offset
,
3907 section
->sh_size
, _("section data"));
3910 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
3911 entry
= byte_get (indices
, 4);
3914 if (do_section_groups
)
3916 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
3917 get_group_flags (entry
), name
, group_name
, size
);
3919 printf (_(" [Index] Name\n"));
3922 group
->group_index
= i
;
3924 for (j
= 0; j
< size
; j
++)
3926 struct group_list
*g
;
3928 entry
= byte_get (indices
, 4);
3931 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
3934 error (_("section [%5u] already in group section [%5u]\n"),
3935 entry
, section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
3939 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
3942 if (do_section_groups
)
3944 sec
= SECTION_HEADER (entry
);
3945 printf (" [%5u] %s\n",
3946 entry
, SECTION_NAME (sec
));
3949 g
= xmalloc (sizeof (struct group_list
));
3950 g
->section_index
= entry
;
3951 g
->next
= group
->root
;
3973 } dynamic_relocations
[] =
3975 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
3976 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
3977 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
3980 /* Process the reloc section. */
3982 process_relocs (FILE *file
)
3984 unsigned long rel_size
;
3985 unsigned long rel_offset
;
3991 if (do_using_dynamic
)
3995 int has_dynamic_reloc
;
3998 has_dynamic_reloc
= 0;
4000 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4002 is_rela
= dynamic_relocations
[i
].rela
;
4003 name
= dynamic_relocations
[i
].name
;
4004 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4005 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4007 has_dynamic_reloc
|= rel_size
;
4009 if (is_rela
== UNKNOWN
)
4011 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4012 switch (dynamic_info
[DT_PLTREL
])
4026 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4027 name
, rel_offset
, rel_size
);
4029 dump_relocations (file
,
4030 offset_from_vma (file
, rel_offset
, rel_size
),
4032 dynamic_symbols
, num_dynamic_syms
,
4033 dynamic_strings
, is_rela
);
4037 if (! has_dynamic_reloc
)
4038 printf (_("\nThere are no dynamic relocations in this file.\n"));
4042 Elf_Internal_Shdr
*section
;
4046 for (i
= 0, section
= section_headers
;
4047 i
< elf_header
.e_shnum
;
4050 if ( section
->sh_type
!= SHT_RELA
4051 && section
->sh_type
!= SHT_REL
)
4054 rel_offset
= section
->sh_offset
;
4055 rel_size
= section
->sh_size
;
4059 Elf_Internal_Shdr
*strsec
;
4060 Elf_Internal_Sym
*symtab
;
4063 unsigned long nsyms
;
4065 printf (_("\nRelocation section "));
4067 if (string_table
== NULL
)
4068 printf ("%d", section
->sh_name
);
4070 printf (_("'%s'"), SECTION_NAME (section
));
4072 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4073 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4078 if (section
->sh_link
)
4080 Elf_Internal_Shdr
*symsec
;
4082 symsec
= SECTION_HEADER (section
->sh_link
);
4083 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4084 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4089 strsec
= SECTION_HEADER (symsec
->sh_link
);
4091 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4092 strsec
->sh_size
, _("string table"));
4094 is_rela
= section
->sh_type
== SHT_RELA
;
4096 dump_relocations (file
, rel_offset
, rel_size
,
4097 symtab
, nsyms
, strtab
, is_rela
);
4109 printf (_("\nThere are no relocations in this file.\n"));
4115 #include "unwind-ia64.h"
4117 /* An absolute address consists of a section and an offset. If the
4118 section is NULL, the offset itself is the address, otherwise, the
4119 address equals to LOAD_ADDRESS(section) + offset. */
4123 unsigned short section
;
4129 struct unw_table_entry
4131 struct absaddr start
;
4133 struct absaddr info
;
4135 *table
; /* Unwind table. */
4136 unsigned long table_len
; /* Length of unwind table. */
4137 unsigned char *info
; /* Unwind info. */
4138 unsigned long info_size
; /* Size of unwind info. */
4139 bfd_vma info_addr
; /* starting address of unwind info. */
4140 bfd_vma seg_base
; /* Starting address of segment. */
4141 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4142 unsigned long nsyms
; /* Number of symbols. */
4143 char *strtab
; /* The string table. */
4144 unsigned long strtab_size
; /* Size of string table. */
4148 find_symbol_for_address (struct unw_aux_info
*aux
,
4149 struct absaddr addr
,
4150 const char **symname
,
4153 bfd_vma dist
= 0x100000;
4154 Elf_Internal_Sym
*sym
, *best
= NULL
;
4157 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
4159 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4160 && sym
->st_name
!= 0
4161 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4162 && addr
.offset
>= sym
->st_value
4163 && addr
.offset
- sym
->st_value
< dist
)
4166 dist
= addr
.offset
- sym
->st_value
;
4173 *symname
= (best
->st_name
>= aux
->strtab_size
4174 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
4179 *offset
= addr
.offset
;
4183 dump_ia64_unwind (struct unw_aux_info
*aux
)
4186 struct unw_table_entry
*tp
;
4189 addr_size
= is_32bit_elf
? 4 : 8;
4191 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4195 const unsigned char *dp
;
4196 const unsigned char *head
;
4197 const char *procname
;
4199 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
4201 fputs ("\n<", stdout
);
4205 fputs (procname
, stdout
);
4208 printf ("+%lx", (unsigned long) offset
);
4211 fputs (">: [", stdout
);
4212 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4213 fputc ('-', stdout
);
4214 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4215 printf ("], info at +0x%lx\n",
4216 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4218 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4219 stamp
= BYTE_GET8 ((unsigned char *) head
);
4221 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4222 (unsigned) UNW_VER (stamp
),
4223 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4224 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4225 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4226 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4228 if (UNW_VER (stamp
) != 1)
4230 printf ("\tUnknown version.\n");
4235 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4236 dp
= unw_decode (dp
, in_body
, & in_body
);
4241 slurp_ia64_unwind_table (FILE *file
,
4242 struct unw_aux_info
*aux
,
4243 Elf_Internal_Shdr
*sec
)
4245 unsigned long size
, addr_size
, nrelas
, i
;
4246 Elf_Internal_Phdr
*seg
;
4247 struct unw_table_entry
*tep
;
4248 Elf_Internal_Shdr
*relsec
;
4249 Elf_Internal_Rela
*rela
, *rp
;
4250 unsigned char *table
, *tp
;
4251 Elf_Internal_Sym
*sym
;
4252 const char *relname
;
4254 addr_size
= is_32bit_elf
? 4 : 8;
4256 /* First, find the starting address of the segment that includes
4259 if (elf_header
.e_phnum
)
4261 if (! get_program_headers (file
))
4264 for (seg
= program_headers
;
4265 seg
< program_headers
+ elf_header
.e_phnum
;
4268 if (seg
->p_type
!= PT_LOAD
)
4271 if (sec
->sh_addr
>= seg
->p_vaddr
4272 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4274 aux
->seg_base
= seg
->p_vaddr
;
4280 /* Second, build the unwind table from the contents of the unwind section: */
4281 size
= sec
->sh_size
;
4282 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4286 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4287 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4289 tep
->start
.section
= SHN_UNDEF
;
4290 tep
->end
.section
= SHN_UNDEF
;
4291 tep
->info
.section
= SHN_UNDEF
;
4294 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4295 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4296 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4300 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4301 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4302 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4304 tep
->start
.offset
+= aux
->seg_base
;
4305 tep
->end
.offset
+= aux
->seg_base
;
4306 tep
->info
.offset
+= aux
->seg_base
;
4310 /* Third, apply any relocations to the unwind table: */
4312 for (relsec
= section_headers
;
4313 relsec
< section_headers
+ elf_header
.e_shnum
;
4316 if (relsec
->sh_type
!= SHT_RELA
4317 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4320 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4324 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4328 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4329 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4331 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4333 warn (_("Skipping unexpected symbol type %u\n"),
4334 ELF32_ST_TYPE (sym
->st_info
));
4340 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4341 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4343 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4345 warn (_("Skipping unexpected symbol type %u\n"),
4346 ELF64_ST_TYPE (sym
->st_info
));
4351 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4353 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4357 i
= rp
->r_offset
/ (3 * addr_size
);
4359 switch (rp
->r_offset
/addr_size
% 3)
4362 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4363 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4366 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4367 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4370 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4371 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4381 aux
->table_len
= size
/ (3 * addr_size
);
4386 process_unwind (FILE *file
)
4388 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4389 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4390 struct unw_aux_info aux
;
4395 if (elf_header
.e_machine
!= EM_IA_64
)
4397 printf (_("\nThere are no unwind sections in this file.\n"));
4401 memset (& aux
, 0, sizeof (aux
));
4403 addr_size
= is_32bit_elf
? 4 : 8;
4405 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4407 if (sec
->sh_type
== SHT_SYMTAB
)
4409 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4410 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4412 strsec
= SECTION_HEADER (sec
->sh_link
);
4413 aux
.strtab_size
= strsec
->sh_size
;
4414 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4415 aux
.strtab_size
, _("string table"));
4417 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4422 printf (_("\nThere are no unwind sections in this file.\n"));
4424 while (unwcount
-- > 0)
4429 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4430 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4431 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4438 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4440 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4442 /* We need to find which section group it is in. */
4443 struct group_list
*g
= section_headers_groups
[i
]->root
;
4445 for (; g
!= NULL
; g
= g
->next
)
4447 sec
= SECTION_HEADER (g
->section_index
);
4448 if (strcmp (SECTION_NAME (sec
),
4449 ELF_STRING_ia64_unwind_info
) == 0)
4454 i
= elf_header
.e_shnum
;
4456 else if (strncmp (SECTION_NAME (unwsec
),
4457 ELF_STRING_ia64_unwind_once
, len
) == 0)
4459 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4460 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4461 suffix
= SECTION_NAME (unwsec
) + len
;
4462 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4464 if (strncmp (SECTION_NAME (sec
),
4465 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4466 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4471 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4472 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4473 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4474 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4476 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4478 suffix
= SECTION_NAME (unwsec
) + len
;
4479 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4481 if (strncmp (SECTION_NAME (sec
),
4482 ELF_STRING_ia64_unwind_info
, len2
) == 0
4483 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4487 if (i
== elf_header
.e_shnum
)
4489 printf (_("\nCould not find unwind info section for "));
4491 if (string_table
== NULL
)
4492 printf ("%d", unwsec
->sh_name
);
4494 printf (_("'%s'"), SECTION_NAME (unwsec
));
4498 aux
.info_size
= sec
->sh_size
;
4499 aux
.info_addr
= sec
->sh_addr
;
4500 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4503 printf (_("\nUnwind section "));
4505 if (string_table
== NULL
)
4506 printf ("%d", unwsec
->sh_name
);
4508 printf (_("'%s'"), SECTION_NAME (unwsec
));
4510 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4511 (unsigned long) unwsec
->sh_offset
,
4512 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4514 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4516 if (aux
.table_len
> 0)
4517 dump_ia64_unwind (& aux
);
4520 free ((char *) aux
.table
);
4522 free ((char *) aux
.info
);
4531 free ((char *) aux
.strtab
);
4537 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
4539 switch (entry
->d_tag
)
4542 if (entry
->d_un
.d_val
== 0)
4546 static const char * opts
[] =
4548 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4549 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4550 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4551 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4556 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4557 if (entry
->d_un
.d_val
& (1 << cnt
))
4559 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4566 case DT_MIPS_IVERSION
:
4567 if (dynamic_strings
!= NULL
)
4568 printf ("Interface Version: %s\n",
4569 dynamic_strings
+ entry
->d_un
.d_val
);
4571 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4574 case DT_MIPS_TIME_STAMP
:
4579 time_t time
= entry
->d_un
.d_val
;
4580 tmp
= gmtime (&time
);
4581 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4582 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4583 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4584 printf ("Time Stamp: %s\n", timebuf
);
4588 case DT_MIPS_RLD_VERSION
:
4589 case DT_MIPS_LOCAL_GOTNO
:
4590 case DT_MIPS_CONFLICTNO
:
4591 case DT_MIPS_LIBLISTNO
:
4592 case DT_MIPS_SYMTABNO
:
4593 case DT_MIPS_UNREFEXTNO
:
4594 case DT_MIPS_HIPAGENO
:
4595 case DT_MIPS_DELTA_CLASS_NO
:
4596 case DT_MIPS_DELTA_INSTANCE_NO
:
4597 case DT_MIPS_DELTA_RELOC_NO
:
4598 case DT_MIPS_DELTA_SYM_NO
:
4599 case DT_MIPS_DELTA_CLASSSYM_NO
:
4600 case DT_MIPS_COMPACT_SIZE
:
4601 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4605 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4611 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
4613 switch (entry
->d_tag
)
4615 case DT_HP_DLD_FLAGS
:
4624 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4625 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4626 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4627 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4628 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4629 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4630 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4631 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4632 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4633 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4634 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4638 bfd_vma val
= entry
->d_un
.d_val
;
4640 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4641 if (val
& flags
[cnt
].bit
)
4645 fputs (flags
[cnt
].str
, stdout
);
4647 val
^= flags
[cnt
].bit
;
4650 if (val
!= 0 || first
)
4654 print_vma (val
, HEX
);
4660 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4667 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
4669 switch (entry
->d_tag
)
4671 case DT_IA_64_PLT_RESERVE
:
4672 /* First 3 slots reserved. */
4673 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4675 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
4679 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4686 get_32bit_dynamic_section (FILE *file
)
4688 Elf32_External_Dyn
*edyn
, *ext
;
4689 Elf_Internal_Dyn
*entry
;
4691 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4692 _("dynamic section"));
4696 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4697 might not have the luxury of section headers. Look for the DT_NULL
4698 terminator to determine the number of entries. */
4699 for (ext
= edyn
, dynamic_nent
= 0;
4700 (char *) ext
< (char *) edyn
+ dynamic_size
;
4704 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
4708 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4709 if (dynamic_section
== NULL
)
4711 error (_("Out of memory\n"));
4716 for (ext
= edyn
, entry
= dynamic_section
;
4717 entry
< dynamic_section
+ dynamic_nent
;
4720 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
4721 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
4730 get_64bit_dynamic_section (FILE *file
)
4732 Elf64_External_Dyn
*edyn
, *ext
;
4733 Elf_Internal_Dyn
*entry
;
4735 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4736 _("dynamic section"));
4740 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4741 might not have the luxury of section headers. Look for the DT_NULL
4742 terminator to determine the number of entries. */
4743 for (ext
= edyn
, dynamic_nent
= 0;
4744 (char *) ext
< (char *) edyn
+ dynamic_size
;
4748 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
4752 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4753 if (dynamic_section
== NULL
)
4755 error (_("Out of memory\n"));
4760 for (ext
= edyn
, entry
= dynamic_section
;
4761 entry
< dynamic_section
+ dynamic_nent
;
4764 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
4765 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
4774 get_dynamic_flags (bfd_vma flags
)
4776 static char buff
[128];
4784 flag
= flags
& - flags
;
4792 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4793 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4794 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4795 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4796 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4797 default: strcpy (p
, "unknown"); break;
4800 p
= strchr (p
, '\0');
4805 /* Parse and display the contents of the dynamic section. */
4808 process_dynamic_section (FILE *file
)
4810 Elf_Internal_Dyn
*entry
;
4812 if (dynamic_size
== 0)
4815 printf (_("\nThere is no dynamic section in this file.\n"));
4822 if (! get_32bit_dynamic_section (file
))
4825 else if (! get_64bit_dynamic_section (file
))
4828 /* Find the appropriate symbol table. */
4829 if (dynamic_symbols
== NULL
)
4831 for (entry
= dynamic_section
;
4832 entry
< dynamic_section
+ dynamic_nent
;
4835 Elf_Internal_Shdr section
;
4837 if (entry
->d_tag
!= DT_SYMTAB
)
4840 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4842 /* Since we do not know how big the symbol table is,
4843 we default to reading in the entire file (!) and
4844 processing that. This is overkill, I know, but it
4846 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4848 if (archive_file_offset
!= 0)
4849 section
.sh_size
= archive_file_size
- section
.sh_offset
;
4852 if (fseek (file
, 0, SEEK_END
))
4853 error (_("Unable to seek to end of file!"));
4855 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4859 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4861 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4863 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4864 if (num_dynamic_syms
< 1)
4866 error (_("Unable to determine the number of symbols to load\n"));
4870 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4874 /* Similarly find a string table. */
4875 if (dynamic_strings
== NULL
)
4877 for (entry
= dynamic_section
;
4878 entry
< dynamic_section
+ dynamic_nent
;
4881 unsigned long offset
;
4884 if (entry
->d_tag
!= DT_STRTAB
)
4887 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4889 /* Since we do not know how big the string table is,
4890 we default to reading in the entire file (!) and
4891 processing that. This is overkill, I know, but it
4894 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4896 if (archive_file_offset
!= 0)
4897 str_tab_len
= archive_file_size
- offset
;
4900 if (fseek (file
, 0, SEEK_END
))
4901 error (_("Unable to seek to end of file\n"));
4902 str_tab_len
= ftell (file
) - offset
;
4905 if (str_tab_len
< 1)
4908 (_("Unable to determine the length of the dynamic string table\n"));
4912 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
4913 _("dynamic string table"));
4918 /* And find the syminfo section if available. */
4919 if (dynamic_syminfo
== NULL
)
4921 unsigned long syminsz
= 0;
4923 for (entry
= dynamic_section
;
4924 entry
< dynamic_section
+ dynamic_nent
;
4927 if (entry
->d_tag
== DT_SYMINENT
)
4929 /* Note: these braces are necessary to avoid a syntax
4930 error from the SunOS4 C compiler. */
4931 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4933 else if (entry
->d_tag
== DT_SYMINSZ
)
4934 syminsz
= entry
->d_un
.d_val
;
4935 else if (entry
->d_tag
== DT_SYMINFO
)
4936 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
4940 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4942 Elf_External_Syminfo
*extsyminfo
, *extsym
;
4943 Elf_Internal_Syminfo
*syminfo
;
4945 /* There is a syminfo section. Read the data. */
4946 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
4947 _("symbol information"));
4951 dynamic_syminfo
= malloc (syminsz
);
4952 if (dynamic_syminfo
== NULL
)
4954 error (_("Out of memory\n"));
4958 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4959 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
4960 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
4961 ++syminfo
, ++extsym
)
4963 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
4964 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
4971 if (do_dynamic
&& dynamic_addr
)
4972 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
4973 dynamic_addr
, dynamic_nent
);
4975 printf (_(" Tag Type Name/Value\n"));
4977 for (entry
= dynamic_section
;
4978 entry
< dynamic_section
+ dynamic_nent
;
4986 print_vma (entry
->d_tag
, FULL_HEX
);
4987 dtype
= get_dynamic_type (entry
->d_tag
);
4988 printf (" (%s)%*s", dtype
,
4989 ((is_32bit_elf
? 27 : 19)
4990 - (int) strlen (dtype
)),
4994 switch (entry
->d_tag
)
4998 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5008 switch (entry
->d_tag
)
5011 printf (_("Auxiliary library"));
5015 printf (_("Filter library"));
5019 printf (_("Configuration file"));
5023 printf (_("Dependency audit library"));
5027 printf (_("Audit library"));
5031 if (dynamic_strings
)
5032 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
5036 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5045 printf (_("Flags:"));
5047 if (entry
->d_un
.d_val
== 0)
5048 printf (_(" None\n"));
5051 unsigned long int val
= entry
->d_un
.d_val
;
5053 if (val
& DTF_1_PARINIT
)
5055 printf (" PARINIT");
5056 val
^= DTF_1_PARINIT
;
5058 if (val
& DTF_1_CONFEXP
)
5060 printf (" CONFEXP");
5061 val
^= DTF_1_CONFEXP
;
5064 printf (" %lx", val
);
5073 printf (_("Flags:"));
5075 if (entry
->d_un
.d_val
== 0)
5076 printf (_(" None\n"));
5079 unsigned long int val
= entry
->d_un
.d_val
;
5081 if (val
& DF_P1_LAZYLOAD
)
5083 printf (" LAZYLOAD");
5084 val
^= DF_P1_LAZYLOAD
;
5086 if (val
& DF_P1_GROUPPERM
)
5088 printf (" GROUPPERM");
5089 val
^= DF_P1_GROUPPERM
;
5092 printf (" %lx", val
);
5101 printf (_("Flags:"));
5102 if (entry
->d_un
.d_val
== 0)
5103 printf (_(" None\n"));
5106 unsigned long int val
= entry
->d_un
.d_val
;
5113 if (val
& DF_1_GLOBAL
)
5118 if (val
& DF_1_GROUP
)
5123 if (val
& DF_1_NODELETE
)
5125 printf (" NODELETE");
5126 val
^= DF_1_NODELETE
;
5128 if (val
& DF_1_LOADFLTR
)
5130 printf (" LOADFLTR");
5131 val
^= DF_1_LOADFLTR
;
5133 if (val
& DF_1_INITFIRST
)
5135 printf (" INITFIRST");
5136 val
^= DF_1_INITFIRST
;
5138 if (val
& DF_1_NOOPEN
)
5143 if (val
& DF_1_ORIGIN
)
5148 if (val
& DF_1_DIRECT
)
5153 if (val
& DF_1_TRANS
)
5158 if (val
& DF_1_INTERPOSE
)
5160 printf (" INTERPOSE");
5161 val
^= DF_1_INTERPOSE
;
5163 if (val
& DF_1_NODEFLIB
)
5165 printf (" NODEFLIB");
5166 val
^= DF_1_NODEFLIB
;
5168 if (val
& DF_1_NODUMP
)
5173 if (val
& DF_1_CONLFAT
)
5175 printf (" CONLFAT");
5176 val
^= DF_1_CONLFAT
;
5179 printf (" %lx", val
);
5186 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5188 puts (get_dynamic_type (entry
->d_un
.d_val
));
5208 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5214 if (dynamic_strings
== NULL
)
5217 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5221 switch (entry
->d_tag
)
5224 printf (_("Shared library: [%s]"), name
);
5226 if (strcmp (name
, program_interpreter
) == 0)
5227 printf (_(" program interpreter"));
5231 printf (_("Library soname: [%s]"), name
);
5235 printf (_("Library rpath: [%s]"), name
);
5239 printf (_("Library runpath: [%s]"), name
);
5243 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5248 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5261 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5265 case DT_INIT_ARRAYSZ
:
5266 case DT_FINI_ARRAYSZ
:
5267 case DT_GNU_CONFLICTSZ
:
5268 case DT_GNU_LIBLISTSZ
:
5271 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5272 printf (" (bytes)\n");
5282 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5295 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
5299 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5303 printf (_("Not needed object: [%s]\n"), name
);
5308 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5314 /* The value of this entry is ignored. */
5319 case DT_GNU_PRELINKED
:
5323 time_t time
= entry
->d_un
.d_val
;
5325 tmp
= gmtime (&time
);
5326 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5327 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5328 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5334 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5335 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5340 switch (elf_header
.e_machine
)
5343 case EM_MIPS_RS3_LE
:
5344 dynamic_section_mips_val (entry
);
5347 dynamic_section_parisc_val (entry
);
5350 dynamic_section_ia64_val (entry
);
5353 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5365 get_ver_flags (unsigned int flags
)
5367 static char buff
[32];
5374 if (flags
& VER_FLG_BASE
)
5375 strcat (buff
, "BASE ");
5377 if (flags
& VER_FLG_WEAK
)
5379 if (flags
& VER_FLG_BASE
)
5380 strcat (buff
, "| ");
5382 strcat (buff
, "WEAK ");
5385 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5386 strcat (buff
, "| <unknown>");
5391 /* Display the contents of the version sections. */
5393 process_version_sections (FILE *file
)
5395 Elf_Internal_Shdr
*section
;
5402 for (i
= 0, section
= section_headers
;
5403 i
< elf_header
.e_shnum
;
5406 switch (section
->sh_type
)
5408 case SHT_GNU_verdef
:
5410 Elf_External_Verdef
*edefs
;
5417 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5418 SECTION_NAME (section
), section
->sh_info
);
5420 printf (_(" Addr: 0x"));
5421 printf_vma (section
->sh_addr
);
5422 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5423 (unsigned long) section
->sh_offset
, section
->sh_link
,
5424 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5426 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5427 _("version definition section"));
5431 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5434 Elf_External_Verdef
*edef
;
5435 Elf_Internal_Verdef ent
;
5436 Elf_External_Verdaux
*eaux
;
5437 Elf_Internal_Verdaux aux
;
5441 vstart
= ((char *) edefs
) + idx
;
5443 edef
= (Elf_External_Verdef
*) vstart
;
5445 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5446 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5447 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5448 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5449 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5450 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5451 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5453 printf (_(" %#06x: Rev: %d Flags: %s"),
5454 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5456 printf (_(" Index: %d Cnt: %d "),
5457 ent
.vd_ndx
, ent
.vd_cnt
);
5459 vstart
+= ent
.vd_aux
;
5461 eaux
= (Elf_External_Verdaux
*) vstart
;
5463 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5464 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5466 if (dynamic_strings
)
5467 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5469 printf (_("Name index: %ld\n"), aux
.vda_name
);
5471 isum
= idx
+ ent
.vd_aux
;
5473 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5475 isum
+= aux
.vda_next
;
5476 vstart
+= aux
.vda_next
;
5478 eaux
= (Elf_External_Verdaux
*) vstart
;
5480 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5481 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5483 if (dynamic_strings
)
5484 printf (_(" %#06x: Parent %d: %s\n"),
5485 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5487 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5488 isum
, j
, aux
.vda_name
);
5498 case SHT_GNU_verneed
:
5500 Elf_External_Verneed
*eneed
;
5506 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5507 SECTION_NAME (section
), section
->sh_info
);
5509 printf (_(" Addr: 0x"));
5510 printf_vma (section
->sh_addr
);
5511 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5512 (unsigned long) section
->sh_offset
, section
->sh_link
,
5513 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5515 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5516 _("version need section"));
5520 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5522 Elf_External_Verneed
*entry
;
5523 Elf_Internal_Verneed ent
;
5528 vstart
= ((char *) eneed
) + idx
;
5530 entry
= (Elf_External_Verneed
*) vstart
;
5532 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5533 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5534 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5535 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5536 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5538 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5540 if (dynamic_strings
)
5541 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5543 printf (_(" File: %lx"), ent
.vn_file
);
5545 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5547 vstart
+= ent
.vn_aux
;
5549 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5551 Elf_External_Vernaux
*eaux
;
5552 Elf_Internal_Vernaux aux
;
5554 eaux
= (Elf_External_Vernaux
*) vstart
;
5556 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5557 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5558 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5559 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5560 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5562 if (dynamic_strings
)
5563 printf (_(" %#06x: Name: %s"),
5564 isum
, dynamic_strings
+ aux
.vna_name
);
5566 printf (_(" %#06x: Name index: %lx"),
5567 isum
, aux
.vna_name
);
5569 printf (_(" Flags: %s Version: %d\n"),
5570 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5572 isum
+= aux
.vna_next
;
5573 vstart
+= aux
.vna_next
;
5583 case SHT_GNU_versym
:
5585 Elf_Internal_Shdr
*link_section
;
5588 unsigned char *edata
;
5589 unsigned short *data
;
5591 Elf_Internal_Sym
*symbols
;
5592 Elf_Internal_Shdr
*string_sec
;
5595 link_section
= SECTION_HEADER (section
->sh_link
);
5596 total
= section
->sh_size
/ section
->sh_entsize
;
5600 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5602 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5604 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5605 string_sec
->sh_size
, _("version string table"));
5609 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5610 SECTION_NAME (section
), total
);
5612 printf (_(" Addr: "));
5613 printf_vma (section
->sh_addr
);
5614 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5615 (unsigned long) section
->sh_offset
, section
->sh_link
,
5616 SECTION_NAME (link_section
));
5618 off
= offset_from_vma (file
,
5619 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5620 total
* sizeof (short));
5621 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
5622 _("version symbol data"));
5629 data
= malloc (total
* sizeof (short));
5631 for (cnt
= total
; cnt
--;)
5632 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5637 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5640 int check_def
, check_need
;
5643 printf (" %03x:", cnt
);
5645 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5646 switch (data
[cnt
+ j
])
5649 fputs (_(" 0 (*local*) "), stdout
);
5653 fputs (_(" 1 (*global*) "), stdout
);
5657 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5658 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5662 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5665 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5672 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5674 Elf_Internal_Verneed ivn
;
5675 unsigned long offset
;
5677 offset
= offset_from_vma
5678 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5679 sizeof (Elf_External_Verneed
));
5683 Elf_Internal_Vernaux ivna
;
5684 Elf_External_Verneed evn
;
5685 Elf_External_Vernaux evna
;
5686 unsigned long a_off
;
5688 get_data (&evn
, file
, offset
, sizeof (evn
),
5691 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5692 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5694 a_off
= offset
+ ivn
.vn_aux
;
5698 get_data (&evna
, file
, a_off
, sizeof (evna
),
5699 _("version need aux (2)"));
5701 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5702 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5704 a_off
+= ivna
.vna_next
;
5706 while (ivna
.vna_other
!= data
[cnt
+ j
]
5707 && ivna
.vna_next
!= 0);
5709 if (ivna
.vna_other
== data
[cnt
+ j
])
5711 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5713 name
= strtab
+ ivna
.vna_name
;
5714 nn
+= printf ("(%s%-*s",
5716 12 - (int) strlen (name
),
5722 offset
+= ivn
.vn_next
;
5724 while (ivn
.vn_next
);
5727 if (check_def
&& data
[cnt
+ j
] != 0x8001
5728 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5730 Elf_Internal_Verdef ivd
;
5731 Elf_External_Verdef evd
;
5732 unsigned long offset
;
5734 offset
= offset_from_vma
5735 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5740 get_data (&evd
, file
, offset
, sizeof (evd
),
5743 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5744 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5746 offset
+= ivd
.vd_next
;
5748 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5749 && ivd
.vd_next
!= 0);
5751 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5753 Elf_External_Verdaux evda
;
5754 Elf_Internal_Verdaux ivda
;
5756 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5758 get_data (&evda
, file
,
5759 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5760 sizeof (evda
), _("version def aux"));
5762 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5764 name
= strtab
+ ivda
.vda_name
;
5765 nn
+= printf ("(%s%-*s",
5767 12 - (int) strlen (name
),
5773 printf ("%*c", 18 - nn
, ' ');
5791 printf (_("\nNo version information found in this file.\n"));
5797 get_symbol_binding (unsigned int binding
)
5799 static char buff
[32];
5803 case STB_LOCAL
: return "LOCAL";
5804 case STB_GLOBAL
: return "GLOBAL";
5805 case STB_WEAK
: return "WEAK";
5807 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5808 sprintf (buff
, _("<processor specific>: %d"), binding
);
5809 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5810 sprintf (buff
, _("<OS specific>: %d"), binding
);
5812 sprintf (buff
, _("<unknown>: %d"), binding
);
5818 get_symbol_type (unsigned int type
)
5820 static char buff
[32];
5824 case STT_NOTYPE
: return "NOTYPE";
5825 case STT_OBJECT
: return "OBJECT";
5826 case STT_FUNC
: return "FUNC";
5827 case STT_SECTION
: return "SECTION";
5828 case STT_FILE
: return "FILE";
5829 case STT_COMMON
: return "COMMON";
5830 case STT_TLS
: return "TLS";
5832 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5834 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5835 return "THUMB_FUNC";
5837 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5840 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5841 return "PARISC_MILLI";
5843 sprintf (buff
, _("<processor specific>: %d"), type
);
5845 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5847 if (elf_header
.e_machine
== EM_PARISC
)
5849 if (type
== STT_HP_OPAQUE
)
5851 if (type
== STT_HP_STUB
)
5855 sprintf (buff
, _("<OS specific>: %d"), type
);
5858 sprintf (buff
, _("<unknown>: %d"), type
);
5864 get_symbol_visibility (unsigned int visibility
)
5868 case STV_DEFAULT
: return "DEFAULT";
5869 case STV_INTERNAL
: return "INTERNAL";
5870 case STV_HIDDEN
: return "HIDDEN";
5871 case STV_PROTECTED
: return "PROTECTED";
5877 get_symbol_index_type (unsigned int type
)
5879 static char buff
[32];
5883 case SHN_UNDEF
: return "UND";
5884 case SHN_ABS
: return "ABS";
5885 case SHN_COMMON
: return "COM";
5887 if (type
== SHN_IA_64_ANSI_COMMON
5888 && elf_header
.e_machine
== EM_IA_64
5889 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
5891 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5892 sprintf (buff
, "PRC[0x%04x]", type
);
5893 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5894 sprintf (buff
, "OS [0x%04x]", type
);
5895 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5896 sprintf (buff
, "RSV[0x%04x]", type
);
5898 sprintf (buff
, "%3d", type
);
5906 get_dynamic_data (FILE *file
, unsigned int number
)
5908 unsigned char *e_data
;
5911 e_data
= malloc (number
* 4);
5915 error (_("Out of memory\n"));
5919 if (fread (e_data
, 4, number
, file
) != number
)
5921 error (_("Unable to read in dynamic data\n"));
5925 i_data
= malloc (number
* sizeof (*i_data
));
5929 error (_("Out of memory\n"));
5935 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5942 /* Dump the symbol table. */
5944 process_symbol_table (FILE *file
)
5946 Elf_Internal_Shdr
*section
;
5947 unsigned char nb
[4];
5948 unsigned char nc
[4];
5951 int *buckets
= NULL
;
5954 if (! do_syms
&& !do_histogram
)
5957 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5961 (archive_file_offset
5962 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
5963 sizeof nb
+ sizeof nc
)),
5966 error (_("Unable to seek to start of dynamic information"));
5970 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5972 error (_("Failed to read in number of buckets\n"));
5976 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5978 error (_("Failed to read in number of chains\n"));
5982 nbuckets
= byte_get (nb
, 4);
5983 nchains
= byte_get (nc
, 4);
5985 buckets
= get_dynamic_data (file
, nbuckets
);
5986 chains
= get_dynamic_data (file
, nchains
);
5988 if (buckets
== NULL
|| chains
== NULL
)
5993 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5998 printf (_("\nSymbol table for image:\n"));
6000 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6002 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6004 for (hn
= 0; hn
< nbuckets
; hn
++)
6009 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6011 Elf_Internal_Sym
*psym
;
6013 psym
= dynamic_symbols
+ si
;
6015 printf (" %3d %3d: ", si
, hn
);
6016 print_vma (psym
->st_value
, LONG_HEX
);
6018 print_vma (psym
->st_size
, DEC_5
);
6020 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6021 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6022 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6023 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6024 print_symbol (25, dynamic_strings
+ psym
->st_name
);
6029 else if (do_syms
&& !do_using_dynamic
)
6033 for (i
= 0, section
= section_headers
;
6034 i
< elf_header
.e_shnum
;
6039 Elf_Internal_Sym
*symtab
;
6040 Elf_Internal_Sym
*psym
;
6043 if ( section
->sh_type
!= SHT_SYMTAB
6044 && section
->sh_type
!= SHT_DYNSYM
)
6047 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6048 SECTION_NAME (section
),
6049 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6051 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6053 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6055 symtab
= GET_ELF_SYMBOLS (file
, section
);
6059 if (section
->sh_link
== elf_header
.e_shstrndx
)
6060 strtab
= string_table
;
6063 Elf_Internal_Shdr
*string_sec
;
6065 string_sec
= SECTION_HEADER (section
->sh_link
);
6067 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6068 string_sec
->sh_size
, _("string table"));
6071 for (si
= 0, psym
= symtab
;
6072 si
< section
->sh_size
/ section
->sh_entsize
;
6075 printf ("%6d: ", si
);
6076 print_vma (psym
->st_value
, LONG_HEX
);
6078 print_vma (psym
->st_size
, DEC_5
);
6079 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6080 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6081 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6082 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6083 print_symbol (25, strtab
+ psym
->st_name
);
6085 if (section
->sh_type
== SHT_DYNSYM
&&
6086 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6088 unsigned char data
[2];
6089 unsigned short vers_data
;
6090 unsigned long offset
;
6094 offset
= offset_from_vma
6095 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6096 sizeof data
+ si
* sizeof (vers_data
));
6098 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6099 sizeof (data
), _("version data"));
6101 vers_data
= byte_get (data
, 2);
6103 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6106 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6108 if ((vers_data
& 0x8000) || vers_data
> 1)
6110 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6111 && (is_nobits
|| ! check_def
))
6113 Elf_External_Verneed evn
;
6114 Elf_Internal_Verneed ivn
;
6115 Elf_Internal_Vernaux ivna
;
6117 /* We must test both. */
6118 offset
= offset_from_vma
6119 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6124 unsigned long vna_off
;
6126 get_data (&evn
, file
, offset
, sizeof (evn
),
6129 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6130 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6132 vna_off
= offset
+ ivn
.vn_aux
;
6136 Elf_External_Vernaux evna
;
6138 get_data (&evna
, file
, vna_off
,
6140 _("version need aux (3)"));
6142 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6143 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6144 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6146 vna_off
+= ivna
.vna_next
;
6148 while (ivna
.vna_other
!= vers_data
6149 && ivna
.vna_next
!= 0);
6151 if (ivna
.vna_other
== vers_data
)
6154 offset
+= ivn
.vn_next
;
6156 while (ivn
.vn_next
!= 0);
6158 if (ivna
.vna_other
== vers_data
)
6161 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6164 else if (! is_nobits
)
6165 error (_("bad dynamic symbol"));
6172 if (vers_data
!= 0x8001
6173 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6175 Elf_Internal_Verdef ivd
;
6176 Elf_Internal_Verdaux ivda
;
6177 Elf_External_Verdaux evda
;
6178 unsigned long offset
;
6180 offset
= offset_from_vma
6182 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6183 sizeof (Elf_External_Verdef
));
6187 Elf_External_Verdef evd
;
6189 get_data (&evd
, file
, offset
, sizeof (evd
),
6192 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6193 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6194 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6196 offset
+= ivd
.vd_next
;
6198 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6199 && ivd
.vd_next
!= 0);
6201 offset
-= ivd
.vd_next
;
6202 offset
+= ivd
.vd_aux
;
6204 get_data (&evda
, file
, offset
, sizeof (evda
),
6205 _("version def aux"));
6207 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6209 if (psym
->st_name
!= ivda
.vda_name
)
6210 printf ((vers_data
& 0x8000)
6212 strtab
+ ivda
.vda_name
);
6222 if (strtab
!= string_table
)
6228 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6230 if (do_histogram
&& buckets
!= NULL
)
6237 int nzero_counts
= 0;
6240 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6242 printf (_(" Length Number %% of total Coverage\n"));
6244 lengths
= calloc (nbuckets
, sizeof (int));
6245 if (lengths
== NULL
)
6247 error (_("Out of memory"));
6250 for (hn
= 0; hn
< nbuckets
; ++hn
)
6255 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6258 if (maxlength
< ++lengths
[hn
])
6263 counts
= calloc (maxlength
+ 1, sizeof (int));
6266 error (_("Out of memory"));
6270 for (hn
= 0; hn
< nbuckets
; ++hn
)
6271 ++counts
[lengths
[hn
]];
6275 printf (" 0 %-10d (%5.1f%%)\n",
6276 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6277 for (si
= 1; si
<= maxlength
; ++si
)
6279 nzero_counts
+= counts
[si
] * si
;
6280 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6281 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6282 (nzero_counts
* 100.0) / nsyms
);
6290 if (buckets
!= NULL
)
6300 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6304 if (dynamic_syminfo
== NULL
6306 /* No syminfo, this is ok. */
6309 /* There better should be a dynamic symbol section. */
6310 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6314 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6315 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6317 printf (_(" Num: Name BoundTo Flags\n"));
6318 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6320 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6322 printf ("%4d: ", i
);
6323 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
6326 switch (dynamic_syminfo
[i
].si_boundto
)
6328 case SYMINFO_BT_SELF
:
6329 fputs ("SELF ", stdout
);
6331 case SYMINFO_BT_PARENT
:
6332 fputs ("PARENT ", stdout
);
6335 if (dynamic_syminfo
[i
].si_boundto
> 0
6336 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
)
6341 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6345 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6349 if (flags
& SYMINFO_FLG_DIRECT
)
6351 if (flags
& SYMINFO_FLG_PASSTHRU
)
6352 printf (" PASSTHRU");
6353 if (flags
& SYMINFO_FLG_COPY
)
6355 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6356 printf (" LAZYLOAD");
6364 #ifdef SUPPORT_DISASSEMBLY
6366 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6368 printf (_("\nAssembly dump of section %s\n"),
6369 SECTION_NAME (section
));
6371 /* XXX -- to be done --- XXX */
6378 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6380 bfd_size_type bytes
;
6382 unsigned char *data
;
6383 unsigned char *start
;
6385 bytes
= section
->sh_size
;
6387 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6389 printf (_("\nSection '%s' has no data to dump.\n"),
6390 SECTION_NAME (section
));
6394 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6396 addr
= section
->sh_addr
;
6398 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6410 lbytes
= (bytes
> 16 ? 16 : bytes
);
6412 printf (" 0x%8.8lx ", (unsigned long) addr
);
6414 switch (elf_header
.e_ident
[EI_DATA
])
6418 for (j
= 15; j
>= 0; j
--)
6421 printf ("%2.2x", data
[j
]);
6431 for (j
= 0; j
< 16; j
++)
6434 printf ("%2.2x", data
[j
]);
6444 for (j
= 0; j
< lbytes
; j
++)
6447 if (k
>= ' ' && k
< 0x7f)
6466 static unsigned long int
6467 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6469 unsigned long int result
= 0;
6470 unsigned int num_read
= 0;
6479 result
|= (byte
& 0x7f) << shift
;
6484 while (byte
& 0x80);
6486 if (length_return
!= NULL
)
6487 *length_return
= num_read
;
6489 if (sign
&& (shift
< 32) && (byte
& 0x40))
6490 result
|= -1 << shift
;
6495 typedef struct State_Machine_Registers
6497 unsigned long address
;
6500 unsigned int column
;
6504 /* This variable hold the number of the last entry seen
6505 in the File Table. */
6506 unsigned int last_file_entry
;
6509 static SMR state_machine_regs
;
6512 reset_state_machine (int is_stmt
)
6514 state_machine_regs
.address
= 0;
6515 state_machine_regs
.file
= 1;
6516 state_machine_regs
.line
= 1;
6517 state_machine_regs
.column
= 0;
6518 state_machine_regs
.is_stmt
= is_stmt
;
6519 state_machine_regs
.basic_block
= 0;
6520 state_machine_regs
.end_sequence
= 0;
6521 state_machine_regs
.last_file_entry
= 0;
6524 /* Handled an extend line op. Returns true if this is the end
6527 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6529 unsigned char op_code
;
6532 unsigned char *name
;
6535 len
= read_leb128 (data
, & bytes_read
, 0);
6540 warn (_("badly formed extended line op encountered!\n"));
6547 printf (_(" Extended opcode %d: "), op_code
);
6551 case DW_LNE_end_sequence
:
6552 printf (_("End of Sequence\n\n"));
6553 reset_state_machine (is_stmt
);
6556 case DW_LNE_set_address
:
6557 adr
= byte_get (data
, pointer_size
);
6558 printf (_("set Address to 0x%lx\n"), adr
);
6559 state_machine_regs
.address
= adr
;
6562 case DW_LNE_define_file
:
6563 printf (_(" define new File Table entry\n"));
6564 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6566 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6568 data
+= strlen ((char *) data
) + 1;
6569 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6571 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6573 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6574 printf (_("%s\n\n"), name
);
6578 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6585 /* Finds section NAME inside FILE and returns a
6586 pointer to it, or NULL upon failure. */
6588 static Elf_Internal_Shdr
*
6589 find_section (const char * name
)
6591 Elf_Internal_Shdr
*sec
;
6594 for (i
= elf_header
.e_shnum
, sec
= section_headers
+ i
- 1;
6596 if (strcmp (SECTION_NAME (sec
), name
) == 0)
6599 if (i
&& sec
&& sec
->sh_size
!= 0)
6605 /* Size of pointers in the .debug_line section. This information is not
6606 really present in that section. It's obtained before dumping the debug
6607 sections by doing some pre-scan of the .debug_info section. */
6608 static unsigned int * debug_line_pointer_sizes
= NULL
;
6609 static unsigned int num_debug_line_pointer_sizes
= 0;
6611 /* Locate and scan the .debug_info section in the file and record the pointer
6612 sizes for the compilation units in it. Usually an executable will have
6613 just one pointer size, but this is not guaranteed, and so we try not to
6614 make any assumptions. Returns zero upon failure, or the number of
6615 compilation units upon success. */
6618 get_debug_line_pointer_sizes (FILE * file
)
6620 Elf_Internal_Shdr
* section
;
6621 unsigned char * start
;
6622 unsigned char * end
;
6623 unsigned char * begin
;
6624 unsigned long length
;
6625 unsigned int num_units
;
6628 section
= find_section (".debug_info");
6629 if (section
== NULL
)
6632 length
= section
->sh_size
;
6633 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6634 _("extracting pointer sizes from .debug_info section"));
6638 end
= start
+ section
->sh_size
;
6639 /* First scan the section to get the number of comp units. */
6640 for (begin
= start
, num_units
= 0; begin
< end
; num_units
++)
6642 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
6643 be the length. For a 64-bit DWARF section, it'll be the escape
6644 code 0xffffffff followed by an 8 byte length. */
6645 length
= byte_get (begin
, 4);
6647 if (length
== 0xffffffff)
6649 length
= byte_get (begin
+ 4, 8);
6650 begin
+= length
+ 12;
6653 begin
+= length
+ 4;
6658 error (_("No comp units in .debug_info section ?"));
6663 /* Then allocate an array to hold the pointer sizes. */
6664 debug_line_pointer_sizes
= malloc (num_units
* sizeof * debug_line_pointer_sizes
);
6665 if (debug_line_pointer_sizes
== NULL
)
6667 error (_("Not enough memory for a pointer size array of %u entries"),
6673 /* Populate the array. */
6674 for (begin
= start
, unit
= 0; begin
< end
; unit
++)
6676 length
= byte_get (begin
, 4);
6677 if (length
== 0xffffffff)
6679 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
6680 from the start of the section. This is computed as follows:
6682 unit_length: 12 bytes
6684 debug_abbrev_offset: 8 bytes
6685 -----------------------------
6688 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 22, 1);
6689 length
= byte_get (begin
+ 4, 8);
6690 begin
+= length
+ 12;
6694 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
6695 the start of the section:
6697 unit_length: 4 bytes
6699 debug_abbrev_offset: 4 bytes
6700 -----------------------------
6703 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 10, 1);
6704 begin
+= length
+ 4;
6709 num_debug_line_pointer_sizes
= num_units
;
6714 display_debug_lines (Elf_Internal_Shdr
*section
,
6715 unsigned char *start
, FILE *file
)
6717 unsigned char *hdrptr
;
6718 DWARF2_Internal_LineInfo info
;
6719 unsigned char *standard_opcodes
;
6720 unsigned char *data
= start
;
6721 unsigned char *end
= start
+ section
->sh_size
;
6722 unsigned char *end_of_sequence
;
6725 int initial_length_size
;
6726 unsigned int comp_unit
= 0;
6728 printf (_("\nDump of debug contents of section %s:\n\n"),
6729 SECTION_NAME (section
));
6731 if (num_debug_line_pointer_sizes
== 0)
6732 get_debug_line_pointer_sizes (file
);
6736 unsigned int pointer_size
;
6740 /* Check the length of the block. */
6741 info
.li_length
= byte_get (hdrptr
, 4);
6744 if (info
.li_length
== 0xffffffff)
6746 /* This section is 64-bit DWARF 3. */
6747 info
.li_length
= byte_get (hdrptr
, 8);
6750 initial_length_size
= 12;
6755 initial_length_size
= 4;
6758 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
6761 (_("The line info appears to be corrupt - the section is too small\n"));
6765 /* Check its version number. */
6766 info
.li_version
= byte_get (hdrptr
, 2);
6768 if (info
.li_version
!= 2 && info
.li_version
!= 3)
6770 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6774 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
6775 hdrptr
+= offset_size
;
6776 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
6778 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
6780 info
.li_line_base
= byte_get (hdrptr
, 1);
6782 info
.li_line_range
= byte_get (hdrptr
, 1);
6784 info
.li_opcode_base
= byte_get (hdrptr
, 1);
6787 /* Sign extend the line base field. */
6788 info
.li_line_base
<<= 24;
6789 info
.li_line_base
>>= 24;
6791 /* Get the pointer size from the comp unit associated
6792 with this block of line number information. */
6793 if (comp_unit
>= num_debug_line_pointer_sizes
)
6795 error (_("Not enough comp units for .debug_lines section\n"));
6800 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
6804 printf (_(" Length: %ld\n"), info
.li_length
);
6805 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6806 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6807 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6808 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6809 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6810 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6811 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6812 printf (_(" (Pointer size: %u)\n"), pointer_size
);
6814 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
6816 reset_state_machine (info
.li_default_is_stmt
);
6818 /* Display the contents of the Opcodes table. */
6819 standard_opcodes
= hdrptr
;
6821 printf (_("\n Opcodes:\n"));
6823 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6824 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6826 /* Display the contents of the Directory table. */
6827 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6830 printf (_("\n The Directory Table is empty.\n"));
6833 printf (_("\n The Directory Table:\n"));
6837 printf (_(" %s\n"), data
);
6839 data
+= strlen ((char *) data
) + 1;
6843 /* Skip the NUL at the end of the table. */
6846 /* Display the contents of the File Name table. */
6848 printf (_("\n The File Name Table is empty.\n"));
6851 printf (_("\n The File Name Table:\n"));
6852 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6856 unsigned char *name
;
6859 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6862 data
+= strlen ((char *) data
) + 1;
6864 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6866 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6868 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6870 printf (_("%s\n"), name
);
6874 /* Skip the NUL at the end of the table. */
6877 /* Now display the statements. */
6878 printf (_("\n Line Number Statements:\n"));
6881 while (data
< end_of_sequence
)
6883 unsigned char op_code
;
6889 if (op_code
>= info
.li_opcode_base
)
6891 op_code
-= info
.li_opcode_base
;
6892 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6893 state_machine_regs
.address
+= adv
;
6894 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6895 op_code
, adv
, state_machine_regs
.address
);
6896 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6897 state_machine_regs
.line
+= adv
;
6898 printf (_(" and Line by %d to %d\n"),
6899 adv
, state_machine_regs
.line
);
6901 else switch (op_code
)
6903 case DW_LNS_extended_op
:
6904 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6909 printf (_(" Copy\n"));
6912 case DW_LNS_advance_pc
:
6913 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6915 state_machine_regs
.address
+= adv
;
6916 printf (_(" Advance PC by %d to %lx\n"), adv
,
6917 state_machine_regs
.address
);
6920 case DW_LNS_advance_line
:
6921 adv
= read_leb128 (data
, & bytes_read
, 1);
6923 state_machine_regs
.line
+= adv
;
6924 printf (_(" Advance Line by %d to %d\n"), adv
,
6925 state_machine_regs
.line
);
6928 case DW_LNS_set_file
:
6929 adv
= read_leb128 (data
, & bytes_read
, 0);
6931 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6933 state_machine_regs
.file
= adv
;
6936 case DW_LNS_set_column
:
6937 adv
= read_leb128 (data
, & bytes_read
, 0);
6939 printf (_(" Set column to %d\n"), adv
);
6940 state_machine_regs
.column
= adv
;
6943 case DW_LNS_negate_stmt
:
6944 adv
= state_machine_regs
.is_stmt
;
6946 printf (_(" Set is_stmt to %d\n"), adv
);
6947 state_machine_regs
.is_stmt
= adv
;
6950 case DW_LNS_set_basic_block
:
6951 printf (_(" Set basic block\n"));
6952 state_machine_regs
.basic_block
= 1;
6955 case DW_LNS_const_add_pc
:
6956 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6957 * info
.li_min_insn_length
);
6958 state_machine_regs
.address
+= adv
;
6959 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6960 state_machine_regs
.address
);
6963 case DW_LNS_fixed_advance_pc
:
6964 adv
= byte_get (data
, 2);
6966 state_machine_regs
.address
+= adv
;
6967 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6968 adv
, state_machine_regs
.address
);
6971 case DW_LNS_set_prologue_end
:
6972 printf (_(" Set prologue_end to true\n"));
6975 case DW_LNS_set_epilogue_begin
:
6976 printf (_(" Set epilogue_begin to true\n"));
6979 case DW_LNS_set_isa
:
6980 adv
= read_leb128 (data
, & bytes_read
, 0);
6982 printf (_(" Set ISA to %d\n"), adv
);
6986 printf (_(" Unknown opcode %d with operands: "), op_code
);
6989 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6991 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6992 i
== 1 ? "" : ", ");
7007 display_debug_pubnames (Elf_Internal_Shdr
*section
,
7008 unsigned char *start
,
7009 FILE *file ATTRIBUTE_UNUSED
)
7011 DWARF2_Internal_PubNames pubnames
;
7014 end
= start
+ section
->sh_size
;
7016 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7020 unsigned char *data
;
7021 unsigned long offset
;
7022 int offset_size
, initial_length_size
;
7026 pubnames
.pn_length
= byte_get (data
, 4);
7028 if (pubnames
.pn_length
== 0xffffffff)
7030 pubnames
.pn_length
= byte_get (data
, 8);
7033 initial_length_size
= 12;
7038 initial_length_size
= 4;
7041 pubnames
.pn_version
= byte_get (data
, 2);
7043 pubnames
.pn_offset
= byte_get (data
, offset_size
);
7044 data
+= offset_size
;
7045 pubnames
.pn_size
= byte_get (data
, offset_size
);
7046 data
+= offset_size
;
7048 start
+= pubnames
.pn_length
+ initial_length_size
;
7050 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
7052 static int warned
= 0;
7056 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
7063 printf (_(" Length: %ld\n"),
7064 pubnames
.pn_length
);
7065 printf (_(" Version: %d\n"),
7066 pubnames
.pn_version
);
7067 printf (_(" Offset into .debug_info section: %ld\n"),
7068 pubnames
.pn_offset
);
7069 printf (_(" Size of area in .debug_info section: %ld\n"),
7072 printf (_("\n Offset\tName\n"));
7076 offset
= byte_get (data
, offset_size
);
7080 data
+= offset_size
;
7081 printf (" %-6ld\t\t%s\n", offset
, data
);
7082 data
+= strlen ((char *) data
) + 1;
7085 while (offset
!= 0);
7093 get_TAG_name (unsigned long tag
)
7097 case DW_TAG_padding
: return "DW_TAG_padding";
7098 case DW_TAG_array_type
: return "DW_TAG_array_type";
7099 case DW_TAG_class_type
: return "DW_TAG_class_type";
7100 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7101 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7102 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7103 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7104 case DW_TAG_label
: return "DW_TAG_label";
7105 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7106 case DW_TAG_member
: return "DW_TAG_member";
7107 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7108 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7109 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7110 case DW_TAG_string_type
: return "DW_TAG_string_type";
7111 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7112 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7113 case DW_TAG_typedef
: return "DW_TAG_typedef";
7114 case DW_TAG_union_type
: return "DW_TAG_union_type";
7115 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7116 case DW_TAG_variant
: return "DW_TAG_variant";
7117 case DW_TAG_common_block
: return "DW_TAG_common_block";
7118 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7119 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7120 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7121 case DW_TAG_module
: return "DW_TAG_module";
7122 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7123 case DW_TAG_set_type
: return "DW_TAG_set_type";
7124 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7125 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7126 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7127 case DW_TAG_base_type
: return "DW_TAG_base_type";
7128 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7129 case DW_TAG_const_type
: return "DW_TAG_const_type";
7130 case DW_TAG_constant
: return "DW_TAG_constant";
7131 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7132 case DW_TAG_file_type
: return "DW_TAG_file_type";
7133 case DW_TAG_friend
: return "DW_TAG_friend";
7134 case DW_TAG_namelist
: return "DW_TAG_namelist";
7135 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7136 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7137 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7138 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7139 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7140 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7141 case DW_TAG_try_block
: return "DW_TAG_try_block";
7142 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7143 case DW_TAG_variable
: return "DW_TAG_variable";
7144 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7145 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7146 case DW_TAG_format_label
: return "DW_TAG_format_label";
7147 case DW_TAG_function_template
: return "DW_TAG_function_template";
7148 case DW_TAG_class_template
: return "DW_TAG_class_template";
7149 /* DWARF 2.1 values. */
7150 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7151 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7152 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7153 case DW_TAG_namespace
: return "DW_TAG_namespace";
7154 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7155 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7156 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7157 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7159 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7160 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7161 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7164 static char buffer
[100];
7166 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7173 get_AT_name (unsigned long attribute
)
7177 case DW_AT_sibling
: return "DW_AT_sibling";
7178 case DW_AT_location
: return "DW_AT_location";
7179 case DW_AT_name
: return "DW_AT_name";
7180 case DW_AT_ordering
: return "DW_AT_ordering";
7181 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
7182 case DW_AT_byte_size
: return "DW_AT_byte_size";
7183 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
7184 case DW_AT_bit_size
: return "DW_AT_bit_size";
7185 case DW_AT_element_list
: return "DW_AT_element_list";
7186 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
7187 case DW_AT_low_pc
: return "DW_AT_low_pc";
7188 case DW_AT_high_pc
: return "DW_AT_high_pc";
7189 case DW_AT_language
: return "DW_AT_language";
7190 case DW_AT_member
: return "DW_AT_member";
7191 case DW_AT_discr
: return "DW_AT_discr";
7192 case DW_AT_discr_value
: return "DW_AT_discr_value";
7193 case DW_AT_visibility
: return "DW_AT_visibility";
7194 case DW_AT_import
: return "DW_AT_import";
7195 case DW_AT_string_length
: return "DW_AT_string_length";
7196 case DW_AT_common_reference
: return "DW_AT_common_reference";
7197 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
7198 case DW_AT_const_value
: return "DW_AT_const_value";
7199 case DW_AT_containing_type
: return "DW_AT_containing_type";
7200 case DW_AT_default_value
: return "DW_AT_default_value";
7201 case DW_AT_inline
: return "DW_AT_inline";
7202 case DW_AT_is_optional
: return "DW_AT_is_optional";
7203 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
7204 case DW_AT_producer
: return "DW_AT_producer";
7205 case DW_AT_prototyped
: return "DW_AT_prototyped";
7206 case DW_AT_return_addr
: return "DW_AT_return_addr";
7207 case DW_AT_start_scope
: return "DW_AT_start_scope";
7208 case DW_AT_stride_size
: return "DW_AT_stride_size";
7209 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
7210 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
7211 case DW_AT_accessibility
: return "DW_AT_accessibility";
7212 case DW_AT_address_class
: return "DW_AT_address_class";
7213 case DW_AT_artificial
: return "DW_AT_artificial";
7214 case DW_AT_base_types
: return "DW_AT_base_types";
7215 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
7216 case DW_AT_count
: return "DW_AT_count";
7217 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
7218 case DW_AT_decl_column
: return "DW_AT_decl_column";
7219 case DW_AT_decl_file
: return "DW_AT_decl_file";
7220 case DW_AT_decl_line
: return "DW_AT_decl_line";
7221 case DW_AT_declaration
: return "DW_AT_declaration";
7222 case DW_AT_discr_list
: return "DW_AT_discr_list";
7223 case DW_AT_encoding
: return "DW_AT_encoding";
7224 case DW_AT_external
: return "DW_AT_external";
7225 case DW_AT_frame_base
: return "DW_AT_frame_base";
7226 case DW_AT_friend
: return "DW_AT_friend";
7227 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
7228 case DW_AT_macro_info
: return "DW_AT_macro_info";
7229 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
7230 case DW_AT_priority
: return "DW_AT_priority";
7231 case DW_AT_segment
: return "DW_AT_segment";
7232 case DW_AT_specification
: return "DW_AT_specification";
7233 case DW_AT_static_link
: return "DW_AT_static_link";
7234 case DW_AT_type
: return "DW_AT_type";
7235 case DW_AT_use_location
: return "DW_AT_use_location";
7236 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
7237 case DW_AT_virtuality
: return "DW_AT_virtuality";
7238 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
7239 /* DWARF 2.1 values. */
7240 case DW_AT_allocated
: return "DW_AT_allocated";
7241 case DW_AT_associated
: return "DW_AT_associated";
7242 case DW_AT_data_location
: return "DW_AT_data_location";
7243 case DW_AT_stride
: return "DW_AT_stride";
7244 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
7245 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
7246 case DW_AT_extension
: return "DW_AT_extension";
7247 case DW_AT_ranges
: return "DW_AT_ranges";
7248 case DW_AT_trampoline
: return "DW_AT_trampoline";
7249 case DW_AT_call_column
: return "DW_AT_call_column";
7250 case DW_AT_call_file
: return "DW_AT_call_file";
7251 case DW_AT_call_line
: return "DW_AT_call_line";
7252 /* SGI/MIPS extensions. */
7253 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
7254 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
7255 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
7256 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
7257 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
7258 case DW_AT_MIPS_software_pipeline_depth
:
7259 return "DW_AT_MIPS_software_pipeline_depth";
7260 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
7261 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
7262 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
7263 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
7264 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
7265 /* GNU extensions. */
7266 case DW_AT_sf_names
: return "DW_AT_sf_names";
7267 case DW_AT_src_info
: return "DW_AT_src_info";
7268 case DW_AT_mac_info
: return "DW_AT_mac_info";
7269 case DW_AT_src_coords
: return "DW_AT_src_coords";
7270 case DW_AT_body_begin
: return "DW_AT_body_begin";
7271 case DW_AT_body_end
: return "DW_AT_body_end";
7272 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
7273 /* UPC extension. */
7274 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
7277 static char buffer
[100];
7279 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
7286 get_FORM_name (unsigned long form
)
7290 case DW_FORM_addr
: return "DW_FORM_addr";
7291 case DW_FORM_block2
: return "DW_FORM_block2";
7292 case DW_FORM_block4
: return "DW_FORM_block4";
7293 case DW_FORM_data2
: return "DW_FORM_data2";
7294 case DW_FORM_data4
: return "DW_FORM_data4";
7295 case DW_FORM_data8
: return "DW_FORM_data8";
7296 case DW_FORM_string
: return "DW_FORM_string";
7297 case DW_FORM_block
: return "DW_FORM_block";
7298 case DW_FORM_block1
: return "DW_FORM_block1";
7299 case DW_FORM_data1
: return "DW_FORM_data1";
7300 case DW_FORM_flag
: return "DW_FORM_flag";
7301 case DW_FORM_sdata
: return "DW_FORM_sdata";
7302 case DW_FORM_strp
: return "DW_FORM_strp";
7303 case DW_FORM_udata
: return "DW_FORM_udata";
7304 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7305 case DW_FORM_ref1
: return "DW_FORM_ref1";
7306 case DW_FORM_ref2
: return "DW_FORM_ref2";
7307 case DW_FORM_ref4
: return "DW_FORM_ref4";
7308 case DW_FORM_ref8
: return "DW_FORM_ref8";
7309 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7310 case DW_FORM_indirect
: return "DW_FORM_indirect";
7313 static char buffer
[100];
7315 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7321 /* FIXME: There are better and more efficient ways to handle
7322 these structures. For now though, I just want something that
7323 is simple to implement. */
7324 typedef struct abbrev_attr
7326 unsigned long attribute
;
7328 struct abbrev_attr
*next
;
7332 typedef struct abbrev_entry
7334 unsigned long entry
;
7337 struct abbrev_attr
*first_attr
;
7338 struct abbrev_attr
*last_attr
;
7339 struct abbrev_entry
*next
;
7343 static abbrev_entry
*first_abbrev
= NULL
;
7344 static abbrev_entry
*last_abbrev
= NULL
;
7349 abbrev_entry
*abbrev
;
7351 for (abbrev
= first_abbrev
; abbrev
;)
7353 abbrev_entry
*next
= abbrev
->next
;
7356 for (attr
= abbrev
->first_attr
; attr
;)
7358 abbrev_attr
*next
= attr
->next
;
7368 last_abbrev
= first_abbrev
= NULL
;
7372 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7374 abbrev_entry
*entry
;
7376 entry
= malloc (sizeof (*entry
));
7382 entry
->entry
= number
;
7384 entry
->children
= children
;
7385 entry
->first_attr
= NULL
;
7386 entry
->last_attr
= NULL
;
7389 if (first_abbrev
== NULL
)
7390 first_abbrev
= entry
;
7392 last_abbrev
->next
= entry
;
7394 last_abbrev
= entry
;
7398 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7402 attr
= malloc (sizeof (*attr
));
7408 attr
->attribute
= attribute
;
7412 if (last_abbrev
->first_attr
== NULL
)
7413 last_abbrev
->first_attr
= attr
;
7415 last_abbrev
->last_attr
->next
= attr
;
7417 last_abbrev
->last_attr
= attr
;
7420 /* Processes the (partial) contents of a .debug_abbrev section.
7421 Returns NULL if the end of the section was encountered.
7422 Returns the address after the last byte read if the end of
7423 an abbreviation set was found. */
7425 static unsigned char *
7426 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7428 if (first_abbrev
!= NULL
)
7434 unsigned long entry
;
7436 unsigned long attribute
;
7439 entry
= read_leb128 (start
, & bytes_read
, 0);
7440 start
+= bytes_read
;
7442 /* A single zero is supposed to end the section according
7443 to the standard. If there's more, then signal that to
7446 return start
== end
? NULL
: start
;
7448 tag
= read_leb128 (start
, & bytes_read
, 0);
7449 start
+= bytes_read
;
7451 children
= *start
++;
7453 add_abbrev (entry
, tag
, children
);
7459 attribute
= read_leb128 (start
, & bytes_read
, 0);
7460 start
+= bytes_read
;
7462 form
= read_leb128 (start
, & bytes_read
, 0);
7463 start
+= bytes_read
;
7466 add_abbrev_attr (attribute
, form
);
7468 while (attribute
!= 0);
7476 display_debug_macinfo (Elf_Internal_Shdr
*section
,
7477 unsigned char *start
,
7478 FILE *file ATTRIBUTE_UNUSED
)
7480 unsigned char *end
= start
+ section
->sh_size
;
7481 unsigned char *curr
= start
;
7482 unsigned int bytes_read
;
7483 enum dwarf_macinfo_record_type op
;
7485 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7489 unsigned int lineno
;
7497 case DW_MACINFO_start_file
:
7499 unsigned int filenum
;
7501 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7503 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7506 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7510 case DW_MACINFO_end_file
:
7511 printf (_(" DW_MACINFO_end_file\n"));
7514 case DW_MACINFO_define
:
7515 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7518 curr
+= strlen (string
) + 1;
7519 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7522 case DW_MACINFO_undef
:
7523 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7526 curr
+= strlen (string
) + 1;
7527 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7530 case DW_MACINFO_vendor_ext
:
7532 unsigned int constant
;
7534 constant
= read_leb128 (curr
, & bytes_read
, 0);
7537 curr
+= strlen (string
) + 1;
7538 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7549 display_debug_abbrev (Elf_Internal_Shdr
*section
,
7550 unsigned char *start
,
7551 FILE *file ATTRIBUTE_UNUSED
)
7553 abbrev_entry
*entry
;
7554 unsigned char *end
= start
+ section
->sh_size
;
7556 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7560 start
= process_abbrev_section (start
, end
);
7562 if (first_abbrev
== NULL
)
7565 printf (_(" Number TAG\n"));
7567 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7571 printf (_(" %ld %s [%s]\n"),
7573 get_TAG_name (entry
->tag
),
7574 entry
->children
? _("has children") : _("no children"));
7576 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7578 printf (_(" %-18s %s\n"),
7579 get_AT_name (attr
->attribute
),
7580 get_FORM_name (attr
->form
));
7594 static unsigned char *
7595 display_block (unsigned char *data
, unsigned long length
)
7597 printf (_(" %lu byte block: "), length
);
7600 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7606 decode_location_expression (unsigned char * data
,
7607 unsigned int pointer_size
,
7608 unsigned long length
)
7612 unsigned long uvalue
;
7613 unsigned char *end
= data
+ length
;
7622 printf ("DW_OP_addr: %lx",
7623 (unsigned long) byte_get (data
, pointer_size
));
7624 data
+= pointer_size
;
7627 printf ("DW_OP_deref");
7630 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7633 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7636 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7640 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7644 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7648 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7652 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7653 (unsigned long) byte_get (data
+ 4, 4));
7657 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7658 (long) byte_get (data
+ 4, 4));
7662 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7666 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7670 printf ("DW_OP_dup");
7673 printf ("DW_OP_drop");
7676 printf ("DW_OP_over");
7679 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7682 printf ("DW_OP_swap");
7685 printf ("DW_OP_rot");
7688 printf ("DW_OP_xderef");
7691 printf ("DW_OP_abs");
7694 printf ("DW_OP_and");
7697 printf ("DW_OP_div");
7700 printf ("DW_OP_minus");
7703 printf ("DW_OP_mod");
7706 printf ("DW_OP_mul");
7709 printf ("DW_OP_neg");
7712 printf ("DW_OP_not");
7715 printf ("DW_OP_or");
7718 printf ("DW_OP_plus");
7720 case DW_OP_plus_uconst
:
7721 printf ("DW_OP_plus_uconst: %lu",
7722 read_leb128 (data
, &bytes_read
, 0));
7726 printf ("DW_OP_shl");
7729 printf ("DW_OP_shr");
7732 printf ("DW_OP_shra");
7735 printf ("DW_OP_xor");
7738 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7742 printf ("DW_OP_eq");
7745 printf ("DW_OP_ge");
7748 printf ("DW_OP_gt");
7751 printf ("DW_OP_le");
7754 printf ("DW_OP_lt");
7757 printf ("DW_OP_ne");
7760 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7796 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7831 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7866 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7867 read_leb128 (data
, &bytes_read
, 1));
7872 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7876 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7880 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7882 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7883 read_leb128 (data
, &bytes_read
, 1));
7887 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7890 case DW_OP_deref_size
:
7891 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7893 case DW_OP_xderef_size
:
7894 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7897 printf ("DW_OP_nop");
7900 /* DWARF 3 extensions. */
7901 case DW_OP_push_object_address
:
7902 printf ("DW_OP_push_object_address");
7905 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7909 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7912 case DW_OP_call_ref
:
7913 printf ("DW_OP_call_ref");
7916 /* GNU extensions. */
7917 case DW_OP_GNU_push_tls_address
:
7918 printf ("DW_OP_GNU_push_tls_address");
7922 if (op
>= DW_OP_lo_user
7923 && op
<= DW_OP_hi_user
)
7924 printf (_("(User defined location op)"));
7926 printf (_("(Unknown location op)"));
7927 /* No way to tell where the next op is, so just bail. */
7931 /* Separate the ops. */
7937 static const char *debug_loc_contents
;
7938 static bfd_vma debug_loc_size
;
7941 load_debug_loc (FILE *file
)
7943 Elf_Internal_Shdr
*sec
;
7945 /* If it is already loaded, do nothing. */
7946 if (debug_loc_contents
!= NULL
)
7949 /* Locate the .debug_loc section. */
7950 sec
= find_section (".debug_loc");
7954 debug_loc_size
= sec
->sh_size
;
7956 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7957 _("debug_loc section data"));
7961 free_debug_loc (void)
7963 if (debug_loc_contents
== NULL
)
7966 free ((char *) debug_loc_contents
);
7967 debug_loc_contents
= NULL
;
7973 display_debug_loc (Elf_Internal_Shdr
*section
,
7974 unsigned char *start
, FILE *file
)
7976 unsigned char *section_end
;
7977 unsigned long bytes
;
7978 unsigned char *section_begin
= start
;
7980 unsigned int comp_unit
= 0;
7982 addr
= section
->sh_addr
;
7983 bytes
= section
->sh_size
;
7984 section_end
= start
+ bytes
;
7988 printf (_("\nThe .debug_loc section is empty.\n"));
7992 if (num_debug_line_pointer_sizes
== 0)
7993 get_debug_line_pointer_sizes (file
);
7995 printf (_("Contents of the .debug_loc section:\n\n"));
7996 printf (_("\n Offset Begin End Expression\n"));
7998 while (start
< section_end
)
8000 unsigned long begin
;
8002 unsigned short length
;
8003 unsigned long offset
;
8004 unsigned int pointer_size
;
8006 offset
= start
- section_begin
;
8008 /* Get the pointer size from the comp unit associated
8009 with this block of location information. */
8010 if (comp_unit
>= num_debug_line_pointer_sizes
)
8012 error (_("Not enough comp units for .debug_loc section\n"));
8017 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
8023 begin
= byte_get (start
, pointer_size
);
8024 start
+= pointer_size
;
8025 end
= byte_get (start
, pointer_size
);
8026 start
+= pointer_size
;
8028 if (begin
== 0 && end
== 0)
8031 /* For now, skip any base address specifiers. */
8032 if (begin
== 0xffffffff)
8038 length
= byte_get (start
, 2);
8041 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
8042 decode_location_expression (start
, pointer_size
, length
);
8052 static const char *debug_str_contents
;
8053 static bfd_vma debug_str_size
;
8056 load_debug_str (FILE *file
)
8058 Elf_Internal_Shdr
*sec
;
8060 /* If it is already loaded, do nothing. */
8061 if (debug_str_contents
!= NULL
)
8064 /* Locate the .debug_str section. */
8065 sec
= find_section (".debug_str");
8069 debug_str_size
= sec
->sh_size
;
8071 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8072 _("debug_str section data"));
8076 free_debug_str (void)
8078 if (debug_str_contents
== NULL
)
8081 free ((char *) debug_str_contents
);
8082 debug_str_contents
= NULL
;
8087 fetch_indirect_string (unsigned long offset
)
8089 if (debug_str_contents
== NULL
)
8090 return _("<no .debug_str section>");
8092 if (offset
> debug_str_size
)
8093 return _("<offset is too big>");
8095 return debug_str_contents
+ offset
;
8099 display_debug_str (Elf_Internal_Shdr
*section
,
8100 unsigned char *start
,
8101 FILE *file ATTRIBUTE_UNUSED
)
8103 unsigned long bytes
;
8106 addr
= section
->sh_addr
;
8107 bytes
= section
->sh_size
;
8111 printf (_("\nThe .debug_str section is empty.\n"));
8115 printf (_("Contents of the .debug_str section:\n\n"));
8123 lbytes
= (bytes
> 16 ? 16 : bytes
);
8125 printf (" 0x%8.8lx ", (unsigned long) addr
);
8127 for (j
= 0; j
< 16; j
++)
8130 printf ("%2.2x", start
[j
]);
8138 for (j
= 0; j
< lbytes
; j
++)
8141 if (k
>= ' ' && k
< 0x80)
8157 static unsigned char *
8158 read_and_display_attr_value (unsigned long attribute
,
8160 unsigned char *data
,
8161 unsigned long cu_offset
,
8162 unsigned long pointer_size
,
8163 unsigned long offset_size
,
8166 unsigned long uvalue
= 0;
8167 unsigned char *block_start
= NULL
;
8175 case DW_FORM_ref_addr
:
8176 if (dwarf_version
== 2)
8178 uvalue
= byte_get (data
, pointer_size
);
8179 data
+= pointer_size
;
8181 else if (dwarf_version
== 3)
8183 uvalue
= byte_get (data
, offset_size
);
8184 data
+= offset_size
;
8188 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8193 uvalue
= byte_get (data
, pointer_size
);
8194 data
+= pointer_size
;
8198 uvalue
= byte_get (data
, offset_size
);
8199 data
+= offset_size
;
8205 uvalue
= byte_get (data
++, 1);
8210 uvalue
= byte_get (data
, 2);
8216 uvalue
= byte_get (data
, 4);
8221 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8225 case DW_FORM_ref_udata
:
8227 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8231 case DW_FORM_indirect
:
8232 form
= read_leb128 (data
, & bytes_read
, 0);
8234 printf (" %s", get_FORM_name (form
));
8235 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8236 pointer_size
, offset_size
,
8242 case DW_FORM_ref_addr
:
8243 printf (" <#%lx>", uvalue
);
8249 case DW_FORM_ref_udata
:
8250 printf (" <%lx>", uvalue
+ cu_offset
);
8254 printf (" %#lx", uvalue
);
8263 printf (" %ld", uvalue
);
8268 uvalue
= byte_get (data
, 4);
8269 printf (" %lx", uvalue
);
8270 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8274 case DW_FORM_string
:
8275 printf (" %s", data
);
8276 data
+= strlen ((char *) data
) + 1;
8280 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8281 block_start
= data
+ bytes_read
;
8282 data
= display_block (block_start
, uvalue
);
8285 case DW_FORM_block1
:
8286 uvalue
= byte_get (data
, 1);
8287 block_start
= data
+ 1;
8288 data
= display_block (block_start
, uvalue
);
8291 case DW_FORM_block2
:
8292 uvalue
= byte_get (data
, 2);
8293 block_start
= data
+ 2;
8294 data
= display_block (block_start
, uvalue
);
8297 case DW_FORM_block4
:
8298 uvalue
= byte_get (data
, 4);
8299 block_start
= data
+ 4;
8300 data
= display_block (block_start
, uvalue
);
8304 printf (_(" (indirect string, offset: 0x%lx): %s"),
8305 uvalue
, fetch_indirect_string (uvalue
));
8308 case DW_FORM_indirect
:
8309 /* Handled above. */
8313 warn (_("Unrecognized form: %d\n"), form
);
8317 /* For some attributes we can display further information. */
8326 case DW_INL_not_inlined
:
8327 printf (_("(not inlined)"));
8329 case DW_INL_inlined
:
8330 printf (_("(inlined)"));
8332 case DW_INL_declared_not_inlined
:
8333 printf (_("(declared as inline but ignored)"));
8335 case DW_INL_declared_inlined
:
8336 printf (_("(declared as inline and inlined)"));
8339 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8344 case DW_AT_language
:
8347 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8348 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8349 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8350 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8351 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8352 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8353 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8354 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8355 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8356 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8357 /* DWARF 2.1 values. */
8358 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8359 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8360 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8361 /* MIPS extension. */
8362 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8363 /* UPC extension. */
8364 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8366 printf ("(Unknown: %lx)", uvalue
);
8371 case DW_AT_encoding
:
8374 case DW_ATE_void
: printf ("(void)"); break;
8375 case DW_ATE_address
: printf ("(machine address)"); break;
8376 case DW_ATE_boolean
: printf ("(boolean)"); break;
8377 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8378 case DW_ATE_float
: printf ("(float)"); break;
8379 case DW_ATE_signed
: printf ("(signed)"); break;
8380 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8381 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8382 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8383 /* DWARF 2.1 value. */
8384 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8386 if (uvalue
>= DW_ATE_lo_user
8387 && uvalue
<= DW_ATE_hi_user
)
8388 printf ("(user defined type)");
8390 printf ("(unknown type)");
8395 case DW_AT_accessibility
:
8398 case DW_ACCESS_public
: printf ("(public)"); break;
8399 case DW_ACCESS_protected
: printf ("(protected)"); break;
8400 case DW_ACCESS_private
: printf ("(private)"); break;
8402 printf ("(unknown accessibility)");
8407 case DW_AT_visibility
:
8410 case DW_VIS_local
: printf ("(local)"); break;
8411 case DW_VIS_exported
: printf ("(exported)"); break;
8412 case DW_VIS_qualified
: printf ("(qualified)"); break;
8413 default: printf ("(unknown visibility)"); break;
8417 case DW_AT_virtuality
:
8420 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8421 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8422 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8423 default: printf ("(unknown virtuality)"); break;
8427 case DW_AT_identifier_case
:
8430 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8431 case DW_ID_up_case
: printf ("(up_case)"); break;
8432 case DW_ID_down_case
: printf ("(down_case)"); break;
8433 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8434 default: printf ("(unknown case)"); break;
8438 case DW_AT_calling_convention
:
8441 case DW_CC_normal
: printf ("(normal)"); break;
8442 case DW_CC_program
: printf ("(program)"); break;
8443 case DW_CC_nocall
: printf ("(nocall)"); break;
8445 if (uvalue
>= DW_CC_lo_user
8446 && uvalue
<= DW_CC_hi_user
)
8447 printf ("(user defined)");
8449 printf ("(unknown convention)");
8453 case DW_AT_ordering
:
8456 case -1: printf ("(undefined)"); break;
8457 case 0: printf ("(row major)"); break;
8458 case 1: printf ("(column major)"); break;
8462 case DW_AT_frame_base
:
8463 case DW_AT_location
:
8464 case DW_AT_data_member_location
:
8465 case DW_AT_vtable_elem_location
:
8466 case DW_AT_allocated
:
8467 case DW_AT_associated
:
8468 case DW_AT_data_location
:
8470 case DW_AT_upper_bound
:
8471 case DW_AT_lower_bound
:
8475 decode_location_expression (block_start
, pointer_size
, uvalue
);
8478 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8481 printf ("location list");
8493 static unsigned char *
8494 read_and_display_attr (unsigned long attribute
,
8496 unsigned char *data
,
8497 unsigned long cu_offset
,
8498 unsigned long pointer_size
,
8499 unsigned long offset_size
,
8502 printf (" %-18s:", get_AT_name (attribute
));
8503 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8504 pointer_size
, offset_size
, dwarf_version
);
8510 display_debug_info (Elf_Internal_Shdr
*section
,
8511 unsigned char *start
,
8514 unsigned char *end
= start
+ section
->sh_size
;
8515 unsigned char *section_begin
= start
;
8517 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8519 load_debug_str (file
);
8520 load_debug_loc (file
);
8524 DWARF2_Internal_CompUnit compunit
;
8525 Elf_Internal_Shdr
*relsec
;
8526 unsigned char *hdrptr
;
8527 unsigned char *cu_abbrev_offset_ptr
;
8528 unsigned char *tags
;
8530 unsigned long cu_offset
;
8532 int initial_length_size
;
8536 compunit
.cu_length
= byte_get (hdrptr
, 4);
8539 if (compunit
.cu_length
== 0xffffffff)
8541 compunit
.cu_length
= byte_get (hdrptr
, 8);
8544 initial_length_size
= 12;
8549 initial_length_size
= 4;
8552 compunit
.cu_version
= byte_get (hdrptr
, 2);
8555 /* Apply addends of RELA relocations. */
8556 for (relsec
= section_headers
;
8557 relsec
< section_headers
+ elf_header
.e_shnum
;
8560 unsigned long nrelas
;
8561 Elf_Internal_Rela
*rela
, *rp
;
8562 Elf_Internal_Shdr
*symsec
;
8563 Elf_Internal_Sym
*symtab
;
8564 Elf_Internal_Sym
*sym
;
8566 if (relsec
->sh_type
!= SHT_RELA
8567 || SECTION_HEADER (relsec
->sh_info
) != section
8568 || relsec
->sh_size
== 0)
8571 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8575 symsec
= SECTION_HEADER (relsec
->sh_link
);
8576 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8578 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8582 if (rp
->r_offset
>= (bfd_vma
) (hdrptr
- section_begin
)
8583 && section
->sh_size
> (bfd_vma
) offset_size
8584 && rp
->r_offset
<= section
->sh_size
- offset_size
)
8585 loc
= section_begin
+ rp
->r_offset
;
8591 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8593 if (ELF32_R_SYM (rp
->r_info
) != 0
8594 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8596 warn (_("Skipping unexpected symbol type %u\n"),
8597 ELF32_ST_TYPE (sym
->st_info
));
8603 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8605 if (ELF64_R_SYM (rp
->r_info
) != 0
8606 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8608 warn (_("Skipping unexpected symbol type %u\n"),
8609 ELF64_ST_TYPE (sym
->st_info
));
8614 byte_put (loc
, rp
->r_addend
, offset_size
);
8621 cu_abbrev_offset_ptr
= hdrptr
;
8622 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8623 hdrptr
+= offset_size
;
8625 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8629 cu_offset
= start
- section_begin
;
8630 start
+= compunit
.cu_length
+ initial_length_size
;
8632 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8633 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8634 printf (_(" Version: %d\n"), compunit
.cu_version
);
8635 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8636 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8638 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8640 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8646 /* Read in the abbrevs used by this compilation unit. */
8648 Elf_Internal_Shdr
*sec
;
8649 unsigned char *begin
;
8651 /* Locate the .debug_abbrev section and process it. */
8652 sec
= find_section (".debug_abbrev");
8655 warn (_("Unable to locate .debug_abbrev section!\n"));
8659 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8660 _("debug_abbrev section data"));
8664 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8665 begin
+ sec
->sh_size
);
8671 while (tags
< start
)
8674 unsigned long abbrev_number
;
8675 abbrev_entry
*entry
;
8678 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8681 /* A null DIE marks the end of a list of children. */
8682 if (abbrev_number
== 0)
8688 /* Scan through the abbreviation list until we reach the
8690 for (entry
= first_abbrev
;
8691 entry
&& entry
->entry
!= abbrev_number
;
8692 entry
= entry
->next
)
8697 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8702 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8704 (unsigned long) (tags
- section_begin
- bytes_read
),
8706 get_TAG_name (entry
->tag
));
8708 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8709 tags
= read_and_display_attr (attr
->attribute
,
8712 compunit
.cu_pointer_size
,
8714 compunit
.cu_version
);
8716 if (entry
->children
)
8730 display_debug_aranges (Elf_Internal_Shdr
*section
,
8731 unsigned char *start
,
8732 FILE *file ATTRIBUTE_UNUSED
)
8734 unsigned char *end
= start
+ section
->sh_size
;
8736 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8740 unsigned char *hdrptr
;
8741 DWARF2_Internal_ARange arange
;
8742 unsigned char *ranges
;
8743 unsigned long length
;
8744 unsigned long address
;
8747 int initial_length_size
;
8751 arange
.ar_length
= byte_get (hdrptr
, 4);
8754 if (arange
.ar_length
== 0xffffffff)
8756 arange
.ar_length
= byte_get (hdrptr
, 8);
8759 initial_length_size
= 12;
8764 initial_length_size
= 4;
8767 arange
.ar_version
= byte_get (hdrptr
, 2);
8770 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
8771 hdrptr
+= offset_size
;
8773 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
8776 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
8779 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
8781 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8785 printf (_(" Length: %ld\n"), arange
.ar_length
);
8786 printf (_(" Version: %d\n"), arange
.ar_version
);
8787 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8788 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8789 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8791 printf (_("\n Address Length\n"));
8795 /* Must pad to an alignment boundary that is twice the pointer size. */
8796 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
8798 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8802 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8804 ranges
+= arange
.ar_pointer_size
;
8806 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8808 ranges
+= arange
.ar_pointer_size
;
8810 /* A pair of zeros marks the end of the list. */
8811 if (address
== 0 && length
== 0)
8814 printf (" %8.8lx %lu\n", address
, length
);
8817 start
+= arange
.ar_length
+ initial_length_size
;
8825 typedef struct Frame_Chunk
8827 struct Frame_Chunk
*next
;
8828 unsigned char *chunk_start
;
8830 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8831 short int *col_type
;
8834 unsigned int code_factor
;
8836 unsigned long pc_begin
;
8837 unsigned long pc_range
;
8841 unsigned char fde_encoding
;
8842 unsigned char cfa_exp
;
8846 /* A marker for a col_type that means this column was never referenced
8847 in the frame info. */
8848 #define DW_CFA_unreferenced (-1)
8851 frame_need_space (Frame_Chunk
*fc
, int reg
)
8853 int prev
= fc
->ncols
;
8855 if (reg
< fc
->ncols
)
8858 fc
->ncols
= reg
+ 1;
8859 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
8860 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
8862 while (prev
< fc
->ncols
)
8864 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8865 fc
->col_offset
[prev
] = 0;
8871 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
8876 if (*max_regs
< fc
->ncols
)
8877 *max_regs
= fc
->ncols
;
8879 if (*need_col_headers
)
8881 *need_col_headers
= 0;
8883 printf (" LOC CFA ");
8885 for (r
= 0; r
< *max_regs
; r
++)
8886 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8891 printf ("r%-4d", r
);
8897 printf ("%08lx ", fc
->pc_begin
);
8899 strcpy (tmp
, "exp");
8901 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8902 printf ("%-8s ", tmp
);
8904 for (r
= 0; r
< fc
->ncols
; r
++)
8906 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8908 switch (fc
->col_type
[r
])
8910 case DW_CFA_undefined
:
8913 case DW_CFA_same_value
:
8917 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8919 case DW_CFA_register
:
8920 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8922 case DW_CFA_expression
:
8923 strcpy (tmp
, "exp");
8926 strcpy (tmp
, "n/a");
8929 printf ("%-5s", tmp
);
8936 size_of_encoded_value (int encoding
)
8938 switch (encoding
& 0x7)
8941 case 0: return is_32bit_elf
? 4 : 8;
8949 get_encoded_value (unsigned char *data
, int encoding
)
8951 int size
= size_of_encoded_value (encoding
);
8952 if (encoding
& DW_EH_PE_signed
)
8953 return byte_get_signed (data
, size
);
8955 return byte_get (data
, size
);
8958 #define GET(N) byte_get (start, N); start += N
8959 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8960 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8963 display_debug_frames (Elf_Internal_Shdr
*section
,
8964 unsigned char *start
,
8965 FILE *file ATTRIBUTE_UNUSED
)
8967 unsigned char *end
= start
+ section
->sh_size
;
8968 unsigned char *section_start
= start
;
8969 Frame_Chunk
*chunks
= 0;
8970 Frame_Chunk
*remembered_state
= 0;
8972 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8975 int addr_size
= is_32bit_elf
? 4 : 8;
8977 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8981 unsigned char *saved_start
;
8982 unsigned char *block_end
;
8983 unsigned long length
;
8984 unsigned long cie_id
;
8987 int need_col_headers
= 1;
8988 unsigned char *augmentation_data
= NULL
;
8989 unsigned long augmentation_data_len
= 0;
8990 int encoded_ptr_size
= addr_size
;
8992 int initial_length_size
;
8994 saved_start
= start
;
8995 length
= byte_get (start
, 4); start
+= 4;
8999 printf ("\n%08lx ZERO terminator\n\n",
9000 (unsigned long)(saved_start
- section_start
));
9004 if (length
== 0xffffffff)
9006 length
= byte_get (start
, 8);
9009 initial_length_size
= 12;
9014 initial_length_size
= 4;
9017 block_end
= saved_start
+ length
+ initial_length_size
;
9018 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
9020 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
9024 fc
= xmalloc (sizeof (Frame_Chunk
));
9025 memset (fc
, 0, sizeof (Frame_Chunk
));
9029 fc
->chunk_start
= saved_start
;
9031 fc
->col_type
= xmalloc (sizeof (short int));
9032 fc
->col_offset
= xmalloc (sizeof (int));
9033 frame_need_space (fc
, max_regs
-1);
9037 fc
->augmentation
= start
;
9038 start
= strchr (start
, '\0') + 1;
9040 if (fc
->augmentation
[0] == 'z')
9042 fc
->code_factor
= LEB ();
9043 fc
->data_factor
= SLEB ();
9052 augmentation_data_len
= LEB ();
9053 augmentation_data
= start
;
9054 start
+= augmentation_data_len
;
9056 else if (strcmp (fc
->augmentation
, "eh") == 0)
9059 fc
->code_factor
= LEB ();
9060 fc
->data_factor
= SLEB ();
9072 fc
->code_factor
= LEB ();
9073 fc
->data_factor
= SLEB ();
9085 if (do_debug_frames_interp
)
9086 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
9087 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9088 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
9092 printf ("\n%08lx %08lx %08lx CIE\n",
9093 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
9094 printf (" Version: %d\n", version
);
9095 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9096 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9097 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9098 printf (" Return address column: %d\n", fc
->ra
);
9100 if (augmentation_data_len
)
9103 printf (" Augmentation data: ");
9104 for (i
= 0; i
< augmentation_data_len
; ++i
)
9105 printf (" %02x", augmentation_data
[i
]);
9111 if (augmentation_data_len
)
9113 unsigned char *p
, *q
;
9114 p
= fc
->augmentation
+ 1;
9115 q
= augmentation_data
;
9122 q
+= 1 + size_of_encoded_value (*q
);
9124 fc
->fde_encoding
= *q
++;
9130 if (fc
->fde_encoding
)
9131 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9134 frame_need_space (fc
, fc
->ra
);
9138 unsigned char *look_for
;
9139 static Frame_Chunk fde_fc
;
9142 memset (fc
, 0, sizeof (Frame_Chunk
));
9144 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
9146 for (cie
= chunks
; cie
; cie
= cie
->next
)
9147 if (cie
->chunk_start
== look_for
)
9152 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9153 cie_id
, saved_start
);
9156 fc
->col_type
= xmalloc (sizeof (short int));
9157 fc
->col_offset
= xmalloc (sizeof (int));
9158 frame_need_space (fc
, max_regs
- 1);
9160 fc
->augmentation
= "";
9161 fc
->fde_encoding
= 0;
9165 fc
->ncols
= cie
->ncols
;
9166 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
9167 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
9168 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9169 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9170 fc
->augmentation
= cie
->augmentation
;
9171 fc
->code_factor
= cie
->code_factor
;
9172 fc
->data_factor
= cie
->data_factor
;
9173 fc
->cfa_reg
= cie
->cfa_reg
;
9174 fc
->cfa_offset
= cie
->cfa_offset
;
9176 frame_need_space (fc
, max_regs
-1);
9177 fc
->fde_encoding
= cie
->fde_encoding
;
9180 if (fc
->fde_encoding
)
9181 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9183 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
9184 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
9185 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
9186 start
+= encoded_ptr_size
;
9187 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
9188 start
+= encoded_ptr_size
;
9190 if (cie
->augmentation
[0] == 'z')
9192 augmentation_data_len
= LEB ();
9193 augmentation_data
= start
;
9194 start
+= augmentation_data_len
;
9197 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9198 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9199 (unsigned long)(cie
->chunk_start
- section_start
),
9200 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
9201 if (! do_debug_frames_interp
&& augmentation_data_len
)
9204 printf (" Augmentation data: ");
9205 for (i
= 0; i
< augmentation_data_len
; ++i
)
9206 printf (" %02x", augmentation_data
[i
]);
9212 /* At this point, fc is the current chunk, cie (if any) is set, and we're
9213 about to interpret instructions for the chunk. */
9214 /* ??? At present we need to do this always, since this sizes the
9215 fc->col_type and fc->col_offset arrays, which we write into always.
9216 We should probably split the interpreted and non-interpreted bits
9217 into two different routines, since there's so much that doesn't
9218 really overlap between them. */
9219 if (1 || do_debug_frames_interp
)
9221 /* Start by making a pass over the chunk, allocating storage
9222 and taking note of what registers are used. */
9223 unsigned char *tmp
= start
;
9225 while (start
< block_end
)
9228 unsigned long reg
, tmp
;
9235 /* Warning: if you add any more cases to this switch, be
9236 sure to add them to the corresponding switch below. */
9239 case DW_CFA_advance_loc
:
9243 frame_need_space (fc
, opa
);
9244 fc
->col_type
[opa
] = DW_CFA_undefined
;
9246 case DW_CFA_restore
:
9247 frame_need_space (fc
, opa
);
9248 fc
->col_type
[opa
] = DW_CFA_undefined
;
9250 case DW_CFA_set_loc
:
9251 start
+= encoded_ptr_size
;
9253 case DW_CFA_advance_loc1
:
9256 case DW_CFA_advance_loc2
:
9259 case DW_CFA_advance_loc4
:
9262 case DW_CFA_offset_extended
:
9263 reg
= LEB (); LEB ();
9264 frame_need_space (fc
, reg
);
9265 fc
->col_type
[reg
] = DW_CFA_undefined
;
9267 case DW_CFA_restore_extended
:
9269 frame_need_space (fc
, reg
);
9270 fc
->col_type
[reg
] = DW_CFA_undefined
;
9272 case DW_CFA_undefined
:
9274 frame_need_space (fc
, reg
);
9275 fc
->col_type
[reg
] = DW_CFA_undefined
;
9277 case DW_CFA_same_value
:
9279 frame_need_space (fc
, reg
);
9280 fc
->col_type
[reg
] = DW_CFA_undefined
;
9282 case DW_CFA_register
:
9283 reg
= LEB (); LEB ();
9284 frame_need_space (fc
, reg
);
9285 fc
->col_type
[reg
] = DW_CFA_undefined
;
9287 case DW_CFA_def_cfa
:
9290 case DW_CFA_def_cfa_register
:
9293 case DW_CFA_def_cfa_offset
:
9296 case DW_CFA_def_cfa_expression
:
9300 case DW_CFA_expression
:
9304 frame_need_space (fc
, reg
);
9305 fc
->col_type
[reg
] = DW_CFA_undefined
;
9307 case DW_CFA_offset_extended_sf
:
9308 reg
= LEB (); SLEB ();
9309 frame_need_space (fc
, reg
);
9310 fc
->col_type
[reg
] = DW_CFA_undefined
;
9312 case DW_CFA_def_cfa_sf
:
9315 case DW_CFA_def_cfa_offset_sf
:
9318 case DW_CFA_MIPS_advance_loc8
:
9321 case DW_CFA_GNU_args_size
:
9324 case DW_CFA_GNU_negative_offset_extended
:
9325 reg
= LEB (); LEB ();
9326 frame_need_space (fc
, reg
);
9327 fc
->col_type
[reg
] = DW_CFA_undefined
;
9336 /* Now we know what registers are used, make a second pass over
9337 the chunk, this time actually printing out the info. */
9339 while (start
< block_end
)
9342 unsigned long ul
, reg
, roffs
;
9351 /* Warning: if you add any more cases to this switch, be
9352 sure to add them to the corresponding switch above. */
9355 case DW_CFA_advance_loc
:
9356 if (do_debug_frames_interp
)
9357 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9359 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9360 opa
* fc
->code_factor
,
9361 fc
->pc_begin
+ opa
* fc
->code_factor
);
9362 fc
->pc_begin
+= opa
* fc
->code_factor
;
9367 if (! do_debug_frames_interp
)
9368 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9369 opa
, roffs
* fc
->data_factor
);
9370 fc
->col_type
[opa
] = DW_CFA_offset
;
9371 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9374 case DW_CFA_restore
:
9375 if (! do_debug_frames_interp
)
9376 printf (" DW_CFA_restore: r%d\n", opa
);
9377 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9378 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9381 case DW_CFA_set_loc
:
9382 vma
= get_encoded_value (start
, fc
->fde_encoding
);
9383 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
9384 vma
+= section
->sh_addr
+ (start
- section_start
);
9385 start
+= encoded_ptr_size
;
9386 if (do_debug_frames_interp
)
9387 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9389 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
9393 case DW_CFA_advance_loc1
:
9394 ofs
= byte_get (start
, 1); start
+= 1;
9395 if (do_debug_frames_interp
)
9396 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9398 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9399 ofs
* fc
->code_factor
,
9400 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9401 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9404 case DW_CFA_advance_loc2
:
9405 ofs
= byte_get (start
, 2); start
+= 2;
9406 if (do_debug_frames_interp
)
9407 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9409 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9410 ofs
* fc
->code_factor
,
9411 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9412 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9415 case DW_CFA_advance_loc4
:
9416 ofs
= byte_get (start
, 4); start
+= 4;
9417 if (do_debug_frames_interp
)
9418 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9420 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9421 ofs
* fc
->code_factor
,
9422 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9423 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9426 case DW_CFA_offset_extended
:
9429 if (! do_debug_frames_interp
)
9430 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9431 reg
, roffs
* fc
->data_factor
);
9432 fc
->col_type
[reg
] = DW_CFA_offset
;
9433 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9436 case DW_CFA_restore_extended
:
9438 if (! do_debug_frames_interp
)
9439 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
9440 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9441 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9444 case DW_CFA_undefined
:
9446 if (! do_debug_frames_interp
)
9447 printf (" DW_CFA_undefined: r%ld\n", reg
);
9448 fc
->col_type
[reg
] = DW_CFA_undefined
;
9449 fc
->col_offset
[reg
] = 0;
9452 case DW_CFA_same_value
:
9454 if (! do_debug_frames_interp
)
9455 printf (" DW_CFA_same_value: r%ld\n", reg
);
9456 fc
->col_type
[reg
] = DW_CFA_same_value
;
9457 fc
->col_offset
[reg
] = 0;
9460 case DW_CFA_register
:
9463 if (! do_debug_frames_interp
)
9464 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
9465 fc
->col_type
[reg
] = DW_CFA_register
;
9466 fc
->col_offset
[reg
] = roffs
;
9469 case DW_CFA_remember_state
:
9470 if (! do_debug_frames_interp
)
9471 printf (" DW_CFA_remember_state\n");
9472 rs
= xmalloc (sizeof (Frame_Chunk
));
9473 rs
->ncols
= fc
->ncols
;
9474 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
9475 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
9476 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
9477 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
9478 rs
->next
= remembered_state
;
9479 remembered_state
= rs
;
9482 case DW_CFA_restore_state
:
9483 if (! do_debug_frames_interp
)
9484 printf (" DW_CFA_restore_state\n");
9485 rs
= remembered_state
;
9488 remembered_state
= rs
->next
;
9489 frame_need_space (fc
, rs
->ncols
-1);
9490 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
9491 memcpy (fc
->col_offset
, rs
->col_offset
,
9492 rs
->ncols
* sizeof (int));
9493 free (rs
->col_type
);
9494 free (rs
->col_offset
);
9497 else if (do_debug_frames_interp
)
9498 printf ("Mismatched DW_CFA_restore_state\n");
9501 case DW_CFA_def_cfa
:
9502 fc
->cfa_reg
= LEB ();
9503 fc
->cfa_offset
= LEB ();
9505 if (! do_debug_frames_interp
)
9506 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9507 fc
->cfa_reg
, fc
->cfa_offset
);
9510 case DW_CFA_def_cfa_register
:
9511 fc
->cfa_reg
= LEB ();
9513 if (! do_debug_frames_interp
)
9514 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9517 case DW_CFA_def_cfa_offset
:
9518 fc
->cfa_offset
= LEB ();
9519 if (! do_debug_frames_interp
)
9520 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9524 if (! do_debug_frames_interp
)
9525 printf (" DW_CFA_nop\n");
9528 case DW_CFA_def_cfa_expression
:
9530 if (! do_debug_frames_interp
)
9532 printf (" DW_CFA_def_cfa_expression (");
9533 decode_location_expression (start
, addr_size
, ul
);
9540 case DW_CFA_expression
:
9543 if (! do_debug_frames_interp
)
9545 printf (" DW_CFA_expression: r%ld (", reg
);
9546 decode_location_expression (start
, addr_size
, ul
);
9549 fc
->col_type
[reg
] = DW_CFA_expression
;
9553 case DW_CFA_offset_extended_sf
:
9556 frame_need_space (fc
, reg
);
9557 if (! do_debug_frames_interp
)
9558 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9559 reg
, l
* fc
->data_factor
);
9560 fc
->col_type
[reg
] = DW_CFA_offset
;
9561 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9564 case DW_CFA_def_cfa_sf
:
9565 fc
->cfa_reg
= LEB ();
9566 fc
->cfa_offset
= SLEB ();
9568 if (! do_debug_frames_interp
)
9569 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9570 fc
->cfa_reg
, fc
->cfa_offset
);
9573 case DW_CFA_def_cfa_offset_sf
:
9574 fc
->cfa_offset
= SLEB ();
9575 if (! do_debug_frames_interp
)
9576 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9579 case DW_CFA_MIPS_advance_loc8
:
9580 ofs
= byte_get (start
, 8); start
+= 8;
9581 if (do_debug_frames_interp
)
9582 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9584 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9585 ofs
* fc
->code_factor
,
9586 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9587 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9590 case DW_CFA_GNU_window_save
:
9591 if (! do_debug_frames_interp
)
9592 printf (" DW_CFA_GNU_window_save\n");
9595 case DW_CFA_GNU_args_size
:
9597 if (! do_debug_frames_interp
)
9598 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9601 case DW_CFA_GNU_negative_offset_extended
:
9604 frame_need_space (fc
, reg
);
9605 if (! do_debug_frames_interp
)
9606 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9607 reg
, l
* fc
->data_factor
);
9608 fc
->col_type
[reg
] = DW_CFA_offset
;
9609 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9613 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9618 if (do_debug_frames_interp
)
9619 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9634 display_debug_not_supported (Elf_Internal_Shdr
*section
,
9635 unsigned char *start ATTRIBUTE_UNUSED
,
9636 FILE *file ATTRIBUTE_UNUSED
)
9638 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9639 SECTION_NAME (section
));
9644 /* A structure containing the name of a debug section
9645 and a pointer to a function that can decode it. */
9648 const char *const name
;
9649 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
9653 { ".debug_abbrev", display_debug_abbrev
},
9654 { ".debug_aranges", display_debug_aranges
},
9655 { ".debug_frame", display_debug_frames
},
9656 { ".debug_info", display_debug_info
},
9657 { ".debug_line", display_debug_lines
},
9658 { ".debug_pubnames", display_debug_pubnames
},
9659 { ".eh_frame", display_debug_frames
},
9660 { ".debug_macinfo", display_debug_macinfo
},
9661 { ".debug_str", display_debug_str
},
9662 { ".debug_loc", display_debug_loc
},
9663 { ".debug_pubtypes", display_debug_pubnames
},
9664 { ".debug_ranges", display_debug_not_supported
},
9665 { ".debug_static_func", display_debug_not_supported
},
9666 { ".debug_static_vars", display_debug_not_supported
},
9667 { ".debug_types", display_debug_not_supported
},
9668 { ".debug_weaknames", display_debug_not_supported
}
9672 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
9674 char *name
= SECTION_NAME (section
);
9675 bfd_size_type length
;
9676 unsigned char *start
;
9679 length
= section
->sh_size
;
9682 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9686 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
9687 _("debug section data"));
9691 /* See if we know how to display the contents of this section. */
9692 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9693 name
= ".debug_info";
9695 for (i
= NUM_ELEM (debug_displays
); i
--;)
9696 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9698 debug_displays
[i
].display (section
, start
, file
);
9703 printf (_("Unrecognized debug section: %s\n"), name
);
9707 /* If we loaded in the abbrev section at some point,
9708 we must release it here. */
9715 process_section_contents (FILE *file
)
9717 Elf_Internal_Shdr
*section
;
9723 for (i
= 0, section
= section_headers
;
9724 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9727 #ifdef SUPPORT_DISASSEMBLY
9728 if (dump_sects
[i
] & DISASS_DUMP
)
9729 disassemble_section (section
, file
);
9731 if (dump_sects
[i
] & HEX_DUMP
)
9732 dump_section (section
, file
);
9734 if (dump_sects
[i
] & DEBUG_DUMP
)
9735 display_debug_section (section
, file
);
9738 if (i
< num_dump_sects
)
9739 warn (_("Some sections were not dumped because they do not exist!\n"));
9745 process_mips_fpe_exception (int mask
)
9750 if (mask
& OEX_FPU_INEX
)
9751 fputs ("INEX", stdout
), first
= 0;
9752 if (mask
& OEX_FPU_UFLO
)
9753 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9754 if (mask
& OEX_FPU_OFLO
)
9755 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9756 if (mask
& OEX_FPU_DIV0
)
9757 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9758 if (mask
& OEX_FPU_INVAL
)
9759 printf ("%sINVAL", first
? "" : "|");
9762 fputs ("0", stdout
);
9766 process_mips_specific (FILE *file
)
9768 Elf_Internal_Dyn
*entry
;
9769 size_t liblist_offset
= 0;
9770 size_t liblistno
= 0;
9771 size_t conflictsno
= 0;
9772 size_t options_offset
= 0;
9773 size_t conflicts_offset
= 0;
9775 /* We have a lot of special sections. Thanks SGI! */
9776 if (dynamic_section
== NULL
)
9777 /* No information available. */
9780 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9781 switch (entry
->d_tag
)
9783 case DT_MIPS_LIBLIST
:
9785 = offset_from_vma (file
, entry
->d_un
.d_val
,
9786 liblistno
* sizeof (Elf32_External_Lib
));
9788 case DT_MIPS_LIBLISTNO
:
9789 liblistno
= entry
->d_un
.d_val
;
9791 case DT_MIPS_OPTIONS
:
9792 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9794 case DT_MIPS_CONFLICT
:
9796 = offset_from_vma (file
, entry
->d_un
.d_val
,
9797 conflictsno
* sizeof (Elf32_External_Conflict
));
9799 case DT_MIPS_CONFLICTNO
:
9800 conflictsno
= entry
->d_un
.d_val
;
9806 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9808 Elf32_External_Lib
*elib
;
9811 elib
= get_data (NULL
, file
, liblist_offset
,
9812 liblistno
* sizeof (Elf32_External_Lib
),
9816 printf ("\nSection '.liblist' contains %lu entries:\n",
9817 (unsigned long) liblistno
);
9818 fputs (" Library Time Stamp Checksum Version Flags\n",
9821 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9828 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9829 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9830 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9831 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9832 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9834 tmp
= gmtime (&time
);
9835 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9836 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9837 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9839 printf ("%3lu: ", (unsigned long) cnt
);
9840 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9841 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9844 if (liblist
.l_flags
== 0)
9855 { " EXACT_MATCH", LL_EXACT_MATCH
},
9856 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9857 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9858 { " EXPORTS", LL_EXPORTS
},
9859 { " DELAY_LOAD", LL_DELAY_LOAD
},
9860 { " DELTA", LL_DELTA
}
9862 int flags
= liblist
.l_flags
;
9866 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9868 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9870 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9871 flags
^= l_flags_vals
[fcnt
].bit
;
9874 printf (" %#x", (unsigned int) flags
);
9884 if (options_offset
!= 0)
9886 Elf_External_Options
*eopt
;
9887 Elf_Internal_Shdr
*sect
= section_headers
;
9888 Elf_Internal_Options
*iopt
;
9889 Elf_Internal_Options
*option
;
9893 /* Find the section header so that we get the size. */
9894 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9897 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
9901 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
9904 error (_("Out of memory"));
9911 while (offset
< sect
->sh_size
)
9913 Elf_External_Options
*eoption
;
9915 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9917 option
->kind
= BYTE_GET (eoption
->kind
);
9918 option
->size
= BYTE_GET (eoption
->size
);
9919 option
->section
= BYTE_GET (eoption
->section
);
9920 option
->info
= BYTE_GET (eoption
->info
);
9922 offset
+= option
->size
;
9928 printf (_("\nSection '%s' contains %d entries:\n"),
9929 SECTION_NAME (sect
), cnt
);
9937 switch (option
->kind
)
9940 /* This shouldn't happen. */
9941 printf (" NULL %d %lx", option
->section
, option
->info
);
9944 printf (" REGINFO ");
9945 if (elf_header
.e_machine
== EM_MIPS
)
9948 Elf32_External_RegInfo
*ereg
;
9949 Elf32_RegInfo reginfo
;
9951 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9952 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9953 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9954 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9955 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9956 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9957 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9959 printf ("GPR %08lx GP 0x%lx\n",
9961 (unsigned long) reginfo
.ri_gp_value
);
9962 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9963 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9964 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9969 Elf64_External_RegInfo
*ereg
;
9970 Elf64_Internal_RegInfo reginfo
;
9972 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9973 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9974 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9975 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9976 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9977 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9978 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9980 printf ("GPR %08lx GP 0x",
9981 reginfo
.ri_gprmask
);
9982 printf_vma (reginfo
.ri_gp_value
);
9985 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9986 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9987 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9991 case ODK_EXCEPTIONS
:
9992 fputs (" EXCEPTIONS fpe_min(", stdout
);
9993 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9994 fputs (") fpe_max(", stdout
);
9995 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9996 fputs (")", stdout
);
9998 if (option
->info
& OEX_PAGE0
)
9999 fputs (" PAGE0", stdout
);
10000 if (option
->info
& OEX_SMM
)
10001 fputs (" SMM", stdout
);
10002 if (option
->info
& OEX_FPDBUG
)
10003 fputs (" FPDBUG", stdout
);
10004 if (option
->info
& OEX_DISMISS
)
10005 fputs (" DISMISS", stdout
);
10008 fputs (" PAD ", stdout
);
10009 if (option
->info
& OPAD_PREFIX
)
10010 fputs (" PREFIX", stdout
);
10011 if (option
->info
& OPAD_POSTFIX
)
10012 fputs (" POSTFIX", stdout
);
10013 if (option
->info
& OPAD_SYMBOL
)
10014 fputs (" SYMBOL", stdout
);
10017 fputs (" HWPATCH ", stdout
);
10018 if (option
->info
& OHW_R4KEOP
)
10019 fputs (" R4KEOP", stdout
);
10020 if (option
->info
& OHW_R8KPFETCH
)
10021 fputs (" R8KPFETCH", stdout
);
10022 if (option
->info
& OHW_R5KEOP
)
10023 fputs (" R5KEOP", stdout
);
10024 if (option
->info
& OHW_R5KCVTL
)
10025 fputs (" R5KCVTL", stdout
);
10028 fputs (" FILL ", stdout
);
10029 /* XXX Print content of info word? */
10032 fputs (" TAGS ", stdout
);
10033 /* XXX Print content of info word? */
10036 fputs (" HWAND ", stdout
);
10037 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10038 fputs (" R4KEOP_CHECKED", stdout
);
10039 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10040 fputs (" R4KEOP_CLEAN", stdout
);
10043 fputs (" HWOR ", stdout
);
10044 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10045 fputs (" R4KEOP_CHECKED", stdout
);
10046 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10047 fputs (" R4KEOP_CLEAN", stdout
);
10050 printf (" GP_GROUP %#06lx self-contained %#06lx",
10051 option
->info
& OGP_GROUP
,
10052 (option
->info
& OGP_SELF
) >> 16);
10055 printf (" IDENT %#06lx self-contained %#06lx",
10056 option
->info
& OGP_GROUP
,
10057 (option
->info
& OGP_SELF
) >> 16);
10060 /* This shouldn't happen. */
10061 printf (" %3d ??? %d %lx",
10062 option
->kind
, option
->section
, option
->info
);
10066 len
= sizeof (*eopt
);
10067 while (len
< option
->size
)
10068 if (((char *) option
)[len
] >= ' '
10069 && ((char *) option
)[len
] < 0x7f)
10070 printf ("%c", ((char *) option
)[len
++]);
10072 printf ("\\%03o", ((char *) option
)[len
++]);
10074 fputs ("\n", stdout
);
10082 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10084 Elf32_Conflict
*iconf
;
10087 if (dynamic_symbols
== NULL
)
10089 error (_("conflict list found without a dynamic symbol table"));
10093 iconf
= malloc (conflictsno
* sizeof (*iconf
));
10096 error (_("Out of memory"));
10102 Elf32_External_Conflict
*econf32
;
10104 econf32
= get_data (NULL
, file
, conflicts_offset
,
10105 conflictsno
* sizeof (*econf32
), _("conflict"));
10109 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10110 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10116 Elf64_External_Conflict
*econf64
;
10118 econf64
= get_data (NULL
, file
, conflicts_offset
,
10119 conflictsno
* sizeof (*econf64
), _("conflict"));
10123 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10124 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10129 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10130 (unsigned long) conflictsno
);
10131 puts (_(" Num: Index Value Name"));
10133 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10135 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
10137 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10138 print_vma (psym
->st_value
, FULL_HEX
);
10140 print_symbol (25, dynamic_strings
+ psym
->st_name
);
10151 process_gnu_liblist (FILE *file
)
10153 Elf_Internal_Shdr
*section
, *string_sec
;
10154 Elf32_External_Lib
*elib
;
10162 for (i
= 0, section
= section_headers
;
10163 i
< elf_header
.e_shnum
;
10166 switch (section
->sh_type
)
10168 case SHT_GNU_LIBLIST
:
10169 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
10174 string_sec
= SECTION_HEADER (section
->sh_link
);
10176 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
10177 string_sec
->sh_size
, _("liblist string table"));
10180 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10186 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10187 SECTION_NAME (section
),
10188 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10190 puts (" Library Time Stamp Checksum Version Flags");
10192 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10200 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10201 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10202 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10203 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10204 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10206 tmp
= gmtime (&time
);
10207 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10208 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10209 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10211 printf ("%3lu: ", (unsigned long) cnt
);
10213 printf ("%-20s", strtab
+ liblist
.l_name
);
10215 printf ("%-20.20s", strtab
+ liblist
.l_name
);
10216 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10217 liblist
.l_version
, liblist
.l_flags
);
10227 static const char *
10228 get_note_type (unsigned e_type
)
10230 static char buff
[64];
10234 case NT_AUXV
: return _("NT_AUXV (auxiliary vector)");
10235 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
10236 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
10237 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
10238 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
10239 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
10240 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
10241 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
10242 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
10243 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
10244 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
10245 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10247 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10252 static const char *
10253 get_netbsd_elfcore_note_type (unsigned e_type
)
10255 static char buff
[64];
10257 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10259 /* NetBSD core "procinfo" structure. */
10260 return _("NetBSD procinfo structure");
10263 /* As of Jan 2002 there are no other machine-independent notes
10264 defined for NetBSD core files. If the note type is less
10265 than the start of the machine-dependent note types, we don't
10268 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10270 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10274 switch (elf_header
.e_machine
)
10276 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10277 and PT_GETFPREGS == mach+2. */
10282 case EM_SPARC32PLUS
:
10286 case NT_NETBSDCORE_FIRSTMACH
+0:
10287 return _("PT_GETREGS (reg structure)");
10288 case NT_NETBSDCORE_FIRSTMACH
+2:
10289 return _("PT_GETFPREGS (fpreg structure)");
10295 /* On all other arch's, PT_GETREGS == mach+1 and
10296 PT_GETFPREGS == mach+3. */
10300 case NT_NETBSDCORE_FIRSTMACH
+1:
10301 return _("PT_GETREGS (reg structure)");
10302 case NT_NETBSDCORE_FIRSTMACH
+3:
10303 return _("PT_GETFPREGS (fpreg structure)");
10309 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
10313 /* Note that by the ELF standard, the name field is already null byte
10314 terminated, and namesz includes the terminating null byte.
10315 I.E. the value of namesz for the name "FSF" is 4.
10317 If the value of namesz is zero, there is no name present. */
10319 process_note (Elf_Internal_Note
*pnote
)
10323 if (pnote
->namesz
== 0)
10325 /* If there is no note name, then use the default set of
10326 note type strings. */
10327 nt
= get_note_type (pnote
->type
);
10329 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
10331 /* NetBSD-specific core file notes. */
10332 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10336 /* Don't recognize this note name; just use the default set of
10337 note type strings. */
10338 nt
= get_note_type (pnote
->type
);
10341 printf (" %s\t\t0x%08lx\t%s\n",
10342 pnote
->namesz
? pnote
->namedata
: "(NONE)",
10343 pnote
->descsz
, nt
);
10349 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10351 Elf_External_Note
*pnotes
;
10352 Elf_External_Note
*external
;
10358 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
10364 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10365 (unsigned long) offset
, (unsigned long) length
);
10366 printf (_(" Owner\t\tData size\tDescription\n"));
10368 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10370 Elf_External_Note
*next
;
10371 Elf_Internal_Note inote
;
10374 inote
.type
= BYTE_GET (external
->type
);
10375 inote
.namesz
= BYTE_GET (external
->namesz
);
10376 inote
.namedata
= external
->name
;
10377 inote
.descsz
= BYTE_GET (external
->descsz
);
10378 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10379 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10381 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10383 if (((char *) next
) > (((char *) pnotes
) + length
))
10385 warn (_("corrupt note found at offset %x into core notes\n"),
10386 ((char *) external
) - ((char *) pnotes
));
10387 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10388 inote
.type
, inote
.namesz
, inote
.descsz
);
10394 /* Verify that name is null terminated. It appears that at least
10395 one version of Linux (RedHat 6.0) generates corefiles that don't
10396 comply with the ELF spec by failing to include the null byte in
10398 if (inote
.namedata
[inote
.namesz
] != '\0')
10400 temp
= malloc (inote
.namesz
+ 1);
10404 error (_("Out of memory\n"));
10409 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10410 temp
[inote
.namesz
] = 0;
10412 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10413 inote
.namedata
= temp
;
10416 res
&= process_note (& inote
);
10431 process_corefile_note_segments (FILE *file
)
10433 Elf_Internal_Phdr
*segment
;
10437 if (! get_program_headers (file
))
10440 for (i
= 0, segment
= program_headers
;
10441 i
< elf_header
.e_phnum
;
10444 if (segment
->p_type
== PT_NOTE
)
10445 res
&= process_corefile_note_segment (file
,
10446 (bfd_vma
) segment
->p_offset
,
10447 (bfd_vma
) segment
->p_filesz
);
10454 process_corefile_contents (FILE *file
)
10456 /* If we have not been asked to display the notes then do nothing. */
10460 /* If file is not a core file then exit. */
10461 if (elf_header
.e_type
!= ET_CORE
)
10464 /* No program headers means no NOTE segment. */
10465 if (elf_header
.e_phnum
== 0)
10467 printf (_("No note segments present in the core file.\n"));
10471 return process_corefile_note_segments (file
);
10475 process_arch_specific (FILE *file
)
10480 switch (elf_header
.e_machine
)
10483 case EM_MIPS_RS3_LE
:
10484 return process_mips_specific (file
);
10493 get_file_header (FILE *file
)
10495 /* Read in the identity array. */
10496 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10499 /* Determine how to read the rest of the header. */
10500 switch (elf_header
.e_ident
[EI_DATA
])
10502 default: /* fall through */
10503 case ELFDATANONE
: /* fall through */
10505 byte_get
= byte_get_little_endian
;
10506 byte_put
= byte_put_little_endian
;
10509 byte_get
= byte_get_big_endian
;
10510 byte_put
= byte_put_big_endian
;
10514 /* For now we only support 32 bit and 64 bit ELF files. */
10515 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10517 /* Read in the rest of the header. */
10520 Elf32_External_Ehdr ehdr32
;
10522 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10525 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10526 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10527 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10528 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10529 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10530 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10531 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10532 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10533 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10534 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10535 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10536 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10537 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10541 Elf64_External_Ehdr ehdr64
;
10543 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10544 we will not be able to cope with the 64bit data found in
10545 64 ELF files. Detect this now and abort before we start
10546 overwriting things. */
10547 if (sizeof (bfd_vma
) < 8)
10549 error (_("This instance of readelf has been built without support for a\n\
10550 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10554 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10557 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10558 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10559 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10560 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10561 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10562 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10563 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10564 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10565 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10566 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10567 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10568 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10569 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10572 if (elf_header
.e_shoff
)
10574 /* There may be some extensions in the first section header. Don't
10575 bomb if we can't read it. */
10577 get_32bit_section_headers (file
, 1);
10579 get_64bit_section_headers (file
, 1);
10585 /* Process one ELF object file according to the command line options.
10586 This file may actually be stored in an archive. The file is
10587 positioned at the start of the ELF object. */
10590 process_object (char *file_name
, FILE *file
)
10594 if (! get_file_header (file
))
10596 error (_("%s: Failed to read file header\n"), file_name
);
10600 /* Initialise per file variables. */
10601 for (i
= NUM_ELEM (version_info
); i
--;)
10602 version_info
[i
] = 0;
10604 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10605 dynamic_info
[i
] = 0;
10607 /* Process the file. */
10609 printf (_("\nFile: %s\n"), file_name
);
10611 if (! process_file_header ())
10614 if (! process_section_headers (file
)
10615 || ! process_section_groups (file
))
10617 /* Without loaded section headers and section groups we
10618 cannot process lots of things. */
10619 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10621 if (! do_using_dynamic
)
10622 do_syms
= do_reloc
= 0;
10625 if (process_program_headers (file
))
10626 process_dynamic_section (file
);
10628 process_relocs (file
);
10630 process_unwind (file
);
10632 process_symbol_table (file
);
10634 process_syminfo (file
);
10636 process_version_sections (file
);
10638 process_section_contents (file
);
10640 process_corefile_contents (file
);
10642 process_gnu_liblist (file
);
10644 process_arch_specific (file
);
10646 if (program_headers
)
10648 free (program_headers
);
10649 program_headers
= NULL
;
10652 if (section_headers
)
10654 free (section_headers
);
10655 section_headers
= NULL
;
10660 free (string_table
);
10661 string_table
= NULL
;
10662 string_table_length
= 0;
10665 if (dynamic_strings
)
10667 free (dynamic_strings
);
10668 dynamic_strings
= NULL
;
10671 if (dynamic_symbols
)
10673 free (dynamic_symbols
);
10674 dynamic_symbols
= NULL
;
10675 num_dynamic_syms
= 0;
10678 if (dynamic_syminfo
)
10680 free (dynamic_syminfo
);
10681 dynamic_syminfo
= NULL
;
10684 if (section_headers_groups
)
10686 free (section_headers_groups
);
10687 section_headers_groups
= NULL
;
10690 if (section_groups
)
10692 struct group_list
*g
, *next
;
10694 for (i
= 0; i
< group_count
; i
++)
10696 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10703 free (section_groups
);
10704 section_groups
= NULL
;
10710 /* Process an ELF archive. The file is positioned just after the
10714 process_archive (char *file_name
, FILE *file
)
10716 struct ar_hdr arhdr
;
10718 unsigned long size
;
10719 char *longnames
= NULL
;
10720 unsigned long longnames_size
= 0;
10721 size_t file_name_size
;
10726 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10727 if (got
!= sizeof arhdr
)
10732 error (_("%s: failed to read archive header\n"), file_name
);
10736 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
10738 /* This is the archive symbol table. Skip it.
10739 FIXME: We should have an option to dump it. */
10740 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10741 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
10743 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10747 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10748 if (got
!= sizeof arhdr
)
10753 error (_("%s: failed to read archive header\n"), file_name
);
10758 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
10760 /* This is the archive string table holding long member
10763 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10765 longnames
= malloc (longnames_size
);
10766 if (longnames
== NULL
)
10768 error (_("Out of memory\n"));
10772 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10775 error(_("%s: failed to read string table\n"), file_name
);
10779 if ((longnames_size
& 1) != 0)
10782 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10783 if (got
!= sizeof arhdr
)
10790 error (_("%s: failed to read archive header\n"), file_name
);
10795 file_name_size
= strlen (file_name
);
10804 if (arhdr
.ar_name
[0] == '/')
10808 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10809 if (off
>= longnames_size
)
10811 error (_("%s: invalid archive string table offset %lu\n"), off
);
10816 name
= longnames
+ off
;
10817 nameend
= memchr (name
, '/', longnames_size
- off
);
10821 name
= arhdr
.ar_name
;
10822 nameend
= memchr (name
, '/', 16);
10825 if (nameend
== NULL
)
10827 error (_("%s: bad archive file name\n"));
10832 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10833 if (namealc
== NULL
)
10835 error (_("Out of memory\n"));
10840 memcpy (namealc
, file_name
, file_name_size
);
10841 namealc
[file_name_size
] = '(';
10842 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10843 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10844 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10846 archive_file_offset
= ftell (file
);
10847 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10849 ret
|= process_object (namealc
, file
);
10854 (archive_file_offset
10855 + archive_file_size
10856 + (archive_file_size
& 1)),
10859 error (_("%s: failed to seek to next archive header\n"), file_name
);
10864 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10865 if (got
!= sizeof arhdr
)
10870 error (_("%s: failed to read archive header\n"), file_name
);
10876 if (longnames
!= 0)
10883 process_file (char *file_name
)
10886 struct stat statbuf
;
10887 char armag
[SARMAG
];
10890 if (stat (file_name
, &statbuf
) < 0)
10892 if (errno
== ENOENT
)
10893 error (_("'%s': No such file\n"), file_name
);
10895 error (_("Could not locate '%s'. System error message: %s\n"),
10896 file_name
, strerror (errno
));
10900 if (! S_ISREG (statbuf
.st_mode
))
10902 error (_("'%s' is not an ordinary file\n"), file_name
);
10906 file
= fopen (file_name
, "rb");
10909 error (_("Input file '%s' is not readable.\n"), file_name
);
10913 if (fread (armag
, SARMAG
, 1, file
) != 1)
10915 error (_("%s: Failed to read file header\n"), file_name
);
10920 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10921 ret
= process_archive (file_name
, file
);
10925 archive_file_size
= archive_file_offset
= 0;
10926 ret
= process_object (file_name
, file
);
10934 #ifdef SUPPORT_DISASSEMBLY
10935 /* Needed by the i386 disassembler. For extra credit, someone could
10936 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10940 print_address (unsigned int addr
, FILE *outfile
)
10942 fprintf (outfile
,"0x%8.8x", addr
);
10945 /* Needed by the i386 disassembler. */
10947 db_task_printsym (unsigned int addr
)
10949 print_address (addr
, stderr
);
10954 main (int argc
, char **argv
)
10957 char *cmdline_dump_sects
= NULL
;
10958 unsigned num_cmdline_dump_sects
= 0;
10960 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10961 setlocale (LC_MESSAGES
, "");
10963 #if defined (HAVE_SETLOCALE)
10964 setlocale (LC_CTYPE
, "");
10966 bindtextdomain (PACKAGE
, LOCALEDIR
);
10967 textdomain (PACKAGE
);
10969 parse_args (argc
, argv
);
10971 if (optind
< (argc
- 1))
10974 /* When processing more than one file remember the dump requests
10975 issued on command line to reset them after each file. */
10976 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
10978 cmdline_dump_sects
= malloc (num_dump_sects
);
10979 if (cmdline_dump_sects
== NULL
)
10980 error (_("Out of memory allocating dump request table."));
10983 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
10984 num_cmdline_dump_sects
= num_dump_sects
;
10989 while (optind
< argc
)
10991 err
|= process_file (argv
[optind
++]);
10993 /* Reset dump requests. */
10994 if (optind
< argc
&& dump_sects
!= NULL
)
10996 num_dump_sects
= num_cmdline_dump_sects
;
10997 if (num_cmdline_dump_sects
> 0)
10998 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11002 if (dump_sects
!= NULL
)
11004 if (cmdline_dump_sects
!= NULL
)
11005 free (cmdline_dump_sects
);