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 switch (e_flags
& EF_FRV_CPU_MASK
)
1878 case EF_FRV_CPU_GENERIC
:
1882 strcat (buf
, ", fr???");
1885 case EF_FRV_CPU_FR300
:
1886 strcat (buf
, ", fr300");
1889 case EF_FRV_CPU_FR400
:
1890 strcat (buf
, ", fr400");
1892 case EF_FRV_CPU_FR405
:
1893 strcat (buf
, ", fr405");
1896 case EF_FRV_CPU_FR450
:
1897 strcat (buf
, ", fr450");
1900 case EF_FRV_CPU_FR500
:
1901 strcat (buf
, ", fr500");
1903 case EF_FRV_CPU_FR550
:
1904 strcat (buf
, ", fr550");
1907 case EF_FRV_CPU_SIMPLE
:
1908 strcat (buf
, ", simple");
1910 case EF_FRV_CPU_TOMCAT
:
1911 strcat (buf
, ", tomcat");
1916 if (e_flags
& EF_CPU32
)
1917 strcat (buf
, ", cpu32");
1918 if (e_flags
& EF_M68000
)
1919 strcat (buf
, ", m68000");
1923 if (e_flags
& EF_PPC_EMB
)
1924 strcat (buf
, ", emb");
1926 if (e_flags
& EF_PPC_RELOCATABLE
)
1927 strcat (buf
, ", relocatable");
1929 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1930 strcat (buf
, ", relocatable-lib");
1934 case EM_CYGNUS_V850
:
1935 switch (e_flags
& EF_V850_ARCH
)
1938 strcat (buf
, ", v850e1");
1941 strcat (buf
, ", v850e");
1944 strcat (buf
, ", v850");
1947 strcat (buf
, ", unknown v850 architecture variant");
1953 case EM_CYGNUS_M32R
:
1954 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1955 strcat (buf
, ", m32r");
1960 case EM_MIPS_RS3_LE
:
1961 if (e_flags
& EF_MIPS_NOREORDER
)
1962 strcat (buf
, ", noreorder");
1964 if (e_flags
& EF_MIPS_PIC
)
1965 strcat (buf
, ", pic");
1967 if (e_flags
& EF_MIPS_CPIC
)
1968 strcat (buf
, ", cpic");
1970 if (e_flags
& EF_MIPS_UCODE
)
1971 strcat (buf
, ", ugen_reserved");
1973 if (e_flags
& EF_MIPS_ABI2
)
1974 strcat (buf
, ", abi2");
1976 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1977 strcat (buf
, ", odk first");
1979 if (e_flags
& EF_MIPS_32BITMODE
)
1980 strcat (buf
, ", 32bitmode");
1982 switch ((e_flags
& EF_MIPS_MACH
))
1984 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1985 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1986 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1987 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1988 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1989 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1990 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1991 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1992 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1994 /* We simply ignore the field in this case to avoid confusion:
1995 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1998 default: strcat (buf
, ", unknown CPU"); break;
2001 switch ((e_flags
& EF_MIPS_ABI
))
2003 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2004 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2005 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2006 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2008 /* We simply ignore the field in this case to avoid confusion:
2009 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2010 This means it is likely to be an o32 file, but not for
2013 default: strcat (buf
, ", unknown ABI"); break;
2016 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2017 strcat (buf
, ", mdmx");
2019 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2020 strcat (buf
, ", mips16");
2022 switch ((e_flags
& EF_MIPS_ARCH
))
2024 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2025 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2026 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2027 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2028 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2029 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2030 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2031 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2032 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2033 default: strcat (buf
, ", unknown ISA"); break;
2039 switch ((e_flags
& EF_SH_MACH_MASK
))
2041 case EF_SH1
: strcat (buf
, ", sh1"); break;
2042 case EF_SH2
: strcat (buf
, ", sh2"); break;
2043 case EF_SH3
: strcat (buf
, ", sh3"); break;
2044 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2045 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2046 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2047 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2048 case EF_SH4
: strcat (buf
, ", sh4"); break;
2049 case EF_SH5
: strcat (buf
, ", sh5"); break;
2050 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2051 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2052 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2053 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2054 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2055 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2056 default: strcat (buf
, ", unknown ISA"); break;
2062 if (e_flags
& EF_SPARC_32PLUS
)
2063 strcat (buf
, ", v8+");
2065 if (e_flags
& EF_SPARC_SUN_US1
)
2066 strcat (buf
, ", ultrasparcI");
2068 if (e_flags
& EF_SPARC_SUN_US3
)
2069 strcat (buf
, ", ultrasparcIII");
2071 if (e_flags
& EF_SPARC_HAL_R1
)
2072 strcat (buf
, ", halr1");
2074 if (e_flags
& EF_SPARC_LEDATA
)
2075 strcat (buf
, ", ledata");
2077 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2078 strcat (buf
, ", tso");
2080 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2081 strcat (buf
, ", pso");
2083 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2084 strcat (buf
, ", rmo");
2088 switch (e_flags
& EF_PARISC_ARCH
)
2090 case EFA_PARISC_1_0
:
2091 strcpy (buf
, ", PA-RISC 1.0");
2093 case EFA_PARISC_1_1
:
2094 strcpy (buf
, ", PA-RISC 1.1");
2096 case EFA_PARISC_2_0
:
2097 strcpy (buf
, ", PA-RISC 2.0");
2102 if (e_flags
& EF_PARISC_TRAPNIL
)
2103 strcat (buf
, ", trapnil");
2104 if (e_flags
& EF_PARISC_EXT
)
2105 strcat (buf
, ", ext");
2106 if (e_flags
& EF_PARISC_LSB
)
2107 strcat (buf
, ", lsb");
2108 if (e_flags
& EF_PARISC_WIDE
)
2109 strcat (buf
, ", wide");
2110 if (e_flags
& EF_PARISC_NO_KABP
)
2111 strcat (buf
, ", no kabp");
2112 if (e_flags
& EF_PARISC_LAZYSWAP
)
2113 strcat (buf
, ", lazyswap");
2118 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2119 strcat (buf
, ", new calling convention");
2121 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2122 strcat (buf
, ", gnu calling convention");
2126 if ((e_flags
& EF_IA_64_ABI64
))
2127 strcat (buf
, ", 64-bit");
2129 strcat (buf
, ", 32-bit");
2130 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2131 strcat (buf
, ", reduced fp model");
2132 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2133 strcat (buf
, ", no function descriptors, constant gp");
2134 else if ((e_flags
& EF_IA_64_CONS_GP
))
2135 strcat (buf
, ", constant gp");
2136 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2137 strcat (buf
, ", absolute");
2141 if ((e_flags
& EF_VAX_NONPIC
))
2142 strcat (buf
, ", non-PIC");
2143 if ((e_flags
& EF_VAX_DFLOAT
))
2144 strcat (buf
, ", D-Float");
2145 if ((e_flags
& EF_VAX_GFLOAT
))
2146 strcat (buf
, ", G-Float");
2155 get_osabi_name (unsigned int osabi
)
2157 static char buff
[32];
2161 case ELFOSABI_NONE
: return "UNIX - System V";
2162 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2163 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2164 case ELFOSABI_LINUX
: return "UNIX - Linux";
2165 case ELFOSABI_HURD
: return "GNU/Hurd";
2166 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2167 case ELFOSABI_AIX
: return "UNIX - AIX";
2168 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2169 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2170 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2171 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2172 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2173 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2174 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2175 case ELFOSABI_AROS
: return "Amiga Research OS";
2176 case ELFOSABI_STANDALONE
: return _("Standalone App");
2177 case ELFOSABI_ARM
: return "ARM";
2179 sprintf (buff
, _("<unknown: %x>"), osabi
);
2185 get_mips_segment_type (unsigned long type
)
2189 case PT_MIPS_REGINFO
:
2191 case PT_MIPS_RTPROC
:
2193 case PT_MIPS_OPTIONS
:
2203 get_parisc_segment_type (unsigned long type
)
2207 case PT_HP_TLS
: return "HP_TLS";
2208 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2209 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2210 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2211 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2212 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2213 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2214 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2215 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2216 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2217 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2218 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2219 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2220 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2229 get_ia64_segment_type (unsigned long type
)
2233 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2234 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2235 case PT_HP_TLS
: return "HP_TLS";
2236 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2237 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2238 case PT_IA_64_HP_STACK
: return "HP_STACK";
2247 get_segment_type (unsigned long p_type
)
2249 static char buff
[32];
2253 case PT_NULL
: return "NULL";
2254 case PT_LOAD
: return "LOAD";
2255 case PT_DYNAMIC
: return "DYNAMIC";
2256 case PT_INTERP
: return "INTERP";
2257 case PT_NOTE
: return "NOTE";
2258 case PT_SHLIB
: return "SHLIB";
2259 case PT_PHDR
: return "PHDR";
2260 case PT_TLS
: return "TLS";
2262 case PT_GNU_EH_FRAME
:
2263 return "GNU_EH_FRAME";
2264 case PT_GNU_STACK
: return "GNU_STACK";
2265 case PT_GNU_RELRO
: return "GNU_RELRO";
2268 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2272 switch (elf_header
.e_machine
)
2275 case EM_MIPS_RS3_LE
:
2276 result
= get_mips_segment_type (p_type
);
2279 result
= get_parisc_segment_type (p_type
);
2282 result
= get_ia64_segment_type (p_type
);
2292 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2294 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2298 switch (elf_header
.e_machine
)
2301 result
= get_parisc_segment_type (p_type
);
2304 result
= get_ia64_segment_type (p_type
);
2314 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2317 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2324 get_mips_section_type_name (unsigned int sh_type
)
2328 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2329 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2330 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2331 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2332 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2333 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2334 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2335 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2336 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2337 case SHT_MIPS_RELD
: return "MIPS_RELD";
2338 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2339 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2340 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2341 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2342 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2343 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2344 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2345 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2346 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2347 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2348 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2349 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2350 case SHT_MIPS_LINE
: return "MIPS_LINE";
2351 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2352 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2353 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2354 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2355 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2356 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2357 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2358 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2359 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2360 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2361 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2362 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2363 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2364 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2365 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2366 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2374 get_parisc_section_type_name (unsigned int sh_type
)
2378 case SHT_PARISC_EXT
: return "PARISC_EXT";
2379 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2380 case SHT_PARISC_DOC
: return "PARISC_DOC";
2388 get_ia64_section_type_name (unsigned int sh_type
)
2390 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2391 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2392 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2396 case SHT_IA_64_EXT
: return "IA_64_EXT";
2397 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2398 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2406 get_section_type_name (unsigned int sh_type
)
2408 static char buff
[32];
2412 case SHT_NULL
: return "NULL";
2413 case SHT_PROGBITS
: return "PROGBITS";
2414 case SHT_SYMTAB
: return "SYMTAB";
2415 case SHT_STRTAB
: return "STRTAB";
2416 case SHT_RELA
: return "RELA";
2417 case SHT_HASH
: return "HASH";
2418 case SHT_DYNAMIC
: return "DYNAMIC";
2419 case SHT_NOTE
: return "NOTE";
2420 case SHT_NOBITS
: return "NOBITS";
2421 case SHT_REL
: return "REL";
2422 case SHT_SHLIB
: return "SHLIB";
2423 case SHT_DYNSYM
: return "DYNSYM";
2424 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2425 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2426 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2427 case SHT_GROUP
: return "GROUP";
2428 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2429 case SHT_GNU_verdef
: return "VERDEF";
2430 case SHT_GNU_verneed
: return "VERNEED";
2431 case SHT_GNU_versym
: return "VERSYM";
2432 case 0x6ffffff0: return "VERSYM";
2433 case 0x6ffffffc: return "VERDEF";
2434 case 0x7ffffffd: return "AUXILIARY";
2435 case 0x7fffffff: return "FILTER";
2436 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2439 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2443 switch (elf_header
.e_machine
)
2446 case EM_MIPS_RS3_LE
:
2447 result
= get_mips_section_type_name (sh_type
);
2450 result
= get_parisc_section_type_name (sh_type
);
2453 result
= get_ia64_section_type_name (sh_type
);
2463 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2465 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2466 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2467 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2468 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2470 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2476 #define OPTION_DEBUG_DUMP 512
2478 struct option options
[] =
2480 {"all", no_argument
, 0, 'a'},
2481 {"file-header", no_argument
, 0, 'h'},
2482 {"program-headers", no_argument
, 0, 'l'},
2483 {"headers", no_argument
, 0, 'e'},
2484 {"histogram", no_argument
, 0, 'I'},
2485 {"segments", no_argument
, 0, 'l'},
2486 {"sections", no_argument
, 0, 'S'},
2487 {"section-headers", no_argument
, 0, 'S'},
2488 {"section-groups", no_argument
, 0, 'g'},
2489 {"symbols", no_argument
, 0, 's'},
2490 {"syms", no_argument
, 0, 's'},
2491 {"relocs", no_argument
, 0, 'r'},
2492 {"notes", no_argument
, 0, 'n'},
2493 {"dynamic", no_argument
, 0, 'd'},
2494 {"arch-specific", no_argument
, 0, 'A'},
2495 {"version-info", no_argument
, 0, 'V'},
2496 {"use-dynamic", no_argument
, 0, 'D'},
2497 {"hex-dump", required_argument
, 0, 'x'},
2498 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2499 {"unwind", no_argument
, 0, 'u'},
2500 #ifdef SUPPORT_DISASSEMBLY
2501 {"instruction-dump", required_argument
, 0, 'i'},
2504 {"version", no_argument
, 0, 'v'},
2505 {"wide", no_argument
, 0, 'W'},
2506 {"help", no_argument
, 0, 'H'},
2507 {0, no_argument
, 0, 0}
2513 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2514 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2515 fprintf (stdout
, _(" Options are:\n\
2516 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2517 -h --file-header Display the ELF file header\n\
2518 -l --program-headers Display the program headers\n\
2519 --segments An alias for --program-headers\n\
2520 -S --section-headers Display the sections' header\n\
2521 --sections An alias for --section-headers\n\
2522 -g --section-groups Display the section groups\n\
2523 -e --headers Equivalent to: -h -l -S\n\
2524 -s --syms Display the symbol table\n\
2525 --symbols An alias for --syms\n\
2526 -n --notes Display the core notes (if present)\n\
2527 -r --relocs Display the relocations (if present)\n\
2528 -u --unwind Display the unwind info (if present)\n\
2529 -d --dynamic Display the dynamic section (if present)\n\
2530 -V --version-info Display the version sections (if present)\n\
2531 -A --arch-specific Display architecture specific information (if any).\n\
2532 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2533 -x --hex-dump=<number> Dump the contents of section <number>\n\
2534 -w[liaprmfFso] or\n\
2535 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2536 Display the contents of DWARF2 debug sections\n"));
2537 #ifdef SUPPORT_DISASSEMBLY
2538 fprintf (stdout
, _("\
2539 -i --instruction-dump=<number>\n\
2540 Disassemble the contents of section <number>\n"));
2542 fprintf (stdout
, _("\
2543 -I --histogram Display histogram of bucket list lengths\n\
2544 -W --wide Allow output width to exceed 80 characters\n\
2545 -H --help Display this information\n\
2546 -v --version Display the version number of readelf\n"));
2547 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2553 request_dump (unsigned int section
, int type
)
2555 if (section
>= num_dump_sects
)
2557 char *new_dump_sects
;
2559 new_dump_sects
= calloc (section
+ 1, 1);
2561 if (new_dump_sects
== NULL
)
2562 error (_("Out of memory allocating dump request table."));
2565 /* Copy current flag settings. */
2566 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2570 dump_sects
= new_dump_sects
;
2571 num_dump_sects
= section
+ 1;
2576 dump_sects
[section
] |= type
;
2582 parse_args (int argc
, char **argv
)
2589 while ((c
= getopt_long
2590 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2611 do_section_groups
++;
2619 do_section_groups
++;
2661 section
= strtoul (optarg
, & cp
, 0);
2662 if (! *cp
&& section
>= 0)
2664 request_dump (section
, HEX_DUMP
);
2674 unsigned int index
= 0;
2678 while (optarg
[index
])
2679 switch (optarg
[index
++])
2688 do_debug_abbrevs
= 1;
2698 do_debug_pubnames
= 1;
2703 do_debug_aranges
= 1;
2707 do_debug_frames_interp
= 1;
2709 do_debug_frames
= 1;
2714 do_debug_macinfo
= 1;
2728 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2733 case OPTION_DEBUG_DUMP
:
2739 static const char *debug_dump_opt
[]
2740 = { "line", "info", "abbrev", "pubnames", "ranges",
2741 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2750 for (index
= 0; debug_dump_opt
[index
]; index
++)
2752 size_t len
= strlen (debug_dump_opt
[index
]);
2754 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2755 && (p
[len
] == ',' || p
[len
] == '\0'))
2764 do_debug_abbrevs
= 1;
2775 do_debug_pubnames
= 1;
2779 do_debug_aranges
= 1;
2784 do_debug_frames_interp
= 1;
2785 do_debug_frames
= 1;
2789 do_debug_macinfo
= 1;
2802 if (debug_dump_opt
[index
] == NULL
)
2804 warn (_("Unrecognized debug option '%s'\n"), p
);
2805 p
= strchr (p
, ',');
2815 #ifdef SUPPORT_DISASSEMBLY
2818 section
= strtoul (optarg
, & cp
, 0);
2819 if (! *cp
&& section
>= 0)
2821 request_dump (section
, DISASS_DUMP
);
2827 print_version (program_name
);
2837 /* xgettext:c-format */
2838 error (_("Invalid option '-%c'\n"), c
);
2845 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2846 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2847 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2848 && !do_section_groups
)
2852 warn (_("Nothing to do.\n"));
2858 get_elf_class (unsigned int elf_class
)
2860 static char buff
[32];
2864 case ELFCLASSNONE
: return _("none");
2865 case ELFCLASS32
: return "ELF32";
2866 case ELFCLASS64
: return "ELF64";
2868 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2874 get_data_encoding (unsigned int encoding
)
2876 static char buff
[32];
2880 case ELFDATANONE
: return _("none");
2881 case ELFDATA2LSB
: return _("2's complement, little endian");
2882 case ELFDATA2MSB
: return _("2's complement, big endian");
2884 sprintf (buff
, _("<unknown: %x>"), encoding
);
2889 /* Decode the data held in 'elf_header'. */
2892 process_file_header (void)
2894 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2895 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2896 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2897 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2900 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2908 printf (_("ELF Header:\n"));
2909 printf (_(" Magic: "));
2910 for (i
= 0; i
< EI_NIDENT
; i
++)
2911 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2913 printf (_(" Class: %s\n"),
2914 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2915 printf (_(" Data: %s\n"),
2916 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2917 printf (_(" Version: %d %s\n"),
2918 elf_header
.e_ident
[EI_VERSION
],
2919 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2921 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2924 printf (_(" OS/ABI: %s\n"),
2925 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2926 printf (_(" ABI Version: %d\n"),
2927 elf_header
.e_ident
[EI_ABIVERSION
]);
2928 printf (_(" Type: %s\n"),
2929 get_file_type (elf_header
.e_type
));
2930 printf (_(" Machine: %s\n"),
2931 get_machine_name (elf_header
.e_machine
));
2932 printf (_(" Version: 0x%lx\n"),
2933 (unsigned long) elf_header
.e_version
);
2935 printf (_(" Entry point address: "));
2936 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2937 printf (_("\n Start of program headers: "));
2938 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2939 printf (_(" (bytes into file)\n Start of section headers: "));
2940 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2941 printf (_(" (bytes into file)\n"));
2943 printf (_(" Flags: 0x%lx%s\n"),
2944 (unsigned long) elf_header
.e_flags
,
2945 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2946 printf (_(" Size of this header: %ld (bytes)\n"),
2947 (long) elf_header
.e_ehsize
);
2948 printf (_(" Size of program headers: %ld (bytes)\n"),
2949 (long) elf_header
.e_phentsize
);
2950 printf (_(" Number of program headers: %ld\n"),
2951 (long) elf_header
.e_phnum
);
2952 printf (_(" Size of section headers: %ld (bytes)\n"),
2953 (long) elf_header
.e_shentsize
);
2954 printf (_(" Number of section headers: %ld"),
2955 (long) elf_header
.e_shnum
);
2956 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2957 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2958 putc ('\n', stdout
);
2959 printf (_(" Section header string table index: %ld"),
2960 (long) elf_header
.e_shstrndx
);
2961 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2962 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2963 putc ('\n', stdout
);
2966 if (section_headers
!= NULL
)
2968 if (elf_header
.e_shnum
== 0)
2969 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2970 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2971 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2972 free (section_headers
);
2973 section_headers
= NULL
;
2981 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
2983 Elf32_External_Phdr
*phdrs
;
2984 Elf32_External_Phdr
*external
;
2985 Elf_Internal_Phdr
*internal
;
2988 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
2989 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2990 _("program headers"));
2994 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2995 i
< elf_header
.e_phnum
;
2996 i
++, internal
++, external
++)
2998 internal
->p_type
= BYTE_GET (external
->p_type
);
2999 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3000 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3001 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3002 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3003 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3004 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3005 internal
->p_align
= BYTE_GET (external
->p_align
);
3014 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3016 Elf64_External_Phdr
*phdrs
;
3017 Elf64_External_Phdr
*external
;
3018 Elf_Internal_Phdr
*internal
;
3021 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3022 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3023 _("program headers"));
3027 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3028 i
< elf_header
.e_phnum
;
3029 i
++, internal
++, external
++)
3031 internal
->p_type
= BYTE_GET (external
->p_type
);
3032 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3033 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
3034 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
3035 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
3036 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
3037 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
3038 internal
->p_align
= BYTE_GET8 (external
->p_align
);
3046 /* Returns 1 if the program headers were read into `program_headers'. */
3049 get_program_headers (FILE *file
)
3051 Elf_Internal_Phdr
*phdrs
;
3053 /* Check cache of prior read. */
3054 if (program_headers
!= NULL
)
3057 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3061 error (_("Out of memory\n"));
3066 ? get_32bit_program_headers (file
, phdrs
)
3067 : get_64bit_program_headers (file
, phdrs
))
3069 program_headers
= phdrs
;
3077 /* Returns 1 if the program headers were loaded. */
3080 process_program_headers (FILE *file
)
3082 Elf_Internal_Phdr
*segment
;
3085 if (elf_header
.e_phnum
== 0)
3088 printf (_("\nThere are no program headers in this file.\n"));
3092 if (do_segments
&& !do_header
)
3094 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3095 printf (_("Entry point "));
3096 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3097 printf (_("\nThere are %d program headers, starting at offset "),
3098 elf_header
.e_phnum
);
3099 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3103 if (! get_program_headers (file
))
3108 if (elf_header
.e_phnum
> 1)
3109 printf (_("\nProgram Headers:\n"));
3111 printf (_("\nProgram Headers:\n"));
3115 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3118 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3122 (_(" Type Offset VirtAddr PhysAddr\n"));
3124 (_(" FileSiz MemSiz Flags Align\n"));
3131 for (i
= 0, segment
= program_headers
;
3132 i
< elf_header
.e_phnum
;
3137 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3141 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3142 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3143 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3144 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3145 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3147 (segment
->p_flags
& PF_R
? 'R' : ' '),
3148 (segment
->p_flags
& PF_W
? 'W' : ' '),
3149 (segment
->p_flags
& PF_X
? 'E' : ' '));
3150 printf ("%#lx", (unsigned long) segment
->p_align
);
3154 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3155 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3158 print_vma (segment
->p_offset
, FULL_HEX
);
3162 print_vma (segment
->p_vaddr
, FULL_HEX
);
3164 print_vma (segment
->p_paddr
, FULL_HEX
);
3167 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3168 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3171 print_vma (segment
->p_filesz
, FULL_HEX
);
3175 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3176 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3179 print_vma (segment
->p_offset
, FULL_HEX
);
3183 (segment
->p_flags
& PF_R
? 'R' : ' '),
3184 (segment
->p_flags
& PF_W
? 'W' : ' '),
3185 (segment
->p_flags
& PF_X
? 'E' : ' '));
3187 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3188 printf ("%#lx", (unsigned long) segment
->p_align
);
3191 print_vma (segment
->p_align
, PREFIX_HEX
);
3196 print_vma (segment
->p_offset
, FULL_HEX
);
3198 print_vma (segment
->p_vaddr
, FULL_HEX
);
3200 print_vma (segment
->p_paddr
, FULL_HEX
);
3202 print_vma (segment
->p_filesz
, FULL_HEX
);
3204 print_vma (segment
->p_memsz
, FULL_HEX
);
3206 (segment
->p_flags
& PF_R
? 'R' : ' '),
3207 (segment
->p_flags
& PF_W
? 'W' : ' '),
3208 (segment
->p_flags
& PF_X
? 'E' : ' '));
3209 print_vma (segment
->p_align
, HEX
);
3213 switch (segment
->p_type
)
3217 error (_("more than one dynamic segment\n"));
3219 /* Try to locate the .dynamic section. If there is
3220 a section header table, we can easily locate it. */
3221 if (section_headers
!= NULL
)
3223 Elf_Internal_Shdr
*sec
;
3226 for (j
= 0, sec
= section_headers
;
3227 j
< elf_header
.e_shnum
;
3229 if (strcmp (SECTION_NAME (sec
), ".dynamic") == 0)
3232 if (j
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
3234 error (_("no .dynamic section in the dynamic segment"));
3238 dynamic_addr
= sec
->sh_offset
;
3239 dynamic_size
= sec
->sh_size
;
3241 if (dynamic_addr
< segment
->p_offset
3242 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3243 warn (_("the .dynamic section is not contained within the dynamic segment"));
3244 else if (dynamic_addr
> segment
->p_offset
)
3245 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3249 /* Otherwise, we can only assume that the .dynamic
3250 section is the first section in the DYNAMIC segment. */
3251 dynamic_addr
= segment
->p_offset
;
3252 dynamic_size
= segment
->p_filesz
;
3257 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3259 error (_("Unable to find program interpreter name\n"));
3262 program_interpreter
[0] = 0;
3263 fscanf (file
, "%63s", program_interpreter
);
3266 printf (_("\n [Requesting program interpreter: %s]"),
3267 program_interpreter
);
3273 putc ('\n', stdout
);
3276 if (do_segments
&& section_headers
!= NULL
)
3278 printf (_("\n Section to Segment mapping:\n"));
3279 printf (_(" Segment Sections...\n"));
3281 assert (string_table
!= NULL
);
3283 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3286 Elf_Internal_Shdr
*section
;
3288 segment
= program_headers
+ i
;
3289 section
= section_headers
;
3291 printf (" %2.2d ", i
);
3293 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3295 if (section
->sh_size
> 0
3296 /* Compare allocated sections by VMA, unallocated
3297 sections by file offset. */
3298 && (section
->sh_flags
& SHF_ALLOC
3299 ? (section
->sh_addr
>= segment
->p_vaddr
3300 && section
->sh_addr
+ section
->sh_size
3301 <= segment
->p_vaddr
+ segment
->p_memsz
)
3302 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3303 && (section
->sh_offset
+ section
->sh_size
3304 <= segment
->p_offset
+ segment
->p_filesz
))))
3305 printf ("%s ", SECTION_NAME (section
));
3316 /* Find the file offset corresponding to VMA by using the program headers. */
3319 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3321 Elf_Internal_Phdr
*seg
;
3323 if (! get_program_headers (file
))
3325 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3329 for (seg
= program_headers
;
3330 seg
< program_headers
+ elf_header
.e_phnum
;
3333 if (seg
->p_type
!= PT_LOAD
)
3336 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3337 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3338 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3341 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3348 get_32bit_section_headers (FILE *file
, unsigned int num
)
3350 Elf32_External_Shdr
*shdrs
;
3351 Elf_Internal_Shdr
*internal
;
3354 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3355 elf_header
.e_shentsize
* num
, _("section headers"));
3359 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3361 if (section_headers
== NULL
)
3363 error (_("Out of memory\n"));
3367 for (i
= 0, internal
= section_headers
;
3371 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3372 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3373 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3374 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3375 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3376 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3377 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3378 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3379 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3380 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3389 get_64bit_section_headers (FILE *file
, unsigned int num
)
3391 Elf64_External_Shdr
*shdrs
;
3392 Elf_Internal_Shdr
*internal
;
3395 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3396 elf_header
.e_shentsize
* num
, _("section headers"));
3400 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3402 if (section_headers
== NULL
)
3404 error (_("Out of memory\n"));
3408 for (i
= 0, internal
= section_headers
;
3412 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3413 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3414 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3415 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3416 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3417 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3418 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3419 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3420 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3421 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3429 static Elf_Internal_Sym
*
3430 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3432 unsigned long number
;
3433 Elf32_External_Sym
*esyms
;
3434 Elf_External_Sym_Shndx
*shndx
;
3435 Elf_Internal_Sym
*isyms
;
3436 Elf_Internal_Sym
*psym
;
3439 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3445 if (symtab_shndx_hdr
!= NULL
3446 && (symtab_shndx_hdr
->sh_link
3447 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3449 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3450 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3458 number
= section
->sh_size
/ section
->sh_entsize
;
3459 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3463 error (_("Out of memory\n"));
3470 for (j
= 0, psym
= isyms
;
3474 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3475 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3476 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3477 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3478 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3480 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3481 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3482 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3492 static Elf_Internal_Sym
*
3493 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3495 unsigned long number
;
3496 Elf64_External_Sym
*esyms
;
3497 Elf_External_Sym_Shndx
*shndx
;
3498 Elf_Internal_Sym
*isyms
;
3499 Elf_Internal_Sym
*psym
;
3502 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3508 if (symtab_shndx_hdr
!= NULL
3509 && (symtab_shndx_hdr
->sh_link
3510 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3512 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3513 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3521 number
= section
->sh_size
/ section
->sh_entsize
;
3522 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3526 error (_("Out of memory\n"));
3533 for (j
= 0, psym
= isyms
;
3537 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3538 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3539 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3540 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3541 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3543 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3544 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3545 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3556 get_elf_section_flags (bfd_vma sh_flags
)
3558 static char buff
[32];
3566 flag
= sh_flags
& - sh_flags
;
3571 case SHF_WRITE
: strcat (buff
, "W"); break;
3572 case SHF_ALLOC
: strcat (buff
, "A"); break;
3573 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3574 case SHF_MERGE
: strcat (buff
, "M"); break;
3575 case SHF_STRINGS
: strcat (buff
, "S"); break;
3576 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3577 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3578 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3579 case SHF_GROUP
: strcat (buff
, "G"); break;
3580 case SHF_TLS
: strcat (buff
, "T"); break;
3583 if (flag
& SHF_MASKOS
)
3586 sh_flags
&= ~ SHF_MASKOS
;
3588 else if (flag
& SHF_MASKPROC
)
3591 sh_flags
&= ~ SHF_MASKPROC
;
3603 process_section_headers (FILE *file
)
3605 Elf_Internal_Shdr
*section
;
3608 section_headers
= NULL
;
3610 if (elf_header
.e_shnum
== 0)
3613 printf (_("\nThere are no sections in this file.\n"));
3618 if (do_sections
&& !do_header
)
3619 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3620 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3624 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3627 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3630 /* Read in the string table, so that we have names to display. */
3631 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3633 if (section
->sh_size
!= 0)
3635 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3636 section
->sh_size
, _("string table"));
3638 if (string_table
== NULL
)
3641 string_table_length
= section
->sh_size
;
3644 /* Scan the sections for the dynamic symbol table
3645 and dynamic string table and debug sections. */
3646 dynamic_symbols
= NULL
;
3647 dynamic_strings
= NULL
;
3648 dynamic_syminfo
= NULL
;
3649 symtab_shndx_hdr
= NULL
;
3651 for (i
= 0, section
= section_headers
;
3652 i
< elf_header
.e_shnum
;
3655 char *name
= SECTION_NAME (section
);
3657 if (section
->sh_type
== SHT_DYNSYM
)
3659 if (dynamic_symbols
!= NULL
)
3661 error (_("File contains multiple dynamic symbol tables\n"));
3665 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3666 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3668 else if (section
->sh_type
== SHT_STRTAB
3669 && strcmp (name
, ".dynstr") == 0)
3671 if (dynamic_strings
!= NULL
)
3673 error (_("File contains multiple dynamic string tables\n"));
3677 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3678 section
->sh_size
, _("dynamic strings"));
3680 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3682 if (symtab_shndx_hdr
!= NULL
)
3684 error (_("File contains multiple symtab shndx tables\n"));
3687 symtab_shndx_hdr
= section
;
3689 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3690 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3691 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3693 && strncmp (name
, ".debug_", 7) == 0)
3698 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3699 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3700 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3701 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3702 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3703 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3704 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3705 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3706 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3708 request_dump (i
, DEBUG_DUMP
);
3710 /* linkonce section to be combined with .debug_info at link time. */
3711 else if ((do_debugging
|| do_debug_info
)
3712 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3713 request_dump (i
, DEBUG_DUMP
);
3714 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3715 request_dump (i
, DEBUG_DUMP
);
3721 if (elf_header
.e_shnum
> 1)
3722 printf (_("\nSection Headers:\n"));
3724 printf (_("\nSection Header:\n"));
3728 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3731 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3734 printf (_(" [Nr] Name Type Address Offset\n"));
3735 printf (_(" Size EntSize Flags Link Info Align\n"));
3738 for (i
= 0, section
= section_headers
;
3739 i
< elf_header
.e_shnum
;
3742 printf (" [%2u] %-17.17s %-15.15s ",
3743 SECTION_HEADER_NUM (i
),
3744 SECTION_NAME (section
),
3745 get_section_type_name (section
->sh_type
));
3749 print_vma (section
->sh_addr
, LONG_HEX
);
3751 printf ( " %6.6lx %6.6lx %2.2lx",
3752 (unsigned long) section
->sh_offset
,
3753 (unsigned long) section
->sh_size
,
3754 (unsigned long) section
->sh_entsize
);
3756 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3758 printf ("%2ld %3lu %2ld\n",
3759 (unsigned long) section
->sh_link
,
3760 (unsigned long) section
->sh_info
,
3761 (unsigned long) section
->sh_addralign
);
3765 print_vma (section
->sh_addr
, LONG_HEX
);
3767 if ((long) section
->sh_offset
== section
->sh_offset
)
3768 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3772 print_vma (section
->sh_offset
, LONG_HEX
);
3775 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3776 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3780 print_vma (section
->sh_size
, LONG_HEX
);
3783 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3784 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3788 print_vma (section
->sh_entsize
, LONG_HEX
);
3791 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3793 printf ("%2ld %3lu ",
3794 (unsigned long) section
->sh_link
,
3795 (unsigned long) section
->sh_info
);
3797 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3798 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3801 print_vma (section
->sh_addralign
, DEC
);
3808 print_vma (section
->sh_addr
, LONG_HEX
);
3809 if ((long) section
->sh_offset
== section
->sh_offset
)
3810 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3814 print_vma (section
->sh_offset
, LONG_HEX
);
3817 print_vma (section
->sh_size
, LONG_HEX
);
3819 print_vma (section
->sh_entsize
, LONG_HEX
);
3821 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3823 printf (" %2ld %3lu %ld\n",
3824 (unsigned long) section
->sh_link
,
3825 (unsigned long) section
->sh_info
,
3826 (unsigned long) section
->sh_addralign
);
3830 printf (_("Key to Flags:\n\
3831 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3832 I (info), L (link order), G (group), x (unknown)\n\
3833 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3839 get_group_flags (unsigned int flags
)
3841 static char buff
[32];
3848 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3855 process_section_groups (FILE *file
)
3857 Elf_Internal_Shdr
*section
;
3859 struct group
*group
;
3861 if (elf_header
.e_shnum
== 0)
3863 if (do_section_groups
)
3864 printf (_("\nThere are no section groups in this file.\n"));
3869 if (section_headers
== NULL
)
3871 error (_("Section headers are not available!\n"));
3875 section_headers_groups
= calloc (elf_header
.e_shnum
,
3876 sizeof (struct group
*));
3878 if (section_headers_groups
== NULL
)
3880 error (_("Out of memory\n"));
3884 /* Scan the sections for the group section. */
3885 for (i
= 0, section
= section_headers
;
3886 i
< elf_header
.e_shnum
;
3888 if (section
->sh_type
== SHT_GROUP
)
3891 section_groups
= calloc (group_count
, sizeof (struct group
));
3893 if (section_groups
== NULL
)
3895 error (_("Out of memory\n"));
3899 for (i
= 0, section
= section_headers
, group
= section_groups
;
3900 i
< elf_header
.e_shnum
;
3903 if (section
->sh_type
== SHT_GROUP
)
3905 char *name
= SECTION_NAME (section
);
3906 char *group_name
, *strtab
, *start
, *indices
;
3907 unsigned int entry
, j
, size
;
3908 Elf_Internal_Sym
*sym
;
3909 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
, *sec
;
3910 Elf_Internal_Sym
*symtab
;
3912 /* Get the symbol table. */
3913 symtab_sec
= SECTION_HEADER (section
->sh_link
);
3914 if (symtab_sec
->sh_type
!= SHT_SYMTAB
)
3916 error (_("Bad sh_link in group section `%s'\n"), name
);
3919 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
3921 sym
= symtab
+ section
->sh_info
;
3923 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3925 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
3928 error (_("Bad sh_info in group section `%s'\n"), name
);
3932 group_name
= SECTION_NAME (section_headers
+ sec_index
);
3937 /* Get the string table. */
3938 strtab_sec
= SECTION_HEADER (symtab_sec
->sh_link
);
3939 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
3940 strtab_sec
->sh_size
,
3943 group_name
= strtab
+ sym
->st_name
;
3946 start
= get_data (NULL
, file
, section
->sh_offset
,
3947 section
->sh_size
, _("section data"));
3950 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
3951 entry
= byte_get (indices
, 4);
3954 if (do_section_groups
)
3956 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
3957 get_group_flags (entry
), name
, group_name
, size
);
3959 printf (_(" [Index] Name\n"));
3962 group
->group_index
= i
;
3964 for (j
= 0; j
< size
; j
++)
3966 struct group_list
*g
;
3968 entry
= byte_get (indices
, 4);
3971 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
3974 error (_("section [%5u] already in group section [%5u]\n"),
3975 entry
, section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
3979 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
3982 if (do_section_groups
)
3984 sec
= SECTION_HEADER (entry
);
3985 printf (" [%5u] %s\n",
3986 entry
, SECTION_NAME (sec
));
3989 g
= xmalloc (sizeof (struct group_list
));
3990 g
->section_index
= entry
;
3991 g
->next
= group
->root
;
4013 } dynamic_relocations
[] =
4015 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4016 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4017 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4020 /* Process the reloc section. */
4022 process_relocs (FILE *file
)
4024 unsigned long rel_size
;
4025 unsigned long rel_offset
;
4031 if (do_using_dynamic
)
4035 int has_dynamic_reloc
;
4038 has_dynamic_reloc
= 0;
4040 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4042 is_rela
= dynamic_relocations
[i
].rela
;
4043 name
= dynamic_relocations
[i
].name
;
4044 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4045 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4047 has_dynamic_reloc
|= rel_size
;
4049 if (is_rela
== UNKNOWN
)
4051 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4052 switch (dynamic_info
[DT_PLTREL
])
4066 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4067 name
, rel_offset
, rel_size
);
4069 dump_relocations (file
,
4070 offset_from_vma (file
, rel_offset
, rel_size
),
4072 dynamic_symbols
, num_dynamic_syms
,
4073 dynamic_strings
, is_rela
);
4077 if (! has_dynamic_reloc
)
4078 printf (_("\nThere are no dynamic relocations in this file.\n"));
4082 Elf_Internal_Shdr
*section
;
4086 for (i
= 0, section
= section_headers
;
4087 i
< elf_header
.e_shnum
;
4090 if ( section
->sh_type
!= SHT_RELA
4091 && section
->sh_type
!= SHT_REL
)
4094 rel_offset
= section
->sh_offset
;
4095 rel_size
= section
->sh_size
;
4099 Elf_Internal_Shdr
*strsec
;
4100 Elf_Internal_Sym
*symtab
;
4103 unsigned long nsyms
;
4105 printf (_("\nRelocation section "));
4107 if (string_table
== NULL
)
4108 printf ("%d", section
->sh_name
);
4110 printf (_("'%s'"), SECTION_NAME (section
));
4112 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4113 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4118 if (section
->sh_link
)
4120 Elf_Internal_Shdr
*symsec
;
4122 symsec
= SECTION_HEADER (section
->sh_link
);
4123 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4124 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4129 strsec
= SECTION_HEADER (symsec
->sh_link
);
4131 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4132 strsec
->sh_size
, _("string table"));
4134 is_rela
= section
->sh_type
== SHT_RELA
;
4136 dump_relocations (file
, rel_offset
, rel_size
,
4137 symtab
, nsyms
, strtab
, is_rela
);
4149 printf (_("\nThere are no relocations in this file.\n"));
4155 #include "unwind-ia64.h"
4157 /* An absolute address consists of a section and an offset. If the
4158 section is NULL, the offset itself is the address, otherwise, the
4159 address equals to LOAD_ADDRESS(section) + offset. */
4163 unsigned short section
;
4169 struct unw_table_entry
4171 struct absaddr start
;
4173 struct absaddr info
;
4175 *table
; /* Unwind table. */
4176 unsigned long table_len
; /* Length of unwind table. */
4177 unsigned char *info
; /* Unwind info. */
4178 unsigned long info_size
; /* Size of unwind info. */
4179 bfd_vma info_addr
; /* starting address of unwind info. */
4180 bfd_vma seg_base
; /* Starting address of segment. */
4181 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4182 unsigned long nsyms
; /* Number of symbols. */
4183 char *strtab
; /* The string table. */
4184 unsigned long strtab_size
; /* Size of string table. */
4188 find_symbol_for_address (struct unw_aux_info
*aux
,
4189 struct absaddr addr
,
4190 const char **symname
,
4193 bfd_vma dist
= 0x100000;
4194 Elf_Internal_Sym
*sym
, *best
= NULL
;
4197 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
4199 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4200 && sym
->st_name
!= 0
4201 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4202 && addr
.offset
>= sym
->st_value
4203 && addr
.offset
- sym
->st_value
< dist
)
4206 dist
= addr
.offset
- sym
->st_value
;
4213 *symname
= (best
->st_name
>= aux
->strtab_size
4214 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
4219 *offset
= addr
.offset
;
4223 dump_ia64_unwind (struct unw_aux_info
*aux
)
4226 struct unw_table_entry
*tp
;
4229 addr_size
= is_32bit_elf
? 4 : 8;
4231 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4235 const unsigned char *dp
;
4236 const unsigned char *head
;
4237 const char *procname
;
4239 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
4241 fputs ("\n<", stdout
);
4245 fputs (procname
, stdout
);
4248 printf ("+%lx", (unsigned long) offset
);
4251 fputs (">: [", stdout
);
4252 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4253 fputc ('-', stdout
);
4254 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4255 printf ("], info at +0x%lx\n",
4256 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4258 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4259 stamp
= BYTE_GET8 ((unsigned char *) head
);
4261 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4262 (unsigned) UNW_VER (stamp
),
4263 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4264 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4265 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4266 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4268 if (UNW_VER (stamp
) != 1)
4270 printf ("\tUnknown version.\n");
4275 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4276 dp
= unw_decode (dp
, in_body
, & in_body
);
4281 slurp_ia64_unwind_table (FILE *file
,
4282 struct unw_aux_info
*aux
,
4283 Elf_Internal_Shdr
*sec
)
4285 unsigned long size
, addr_size
, nrelas
, i
;
4286 Elf_Internal_Phdr
*seg
;
4287 struct unw_table_entry
*tep
;
4288 Elf_Internal_Shdr
*relsec
;
4289 Elf_Internal_Rela
*rela
, *rp
;
4290 unsigned char *table
, *tp
;
4291 Elf_Internal_Sym
*sym
;
4292 const char *relname
;
4294 addr_size
= is_32bit_elf
? 4 : 8;
4296 /* First, find the starting address of the segment that includes
4299 if (elf_header
.e_phnum
)
4301 if (! get_program_headers (file
))
4304 for (seg
= program_headers
;
4305 seg
< program_headers
+ elf_header
.e_phnum
;
4308 if (seg
->p_type
!= PT_LOAD
)
4311 if (sec
->sh_addr
>= seg
->p_vaddr
4312 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4314 aux
->seg_base
= seg
->p_vaddr
;
4320 /* Second, build the unwind table from the contents of the unwind section: */
4321 size
= sec
->sh_size
;
4322 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4326 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4327 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4329 tep
->start
.section
= SHN_UNDEF
;
4330 tep
->end
.section
= SHN_UNDEF
;
4331 tep
->info
.section
= SHN_UNDEF
;
4334 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4335 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4336 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4340 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4341 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4342 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4344 tep
->start
.offset
+= aux
->seg_base
;
4345 tep
->end
.offset
+= aux
->seg_base
;
4346 tep
->info
.offset
+= aux
->seg_base
;
4350 /* Third, apply any relocations to the unwind table: */
4352 for (relsec
= section_headers
;
4353 relsec
< section_headers
+ elf_header
.e_shnum
;
4356 if (relsec
->sh_type
!= SHT_RELA
4357 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4360 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4364 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4368 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4369 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4371 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4373 warn (_("Skipping unexpected symbol type %u\n"),
4374 ELF32_ST_TYPE (sym
->st_info
));
4380 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4381 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4383 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4385 warn (_("Skipping unexpected symbol type %u\n"),
4386 ELF64_ST_TYPE (sym
->st_info
));
4391 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4393 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4397 i
= rp
->r_offset
/ (3 * addr_size
);
4399 switch (rp
->r_offset
/addr_size
% 3)
4402 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4403 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4406 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4407 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4410 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4411 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4421 aux
->table_len
= size
/ (3 * addr_size
);
4426 process_unwind (FILE *file
)
4428 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4429 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4430 struct unw_aux_info aux
;
4435 if (elf_header
.e_machine
!= EM_IA_64
)
4437 printf (_("\nThere are no unwind sections in this file.\n"));
4441 memset (& aux
, 0, sizeof (aux
));
4443 addr_size
= is_32bit_elf
? 4 : 8;
4445 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4447 if (sec
->sh_type
== SHT_SYMTAB
)
4449 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4450 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4452 strsec
= SECTION_HEADER (sec
->sh_link
);
4453 aux
.strtab_size
= strsec
->sh_size
;
4454 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4455 aux
.strtab_size
, _("string table"));
4457 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4462 printf (_("\nThere are no unwind sections in this file.\n"));
4464 while (unwcount
-- > 0)
4469 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4470 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4471 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4478 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4480 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4482 /* We need to find which section group it is in. */
4483 struct group_list
*g
= section_headers_groups
[i
]->root
;
4485 for (; g
!= NULL
; g
= g
->next
)
4487 sec
= SECTION_HEADER (g
->section_index
);
4488 if (strcmp (SECTION_NAME (sec
),
4489 ELF_STRING_ia64_unwind_info
) == 0)
4494 i
= elf_header
.e_shnum
;
4496 else if (strncmp (SECTION_NAME (unwsec
),
4497 ELF_STRING_ia64_unwind_once
, len
) == 0)
4499 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4500 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4501 suffix
= SECTION_NAME (unwsec
) + len
;
4502 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4504 if (strncmp (SECTION_NAME (sec
),
4505 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4506 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4511 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4512 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4513 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4514 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4516 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4518 suffix
= SECTION_NAME (unwsec
) + len
;
4519 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4521 if (strncmp (SECTION_NAME (sec
),
4522 ELF_STRING_ia64_unwind_info
, len2
) == 0
4523 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4527 if (i
== elf_header
.e_shnum
)
4529 printf (_("\nCould not find unwind info section for "));
4531 if (string_table
== NULL
)
4532 printf ("%d", unwsec
->sh_name
);
4534 printf (_("'%s'"), SECTION_NAME (unwsec
));
4538 aux
.info_size
= sec
->sh_size
;
4539 aux
.info_addr
= sec
->sh_addr
;
4540 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4543 printf (_("\nUnwind section "));
4545 if (string_table
== NULL
)
4546 printf ("%d", unwsec
->sh_name
);
4548 printf (_("'%s'"), SECTION_NAME (unwsec
));
4550 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4551 (unsigned long) unwsec
->sh_offset
,
4552 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4554 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4556 if (aux
.table_len
> 0)
4557 dump_ia64_unwind (& aux
);
4560 free ((char *) aux
.table
);
4562 free ((char *) aux
.info
);
4571 free ((char *) aux
.strtab
);
4577 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
4579 switch (entry
->d_tag
)
4582 if (entry
->d_un
.d_val
== 0)
4586 static const char * opts
[] =
4588 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4589 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4590 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4591 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4596 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4597 if (entry
->d_un
.d_val
& (1 << cnt
))
4599 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4606 case DT_MIPS_IVERSION
:
4607 if (dynamic_strings
!= NULL
)
4608 printf ("Interface Version: %s\n",
4609 dynamic_strings
+ entry
->d_un
.d_val
);
4611 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4614 case DT_MIPS_TIME_STAMP
:
4619 time_t time
= entry
->d_un
.d_val
;
4620 tmp
= gmtime (&time
);
4621 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4622 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4623 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4624 printf ("Time Stamp: %s\n", timebuf
);
4628 case DT_MIPS_RLD_VERSION
:
4629 case DT_MIPS_LOCAL_GOTNO
:
4630 case DT_MIPS_CONFLICTNO
:
4631 case DT_MIPS_LIBLISTNO
:
4632 case DT_MIPS_SYMTABNO
:
4633 case DT_MIPS_UNREFEXTNO
:
4634 case DT_MIPS_HIPAGENO
:
4635 case DT_MIPS_DELTA_CLASS_NO
:
4636 case DT_MIPS_DELTA_INSTANCE_NO
:
4637 case DT_MIPS_DELTA_RELOC_NO
:
4638 case DT_MIPS_DELTA_SYM_NO
:
4639 case DT_MIPS_DELTA_CLASSSYM_NO
:
4640 case DT_MIPS_COMPACT_SIZE
:
4641 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4645 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4651 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
4653 switch (entry
->d_tag
)
4655 case DT_HP_DLD_FLAGS
:
4664 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4665 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4666 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4667 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4668 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4669 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4670 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4671 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4672 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4673 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4674 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4678 bfd_vma val
= entry
->d_un
.d_val
;
4680 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4681 if (val
& flags
[cnt
].bit
)
4685 fputs (flags
[cnt
].str
, stdout
);
4687 val
^= flags
[cnt
].bit
;
4690 if (val
!= 0 || first
)
4694 print_vma (val
, HEX
);
4700 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4707 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
4709 switch (entry
->d_tag
)
4711 case DT_IA_64_PLT_RESERVE
:
4712 /* First 3 slots reserved. */
4713 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4715 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
4719 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4726 get_32bit_dynamic_section (FILE *file
)
4728 Elf32_External_Dyn
*edyn
, *ext
;
4729 Elf_Internal_Dyn
*entry
;
4731 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4732 _("dynamic section"));
4736 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4737 might not have the luxury of section headers. Look for the DT_NULL
4738 terminator to determine the number of entries. */
4739 for (ext
= edyn
, dynamic_nent
= 0;
4740 (char *) ext
< (char *) edyn
+ dynamic_size
;
4744 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
4748 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4749 if (dynamic_section
== NULL
)
4751 error (_("Out of memory\n"));
4756 for (ext
= edyn
, entry
= dynamic_section
;
4757 entry
< dynamic_section
+ dynamic_nent
;
4760 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
4761 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
4770 get_64bit_dynamic_section (FILE *file
)
4772 Elf64_External_Dyn
*edyn
, *ext
;
4773 Elf_Internal_Dyn
*entry
;
4775 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4776 _("dynamic section"));
4780 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4781 might not have the luxury of section headers. Look for the DT_NULL
4782 terminator to determine the number of entries. */
4783 for (ext
= edyn
, dynamic_nent
= 0;
4784 (char *) ext
< (char *) edyn
+ dynamic_size
;
4788 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
4792 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4793 if (dynamic_section
== NULL
)
4795 error (_("Out of memory\n"));
4800 for (ext
= edyn
, entry
= dynamic_section
;
4801 entry
< dynamic_section
+ dynamic_nent
;
4804 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
4805 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
4814 get_dynamic_flags (bfd_vma flags
)
4816 static char buff
[128];
4824 flag
= flags
& - flags
;
4832 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4833 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4834 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4835 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4836 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4837 default: strcpy (p
, "unknown"); break;
4840 p
= strchr (p
, '\0');
4845 /* Parse and display the contents of the dynamic section. */
4848 process_dynamic_section (FILE *file
)
4850 Elf_Internal_Dyn
*entry
;
4852 if (dynamic_size
== 0)
4855 printf (_("\nThere is no dynamic section in this file.\n"));
4862 if (! get_32bit_dynamic_section (file
))
4865 else if (! get_64bit_dynamic_section (file
))
4868 /* Find the appropriate symbol table. */
4869 if (dynamic_symbols
== NULL
)
4871 for (entry
= dynamic_section
;
4872 entry
< dynamic_section
+ dynamic_nent
;
4875 Elf_Internal_Shdr section
;
4877 if (entry
->d_tag
!= DT_SYMTAB
)
4880 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4882 /* Since we do not know how big the symbol table is,
4883 we default to reading in the entire file (!) and
4884 processing that. This is overkill, I know, but it
4886 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4888 if (archive_file_offset
!= 0)
4889 section
.sh_size
= archive_file_size
- section
.sh_offset
;
4892 if (fseek (file
, 0, SEEK_END
))
4893 error (_("Unable to seek to end of file!"));
4895 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4899 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4901 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4903 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4904 if (num_dynamic_syms
< 1)
4906 error (_("Unable to determine the number of symbols to load\n"));
4910 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4914 /* Similarly find a string table. */
4915 if (dynamic_strings
== NULL
)
4917 for (entry
= dynamic_section
;
4918 entry
< dynamic_section
+ dynamic_nent
;
4921 unsigned long offset
;
4924 if (entry
->d_tag
!= DT_STRTAB
)
4927 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4929 /* Since we do not know how big the string table is,
4930 we default to reading in the entire file (!) and
4931 processing that. This is overkill, I know, but it
4934 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4936 if (archive_file_offset
!= 0)
4937 str_tab_len
= archive_file_size
- offset
;
4940 if (fseek (file
, 0, SEEK_END
))
4941 error (_("Unable to seek to end of file\n"));
4942 str_tab_len
= ftell (file
) - offset
;
4945 if (str_tab_len
< 1)
4948 (_("Unable to determine the length of the dynamic string table\n"));
4952 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
4953 _("dynamic string table"));
4958 /* And find the syminfo section if available. */
4959 if (dynamic_syminfo
== NULL
)
4961 unsigned long syminsz
= 0;
4963 for (entry
= dynamic_section
;
4964 entry
< dynamic_section
+ dynamic_nent
;
4967 if (entry
->d_tag
== DT_SYMINENT
)
4969 /* Note: these braces are necessary to avoid a syntax
4970 error from the SunOS4 C compiler. */
4971 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4973 else if (entry
->d_tag
== DT_SYMINSZ
)
4974 syminsz
= entry
->d_un
.d_val
;
4975 else if (entry
->d_tag
== DT_SYMINFO
)
4976 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
4980 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4982 Elf_External_Syminfo
*extsyminfo
, *extsym
;
4983 Elf_Internal_Syminfo
*syminfo
;
4985 /* There is a syminfo section. Read the data. */
4986 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
4987 _("symbol information"));
4991 dynamic_syminfo
= malloc (syminsz
);
4992 if (dynamic_syminfo
== NULL
)
4994 error (_("Out of memory\n"));
4998 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4999 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5000 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5001 ++syminfo
, ++extsym
)
5003 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5004 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5011 if (do_dynamic
&& dynamic_addr
)
5012 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5013 dynamic_addr
, dynamic_nent
);
5015 printf (_(" Tag Type Name/Value\n"));
5017 for (entry
= dynamic_section
;
5018 entry
< dynamic_section
+ dynamic_nent
;
5026 print_vma (entry
->d_tag
, FULL_HEX
);
5027 dtype
= get_dynamic_type (entry
->d_tag
);
5028 printf (" (%s)%*s", dtype
,
5029 ((is_32bit_elf
? 27 : 19)
5030 - (int) strlen (dtype
)),
5034 switch (entry
->d_tag
)
5038 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5048 switch (entry
->d_tag
)
5051 printf (_("Auxiliary library"));
5055 printf (_("Filter library"));
5059 printf (_("Configuration file"));
5063 printf (_("Dependency audit library"));
5067 printf (_("Audit library"));
5071 if (dynamic_strings
)
5072 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
5076 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5085 printf (_("Flags:"));
5087 if (entry
->d_un
.d_val
== 0)
5088 printf (_(" None\n"));
5091 unsigned long int val
= entry
->d_un
.d_val
;
5093 if (val
& DTF_1_PARINIT
)
5095 printf (" PARINIT");
5096 val
^= DTF_1_PARINIT
;
5098 if (val
& DTF_1_CONFEXP
)
5100 printf (" CONFEXP");
5101 val
^= DTF_1_CONFEXP
;
5104 printf (" %lx", val
);
5113 printf (_("Flags:"));
5115 if (entry
->d_un
.d_val
== 0)
5116 printf (_(" None\n"));
5119 unsigned long int val
= entry
->d_un
.d_val
;
5121 if (val
& DF_P1_LAZYLOAD
)
5123 printf (" LAZYLOAD");
5124 val
^= DF_P1_LAZYLOAD
;
5126 if (val
& DF_P1_GROUPPERM
)
5128 printf (" GROUPPERM");
5129 val
^= DF_P1_GROUPPERM
;
5132 printf (" %lx", val
);
5141 printf (_("Flags:"));
5142 if (entry
->d_un
.d_val
== 0)
5143 printf (_(" None\n"));
5146 unsigned long int val
= entry
->d_un
.d_val
;
5153 if (val
& DF_1_GLOBAL
)
5158 if (val
& DF_1_GROUP
)
5163 if (val
& DF_1_NODELETE
)
5165 printf (" NODELETE");
5166 val
^= DF_1_NODELETE
;
5168 if (val
& DF_1_LOADFLTR
)
5170 printf (" LOADFLTR");
5171 val
^= DF_1_LOADFLTR
;
5173 if (val
& DF_1_INITFIRST
)
5175 printf (" INITFIRST");
5176 val
^= DF_1_INITFIRST
;
5178 if (val
& DF_1_NOOPEN
)
5183 if (val
& DF_1_ORIGIN
)
5188 if (val
& DF_1_DIRECT
)
5193 if (val
& DF_1_TRANS
)
5198 if (val
& DF_1_INTERPOSE
)
5200 printf (" INTERPOSE");
5201 val
^= DF_1_INTERPOSE
;
5203 if (val
& DF_1_NODEFLIB
)
5205 printf (" NODEFLIB");
5206 val
^= DF_1_NODEFLIB
;
5208 if (val
& DF_1_NODUMP
)
5213 if (val
& DF_1_CONLFAT
)
5215 printf (" CONLFAT");
5216 val
^= DF_1_CONLFAT
;
5219 printf (" %lx", val
);
5226 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5228 puts (get_dynamic_type (entry
->d_un
.d_val
));
5248 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5254 if (dynamic_strings
== NULL
)
5257 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5261 switch (entry
->d_tag
)
5264 printf (_("Shared library: [%s]"), name
);
5266 if (strcmp (name
, program_interpreter
) == 0)
5267 printf (_(" program interpreter"));
5271 printf (_("Library soname: [%s]"), name
);
5275 printf (_("Library rpath: [%s]"), name
);
5279 printf (_("Library runpath: [%s]"), name
);
5283 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5288 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5301 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5305 case DT_INIT_ARRAYSZ
:
5306 case DT_FINI_ARRAYSZ
:
5307 case DT_GNU_CONFLICTSZ
:
5308 case DT_GNU_LIBLISTSZ
:
5311 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5312 printf (" (bytes)\n");
5322 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5335 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
5339 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5343 printf (_("Not needed object: [%s]\n"), name
);
5348 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5354 /* The value of this entry is ignored. */
5359 case DT_GNU_PRELINKED
:
5363 time_t time
= entry
->d_un
.d_val
;
5365 tmp
= gmtime (&time
);
5366 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5367 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5368 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5374 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5375 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5380 switch (elf_header
.e_machine
)
5383 case EM_MIPS_RS3_LE
:
5384 dynamic_section_mips_val (entry
);
5387 dynamic_section_parisc_val (entry
);
5390 dynamic_section_ia64_val (entry
);
5393 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5405 get_ver_flags (unsigned int flags
)
5407 static char buff
[32];
5414 if (flags
& VER_FLG_BASE
)
5415 strcat (buff
, "BASE ");
5417 if (flags
& VER_FLG_WEAK
)
5419 if (flags
& VER_FLG_BASE
)
5420 strcat (buff
, "| ");
5422 strcat (buff
, "WEAK ");
5425 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5426 strcat (buff
, "| <unknown>");
5431 /* Display the contents of the version sections. */
5433 process_version_sections (FILE *file
)
5435 Elf_Internal_Shdr
*section
;
5442 for (i
= 0, section
= section_headers
;
5443 i
< elf_header
.e_shnum
;
5446 switch (section
->sh_type
)
5448 case SHT_GNU_verdef
:
5450 Elf_External_Verdef
*edefs
;
5457 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5458 SECTION_NAME (section
), section
->sh_info
);
5460 printf (_(" Addr: 0x"));
5461 printf_vma (section
->sh_addr
);
5462 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5463 (unsigned long) section
->sh_offset
, section
->sh_link
,
5464 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5466 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5467 _("version definition section"));
5471 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5474 Elf_External_Verdef
*edef
;
5475 Elf_Internal_Verdef ent
;
5476 Elf_External_Verdaux
*eaux
;
5477 Elf_Internal_Verdaux aux
;
5481 vstart
= ((char *) edefs
) + idx
;
5483 edef
= (Elf_External_Verdef
*) vstart
;
5485 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5486 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5487 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5488 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5489 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5490 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5491 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5493 printf (_(" %#06x: Rev: %d Flags: %s"),
5494 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5496 printf (_(" Index: %d Cnt: %d "),
5497 ent
.vd_ndx
, ent
.vd_cnt
);
5499 vstart
+= ent
.vd_aux
;
5501 eaux
= (Elf_External_Verdaux
*) vstart
;
5503 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5504 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5506 if (dynamic_strings
)
5507 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5509 printf (_("Name index: %ld\n"), aux
.vda_name
);
5511 isum
= idx
+ ent
.vd_aux
;
5513 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5515 isum
+= aux
.vda_next
;
5516 vstart
+= aux
.vda_next
;
5518 eaux
= (Elf_External_Verdaux
*) vstart
;
5520 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5521 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5523 if (dynamic_strings
)
5524 printf (_(" %#06x: Parent %d: %s\n"),
5525 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5527 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5528 isum
, j
, aux
.vda_name
);
5538 case SHT_GNU_verneed
:
5540 Elf_External_Verneed
*eneed
;
5546 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5547 SECTION_NAME (section
), section
->sh_info
);
5549 printf (_(" Addr: 0x"));
5550 printf_vma (section
->sh_addr
);
5551 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5552 (unsigned long) section
->sh_offset
, section
->sh_link
,
5553 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5555 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5556 _("version need section"));
5560 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5562 Elf_External_Verneed
*entry
;
5563 Elf_Internal_Verneed ent
;
5568 vstart
= ((char *) eneed
) + idx
;
5570 entry
= (Elf_External_Verneed
*) vstart
;
5572 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5573 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5574 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5575 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5576 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5578 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5580 if (dynamic_strings
)
5581 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5583 printf (_(" File: %lx"), ent
.vn_file
);
5585 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5587 vstart
+= ent
.vn_aux
;
5589 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5591 Elf_External_Vernaux
*eaux
;
5592 Elf_Internal_Vernaux aux
;
5594 eaux
= (Elf_External_Vernaux
*) vstart
;
5596 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5597 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5598 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5599 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5600 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5602 if (dynamic_strings
)
5603 printf (_(" %#06x: Name: %s"),
5604 isum
, dynamic_strings
+ aux
.vna_name
);
5606 printf (_(" %#06x: Name index: %lx"),
5607 isum
, aux
.vna_name
);
5609 printf (_(" Flags: %s Version: %d\n"),
5610 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5612 isum
+= aux
.vna_next
;
5613 vstart
+= aux
.vna_next
;
5623 case SHT_GNU_versym
:
5625 Elf_Internal_Shdr
*link_section
;
5628 unsigned char *edata
;
5629 unsigned short *data
;
5631 Elf_Internal_Sym
*symbols
;
5632 Elf_Internal_Shdr
*string_sec
;
5635 link_section
= SECTION_HEADER (section
->sh_link
);
5636 total
= section
->sh_size
/ section
->sh_entsize
;
5640 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5642 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5644 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5645 string_sec
->sh_size
, _("version string table"));
5649 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5650 SECTION_NAME (section
), total
);
5652 printf (_(" Addr: "));
5653 printf_vma (section
->sh_addr
);
5654 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5655 (unsigned long) section
->sh_offset
, section
->sh_link
,
5656 SECTION_NAME (link_section
));
5658 off
= offset_from_vma (file
,
5659 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5660 total
* sizeof (short));
5661 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
5662 _("version symbol data"));
5669 data
= malloc (total
* sizeof (short));
5671 for (cnt
= total
; cnt
--;)
5672 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5677 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5680 int check_def
, check_need
;
5683 printf (" %03x:", cnt
);
5685 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5686 switch (data
[cnt
+ j
])
5689 fputs (_(" 0 (*local*) "), stdout
);
5693 fputs (_(" 1 (*global*) "), stdout
);
5697 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5698 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5702 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5705 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5712 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5714 Elf_Internal_Verneed ivn
;
5715 unsigned long offset
;
5717 offset
= offset_from_vma
5718 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5719 sizeof (Elf_External_Verneed
));
5723 Elf_Internal_Vernaux ivna
;
5724 Elf_External_Verneed evn
;
5725 Elf_External_Vernaux evna
;
5726 unsigned long a_off
;
5728 get_data (&evn
, file
, offset
, sizeof (evn
),
5731 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5732 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5734 a_off
= offset
+ ivn
.vn_aux
;
5738 get_data (&evna
, file
, a_off
, sizeof (evna
),
5739 _("version need aux (2)"));
5741 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5742 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5744 a_off
+= ivna
.vna_next
;
5746 while (ivna
.vna_other
!= data
[cnt
+ j
]
5747 && ivna
.vna_next
!= 0);
5749 if (ivna
.vna_other
== data
[cnt
+ j
])
5751 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5753 name
= strtab
+ ivna
.vna_name
;
5754 nn
+= printf ("(%s%-*s",
5756 12 - (int) strlen (name
),
5762 offset
+= ivn
.vn_next
;
5764 while (ivn
.vn_next
);
5767 if (check_def
&& data
[cnt
+ j
] != 0x8001
5768 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5770 Elf_Internal_Verdef ivd
;
5771 Elf_External_Verdef evd
;
5772 unsigned long offset
;
5774 offset
= offset_from_vma
5775 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5780 get_data (&evd
, file
, offset
, sizeof (evd
),
5783 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5784 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5786 offset
+= ivd
.vd_next
;
5788 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5789 && ivd
.vd_next
!= 0);
5791 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5793 Elf_External_Verdaux evda
;
5794 Elf_Internal_Verdaux ivda
;
5796 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5798 get_data (&evda
, file
,
5799 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5800 sizeof (evda
), _("version def aux"));
5802 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5804 name
= strtab
+ ivda
.vda_name
;
5805 nn
+= printf ("(%s%-*s",
5807 12 - (int) strlen (name
),
5813 printf ("%*c", 18 - nn
, ' ');
5831 printf (_("\nNo version information found in this file.\n"));
5837 get_symbol_binding (unsigned int binding
)
5839 static char buff
[32];
5843 case STB_LOCAL
: return "LOCAL";
5844 case STB_GLOBAL
: return "GLOBAL";
5845 case STB_WEAK
: return "WEAK";
5847 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5848 sprintf (buff
, _("<processor specific>: %d"), binding
);
5849 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5850 sprintf (buff
, _("<OS specific>: %d"), binding
);
5852 sprintf (buff
, _("<unknown>: %d"), binding
);
5858 get_symbol_type (unsigned int type
)
5860 static char buff
[32];
5864 case STT_NOTYPE
: return "NOTYPE";
5865 case STT_OBJECT
: return "OBJECT";
5866 case STT_FUNC
: return "FUNC";
5867 case STT_SECTION
: return "SECTION";
5868 case STT_FILE
: return "FILE";
5869 case STT_COMMON
: return "COMMON";
5870 case STT_TLS
: return "TLS";
5872 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5874 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5875 return "THUMB_FUNC";
5877 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5880 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5881 return "PARISC_MILLI";
5883 sprintf (buff
, _("<processor specific>: %d"), type
);
5885 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5887 if (elf_header
.e_machine
== EM_PARISC
)
5889 if (type
== STT_HP_OPAQUE
)
5891 if (type
== STT_HP_STUB
)
5895 sprintf (buff
, _("<OS specific>: %d"), type
);
5898 sprintf (buff
, _("<unknown>: %d"), type
);
5904 get_symbol_visibility (unsigned int visibility
)
5908 case STV_DEFAULT
: return "DEFAULT";
5909 case STV_INTERNAL
: return "INTERNAL";
5910 case STV_HIDDEN
: return "HIDDEN";
5911 case STV_PROTECTED
: return "PROTECTED";
5917 get_symbol_index_type (unsigned int type
)
5919 static char buff
[32];
5923 case SHN_UNDEF
: return "UND";
5924 case SHN_ABS
: return "ABS";
5925 case SHN_COMMON
: return "COM";
5927 if (type
== SHN_IA_64_ANSI_COMMON
5928 && elf_header
.e_machine
== EM_IA_64
5929 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
5931 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5932 sprintf (buff
, "PRC[0x%04x]", type
);
5933 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5934 sprintf (buff
, "OS [0x%04x]", type
);
5935 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5936 sprintf (buff
, "RSV[0x%04x]", type
);
5938 sprintf (buff
, "%3d", type
);
5946 get_dynamic_data (FILE *file
, unsigned int number
)
5948 unsigned char *e_data
;
5951 e_data
= malloc (number
* 4);
5955 error (_("Out of memory\n"));
5959 if (fread (e_data
, 4, number
, file
) != number
)
5961 error (_("Unable to read in dynamic data\n"));
5965 i_data
= malloc (number
* sizeof (*i_data
));
5969 error (_("Out of memory\n"));
5975 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5982 /* Dump the symbol table. */
5984 process_symbol_table (FILE *file
)
5986 Elf_Internal_Shdr
*section
;
5987 unsigned char nb
[4];
5988 unsigned char nc
[4];
5991 int *buckets
= NULL
;
5994 if (! do_syms
&& !do_histogram
)
5997 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6001 (archive_file_offset
6002 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6003 sizeof nb
+ sizeof nc
)),
6006 error (_("Unable to seek to start of dynamic information"));
6010 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
6012 error (_("Failed to read in number of buckets\n"));
6016 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
6018 error (_("Failed to read in number of chains\n"));
6022 nbuckets
= byte_get (nb
, 4);
6023 nchains
= byte_get (nc
, 4);
6025 buckets
= get_dynamic_data (file
, nbuckets
);
6026 chains
= get_dynamic_data (file
, nchains
);
6028 if (buckets
== NULL
|| chains
== NULL
)
6033 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6038 printf (_("\nSymbol table for image:\n"));
6040 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6042 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6044 for (hn
= 0; hn
< nbuckets
; hn
++)
6049 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6051 Elf_Internal_Sym
*psym
;
6053 psym
= dynamic_symbols
+ si
;
6055 printf (" %3d %3d: ", si
, hn
);
6056 print_vma (psym
->st_value
, LONG_HEX
);
6058 print_vma (psym
->st_size
, DEC_5
);
6060 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6061 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6062 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6063 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6064 print_symbol (25, dynamic_strings
+ psym
->st_name
);
6069 else if (do_syms
&& !do_using_dynamic
)
6073 for (i
= 0, section
= section_headers
;
6074 i
< elf_header
.e_shnum
;
6079 Elf_Internal_Sym
*symtab
;
6080 Elf_Internal_Sym
*psym
;
6083 if ( section
->sh_type
!= SHT_SYMTAB
6084 && section
->sh_type
!= SHT_DYNSYM
)
6087 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6088 SECTION_NAME (section
),
6089 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6091 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6093 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6095 symtab
= GET_ELF_SYMBOLS (file
, section
);
6099 if (section
->sh_link
== elf_header
.e_shstrndx
)
6100 strtab
= string_table
;
6103 Elf_Internal_Shdr
*string_sec
;
6105 string_sec
= SECTION_HEADER (section
->sh_link
);
6107 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6108 string_sec
->sh_size
, _("string table"));
6111 for (si
= 0, psym
= symtab
;
6112 si
< section
->sh_size
/ section
->sh_entsize
;
6115 printf ("%6d: ", si
);
6116 print_vma (psym
->st_value
, LONG_HEX
);
6118 print_vma (psym
->st_size
, DEC_5
);
6119 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6120 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6121 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6122 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6123 print_symbol (25, strtab
+ psym
->st_name
);
6125 if (section
->sh_type
== SHT_DYNSYM
&&
6126 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6128 unsigned char data
[2];
6129 unsigned short vers_data
;
6130 unsigned long offset
;
6134 offset
= offset_from_vma
6135 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6136 sizeof data
+ si
* sizeof (vers_data
));
6138 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6139 sizeof (data
), _("version data"));
6141 vers_data
= byte_get (data
, 2);
6143 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6146 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6148 if ((vers_data
& 0x8000) || vers_data
> 1)
6150 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6151 && (is_nobits
|| ! check_def
))
6153 Elf_External_Verneed evn
;
6154 Elf_Internal_Verneed ivn
;
6155 Elf_Internal_Vernaux ivna
;
6157 /* We must test both. */
6158 offset
= offset_from_vma
6159 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6164 unsigned long vna_off
;
6166 get_data (&evn
, file
, offset
, sizeof (evn
),
6169 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6170 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6172 vna_off
= offset
+ ivn
.vn_aux
;
6176 Elf_External_Vernaux evna
;
6178 get_data (&evna
, file
, vna_off
,
6180 _("version need aux (3)"));
6182 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6183 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6184 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6186 vna_off
+= ivna
.vna_next
;
6188 while (ivna
.vna_other
!= vers_data
6189 && ivna
.vna_next
!= 0);
6191 if (ivna
.vna_other
== vers_data
)
6194 offset
+= ivn
.vn_next
;
6196 while (ivn
.vn_next
!= 0);
6198 if (ivna
.vna_other
== vers_data
)
6201 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6204 else if (! is_nobits
)
6205 error (_("bad dynamic symbol"));
6212 if (vers_data
!= 0x8001
6213 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6215 Elf_Internal_Verdef ivd
;
6216 Elf_Internal_Verdaux ivda
;
6217 Elf_External_Verdaux evda
;
6218 unsigned long offset
;
6220 offset
= offset_from_vma
6222 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6223 sizeof (Elf_External_Verdef
));
6227 Elf_External_Verdef evd
;
6229 get_data (&evd
, file
, offset
, sizeof (evd
),
6232 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6233 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6234 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6236 offset
+= ivd
.vd_next
;
6238 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6239 && ivd
.vd_next
!= 0);
6241 offset
-= ivd
.vd_next
;
6242 offset
+= ivd
.vd_aux
;
6244 get_data (&evda
, file
, offset
, sizeof (evda
),
6245 _("version def aux"));
6247 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6249 if (psym
->st_name
!= ivda
.vda_name
)
6250 printf ((vers_data
& 0x8000)
6252 strtab
+ ivda
.vda_name
);
6262 if (strtab
!= string_table
)
6268 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6270 if (do_histogram
&& buckets
!= NULL
)
6277 int nzero_counts
= 0;
6280 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6282 printf (_(" Length Number %% of total Coverage\n"));
6284 lengths
= calloc (nbuckets
, sizeof (int));
6285 if (lengths
== NULL
)
6287 error (_("Out of memory"));
6290 for (hn
= 0; hn
< nbuckets
; ++hn
)
6295 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6298 if (maxlength
< ++lengths
[hn
])
6303 counts
= calloc (maxlength
+ 1, sizeof (int));
6306 error (_("Out of memory"));
6310 for (hn
= 0; hn
< nbuckets
; ++hn
)
6311 ++counts
[lengths
[hn
]];
6315 printf (" 0 %-10d (%5.1f%%)\n",
6316 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6317 for (si
= 1; si
<= maxlength
; ++si
)
6319 nzero_counts
+= counts
[si
] * si
;
6320 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6321 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6322 (nzero_counts
* 100.0) / nsyms
);
6330 if (buckets
!= NULL
)
6340 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6344 if (dynamic_syminfo
== NULL
6346 /* No syminfo, this is ok. */
6349 /* There better should be a dynamic symbol section. */
6350 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6354 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6355 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6357 printf (_(" Num: Name BoundTo Flags\n"));
6358 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6360 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6362 printf ("%4d: ", i
);
6363 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
6366 switch (dynamic_syminfo
[i
].si_boundto
)
6368 case SYMINFO_BT_SELF
:
6369 fputs ("SELF ", stdout
);
6371 case SYMINFO_BT_PARENT
:
6372 fputs ("PARENT ", stdout
);
6375 if (dynamic_syminfo
[i
].si_boundto
> 0
6376 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
)
6381 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6385 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6389 if (flags
& SYMINFO_FLG_DIRECT
)
6391 if (flags
& SYMINFO_FLG_PASSTHRU
)
6392 printf (" PASSTHRU");
6393 if (flags
& SYMINFO_FLG_COPY
)
6395 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6396 printf (" LAZYLOAD");
6404 #ifdef SUPPORT_DISASSEMBLY
6406 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6408 printf (_("\nAssembly dump of section %s\n"),
6409 SECTION_NAME (section
));
6411 /* XXX -- to be done --- XXX */
6418 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6420 bfd_size_type bytes
;
6422 unsigned char *data
;
6423 unsigned char *start
;
6425 bytes
= section
->sh_size
;
6427 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6429 printf (_("\nSection '%s' has no data to dump.\n"),
6430 SECTION_NAME (section
));
6434 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6436 addr
= section
->sh_addr
;
6438 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6450 lbytes
= (bytes
> 16 ? 16 : bytes
);
6452 printf (" 0x%8.8lx ", (unsigned long) addr
);
6454 switch (elf_header
.e_ident
[EI_DATA
])
6458 for (j
= 15; j
>= 0; j
--)
6461 printf ("%2.2x", data
[j
]);
6471 for (j
= 0; j
< 16; j
++)
6474 printf ("%2.2x", data
[j
]);
6484 for (j
= 0; j
< lbytes
; j
++)
6487 if (k
>= ' ' && k
< 0x7f)
6506 static unsigned long int
6507 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6509 unsigned long int result
= 0;
6510 unsigned int num_read
= 0;
6519 result
|= (byte
& 0x7f) << shift
;
6524 while (byte
& 0x80);
6526 if (length_return
!= NULL
)
6527 *length_return
= num_read
;
6529 if (sign
&& (shift
< 32) && (byte
& 0x40))
6530 result
|= -1 << shift
;
6535 typedef struct State_Machine_Registers
6537 unsigned long address
;
6540 unsigned int column
;
6544 /* This variable hold the number of the last entry seen
6545 in the File Table. */
6546 unsigned int last_file_entry
;
6549 static SMR state_machine_regs
;
6552 reset_state_machine (int is_stmt
)
6554 state_machine_regs
.address
= 0;
6555 state_machine_regs
.file
= 1;
6556 state_machine_regs
.line
= 1;
6557 state_machine_regs
.column
= 0;
6558 state_machine_regs
.is_stmt
= is_stmt
;
6559 state_machine_regs
.basic_block
= 0;
6560 state_machine_regs
.end_sequence
= 0;
6561 state_machine_regs
.last_file_entry
= 0;
6564 /* Handled an extend line op. Returns true if this is the end
6567 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6569 unsigned char op_code
;
6572 unsigned char *name
;
6575 len
= read_leb128 (data
, & bytes_read
, 0);
6580 warn (_("badly formed extended line op encountered!\n"));
6587 printf (_(" Extended opcode %d: "), op_code
);
6591 case DW_LNE_end_sequence
:
6592 printf (_("End of Sequence\n\n"));
6593 reset_state_machine (is_stmt
);
6596 case DW_LNE_set_address
:
6597 adr
= byte_get (data
, pointer_size
);
6598 printf (_("set Address to 0x%lx\n"), adr
);
6599 state_machine_regs
.address
= adr
;
6602 case DW_LNE_define_file
:
6603 printf (_(" define new File Table entry\n"));
6604 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6606 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6608 data
+= strlen ((char *) data
) + 1;
6609 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6611 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6613 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6614 printf (_("%s\n\n"), name
);
6618 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6625 /* Finds section NAME inside FILE and returns a
6626 pointer to it, or NULL upon failure. */
6628 static Elf_Internal_Shdr
*
6629 find_section (const char * name
)
6631 Elf_Internal_Shdr
*sec
;
6634 for (i
= elf_header
.e_shnum
, sec
= section_headers
+ i
- 1;
6636 if (strcmp (SECTION_NAME (sec
), name
) == 0)
6639 if (i
&& sec
&& sec
->sh_size
!= 0)
6645 /* Size of pointers in the .debug_line section. This information is not
6646 really present in that section. It's obtained before dumping the debug
6647 sections by doing some pre-scan of the .debug_info section. */
6648 static unsigned int * debug_line_pointer_sizes
= NULL
;
6649 static unsigned int num_debug_line_pointer_sizes
= 0;
6651 /* Locate and scan the .debug_info section in the file and record the pointer
6652 sizes for the compilation units in it. Usually an executable will have
6653 just one pointer size, but this is not guaranteed, and so we try not to
6654 make any assumptions. Returns zero upon failure, or the number of
6655 compilation units upon success. */
6658 get_debug_line_pointer_sizes (FILE * file
)
6660 Elf_Internal_Shdr
* section
;
6661 unsigned char * start
;
6662 unsigned char * end
;
6663 unsigned char * begin
;
6664 unsigned long length
;
6665 unsigned int num_units
;
6668 section
= find_section (".debug_info");
6669 if (section
== NULL
)
6672 length
= section
->sh_size
;
6673 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6674 _("extracting pointer sizes from .debug_info section"));
6678 end
= start
+ section
->sh_size
;
6679 /* First scan the section to get the number of comp units. */
6680 for (begin
= start
, num_units
= 0; begin
< end
; num_units
++)
6682 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
6683 be the length. For a 64-bit DWARF section, it'll be the escape
6684 code 0xffffffff followed by an 8 byte length. */
6685 length
= byte_get (begin
, 4);
6687 if (length
== 0xffffffff)
6689 length
= byte_get (begin
+ 4, 8);
6690 begin
+= length
+ 12;
6693 begin
+= length
+ 4;
6698 error (_("No comp units in .debug_info section ?"));
6703 /* Then allocate an array to hold the pointer sizes. */
6704 debug_line_pointer_sizes
= malloc (num_units
* sizeof * debug_line_pointer_sizes
);
6705 if (debug_line_pointer_sizes
== NULL
)
6707 error (_("Not enough memory for a pointer size array of %u entries"),
6713 /* Populate the array. */
6714 for (begin
= start
, unit
= 0; begin
< end
; unit
++)
6716 length
= byte_get (begin
, 4);
6717 if (length
== 0xffffffff)
6719 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
6720 from the start of the section. This is computed as follows:
6722 unit_length: 12 bytes
6724 debug_abbrev_offset: 8 bytes
6725 -----------------------------
6728 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 22, 1);
6729 length
= byte_get (begin
+ 4, 8);
6730 begin
+= length
+ 12;
6734 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
6735 the start of the section:
6737 unit_length: 4 bytes
6739 debug_abbrev_offset: 4 bytes
6740 -----------------------------
6743 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 10, 1);
6744 begin
+= length
+ 4;
6749 num_debug_line_pointer_sizes
= num_units
;
6754 display_debug_lines (Elf_Internal_Shdr
*section
,
6755 unsigned char *start
, FILE *file
)
6757 unsigned char *hdrptr
;
6758 DWARF2_Internal_LineInfo info
;
6759 unsigned char *standard_opcodes
;
6760 unsigned char *data
= start
;
6761 unsigned char *end
= start
+ section
->sh_size
;
6762 unsigned char *end_of_sequence
;
6765 int initial_length_size
;
6766 unsigned int comp_unit
= 0;
6768 printf (_("\nDump of debug contents of section %s:\n\n"),
6769 SECTION_NAME (section
));
6771 if (num_debug_line_pointer_sizes
== 0)
6772 get_debug_line_pointer_sizes (file
);
6776 unsigned int pointer_size
;
6780 /* Check the length of the block. */
6781 info
.li_length
= byte_get (hdrptr
, 4);
6784 if (info
.li_length
== 0xffffffff)
6786 /* This section is 64-bit DWARF 3. */
6787 info
.li_length
= byte_get (hdrptr
, 8);
6790 initial_length_size
= 12;
6795 initial_length_size
= 4;
6798 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
6801 (_("The line info appears to be corrupt - the section is too small\n"));
6805 /* Check its version number. */
6806 info
.li_version
= byte_get (hdrptr
, 2);
6808 if (info
.li_version
!= 2 && info
.li_version
!= 3)
6810 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6814 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
6815 hdrptr
+= offset_size
;
6816 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
6818 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
6820 info
.li_line_base
= byte_get (hdrptr
, 1);
6822 info
.li_line_range
= byte_get (hdrptr
, 1);
6824 info
.li_opcode_base
= byte_get (hdrptr
, 1);
6827 /* Sign extend the line base field. */
6828 info
.li_line_base
<<= 24;
6829 info
.li_line_base
>>= 24;
6831 /* Get the pointer size from the comp unit associated
6832 with this block of line number information. */
6833 if (comp_unit
>= num_debug_line_pointer_sizes
)
6835 error (_("Not enough comp units for .debug_lines section\n"));
6840 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
6844 printf (_(" Length: %ld\n"), info
.li_length
);
6845 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6846 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6847 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6848 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6849 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6850 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6851 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6852 printf (_(" (Pointer size: %u)\n"), pointer_size
);
6854 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
6856 reset_state_machine (info
.li_default_is_stmt
);
6858 /* Display the contents of the Opcodes table. */
6859 standard_opcodes
= hdrptr
;
6861 printf (_("\n Opcodes:\n"));
6863 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6864 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6866 /* Display the contents of the Directory table. */
6867 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6870 printf (_("\n The Directory Table is empty.\n"));
6873 printf (_("\n The Directory Table:\n"));
6877 printf (_(" %s\n"), data
);
6879 data
+= strlen ((char *) data
) + 1;
6883 /* Skip the NUL at the end of the table. */
6886 /* Display the contents of the File Name table. */
6888 printf (_("\n The File Name Table is empty.\n"));
6891 printf (_("\n The File Name Table:\n"));
6892 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6896 unsigned char *name
;
6899 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6902 data
+= strlen ((char *) data
) + 1;
6904 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6906 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6908 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6910 printf (_("%s\n"), name
);
6914 /* Skip the NUL at the end of the table. */
6917 /* Now display the statements. */
6918 printf (_("\n Line Number Statements:\n"));
6921 while (data
< end_of_sequence
)
6923 unsigned char op_code
;
6929 if (op_code
>= info
.li_opcode_base
)
6931 op_code
-= info
.li_opcode_base
;
6932 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6933 state_machine_regs
.address
+= adv
;
6934 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6935 op_code
, adv
, state_machine_regs
.address
);
6936 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6937 state_machine_regs
.line
+= adv
;
6938 printf (_(" and Line by %d to %d\n"),
6939 adv
, state_machine_regs
.line
);
6941 else switch (op_code
)
6943 case DW_LNS_extended_op
:
6944 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6949 printf (_(" Copy\n"));
6952 case DW_LNS_advance_pc
:
6953 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6955 state_machine_regs
.address
+= adv
;
6956 printf (_(" Advance PC by %d to %lx\n"), adv
,
6957 state_machine_regs
.address
);
6960 case DW_LNS_advance_line
:
6961 adv
= read_leb128 (data
, & bytes_read
, 1);
6963 state_machine_regs
.line
+= adv
;
6964 printf (_(" Advance Line by %d to %d\n"), adv
,
6965 state_machine_regs
.line
);
6968 case DW_LNS_set_file
:
6969 adv
= read_leb128 (data
, & bytes_read
, 0);
6971 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6973 state_machine_regs
.file
= adv
;
6976 case DW_LNS_set_column
:
6977 adv
= read_leb128 (data
, & bytes_read
, 0);
6979 printf (_(" Set column to %d\n"), adv
);
6980 state_machine_regs
.column
= adv
;
6983 case DW_LNS_negate_stmt
:
6984 adv
= state_machine_regs
.is_stmt
;
6986 printf (_(" Set is_stmt to %d\n"), adv
);
6987 state_machine_regs
.is_stmt
= adv
;
6990 case DW_LNS_set_basic_block
:
6991 printf (_(" Set basic block\n"));
6992 state_machine_regs
.basic_block
= 1;
6995 case DW_LNS_const_add_pc
:
6996 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6997 * info
.li_min_insn_length
);
6998 state_machine_regs
.address
+= adv
;
6999 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
7000 state_machine_regs
.address
);
7003 case DW_LNS_fixed_advance_pc
:
7004 adv
= byte_get (data
, 2);
7006 state_machine_regs
.address
+= adv
;
7007 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
7008 adv
, state_machine_regs
.address
);
7011 case DW_LNS_set_prologue_end
:
7012 printf (_(" Set prologue_end to true\n"));
7015 case DW_LNS_set_epilogue_begin
:
7016 printf (_(" Set epilogue_begin to true\n"));
7019 case DW_LNS_set_isa
:
7020 adv
= read_leb128 (data
, & bytes_read
, 0);
7022 printf (_(" Set ISA to %d\n"), adv
);
7026 printf (_(" Unknown opcode %d with operands: "), op_code
);
7029 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
7031 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
7032 i
== 1 ? "" : ", ");
7047 display_debug_pubnames (Elf_Internal_Shdr
*section
,
7048 unsigned char *start
,
7049 FILE *file ATTRIBUTE_UNUSED
)
7051 DWARF2_Internal_PubNames pubnames
;
7054 end
= start
+ section
->sh_size
;
7056 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7060 unsigned char *data
;
7061 unsigned long offset
;
7062 int offset_size
, initial_length_size
;
7066 pubnames
.pn_length
= byte_get (data
, 4);
7068 if (pubnames
.pn_length
== 0xffffffff)
7070 pubnames
.pn_length
= byte_get (data
, 8);
7073 initial_length_size
= 12;
7078 initial_length_size
= 4;
7081 pubnames
.pn_version
= byte_get (data
, 2);
7083 pubnames
.pn_offset
= byte_get (data
, offset_size
);
7084 data
+= offset_size
;
7085 pubnames
.pn_size
= byte_get (data
, offset_size
);
7086 data
+= offset_size
;
7088 start
+= pubnames
.pn_length
+ initial_length_size
;
7090 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
7092 static int warned
= 0;
7096 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
7103 printf (_(" Length: %ld\n"),
7104 pubnames
.pn_length
);
7105 printf (_(" Version: %d\n"),
7106 pubnames
.pn_version
);
7107 printf (_(" Offset into .debug_info section: %ld\n"),
7108 pubnames
.pn_offset
);
7109 printf (_(" Size of area in .debug_info section: %ld\n"),
7112 printf (_("\n Offset\tName\n"));
7116 offset
= byte_get (data
, offset_size
);
7120 data
+= offset_size
;
7121 printf (" %-6ld\t\t%s\n", offset
, data
);
7122 data
+= strlen ((char *) data
) + 1;
7125 while (offset
!= 0);
7133 get_TAG_name (unsigned long tag
)
7137 case DW_TAG_padding
: return "DW_TAG_padding";
7138 case DW_TAG_array_type
: return "DW_TAG_array_type";
7139 case DW_TAG_class_type
: return "DW_TAG_class_type";
7140 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7141 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7142 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7143 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7144 case DW_TAG_label
: return "DW_TAG_label";
7145 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7146 case DW_TAG_member
: return "DW_TAG_member";
7147 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7148 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7149 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7150 case DW_TAG_string_type
: return "DW_TAG_string_type";
7151 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7152 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7153 case DW_TAG_typedef
: return "DW_TAG_typedef";
7154 case DW_TAG_union_type
: return "DW_TAG_union_type";
7155 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7156 case DW_TAG_variant
: return "DW_TAG_variant";
7157 case DW_TAG_common_block
: return "DW_TAG_common_block";
7158 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7159 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7160 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7161 case DW_TAG_module
: return "DW_TAG_module";
7162 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7163 case DW_TAG_set_type
: return "DW_TAG_set_type";
7164 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7165 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7166 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7167 case DW_TAG_base_type
: return "DW_TAG_base_type";
7168 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7169 case DW_TAG_const_type
: return "DW_TAG_const_type";
7170 case DW_TAG_constant
: return "DW_TAG_constant";
7171 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7172 case DW_TAG_file_type
: return "DW_TAG_file_type";
7173 case DW_TAG_friend
: return "DW_TAG_friend";
7174 case DW_TAG_namelist
: return "DW_TAG_namelist";
7175 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7176 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7177 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7178 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7179 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7180 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7181 case DW_TAG_try_block
: return "DW_TAG_try_block";
7182 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7183 case DW_TAG_variable
: return "DW_TAG_variable";
7184 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7185 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7186 case DW_TAG_format_label
: return "DW_TAG_format_label";
7187 case DW_TAG_function_template
: return "DW_TAG_function_template";
7188 case DW_TAG_class_template
: return "DW_TAG_class_template";
7189 /* DWARF 2.1 values. */
7190 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7191 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7192 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7193 case DW_TAG_namespace
: return "DW_TAG_namespace";
7194 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7195 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7196 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7197 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7199 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7200 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7201 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7204 static char buffer
[100];
7206 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7213 get_AT_name (unsigned long attribute
)
7217 case DW_AT_sibling
: return "DW_AT_sibling";
7218 case DW_AT_location
: return "DW_AT_location";
7219 case DW_AT_name
: return "DW_AT_name";
7220 case DW_AT_ordering
: return "DW_AT_ordering";
7221 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
7222 case DW_AT_byte_size
: return "DW_AT_byte_size";
7223 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
7224 case DW_AT_bit_size
: return "DW_AT_bit_size";
7225 case DW_AT_element_list
: return "DW_AT_element_list";
7226 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
7227 case DW_AT_low_pc
: return "DW_AT_low_pc";
7228 case DW_AT_high_pc
: return "DW_AT_high_pc";
7229 case DW_AT_language
: return "DW_AT_language";
7230 case DW_AT_member
: return "DW_AT_member";
7231 case DW_AT_discr
: return "DW_AT_discr";
7232 case DW_AT_discr_value
: return "DW_AT_discr_value";
7233 case DW_AT_visibility
: return "DW_AT_visibility";
7234 case DW_AT_import
: return "DW_AT_import";
7235 case DW_AT_string_length
: return "DW_AT_string_length";
7236 case DW_AT_common_reference
: return "DW_AT_common_reference";
7237 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
7238 case DW_AT_const_value
: return "DW_AT_const_value";
7239 case DW_AT_containing_type
: return "DW_AT_containing_type";
7240 case DW_AT_default_value
: return "DW_AT_default_value";
7241 case DW_AT_inline
: return "DW_AT_inline";
7242 case DW_AT_is_optional
: return "DW_AT_is_optional";
7243 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
7244 case DW_AT_producer
: return "DW_AT_producer";
7245 case DW_AT_prototyped
: return "DW_AT_prototyped";
7246 case DW_AT_return_addr
: return "DW_AT_return_addr";
7247 case DW_AT_start_scope
: return "DW_AT_start_scope";
7248 case DW_AT_stride_size
: return "DW_AT_stride_size";
7249 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
7250 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
7251 case DW_AT_accessibility
: return "DW_AT_accessibility";
7252 case DW_AT_address_class
: return "DW_AT_address_class";
7253 case DW_AT_artificial
: return "DW_AT_artificial";
7254 case DW_AT_base_types
: return "DW_AT_base_types";
7255 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
7256 case DW_AT_count
: return "DW_AT_count";
7257 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
7258 case DW_AT_decl_column
: return "DW_AT_decl_column";
7259 case DW_AT_decl_file
: return "DW_AT_decl_file";
7260 case DW_AT_decl_line
: return "DW_AT_decl_line";
7261 case DW_AT_declaration
: return "DW_AT_declaration";
7262 case DW_AT_discr_list
: return "DW_AT_discr_list";
7263 case DW_AT_encoding
: return "DW_AT_encoding";
7264 case DW_AT_external
: return "DW_AT_external";
7265 case DW_AT_frame_base
: return "DW_AT_frame_base";
7266 case DW_AT_friend
: return "DW_AT_friend";
7267 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
7268 case DW_AT_macro_info
: return "DW_AT_macro_info";
7269 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
7270 case DW_AT_priority
: return "DW_AT_priority";
7271 case DW_AT_segment
: return "DW_AT_segment";
7272 case DW_AT_specification
: return "DW_AT_specification";
7273 case DW_AT_static_link
: return "DW_AT_static_link";
7274 case DW_AT_type
: return "DW_AT_type";
7275 case DW_AT_use_location
: return "DW_AT_use_location";
7276 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
7277 case DW_AT_virtuality
: return "DW_AT_virtuality";
7278 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
7279 /* DWARF 2.1 values. */
7280 case DW_AT_allocated
: return "DW_AT_allocated";
7281 case DW_AT_associated
: return "DW_AT_associated";
7282 case DW_AT_data_location
: return "DW_AT_data_location";
7283 case DW_AT_stride
: return "DW_AT_stride";
7284 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
7285 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
7286 case DW_AT_extension
: return "DW_AT_extension";
7287 case DW_AT_ranges
: return "DW_AT_ranges";
7288 case DW_AT_trampoline
: return "DW_AT_trampoline";
7289 case DW_AT_call_column
: return "DW_AT_call_column";
7290 case DW_AT_call_file
: return "DW_AT_call_file";
7291 case DW_AT_call_line
: return "DW_AT_call_line";
7292 /* SGI/MIPS extensions. */
7293 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
7294 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
7295 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
7296 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
7297 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
7298 case DW_AT_MIPS_software_pipeline_depth
:
7299 return "DW_AT_MIPS_software_pipeline_depth";
7300 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
7301 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
7302 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
7303 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
7304 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
7305 /* GNU extensions. */
7306 case DW_AT_sf_names
: return "DW_AT_sf_names";
7307 case DW_AT_src_info
: return "DW_AT_src_info";
7308 case DW_AT_mac_info
: return "DW_AT_mac_info";
7309 case DW_AT_src_coords
: return "DW_AT_src_coords";
7310 case DW_AT_body_begin
: return "DW_AT_body_begin";
7311 case DW_AT_body_end
: return "DW_AT_body_end";
7312 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
7313 /* UPC extension. */
7314 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
7317 static char buffer
[100];
7319 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
7326 get_FORM_name (unsigned long form
)
7330 case DW_FORM_addr
: return "DW_FORM_addr";
7331 case DW_FORM_block2
: return "DW_FORM_block2";
7332 case DW_FORM_block4
: return "DW_FORM_block4";
7333 case DW_FORM_data2
: return "DW_FORM_data2";
7334 case DW_FORM_data4
: return "DW_FORM_data4";
7335 case DW_FORM_data8
: return "DW_FORM_data8";
7336 case DW_FORM_string
: return "DW_FORM_string";
7337 case DW_FORM_block
: return "DW_FORM_block";
7338 case DW_FORM_block1
: return "DW_FORM_block1";
7339 case DW_FORM_data1
: return "DW_FORM_data1";
7340 case DW_FORM_flag
: return "DW_FORM_flag";
7341 case DW_FORM_sdata
: return "DW_FORM_sdata";
7342 case DW_FORM_strp
: return "DW_FORM_strp";
7343 case DW_FORM_udata
: return "DW_FORM_udata";
7344 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7345 case DW_FORM_ref1
: return "DW_FORM_ref1";
7346 case DW_FORM_ref2
: return "DW_FORM_ref2";
7347 case DW_FORM_ref4
: return "DW_FORM_ref4";
7348 case DW_FORM_ref8
: return "DW_FORM_ref8";
7349 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7350 case DW_FORM_indirect
: return "DW_FORM_indirect";
7353 static char buffer
[100];
7355 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7361 /* FIXME: There are better and more efficient ways to handle
7362 these structures. For now though, I just want something that
7363 is simple to implement. */
7364 typedef struct abbrev_attr
7366 unsigned long attribute
;
7368 struct abbrev_attr
*next
;
7372 typedef struct abbrev_entry
7374 unsigned long entry
;
7377 struct abbrev_attr
*first_attr
;
7378 struct abbrev_attr
*last_attr
;
7379 struct abbrev_entry
*next
;
7383 static abbrev_entry
*first_abbrev
= NULL
;
7384 static abbrev_entry
*last_abbrev
= NULL
;
7389 abbrev_entry
*abbrev
;
7391 for (abbrev
= first_abbrev
; abbrev
;)
7393 abbrev_entry
*next
= abbrev
->next
;
7396 for (attr
= abbrev
->first_attr
; attr
;)
7398 abbrev_attr
*next
= attr
->next
;
7408 last_abbrev
= first_abbrev
= NULL
;
7412 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7414 abbrev_entry
*entry
;
7416 entry
= malloc (sizeof (*entry
));
7422 entry
->entry
= number
;
7424 entry
->children
= children
;
7425 entry
->first_attr
= NULL
;
7426 entry
->last_attr
= NULL
;
7429 if (first_abbrev
== NULL
)
7430 first_abbrev
= entry
;
7432 last_abbrev
->next
= entry
;
7434 last_abbrev
= entry
;
7438 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7442 attr
= malloc (sizeof (*attr
));
7448 attr
->attribute
= attribute
;
7452 if (last_abbrev
->first_attr
== NULL
)
7453 last_abbrev
->first_attr
= attr
;
7455 last_abbrev
->last_attr
->next
= attr
;
7457 last_abbrev
->last_attr
= attr
;
7460 /* Processes the (partial) contents of a .debug_abbrev section.
7461 Returns NULL if the end of the section was encountered.
7462 Returns the address after the last byte read if the end of
7463 an abbreviation set was found. */
7465 static unsigned char *
7466 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7468 if (first_abbrev
!= NULL
)
7474 unsigned long entry
;
7476 unsigned long attribute
;
7479 entry
= read_leb128 (start
, & bytes_read
, 0);
7480 start
+= bytes_read
;
7482 /* A single zero is supposed to end the section according
7483 to the standard. If there's more, then signal that to
7486 return start
== end
? NULL
: start
;
7488 tag
= read_leb128 (start
, & bytes_read
, 0);
7489 start
+= bytes_read
;
7491 children
= *start
++;
7493 add_abbrev (entry
, tag
, children
);
7499 attribute
= read_leb128 (start
, & bytes_read
, 0);
7500 start
+= bytes_read
;
7502 form
= read_leb128 (start
, & bytes_read
, 0);
7503 start
+= bytes_read
;
7506 add_abbrev_attr (attribute
, form
);
7508 while (attribute
!= 0);
7516 display_debug_macinfo (Elf_Internal_Shdr
*section
,
7517 unsigned char *start
,
7518 FILE *file ATTRIBUTE_UNUSED
)
7520 unsigned char *end
= start
+ section
->sh_size
;
7521 unsigned char *curr
= start
;
7522 unsigned int bytes_read
;
7523 enum dwarf_macinfo_record_type op
;
7525 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7529 unsigned int lineno
;
7537 case DW_MACINFO_start_file
:
7539 unsigned int filenum
;
7541 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7543 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7546 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7550 case DW_MACINFO_end_file
:
7551 printf (_(" DW_MACINFO_end_file\n"));
7554 case DW_MACINFO_define
:
7555 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7558 curr
+= strlen (string
) + 1;
7559 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7562 case DW_MACINFO_undef
:
7563 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7566 curr
+= strlen (string
) + 1;
7567 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7570 case DW_MACINFO_vendor_ext
:
7572 unsigned int constant
;
7574 constant
= read_leb128 (curr
, & bytes_read
, 0);
7577 curr
+= strlen (string
) + 1;
7578 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7589 display_debug_abbrev (Elf_Internal_Shdr
*section
,
7590 unsigned char *start
,
7591 FILE *file ATTRIBUTE_UNUSED
)
7593 abbrev_entry
*entry
;
7594 unsigned char *end
= start
+ section
->sh_size
;
7596 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7600 start
= process_abbrev_section (start
, end
);
7602 if (first_abbrev
== NULL
)
7605 printf (_(" Number TAG\n"));
7607 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7611 printf (_(" %ld %s [%s]\n"),
7613 get_TAG_name (entry
->tag
),
7614 entry
->children
? _("has children") : _("no children"));
7616 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7618 printf (_(" %-18s %s\n"),
7619 get_AT_name (attr
->attribute
),
7620 get_FORM_name (attr
->form
));
7634 static unsigned char *
7635 display_block (unsigned char *data
, unsigned long length
)
7637 printf (_(" %lu byte block: "), length
);
7640 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7646 decode_location_expression (unsigned char * data
,
7647 unsigned int pointer_size
,
7648 unsigned long length
)
7652 unsigned long uvalue
;
7653 unsigned char *end
= data
+ length
;
7662 printf ("DW_OP_addr: %lx",
7663 (unsigned long) byte_get (data
, pointer_size
));
7664 data
+= pointer_size
;
7667 printf ("DW_OP_deref");
7670 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7673 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7676 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7680 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7684 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7688 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7692 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7693 (unsigned long) byte_get (data
+ 4, 4));
7697 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7698 (long) byte_get (data
+ 4, 4));
7702 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7706 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7710 printf ("DW_OP_dup");
7713 printf ("DW_OP_drop");
7716 printf ("DW_OP_over");
7719 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7722 printf ("DW_OP_swap");
7725 printf ("DW_OP_rot");
7728 printf ("DW_OP_xderef");
7731 printf ("DW_OP_abs");
7734 printf ("DW_OP_and");
7737 printf ("DW_OP_div");
7740 printf ("DW_OP_minus");
7743 printf ("DW_OP_mod");
7746 printf ("DW_OP_mul");
7749 printf ("DW_OP_neg");
7752 printf ("DW_OP_not");
7755 printf ("DW_OP_or");
7758 printf ("DW_OP_plus");
7760 case DW_OP_plus_uconst
:
7761 printf ("DW_OP_plus_uconst: %lu",
7762 read_leb128 (data
, &bytes_read
, 0));
7766 printf ("DW_OP_shl");
7769 printf ("DW_OP_shr");
7772 printf ("DW_OP_shra");
7775 printf ("DW_OP_xor");
7778 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7782 printf ("DW_OP_eq");
7785 printf ("DW_OP_ge");
7788 printf ("DW_OP_gt");
7791 printf ("DW_OP_le");
7794 printf ("DW_OP_lt");
7797 printf ("DW_OP_ne");
7800 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7836 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7871 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7906 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7907 read_leb128 (data
, &bytes_read
, 1));
7912 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7916 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7920 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7922 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7923 read_leb128 (data
, &bytes_read
, 1));
7927 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7930 case DW_OP_deref_size
:
7931 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7933 case DW_OP_xderef_size
:
7934 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7937 printf ("DW_OP_nop");
7940 /* DWARF 3 extensions. */
7941 case DW_OP_push_object_address
:
7942 printf ("DW_OP_push_object_address");
7945 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7949 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7952 case DW_OP_call_ref
:
7953 printf ("DW_OP_call_ref");
7956 /* GNU extensions. */
7957 case DW_OP_GNU_push_tls_address
:
7958 printf ("DW_OP_GNU_push_tls_address");
7962 if (op
>= DW_OP_lo_user
7963 && op
<= DW_OP_hi_user
)
7964 printf (_("(User defined location op)"));
7966 printf (_("(Unknown location op)"));
7967 /* No way to tell where the next op is, so just bail. */
7971 /* Separate the ops. */
7977 static const char *debug_loc_contents
;
7978 static bfd_vma debug_loc_size
;
7981 load_debug_loc (FILE *file
)
7983 Elf_Internal_Shdr
*sec
;
7985 /* If it is already loaded, do nothing. */
7986 if (debug_loc_contents
!= NULL
)
7989 /* Locate the .debug_loc section. */
7990 sec
= find_section (".debug_loc");
7994 debug_loc_size
= sec
->sh_size
;
7996 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7997 _("debug_loc section data"));
8001 free_debug_loc (void)
8003 if (debug_loc_contents
== NULL
)
8006 free ((char *) debug_loc_contents
);
8007 debug_loc_contents
= NULL
;
8013 display_debug_loc (Elf_Internal_Shdr
*section
,
8014 unsigned char *start
, FILE *file
)
8016 unsigned char *section_end
;
8017 unsigned long bytes
;
8018 unsigned char *section_begin
= start
;
8020 unsigned int comp_unit
= 0;
8022 addr
= section
->sh_addr
;
8023 bytes
= section
->sh_size
;
8024 section_end
= start
+ bytes
;
8028 printf (_("\nThe .debug_loc section is empty.\n"));
8032 if (num_debug_line_pointer_sizes
== 0)
8033 get_debug_line_pointer_sizes (file
);
8035 printf (_("Contents of the .debug_loc section:\n\n"));
8036 printf (_("\n Offset Begin End Expression\n"));
8038 while (start
< section_end
)
8040 unsigned long begin
;
8042 unsigned short length
;
8043 unsigned long offset
;
8044 unsigned int pointer_size
;
8046 offset
= start
- section_begin
;
8048 /* Get the pointer size from the comp unit associated
8049 with this block of location information. */
8050 if (comp_unit
>= num_debug_line_pointer_sizes
)
8052 error (_("Not enough comp units for .debug_loc section\n"));
8057 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
8063 begin
= byte_get (start
, pointer_size
);
8064 start
+= pointer_size
;
8065 end
= byte_get (start
, pointer_size
);
8066 start
+= pointer_size
;
8068 if (begin
== 0 && end
== 0)
8071 /* For now, skip any base address specifiers. */
8072 if (begin
== 0xffffffff)
8078 length
= byte_get (start
, 2);
8081 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
8082 decode_location_expression (start
, pointer_size
, length
);
8092 static const char *debug_str_contents
;
8093 static bfd_vma debug_str_size
;
8096 load_debug_str (FILE *file
)
8098 Elf_Internal_Shdr
*sec
;
8100 /* If it is already loaded, do nothing. */
8101 if (debug_str_contents
!= NULL
)
8104 /* Locate the .debug_str section. */
8105 sec
= find_section (".debug_str");
8109 debug_str_size
= sec
->sh_size
;
8111 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8112 _("debug_str section data"));
8116 free_debug_str (void)
8118 if (debug_str_contents
== NULL
)
8121 free ((char *) debug_str_contents
);
8122 debug_str_contents
= NULL
;
8127 fetch_indirect_string (unsigned long offset
)
8129 if (debug_str_contents
== NULL
)
8130 return _("<no .debug_str section>");
8132 if (offset
> debug_str_size
)
8133 return _("<offset is too big>");
8135 return debug_str_contents
+ offset
;
8139 display_debug_str (Elf_Internal_Shdr
*section
,
8140 unsigned char *start
,
8141 FILE *file ATTRIBUTE_UNUSED
)
8143 unsigned long bytes
;
8146 addr
= section
->sh_addr
;
8147 bytes
= section
->sh_size
;
8151 printf (_("\nThe .debug_str section is empty.\n"));
8155 printf (_("Contents of the .debug_str section:\n\n"));
8163 lbytes
= (bytes
> 16 ? 16 : bytes
);
8165 printf (" 0x%8.8lx ", (unsigned long) addr
);
8167 for (j
= 0; j
< 16; j
++)
8170 printf ("%2.2x", start
[j
]);
8178 for (j
= 0; j
< lbytes
; j
++)
8181 if (k
>= ' ' && k
< 0x80)
8197 static unsigned char *
8198 read_and_display_attr_value (unsigned long attribute
,
8200 unsigned char *data
,
8201 unsigned long cu_offset
,
8202 unsigned long pointer_size
,
8203 unsigned long offset_size
,
8206 unsigned long uvalue
= 0;
8207 unsigned char *block_start
= NULL
;
8215 case DW_FORM_ref_addr
:
8216 if (dwarf_version
== 2)
8218 uvalue
= byte_get (data
, pointer_size
);
8219 data
+= pointer_size
;
8221 else if (dwarf_version
== 3)
8223 uvalue
= byte_get (data
, offset_size
);
8224 data
+= offset_size
;
8228 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8233 uvalue
= byte_get (data
, pointer_size
);
8234 data
+= pointer_size
;
8238 uvalue
= byte_get (data
, offset_size
);
8239 data
+= offset_size
;
8245 uvalue
= byte_get (data
++, 1);
8250 uvalue
= byte_get (data
, 2);
8256 uvalue
= byte_get (data
, 4);
8261 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8265 case DW_FORM_ref_udata
:
8267 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8271 case DW_FORM_indirect
:
8272 form
= read_leb128 (data
, & bytes_read
, 0);
8274 printf (" %s", get_FORM_name (form
));
8275 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8276 pointer_size
, offset_size
,
8282 case DW_FORM_ref_addr
:
8283 printf (" <#%lx>", uvalue
);
8289 case DW_FORM_ref_udata
:
8290 printf (" <%lx>", uvalue
+ cu_offset
);
8294 printf (" %#lx", uvalue
);
8303 printf (" %ld", uvalue
);
8308 uvalue
= byte_get (data
, 4);
8309 printf (" %lx", uvalue
);
8310 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8314 case DW_FORM_string
:
8315 printf (" %s", data
);
8316 data
+= strlen ((char *) data
) + 1;
8320 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8321 block_start
= data
+ bytes_read
;
8322 data
= display_block (block_start
, uvalue
);
8325 case DW_FORM_block1
:
8326 uvalue
= byte_get (data
, 1);
8327 block_start
= data
+ 1;
8328 data
= display_block (block_start
, uvalue
);
8331 case DW_FORM_block2
:
8332 uvalue
= byte_get (data
, 2);
8333 block_start
= data
+ 2;
8334 data
= display_block (block_start
, uvalue
);
8337 case DW_FORM_block4
:
8338 uvalue
= byte_get (data
, 4);
8339 block_start
= data
+ 4;
8340 data
= display_block (block_start
, uvalue
);
8344 printf (_(" (indirect string, offset: 0x%lx): %s"),
8345 uvalue
, fetch_indirect_string (uvalue
));
8348 case DW_FORM_indirect
:
8349 /* Handled above. */
8353 warn (_("Unrecognized form: %d\n"), form
);
8357 /* For some attributes we can display further information. */
8366 case DW_INL_not_inlined
:
8367 printf (_("(not inlined)"));
8369 case DW_INL_inlined
:
8370 printf (_("(inlined)"));
8372 case DW_INL_declared_not_inlined
:
8373 printf (_("(declared as inline but ignored)"));
8375 case DW_INL_declared_inlined
:
8376 printf (_("(declared as inline and inlined)"));
8379 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8384 case DW_AT_language
:
8387 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8388 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8389 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8390 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8391 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8392 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8393 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8394 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8395 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8396 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8397 /* DWARF 2.1 values. */
8398 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8399 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8400 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8401 /* MIPS extension. */
8402 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8403 /* UPC extension. */
8404 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8406 printf ("(Unknown: %lx)", uvalue
);
8411 case DW_AT_encoding
:
8414 case DW_ATE_void
: printf ("(void)"); break;
8415 case DW_ATE_address
: printf ("(machine address)"); break;
8416 case DW_ATE_boolean
: printf ("(boolean)"); break;
8417 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8418 case DW_ATE_float
: printf ("(float)"); break;
8419 case DW_ATE_signed
: printf ("(signed)"); break;
8420 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8421 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8422 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8423 /* DWARF 2.1 value. */
8424 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8426 if (uvalue
>= DW_ATE_lo_user
8427 && uvalue
<= DW_ATE_hi_user
)
8428 printf ("(user defined type)");
8430 printf ("(unknown type)");
8435 case DW_AT_accessibility
:
8438 case DW_ACCESS_public
: printf ("(public)"); break;
8439 case DW_ACCESS_protected
: printf ("(protected)"); break;
8440 case DW_ACCESS_private
: printf ("(private)"); break;
8442 printf ("(unknown accessibility)");
8447 case DW_AT_visibility
:
8450 case DW_VIS_local
: printf ("(local)"); break;
8451 case DW_VIS_exported
: printf ("(exported)"); break;
8452 case DW_VIS_qualified
: printf ("(qualified)"); break;
8453 default: printf ("(unknown visibility)"); break;
8457 case DW_AT_virtuality
:
8460 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8461 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8462 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8463 default: printf ("(unknown virtuality)"); break;
8467 case DW_AT_identifier_case
:
8470 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8471 case DW_ID_up_case
: printf ("(up_case)"); break;
8472 case DW_ID_down_case
: printf ("(down_case)"); break;
8473 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8474 default: printf ("(unknown case)"); break;
8478 case DW_AT_calling_convention
:
8481 case DW_CC_normal
: printf ("(normal)"); break;
8482 case DW_CC_program
: printf ("(program)"); break;
8483 case DW_CC_nocall
: printf ("(nocall)"); break;
8485 if (uvalue
>= DW_CC_lo_user
8486 && uvalue
<= DW_CC_hi_user
)
8487 printf ("(user defined)");
8489 printf ("(unknown convention)");
8493 case DW_AT_ordering
:
8496 case -1: printf ("(undefined)"); break;
8497 case 0: printf ("(row major)"); break;
8498 case 1: printf ("(column major)"); break;
8502 case DW_AT_frame_base
:
8503 case DW_AT_location
:
8504 case DW_AT_data_member_location
:
8505 case DW_AT_vtable_elem_location
:
8506 case DW_AT_allocated
:
8507 case DW_AT_associated
:
8508 case DW_AT_data_location
:
8510 case DW_AT_upper_bound
:
8511 case DW_AT_lower_bound
:
8515 decode_location_expression (block_start
, pointer_size
, uvalue
);
8518 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8521 printf ("location list");
8533 static unsigned char *
8534 read_and_display_attr (unsigned long attribute
,
8536 unsigned char *data
,
8537 unsigned long cu_offset
,
8538 unsigned long pointer_size
,
8539 unsigned long offset_size
,
8542 printf (" %-18s:", get_AT_name (attribute
));
8543 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8544 pointer_size
, offset_size
, dwarf_version
);
8549 /* Apply addends of RELA relocations. */
8552 debug_apply_rela_addends (FILE *file
,
8553 Elf_Internal_Shdr
*section
,
8555 unsigned char *sec_data
,
8556 unsigned char *start
,
8559 Elf_Internal_Shdr
*relsec
;
8561 if (end
- start
< reloc_size
)
8564 for (relsec
= section_headers
;
8565 relsec
< section_headers
+ elf_header
.e_shnum
;
8568 unsigned long nrelas
;
8569 Elf_Internal_Rela
*rela
, *rp
;
8570 Elf_Internal_Shdr
*symsec
;
8571 Elf_Internal_Sym
*symtab
;
8572 Elf_Internal_Sym
*sym
;
8574 if (relsec
->sh_type
!= SHT_RELA
8575 || SECTION_HEADER (relsec
->sh_info
) != section
8576 || relsec
->sh_size
== 0)
8579 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8583 symsec
= SECTION_HEADER (relsec
->sh_link
);
8584 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8586 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8590 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
8591 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
8592 loc
= sec_data
+ rp
->r_offset
;
8598 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8600 if (ELF32_R_SYM (rp
->r_info
) != 0
8601 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8603 warn (_("Skipping unexpected symbol type %u\n"),
8604 ELF32_ST_TYPE (sym
->st_info
));
8610 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8612 if (ELF64_R_SYM (rp
->r_info
) != 0
8613 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8615 warn (_("Skipping unexpected symbol type %u\n"),
8616 ELF64_ST_TYPE (sym
->st_info
));
8621 byte_put (loc
, rp
->r_addend
, reloc_size
);
8632 display_debug_info (Elf_Internal_Shdr
*section
,
8633 unsigned char *start
,
8636 unsigned char *end
= start
+ section
->sh_size
;
8637 unsigned char *section_begin
= start
;
8639 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8641 load_debug_str (file
);
8642 load_debug_loc (file
);
8646 DWARF2_Internal_CompUnit compunit
;
8647 unsigned char *hdrptr
;
8648 unsigned char *cu_abbrev_offset_ptr
;
8649 unsigned char *tags
;
8651 unsigned long cu_offset
;
8653 int initial_length_size
;
8657 compunit
.cu_length
= byte_get (hdrptr
, 4);
8660 if (compunit
.cu_length
== 0xffffffff)
8662 compunit
.cu_length
= byte_get (hdrptr
, 8);
8665 initial_length_size
= 12;
8670 initial_length_size
= 4;
8673 compunit
.cu_version
= byte_get (hdrptr
, 2);
8676 cu_offset
= start
- section_begin
;
8677 start
+= compunit
.cu_length
+ initial_length_size
;
8679 if (elf_header
.e_type
== ET_REL
8680 && !debug_apply_rela_addends (file
, section
, offset_size
,
8681 section_begin
, hdrptr
, start
))
8684 cu_abbrev_offset_ptr
= hdrptr
;
8685 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8686 hdrptr
+= offset_size
;
8688 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8693 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8694 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8695 printf (_(" Version: %d\n"), compunit
.cu_version
);
8696 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8697 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8699 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8701 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8707 /* Read in the abbrevs used by this compilation unit. */
8709 Elf_Internal_Shdr
*sec
;
8710 unsigned char *begin
;
8712 /* Locate the .debug_abbrev section and process it. */
8713 sec
= find_section (".debug_abbrev");
8716 warn (_("Unable to locate .debug_abbrev section!\n"));
8720 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8721 _("debug_abbrev section data"));
8725 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8726 begin
+ sec
->sh_size
);
8732 while (tags
< start
)
8735 unsigned long abbrev_number
;
8736 abbrev_entry
*entry
;
8739 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8742 /* A null DIE marks the end of a list of children. */
8743 if (abbrev_number
== 0)
8749 /* Scan through the abbreviation list until we reach the
8751 for (entry
= first_abbrev
;
8752 entry
&& entry
->entry
!= abbrev_number
;
8753 entry
= entry
->next
)
8758 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8763 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8765 (unsigned long) (tags
- section_begin
- bytes_read
),
8767 get_TAG_name (entry
->tag
));
8769 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8770 tags
= read_and_display_attr (attr
->attribute
,
8773 compunit
.cu_pointer_size
,
8775 compunit
.cu_version
);
8777 if (entry
->children
)
8791 display_debug_aranges (Elf_Internal_Shdr
*section
,
8792 unsigned char *start
,
8793 FILE *file ATTRIBUTE_UNUSED
)
8795 unsigned char *end
= start
+ section
->sh_size
;
8797 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8801 unsigned char *hdrptr
;
8802 DWARF2_Internal_ARange arange
;
8803 unsigned char *ranges
;
8804 unsigned long length
;
8805 unsigned long address
;
8808 int initial_length_size
;
8812 arange
.ar_length
= byte_get (hdrptr
, 4);
8815 if (arange
.ar_length
== 0xffffffff)
8817 arange
.ar_length
= byte_get (hdrptr
, 8);
8820 initial_length_size
= 12;
8825 initial_length_size
= 4;
8828 arange
.ar_version
= byte_get (hdrptr
, 2);
8831 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
8832 hdrptr
+= offset_size
;
8834 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
8837 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
8840 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
8842 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8846 printf (_(" Length: %ld\n"), arange
.ar_length
);
8847 printf (_(" Version: %d\n"), arange
.ar_version
);
8848 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8849 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8850 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8852 printf (_("\n Address Length\n"));
8856 /* Must pad to an alignment boundary that is twice the pointer size. */
8857 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
8859 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8863 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8865 ranges
+= arange
.ar_pointer_size
;
8867 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8869 ranges
+= arange
.ar_pointer_size
;
8871 /* A pair of zeros marks the end of the list. */
8872 if (address
== 0 && length
== 0)
8875 printf (" %8.8lx %lu\n", address
, length
);
8878 start
+= arange
.ar_length
+ initial_length_size
;
8886 typedef struct Frame_Chunk
8888 struct Frame_Chunk
*next
;
8889 unsigned char *chunk_start
;
8891 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8892 short int *col_type
;
8895 unsigned int code_factor
;
8897 unsigned long pc_begin
;
8898 unsigned long pc_range
;
8902 unsigned char fde_encoding
;
8903 unsigned char cfa_exp
;
8907 /* A marker for a col_type that means this column was never referenced
8908 in the frame info. */
8909 #define DW_CFA_unreferenced (-1)
8912 frame_need_space (Frame_Chunk
*fc
, int reg
)
8914 int prev
= fc
->ncols
;
8916 if (reg
< fc
->ncols
)
8919 fc
->ncols
= reg
+ 1;
8920 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
8921 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
8923 while (prev
< fc
->ncols
)
8925 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8926 fc
->col_offset
[prev
] = 0;
8932 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
8937 if (*max_regs
< fc
->ncols
)
8938 *max_regs
= fc
->ncols
;
8940 if (*need_col_headers
)
8942 *need_col_headers
= 0;
8944 printf (" LOC CFA ");
8946 for (r
= 0; r
< *max_regs
; r
++)
8947 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8952 printf ("r%-4d", r
);
8958 printf ("%08lx ", fc
->pc_begin
);
8960 strcpy (tmp
, "exp");
8962 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8963 printf ("%-8s ", tmp
);
8965 for (r
= 0; r
< fc
->ncols
; r
++)
8967 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8969 switch (fc
->col_type
[r
])
8971 case DW_CFA_undefined
:
8974 case DW_CFA_same_value
:
8978 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8980 case DW_CFA_register
:
8981 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8983 case DW_CFA_expression
:
8984 strcpy (tmp
, "exp");
8987 strcpy (tmp
, "n/a");
8990 printf ("%-5s", tmp
);
8997 size_of_encoded_value (int encoding
)
8999 switch (encoding
& 0x7)
9002 case 0: return is_32bit_elf
? 4 : 8;
9010 get_encoded_value (unsigned char *data
, int encoding
)
9012 int size
= size_of_encoded_value (encoding
);
9013 if (encoding
& DW_EH_PE_signed
)
9014 return byte_get_signed (data
, size
);
9016 return byte_get (data
, size
);
9019 #define GET(N) byte_get (start, N); start += N
9020 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9021 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9024 display_debug_frames (Elf_Internal_Shdr
*section
,
9025 unsigned char *start
,
9026 FILE *file ATTRIBUTE_UNUSED
)
9028 unsigned char *end
= start
+ section
->sh_size
;
9029 unsigned char *section_start
= start
;
9030 Frame_Chunk
*chunks
= 0;
9031 Frame_Chunk
*remembered_state
= 0;
9033 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
9036 int addr_size
= is_32bit_elf
? 4 : 8;
9038 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
9042 unsigned char *saved_start
;
9043 unsigned char *block_end
;
9044 unsigned long length
;
9045 unsigned long cie_id
;
9048 int need_col_headers
= 1;
9049 unsigned char *augmentation_data
= NULL
;
9050 unsigned long augmentation_data_len
= 0;
9051 int encoded_ptr_size
= addr_size
;
9053 int initial_length_size
;
9055 saved_start
= start
;
9056 length
= byte_get (start
, 4); start
+= 4;
9060 printf ("\n%08lx ZERO terminator\n\n",
9061 (unsigned long)(saved_start
- section_start
));
9065 if (length
== 0xffffffff)
9067 length
= byte_get (start
, 8);
9070 initial_length_size
= 12;
9075 initial_length_size
= 4;
9078 block_end
= saved_start
+ length
+ initial_length_size
;
9079 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
9081 if (elf_header
.e_type
== ET_REL
9082 && !debug_apply_rela_addends (file
, section
, offset_size
,
9083 section_start
, start
, block_end
))
9086 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
9090 fc
= xmalloc (sizeof (Frame_Chunk
));
9091 memset (fc
, 0, sizeof (Frame_Chunk
));
9095 fc
->chunk_start
= saved_start
;
9097 fc
->col_type
= xmalloc (sizeof (short int));
9098 fc
->col_offset
= xmalloc (sizeof (int));
9099 frame_need_space (fc
, max_regs
-1);
9103 fc
->augmentation
= start
;
9104 start
= strchr (start
, '\0') + 1;
9106 if (fc
->augmentation
[0] == 'z')
9108 fc
->code_factor
= LEB ();
9109 fc
->data_factor
= SLEB ();
9118 augmentation_data_len
= LEB ();
9119 augmentation_data
= start
;
9120 start
+= augmentation_data_len
;
9122 else if (strcmp (fc
->augmentation
, "eh") == 0)
9125 fc
->code_factor
= LEB ();
9126 fc
->data_factor
= SLEB ();
9138 fc
->code_factor
= LEB ();
9139 fc
->data_factor
= SLEB ();
9151 if (do_debug_frames_interp
)
9152 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
9153 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9154 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
9158 printf ("\n%08lx %08lx %08lx CIE\n",
9159 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
9160 printf (" Version: %d\n", version
);
9161 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9162 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9163 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9164 printf (" Return address column: %d\n", fc
->ra
);
9166 if (augmentation_data_len
)
9169 printf (" Augmentation data: ");
9170 for (i
= 0; i
< augmentation_data_len
; ++i
)
9171 printf (" %02x", augmentation_data
[i
]);
9177 if (augmentation_data_len
)
9179 unsigned char *p
, *q
;
9180 p
= fc
->augmentation
+ 1;
9181 q
= augmentation_data
;
9188 q
+= 1 + size_of_encoded_value (*q
);
9190 fc
->fde_encoding
= *q
++;
9196 if (fc
->fde_encoding
)
9197 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9200 frame_need_space (fc
, fc
->ra
);
9204 unsigned char *look_for
;
9205 static Frame_Chunk fde_fc
;
9208 memset (fc
, 0, sizeof (Frame_Chunk
));
9210 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
9212 for (cie
= chunks
; cie
; cie
= cie
->next
)
9213 if (cie
->chunk_start
== look_for
)
9218 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9219 cie_id
, saved_start
);
9222 fc
->col_type
= xmalloc (sizeof (short int));
9223 fc
->col_offset
= xmalloc (sizeof (int));
9224 frame_need_space (fc
, max_regs
- 1);
9226 fc
->augmentation
= "";
9227 fc
->fde_encoding
= 0;
9231 fc
->ncols
= cie
->ncols
;
9232 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
9233 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
9234 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9235 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9236 fc
->augmentation
= cie
->augmentation
;
9237 fc
->code_factor
= cie
->code_factor
;
9238 fc
->data_factor
= cie
->data_factor
;
9239 fc
->cfa_reg
= cie
->cfa_reg
;
9240 fc
->cfa_offset
= cie
->cfa_offset
;
9242 frame_need_space (fc
, max_regs
-1);
9243 fc
->fde_encoding
= cie
->fde_encoding
;
9246 if (fc
->fde_encoding
)
9247 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9249 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
9250 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9251 /* Don't adjust for ET_REL since there's invariably a pcrel
9252 reloc here, which we haven't applied. */
9253 && elf_header
.e_type
!= ET_REL
)
9254 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
9255 start
+= encoded_ptr_size
;
9256 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
9257 start
+= encoded_ptr_size
;
9259 if (cie
->augmentation
[0] == 'z')
9261 augmentation_data_len
= LEB ();
9262 augmentation_data
= start
;
9263 start
+= augmentation_data_len
;
9266 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9267 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9268 (unsigned long)(cie
->chunk_start
- section_start
),
9269 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
9270 if (! do_debug_frames_interp
&& augmentation_data_len
)
9273 printf (" Augmentation data: ");
9274 for (i
= 0; i
< augmentation_data_len
; ++i
)
9275 printf (" %02x", augmentation_data
[i
]);
9281 /* At this point, fc is the current chunk, cie (if any) is set, and we're
9282 about to interpret instructions for the chunk. */
9283 /* ??? At present we need to do this always, since this sizes the
9284 fc->col_type and fc->col_offset arrays, which we write into always.
9285 We should probably split the interpreted and non-interpreted bits
9286 into two different routines, since there's so much that doesn't
9287 really overlap between them. */
9288 if (1 || do_debug_frames_interp
)
9290 /* Start by making a pass over the chunk, allocating storage
9291 and taking note of what registers are used. */
9292 unsigned char *tmp
= start
;
9294 while (start
< block_end
)
9297 unsigned long reg
, tmp
;
9304 /* Warning: if you add any more cases to this switch, be
9305 sure to add them to the corresponding switch below. */
9308 case DW_CFA_advance_loc
:
9312 frame_need_space (fc
, opa
);
9313 fc
->col_type
[opa
] = DW_CFA_undefined
;
9315 case DW_CFA_restore
:
9316 frame_need_space (fc
, opa
);
9317 fc
->col_type
[opa
] = DW_CFA_undefined
;
9319 case DW_CFA_set_loc
:
9320 start
+= encoded_ptr_size
;
9322 case DW_CFA_advance_loc1
:
9325 case DW_CFA_advance_loc2
:
9328 case DW_CFA_advance_loc4
:
9331 case DW_CFA_offset_extended
:
9332 reg
= LEB (); LEB ();
9333 frame_need_space (fc
, reg
);
9334 fc
->col_type
[reg
] = DW_CFA_undefined
;
9336 case DW_CFA_restore_extended
:
9338 frame_need_space (fc
, reg
);
9339 fc
->col_type
[reg
] = DW_CFA_undefined
;
9341 case DW_CFA_undefined
:
9343 frame_need_space (fc
, reg
);
9344 fc
->col_type
[reg
] = DW_CFA_undefined
;
9346 case DW_CFA_same_value
:
9348 frame_need_space (fc
, reg
);
9349 fc
->col_type
[reg
] = DW_CFA_undefined
;
9351 case DW_CFA_register
:
9352 reg
= LEB (); LEB ();
9353 frame_need_space (fc
, reg
);
9354 fc
->col_type
[reg
] = DW_CFA_undefined
;
9356 case DW_CFA_def_cfa
:
9359 case DW_CFA_def_cfa_register
:
9362 case DW_CFA_def_cfa_offset
:
9365 case DW_CFA_def_cfa_expression
:
9369 case DW_CFA_expression
:
9373 frame_need_space (fc
, reg
);
9374 fc
->col_type
[reg
] = DW_CFA_undefined
;
9376 case DW_CFA_offset_extended_sf
:
9377 reg
= LEB (); SLEB ();
9378 frame_need_space (fc
, reg
);
9379 fc
->col_type
[reg
] = DW_CFA_undefined
;
9381 case DW_CFA_def_cfa_sf
:
9384 case DW_CFA_def_cfa_offset_sf
:
9387 case DW_CFA_MIPS_advance_loc8
:
9390 case DW_CFA_GNU_args_size
:
9393 case DW_CFA_GNU_negative_offset_extended
:
9394 reg
= LEB (); LEB ();
9395 frame_need_space (fc
, reg
);
9396 fc
->col_type
[reg
] = DW_CFA_undefined
;
9405 /* Now we know what registers are used, make a second pass over
9406 the chunk, this time actually printing out the info. */
9408 while (start
< block_end
)
9411 unsigned long ul
, reg
, roffs
;
9420 /* Warning: if you add any more cases to this switch, be
9421 sure to add them to the corresponding switch above. */
9424 case DW_CFA_advance_loc
:
9425 if (do_debug_frames_interp
)
9426 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9428 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9429 opa
* fc
->code_factor
,
9430 fc
->pc_begin
+ opa
* fc
->code_factor
);
9431 fc
->pc_begin
+= opa
* fc
->code_factor
;
9436 if (! do_debug_frames_interp
)
9437 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9438 opa
, roffs
* fc
->data_factor
);
9439 fc
->col_type
[opa
] = DW_CFA_offset
;
9440 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9443 case DW_CFA_restore
:
9444 if (! do_debug_frames_interp
)
9445 printf (" DW_CFA_restore: r%d\n", opa
);
9446 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9447 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9450 case DW_CFA_set_loc
:
9451 vma
= get_encoded_value (start
, fc
->fde_encoding
);
9452 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9453 && elf_header
.e_type
!= ET_REL
)
9454 vma
+= section
->sh_addr
+ (start
- section_start
);
9455 start
+= encoded_ptr_size
;
9456 if (do_debug_frames_interp
)
9457 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9459 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
9463 case DW_CFA_advance_loc1
:
9464 ofs
= byte_get (start
, 1); start
+= 1;
9465 if (do_debug_frames_interp
)
9466 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9468 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9469 ofs
* fc
->code_factor
,
9470 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9471 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9474 case DW_CFA_advance_loc2
:
9475 ofs
= byte_get (start
, 2); start
+= 2;
9476 if (do_debug_frames_interp
)
9477 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9479 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9480 ofs
* fc
->code_factor
,
9481 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9482 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9485 case DW_CFA_advance_loc4
:
9486 ofs
= byte_get (start
, 4); start
+= 4;
9487 if (do_debug_frames_interp
)
9488 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9490 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9491 ofs
* fc
->code_factor
,
9492 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9493 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9496 case DW_CFA_offset_extended
:
9499 if (! do_debug_frames_interp
)
9500 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9501 reg
, roffs
* fc
->data_factor
);
9502 fc
->col_type
[reg
] = DW_CFA_offset
;
9503 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9506 case DW_CFA_restore_extended
:
9508 if (! do_debug_frames_interp
)
9509 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
9510 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9511 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9514 case DW_CFA_undefined
:
9516 if (! do_debug_frames_interp
)
9517 printf (" DW_CFA_undefined: r%ld\n", reg
);
9518 fc
->col_type
[reg
] = DW_CFA_undefined
;
9519 fc
->col_offset
[reg
] = 0;
9522 case DW_CFA_same_value
:
9524 if (! do_debug_frames_interp
)
9525 printf (" DW_CFA_same_value: r%ld\n", reg
);
9526 fc
->col_type
[reg
] = DW_CFA_same_value
;
9527 fc
->col_offset
[reg
] = 0;
9530 case DW_CFA_register
:
9533 if (! do_debug_frames_interp
)
9534 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
9535 fc
->col_type
[reg
] = DW_CFA_register
;
9536 fc
->col_offset
[reg
] = roffs
;
9539 case DW_CFA_remember_state
:
9540 if (! do_debug_frames_interp
)
9541 printf (" DW_CFA_remember_state\n");
9542 rs
= xmalloc (sizeof (Frame_Chunk
));
9543 rs
->ncols
= fc
->ncols
;
9544 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
9545 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
9546 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
9547 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
9548 rs
->next
= remembered_state
;
9549 remembered_state
= rs
;
9552 case DW_CFA_restore_state
:
9553 if (! do_debug_frames_interp
)
9554 printf (" DW_CFA_restore_state\n");
9555 rs
= remembered_state
;
9558 remembered_state
= rs
->next
;
9559 frame_need_space (fc
, rs
->ncols
-1);
9560 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
9561 memcpy (fc
->col_offset
, rs
->col_offset
,
9562 rs
->ncols
* sizeof (int));
9563 free (rs
->col_type
);
9564 free (rs
->col_offset
);
9567 else if (do_debug_frames_interp
)
9568 printf ("Mismatched DW_CFA_restore_state\n");
9571 case DW_CFA_def_cfa
:
9572 fc
->cfa_reg
= LEB ();
9573 fc
->cfa_offset
= LEB ();
9575 if (! do_debug_frames_interp
)
9576 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9577 fc
->cfa_reg
, fc
->cfa_offset
);
9580 case DW_CFA_def_cfa_register
:
9581 fc
->cfa_reg
= LEB ();
9583 if (! do_debug_frames_interp
)
9584 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9587 case DW_CFA_def_cfa_offset
:
9588 fc
->cfa_offset
= LEB ();
9589 if (! do_debug_frames_interp
)
9590 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9594 if (! do_debug_frames_interp
)
9595 printf (" DW_CFA_nop\n");
9598 case DW_CFA_def_cfa_expression
:
9600 if (! do_debug_frames_interp
)
9602 printf (" DW_CFA_def_cfa_expression (");
9603 decode_location_expression (start
, addr_size
, ul
);
9610 case DW_CFA_expression
:
9613 if (! do_debug_frames_interp
)
9615 printf (" DW_CFA_expression: r%ld (", reg
);
9616 decode_location_expression (start
, addr_size
, ul
);
9619 fc
->col_type
[reg
] = DW_CFA_expression
;
9623 case DW_CFA_offset_extended_sf
:
9626 frame_need_space (fc
, reg
);
9627 if (! do_debug_frames_interp
)
9628 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9629 reg
, l
* fc
->data_factor
);
9630 fc
->col_type
[reg
] = DW_CFA_offset
;
9631 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9634 case DW_CFA_def_cfa_sf
:
9635 fc
->cfa_reg
= LEB ();
9636 fc
->cfa_offset
= SLEB ();
9638 if (! do_debug_frames_interp
)
9639 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9640 fc
->cfa_reg
, fc
->cfa_offset
);
9643 case DW_CFA_def_cfa_offset_sf
:
9644 fc
->cfa_offset
= SLEB ();
9645 if (! do_debug_frames_interp
)
9646 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9649 case DW_CFA_MIPS_advance_loc8
:
9650 ofs
= byte_get (start
, 8); start
+= 8;
9651 if (do_debug_frames_interp
)
9652 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9654 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9655 ofs
* fc
->code_factor
,
9656 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9657 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9660 case DW_CFA_GNU_window_save
:
9661 if (! do_debug_frames_interp
)
9662 printf (" DW_CFA_GNU_window_save\n");
9665 case DW_CFA_GNU_args_size
:
9667 if (! do_debug_frames_interp
)
9668 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9671 case DW_CFA_GNU_negative_offset_extended
:
9674 frame_need_space (fc
, reg
);
9675 if (! do_debug_frames_interp
)
9676 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9677 reg
, l
* fc
->data_factor
);
9678 fc
->col_type
[reg
] = DW_CFA_offset
;
9679 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9683 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9688 if (do_debug_frames_interp
)
9689 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9704 display_debug_not_supported (Elf_Internal_Shdr
*section
,
9705 unsigned char *start ATTRIBUTE_UNUSED
,
9706 FILE *file ATTRIBUTE_UNUSED
)
9708 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9709 SECTION_NAME (section
));
9714 /* A structure containing the name of a debug section
9715 and a pointer to a function that can decode it. */
9718 const char *const name
;
9719 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
9723 { ".debug_abbrev", display_debug_abbrev
},
9724 { ".debug_aranges", display_debug_aranges
},
9725 { ".debug_frame", display_debug_frames
},
9726 { ".debug_info", display_debug_info
},
9727 { ".debug_line", display_debug_lines
},
9728 { ".debug_pubnames", display_debug_pubnames
},
9729 { ".eh_frame", display_debug_frames
},
9730 { ".debug_macinfo", display_debug_macinfo
},
9731 { ".debug_str", display_debug_str
},
9732 { ".debug_loc", display_debug_loc
},
9733 { ".debug_pubtypes", display_debug_pubnames
},
9734 { ".debug_ranges", display_debug_not_supported
},
9735 { ".debug_static_func", display_debug_not_supported
},
9736 { ".debug_static_vars", display_debug_not_supported
},
9737 { ".debug_types", display_debug_not_supported
},
9738 { ".debug_weaknames", display_debug_not_supported
}
9742 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
9744 char *name
= SECTION_NAME (section
);
9745 bfd_size_type length
;
9746 unsigned char *start
;
9749 length
= section
->sh_size
;
9752 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9756 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
9757 _("debug section data"));
9761 /* See if we know how to display the contents of this section. */
9762 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9763 name
= ".debug_info";
9765 for (i
= NUM_ELEM (debug_displays
); i
--;)
9766 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9768 debug_displays
[i
].display (section
, start
, file
);
9773 printf (_("Unrecognized debug section: %s\n"), name
);
9777 /* If we loaded in the abbrev section at some point,
9778 we must release it here. */
9785 process_section_contents (FILE *file
)
9787 Elf_Internal_Shdr
*section
;
9793 for (i
= 0, section
= section_headers
;
9794 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9797 #ifdef SUPPORT_DISASSEMBLY
9798 if (dump_sects
[i
] & DISASS_DUMP
)
9799 disassemble_section (section
, file
);
9801 if (dump_sects
[i
] & HEX_DUMP
)
9802 dump_section (section
, file
);
9804 if (dump_sects
[i
] & DEBUG_DUMP
)
9805 display_debug_section (section
, file
);
9808 if (i
< num_dump_sects
)
9809 warn (_("Some sections were not dumped because they do not exist!\n"));
9815 process_mips_fpe_exception (int mask
)
9820 if (mask
& OEX_FPU_INEX
)
9821 fputs ("INEX", stdout
), first
= 0;
9822 if (mask
& OEX_FPU_UFLO
)
9823 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9824 if (mask
& OEX_FPU_OFLO
)
9825 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9826 if (mask
& OEX_FPU_DIV0
)
9827 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9828 if (mask
& OEX_FPU_INVAL
)
9829 printf ("%sINVAL", first
? "" : "|");
9832 fputs ("0", stdout
);
9836 process_mips_specific (FILE *file
)
9838 Elf_Internal_Dyn
*entry
;
9839 size_t liblist_offset
= 0;
9840 size_t liblistno
= 0;
9841 size_t conflictsno
= 0;
9842 size_t options_offset
= 0;
9843 size_t conflicts_offset
= 0;
9845 /* We have a lot of special sections. Thanks SGI! */
9846 if (dynamic_section
== NULL
)
9847 /* No information available. */
9850 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9851 switch (entry
->d_tag
)
9853 case DT_MIPS_LIBLIST
:
9855 = offset_from_vma (file
, entry
->d_un
.d_val
,
9856 liblistno
* sizeof (Elf32_External_Lib
));
9858 case DT_MIPS_LIBLISTNO
:
9859 liblistno
= entry
->d_un
.d_val
;
9861 case DT_MIPS_OPTIONS
:
9862 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9864 case DT_MIPS_CONFLICT
:
9866 = offset_from_vma (file
, entry
->d_un
.d_val
,
9867 conflictsno
* sizeof (Elf32_External_Conflict
));
9869 case DT_MIPS_CONFLICTNO
:
9870 conflictsno
= entry
->d_un
.d_val
;
9876 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9878 Elf32_External_Lib
*elib
;
9881 elib
= get_data (NULL
, file
, liblist_offset
,
9882 liblistno
* sizeof (Elf32_External_Lib
),
9886 printf ("\nSection '.liblist' contains %lu entries:\n",
9887 (unsigned long) liblistno
);
9888 fputs (" Library Time Stamp Checksum Version Flags\n",
9891 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9898 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9899 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9900 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9901 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9902 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9904 tmp
= gmtime (&time
);
9905 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9906 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9907 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9909 printf ("%3lu: ", (unsigned long) cnt
);
9910 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9911 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9914 if (liblist
.l_flags
== 0)
9925 { " EXACT_MATCH", LL_EXACT_MATCH
},
9926 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9927 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9928 { " EXPORTS", LL_EXPORTS
},
9929 { " DELAY_LOAD", LL_DELAY_LOAD
},
9930 { " DELTA", LL_DELTA
}
9932 int flags
= liblist
.l_flags
;
9936 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9938 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9940 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9941 flags
^= l_flags_vals
[fcnt
].bit
;
9944 printf (" %#x", (unsigned int) flags
);
9954 if (options_offset
!= 0)
9956 Elf_External_Options
*eopt
;
9957 Elf_Internal_Shdr
*sect
= section_headers
;
9958 Elf_Internal_Options
*iopt
;
9959 Elf_Internal_Options
*option
;
9963 /* Find the section header so that we get the size. */
9964 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9967 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
9971 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
9974 error (_("Out of memory"));
9981 while (offset
< sect
->sh_size
)
9983 Elf_External_Options
*eoption
;
9985 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9987 option
->kind
= BYTE_GET (eoption
->kind
);
9988 option
->size
= BYTE_GET (eoption
->size
);
9989 option
->section
= BYTE_GET (eoption
->section
);
9990 option
->info
= BYTE_GET (eoption
->info
);
9992 offset
+= option
->size
;
9998 printf (_("\nSection '%s' contains %d entries:\n"),
9999 SECTION_NAME (sect
), cnt
);
10007 switch (option
->kind
)
10010 /* This shouldn't happen. */
10011 printf (" NULL %d %lx", option
->section
, option
->info
);
10014 printf (" REGINFO ");
10015 if (elf_header
.e_machine
== EM_MIPS
)
10018 Elf32_External_RegInfo
*ereg
;
10019 Elf32_RegInfo reginfo
;
10021 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10022 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10023 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10024 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10025 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10026 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10027 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10029 printf ("GPR %08lx GP 0x%lx\n",
10030 reginfo
.ri_gprmask
,
10031 (unsigned long) reginfo
.ri_gp_value
);
10032 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10033 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10034 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10039 Elf64_External_RegInfo
*ereg
;
10040 Elf64_Internal_RegInfo reginfo
;
10042 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10043 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10044 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10045 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10046 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10047 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10048 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
10050 printf ("GPR %08lx GP 0x",
10051 reginfo
.ri_gprmask
);
10052 printf_vma (reginfo
.ri_gp_value
);
10055 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10056 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10057 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10061 case ODK_EXCEPTIONS
:
10062 fputs (" EXCEPTIONS fpe_min(", stdout
);
10063 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10064 fputs (") fpe_max(", stdout
);
10065 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10066 fputs (")", stdout
);
10068 if (option
->info
& OEX_PAGE0
)
10069 fputs (" PAGE0", stdout
);
10070 if (option
->info
& OEX_SMM
)
10071 fputs (" SMM", stdout
);
10072 if (option
->info
& OEX_FPDBUG
)
10073 fputs (" FPDBUG", stdout
);
10074 if (option
->info
& OEX_DISMISS
)
10075 fputs (" DISMISS", stdout
);
10078 fputs (" PAD ", stdout
);
10079 if (option
->info
& OPAD_PREFIX
)
10080 fputs (" PREFIX", stdout
);
10081 if (option
->info
& OPAD_POSTFIX
)
10082 fputs (" POSTFIX", stdout
);
10083 if (option
->info
& OPAD_SYMBOL
)
10084 fputs (" SYMBOL", stdout
);
10087 fputs (" HWPATCH ", stdout
);
10088 if (option
->info
& OHW_R4KEOP
)
10089 fputs (" R4KEOP", stdout
);
10090 if (option
->info
& OHW_R8KPFETCH
)
10091 fputs (" R8KPFETCH", stdout
);
10092 if (option
->info
& OHW_R5KEOP
)
10093 fputs (" R5KEOP", stdout
);
10094 if (option
->info
& OHW_R5KCVTL
)
10095 fputs (" R5KCVTL", stdout
);
10098 fputs (" FILL ", stdout
);
10099 /* XXX Print content of info word? */
10102 fputs (" TAGS ", stdout
);
10103 /* XXX Print content of info word? */
10106 fputs (" HWAND ", stdout
);
10107 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10108 fputs (" R4KEOP_CHECKED", stdout
);
10109 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10110 fputs (" R4KEOP_CLEAN", stdout
);
10113 fputs (" HWOR ", stdout
);
10114 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10115 fputs (" R4KEOP_CHECKED", stdout
);
10116 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10117 fputs (" R4KEOP_CLEAN", stdout
);
10120 printf (" GP_GROUP %#06lx self-contained %#06lx",
10121 option
->info
& OGP_GROUP
,
10122 (option
->info
& OGP_SELF
) >> 16);
10125 printf (" IDENT %#06lx self-contained %#06lx",
10126 option
->info
& OGP_GROUP
,
10127 (option
->info
& OGP_SELF
) >> 16);
10130 /* This shouldn't happen. */
10131 printf (" %3d ??? %d %lx",
10132 option
->kind
, option
->section
, option
->info
);
10136 len
= sizeof (*eopt
);
10137 while (len
< option
->size
)
10138 if (((char *) option
)[len
] >= ' '
10139 && ((char *) option
)[len
] < 0x7f)
10140 printf ("%c", ((char *) option
)[len
++]);
10142 printf ("\\%03o", ((char *) option
)[len
++]);
10144 fputs ("\n", stdout
);
10152 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10154 Elf32_Conflict
*iconf
;
10157 if (dynamic_symbols
== NULL
)
10159 error (_("conflict list found without a dynamic symbol table"));
10163 iconf
= malloc (conflictsno
* sizeof (*iconf
));
10166 error (_("Out of memory"));
10172 Elf32_External_Conflict
*econf32
;
10174 econf32
= get_data (NULL
, file
, conflicts_offset
,
10175 conflictsno
* sizeof (*econf32
), _("conflict"));
10179 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10180 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10186 Elf64_External_Conflict
*econf64
;
10188 econf64
= get_data (NULL
, file
, conflicts_offset
,
10189 conflictsno
* sizeof (*econf64
), _("conflict"));
10193 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10194 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10199 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10200 (unsigned long) conflictsno
);
10201 puts (_(" Num: Index Value Name"));
10203 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10205 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
10207 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10208 print_vma (psym
->st_value
, FULL_HEX
);
10210 print_symbol (25, dynamic_strings
+ psym
->st_name
);
10221 process_gnu_liblist (FILE *file
)
10223 Elf_Internal_Shdr
*section
, *string_sec
;
10224 Elf32_External_Lib
*elib
;
10232 for (i
= 0, section
= section_headers
;
10233 i
< elf_header
.e_shnum
;
10236 switch (section
->sh_type
)
10238 case SHT_GNU_LIBLIST
:
10239 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
10244 string_sec
= SECTION_HEADER (section
->sh_link
);
10246 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
10247 string_sec
->sh_size
, _("liblist string table"));
10250 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10256 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10257 SECTION_NAME (section
),
10258 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10260 puts (" Library Time Stamp Checksum Version Flags");
10262 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10270 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10271 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10272 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10273 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10274 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10276 tmp
= gmtime (&time
);
10277 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10278 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10279 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10281 printf ("%3lu: ", (unsigned long) cnt
);
10283 printf ("%-20s", strtab
+ liblist
.l_name
);
10285 printf ("%-20.20s", strtab
+ liblist
.l_name
);
10286 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10287 liblist
.l_version
, liblist
.l_flags
);
10297 static const char *
10298 get_note_type (unsigned e_type
)
10300 static char buff
[64];
10304 case NT_AUXV
: return _("NT_AUXV (auxiliary vector)");
10305 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
10306 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
10307 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
10308 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
10309 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
10310 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
10311 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
10312 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
10313 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
10314 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
10315 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10317 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10322 static const char *
10323 get_netbsd_elfcore_note_type (unsigned e_type
)
10325 static char buff
[64];
10327 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10329 /* NetBSD core "procinfo" structure. */
10330 return _("NetBSD procinfo structure");
10333 /* As of Jan 2002 there are no other machine-independent notes
10334 defined for NetBSD core files. If the note type is less
10335 than the start of the machine-dependent note types, we don't
10338 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10340 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10344 switch (elf_header
.e_machine
)
10346 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10347 and PT_GETFPREGS == mach+2. */
10352 case EM_SPARC32PLUS
:
10356 case NT_NETBSDCORE_FIRSTMACH
+0:
10357 return _("PT_GETREGS (reg structure)");
10358 case NT_NETBSDCORE_FIRSTMACH
+2:
10359 return _("PT_GETFPREGS (fpreg structure)");
10365 /* On all other arch's, PT_GETREGS == mach+1 and
10366 PT_GETFPREGS == mach+3. */
10370 case NT_NETBSDCORE_FIRSTMACH
+1:
10371 return _("PT_GETREGS (reg structure)");
10372 case NT_NETBSDCORE_FIRSTMACH
+3:
10373 return _("PT_GETFPREGS (fpreg structure)");
10379 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
10383 /* Note that by the ELF standard, the name field is already null byte
10384 terminated, and namesz includes the terminating null byte.
10385 I.E. the value of namesz for the name "FSF" is 4.
10387 If the value of namesz is zero, there is no name present. */
10389 process_note (Elf_Internal_Note
*pnote
)
10393 if (pnote
->namesz
== 0)
10395 /* If there is no note name, then use the default set of
10396 note type strings. */
10397 nt
= get_note_type (pnote
->type
);
10399 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
10401 /* NetBSD-specific core file notes. */
10402 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10406 /* Don't recognize this note name; just use the default set of
10407 note type strings. */
10408 nt
= get_note_type (pnote
->type
);
10411 printf (" %s\t\t0x%08lx\t%s\n",
10412 pnote
->namesz
? pnote
->namedata
: "(NONE)",
10413 pnote
->descsz
, nt
);
10419 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10421 Elf_External_Note
*pnotes
;
10422 Elf_External_Note
*external
;
10428 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
10434 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10435 (unsigned long) offset
, (unsigned long) length
);
10436 printf (_(" Owner\t\tData size\tDescription\n"));
10438 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10440 Elf_External_Note
*next
;
10441 Elf_Internal_Note inote
;
10444 inote
.type
= BYTE_GET (external
->type
);
10445 inote
.namesz
= BYTE_GET (external
->namesz
);
10446 inote
.namedata
= external
->name
;
10447 inote
.descsz
= BYTE_GET (external
->descsz
);
10448 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10449 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10451 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10453 if (((char *) next
) > (((char *) pnotes
) + length
))
10455 warn (_("corrupt note found at offset %x into core notes\n"),
10456 ((char *) external
) - ((char *) pnotes
));
10457 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10458 inote
.type
, inote
.namesz
, inote
.descsz
);
10464 /* Verify that name is null terminated. It appears that at least
10465 one version of Linux (RedHat 6.0) generates corefiles that don't
10466 comply with the ELF spec by failing to include the null byte in
10468 if (inote
.namedata
[inote
.namesz
] != '\0')
10470 temp
= malloc (inote
.namesz
+ 1);
10474 error (_("Out of memory\n"));
10479 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10480 temp
[inote
.namesz
] = 0;
10482 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10483 inote
.namedata
= temp
;
10486 res
&= process_note (& inote
);
10501 process_corefile_note_segments (FILE *file
)
10503 Elf_Internal_Phdr
*segment
;
10507 if (! get_program_headers (file
))
10510 for (i
= 0, segment
= program_headers
;
10511 i
< elf_header
.e_phnum
;
10514 if (segment
->p_type
== PT_NOTE
)
10515 res
&= process_corefile_note_segment (file
,
10516 (bfd_vma
) segment
->p_offset
,
10517 (bfd_vma
) segment
->p_filesz
);
10524 process_corefile_contents (FILE *file
)
10526 /* If we have not been asked to display the notes then do nothing. */
10530 /* If file is not a core file then exit. */
10531 if (elf_header
.e_type
!= ET_CORE
)
10534 /* No program headers means no NOTE segment. */
10535 if (elf_header
.e_phnum
== 0)
10537 printf (_("No note segments present in the core file.\n"));
10541 return process_corefile_note_segments (file
);
10545 process_arch_specific (FILE *file
)
10550 switch (elf_header
.e_machine
)
10553 case EM_MIPS_RS3_LE
:
10554 return process_mips_specific (file
);
10563 get_file_header (FILE *file
)
10565 /* Read in the identity array. */
10566 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10569 /* Determine how to read the rest of the header. */
10570 switch (elf_header
.e_ident
[EI_DATA
])
10572 default: /* fall through */
10573 case ELFDATANONE
: /* fall through */
10575 byte_get
= byte_get_little_endian
;
10576 byte_put
= byte_put_little_endian
;
10579 byte_get
= byte_get_big_endian
;
10580 byte_put
= byte_put_big_endian
;
10584 /* For now we only support 32 bit and 64 bit ELF files. */
10585 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10587 /* Read in the rest of the header. */
10590 Elf32_External_Ehdr ehdr32
;
10592 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10595 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10596 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10597 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10598 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10599 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10600 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10601 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10602 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10603 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10604 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10605 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10606 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10607 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10611 Elf64_External_Ehdr ehdr64
;
10613 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10614 we will not be able to cope with the 64bit data found in
10615 64 ELF files. Detect this now and abort before we start
10616 overwriting things. */
10617 if (sizeof (bfd_vma
) < 8)
10619 error (_("This instance of readelf has been built without support for a\n\
10620 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10624 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10627 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10628 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10629 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10630 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10631 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10632 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10633 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10634 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10635 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10636 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10637 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10638 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10639 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10642 if (elf_header
.e_shoff
)
10644 /* There may be some extensions in the first section header. Don't
10645 bomb if we can't read it. */
10647 get_32bit_section_headers (file
, 1);
10649 get_64bit_section_headers (file
, 1);
10655 /* Process one ELF object file according to the command line options.
10656 This file may actually be stored in an archive. The file is
10657 positioned at the start of the ELF object. */
10660 process_object (char *file_name
, FILE *file
)
10664 if (! get_file_header (file
))
10666 error (_("%s: Failed to read file header\n"), file_name
);
10670 /* Initialise per file variables. */
10671 for (i
= NUM_ELEM (version_info
); i
--;)
10672 version_info
[i
] = 0;
10674 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10675 dynamic_info
[i
] = 0;
10677 /* Process the file. */
10679 printf (_("\nFile: %s\n"), file_name
);
10681 if (! process_file_header ())
10684 if (! process_section_headers (file
)
10685 || ! process_section_groups (file
))
10687 /* Without loaded section headers and section groups we
10688 cannot process lots of things. */
10689 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10691 if (! do_using_dynamic
)
10692 do_syms
= do_reloc
= 0;
10695 if (process_program_headers (file
))
10696 process_dynamic_section (file
);
10698 process_relocs (file
);
10700 process_unwind (file
);
10702 process_symbol_table (file
);
10704 process_syminfo (file
);
10706 process_version_sections (file
);
10708 process_section_contents (file
);
10710 process_corefile_contents (file
);
10712 process_gnu_liblist (file
);
10714 process_arch_specific (file
);
10716 if (program_headers
)
10718 free (program_headers
);
10719 program_headers
= NULL
;
10722 if (section_headers
)
10724 free (section_headers
);
10725 section_headers
= NULL
;
10730 free (string_table
);
10731 string_table
= NULL
;
10732 string_table_length
= 0;
10735 if (dynamic_strings
)
10737 free (dynamic_strings
);
10738 dynamic_strings
= NULL
;
10741 if (dynamic_symbols
)
10743 free (dynamic_symbols
);
10744 dynamic_symbols
= NULL
;
10745 num_dynamic_syms
= 0;
10748 if (dynamic_syminfo
)
10750 free (dynamic_syminfo
);
10751 dynamic_syminfo
= NULL
;
10754 if (section_headers_groups
)
10756 free (section_headers_groups
);
10757 section_headers_groups
= NULL
;
10760 if (section_groups
)
10762 struct group_list
*g
, *next
;
10764 for (i
= 0; i
< group_count
; i
++)
10766 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10773 free (section_groups
);
10774 section_groups
= NULL
;
10780 /* Process an ELF archive. The file is positioned just after the
10784 process_archive (char *file_name
, FILE *file
)
10786 struct ar_hdr arhdr
;
10788 unsigned long size
;
10789 char *longnames
= NULL
;
10790 unsigned long longnames_size
= 0;
10791 size_t file_name_size
;
10796 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10797 if (got
!= sizeof arhdr
)
10802 error (_("%s: failed to read archive header\n"), file_name
);
10806 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
10808 /* This is the archive symbol table. Skip it.
10809 FIXME: We should have an option to dump it. */
10810 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10811 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
10813 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10817 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10818 if (got
!= sizeof arhdr
)
10823 error (_("%s: failed to read archive header\n"), file_name
);
10828 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
10830 /* This is the archive string table holding long member
10833 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10835 longnames
= malloc (longnames_size
);
10836 if (longnames
== NULL
)
10838 error (_("Out of memory\n"));
10842 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10845 error(_("%s: failed to read string table\n"), file_name
);
10849 if ((longnames_size
& 1) != 0)
10852 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10853 if (got
!= sizeof arhdr
)
10860 error (_("%s: failed to read archive header\n"), file_name
);
10865 file_name_size
= strlen (file_name
);
10874 if (arhdr
.ar_name
[0] == '/')
10878 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10879 if (off
>= longnames_size
)
10881 error (_("%s: invalid archive string table offset %lu\n"), off
);
10886 name
= longnames
+ off
;
10887 nameend
= memchr (name
, '/', longnames_size
- off
);
10891 name
= arhdr
.ar_name
;
10892 nameend
= memchr (name
, '/', 16);
10895 if (nameend
== NULL
)
10897 error (_("%s: bad archive file name\n"));
10902 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10903 if (namealc
== NULL
)
10905 error (_("Out of memory\n"));
10910 memcpy (namealc
, file_name
, file_name_size
);
10911 namealc
[file_name_size
] = '(';
10912 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10913 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10914 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10916 archive_file_offset
= ftell (file
);
10917 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10919 ret
|= process_object (namealc
, file
);
10924 (archive_file_offset
10925 + archive_file_size
10926 + (archive_file_size
& 1)),
10929 error (_("%s: failed to seek to next archive header\n"), file_name
);
10934 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10935 if (got
!= sizeof arhdr
)
10940 error (_("%s: failed to read archive header\n"), file_name
);
10946 if (longnames
!= 0)
10953 process_file (char *file_name
)
10956 struct stat statbuf
;
10957 char armag
[SARMAG
];
10960 if (stat (file_name
, &statbuf
) < 0)
10962 if (errno
== ENOENT
)
10963 error (_("'%s': No such file\n"), file_name
);
10965 error (_("Could not locate '%s'. System error message: %s\n"),
10966 file_name
, strerror (errno
));
10970 if (! S_ISREG (statbuf
.st_mode
))
10972 error (_("'%s' is not an ordinary file\n"), file_name
);
10976 file
= fopen (file_name
, "rb");
10979 error (_("Input file '%s' is not readable.\n"), file_name
);
10983 if (fread (armag
, SARMAG
, 1, file
) != 1)
10985 error (_("%s: Failed to read file header\n"), file_name
);
10990 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10991 ret
= process_archive (file_name
, file
);
10995 archive_file_size
= archive_file_offset
= 0;
10996 ret
= process_object (file_name
, file
);
11004 #ifdef SUPPORT_DISASSEMBLY
11005 /* Needed by the i386 disassembler. For extra credit, someone could
11006 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11010 print_address (unsigned int addr
, FILE *outfile
)
11012 fprintf (outfile
,"0x%8.8x", addr
);
11015 /* Needed by the i386 disassembler. */
11017 db_task_printsym (unsigned int addr
)
11019 print_address (addr
, stderr
);
11024 main (int argc
, char **argv
)
11027 char *cmdline_dump_sects
= NULL
;
11028 unsigned num_cmdline_dump_sects
= 0;
11030 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11031 setlocale (LC_MESSAGES
, "");
11033 #if defined (HAVE_SETLOCALE)
11034 setlocale (LC_CTYPE
, "");
11036 bindtextdomain (PACKAGE
, LOCALEDIR
);
11037 textdomain (PACKAGE
);
11039 parse_args (argc
, argv
);
11041 if (optind
< (argc
- 1))
11044 /* When processing more than one file remember the dump requests
11045 issued on command line to reset them after each file. */
11046 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
11048 cmdline_dump_sects
= malloc (num_dump_sects
);
11049 if (cmdline_dump_sects
== NULL
)
11050 error (_("Out of memory allocating dump request table."));
11053 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
11054 num_cmdline_dump_sects
= num_dump_sects
;
11059 while (optind
< argc
)
11061 err
|= process_file (argv
[optind
++]);
11063 /* Reset dump requests. */
11064 if (optind
< argc
&& dump_sects
!= NULL
)
11066 num_dump_sects
= num_cmdline_dump_sects
;
11067 if (num_cmdline_dump_sects
> 0)
11068 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11072 if (dump_sects
!= NULL
)
11074 if (cmdline_dump_sects
!= NULL
)
11075 free (cmdline_dump_sects
);