1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 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"
108 #include "elf/iq2000.h"
109 #include "elf/xtensa.h"
115 #include "libiberty.h"
117 char *program_name
= "readelf";
118 long archive_file_offset
;
119 unsigned long archive_file_size
;
120 unsigned long dynamic_addr
;
121 bfd_size_type dynamic_size
;
122 char *dynamic_strings
;
124 unsigned long string_table_length
;
125 unsigned long num_dynamic_syms
;
126 Elf_Internal_Sym
*dynamic_symbols
;
127 Elf_Internal_Syminfo
*dynamic_syminfo
;
128 unsigned long dynamic_syminfo_offset
;
129 unsigned int dynamic_syminfo_nent
;
130 char program_interpreter
[64];
131 bfd_vma dynamic_info
[DT_JMPREL
+ 1];
132 bfd_vma version_info
[16];
133 Elf_Internal_Ehdr elf_header
;
134 Elf_Internal_Shdr
*section_headers
;
135 Elf_Internal_Phdr
*program_headers
;
136 Elf_Internal_Dyn
*dynamic_segment
;
137 Elf_Internal_Shdr
*symtab_shndx_hdr
;
143 int do_section_groups
;
146 int do_using_dynamic
;
154 int do_debug_abbrevs
;
156 int do_debug_pubnames
;
157 int do_debug_aranges
;
159 int do_debug_frames_interp
;
160 int do_debug_macinfo
;
169 struct group_list
*next
;
170 unsigned int section_index
;
175 struct group_list
*root
;
176 unsigned int group_index
;
179 struct group
*section_groups
;
180 size_t group_count
= 0;
182 struct group
**section_headers_groups
;
184 /* A dynamic array of flags indicating which sections require dumping. */
185 char *dump_sects
= NULL
;
186 unsigned int num_dump_sects
= 0;
188 #define HEX_DUMP (1 << 0)
189 #define DISASS_DUMP (1 << 1)
190 #define DEBUG_DUMP (1 << 2)
192 /* How to rpint a vma value. */
193 typedef enum print_mode
205 static bfd_vma (*byte_get
) (unsigned char *, int);
206 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
208 typedef int Elf32_Word
;
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
:
709 warn (_("Don't know about relocations on this machine architecture\n"));
715 slurp_rela_relocs (FILE *file
,
716 unsigned long rel_offset
,
717 unsigned long rel_size
,
718 Elf_Internal_Rela
**relasp
,
719 unsigned long *nrelasp
)
721 Elf_Internal_Rela
*relas
;
722 unsigned long nrelas
;
727 Elf32_External_Rela
*erelas
;
729 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
733 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
735 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
739 error(_("out of memory parsing relocs"));
743 for (i
= 0; i
< nrelas
; i
++)
745 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
746 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
747 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
754 Elf64_External_Rela
*erelas
;
756 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
760 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
762 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
766 error(_("out of memory parsing relocs"));
770 for (i
= 0; i
< nrelas
; i
++)
772 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
773 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
774 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
785 slurp_rel_relocs (FILE *file
,
786 unsigned long rel_offset
,
787 unsigned long rel_size
,
788 Elf_Internal_Rela
**relsp
,
789 unsigned long *nrelsp
)
791 Elf_Internal_Rela
*rels
;
797 Elf32_External_Rel
*erels
;
799 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
803 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
805 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
809 error(_("out of memory parsing relocs"));
813 for (i
= 0; i
< nrels
; i
++)
815 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
816 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
817 rels
[i
].r_addend
= 0;
824 Elf64_External_Rel
*erels
;
826 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
830 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
832 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
836 error(_("out of memory parsing relocs"));
840 for (i
= 0; i
< nrels
; i
++)
842 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
843 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
844 rels
[i
].r_addend
= 0;
854 /* Display the contents of the relocation data found at the specified
858 dump_relocations (FILE *file
,
859 unsigned long rel_offset
,
860 unsigned long rel_size
,
861 Elf_Internal_Sym
*symtab
,
867 Elf_Internal_Rela
*rels
;
870 if (is_rela
== UNKNOWN
)
871 is_rela
= guess_is_rela (elf_header
.e_machine
);
875 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
880 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
889 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
891 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
896 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
898 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
906 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
908 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
913 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
915 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
919 for (i
= 0; i
< rel_size
; i
++)
922 const char *rtype2
= NULL
;
923 const char *rtype3
= NULL
;
926 bfd_vma symtab_index
;
931 offset
= rels
[i
].r_offset
;
932 info
= rels
[i
].r_info
;
936 type
= ELF32_R_TYPE (info
);
937 symtab_index
= ELF32_R_SYM (info
);
941 /* The #ifdef BFD64 below is to prevent a compile time warning.
942 We know that if we do not have a 64 bit data type that we
943 will never execute this code anyway. */
945 if (elf_header
.e_machine
== EM_MIPS
)
947 /* In little-endian objects, r_info isn't really a 64-bit
948 little-endian value: it has a 32-bit little-endian
949 symbol index followed by four individual byte fields.
950 Reorder INFO accordingly. */
951 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
952 info
= (((info
& 0xffffffff) << 32)
953 | ((info
>> 56) & 0xff)
954 | ((info
>> 40) & 0xff00)
955 | ((info
>> 24) & 0xff0000)
956 | ((info
>> 8) & 0xff000000));
957 type
= ELF64_MIPS_R_TYPE (info
);
958 type2
= ELF64_MIPS_R_TYPE2 (info
);
959 type3
= ELF64_MIPS_R_TYPE3 (info
);
961 else if (elf_header
.e_machine
== EM_SPARCV9
)
962 type
= ELF64_R_TYPE_ID (info
);
964 type
= ELF64_R_TYPE (info
);
966 symtab_index
= ELF64_R_SYM (info
);
972 #ifdef _bfd_int64_low
973 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
975 printf ("%8.8lx %8.8lx ", offset
, info
);
980 #ifdef _bfd_int64_low
982 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
983 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
984 _bfd_int64_high (offset
),
985 _bfd_int64_low (offset
),
986 _bfd_int64_high (info
),
987 _bfd_int64_low (info
));
990 ? "%16.16lx %16.16lx "
991 : "%12.12lx %12.12lx ",
996 switch (elf_header
.e_machine
)
1003 case EM_CYGNUS_M32R
:
1004 rtype
= elf_m32r_reloc_type (type
);
1009 rtype
= elf_i386_reloc_type (type
);
1014 rtype
= elf_m68hc11_reloc_type (type
);
1018 rtype
= elf_m68k_reloc_type (type
);
1022 rtype
= elf_i960_reloc_type (type
);
1027 rtype
= elf_avr_reloc_type (type
);
1030 case EM_OLD_SPARCV9
:
1031 case EM_SPARC32PLUS
:
1034 rtype
= elf_sparc_reloc_type (type
);
1038 case EM_CYGNUS_V850
:
1039 rtype
= v850_reloc_type (type
);
1043 case EM_CYGNUS_D10V
:
1044 rtype
= elf_d10v_reloc_type (type
);
1048 case EM_CYGNUS_D30V
:
1049 rtype
= elf_d30v_reloc_type (type
);
1053 rtype
= elf_dlx_reloc_type (type
);
1057 rtype
= elf_sh_reloc_type (type
);
1061 case EM_CYGNUS_MN10300
:
1062 rtype
= elf_mn10300_reloc_type (type
);
1066 case EM_CYGNUS_MN10200
:
1067 rtype
= elf_mn10200_reloc_type (type
);
1071 case EM_CYGNUS_FR30
:
1072 rtype
= elf_fr30_reloc_type (type
);
1076 rtype
= elf_frv_reloc_type (type
);
1080 rtype
= elf_mcore_reloc_type (type
);
1084 rtype
= elf_mmix_reloc_type (type
);
1089 rtype
= elf_msp430_reloc_type (type
);
1093 rtype
= elf_ppc_reloc_type (type
);
1097 rtype
= elf_ppc64_reloc_type (type
);
1101 case EM_MIPS_RS3_LE
:
1102 rtype
= elf_mips_reloc_type (type
);
1105 rtype2
= elf_mips_reloc_type (type2
);
1106 rtype3
= elf_mips_reloc_type (type3
);
1111 rtype
= elf_alpha_reloc_type (type
);
1115 rtype
= elf_arm_reloc_type (type
);
1119 rtype
= elf_arc_reloc_type (type
);
1123 rtype
= elf_hppa_reloc_type (type
);
1129 rtype
= elf_h8_reloc_type (type
);
1134 rtype
= elf_or32_reloc_type (type
);
1139 rtype
= elf_pj_reloc_type (type
);
1142 rtype
= elf_ia64_reloc_type (type
);
1146 rtype
= elf_cris_reloc_type (type
);
1150 rtype
= elf_i860_reloc_type (type
);
1154 rtype
= elf_x86_64_reloc_type (type
);
1158 rtype
= i370_reloc_type (type
);
1163 rtype
= elf_s390_reloc_type (type
);
1167 rtype
= elf_xstormy16_reloc_type (type
);
1171 rtype
= elf_vax_reloc_type (type
);
1176 rtype
= elf_ip2k_reloc_type (type
);
1180 rtype
= elf_iq2000_reloc_type (type
);
1185 rtype
= elf_xtensa_reloc_type (type
);
1190 #ifdef _bfd_int64_low
1191 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1193 printf (_("unrecognized: %-7lx"), type
);
1196 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1200 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1201 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1204 Elf_Internal_Sym
*psym
;
1206 psym
= symtab
+ symtab_index
;
1209 print_vma (psym
->st_value
, LONG_HEX
);
1210 printf (is_32bit_elf
? " " : " ");
1212 if (psym
->st_name
== 0)
1214 const char *sec_name
= "<null>";
1217 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1219 bfd_vma sec_index
= (bfd_vma
) -1;
1221 if (psym
->st_shndx
< SHN_LORESERVE
)
1222 sec_index
= psym
->st_shndx
;
1223 else if (psym
->st_shndx
> SHN_LORESERVE
)
1224 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1227 if (sec_index
!= (bfd_vma
) -1)
1228 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1229 else if (psym
->st_shndx
== SHN_ABS
)
1231 else if (psym
->st_shndx
== SHN_COMMON
)
1232 sec_name
= "COMMON";
1233 else if (elf_header
.e_machine
== EM_IA_64
1234 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1235 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1236 sec_name
= "ANSI_COM";
1239 sprintf (name_buf
, "<section 0x%x>",
1240 (unsigned int) psym
->st_shndx
);
1241 sec_name
= name_buf
;
1244 print_symbol (22, sec_name
);
1246 else if (strtab
== NULL
)
1247 printf (_("<string table index %3ld>"), psym
->st_name
);
1249 print_symbol (22, strtab
+ psym
->st_name
);
1252 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1257 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1258 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1261 if (elf_header
.e_machine
== EM_SPARCV9
1262 && !strcmp (rtype
, "R_SPARC_OLO10"))
1263 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1267 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1269 printf (" Type2: ");
1272 #ifdef _bfd_int64_low
1273 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1275 printf (_("unrecognized: %-7lx"), type2
);
1278 printf ("%-17.17s", rtype2
);
1280 printf("\n Type3: ");
1283 #ifdef _bfd_int64_low
1284 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1286 printf (_("unrecognized: %-7lx"), type3
);
1289 printf ("%-17.17s", rtype3
);
1301 get_mips_dynamic_type (unsigned long type
)
1305 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1306 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1307 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1308 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1309 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1310 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1311 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1312 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1313 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1314 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1315 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1316 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1317 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1318 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1319 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1320 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1321 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1322 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1323 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1324 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1325 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1326 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1327 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1328 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1329 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1330 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1331 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1332 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1333 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1334 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1335 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1336 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1337 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1338 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1339 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1340 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1341 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1342 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1343 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1344 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1345 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1346 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1347 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1354 get_sparc64_dynamic_type (unsigned long type
)
1358 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1365 get_ppc64_dynamic_type (unsigned long type
)
1369 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1370 case DT_PPC64_OPD
: return "PPC64_OPD";
1371 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1378 get_parisc_dynamic_type (unsigned long type
)
1382 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1383 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1384 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1385 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1386 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1387 case DT_HP_PREINIT
: return "HP_PREINIT";
1388 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1389 case DT_HP_NEEDED
: return "HP_NEEDED";
1390 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1391 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1392 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1393 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1394 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1401 get_ia64_dynamic_type (unsigned long type
)
1405 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1412 get_dynamic_type (unsigned long type
)
1414 static char buff
[32];
1418 case DT_NULL
: return "NULL";
1419 case DT_NEEDED
: return "NEEDED";
1420 case DT_PLTRELSZ
: return "PLTRELSZ";
1421 case DT_PLTGOT
: return "PLTGOT";
1422 case DT_HASH
: return "HASH";
1423 case DT_STRTAB
: return "STRTAB";
1424 case DT_SYMTAB
: return "SYMTAB";
1425 case DT_RELA
: return "RELA";
1426 case DT_RELASZ
: return "RELASZ";
1427 case DT_RELAENT
: return "RELAENT";
1428 case DT_STRSZ
: return "STRSZ";
1429 case DT_SYMENT
: return "SYMENT";
1430 case DT_INIT
: return "INIT";
1431 case DT_FINI
: return "FINI";
1432 case DT_SONAME
: return "SONAME";
1433 case DT_RPATH
: return "RPATH";
1434 case DT_SYMBOLIC
: return "SYMBOLIC";
1435 case DT_REL
: return "REL";
1436 case DT_RELSZ
: return "RELSZ";
1437 case DT_RELENT
: return "RELENT";
1438 case DT_PLTREL
: return "PLTREL";
1439 case DT_DEBUG
: return "DEBUG";
1440 case DT_TEXTREL
: return "TEXTREL";
1441 case DT_JMPREL
: return "JMPREL";
1442 case DT_BIND_NOW
: return "BIND_NOW";
1443 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1444 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1445 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1446 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1447 case DT_RUNPATH
: return "RUNPATH";
1448 case DT_FLAGS
: return "FLAGS";
1450 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1451 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1453 case DT_CHECKSUM
: return "CHECKSUM";
1454 case DT_PLTPADSZ
: return "PLTPADSZ";
1455 case DT_MOVEENT
: return "MOVEENT";
1456 case DT_MOVESZ
: return "MOVESZ";
1457 case DT_FEATURE
: return "FEATURE";
1458 case DT_POSFLAG_1
: return "POSFLAG_1";
1459 case DT_SYMINSZ
: return "SYMINSZ";
1460 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1462 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1463 case DT_CONFIG
: return "CONFIG";
1464 case DT_DEPAUDIT
: return "DEPAUDIT";
1465 case DT_AUDIT
: return "AUDIT";
1466 case DT_PLTPAD
: return "PLTPAD";
1467 case DT_MOVETAB
: return "MOVETAB";
1468 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1470 case DT_VERSYM
: return "VERSYM";
1472 case DT_RELACOUNT
: return "RELACOUNT";
1473 case DT_RELCOUNT
: return "RELCOUNT";
1474 case DT_FLAGS_1
: return "FLAGS_1";
1475 case DT_VERDEF
: return "VERDEF";
1476 case DT_VERDEFNUM
: return "VERDEFNUM";
1477 case DT_VERNEED
: return "VERNEED";
1478 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1480 case DT_AUXILIARY
: return "AUXILIARY";
1481 case DT_USED
: return "USED";
1482 case DT_FILTER
: return "FILTER";
1484 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1485 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1486 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1487 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1488 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1491 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1495 switch (elf_header
.e_machine
)
1498 case EM_MIPS_RS3_LE
:
1499 result
= get_mips_dynamic_type (type
);
1502 result
= get_sparc64_dynamic_type (type
);
1505 result
= get_ppc64_dynamic_type (type
);
1508 result
= get_ia64_dynamic_type (type
);
1518 sprintf (buff
, _("Processor Specific: %lx"), type
);
1520 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1524 switch (elf_header
.e_machine
)
1527 result
= get_parisc_dynamic_type (type
);
1537 sprintf (buff
, _("Operating System specific: %lx"), type
);
1540 sprintf (buff
, _("<unknown>: %lx"), type
);
1547 get_file_type (unsigned e_type
)
1549 static char buff
[32];
1553 case ET_NONE
: return _("NONE (None)");
1554 case ET_REL
: return _("REL (Relocatable file)");
1555 case ET_EXEC
: return _("EXEC (Executable file)");
1556 case ET_DYN
: return _("DYN (Shared object file)");
1557 case ET_CORE
: return _("CORE (Core file)");
1560 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1561 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1562 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1563 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1565 sprintf (buff
, _("<unknown>: %x"), e_type
);
1571 get_machine_name (unsigned e_machine
)
1573 static char buff
[64]; /* XXX */
1577 case EM_NONE
: return _("None");
1578 case EM_M32
: return "WE32100";
1579 case EM_SPARC
: return "Sparc";
1580 case EM_386
: return "Intel 80386";
1581 case EM_68K
: return "MC68000";
1582 case EM_88K
: return "MC88000";
1583 case EM_486
: return "Intel 80486";
1584 case EM_860
: return "Intel 80860";
1585 case EM_MIPS
: return "MIPS R3000";
1586 case EM_S370
: return "IBM System/370";
1587 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1588 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1589 case EM_PARISC
: return "HPPA";
1590 case EM_PPC_OLD
: return "Power PC (old)";
1591 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1592 case EM_960
: return "Intel 90860";
1593 case EM_PPC
: return "PowerPC";
1594 case EM_PPC64
: return "PowerPC64";
1595 case EM_V800
: return "NEC V800";
1596 case EM_FR20
: return "Fujitsu FR20";
1597 case EM_RH32
: return "TRW RH32";
1598 case EM_MCORE
: return "MCORE";
1599 case EM_ARM
: return "ARM";
1600 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1601 case EM_SH
: return "Renesas / SuperH SH";
1602 case EM_SPARCV9
: return "Sparc v9";
1603 case EM_TRICORE
: return "Siemens Tricore";
1604 case EM_ARC
: return "ARC";
1605 case EM_H8_300
: return "Renesas H8/300";
1606 case EM_H8_300H
: return "Renesas H8/300H";
1607 case EM_H8S
: return "Renesas H8S";
1608 case EM_H8_500
: return "Renesas H8/500";
1609 case EM_IA_64
: return "Intel IA-64";
1610 case EM_MIPS_X
: return "Stanford MIPS-X";
1611 case EM_COLDFIRE
: return "Motorola Coldfire";
1612 case EM_68HC12
: return "Motorola M68HC12";
1613 case EM_ALPHA
: return "Alpha";
1614 case EM_CYGNUS_D10V
:
1615 case EM_D10V
: return "d10v";
1616 case EM_CYGNUS_D30V
:
1617 case EM_D30V
: return "d30v";
1618 case EM_CYGNUS_M32R
:
1619 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1620 case EM_CYGNUS_V850
:
1621 case EM_V850
: return "NEC v850";
1622 case EM_CYGNUS_MN10300
:
1623 case EM_MN10300
: return "mn10300";
1624 case EM_CYGNUS_MN10200
:
1625 case EM_MN10200
: return "mn10200";
1626 case EM_CYGNUS_FR30
:
1627 case EM_FR30
: return "Fujitsu FR30";
1628 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1630 case EM_PJ
: return "picoJava";
1631 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1632 case EM_PCP
: return "Siemens PCP";
1633 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1634 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1635 case EM_STARCORE
: return "Motorola Star*Core processor";
1636 case EM_ME16
: return "Toyota ME16 processor";
1637 case EM_ST100
: return "STMicroelectronics ST100 processor";
1638 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1639 case EM_FX66
: return "Siemens FX66 microcontroller";
1640 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1641 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1642 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1643 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1644 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1645 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1646 case EM_SVX
: return "Silicon Graphics SVx";
1647 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1648 case EM_VAX
: return "Digital VAX";
1650 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1651 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1652 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1653 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1654 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1655 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1656 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1657 case EM_PRISM
: return "Vitesse Prism";
1658 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1660 case EM_S390
: return "IBM S/390";
1661 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1663 case EM_OR32
: return "OpenRISC";
1664 case EM_DLX
: return "OpenDLX";
1666 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1667 case EM_IQ2000
: return "Vitesse IQ2000";
1669 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1671 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1677 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1682 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1683 e_flags
&= ~ EF_ARM_EABIMASK
;
1685 /* Handle "generic" ARM flags. */
1686 if (e_flags
& EF_ARM_RELEXEC
)
1688 strcat (buf
, ", relocatable executable");
1689 e_flags
&= ~ EF_ARM_RELEXEC
;
1692 if (e_flags
& EF_ARM_HASENTRY
)
1694 strcat (buf
, ", has entry point");
1695 e_flags
&= ~ EF_ARM_HASENTRY
;
1698 /* Now handle EABI specific flags. */
1702 strcat (buf
, ", <unrecognized EABI>");
1707 case EF_ARM_EABI_VER1
:
1708 strcat (buf
, ", Version1 EABI");
1713 /* Process flags one bit at a time. */
1714 flag
= e_flags
& - e_flags
;
1719 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1720 strcat (buf
, ", sorted symbol tables");
1730 case EF_ARM_EABI_VER2
:
1731 strcat (buf
, ", Version2 EABI");
1736 /* Process flags one bit at a time. */
1737 flag
= e_flags
& - e_flags
;
1742 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1743 strcat (buf
, ", sorted symbol tables");
1746 case EF_ARM_DYNSYMSUSESEGIDX
:
1747 strcat (buf
, ", dynamic symbols use segment index");
1750 case EF_ARM_MAPSYMSFIRST
:
1751 strcat (buf
, ", mapping symbols precede others");
1761 case EF_ARM_EABI_VER3
:
1762 strcat (buf
, ", Version3 EABI");
1767 /* Process flags one bit at a time. */
1768 flag
= e_flags
& - e_flags
;
1774 strcat (buf
, ", BE8");
1778 strcat (buf
, ", LE8");
1788 case EF_ARM_EABI_UNKNOWN
:
1789 strcat (buf
, ", GNU EABI");
1794 /* Process flags one bit at a time. */
1795 flag
= e_flags
& - e_flags
;
1800 case EF_ARM_INTERWORK
:
1801 strcat (buf
, ", interworking enabled");
1804 case EF_ARM_APCS_26
:
1805 strcat (buf
, ", uses APCS/26");
1808 case EF_ARM_APCS_FLOAT
:
1809 strcat (buf
, ", uses APCS/float");
1813 strcat (buf
, ", position independent");
1817 strcat (buf
, ", 8 bit structure alignment");
1820 case EF_ARM_NEW_ABI
:
1821 strcat (buf
, ", uses new ABI");
1824 case EF_ARM_OLD_ABI
:
1825 strcat (buf
, ", uses old ABI");
1828 case EF_ARM_SOFT_FLOAT
:
1829 strcat (buf
, ", software FP");
1832 case EF_ARM_MAVERICK_FLOAT
:
1833 strcat (buf
, ", Maverick FP");
1844 strcat (buf
,", <unknown>");
1848 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1850 static char buf
[1024];
1862 decode_ARM_machine_flags (e_flags
, buf
);
1866 if (e_flags
& EF_CPU32
)
1867 strcat (buf
, ", cpu32");
1868 if (e_flags
& EF_M68000
)
1869 strcat (buf
, ", m68000");
1873 if (e_flags
& EF_PPC_EMB
)
1874 strcat (buf
, ", emb");
1876 if (e_flags
& EF_PPC_RELOCATABLE
)
1877 strcat (buf
, ", relocatable");
1879 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1880 strcat (buf
, ", relocatable-lib");
1884 case EM_CYGNUS_V850
:
1885 switch (e_flags
& EF_V850_ARCH
)
1888 strcat (buf
, ", v850e1");
1891 strcat (buf
, ", v850e");
1894 strcat (buf
, ", v850");
1897 strcat (buf
, ", unknown v850 architecture variant");
1903 case EM_CYGNUS_M32R
:
1904 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1905 strcat (buf
, ", m32r");
1910 case EM_MIPS_RS3_LE
:
1911 if (e_flags
& EF_MIPS_NOREORDER
)
1912 strcat (buf
, ", noreorder");
1914 if (e_flags
& EF_MIPS_PIC
)
1915 strcat (buf
, ", pic");
1917 if (e_flags
& EF_MIPS_CPIC
)
1918 strcat (buf
, ", cpic");
1920 if (e_flags
& EF_MIPS_UCODE
)
1921 strcat (buf
, ", ugen_reserved");
1923 if (e_flags
& EF_MIPS_ABI2
)
1924 strcat (buf
, ", abi2");
1926 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1927 strcat (buf
, ", odk first");
1929 if (e_flags
& EF_MIPS_32BITMODE
)
1930 strcat (buf
, ", 32bitmode");
1932 switch ((e_flags
& EF_MIPS_MACH
))
1934 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1935 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1936 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1937 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1938 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1939 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1940 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1941 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1942 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1944 /* We simply ignore the field in this case to avoid confusion:
1945 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1948 default: strcat (buf
, ", unknown CPU"); break;
1951 switch ((e_flags
& EF_MIPS_ABI
))
1953 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1954 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1955 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1956 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1958 /* We simply ignore the field in this case to avoid confusion:
1959 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1960 This means it is likely to be an o32 file, but not for
1963 default: strcat (buf
, ", unknown ABI"); break;
1966 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1967 strcat (buf
, ", mdmx");
1969 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1970 strcat (buf
, ", mips16");
1972 switch ((e_flags
& EF_MIPS_ARCH
))
1974 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1975 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1976 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1977 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1978 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1979 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1980 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
1981 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1982 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
1983 default: strcat (buf
, ", unknown ISA"); break;
1989 if (e_flags
& EF_SPARC_32PLUS
)
1990 strcat (buf
, ", v8+");
1992 if (e_flags
& EF_SPARC_SUN_US1
)
1993 strcat (buf
, ", ultrasparcI");
1995 if (e_flags
& EF_SPARC_SUN_US3
)
1996 strcat (buf
, ", ultrasparcIII");
1998 if (e_flags
& EF_SPARC_HAL_R1
)
1999 strcat (buf
, ", halr1");
2001 if (e_flags
& EF_SPARC_LEDATA
)
2002 strcat (buf
, ", ledata");
2004 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2005 strcat (buf
, ", tso");
2007 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2008 strcat (buf
, ", pso");
2010 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2011 strcat (buf
, ", rmo");
2015 switch (e_flags
& EF_PARISC_ARCH
)
2017 case EFA_PARISC_1_0
:
2018 strcpy (buf
, ", PA-RISC 1.0");
2020 case EFA_PARISC_1_1
:
2021 strcpy (buf
, ", PA-RISC 1.1");
2023 case EFA_PARISC_2_0
:
2024 strcpy (buf
, ", PA-RISC 2.0");
2029 if (e_flags
& EF_PARISC_TRAPNIL
)
2030 strcat (buf
, ", trapnil");
2031 if (e_flags
& EF_PARISC_EXT
)
2032 strcat (buf
, ", ext");
2033 if (e_flags
& EF_PARISC_LSB
)
2034 strcat (buf
, ", lsb");
2035 if (e_flags
& EF_PARISC_WIDE
)
2036 strcat (buf
, ", wide");
2037 if (e_flags
& EF_PARISC_NO_KABP
)
2038 strcat (buf
, ", no kabp");
2039 if (e_flags
& EF_PARISC_LAZYSWAP
)
2040 strcat (buf
, ", lazyswap");
2045 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2046 strcat (buf
, ", new calling convention");
2048 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2049 strcat (buf
, ", gnu calling convention");
2053 if ((e_flags
& EF_IA_64_ABI64
))
2054 strcat (buf
, ", 64-bit");
2056 strcat (buf
, ", 32-bit");
2057 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2058 strcat (buf
, ", reduced fp model");
2059 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2060 strcat (buf
, ", no function descriptors, constant gp");
2061 else if ((e_flags
& EF_IA_64_CONS_GP
))
2062 strcat (buf
, ", constant gp");
2063 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2064 strcat (buf
, ", absolute");
2068 if ((e_flags
& EF_VAX_NONPIC
))
2069 strcat (buf
, ", non-PIC");
2070 if ((e_flags
& EF_VAX_DFLOAT
))
2071 strcat (buf
, ", D-Float");
2072 if ((e_flags
& EF_VAX_GFLOAT
))
2073 strcat (buf
, ", G-Float");
2082 get_osabi_name (unsigned int osabi
)
2084 static char buff
[32];
2088 case ELFOSABI_NONE
: return "UNIX - System V";
2089 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2090 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2091 case ELFOSABI_LINUX
: return "UNIX - Linux";
2092 case ELFOSABI_HURD
: return "GNU/Hurd";
2093 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2094 case ELFOSABI_AIX
: return "UNIX - AIX";
2095 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2096 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2097 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2098 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2099 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2100 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2101 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2102 case ELFOSABI_AROS
: return "Amiga Research OS";
2103 case ELFOSABI_STANDALONE
: return _("Standalone App");
2104 case ELFOSABI_ARM
: return "ARM";
2106 sprintf (buff
, _("<unknown: %x>"), osabi
);
2112 get_mips_segment_type (unsigned long type
)
2116 case PT_MIPS_REGINFO
:
2118 case PT_MIPS_RTPROC
:
2120 case PT_MIPS_OPTIONS
:
2130 get_parisc_segment_type (unsigned long type
)
2134 case PT_HP_TLS
: return "HP_TLS";
2135 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2136 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2137 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2138 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2139 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2140 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2141 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2142 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2143 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2144 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2145 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2146 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2147 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2156 get_ia64_segment_type (unsigned long type
)
2160 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2161 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2162 case PT_HP_TLS
: return "HP_TLS";
2163 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2164 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2165 case PT_IA_64_HP_STACK
: return "HP_STACK";
2174 get_segment_type (unsigned long p_type
)
2176 static char buff
[32];
2180 case PT_NULL
: return "NULL";
2181 case PT_LOAD
: return "LOAD";
2182 case PT_DYNAMIC
: return "DYNAMIC";
2183 case PT_INTERP
: return "INTERP";
2184 case PT_NOTE
: return "NOTE";
2185 case PT_SHLIB
: return "SHLIB";
2186 case PT_PHDR
: return "PHDR";
2187 case PT_TLS
: return "TLS";
2189 case PT_GNU_EH_FRAME
:
2190 return "GNU_EH_FRAME";
2191 case PT_GNU_STACK
: return "STACK";
2192 case PT_GNU_RELRO
: return "GNU_RELRO";
2195 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2199 switch (elf_header
.e_machine
)
2202 case EM_MIPS_RS3_LE
:
2203 result
= get_mips_segment_type (p_type
);
2206 result
= get_parisc_segment_type (p_type
);
2209 result
= get_ia64_segment_type (p_type
);
2219 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2221 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2225 switch (elf_header
.e_machine
)
2228 result
= get_parisc_segment_type (p_type
);
2231 result
= get_ia64_segment_type (p_type
);
2241 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2244 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2251 get_mips_section_type_name (unsigned int sh_type
)
2255 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2256 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2257 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2258 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2259 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2260 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2261 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2262 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2263 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2264 case SHT_MIPS_RELD
: return "MIPS_RELD";
2265 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2266 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2267 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2268 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2269 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2270 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2271 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2272 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2273 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2274 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2275 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2276 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2277 case SHT_MIPS_LINE
: return "MIPS_LINE";
2278 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2279 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2280 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2281 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2282 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2283 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2284 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2285 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2286 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2287 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2288 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2289 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2290 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2291 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2292 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2293 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2301 get_parisc_section_type_name (unsigned int sh_type
)
2305 case SHT_PARISC_EXT
: return "PARISC_EXT";
2306 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2307 case SHT_PARISC_DOC
: return "PARISC_DOC";
2315 get_ia64_section_type_name (unsigned int sh_type
)
2317 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2318 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2319 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2323 case SHT_IA_64_EXT
: return "IA_64_EXT";
2324 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2325 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2333 get_section_type_name (unsigned int sh_type
)
2335 static char buff
[32];
2339 case SHT_NULL
: return "NULL";
2340 case SHT_PROGBITS
: return "PROGBITS";
2341 case SHT_SYMTAB
: return "SYMTAB";
2342 case SHT_STRTAB
: return "STRTAB";
2343 case SHT_RELA
: return "RELA";
2344 case SHT_HASH
: return "HASH";
2345 case SHT_DYNAMIC
: return "DYNAMIC";
2346 case SHT_NOTE
: return "NOTE";
2347 case SHT_NOBITS
: return "NOBITS";
2348 case SHT_REL
: return "REL";
2349 case SHT_SHLIB
: return "SHLIB";
2350 case SHT_DYNSYM
: return "DYNSYM";
2351 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2352 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2353 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2354 case SHT_GROUP
: return "GROUP";
2355 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2356 case SHT_GNU_verdef
: return "VERDEF";
2357 case SHT_GNU_verneed
: return "VERNEED";
2358 case SHT_GNU_versym
: return "VERSYM";
2359 case 0x6ffffff0: return "VERSYM";
2360 case 0x6ffffffc: return "VERDEF";
2361 case 0x7ffffffd: return "AUXILIARY";
2362 case 0x7fffffff: return "FILTER";
2363 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2366 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2370 switch (elf_header
.e_machine
)
2373 case EM_MIPS_RS3_LE
:
2374 result
= get_mips_section_type_name (sh_type
);
2377 result
= get_parisc_section_type_name (sh_type
);
2380 result
= get_ia64_section_type_name (sh_type
);
2390 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2392 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2393 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2394 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2395 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2397 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2403 #define OPTION_DEBUG_DUMP 512
2405 struct option options
[] =
2407 {"all", no_argument
, 0, 'a'},
2408 {"file-header", no_argument
, 0, 'h'},
2409 {"program-headers", no_argument
, 0, 'l'},
2410 {"headers", no_argument
, 0, 'e'},
2411 {"histogram", no_argument
, 0, 'I'},
2412 {"segments", no_argument
, 0, 'l'},
2413 {"sections", no_argument
, 0, 'S'},
2414 {"section-headers", no_argument
, 0, 'S'},
2415 {"section-groups", no_argument
, 0, 'g'},
2416 {"symbols", no_argument
, 0, 's'},
2417 {"syms", no_argument
, 0, 's'},
2418 {"relocs", no_argument
, 0, 'r'},
2419 {"notes", no_argument
, 0, 'n'},
2420 {"dynamic", no_argument
, 0, 'd'},
2421 {"arch-specific", no_argument
, 0, 'A'},
2422 {"version-info", no_argument
, 0, 'V'},
2423 {"use-dynamic", no_argument
, 0, 'D'},
2424 {"hex-dump", required_argument
, 0, 'x'},
2425 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2426 {"unwind", no_argument
, 0, 'u'},
2427 #ifdef SUPPORT_DISASSEMBLY
2428 {"instruction-dump", required_argument
, 0, 'i'},
2431 {"version", no_argument
, 0, 'v'},
2432 {"wide", no_argument
, 0, 'W'},
2433 {"help", no_argument
, 0, 'H'},
2434 {0, no_argument
, 0, 0}
2440 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2441 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2442 fprintf (stdout
, _(" Options are:\n\
2443 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2444 -h --file-header Display the ELF file header\n\
2445 -l --program-headers Display the program headers\n\
2446 --segments An alias for --program-headers\n\
2447 -S --section-headers Display the sections' header\n\
2448 --sections An alias for --section-headers\n\
2449 -g --section-groups Display the section groups\n\
2450 -e --headers Equivalent to: -h -l -S\n\
2451 -s --syms Display the symbol table\n\
2452 --symbols An alias for --syms\n\
2453 -n --notes Display the core notes (if present)\n\
2454 -r --relocs Display the relocations (if present)\n\
2455 -u --unwind Display the unwind info (if present)\n\
2456 -d --dynamic Display the dynamic segment (if present)\n\
2457 -V --version-info Display the version sections (if present)\n\
2458 -A --arch-specific Display architecture specific information (if any).\n\
2459 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2460 -x --hex-dump=<number> Dump the contents of section <number>\n\
2461 -w[liaprmfFso] or\n\
2462 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2463 Display the contents of DWARF2 debug sections\n"));
2464 #ifdef SUPPORT_DISASSEMBLY
2465 fprintf (stdout
, _("\
2466 -i --instruction-dump=<number>\n\
2467 Disassemble the contents of section <number>\n"));
2469 fprintf (stdout
, _("\
2470 -I --histogram Display histogram of bucket list lengths\n\
2471 -W --wide Allow output width to exceed 80 characters\n\
2472 -H --help Display this information\n\
2473 -v --version Display the version number of readelf\n"));
2474 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2480 request_dump (unsigned int section
, int type
)
2482 if (section
>= num_dump_sects
)
2484 char *new_dump_sects
;
2486 new_dump_sects
= calloc (section
+ 1, 1);
2488 if (new_dump_sects
== NULL
)
2489 error (_("Out of memory allocating dump request table."));
2492 /* Copy current flag settings. */
2493 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2497 dump_sects
= new_dump_sects
;
2498 num_dump_sects
= section
+ 1;
2503 dump_sects
[section
] |= type
;
2509 parse_args (int argc
, char **argv
)
2516 while ((c
= getopt_long
2517 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2538 do_section_groups
++;
2546 do_section_groups
++;
2588 section
= strtoul (optarg
, & cp
, 0);
2589 if (! *cp
&& section
>= 0)
2591 request_dump (section
, HEX_DUMP
);
2601 unsigned int index
= 0;
2605 while (optarg
[index
])
2606 switch (optarg
[index
++])
2615 do_debug_abbrevs
= 1;
2625 do_debug_pubnames
= 1;
2630 do_debug_aranges
= 1;
2634 do_debug_frames_interp
= 1;
2636 do_debug_frames
= 1;
2641 do_debug_macinfo
= 1;
2655 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2660 case OPTION_DEBUG_DUMP
:
2666 static const char *debug_dump_opt
[]
2667 = { "line", "info", "abbrev", "pubnames", "ranges",
2668 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2677 for (index
= 0; debug_dump_opt
[index
]; index
++)
2679 size_t len
= strlen (debug_dump_opt
[index
]);
2681 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2682 && (p
[len
] == ',' || p
[len
] == '\0'))
2691 do_debug_abbrevs
= 1;
2702 do_debug_pubnames
= 1;
2706 do_debug_aranges
= 1;
2711 do_debug_frames_interp
= 1;
2712 do_debug_frames
= 1;
2716 do_debug_macinfo
= 1;
2729 if (debug_dump_opt
[index
] == NULL
)
2731 warn (_("Unrecognized debug option '%s'\n"), p
);
2732 p
= strchr (p
, ',');
2742 #ifdef SUPPORT_DISASSEMBLY
2745 section
= strtoul (optarg
, & cp
, 0);
2746 if (! *cp
&& section
>= 0)
2748 request_dump (section
, DISASS_DUMP
);
2754 print_version (program_name
);
2764 /* xgettext:c-format */
2765 error (_("Invalid option '-%c'\n"), c
);
2772 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2773 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2774 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2775 && !do_section_groups
)
2779 warn (_("Nothing to do.\n"));
2785 get_elf_class (unsigned int elf_class
)
2787 static char buff
[32];
2791 case ELFCLASSNONE
: return _("none");
2792 case ELFCLASS32
: return "ELF32";
2793 case ELFCLASS64
: return "ELF64";
2795 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2801 get_data_encoding (unsigned int encoding
)
2803 static char buff
[32];
2807 case ELFDATANONE
: return _("none");
2808 case ELFDATA2LSB
: return _("2's complement, little endian");
2809 case ELFDATA2MSB
: return _("2's complement, big endian");
2811 sprintf (buff
, _("<unknown: %x>"), encoding
);
2816 /* Decode the data held in 'elf_header'. */
2819 process_file_header (void)
2821 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2822 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2823 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2824 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2827 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2835 printf (_("ELF Header:\n"));
2836 printf (_(" Magic: "));
2837 for (i
= 0; i
< EI_NIDENT
; i
++)
2838 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2840 printf (_(" Class: %s\n"),
2841 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2842 printf (_(" Data: %s\n"),
2843 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2844 printf (_(" Version: %d %s\n"),
2845 elf_header
.e_ident
[EI_VERSION
],
2846 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2848 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2851 printf (_(" OS/ABI: %s\n"),
2852 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2853 printf (_(" ABI Version: %d\n"),
2854 elf_header
.e_ident
[EI_ABIVERSION
]);
2855 printf (_(" Type: %s\n"),
2856 get_file_type (elf_header
.e_type
));
2857 printf (_(" Machine: %s\n"),
2858 get_machine_name (elf_header
.e_machine
));
2859 printf (_(" Version: 0x%lx\n"),
2860 (unsigned long) elf_header
.e_version
);
2862 printf (_(" Entry point address: "));
2863 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2864 printf (_("\n Start of program headers: "));
2865 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2866 printf (_(" (bytes into file)\n Start of section headers: "));
2867 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2868 printf (_(" (bytes into file)\n"));
2870 printf (_(" Flags: 0x%lx%s\n"),
2871 (unsigned long) elf_header
.e_flags
,
2872 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2873 printf (_(" Size of this header: %ld (bytes)\n"),
2874 (long) elf_header
.e_ehsize
);
2875 printf (_(" Size of program headers: %ld (bytes)\n"),
2876 (long) elf_header
.e_phentsize
);
2877 printf (_(" Number of program headers: %ld\n"),
2878 (long) elf_header
.e_phnum
);
2879 printf (_(" Size of section headers: %ld (bytes)\n"),
2880 (long) elf_header
.e_shentsize
);
2881 printf (_(" Number of section headers: %ld"),
2882 (long) elf_header
.e_shnum
);
2883 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2884 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2885 putc ('\n', stdout
);
2886 printf (_(" Section header string table index: %ld"),
2887 (long) elf_header
.e_shstrndx
);
2888 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2889 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2890 putc ('\n', stdout
);
2893 if (section_headers
!= NULL
)
2895 if (elf_header
.e_shnum
== 0)
2896 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2897 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2898 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2899 free (section_headers
);
2900 section_headers
= NULL
;
2908 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
2910 Elf32_External_Phdr
*phdrs
;
2911 Elf32_External_Phdr
*external
;
2912 Elf_Internal_Phdr
*internal
;
2915 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
2916 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2917 _("program headers"));
2921 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2922 i
< elf_header
.e_phnum
;
2923 i
++, internal
++, external
++)
2925 internal
->p_type
= BYTE_GET (external
->p_type
);
2926 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2927 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2928 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2929 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2930 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2931 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2932 internal
->p_align
= BYTE_GET (external
->p_align
);
2941 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
2943 Elf64_External_Phdr
*phdrs
;
2944 Elf64_External_Phdr
*external
;
2945 Elf_Internal_Phdr
*internal
;
2948 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
2949 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2950 _("program headers"));
2954 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2955 i
< elf_header
.e_phnum
;
2956 i
++, internal
++, external
++)
2958 internal
->p_type
= BYTE_GET (external
->p_type
);
2959 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2960 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2961 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2962 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2963 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2964 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2965 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2973 /* Returns 1 if the program headers were read into `program_headers'. */
2976 get_program_headers (FILE *file
)
2978 Elf_Internal_Phdr
*phdrs
;
2980 /* Check cache of prior read. */
2981 if (program_headers
!= NULL
)
2984 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2988 error (_("Out of memory\n"));
2993 ? get_32bit_program_headers (file
, phdrs
)
2994 : get_64bit_program_headers (file
, phdrs
))
2996 program_headers
= phdrs
;
3004 /* Returns 1 if the program headers were loaded. */
3007 process_program_headers (FILE *file
)
3009 Elf_Internal_Phdr
*segment
;
3012 if (elf_header
.e_phnum
== 0)
3015 printf (_("\nThere are no program headers in this file.\n"));
3019 if (do_segments
&& !do_header
)
3021 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3022 printf (_("Entry point "));
3023 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3024 printf (_("\nThere are %d program headers, starting at offset "),
3025 elf_header
.e_phnum
);
3026 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3030 if (! get_program_headers (file
))
3035 if (elf_header
.e_phnum
> 1)
3036 printf (_("\nProgram Headers:\n"));
3038 printf (_("\nProgram Headers:\n"));
3042 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3045 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3049 (_(" Type Offset VirtAddr PhysAddr\n"));
3051 (_(" FileSiz MemSiz Flags Align\n"));
3058 for (i
= 0, segment
= program_headers
;
3059 i
< elf_header
.e_phnum
;
3064 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3068 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3069 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3070 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3071 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3072 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3074 (segment
->p_flags
& PF_R
? 'R' : ' '),
3075 (segment
->p_flags
& PF_W
? 'W' : ' '),
3076 (segment
->p_flags
& PF_X
? 'E' : ' '));
3077 printf ("%#lx", (unsigned long) segment
->p_align
);
3081 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3082 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3085 print_vma (segment
->p_offset
, FULL_HEX
);
3089 print_vma (segment
->p_vaddr
, FULL_HEX
);
3091 print_vma (segment
->p_paddr
, FULL_HEX
);
3094 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3095 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3098 print_vma (segment
->p_filesz
, FULL_HEX
);
3102 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3103 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3106 print_vma (segment
->p_offset
, FULL_HEX
);
3110 (segment
->p_flags
& PF_R
? 'R' : ' '),
3111 (segment
->p_flags
& PF_W
? 'W' : ' '),
3112 (segment
->p_flags
& PF_X
? 'E' : ' '));
3114 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3115 printf ("%#lx", (unsigned long) segment
->p_align
);
3118 print_vma (segment
->p_align
, PREFIX_HEX
);
3123 print_vma (segment
->p_offset
, FULL_HEX
);
3125 print_vma (segment
->p_vaddr
, FULL_HEX
);
3127 print_vma (segment
->p_paddr
, FULL_HEX
);
3129 print_vma (segment
->p_filesz
, FULL_HEX
);
3131 print_vma (segment
->p_memsz
, FULL_HEX
);
3133 (segment
->p_flags
& PF_R
? 'R' : ' '),
3134 (segment
->p_flags
& PF_W
? 'W' : ' '),
3135 (segment
->p_flags
& PF_X
? 'E' : ' '));
3136 print_vma (segment
->p_align
, HEX
);
3140 switch (segment
->p_type
)
3144 error (_("more than one dynamic segment\n"));
3146 dynamic_addr
= segment
->p_offset
;
3147 dynamic_size
= segment
->p_filesz
;
3151 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3153 error (_("Unable to find program interpreter name\n"));
3156 program_interpreter
[0] = 0;
3157 fscanf (file
, "%63s", program_interpreter
);
3160 printf (_("\n [Requesting program interpreter: %s]"),
3161 program_interpreter
);
3167 putc ('\n', stdout
);
3170 if (do_segments
&& section_headers
!= NULL
)
3172 printf (_("\n Section to Segment mapping:\n"));
3173 printf (_(" Segment Sections...\n"));
3175 assert (string_table
!= NULL
);
3177 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3180 Elf_Internal_Shdr
*section
;
3182 segment
= program_headers
+ i
;
3183 section
= section_headers
;
3185 printf (" %2.2d ", i
);
3187 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3189 if (section
->sh_size
> 0
3190 /* Compare allocated sections by VMA, unallocated
3191 sections by file offset. */
3192 && (section
->sh_flags
& SHF_ALLOC
3193 ? (section
->sh_addr
>= segment
->p_vaddr
3194 && section
->sh_addr
+ section
->sh_size
3195 <= segment
->p_vaddr
+ segment
->p_memsz
)
3196 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3197 && (section
->sh_offset
+ section
->sh_size
3198 <= segment
->p_offset
+ segment
->p_filesz
))))
3199 printf ("%s ", SECTION_NAME (section
));
3210 /* Find the file offset corresponding to VMA by using the program headers. */
3213 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3215 Elf_Internal_Phdr
*seg
;
3217 if (! get_program_headers (file
))
3219 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3223 for (seg
= program_headers
;
3224 seg
< program_headers
+ elf_header
.e_phnum
;
3227 if (seg
->p_type
!= PT_LOAD
)
3230 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3231 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3232 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3235 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3242 get_32bit_section_headers (FILE *file
, unsigned int num
)
3244 Elf32_External_Shdr
*shdrs
;
3245 Elf_Internal_Shdr
*internal
;
3248 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3249 elf_header
.e_shentsize
* num
, _("section headers"));
3253 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3255 if (section_headers
== NULL
)
3257 error (_("Out of memory\n"));
3261 for (i
= 0, internal
= section_headers
;
3265 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3266 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3267 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3268 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3269 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3270 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3271 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3272 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3273 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3274 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3283 get_64bit_section_headers (FILE *file
, unsigned int num
)
3285 Elf64_External_Shdr
*shdrs
;
3286 Elf_Internal_Shdr
*internal
;
3289 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3290 elf_header
.e_shentsize
* num
, _("section headers"));
3294 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3296 if (section_headers
== NULL
)
3298 error (_("Out of memory\n"));
3302 for (i
= 0, internal
= section_headers
;
3306 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3307 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3308 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3309 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3310 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3311 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3312 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3313 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3314 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3315 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3323 static Elf_Internal_Sym
*
3324 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3326 unsigned long number
;
3327 Elf32_External_Sym
*esyms
;
3328 Elf_External_Sym_Shndx
*shndx
;
3329 Elf_Internal_Sym
*isyms
;
3330 Elf_Internal_Sym
*psym
;
3333 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3339 if (symtab_shndx_hdr
!= NULL
3340 && (symtab_shndx_hdr
->sh_link
3341 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3343 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3344 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3352 number
= section
->sh_size
/ section
->sh_entsize
;
3353 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3357 error (_("Out of memory\n"));
3364 for (j
= 0, psym
= isyms
;
3368 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3369 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3370 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3371 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3372 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3374 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3375 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3376 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3386 static Elf_Internal_Sym
*
3387 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3389 unsigned long number
;
3390 Elf64_External_Sym
*esyms
;
3391 Elf_External_Sym_Shndx
*shndx
;
3392 Elf_Internal_Sym
*isyms
;
3393 Elf_Internal_Sym
*psym
;
3396 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3402 if (symtab_shndx_hdr
!= NULL
3403 && (symtab_shndx_hdr
->sh_link
3404 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3406 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3407 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3415 number
= section
->sh_size
/ section
->sh_entsize
;
3416 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3420 error (_("Out of memory\n"));
3427 for (j
= 0, psym
= isyms
;
3431 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3432 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3433 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3434 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3435 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3437 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3438 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3439 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3450 get_elf_section_flags (bfd_vma sh_flags
)
3452 static char buff
[32];
3460 flag
= sh_flags
& - sh_flags
;
3465 case SHF_WRITE
: strcat (buff
, "W"); break;
3466 case SHF_ALLOC
: strcat (buff
, "A"); break;
3467 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3468 case SHF_MERGE
: strcat (buff
, "M"); break;
3469 case SHF_STRINGS
: strcat (buff
, "S"); break;
3470 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3471 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3472 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3473 case SHF_GROUP
: strcat (buff
, "G"); break;
3474 case SHF_TLS
: strcat (buff
, "T"); break;
3477 if (flag
& SHF_MASKOS
)
3480 sh_flags
&= ~ SHF_MASKOS
;
3482 else if (flag
& SHF_MASKPROC
)
3485 sh_flags
&= ~ SHF_MASKPROC
;
3497 process_section_headers (FILE *file
)
3499 Elf_Internal_Shdr
*section
;
3502 section_headers
= NULL
;
3504 if (elf_header
.e_shnum
== 0)
3507 printf (_("\nThere are no sections in this file.\n"));
3512 if (do_sections
&& !do_header
)
3513 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3514 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3518 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3521 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3524 /* Read in the string table, so that we have names to display. */
3525 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3527 if (section
->sh_size
!= 0)
3529 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3530 section
->sh_size
, _("string table"));
3532 if (string_table
== NULL
)
3535 string_table_length
= section
->sh_size
;
3538 /* Scan the sections for the dynamic symbol table
3539 and dynamic string table and debug sections. */
3540 dynamic_symbols
= NULL
;
3541 dynamic_strings
= NULL
;
3542 dynamic_syminfo
= NULL
;
3543 symtab_shndx_hdr
= NULL
;
3545 for (i
= 0, section
= section_headers
;
3546 i
< elf_header
.e_shnum
;
3549 char *name
= SECTION_NAME (section
);
3551 if (section
->sh_type
== SHT_DYNSYM
)
3553 if (dynamic_symbols
!= NULL
)
3555 error (_("File contains multiple dynamic symbol tables\n"));
3559 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3560 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3562 else if (section
->sh_type
== SHT_STRTAB
3563 && strcmp (name
, ".dynstr") == 0)
3565 if (dynamic_strings
!= NULL
)
3567 error (_("File contains multiple dynamic string tables\n"));
3571 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3572 section
->sh_size
, _("dynamic strings"));
3574 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3576 if (symtab_shndx_hdr
!= NULL
)
3578 error (_("File contains multiple symtab shndx tables\n"));
3581 symtab_shndx_hdr
= section
;
3583 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3584 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3585 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3587 && strncmp (name
, ".debug_", 7) == 0)
3592 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3593 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3594 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3595 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3596 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3597 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3598 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3599 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3600 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3602 request_dump (i
, DEBUG_DUMP
);
3604 /* linkonce section to be combined with .debug_info at link time. */
3605 else if ((do_debugging
|| do_debug_info
)
3606 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3607 request_dump (i
, DEBUG_DUMP
);
3608 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3609 request_dump (i
, DEBUG_DUMP
);
3615 if (elf_header
.e_shnum
> 1)
3616 printf (_("\nSection Headers:\n"));
3618 printf (_("\nSection Header:\n"));
3622 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3625 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3628 printf (_(" [Nr] Name Type Address Offset\n"));
3629 printf (_(" Size EntSize Flags Link Info Align\n"));
3632 for (i
= 0, section
= section_headers
;
3633 i
< elf_header
.e_shnum
;
3636 printf (" [%2u] %-17.17s %-15.15s ",
3637 SECTION_HEADER_NUM (i
),
3638 SECTION_NAME (section
),
3639 get_section_type_name (section
->sh_type
));
3643 print_vma (section
->sh_addr
, LONG_HEX
);
3645 printf ( " %6.6lx %6.6lx %2.2lx",
3646 (unsigned long) section
->sh_offset
,
3647 (unsigned long) section
->sh_size
,
3648 (unsigned long) section
->sh_entsize
);
3650 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3652 printf ("%2ld %3lu %2ld\n",
3653 (unsigned long) section
->sh_link
,
3654 (unsigned long) section
->sh_info
,
3655 (unsigned long) section
->sh_addralign
);
3659 print_vma (section
->sh_addr
, LONG_HEX
);
3661 if ((long) section
->sh_offset
== section
->sh_offset
)
3662 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3666 print_vma (section
->sh_offset
, LONG_HEX
);
3669 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3670 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3674 print_vma (section
->sh_size
, LONG_HEX
);
3677 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3678 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3682 print_vma (section
->sh_entsize
, LONG_HEX
);
3685 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3687 printf ("%2ld %3lu ",
3688 (unsigned long) section
->sh_link
,
3689 (unsigned long) section
->sh_info
);
3691 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3692 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3695 print_vma (section
->sh_addralign
, DEC
);
3702 print_vma (section
->sh_addr
, LONG_HEX
);
3703 if ((long) section
->sh_offset
== section
->sh_offset
)
3704 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3708 print_vma (section
->sh_offset
, LONG_HEX
);
3711 print_vma (section
->sh_size
, LONG_HEX
);
3713 print_vma (section
->sh_entsize
, LONG_HEX
);
3715 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3717 printf (" %2ld %3lu %ld\n",
3718 (unsigned long) section
->sh_link
,
3719 (unsigned long) section
->sh_info
,
3720 (unsigned long) section
->sh_addralign
);
3724 printf (_("Key to Flags:\n\
3725 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3726 I (info), L (link order), G (group), x (unknown)\n\
3727 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3733 get_group_flags (unsigned int flags
)
3735 static char buff
[32];
3742 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3749 process_section_groups (FILE *file
)
3751 Elf_Internal_Shdr
*section
;
3753 struct group
*group
;
3755 if (elf_header
.e_shnum
== 0)
3757 if (do_section_groups
)
3758 printf (_("\nThere are no section groups in this file.\n"));
3763 if (section_headers
== NULL
)
3765 error (_("Section headers are not available!\n"));
3769 section_headers_groups
= calloc (elf_header
.e_shnum
,
3770 sizeof (struct group
*));
3772 if (section_headers_groups
== NULL
)
3774 error (_("Out of memory\n"));
3778 /* Scan the sections for the group section. */
3779 for (i
= 0, section
= section_headers
;
3780 i
< elf_header
.e_shnum
;
3782 if (section
->sh_type
== SHT_GROUP
)
3785 section_groups
= calloc (group_count
, sizeof (struct group
));
3787 if (section_groups
== NULL
)
3789 error (_("Out of memory\n"));
3793 for (i
= 0, section
= section_headers
, group
= section_groups
;
3794 i
< elf_header
.e_shnum
;
3797 if (section
->sh_type
== SHT_GROUP
)
3799 char *name
= SECTION_NAME (section
);
3800 char *group_name
, *strtab
, *start
, *indices
;
3801 unsigned int entry
, j
, size
;
3802 Elf_Internal_Sym
*sym
;
3803 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
, *sec
;
3804 Elf_Internal_Sym
*symtab
;
3806 /* Get the symbol table. */
3807 symtab_sec
= SECTION_HEADER (section
->sh_link
);
3808 if (symtab_sec
->sh_type
!= SHT_SYMTAB
)
3810 error (_("Bad sh_link in group section `%s'\n"), name
);
3813 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
3815 sym
= symtab
+ section
->sh_info
;
3817 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3819 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
3822 error (_("Bad sh_info in group section `%s'\n"), name
);
3826 group_name
= SECTION_NAME (section_headers
+ sec_index
);
3831 /* Get the string table. */
3832 strtab_sec
= SECTION_HEADER (symtab_sec
->sh_link
);
3833 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
3834 strtab_sec
->sh_size
,
3837 group_name
= strtab
+ sym
->st_name
;
3840 start
= get_data (NULL
, file
, section
->sh_offset
,
3841 section
->sh_size
, _("section data"));
3844 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
3845 entry
= byte_get (indices
, 4);
3848 if (do_section_groups
)
3850 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
3851 get_group_flags (entry
), name
, group_name
, size
);
3853 printf (_(" [Index] Name\n"));
3856 group
->group_index
= i
;
3858 for (j
= 0; j
< size
; j
++)
3860 struct group_list
*g
;
3862 entry
= byte_get (indices
, 4);
3865 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
3868 error (_("section [%5u] already in group section [%5u]\n"),
3869 entry
, section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
3873 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
3876 if (do_section_groups
)
3878 sec
= SECTION_HEADER (entry
);
3879 printf (" [%5u] %s\n",
3880 entry
, SECTION_NAME (sec
));
3883 g
= xmalloc (sizeof (struct group_list
));
3884 g
->section_index
= entry
;
3885 g
->next
= group
->root
;
3907 } dynamic_relocations
[] =
3909 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
3910 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
3911 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
3914 /* Process the reloc section. */
3916 process_relocs (FILE *file
)
3918 unsigned long rel_size
;
3919 unsigned long rel_offset
;
3925 if (do_using_dynamic
)
3929 int has_dynamic_reloc
;
3932 has_dynamic_reloc
= 0;
3934 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
3936 is_rela
= dynamic_relocations
[i
].rela
;
3937 name
= dynamic_relocations
[i
].name
;
3938 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
3939 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
3941 has_dynamic_reloc
|= rel_size
;
3943 if (is_rela
== UNKNOWN
)
3945 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
3946 switch (dynamic_info
[DT_PLTREL
])
3960 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
3961 name
, rel_offset
, rel_size
);
3963 dump_relocations (file
,
3964 offset_from_vma (file
, rel_offset
, rel_size
),
3966 dynamic_symbols
, num_dynamic_syms
,
3967 dynamic_strings
, is_rela
);
3971 if (! has_dynamic_reloc
)
3972 printf (_("\nThere are no dynamic relocations in this file.\n"));
3976 Elf_Internal_Shdr
*section
;
3980 for (i
= 0, section
= section_headers
;
3981 i
< elf_header
.e_shnum
;
3984 if ( section
->sh_type
!= SHT_RELA
3985 && section
->sh_type
!= SHT_REL
)
3988 rel_offset
= section
->sh_offset
;
3989 rel_size
= section
->sh_size
;
3993 Elf_Internal_Shdr
*strsec
;
3994 Elf_Internal_Sym
*symtab
;
3997 unsigned long nsyms
;
3999 printf (_("\nRelocation section "));
4001 if (string_table
== NULL
)
4002 printf ("%d", section
->sh_name
);
4004 printf (_("'%s'"), SECTION_NAME (section
));
4006 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4007 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4012 if (section
->sh_link
)
4014 Elf_Internal_Shdr
*symsec
;
4016 symsec
= SECTION_HEADER (section
->sh_link
);
4017 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4018 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4023 strsec
= SECTION_HEADER (symsec
->sh_link
);
4025 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4026 strsec
->sh_size
, _("string table"));
4028 is_rela
= section
->sh_type
== SHT_RELA
;
4030 dump_relocations (file
, rel_offset
, rel_size
,
4031 symtab
, nsyms
, strtab
, is_rela
);
4043 printf (_("\nThere are no relocations in this file.\n"));
4049 #include "unwind-ia64.h"
4051 /* An absolute address consists of a section and an offset. If the
4052 section is NULL, the offset itself is the address, otherwise, the
4053 address equals to LOAD_ADDRESS(section) + offset. */
4057 unsigned short section
;
4063 struct unw_table_entry
4065 struct absaddr start
;
4067 struct absaddr info
;
4069 *table
; /* Unwind table. */
4070 unsigned long table_len
; /* Length of unwind table. */
4071 unsigned char *info
; /* Unwind info. */
4072 unsigned long info_size
; /* Size of unwind info. */
4073 bfd_vma info_addr
; /* starting address of unwind info. */
4074 bfd_vma seg_base
; /* Starting address of segment. */
4075 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4076 unsigned long nsyms
; /* Number of symbols. */
4077 char *strtab
; /* The string table. */
4078 unsigned long strtab_size
; /* Size of string table. */
4082 find_symbol_for_address (struct unw_aux_info
*aux
,
4083 struct absaddr addr
,
4084 const char **symname
,
4087 bfd_vma dist
= 0x100000;
4088 Elf_Internal_Sym
*sym
, *best
= NULL
;
4091 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
4093 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4094 && sym
->st_name
!= 0
4095 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4096 && addr
.offset
>= sym
->st_value
4097 && addr
.offset
- sym
->st_value
< dist
)
4100 dist
= addr
.offset
- sym
->st_value
;
4107 *symname
= (best
->st_name
>= aux
->strtab_size
4108 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
4113 *offset
= addr
.offset
;
4117 dump_ia64_unwind (struct unw_aux_info
*aux
)
4120 struct unw_table_entry
*tp
;
4123 addr_size
= is_32bit_elf
? 4 : 8;
4125 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4129 const unsigned char *dp
;
4130 const unsigned char *head
;
4131 const char *procname
;
4133 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
4135 fputs ("\n<", stdout
);
4139 fputs (procname
, stdout
);
4142 printf ("+%lx", (unsigned long) offset
);
4145 fputs (">: [", stdout
);
4146 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4147 fputc ('-', stdout
);
4148 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4149 printf ("], info at +0x%lx\n",
4150 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4152 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4153 stamp
= BYTE_GET8 ((unsigned char *) head
);
4155 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4156 (unsigned) UNW_VER (stamp
),
4157 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4158 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4159 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4160 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4162 if (UNW_VER (stamp
) != 1)
4164 printf ("\tUnknown version.\n");
4169 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4170 dp
= unw_decode (dp
, in_body
, & in_body
);
4175 slurp_ia64_unwind_table (FILE *file
,
4176 struct unw_aux_info
*aux
,
4177 Elf_Internal_Shdr
*sec
)
4179 unsigned long size
, addr_size
, nrelas
, i
;
4180 Elf_Internal_Phdr
*seg
;
4181 struct unw_table_entry
*tep
;
4182 Elf_Internal_Shdr
*relsec
;
4183 Elf_Internal_Rela
*rela
, *rp
;
4184 unsigned char *table
, *tp
;
4185 Elf_Internal_Sym
*sym
;
4186 const char *relname
;
4188 addr_size
= is_32bit_elf
? 4 : 8;
4190 /* First, find the starting address of the segment that includes
4193 if (elf_header
.e_phnum
)
4195 if (! get_program_headers (file
))
4198 for (seg
= program_headers
;
4199 seg
< program_headers
+ elf_header
.e_phnum
;
4202 if (seg
->p_type
!= PT_LOAD
)
4205 if (sec
->sh_addr
>= seg
->p_vaddr
4206 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4208 aux
->seg_base
= seg
->p_vaddr
;
4214 /* Second, build the unwind table from the contents of the unwind section: */
4215 size
= sec
->sh_size
;
4216 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4220 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4221 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4223 tep
->start
.section
= SHN_UNDEF
;
4224 tep
->end
.section
= SHN_UNDEF
;
4225 tep
->info
.section
= SHN_UNDEF
;
4228 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4229 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4230 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4234 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4235 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4236 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4238 tep
->start
.offset
+= aux
->seg_base
;
4239 tep
->end
.offset
+= aux
->seg_base
;
4240 tep
->info
.offset
+= aux
->seg_base
;
4244 /* Third, apply any relocations to the unwind table: */
4246 for (relsec
= section_headers
;
4247 relsec
< section_headers
+ elf_header
.e_shnum
;
4250 if (relsec
->sh_type
!= SHT_RELA
4251 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4254 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4258 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4262 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4263 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4265 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4267 warn (_("Skipping unexpected symbol type %u\n"),
4268 ELF32_ST_TYPE (sym
->st_info
));
4274 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4275 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4277 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4279 warn (_("Skipping unexpected symbol type %u\n"),
4280 ELF64_ST_TYPE (sym
->st_info
));
4285 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4287 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4291 i
= rp
->r_offset
/ (3 * addr_size
);
4293 switch (rp
->r_offset
/addr_size
% 3)
4296 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4297 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4300 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4301 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4304 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4305 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4315 aux
->table_len
= size
/ (3 * addr_size
);
4320 process_unwind (FILE *file
)
4322 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4323 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4324 struct unw_aux_info aux
;
4329 if (elf_header
.e_machine
!= EM_IA_64
)
4331 printf (_("\nThere are no unwind sections in this file.\n"));
4335 memset (& aux
, 0, sizeof (aux
));
4337 addr_size
= is_32bit_elf
? 4 : 8;
4339 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4341 if (sec
->sh_type
== SHT_SYMTAB
)
4343 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4344 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4346 strsec
= SECTION_HEADER (sec
->sh_link
);
4347 aux
.strtab_size
= strsec
->sh_size
;
4348 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4349 aux
.strtab_size
, _("string table"));
4351 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4356 printf (_("\nThere are no unwind sections in this file.\n"));
4358 while (unwcount
-- > 0)
4363 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4364 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4365 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4372 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4374 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4376 /* We need to find which section group it is in. */
4377 struct group_list
*g
= section_headers_groups
[i
]->root
;
4379 for (; g
!= NULL
; g
= g
->next
)
4381 sec
= SECTION_HEADER (g
->section_index
);
4382 if (strcmp (SECTION_NAME (sec
),
4383 ELF_STRING_ia64_unwind_info
) == 0)
4388 i
= elf_header
.e_shnum
;
4390 else if (strncmp (SECTION_NAME (unwsec
),
4391 ELF_STRING_ia64_unwind_once
, len
) == 0)
4393 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4394 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4395 suffix
= SECTION_NAME (unwsec
) + len
;
4396 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4398 if (strncmp (SECTION_NAME (sec
),
4399 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4400 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4405 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4406 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4407 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4408 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4410 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4412 suffix
= SECTION_NAME (unwsec
) + len
;
4413 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4415 if (strncmp (SECTION_NAME (sec
),
4416 ELF_STRING_ia64_unwind_info
, len2
) == 0
4417 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4421 if (i
== elf_header
.e_shnum
)
4423 printf (_("\nCould not find unwind info section for "));
4425 if (string_table
== NULL
)
4426 printf ("%d", unwsec
->sh_name
);
4428 printf (_("'%s'"), SECTION_NAME (unwsec
));
4432 aux
.info_size
= sec
->sh_size
;
4433 aux
.info_addr
= sec
->sh_addr
;
4434 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4437 printf (_("\nUnwind section "));
4439 if (string_table
== NULL
)
4440 printf ("%d", unwsec
->sh_name
);
4442 printf (_("'%s'"), SECTION_NAME (unwsec
));
4444 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4445 (unsigned long) unwsec
->sh_offset
,
4446 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4448 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4450 if (aux
.table_len
> 0)
4451 dump_ia64_unwind (& aux
);
4454 free ((char *) aux
.table
);
4456 free ((char *) aux
.info
);
4465 free ((char *) aux
.strtab
);
4471 dynamic_segment_mips_val (Elf_Internal_Dyn
*entry
)
4473 switch (entry
->d_tag
)
4476 if (entry
->d_un
.d_val
== 0)
4480 static const char * opts
[] =
4482 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4483 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4484 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4485 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4490 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4491 if (entry
->d_un
.d_val
& (1 << cnt
))
4493 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4500 case DT_MIPS_IVERSION
:
4501 if (dynamic_strings
!= NULL
)
4502 printf ("Interface Version: %s\n",
4503 dynamic_strings
+ entry
->d_un
.d_val
);
4505 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4508 case DT_MIPS_TIME_STAMP
:
4513 time_t time
= entry
->d_un
.d_val
;
4514 tmp
= gmtime (&time
);
4515 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4516 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4517 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4518 printf ("Time Stamp: %s\n", timebuf
);
4522 case DT_MIPS_RLD_VERSION
:
4523 case DT_MIPS_LOCAL_GOTNO
:
4524 case DT_MIPS_CONFLICTNO
:
4525 case DT_MIPS_LIBLISTNO
:
4526 case DT_MIPS_SYMTABNO
:
4527 case DT_MIPS_UNREFEXTNO
:
4528 case DT_MIPS_HIPAGENO
:
4529 case DT_MIPS_DELTA_CLASS_NO
:
4530 case DT_MIPS_DELTA_INSTANCE_NO
:
4531 case DT_MIPS_DELTA_RELOC_NO
:
4532 case DT_MIPS_DELTA_SYM_NO
:
4533 case DT_MIPS_DELTA_CLASSSYM_NO
:
4534 case DT_MIPS_COMPACT_SIZE
:
4535 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4539 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4545 dynamic_segment_parisc_val (Elf_Internal_Dyn
*entry
)
4547 switch (entry
->d_tag
)
4549 case DT_HP_DLD_FLAGS
:
4558 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4559 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4560 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4561 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4562 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4563 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4564 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4565 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4566 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4567 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4568 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4572 bfd_vma val
= entry
->d_un
.d_val
;
4574 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4575 if (val
& flags
[cnt
].bit
)
4579 fputs (flags
[cnt
].str
, stdout
);
4581 val
^= flags
[cnt
].bit
;
4584 if (val
!= 0 || first
)
4588 print_vma (val
, HEX
);
4594 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4601 dynamic_segment_ia64_val (Elf_Internal_Dyn
*entry
)
4603 switch (entry
->d_tag
)
4605 case DT_IA_64_PLT_RESERVE
:
4606 /* First 3 slots reserved. */
4607 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4609 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
4613 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4620 get_32bit_dynamic_segment (FILE *file
)
4622 Elf32_External_Dyn
*edyn
;
4623 Elf_Internal_Dyn
*entry
;
4626 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4627 _("dynamic segment"));
4631 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4632 how large this .dynamic is now. We can do this even before the byte
4633 swapping since the DT_NULL tag is recognizable. */
4635 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4638 dynamic_segment
= malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4640 if (dynamic_segment
== NULL
)
4642 error (_("Out of memory\n"));
4647 for (i
= 0, entry
= dynamic_segment
;
4651 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4652 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4661 get_64bit_dynamic_segment (FILE *file
)
4663 Elf64_External_Dyn
*edyn
;
4664 Elf_Internal_Dyn
*entry
;
4667 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4668 _("dynamic segment"));
4672 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4673 how large this .dynamic is now. We can do this even before the byte
4674 swapping since the DT_NULL tag is recognizable. */
4676 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4679 dynamic_segment
= malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4681 if (dynamic_segment
== NULL
)
4683 error (_("Out of memory\n"));
4688 for (i
= 0, entry
= dynamic_segment
;
4692 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4693 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4702 get_dynamic_flags (bfd_vma flags
)
4704 static char buff
[128];
4712 flag
= flags
& - flags
;
4720 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4721 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4722 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4723 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4724 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4725 default: strcpy (p
, "unknown"); break;
4728 p
= strchr (p
, '\0');
4733 /* Parse and display the contents of the dynamic segment. */
4735 process_dynamic_segment (FILE *file
)
4737 Elf_Internal_Dyn
*entry
;
4740 if (dynamic_size
== 0)
4743 printf (_("\nThere is no dynamic segment in this file.\n"));
4750 if (! get_32bit_dynamic_segment (file
))
4753 else if (! get_64bit_dynamic_segment (file
))
4756 /* Find the appropriate symbol table. */
4757 if (dynamic_symbols
== NULL
)
4759 for (i
= 0, entry
= dynamic_segment
;
4763 Elf_Internal_Shdr section
;
4765 if (entry
->d_tag
!= DT_SYMTAB
)
4768 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4770 /* Since we do not know how big the symbol table is,
4771 we default to reading in the entire file (!) and
4772 processing that. This is overkill, I know, but it
4774 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4776 if (archive_file_offset
!= 0)
4777 section
.sh_size
= archive_file_size
- section
.sh_offset
;
4780 if (fseek (file
, 0, SEEK_END
))
4781 error (_("Unable to seek to end of file!"));
4783 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4787 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4789 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4791 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4792 if (num_dynamic_syms
< 1)
4794 error (_("Unable to determine the number of symbols to load\n"));
4798 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4802 /* Similarly find a string table. */
4803 if (dynamic_strings
== NULL
)
4805 for (i
= 0, entry
= dynamic_segment
;
4809 unsigned long offset
;
4812 if (entry
->d_tag
!= DT_STRTAB
)
4815 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4817 /* Since we do not know how big the string table is,
4818 we default to reading in the entire file (!) and
4819 processing that. This is overkill, I know, but it
4822 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4824 if (archive_file_offset
!= 0)
4825 str_tab_len
= archive_file_size
- offset
;
4828 if (fseek (file
, 0, SEEK_END
))
4829 error (_("Unable to seek to end of file\n"));
4830 str_tab_len
= ftell (file
) - offset
;
4833 if (str_tab_len
< 1)
4836 (_("Unable to determine the length of the dynamic string table\n"));
4840 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
4841 _("dynamic string table"));
4846 /* And find the syminfo section if available. */
4847 if (dynamic_syminfo
== NULL
)
4849 unsigned long syminsz
= 0;
4851 for (i
= 0, entry
= dynamic_segment
;
4855 if (entry
->d_tag
== DT_SYMINENT
)
4857 /* Note: these braces are necessary to avoid a syntax
4858 error from the SunOS4 C compiler. */
4859 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4861 else if (entry
->d_tag
== DT_SYMINSZ
)
4862 syminsz
= entry
->d_un
.d_val
;
4863 else if (entry
->d_tag
== DT_SYMINFO
)
4864 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
4868 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4870 Elf_External_Syminfo
*extsyminfo
;
4871 Elf_Internal_Syminfo
*syminfo
;
4873 /* There is a syminfo section. Read the data. */
4874 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
4875 _("symbol information"));
4879 dynamic_syminfo
= malloc (syminsz
);
4880 if (dynamic_syminfo
== NULL
)
4882 error (_("Out of memory\n"));
4886 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4887 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4890 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4891 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4898 if (do_dynamic
&& dynamic_addr
)
4899 printf (_("\nDynamic segment at offset 0x%lx contains %ld entries:\n"),
4900 dynamic_addr
, (long) dynamic_size
);
4902 printf (_(" Tag Type Name/Value\n"));
4904 for (i
= 0, entry
= dynamic_segment
;
4913 print_vma (entry
->d_tag
, FULL_HEX
);
4914 dtype
= get_dynamic_type (entry
->d_tag
);
4915 printf (" (%s)%*s", dtype
,
4916 ((is_32bit_elf
? 27 : 19)
4917 - (int) strlen (dtype
)),
4921 switch (entry
->d_tag
)
4925 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4935 switch (entry
->d_tag
)
4938 printf (_("Auxiliary library"));
4942 printf (_("Filter library"));
4946 printf (_("Configuration file"));
4950 printf (_("Dependency audit library"));
4954 printf (_("Audit library"));
4958 if (dynamic_strings
)
4959 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4963 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4972 printf (_("Flags:"));
4974 if (entry
->d_un
.d_val
== 0)
4975 printf (_(" None\n"));
4978 unsigned long int val
= entry
->d_un
.d_val
;
4980 if (val
& DTF_1_PARINIT
)
4982 printf (" PARINIT");
4983 val
^= DTF_1_PARINIT
;
4985 if (val
& DTF_1_CONFEXP
)
4987 printf (" CONFEXP");
4988 val
^= DTF_1_CONFEXP
;
4991 printf (" %lx", val
);
5000 printf (_("Flags:"));
5002 if (entry
->d_un
.d_val
== 0)
5003 printf (_(" None\n"));
5006 unsigned long int val
= entry
->d_un
.d_val
;
5008 if (val
& DF_P1_LAZYLOAD
)
5010 printf (" LAZYLOAD");
5011 val
^= DF_P1_LAZYLOAD
;
5013 if (val
& DF_P1_GROUPPERM
)
5015 printf (" GROUPPERM");
5016 val
^= DF_P1_GROUPPERM
;
5019 printf (" %lx", val
);
5028 printf (_("Flags:"));
5029 if (entry
->d_un
.d_val
== 0)
5030 printf (_(" None\n"));
5033 unsigned long int val
= entry
->d_un
.d_val
;
5040 if (val
& DF_1_GLOBAL
)
5045 if (val
& DF_1_GROUP
)
5050 if (val
& DF_1_NODELETE
)
5052 printf (" NODELETE");
5053 val
^= DF_1_NODELETE
;
5055 if (val
& DF_1_LOADFLTR
)
5057 printf (" LOADFLTR");
5058 val
^= DF_1_LOADFLTR
;
5060 if (val
& DF_1_INITFIRST
)
5062 printf (" INITFIRST");
5063 val
^= DF_1_INITFIRST
;
5065 if (val
& DF_1_NOOPEN
)
5070 if (val
& DF_1_ORIGIN
)
5075 if (val
& DF_1_DIRECT
)
5080 if (val
& DF_1_TRANS
)
5085 if (val
& DF_1_INTERPOSE
)
5087 printf (" INTERPOSE");
5088 val
^= DF_1_INTERPOSE
;
5090 if (val
& DF_1_NODEFLIB
)
5092 printf (" NODEFLIB");
5093 val
^= DF_1_NODEFLIB
;
5095 if (val
& DF_1_NODUMP
)
5100 if (val
& DF_1_CONLFAT
)
5102 printf (" CONLFAT");
5103 val
^= DF_1_CONLFAT
;
5106 printf (" %lx", val
);
5113 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5115 puts (get_dynamic_type (entry
->d_un
.d_val
));
5135 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5141 if (dynamic_strings
== NULL
)
5144 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5148 switch (entry
->d_tag
)
5151 printf (_("Shared library: [%s]"), name
);
5153 if (strcmp (name
, program_interpreter
) == 0)
5154 printf (_(" program interpreter"));
5158 printf (_("Library soname: [%s]"), name
);
5162 printf (_("Library rpath: [%s]"), name
);
5166 printf (_("Library runpath: [%s]"), name
);
5170 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5175 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5188 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5192 case DT_INIT_ARRAYSZ
:
5193 case DT_FINI_ARRAYSZ
:
5194 case DT_GNU_CONFLICTSZ
:
5195 case DT_GNU_LIBLISTSZ
:
5198 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5199 printf (" (bytes)\n");
5209 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5222 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
5226 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5230 printf (_("Not needed object: [%s]\n"), name
);
5235 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5241 /* The value of this entry is ignored. */
5246 case DT_GNU_PRELINKED
:
5250 time_t time
= entry
->d_un
.d_val
;
5252 tmp
= gmtime (&time
);
5253 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5254 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5255 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5261 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5262 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5267 switch (elf_header
.e_machine
)
5270 case EM_MIPS_RS3_LE
:
5271 dynamic_segment_mips_val (entry
);
5274 dynamic_segment_parisc_val (entry
);
5277 dynamic_segment_ia64_val (entry
);
5280 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5292 get_ver_flags (unsigned int flags
)
5294 static char buff
[32];
5301 if (flags
& VER_FLG_BASE
)
5302 strcat (buff
, "BASE ");
5304 if (flags
& VER_FLG_WEAK
)
5306 if (flags
& VER_FLG_BASE
)
5307 strcat (buff
, "| ");
5309 strcat (buff
, "WEAK ");
5312 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5313 strcat (buff
, "| <unknown>");
5318 /* Display the contents of the version sections. */
5320 process_version_sections (FILE *file
)
5322 Elf_Internal_Shdr
*section
;
5329 for (i
= 0, section
= section_headers
;
5330 i
< elf_header
.e_shnum
;
5333 switch (section
->sh_type
)
5335 case SHT_GNU_verdef
:
5337 Elf_External_Verdef
*edefs
;
5344 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5345 SECTION_NAME (section
), section
->sh_info
);
5347 printf (_(" Addr: 0x"));
5348 printf_vma (section
->sh_addr
);
5349 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5350 (unsigned long) section
->sh_offset
, section
->sh_link
,
5351 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5353 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5354 _("version definition section"));
5358 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5361 Elf_External_Verdef
*edef
;
5362 Elf_Internal_Verdef ent
;
5363 Elf_External_Verdaux
*eaux
;
5364 Elf_Internal_Verdaux aux
;
5368 vstart
= ((char *) edefs
) + idx
;
5370 edef
= (Elf_External_Verdef
*) vstart
;
5372 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5373 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5374 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5375 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5376 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5377 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5378 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5380 printf (_(" %#06x: Rev: %d Flags: %s"),
5381 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5383 printf (_(" Index: %d Cnt: %d "),
5384 ent
.vd_ndx
, ent
.vd_cnt
);
5386 vstart
+= ent
.vd_aux
;
5388 eaux
= (Elf_External_Verdaux
*) vstart
;
5390 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5391 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5393 if (dynamic_strings
)
5394 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5396 printf (_("Name index: %ld\n"), aux
.vda_name
);
5398 isum
= idx
+ ent
.vd_aux
;
5400 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5402 isum
+= aux
.vda_next
;
5403 vstart
+= aux
.vda_next
;
5405 eaux
= (Elf_External_Verdaux
*) vstart
;
5407 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5408 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5410 if (dynamic_strings
)
5411 printf (_(" %#06x: Parent %d: %s\n"),
5412 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5414 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5415 isum
, j
, aux
.vda_name
);
5425 case SHT_GNU_verneed
:
5427 Elf_External_Verneed
*eneed
;
5433 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5434 SECTION_NAME (section
), section
->sh_info
);
5436 printf (_(" Addr: 0x"));
5437 printf_vma (section
->sh_addr
);
5438 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5439 (unsigned long) section
->sh_offset
, section
->sh_link
,
5440 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5442 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5443 _("version need section"));
5447 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5449 Elf_External_Verneed
*entry
;
5450 Elf_Internal_Verneed ent
;
5455 vstart
= ((char *) eneed
) + idx
;
5457 entry
= (Elf_External_Verneed
*) vstart
;
5459 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5460 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5461 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5462 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5463 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5465 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5467 if (dynamic_strings
)
5468 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5470 printf (_(" File: %lx"), ent
.vn_file
);
5472 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5474 vstart
+= ent
.vn_aux
;
5476 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5478 Elf_External_Vernaux
*eaux
;
5479 Elf_Internal_Vernaux aux
;
5481 eaux
= (Elf_External_Vernaux
*) vstart
;
5483 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5484 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5485 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5486 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5487 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5489 if (dynamic_strings
)
5490 printf (_(" %#06x: Name: %s"),
5491 isum
, dynamic_strings
+ aux
.vna_name
);
5493 printf (_(" %#06x: Name index: %lx"),
5494 isum
, aux
.vna_name
);
5496 printf (_(" Flags: %s Version: %d\n"),
5497 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5499 isum
+= aux
.vna_next
;
5500 vstart
+= aux
.vna_next
;
5510 case SHT_GNU_versym
:
5512 Elf_Internal_Shdr
*link_section
;
5515 unsigned char *edata
;
5516 unsigned short *data
;
5518 Elf_Internal_Sym
*symbols
;
5519 Elf_Internal_Shdr
*string_sec
;
5522 link_section
= SECTION_HEADER (section
->sh_link
);
5523 total
= section
->sh_size
/ section
->sh_entsize
;
5527 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5529 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5531 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5532 string_sec
->sh_size
, _("version string table"));
5536 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5537 SECTION_NAME (section
), total
);
5539 printf (_(" Addr: "));
5540 printf_vma (section
->sh_addr
);
5541 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5542 (unsigned long) section
->sh_offset
, section
->sh_link
,
5543 SECTION_NAME (link_section
));
5545 off
= offset_from_vma (file
,
5546 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5547 total
* sizeof (short));
5548 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
5549 _("version symbol data"));
5556 data
= malloc (total
* sizeof (short));
5558 for (cnt
= total
; cnt
--;)
5559 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5564 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5567 int check_def
, check_need
;
5570 printf (" %03x:", cnt
);
5572 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5573 switch (data
[cnt
+ j
])
5576 fputs (_(" 0 (*local*) "), stdout
);
5580 fputs (_(" 1 (*global*) "), stdout
);
5584 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5585 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5589 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5592 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5599 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5601 Elf_Internal_Verneed ivn
;
5602 unsigned long offset
;
5604 offset
= offset_from_vma
5605 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5606 sizeof (Elf_External_Verneed
));
5610 Elf_Internal_Vernaux ivna
;
5611 Elf_External_Verneed evn
;
5612 Elf_External_Vernaux evna
;
5613 unsigned long a_off
;
5615 get_data (&evn
, file
, offset
, sizeof (evn
),
5618 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5619 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5621 a_off
= offset
+ ivn
.vn_aux
;
5625 get_data (&evna
, file
, a_off
, sizeof (evna
),
5626 _("version need aux (2)"));
5628 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5629 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5631 a_off
+= ivna
.vna_next
;
5633 while (ivna
.vna_other
!= data
[cnt
+ j
]
5634 && ivna
.vna_next
!= 0);
5636 if (ivna
.vna_other
== data
[cnt
+ j
])
5638 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5640 name
= strtab
+ ivna
.vna_name
;
5641 nn
+= printf ("(%s%-*s",
5643 12 - (int) strlen (name
),
5649 offset
+= ivn
.vn_next
;
5651 while (ivn
.vn_next
);
5654 if (check_def
&& data
[cnt
+ j
] != 0x8001
5655 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5657 Elf_Internal_Verdef ivd
;
5658 Elf_External_Verdef evd
;
5659 unsigned long offset
;
5661 offset
= offset_from_vma
5662 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5667 get_data (&evd
, file
, offset
, sizeof (evd
),
5670 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5671 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5673 offset
+= ivd
.vd_next
;
5675 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5676 && ivd
.vd_next
!= 0);
5678 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5680 Elf_External_Verdaux evda
;
5681 Elf_Internal_Verdaux ivda
;
5683 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5685 get_data (&evda
, file
,
5686 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5687 sizeof (evda
), _("version def aux"));
5689 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5691 name
= strtab
+ ivda
.vda_name
;
5692 nn
+= printf ("(%s%-*s",
5694 12 - (int) strlen (name
),
5700 printf ("%*c", 18 - nn
, ' ');
5718 printf (_("\nNo version information found in this file.\n"));
5724 get_symbol_binding (unsigned int binding
)
5726 static char buff
[32];
5730 case STB_LOCAL
: return "LOCAL";
5731 case STB_GLOBAL
: return "GLOBAL";
5732 case STB_WEAK
: return "WEAK";
5734 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5735 sprintf (buff
, _("<processor specific>: %d"), binding
);
5736 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5737 sprintf (buff
, _("<OS specific>: %d"), binding
);
5739 sprintf (buff
, _("<unknown>: %d"), binding
);
5745 get_symbol_type (unsigned int type
)
5747 static char buff
[32];
5751 case STT_NOTYPE
: return "NOTYPE";
5752 case STT_OBJECT
: return "OBJECT";
5753 case STT_FUNC
: return "FUNC";
5754 case STT_SECTION
: return "SECTION";
5755 case STT_FILE
: return "FILE";
5756 case STT_COMMON
: return "COMMON";
5757 case STT_TLS
: return "TLS";
5759 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5761 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5762 return "THUMB_FUNC";
5764 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5767 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5768 return "PARISC_MILLI";
5770 sprintf (buff
, _("<processor specific>: %d"), type
);
5772 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5774 if (elf_header
.e_machine
== EM_PARISC
)
5776 if (type
== STT_HP_OPAQUE
)
5778 if (type
== STT_HP_STUB
)
5782 sprintf (buff
, _("<OS specific>: %d"), type
);
5785 sprintf (buff
, _("<unknown>: %d"), type
);
5791 get_symbol_visibility (unsigned int visibility
)
5795 case STV_DEFAULT
: return "DEFAULT";
5796 case STV_INTERNAL
: return "INTERNAL";
5797 case STV_HIDDEN
: return "HIDDEN";
5798 case STV_PROTECTED
: return "PROTECTED";
5804 get_symbol_index_type (unsigned int type
)
5806 static char buff
[32];
5810 case SHN_UNDEF
: return "UND";
5811 case SHN_ABS
: return "ABS";
5812 case SHN_COMMON
: return "COM";
5814 if (type
== SHN_IA_64_ANSI_COMMON
5815 && elf_header
.e_machine
== EM_IA_64
5816 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
5818 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5819 sprintf (buff
, "PRC[0x%04x]", type
);
5820 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5821 sprintf (buff
, "OS [0x%04x]", type
);
5822 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5823 sprintf (buff
, "RSV[0x%04x]", type
);
5825 sprintf (buff
, "%3d", type
);
5833 get_dynamic_data (FILE *file
, unsigned int number
)
5835 unsigned char *e_data
;
5838 e_data
= malloc (number
* 4);
5842 error (_("Out of memory\n"));
5846 if (fread (e_data
, 4, number
, file
) != number
)
5848 error (_("Unable to read in dynamic data\n"));
5852 i_data
= malloc (number
* sizeof (*i_data
));
5856 error (_("Out of memory\n"));
5862 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5869 /* Dump the symbol table. */
5871 process_symbol_table (FILE *file
)
5873 Elf_Internal_Shdr
*section
;
5874 unsigned char nb
[4];
5875 unsigned char nc
[4];
5878 int *buckets
= NULL
;
5881 if (! do_syms
&& !do_histogram
)
5884 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5888 (archive_file_offset
5889 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
5890 sizeof nb
+ sizeof nc
)),
5893 error (_("Unable to seek to start of dynamic information"));
5897 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5899 error (_("Failed to read in number of buckets\n"));
5903 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5905 error (_("Failed to read in number of chains\n"));
5909 nbuckets
= byte_get (nb
, 4);
5910 nchains
= byte_get (nc
, 4);
5912 buckets
= get_dynamic_data (file
, nbuckets
);
5913 chains
= get_dynamic_data (file
, nchains
);
5915 if (buckets
== NULL
|| chains
== NULL
)
5920 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5925 printf (_("\nSymbol table for image:\n"));
5927 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5929 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5931 for (hn
= 0; hn
< nbuckets
; hn
++)
5936 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5938 Elf_Internal_Sym
*psym
;
5940 psym
= dynamic_symbols
+ si
;
5942 printf (" %3d %3d: ", si
, hn
);
5943 print_vma (psym
->st_value
, LONG_HEX
);
5945 print_vma (psym
->st_size
, DEC_5
);
5947 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5948 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5949 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5950 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5951 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5956 else if (do_syms
&& !do_using_dynamic
)
5960 for (i
= 0, section
= section_headers
;
5961 i
< elf_header
.e_shnum
;
5966 Elf_Internal_Sym
*symtab
;
5967 Elf_Internal_Sym
*psym
;
5970 if ( section
->sh_type
!= SHT_SYMTAB
5971 && section
->sh_type
!= SHT_DYNSYM
)
5974 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5975 SECTION_NAME (section
),
5976 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5978 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5980 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5982 symtab
= GET_ELF_SYMBOLS (file
, section
);
5986 if (section
->sh_link
== elf_header
.e_shstrndx
)
5987 strtab
= string_table
;
5990 Elf_Internal_Shdr
*string_sec
;
5992 string_sec
= SECTION_HEADER (section
->sh_link
);
5994 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5995 string_sec
->sh_size
, _("string table"));
5998 for (si
= 0, psym
= symtab
;
5999 si
< section
->sh_size
/ section
->sh_entsize
;
6002 printf ("%6d: ", si
);
6003 print_vma (psym
->st_value
, LONG_HEX
);
6005 print_vma (psym
->st_size
, DEC_5
);
6006 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6007 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6008 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6009 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6010 print_symbol (25, strtab
+ psym
->st_name
);
6012 if (section
->sh_type
== SHT_DYNSYM
&&
6013 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6015 unsigned char data
[2];
6016 unsigned short vers_data
;
6017 unsigned long offset
;
6021 offset
= offset_from_vma
6022 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6023 sizeof data
+ si
* sizeof (vers_data
));
6025 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6026 sizeof (data
), _("version data"));
6028 vers_data
= byte_get (data
, 2);
6030 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6033 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6035 if ((vers_data
& 0x8000) || vers_data
> 1)
6037 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6038 && (is_nobits
|| ! check_def
))
6040 Elf_External_Verneed evn
;
6041 Elf_Internal_Verneed ivn
;
6042 Elf_Internal_Vernaux ivna
;
6044 /* We must test both. */
6045 offset
= offset_from_vma
6046 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6051 unsigned long vna_off
;
6053 get_data (&evn
, file
, offset
, sizeof (evn
),
6056 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6057 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6059 vna_off
= offset
+ ivn
.vn_aux
;
6063 Elf_External_Vernaux evna
;
6065 get_data (&evna
, file
, vna_off
,
6067 _("version need aux (3)"));
6069 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6070 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6071 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6073 vna_off
+= ivna
.vna_next
;
6075 while (ivna
.vna_other
!= vers_data
6076 && ivna
.vna_next
!= 0);
6078 if (ivna
.vna_other
== vers_data
)
6081 offset
+= ivn
.vn_next
;
6083 while (ivn
.vn_next
!= 0);
6085 if (ivna
.vna_other
== vers_data
)
6088 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6091 else if (! is_nobits
)
6092 error (_("bad dynamic symbol"));
6099 if (vers_data
!= 0x8001
6100 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6102 Elf_Internal_Verdef ivd
;
6103 Elf_Internal_Verdaux ivda
;
6104 Elf_External_Verdaux evda
;
6105 unsigned long offset
;
6107 offset
= offset_from_vma
6109 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6110 sizeof (Elf_External_Verdef
));
6114 Elf_External_Verdef evd
;
6116 get_data (&evd
, file
, offset
, sizeof (evd
),
6119 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6120 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6121 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6123 offset
+= ivd
.vd_next
;
6125 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6126 && ivd
.vd_next
!= 0);
6128 offset
-= ivd
.vd_next
;
6129 offset
+= ivd
.vd_aux
;
6131 get_data (&evda
, file
, offset
, sizeof (evda
),
6132 _("version def aux"));
6134 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6136 if (psym
->st_name
!= ivda
.vda_name
)
6137 printf ((vers_data
& 0x8000)
6139 strtab
+ ivda
.vda_name
);
6149 if (strtab
!= string_table
)
6155 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6157 if (do_histogram
&& buckets
!= NULL
)
6164 int nzero_counts
= 0;
6167 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6169 printf (_(" Length Number %% of total Coverage\n"));
6171 lengths
= calloc (nbuckets
, sizeof (int));
6172 if (lengths
== NULL
)
6174 error (_("Out of memory"));
6177 for (hn
= 0; hn
< nbuckets
; ++hn
)
6182 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6185 if (maxlength
< ++lengths
[hn
])
6190 counts
= calloc (maxlength
+ 1, sizeof (int));
6193 error (_("Out of memory"));
6197 for (hn
= 0; hn
< nbuckets
; ++hn
)
6198 ++counts
[lengths
[hn
]];
6202 printf (" 0 %-10d (%5.1f%%)\n",
6203 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6204 for (si
= 1; si
<= maxlength
; ++si
)
6206 nzero_counts
+= counts
[si
] * si
;
6207 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6208 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6209 (nzero_counts
* 100.0) / nsyms
);
6217 if (buckets
!= NULL
)
6227 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6231 if (dynamic_syminfo
== NULL
6233 /* No syminfo, this is ok. */
6236 /* There better should be a dynamic symbol section. */
6237 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6241 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6242 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6244 printf (_(" Num: Name BoundTo Flags\n"));
6245 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6247 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6249 printf ("%4d: ", i
);
6250 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
6253 switch (dynamic_syminfo
[i
].si_boundto
)
6255 case SYMINFO_BT_SELF
:
6256 fputs ("SELF ", stdout
);
6258 case SYMINFO_BT_PARENT
:
6259 fputs ("PARENT ", stdout
);
6262 if (dynamic_syminfo
[i
].si_boundto
> 0
6263 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
6268 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6272 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6276 if (flags
& SYMINFO_FLG_DIRECT
)
6278 if (flags
& SYMINFO_FLG_PASSTHRU
)
6279 printf (" PASSTHRU");
6280 if (flags
& SYMINFO_FLG_COPY
)
6282 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6283 printf (" LAZYLOAD");
6291 #ifdef SUPPORT_DISASSEMBLY
6293 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6295 printf (_("\nAssembly dump of section %s\n"),
6296 SECTION_NAME (section
));
6298 /* XXX -- to be done --- XXX */
6305 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6307 bfd_size_type bytes
;
6309 unsigned char *data
;
6310 unsigned char *start
;
6312 bytes
= section
->sh_size
;
6314 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6316 printf (_("\nSection '%s' has no data to dump.\n"),
6317 SECTION_NAME (section
));
6321 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6323 addr
= section
->sh_addr
;
6325 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6337 lbytes
= (bytes
> 16 ? 16 : bytes
);
6339 printf (" 0x%8.8lx ", (unsigned long) addr
);
6341 switch (elf_header
.e_ident
[EI_DATA
])
6345 for (j
= 15; j
>= 0; j
--)
6348 printf ("%2.2x", data
[j
]);
6358 for (j
= 0; j
< 16; j
++)
6361 printf ("%2.2x", data
[j
]);
6371 for (j
= 0; j
< lbytes
; j
++)
6374 if (k
>= ' ' && k
< 0x7f)
6393 static unsigned long int
6394 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6396 unsigned long int result
= 0;
6397 unsigned int num_read
= 0;
6406 result
|= (byte
& 0x7f) << shift
;
6411 while (byte
& 0x80);
6413 if (length_return
!= NULL
)
6414 *length_return
= num_read
;
6416 if (sign
&& (shift
< 32) && (byte
& 0x40))
6417 result
|= -1 << shift
;
6422 typedef struct State_Machine_Registers
6424 unsigned long address
;
6427 unsigned int column
;
6431 /* This variable hold the number of the last entry seen
6432 in the File Table. */
6433 unsigned int last_file_entry
;
6436 static SMR state_machine_regs
;
6439 reset_state_machine (int is_stmt
)
6441 state_machine_regs
.address
= 0;
6442 state_machine_regs
.file
= 1;
6443 state_machine_regs
.line
= 1;
6444 state_machine_regs
.column
= 0;
6445 state_machine_regs
.is_stmt
= is_stmt
;
6446 state_machine_regs
.basic_block
= 0;
6447 state_machine_regs
.end_sequence
= 0;
6448 state_machine_regs
.last_file_entry
= 0;
6451 /* Handled an extend line op. Returns true if this is the end
6454 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6456 unsigned char op_code
;
6459 unsigned char *name
;
6462 len
= read_leb128 (data
, & bytes_read
, 0);
6467 warn (_("badly formed extended line op encountered!\n"));
6474 printf (_(" Extended opcode %d: "), op_code
);
6478 case DW_LNE_end_sequence
:
6479 printf (_("End of Sequence\n\n"));
6480 reset_state_machine (is_stmt
);
6483 case DW_LNE_set_address
:
6484 adr
= byte_get (data
, pointer_size
);
6485 printf (_("set Address to 0x%lx\n"), adr
);
6486 state_machine_regs
.address
= adr
;
6489 case DW_LNE_define_file
:
6490 printf (_(" define new File Table entry\n"));
6491 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6493 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6495 data
+= strlen ((char *) data
) + 1;
6496 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6498 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6500 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6501 printf (_("%s\n\n"), name
);
6505 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6512 /* Finds section NAME inside FILE and returns a
6513 pointer to it, or NULL upon failure. */
6515 static Elf_Internal_Shdr
*
6516 find_section (const char * name
)
6518 Elf_Internal_Shdr
*sec
;
6521 for (i
= elf_header
.e_shnum
, sec
= section_headers
+ i
- 1;
6523 if (strcmp (SECTION_NAME (sec
), name
) == 0)
6526 if (i
&& sec
&& sec
->sh_size
!= 0)
6532 /* Size of pointers in the .debug_line section. This information is not
6533 really present in that section. It's obtained before dumping the debug
6534 sections by doing some pre-scan of the .debug_info section. */
6535 static unsigned int * debug_line_pointer_sizes
= NULL
;
6536 static unsigned int num_debug_line_pointer_sizes
= 0;
6538 /* Locate and scan the .debug_info section in the file and record the pointer
6539 sizes for the compilation units in it. Usually an executable will have
6540 just one pointer size, but this is not guaranteed, and so we try not to
6541 make any assumptions. Returns zero upon failure, or the number of
6542 compilation units upon success. */
6545 get_debug_line_pointer_sizes (FILE * file
)
6547 Elf_Internal_Shdr
* section
;
6548 unsigned char * start
;
6549 unsigned char * end
;
6550 unsigned char * begin
;
6551 unsigned long length
;
6552 unsigned int num_units
;
6555 section
= find_section (".debug_info");
6556 if (section
== NULL
)
6559 length
= section
->sh_size
;
6560 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6561 _("extracting pointer sizes from .debug_info section"));
6565 end
= start
+ section
->sh_size
;
6566 /* First scan the section to get the number of comp units. */
6567 for (begin
= start
, num_units
= 0; begin
< end
; num_units
++)
6569 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
6570 be the length. For a 64-bit DWARF section, it'll be the escape
6571 code 0xffffffff followed by an 8 byte length. */
6572 length
= byte_get (begin
, 4);
6574 if (length
== 0xffffffff)
6576 length
= byte_get (begin
+ 4, 8);
6577 begin
+= length
+ 12;
6580 begin
+= length
+ 4;
6585 error (_("No comp units in .debug_info section ?"));
6590 /* Then allocate an array to hold the pointer sizes. */
6591 debug_line_pointer_sizes
= malloc (num_units
* sizeof * debug_line_pointer_sizes
);
6592 if (debug_line_pointer_sizes
== NULL
)
6594 error (_("Not enough memory for a pointer size array of %u entries"),
6600 /* Populate the array. */
6601 for (begin
= start
, unit
= 0; begin
< end
; unit
++)
6603 length
= byte_get (begin
, 4);
6604 if (length
== 0xffffffff)
6606 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
6607 from the start of the section. This is computed as follows:
6609 unit_length: 12 bytes
6611 debug_abbrev_offset: 8 bytes
6612 -----------------------------
6615 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 22, 1);
6616 length
= byte_get (begin
+ 4, 8);
6617 begin
+= length
+ 12;
6621 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
6622 the start of the section:
6624 unit_length: 4 bytes
6626 debug_abbrev_offset: 4 bytes
6627 -----------------------------
6630 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 10, 1);
6631 begin
+= length
+ 4;
6636 num_debug_line_pointer_sizes
= num_units
;
6641 display_debug_lines (Elf_Internal_Shdr
*section
,
6642 unsigned char *start
, FILE *file
)
6644 unsigned char *hdrptr
;
6645 DWARF2_Internal_LineInfo info
;
6646 unsigned char *standard_opcodes
;
6647 unsigned char *data
= start
;
6648 unsigned char *end
= start
+ section
->sh_size
;
6649 unsigned char *end_of_sequence
;
6652 int initial_length_size
;
6653 unsigned int comp_unit
= 0;
6655 printf (_("\nDump of debug contents of section %s:\n\n"),
6656 SECTION_NAME (section
));
6658 if (num_debug_line_pointer_sizes
== 0)
6659 get_debug_line_pointer_sizes (file
);
6663 unsigned int pointer_size
;
6667 /* Check the length of the block. */
6668 info
.li_length
= byte_get (hdrptr
, 4);
6671 if (info
.li_length
== 0xffffffff)
6673 /* This section is 64-bit DWARF 3. */
6674 info
.li_length
= byte_get (hdrptr
, 8);
6677 initial_length_size
= 12;
6682 initial_length_size
= 4;
6685 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
6688 (_("The line info appears to be corrupt - the section is too small\n"));
6692 /* Check its version number. */
6693 info
.li_version
= byte_get (hdrptr
, 2);
6695 if (info
.li_version
!= 2 && info
.li_version
!= 3)
6697 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6701 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
6702 hdrptr
+= offset_size
;
6703 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
6705 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
6707 info
.li_line_base
= byte_get (hdrptr
, 1);
6709 info
.li_line_range
= byte_get (hdrptr
, 1);
6711 info
.li_opcode_base
= byte_get (hdrptr
, 1);
6714 /* Sign extend the line base field. */
6715 info
.li_line_base
<<= 24;
6716 info
.li_line_base
>>= 24;
6718 /* Get the pointer size from the comp unit associated
6719 with this block of line number information. */
6720 if (comp_unit
>= num_debug_line_pointer_sizes
)
6722 error (_("Not enough comp units for .debug_lines section\n"));
6727 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
6731 printf (_(" Length: %ld\n"), info
.li_length
);
6732 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6733 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6734 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6735 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6736 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6737 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6738 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6739 printf (_(" (Pointer size: %u)\n"), pointer_size
);
6741 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
6743 reset_state_machine (info
.li_default_is_stmt
);
6745 /* Display the contents of the Opcodes table. */
6746 standard_opcodes
= hdrptr
;
6748 printf (_("\n Opcodes:\n"));
6750 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6751 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6753 /* Display the contents of the Directory table. */
6754 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6757 printf (_("\n The Directory Table is empty.\n"));
6760 printf (_("\n The Directory Table:\n"));
6764 printf (_(" %s\n"), data
);
6766 data
+= strlen ((char *) data
) + 1;
6770 /* Skip the NUL at the end of the table. */
6773 /* Display the contents of the File Name table. */
6775 printf (_("\n The File Name Table is empty.\n"));
6778 printf (_("\n The File Name Table:\n"));
6779 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6783 unsigned char *name
;
6786 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6789 data
+= strlen ((char *) data
) + 1;
6791 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6793 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6795 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6797 printf (_("%s\n"), name
);
6801 /* Skip the NUL at the end of the table. */
6804 /* Now display the statements. */
6805 printf (_("\n Line Number Statements:\n"));
6808 while (data
< end_of_sequence
)
6810 unsigned char op_code
;
6816 if (op_code
>= info
.li_opcode_base
)
6818 op_code
-= info
.li_opcode_base
;
6819 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6820 state_machine_regs
.address
+= adv
;
6821 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6822 op_code
, adv
, state_machine_regs
.address
);
6823 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6824 state_machine_regs
.line
+= adv
;
6825 printf (_(" and Line by %d to %d\n"),
6826 adv
, state_machine_regs
.line
);
6828 else switch (op_code
)
6830 case DW_LNS_extended_op
:
6831 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6836 printf (_(" Copy\n"));
6839 case DW_LNS_advance_pc
:
6840 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6842 state_machine_regs
.address
+= adv
;
6843 printf (_(" Advance PC by %d to %lx\n"), adv
,
6844 state_machine_regs
.address
);
6847 case DW_LNS_advance_line
:
6848 adv
= read_leb128 (data
, & bytes_read
, 1);
6850 state_machine_regs
.line
+= adv
;
6851 printf (_(" Advance Line by %d to %d\n"), adv
,
6852 state_machine_regs
.line
);
6855 case DW_LNS_set_file
:
6856 adv
= read_leb128 (data
, & bytes_read
, 0);
6858 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6860 state_machine_regs
.file
= adv
;
6863 case DW_LNS_set_column
:
6864 adv
= read_leb128 (data
, & bytes_read
, 0);
6866 printf (_(" Set column to %d\n"), adv
);
6867 state_machine_regs
.column
= adv
;
6870 case DW_LNS_negate_stmt
:
6871 adv
= state_machine_regs
.is_stmt
;
6873 printf (_(" Set is_stmt to %d\n"), adv
);
6874 state_machine_regs
.is_stmt
= adv
;
6877 case DW_LNS_set_basic_block
:
6878 printf (_(" Set basic block\n"));
6879 state_machine_regs
.basic_block
= 1;
6882 case DW_LNS_const_add_pc
:
6883 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6884 * info
.li_min_insn_length
);
6885 state_machine_regs
.address
+= adv
;
6886 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6887 state_machine_regs
.address
);
6890 case DW_LNS_fixed_advance_pc
:
6891 adv
= byte_get (data
, 2);
6893 state_machine_regs
.address
+= adv
;
6894 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6895 adv
, state_machine_regs
.address
);
6898 case DW_LNS_set_prologue_end
:
6899 printf (_(" Set prologue_end to true\n"));
6902 case DW_LNS_set_epilogue_begin
:
6903 printf (_(" Set epilogue_begin to true\n"));
6906 case DW_LNS_set_isa
:
6907 adv
= read_leb128 (data
, & bytes_read
, 0);
6909 printf (_(" Set ISA to %d\n"), adv
);
6913 printf (_(" Unknown opcode %d with operands: "), op_code
);
6916 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6918 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6919 i
== 1 ? "" : ", ");
6934 display_debug_pubnames (Elf_Internal_Shdr
*section
,
6935 unsigned char *start
,
6936 FILE *file ATTRIBUTE_UNUSED
)
6938 DWARF2_Internal_PubNames pubnames
;
6941 end
= start
+ section
->sh_size
;
6943 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6947 unsigned char *data
;
6948 unsigned long offset
;
6949 int offset_size
, initial_length_size
;
6953 pubnames
.pn_length
= byte_get (data
, 4);
6955 if (pubnames
.pn_length
== 0xffffffff)
6957 pubnames
.pn_length
= byte_get (data
, 8);
6960 initial_length_size
= 12;
6965 initial_length_size
= 4;
6968 pubnames
.pn_version
= byte_get (data
, 2);
6970 pubnames
.pn_offset
= byte_get (data
, offset_size
);
6971 data
+= offset_size
;
6972 pubnames
.pn_size
= byte_get (data
, offset_size
);
6973 data
+= offset_size
;
6975 start
+= pubnames
.pn_length
+ initial_length_size
;
6977 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
6979 static int warned
= 0;
6983 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
6990 printf (_(" Length: %ld\n"),
6991 pubnames
.pn_length
);
6992 printf (_(" Version: %d\n"),
6993 pubnames
.pn_version
);
6994 printf (_(" Offset into .debug_info section: %ld\n"),
6995 pubnames
.pn_offset
);
6996 printf (_(" Size of area in .debug_info section: %ld\n"),
6999 printf (_("\n Offset\tName\n"));
7003 offset
= byte_get (data
, offset_size
);
7007 data
+= offset_size
;
7008 printf (" %-6ld\t\t%s\n", offset
, data
);
7009 data
+= strlen ((char *) data
) + 1;
7012 while (offset
!= 0);
7020 get_TAG_name (unsigned long tag
)
7024 case DW_TAG_padding
: return "DW_TAG_padding";
7025 case DW_TAG_array_type
: return "DW_TAG_array_type";
7026 case DW_TAG_class_type
: return "DW_TAG_class_type";
7027 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7028 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7029 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7030 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7031 case DW_TAG_label
: return "DW_TAG_label";
7032 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7033 case DW_TAG_member
: return "DW_TAG_member";
7034 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7035 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7036 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7037 case DW_TAG_string_type
: return "DW_TAG_string_type";
7038 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7039 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7040 case DW_TAG_typedef
: return "DW_TAG_typedef";
7041 case DW_TAG_union_type
: return "DW_TAG_union_type";
7042 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7043 case DW_TAG_variant
: return "DW_TAG_variant";
7044 case DW_TAG_common_block
: return "DW_TAG_common_block";
7045 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7046 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7047 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7048 case DW_TAG_module
: return "DW_TAG_module";
7049 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7050 case DW_TAG_set_type
: return "DW_TAG_set_type";
7051 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7052 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7053 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7054 case DW_TAG_base_type
: return "DW_TAG_base_type";
7055 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7056 case DW_TAG_const_type
: return "DW_TAG_const_type";
7057 case DW_TAG_constant
: return "DW_TAG_constant";
7058 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7059 case DW_TAG_file_type
: return "DW_TAG_file_type";
7060 case DW_TAG_friend
: return "DW_TAG_friend";
7061 case DW_TAG_namelist
: return "DW_TAG_namelist";
7062 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7063 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7064 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7065 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7066 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7067 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7068 case DW_TAG_try_block
: return "DW_TAG_try_block";
7069 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7070 case DW_TAG_variable
: return "DW_TAG_variable";
7071 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7072 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7073 case DW_TAG_format_label
: return "DW_TAG_format_label";
7074 case DW_TAG_function_template
: return "DW_TAG_function_template";
7075 case DW_TAG_class_template
: return "DW_TAG_class_template";
7076 /* DWARF 2.1 values. */
7077 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7078 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7079 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7080 case DW_TAG_namespace
: return "DW_TAG_namespace";
7081 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7082 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7083 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7084 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7086 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7087 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7088 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7091 static char buffer
[100];
7093 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7100 get_AT_name (unsigned long attribute
)
7104 case DW_AT_sibling
: return "DW_AT_sibling";
7105 case DW_AT_location
: return "DW_AT_location";
7106 case DW_AT_name
: return "DW_AT_name";
7107 case DW_AT_ordering
: return "DW_AT_ordering";
7108 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
7109 case DW_AT_byte_size
: return "DW_AT_byte_size";
7110 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
7111 case DW_AT_bit_size
: return "DW_AT_bit_size";
7112 case DW_AT_element_list
: return "DW_AT_element_list";
7113 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
7114 case DW_AT_low_pc
: return "DW_AT_low_pc";
7115 case DW_AT_high_pc
: return "DW_AT_high_pc";
7116 case DW_AT_language
: return "DW_AT_language";
7117 case DW_AT_member
: return "DW_AT_member";
7118 case DW_AT_discr
: return "DW_AT_discr";
7119 case DW_AT_discr_value
: return "DW_AT_discr_value";
7120 case DW_AT_visibility
: return "DW_AT_visibility";
7121 case DW_AT_import
: return "DW_AT_import";
7122 case DW_AT_string_length
: return "DW_AT_string_length";
7123 case DW_AT_common_reference
: return "DW_AT_common_reference";
7124 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
7125 case DW_AT_const_value
: return "DW_AT_const_value";
7126 case DW_AT_containing_type
: return "DW_AT_containing_type";
7127 case DW_AT_default_value
: return "DW_AT_default_value";
7128 case DW_AT_inline
: return "DW_AT_inline";
7129 case DW_AT_is_optional
: return "DW_AT_is_optional";
7130 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
7131 case DW_AT_producer
: return "DW_AT_producer";
7132 case DW_AT_prototyped
: return "DW_AT_prototyped";
7133 case DW_AT_return_addr
: return "DW_AT_return_addr";
7134 case DW_AT_start_scope
: return "DW_AT_start_scope";
7135 case DW_AT_stride_size
: return "DW_AT_stride_size";
7136 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
7137 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
7138 case DW_AT_accessibility
: return "DW_AT_accessibility";
7139 case DW_AT_address_class
: return "DW_AT_address_class";
7140 case DW_AT_artificial
: return "DW_AT_artificial";
7141 case DW_AT_base_types
: return "DW_AT_base_types";
7142 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
7143 case DW_AT_count
: return "DW_AT_count";
7144 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
7145 case DW_AT_decl_column
: return "DW_AT_decl_column";
7146 case DW_AT_decl_file
: return "DW_AT_decl_file";
7147 case DW_AT_decl_line
: return "DW_AT_decl_line";
7148 case DW_AT_declaration
: return "DW_AT_declaration";
7149 case DW_AT_discr_list
: return "DW_AT_discr_list";
7150 case DW_AT_encoding
: return "DW_AT_encoding";
7151 case DW_AT_external
: return "DW_AT_external";
7152 case DW_AT_frame_base
: return "DW_AT_frame_base";
7153 case DW_AT_friend
: return "DW_AT_friend";
7154 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
7155 case DW_AT_macro_info
: return "DW_AT_macro_info";
7156 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
7157 case DW_AT_priority
: return "DW_AT_priority";
7158 case DW_AT_segment
: return "DW_AT_segment";
7159 case DW_AT_specification
: return "DW_AT_specification";
7160 case DW_AT_static_link
: return "DW_AT_static_link";
7161 case DW_AT_type
: return "DW_AT_type";
7162 case DW_AT_use_location
: return "DW_AT_use_location";
7163 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
7164 case DW_AT_virtuality
: return "DW_AT_virtuality";
7165 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
7166 /* DWARF 2.1 values. */
7167 case DW_AT_allocated
: return "DW_AT_allocated";
7168 case DW_AT_associated
: return "DW_AT_associated";
7169 case DW_AT_data_location
: return "DW_AT_data_location";
7170 case DW_AT_stride
: return "DW_AT_stride";
7171 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
7172 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
7173 case DW_AT_extension
: return "DW_AT_extension";
7174 case DW_AT_ranges
: return "DW_AT_ranges";
7175 case DW_AT_trampoline
: return "DW_AT_trampoline";
7176 case DW_AT_call_column
: return "DW_AT_call_column";
7177 case DW_AT_call_file
: return "DW_AT_call_file";
7178 case DW_AT_call_line
: return "DW_AT_call_line";
7179 /* SGI/MIPS extensions. */
7180 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
7181 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
7182 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
7183 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
7184 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
7185 case DW_AT_MIPS_software_pipeline_depth
:
7186 return "DW_AT_MIPS_software_pipeline_depth";
7187 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
7188 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
7189 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
7190 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
7191 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
7192 /* GNU extensions. */
7193 case DW_AT_sf_names
: return "DW_AT_sf_names";
7194 case DW_AT_src_info
: return "DW_AT_src_info";
7195 case DW_AT_mac_info
: return "DW_AT_mac_info";
7196 case DW_AT_src_coords
: return "DW_AT_src_coords";
7197 case DW_AT_body_begin
: return "DW_AT_body_begin";
7198 case DW_AT_body_end
: return "DW_AT_body_end";
7199 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
7200 /* UPC extension. */
7201 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
7204 static char buffer
[100];
7206 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
7213 get_FORM_name (unsigned long form
)
7217 case DW_FORM_addr
: return "DW_FORM_addr";
7218 case DW_FORM_block2
: return "DW_FORM_block2";
7219 case DW_FORM_block4
: return "DW_FORM_block4";
7220 case DW_FORM_data2
: return "DW_FORM_data2";
7221 case DW_FORM_data4
: return "DW_FORM_data4";
7222 case DW_FORM_data8
: return "DW_FORM_data8";
7223 case DW_FORM_string
: return "DW_FORM_string";
7224 case DW_FORM_block
: return "DW_FORM_block";
7225 case DW_FORM_block1
: return "DW_FORM_block1";
7226 case DW_FORM_data1
: return "DW_FORM_data1";
7227 case DW_FORM_flag
: return "DW_FORM_flag";
7228 case DW_FORM_sdata
: return "DW_FORM_sdata";
7229 case DW_FORM_strp
: return "DW_FORM_strp";
7230 case DW_FORM_udata
: return "DW_FORM_udata";
7231 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7232 case DW_FORM_ref1
: return "DW_FORM_ref1";
7233 case DW_FORM_ref2
: return "DW_FORM_ref2";
7234 case DW_FORM_ref4
: return "DW_FORM_ref4";
7235 case DW_FORM_ref8
: return "DW_FORM_ref8";
7236 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7237 case DW_FORM_indirect
: return "DW_FORM_indirect";
7240 static char buffer
[100];
7242 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7248 /* FIXME: There are better and more efficient ways to handle
7249 these structures. For now though, I just want something that
7250 is simple to implement. */
7251 typedef struct abbrev_attr
7253 unsigned long attribute
;
7255 struct abbrev_attr
*next
;
7259 typedef struct abbrev_entry
7261 unsigned long entry
;
7264 struct abbrev_attr
*first_attr
;
7265 struct abbrev_attr
*last_attr
;
7266 struct abbrev_entry
*next
;
7270 static abbrev_entry
*first_abbrev
= NULL
;
7271 static abbrev_entry
*last_abbrev
= NULL
;
7276 abbrev_entry
*abbrev
;
7278 for (abbrev
= first_abbrev
; abbrev
;)
7280 abbrev_entry
*next
= abbrev
->next
;
7283 for (attr
= abbrev
->first_attr
; attr
;)
7285 abbrev_attr
*next
= attr
->next
;
7295 last_abbrev
= first_abbrev
= NULL
;
7299 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7301 abbrev_entry
*entry
;
7303 entry
= malloc (sizeof (*entry
));
7309 entry
->entry
= number
;
7311 entry
->children
= children
;
7312 entry
->first_attr
= NULL
;
7313 entry
->last_attr
= NULL
;
7316 if (first_abbrev
== NULL
)
7317 first_abbrev
= entry
;
7319 last_abbrev
->next
= entry
;
7321 last_abbrev
= entry
;
7325 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7329 attr
= malloc (sizeof (*attr
));
7335 attr
->attribute
= attribute
;
7339 if (last_abbrev
->first_attr
== NULL
)
7340 last_abbrev
->first_attr
= attr
;
7342 last_abbrev
->last_attr
->next
= attr
;
7344 last_abbrev
->last_attr
= attr
;
7347 /* Processes the (partial) contents of a .debug_abbrev section.
7348 Returns NULL if the end of the section was encountered.
7349 Returns the address after the last byte read if the end of
7350 an abbreviation set was found. */
7352 static unsigned char *
7353 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7355 if (first_abbrev
!= NULL
)
7361 unsigned long entry
;
7363 unsigned long attribute
;
7366 entry
= read_leb128 (start
, & bytes_read
, 0);
7367 start
+= bytes_read
;
7369 /* A single zero is supposed to end the section according
7370 to the standard. If there's more, then signal that to
7373 return start
== end
? NULL
: start
;
7375 tag
= read_leb128 (start
, & bytes_read
, 0);
7376 start
+= bytes_read
;
7378 children
= *start
++;
7380 add_abbrev (entry
, tag
, children
);
7386 attribute
= read_leb128 (start
, & bytes_read
, 0);
7387 start
+= bytes_read
;
7389 form
= read_leb128 (start
, & bytes_read
, 0);
7390 start
+= bytes_read
;
7393 add_abbrev_attr (attribute
, form
);
7395 while (attribute
!= 0);
7403 display_debug_macinfo (Elf_Internal_Shdr
*section
,
7404 unsigned char *start
,
7405 FILE *file ATTRIBUTE_UNUSED
)
7407 unsigned char *end
= start
+ section
->sh_size
;
7408 unsigned char *curr
= start
;
7409 unsigned int bytes_read
;
7410 enum dwarf_macinfo_record_type op
;
7412 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7416 unsigned int lineno
;
7424 case DW_MACINFO_start_file
:
7426 unsigned int filenum
;
7428 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7430 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7433 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7437 case DW_MACINFO_end_file
:
7438 printf (_(" DW_MACINFO_end_file\n"));
7441 case DW_MACINFO_define
:
7442 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7445 curr
+= strlen (string
) + 1;
7446 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7449 case DW_MACINFO_undef
:
7450 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7453 curr
+= strlen (string
) + 1;
7454 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7457 case DW_MACINFO_vendor_ext
:
7459 unsigned int constant
;
7461 constant
= read_leb128 (curr
, & bytes_read
, 0);
7464 curr
+= strlen (string
) + 1;
7465 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7476 display_debug_abbrev (Elf_Internal_Shdr
*section
,
7477 unsigned char *start
,
7478 FILE *file ATTRIBUTE_UNUSED
)
7480 abbrev_entry
*entry
;
7481 unsigned char *end
= start
+ section
->sh_size
;
7483 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7487 start
= process_abbrev_section (start
, end
);
7489 if (first_abbrev
== NULL
)
7492 printf (_(" Number TAG\n"));
7494 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7498 printf (_(" %ld %s [%s]\n"),
7500 get_TAG_name (entry
->tag
),
7501 entry
->children
? _("has children") : _("no children"));
7503 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7505 printf (_(" %-18s %s\n"),
7506 get_AT_name (attr
->attribute
),
7507 get_FORM_name (attr
->form
));
7521 static unsigned char *
7522 display_block (unsigned char *data
, unsigned long length
)
7524 printf (_(" %lu byte block: "), length
);
7527 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7533 decode_location_expression (unsigned char * data
,
7534 unsigned int pointer_size
,
7535 unsigned long length
)
7539 unsigned long uvalue
;
7540 unsigned char *end
= data
+ length
;
7549 printf ("DW_OP_addr: %lx",
7550 (unsigned long) byte_get (data
, pointer_size
));
7551 data
+= pointer_size
;
7554 printf ("DW_OP_deref");
7557 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7560 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7563 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7567 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7571 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7575 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7579 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7580 (unsigned long) byte_get (data
+ 4, 4));
7584 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7585 (long) byte_get (data
+ 4, 4));
7589 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7593 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7597 printf ("DW_OP_dup");
7600 printf ("DW_OP_drop");
7603 printf ("DW_OP_over");
7606 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7609 printf ("DW_OP_swap");
7612 printf ("DW_OP_rot");
7615 printf ("DW_OP_xderef");
7618 printf ("DW_OP_abs");
7621 printf ("DW_OP_and");
7624 printf ("DW_OP_div");
7627 printf ("DW_OP_minus");
7630 printf ("DW_OP_mod");
7633 printf ("DW_OP_mul");
7636 printf ("DW_OP_neg");
7639 printf ("DW_OP_not");
7642 printf ("DW_OP_or");
7645 printf ("DW_OP_plus");
7647 case DW_OP_plus_uconst
:
7648 printf ("DW_OP_plus_uconst: %lu",
7649 read_leb128 (data
, &bytes_read
, 0));
7653 printf ("DW_OP_shl");
7656 printf ("DW_OP_shr");
7659 printf ("DW_OP_shra");
7662 printf ("DW_OP_xor");
7665 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7669 printf ("DW_OP_eq");
7672 printf ("DW_OP_ge");
7675 printf ("DW_OP_gt");
7678 printf ("DW_OP_le");
7681 printf ("DW_OP_lt");
7684 printf ("DW_OP_ne");
7687 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7723 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7758 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7793 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7794 read_leb128 (data
, &bytes_read
, 1));
7799 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7803 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7807 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7809 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7810 read_leb128 (data
, &bytes_read
, 1));
7814 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7817 case DW_OP_deref_size
:
7818 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7820 case DW_OP_xderef_size
:
7821 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7824 printf ("DW_OP_nop");
7827 /* DWARF 3 extensions. */
7828 case DW_OP_push_object_address
:
7829 printf ("DW_OP_push_object_address");
7832 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7836 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7839 case DW_OP_call_ref
:
7840 printf ("DW_OP_call_ref");
7843 /* GNU extensions. */
7844 case DW_OP_GNU_push_tls_address
:
7845 printf ("DW_OP_GNU_push_tls_address");
7849 if (op
>= DW_OP_lo_user
7850 && op
<= DW_OP_hi_user
)
7851 printf (_("(User defined location op)"));
7853 printf (_("(Unknown location op)"));
7854 /* No way to tell where the next op is, so just bail. */
7858 /* Separate the ops. */
7864 static const char *debug_loc_contents
;
7865 static bfd_vma debug_loc_size
;
7868 load_debug_loc (FILE *file
)
7870 Elf_Internal_Shdr
*sec
;
7872 /* If it is already loaded, do nothing. */
7873 if (debug_loc_contents
!= NULL
)
7876 /* Locate the .debug_loc section. */
7877 sec
= find_section (".debug_loc");
7881 debug_loc_size
= sec
->sh_size
;
7883 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7884 _("debug_loc section data"));
7888 free_debug_loc (void)
7890 if (debug_loc_contents
== NULL
)
7893 free ((char *) debug_loc_contents
);
7894 debug_loc_contents
= NULL
;
7900 display_debug_loc (Elf_Internal_Shdr
*section
,
7901 unsigned char *start
, FILE *file
)
7903 unsigned char *section_end
;
7904 unsigned long bytes
;
7905 unsigned char *section_begin
= start
;
7907 unsigned int comp_unit
= 0;
7909 addr
= section
->sh_addr
;
7910 bytes
= section
->sh_size
;
7911 section_end
= start
+ bytes
;
7915 printf (_("\nThe .debug_loc section is empty.\n"));
7919 if (num_debug_line_pointer_sizes
== 0)
7920 get_debug_line_pointer_sizes (file
);
7922 printf (_("Contents of the .debug_loc section:\n\n"));
7923 printf (_("\n Offset Begin End Expression\n"));
7925 while (start
< section_end
)
7927 unsigned long begin
;
7929 unsigned short length
;
7930 unsigned long offset
;
7931 unsigned int pointer_size
;
7933 offset
= start
- section_begin
;
7935 /* Get the pointer size from the comp unit associated
7936 with this block of location information. */
7937 if (comp_unit
>= num_debug_line_pointer_sizes
)
7939 error (_("Not enough comp units for .debug_loc section\n"));
7944 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
7950 begin
= byte_get (start
, pointer_size
);
7951 start
+= pointer_size
;
7952 end
= byte_get (start
, pointer_size
);
7953 start
+= pointer_size
;
7955 if (begin
== 0 && end
== 0)
7958 /* For now, skip any base address specifiers. */
7959 if (begin
== 0xffffffff)
7965 length
= byte_get (start
, 2);
7968 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7969 decode_location_expression (start
, pointer_size
, length
);
7979 static const char *debug_str_contents
;
7980 static bfd_vma debug_str_size
;
7983 load_debug_str (FILE *file
)
7985 Elf_Internal_Shdr
*sec
;
7987 /* If it is already loaded, do nothing. */
7988 if (debug_str_contents
!= NULL
)
7991 /* Locate the .debug_str section. */
7992 sec
= find_section (".debug_str");
7996 debug_str_size
= sec
->sh_size
;
7998 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7999 _("debug_str section data"));
8003 free_debug_str (void)
8005 if (debug_str_contents
== NULL
)
8008 free ((char *) debug_str_contents
);
8009 debug_str_contents
= NULL
;
8014 fetch_indirect_string (unsigned long offset
)
8016 if (debug_str_contents
== NULL
)
8017 return _("<no .debug_str section>");
8019 if (offset
> debug_str_size
)
8020 return _("<offset is too big>");
8022 return debug_str_contents
+ offset
;
8026 display_debug_str (Elf_Internal_Shdr
*section
,
8027 unsigned char *start
,
8028 FILE *file ATTRIBUTE_UNUSED
)
8030 unsigned long bytes
;
8033 addr
= section
->sh_addr
;
8034 bytes
= section
->sh_size
;
8038 printf (_("\nThe .debug_str section is empty.\n"));
8042 printf (_("Contents of the .debug_str section:\n\n"));
8050 lbytes
= (bytes
> 16 ? 16 : bytes
);
8052 printf (" 0x%8.8lx ", (unsigned long) addr
);
8054 for (j
= 0; j
< 16; j
++)
8057 printf ("%2.2x", start
[j
]);
8065 for (j
= 0; j
< lbytes
; j
++)
8068 if (k
>= ' ' && k
< 0x80)
8084 static unsigned char *
8085 read_and_display_attr_value (unsigned long attribute
,
8087 unsigned char *data
,
8088 unsigned long cu_offset
,
8089 unsigned long pointer_size
,
8090 unsigned long offset_size
,
8093 unsigned long uvalue
= 0;
8094 unsigned char *block_start
= NULL
;
8102 case DW_FORM_ref_addr
:
8103 if (dwarf_version
== 2)
8105 uvalue
= byte_get (data
, pointer_size
);
8106 data
+= pointer_size
;
8108 else if (dwarf_version
== 3)
8110 uvalue
= byte_get (data
, offset_size
);
8111 data
+= offset_size
;
8115 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8120 uvalue
= byte_get (data
, pointer_size
);
8121 data
+= pointer_size
;
8125 uvalue
= byte_get (data
, offset_size
);
8126 data
+= offset_size
;
8132 uvalue
= byte_get (data
++, 1);
8137 uvalue
= byte_get (data
, 2);
8143 uvalue
= byte_get (data
, 4);
8148 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8152 case DW_FORM_ref_udata
:
8154 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8158 case DW_FORM_indirect
:
8159 form
= read_leb128 (data
, & bytes_read
, 0);
8161 printf (" %s", get_FORM_name (form
));
8162 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8163 pointer_size
, offset_size
,
8169 case DW_FORM_ref_addr
:
8170 printf (" <#%lx>", uvalue
);
8176 case DW_FORM_ref_udata
:
8177 printf (" <%lx>", uvalue
+ cu_offset
);
8181 printf (" %#lx", uvalue
);
8190 printf (" %ld", uvalue
);
8195 uvalue
= byte_get (data
, 4);
8196 printf (" %lx", uvalue
);
8197 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8201 case DW_FORM_string
:
8202 printf (" %s", data
);
8203 data
+= strlen ((char *) data
) + 1;
8207 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8208 block_start
= data
+ bytes_read
;
8209 data
= display_block (block_start
, uvalue
);
8212 case DW_FORM_block1
:
8213 uvalue
= byte_get (data
, 1);
8214 block_start
= data
+ 1;
8215 data
= display_block (block_start
, uvalue
);
8218 case DW_FORM_block2
:
8219 uvalue
= byte_get (data
, 2);
8220 block_start
= data
+ 2;
8221 data
= display_block (block_start
, uvalue
);
8224 case DW_FORM_block4
:
8225 uvalue
= byte_get (data
, 4);
8226 block_start
= data
+ 4;
8227 data
= display_block (block_start
, uvalue
);
8231 printf (_(" (indirect string, offset: 0x%lx): %s"),
8232 uvalue
, fetch_indirect_string (uvalue
));
8235 case DW_FORM_indirect
:
8236 /* Handled above. */
8240 warn (_("Unrecognized form: %d\n"), form
);
8244 /* For some attributes we can display further information. */
8253 case DW_INL_not_inlined
:
8254 printf (_("(not inlined)"));
8256 case DW_INL_inlined
:
8257 printf (_("(inlined)"));
8259 case DW_INL_declared_not_inlined
:
8260 printf (_("(declared as inline but ignored)"));
8262 case DW_INL_declared_inlined
:
8263 printf (_("(declared as inline and inlined)"));
8266 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8271 case DW_AT_language
:
8274 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8275 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8276 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8277 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8278 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8279 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8280 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8281 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8282 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8283 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8284 /* DWARF 2.1 values. */
8285 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8286 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8287 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8288 /* MIPS extension. */
8289 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8290 /* UPC extension. */
8291 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8293 printf ("(Unknown: %lx)", uvalue
);
8298 case DW_AT_encoding
:
8301 case DW_ATE_void
: printf ("(void)"); break;
8302 case DW_ATE_address
: printf ("(machine address)"); break;
8303 case DW_ATE_boolean
: printf ("(boolean)"); break;
8304 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8305 case DW_ATE_float
: printf ("(float)"); break;
8306 case DW_ATE_signed
: printf ("(signed)"); break;
8307 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8308 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8309 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8310 /* DWARF 2.1 value. */
8311 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8313 if (uvalue
>= DW_ATE_lo_user
8314 && uvalue
<= DW_ATE_hi_user
)
8315 printf ("(user defined type)");
8317 printf ("(unknown type)");
8322 case DW_AT_accessibility
:
8325 case DW_ACCESS_public
: printf ("(public)"); break;
8326 case DW_ACCESS_protected
: printf ("(protected)"); break;
8327 case DW_ACCESS_private
: printf ("(private)"); break;
8329 printf ("(unknown accessibility)");
8334 case DW_AT_visibility
:
8337 case DW_VIS_local
: printf ("(local)"); break;
8338 case DW_VIS_exported
: printf ("(exported)"); break;
8339 case DW_VIS_qualified
: printf ("(qualified)"); break;
8340 default: printf ("(unknown visibility)"); break;
8344 case DW_AT_virtuality
:
8347 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8348 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8349 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8350 default: printf ("(unknown virtuality)"); break;
8354 case DW_AT_identifier_case
:
8357 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8358 case DW_ID_up_case
: printf ("(up_case)"); break;
8359 case DW_ID_down_case
: printf ("(down_case)"); break;
8360 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8361 default: printf ("(unknown case)"); break;
8365 case DW_AT_calling_convention
:
8368 case DW_CC_normal
: printf ("(normal)"); break;
8369 case DW_CC_program
: printf ("(program)"); break;
8370 case DW_CC_nocall
: printf ("(nocall)"); break;
8372 if (uvalue
>= DW_CC_lo_user
8373 && uvalue
<= DW_CC_hi_user
)
8374 printf ("(user defined)");
8376 printf ("(unknown convention)");
8380 case DW_AT_ordering
:
8383 case -1: printf ("(undefined)"); break;
8384 case 0: printf ("(row major)"); break;
8385 case 1: printf ("(column major)"); break;
8389 case DW_AT_frame_base
:
8390 case DW_AT_location
:
8391 case DW_AT_data_member_location
:
8392 case DW_AT_vtable_elem_location
:
8393 case DW_AT_allocated
:
8394 case DW_AT_associated
:
8395 case DW_AT_data_location
:
8397 case DW_AT_upper_bound
:
8398 case DW_AT_lower_bound
:
8402 decode_location_expression (block_start
, pointer_size
, uvalue
);
8405 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8408 printf ("location list");
8420 static unsigned char *
8421 read_and_display_attr (unsigned long attribute
,
8423 unsigned char *data
,
8424 unsigned long cu_offset
,
8425 unsigned long pointer_size
,
8426 unsigned long offset_size
,
8429 printf (" %-18s:", get_AT_name (attribute
));
8430 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8431 pointer_size
, offset_size
, dwarf_version
);
8437 display_debug_info (Elf_Internal_Shdr
*section
,
8438 unsigned char *start
,
8441 unsigned char *end
= start
+ section
->sh_size
;
8442 unsigned char *section_begin
= start
;
8444 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8446 load_debug_str (file
);
8447 load_debug_loc (file
);
8451 DWARF2_Internal_CompUnit compunit
;
8452 Elf_Internal_Shdr
*relsec
;
8453 unsigned char *hdrptr
;
8454 unsigned char *cu_abbrev_offset_ptr
;
8455 unsigned char *tags
;
8457 unsigned long cu_offset
;
8459 int initial_length_size
;
8463 compunit
.cu_length
= byte_get (hdrptr
, 4);
8466 if (compunit
.cu_length
== 0xffffffff)
8468 compunit
.cu_length
= byte_get (hdrptr
, 8);
8471 initial_length_size
= 12;
8476 initial_length_size
= 4;
8479 compunit
.cu_version
= byte_get (hdrptr
, 2);
8482 /* Apply addends of RELA relocations. */
8483 for (relsec
= section_headers
;
8484 relsec
< section_headers
+ elf_header
.e_shnum
;
8487 unsigned long nrelas
;
8488 Elf_Internal_Rela
*rela
, *rp
;
8489 Elf_Internal_Shdr
*symsec
;
8490 Elf_Internal_Sym
*symtab
;
8491 Elf_Internal_Sym
*sym
;
8493 if (relsec
->sh_type
!= SHT_RELA
8494 || SECTION_HEADER (relsec
->sh_info
) != section
8495 || relsec
->sh_size
== 0)
8498 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8502 symsec
= SECTION_HEADER (relsec
->sh_link
);
8503 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8505 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8509 if (rp
->r_offset
>= (bfd_vma
) (hdrptr
- section_begin
)
8510 && section
->sh_size
> (bfd_vma
) offset_size
8511 && rp
->r_offset
<= section
->sh_size
- offset_size
)
8512 loc
= section_begin
+ rp
->r_offset
;
8518 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8520 if (ELF32_R_SYM (rp
->r_info
) != 0
8521 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8523 warn (_("Skipping unexpected symbol type %u\n"),
8524 ELF32_ST_TYPE (sym
->st_info
));
8530 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8532 if (ELF64_R_SYM (rp
->r_info
) != 0
8533 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8535 warn (_("Skipping unexpected symbol type %u\n"),
8536 ELF64_ST_TYPE (sym
->st_info
));
8541 byte_put (loc
, rp
->r_addend
, offset_size
);
8548 cu_abbrev_offset_ptr
= hdrptr
;
8549 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8550 hdrptr
+= offset_size
;
8552 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8556 cu_offset
= start
- section_begin
;
8557 start
+= compunit
.cu_length
+ initial_length_size
;
8559 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8560 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8561 printf (_(" Version: %d\n"), compunit
.cu_version
);
8562 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8563 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8565 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8567 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8573 /* Read in the abbrevs used by this compilation unit. */
8575 Elf_Internal_Shdr
*sec
;
8576 unsigned char *begin
;
8578 /* Locate the .debug_abbrev section and process it. */
8579 sec
= find_section (".debug_abbrev");
8582 warn (_("Unable to locate .debug_abbrev section!\n"));
8586 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8587 _("debug_abbrev section data"));
8591 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8592 begin
+ sec
->sh_size
);
8598 while (tags
< start
)
8601 unsigned long abbrev_number
;
8602 abbrev_entry
*entry
;
8605 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8608 /* A null DIE marks the end of a list of children. */
8609 if (abbrev_number
== 0)
8615 /* Scan through the abbreviation list until we reach the
8617 for (entry
= first_abbrev
;
8618 entry
&& entry
->entry
!= abbrev_number
;
8619 entry
= entry
->next
)
8624 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8629 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8631 (unsigned long) (tags
- section_begin
- bytes_read
),
8633 get_TAG_name (entry
->tag
));
8635 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8636 tags
= read_and_display_attr (attr
->attribute
,
8639 compunit
.cu_pointer_size
,
8641 compunit
.cu_version
);
8643 if (entry
->children
)
8657 display_debug_aranges (Elf_Internal_Shdr
*section
,
8658 unsigned char *start
,
8659 FILE *file ATTRIBUTE_UNUSED
)
8661 unsigned char *end
= start
+ section
->sh_size
;
8663 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8667 unsigned char *hdrptr
;
8668 DWARF2_Internal_ARange arange
;
8669 unsigned char *ranges
;
8670 unsigned long length
;
8671 unsigned long address
;
8674 int initial_length_size
;
8678 arange
.ar_length
= byte_get (hdrptr
, 4);
8681 if (arange
.ar_length
== 0xffffffff)
8683 arange
.ar_length
= byte_get (hdrptr
, 8);
8686 initial_length_size
= 12;
8691 initial_length_size
= 4;
8694 arange
.ar_version
= byte_get (hdrptr
, 2);
8697 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
8698 hdrptr
+= offset_size
;
8700 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
8703 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
8706 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
8708 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8712 printf (_(" Length: %ld\n"), arange
.ar_length
);
8713 printf (_(" Version: %d\n"), arange
.ar_version
);
8714 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8715 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8716 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8718 printf (_("\n Address Length\n"));
8722 /* Must pad to an alignment boundary that is twice the pointer size. */
8723 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
8725 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8729 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8731 ranges
+= arange
.ar_pointer_size
;
8733 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8735 ranges
+= arange
.ar_pointer_size
;
8737 /* A pair of zeros marks the end of the list. */
8738 if (address
== 0 && length
== 0)
8741 printf (" %8.8lx %lu\n", address
, length
);
8744 start
+= arange
.ar_length
+ initial_length_size
;
8752 typedef struct Frame_Chunk
8754 struct Frame_Chunk
*next
;
8755 unsigned char *chunk_start
;
8757 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8758 short int *col_type
;
8761 unsigned int code_factor
;
8763 unsigned long pc_begin
;
8764 unsigned long pc_range
;
8768 unsigned char fde_encoding
;
8769 unsigned char cfa_exp
;
8773 /* A marker for a col_type that means this column was never referenced
8774 in the frame info. */
8775 #define DW_CFA_unreferenced (-1)
8778 frame_need_space (Frame_Chunk
*fc
, int reg
)
8780 int prev
= fc
->ncols
;
8782 if (reg
< fc
->ncols
)
8785 fc
->ncols
= reg
+ 1;
8786 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
8787 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
8789 while (prev
< fc
->ncols
)
8791 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8792 fc
->col_offset
[prev
] = 0;
8798 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
8803 if (*max_regs
< fc
->ncols
)
8804 *max_regs
= fc
->ncols
;
8806 if (*need_col_headers
)
8808 *need_col_headers
= 0;
8810 printf (" LOC CFA ");
8812 for (r
= 0; r
< *max_regs
; r
++)
8813 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8818 printf ("r%-4d", r
);
8824 printf ("%08lx ", fc
->pc_begin
);
8826 strcpy (tmp
, "exp");
8828 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8829 printf ("%-8s ", tmp
);
8831 for (r
= 0; r
< fc
->ncols
; r
++)
8833 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8835 switch (fc
->col_type
[r
])
8837 case DW_CFA_undefined
:
8840 case DW_CFA_same_value
:
8844 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8846 case DW_CFA_register
:
8847 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8849 case DW_CFA_expression
:
8850 strcpy (tmp
, "exp");
8853 strcpy (tmp
, "n/a");
8856 printf ("%-5s", tmp
);
8863 size_of_encoded_value (int encoding
)
8865 switch (encoding
& 0x7)
8868 case 0: return is_32bit_elf
? 4 : 8;
8876 get_encoded_value (unsigned char *data
, int encoding
)
8878 int size
= size_of_encoded_value (encoding
);
8879 if (encoding
& DW_EH_PE_signed
)
8880 return byte_get_signed (data
, size
);
8882 return byte_get (data
, size
);
8885 #define GET(N) byte_get (start, N); start += N
8886 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8887 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8890 display_debug_frames (Elf_Internal_Shdr
*section
,
8891 unsigned char *start
,
8892 FILE *file ATTRIBUTE_UNUSED
)
8894 unsigned char *end
= start
+ section
->sh_size
;
8895 unsigned char *section_start
= start
;
8896 Frame_Chunk
*chunks
= 0;
8897 Frame_Chunk
*remembered_state
= 0;
8899 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8902 int addr_size
= is_32bit_elf
? 4 : 8;
8904 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8908 unsigned char *saved_start
;
8909 unsigned char *block_end
;
8910 unsigned long length
;
8911 unsigned long cie_id
;
8914 int need_col_headers
= 1;
8915 unsigned char *augmentation_data
= NULL
;
8916 unsigned long augmentation_data_len
= 0;
8917 int encoded_ptr_size
= addr_size
;
8919 int initial_length_size
;
8921 saved_start
= start
;
8922 length
= byte_get (start
, 4); start
+= 4;
8926 printf ("\n%08lx ZERO terminator\n\n",
8927 (unsigned long)(saved_start
- section_start
));
8931 if (length
== 0xffffffff)
8933 length
= byte_get (start
, 8);
8936 initial_length_size
= 12;
8941 initial_length_size
= 4;
8944 block_end
= saved_start
+ length
+ initial_length_size
;
8945 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
8947 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8951 fc
= xmalloc (sizeof (Frame_Chunk
));
8952 memset (fc
, 0, sizeof (Frame_Chunk
));
8956 fc
->chunk_start
= saved_start
;
8958 fc
->col_type
= xmalloc (sizeof (short int));
8959 fc
->col_offset
= xmalloc (sizeof (int));
8960 frame_need_space (fc
, max_regs
-1);
8964 fc
->augmentation
= start
;
8965 start
= strchr (start
, '\0') + 1;
8967 if (fc
->augmentation
[0] == 'z')
8969 fc
->code_factor
= LEB ();
8970 fc
->data_factor
= SLEB ();
8971 fc
->ra
= byte_get (start
, 1); start
+= 1;
8972 augmentation_data_len
= LEB ();
8973 augmentation_data
= start
;
8974 start
+= augmentation_data_len
;
8976 else if (strcmp (fc
->augmentation
, "eh") == 0)
8979 fc
->code_factor
= LEB ();
8980 fc
->data_factor
= SLEB ();
8981 fc
->ra
= byte_get (start
, 1); start
+= 1;
8985 fc
->code_factor
= LEB ();
8986 fc
->data_factor
= SLEB ();
8987 fc
->ra
= byte_get (start
, 1); start
+= 1;
8991 if (do_debug_frames_interp
)
8992 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8993 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8994 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8998 printf ("\n%08lx %08lx %08lx CIE\n",
8999 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
9000 printf (" Version: %d\n", version
);
9001 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9002 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9003 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9004 printf (" Return address column: %d\n", fc
->ra
);
9006 if (augmentation_data_len
)
9009 printf (" Augmentation data: ");
9010 for (i
= 0; i
< augmentation_data_len
; ++i
)
9011 printf (" %02x", augmentation_data
[i
]);
9017 if (augmentation_data_len
)
9019 unsigned char *p
, *q
;
9020 p
= fc
->augmentation
+ 1;
9021 q
= augmentation_data
;
9028 q
+= 1 + size_of_encoded_value (*q
);
9030 fc
->fde_encoding
= *q
++;
9036 if (fc
->fde_encoding
)
9037 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9040 frame_need_space (fc
, fc
->ra
);
9044 unsigned char *look_for
;
9045 static Frame_Chunk fde_fc
;
9048 memset (fc
, 0, sizeof (Frame_Chunk
));
9050 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
9052 for (cie
= chunks
; cie
; cie
= cie
->next
)
9053 if (cie
->chunk_start
== look_for
)
9058 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9059 cie_id
, saved_start
);
9062 fc
->col_type
= xmalloc (sizeof (short int));
9063 fc
->col_offset
= xmalloc (sizeof (int));
9064 frame_need_space (fc
, max_regs
- 1);
9066 fc
->augmentation
= "";
9067 fc
->fde_encoding
= 0;
9071 fc
->ncols
= cie
->ncols
;
9072 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
9073 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
9074 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9075 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9076 fc
->augmentation
= cie
->augmentation
;
9077 fc
->code_factor
= cie
->code_factor
;
9078 fc
->data_factor
= cie
->data_factor
;
9079 fc
->cfa_reg
= cie
->cfa_reg
;
9080 fc
->cfa_offset
= cie
->cfa_offset
;
9082 frame_need_space (fc
, max_regs
-1);
9083 fc
->fde_encoding
= cie
->fde_encoding
;
9086 if (fc
->fde_encoding
)
9087 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9089 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
9090 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
9091 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
9092 start
+= encoded_ptr_size
;
9093 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
9094 start
+= encoded_ptr_size
;
9096 if (cie
->augmentation
[0] == 'z')
9098 augmentation_data_len
= LEB ();
9099 augmentation_data
= start
;
9100 start
+= augmentation_data_len
;
9103 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9104 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9105 (unsigned long)(cie
->chunk_start
- section_start
),
9106 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
9107 if (! do_debug_frames_interp
&& augmentation_data_len
)
9110 printf (" Augmentation data: ");
9111 for (i
= 0; i
< augmentation_data_len
; ++i
)
9112 printf (" %02x", augmentation_data
[i
]);
9118 /* At this point, fc is the current chunk, cie (if any) is set, and we're
9119 about to interpret instructions for the chunk. */
9120 /* ??? At present we need to do this always, since this sizes the
9121 fc->col_type and fc->col_offset arrays, which we write into always.
9122 We should probably split the interpreted and non-interpreted bits
9123 into two different routines, since there's so much that doesn't
9124 really overlap between them. */
9125 if (1 || do_debug_frames_interp
)
9127 /* Start by making a pass over the chunk, allocating storage
9128 and taking note of what registers are used. */
9129 unsigned char *tmp
= start
;
9131 while (start
< block_end
)
9134 unsigned long reg
, tmp
;
9141 /* Warning: if you add any more cases to this switch, be
9142 sure to add them to the corresponding switch below. */
9145 case DW_CFA_advance_loc
:
9149 frame_need_space (fc
, opa
);
9150 fc
->col_type
[opa
] = DW_CFA_undefined
;
9152 case DW_CFA_restore
:
9153 frame_need_space (fc
, opa
);
9154 fc
->col_type
[opa
] = DW_CFA_undefined
;
9156 case DW_CFA_set_loc
:
9157 start
+= encoded_ptr_size
;
9159 case DW_CFA_advance_loc1
:
9162 case DW_CFA_advance_loc2
:
9165 case DW_CFA_advance_loc4
:
9168 case DW_CFA_offset_extended
:
9169 reg
= LEB (); LEB ();
9170 frame_need_space (fc
, reg
);
9171 fc
->col_type
[reg
] = DW_CFA_undefined
;
9173 case DW_CFA_restore_extended
:
9175 frame_need_space (fc
, reg
);
9176 fc
->col_type
[reg
] = DW_CFA_undefined
;
9178 case DW_CFA_undefined
:
9180 frame_need_space (fc
, reg
);
9181 fc
->col_type
[reg
] = DW_CFA_undefined
;
9183 case DW_CFA_same_value
:
9185 frame_need_space (fc
, reg
);
9186 fc
->col_type
[reg
] = DW_CFA_undefined
;
9188 case DW_CFA_register
:
9189 reg
= LEB (); LEB ();
9190 frame_need_space (fc
, reg
);
9191 fc
->col_type
[reg
] = DW_CFA_undefined
;
9193 case DW_CFA_def_cfa
:
9196 case DW_CFA_def_cfa_register
:
9199 case DW_CFA_def_cfa_offset
:
9202 case DW_CFA_def_cfa_expression
:
9206 case DW_CFA_expression
:
9210 frame_need_space (fc
, reg
);
9211 fc
->col_type
[reg
] = DW_CFA_undefined
;
9213 case DW_CFA_offset_extended_sf
:
9214 reg
= LEB (); SLEB ();
9215 frame_need_space (fc
, reg
);
9216 fc
->col_type
[reg
] = DW_CFA_undefined
;
9218 case DW_CFA_def_cfa_sf
:
9221 case DW_CFA_def_cfa_offset_sf
:
9224 case DW_CFA_MIPS_advance_loc8
:
9227 case DW_CFA_GNU_args_size
:
9230 case DW_CFA_GNU_negative_offset_extended
:
9231 reg
= LEB (); LEB ();
9232 frame_need_space (fc
, reg
);
9233 fc
->col_type
[reg
] = DW_CFA_undefined
;
9242 /* Now we know what registers are used, make a second pass over
9243 the chunk, this time actually printing out the info. */
9245 while (start
< block_end
)
9248 unsigned long ul
, reg
, roffs
;
9257 /* Warning: if you add any more cases to this switch, be
9258 sure to add them to the corresponding switch above. */
9261 case DW_CFA_advance_loc
:
9262 if (do_debug_frames_interp
)
9263 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9265 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9266 opa
* fc
->code_factor
,
9267 fc
->pc_begin
+ opa
* fc
->code_factor
);
9268 fc
->pc_begin
+= opa
* fc
->code_factor
;
9273 if (! do_debug_frames_interp
)
9274 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9275 opa
, roffs
* fc
->data_factor
);
9276 fc
->col_type
[opa
] = DW_CFA_offset
;
9277 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9280 case DW_CFA_restore
:
9281 if (! do_debug_frames_interp
)
9282 printf (" DW_CFA_restore: r%d\n", opa
);
9283 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9284 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9287 case DW_CFA_set_loc
:
9288 vma
= get_encoded_value (start
, fc
->fde_encoding
);
9289 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
9290 vma
+= section
->sh_addr
+ (start
- section_start
);
9291 start
+= encoded_ptr_size
;
9292 if (do_debug_frames_interp
)
9293 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9295 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
9299 case DW_CFA_advance_loc1
:
9300 ofs
= byte_get (start
, 1); start
+= 1;
9301 if (do_debug_frames_interp
)
9302 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9304 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9305 ofs
* fc
->code_factor
,
9306 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9307 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9310 case DW_CFA_advance_loc2
:
9311 ofs
= byte_get (start
, 2); start
+= 2;
9312 if (do_debug_frames_interp
)
9313 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9315 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9316 ofs
* fc
->code_factor
,
9317 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9318 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9321 case DW_CFA_advance_loc4
:
9322 ofs
= byte_get (start
, 4); start
+= 4;
9323 if (do_debug_frames_interp
)
9324 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9326 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9327 ofs
* fc
->code_factor
,
9328 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9329 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9332 case DW_CFA_offset_extended
:
9335 if (! do_debug_frames_interp
)
9336 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9337 reg
, roffs
* fc
->data_factor
);
9338 fc
->col_type
[reg
] = DW_CFA_offset
;
9339 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9342 case DW_CFA_restore_extended
:
9344 if (! do_debug_frames_interp
)
9345 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
9346 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9347 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9350 case DW_CFA_undefined
:
9352 if (! do_debug_frames_interp
)
9353 printf (" DW_CFA_undefined: r%ld\n", reg
);
9354 fc
->col_type
[reg
] = DW_CFA_undefined
;
9355 fc
->col_offset
[reg
] = 0;
9358 case DW_CFA_same_value
:
9360 if (! do_debug_frames_interp
)
9361 printf (" DW_CFA_same_value: r%ld\n", reg
);
9362 fc
->col_type
[reg
] = DW_CFA_same_value
;
9363 fc
->col_offset
[reg
] = 0;
9366 case DW_CFA_register
:
9369 if (! do_debug_frames_interp
)
9370 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
9371 fc
->col_type
[reg
] = DW_CFA_register
;
9372 fc
->col_offset
[reg
] = roffs
;
9375 case DW_CFA_remember_state
:
9376 if (! do_debug_frames_interp
)
9377 printf (" DW_CFA_remember_state\n");
9378 rs
= xmalloc (sizeof (Frame_Chunk
));
9379 rs
->ncols
= fc
->ncols
;
9380 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
9381 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
9382 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
9383 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
9384 rs
->next
= remembered_state
;
9385 remembered_state
= rs
;
9388 case DW_CFA_restore_state
:
9389 if (! do_debug_frames_interp
)
9390 printf (" DW_CFA_restore_state\n");
9391 rs
= remembered_state
;
9394 remembered_state
= rs
->next
;
9395 frame_need_space (fc
, rs
->ncols
-1);
9396 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
9397 memcpy (fc
->col_offset
, rs
->col_offset
,
9398 rs
->ncols
* sizeof (int));
9399 free (rs
->col_type
);
9400 free (rs
->col_offset
);
9403 else if (do_debug_frames_interp
)
9404 printf ("Mismatched DW_CFA_restore_state\n");
9407 case DW_CFA_def_cfa
:
9408 fc
->cfa_reg
= LEB ();
9409 fc
->cfa_offset
= LEB ();
9411 if (! do_debug_frames_interp
)
9412 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9413 fc
->cfa_reg
, fc
->cfa_offset
);
9416 case DW_CFA_def_cfa_register
:
9417 fc
->cfa_reg
= LEB ();
9419 if (! do_debug_frames_interp
)
9420 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9423 case DW_CFA_def_cfa_offset
:
9424 fc
->cfa_offset
= LEB ();
9425 if (! do_debug_frames_interp
)
9426 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9430 if (! do_debug_frames_interp
)
9431 printf (" DW_CFA_nop\n");
9434 case DW_CFA_def_cfa_expression
:
9436 if (! do_debug_frames_interp
)
9438 printf (" DW_CFA_def_cfa_expression (");
9439 decode_location_expression (start
, addr_size
, ul
);
9446 case DW_CFA_expression
:
9449 if (! do_debug_frames_interp
)
9451 printf (" DW_CFA_expression: r%ld (", reg
);
9452 decode_location_expression (start
, addr_size
, ul
);
9455 fc
->col_type
[reg
] = DW_CFA_expression
;
9459 case DW_CFA_offset_extended_sf
:
9462 frame_need_space (fc
, reg
);
9463 if (! do_debug_frames_interp
)
9464 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9465 reg
, l
* fc
->data_factor
);
9466 fc
->col_type
[reg
] = DW_CFA_offset
;
9467 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9470 case DW_CFA_def_cfa_sf
:
9471 fc
->cfa_reg
= LEB ();
9472 fc
->cfa_offset
= SLEB ();
9474 if (! do_debug_frames_interp
)
9475 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9476 fc
->cfa_reg
, fc
->cfa_offset
);
9479 case DW_CFA_def_cfa_offset_sf
:
9480 fc
->cfa_offset
= SLEB ();
9481 if (! do_debug_frames_interp
)
9482 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9485 case DW_CFA_MIPS_advance_loc8
:
9486 ofs
= byte_get (start
, 8); start
+= 8;
9487 if (do_debug_frames_interp
)
9488 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9490 printf (" DW_CFA_MIPS_advance_loc8: %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_GNU_window_save
:
9497 if (! do_debug_frames_interp
)
9498 printf (" DW_CFA_GNU_window_save\n");
9501 case DW_CFA_GNU_args_size
:
9503 if (! do_debug_frames_interp
)
9504 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9507 case DW_CFA_GNU_negative_offset_extended
:
9510 frame_need_space (fc
, reg
);
9511 if (! do_debug_frames_interp
)
9512 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9513 reg
, l
* fc
->data_factor
);
9514 fc
->col_type
[reg
] = DW_CFA_offset
;
9515 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9519 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9524 if (do_debug_frames_interp
)
9525 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9540 display_debug_not_supported (Elf_Internal_Shdr
*section
,
9541 unsigned char *start ATTRIBUTE_UNUSED
,
9542 FILE *file ATTRIBUTE_UNUSED
)
9544 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9545 SECTION_NAME (section
));
9550 /* A structure containing the name of a debug section
9551 and a pointer to a function that can decode it. */
9554 const char *const name
;
9555 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
9559 { ".debug_abbrev", display_debug_abbrev
},
9560 { ".debug_aranges", display_debug_aranges
},
9561 { ".debug_frame", display_debug_frames
},
9562 { ".debug_info", display_debug_info
},
9563 { ".debug_line", display_debug_lines
},
9564 { ".debug_pubnames", display_debug_pubnames
},
9565 { ".eh_frame", display_debug_frames
},
9566 { ".debug_macinfo", display_debug_macinfo
},
9567 { ".debug_str", display_debug_str
},
9568 { ".debug_loc", display_debug_loc
},
9569 { ".debug_pubtypes", display_debug_pubnames
},
9570 { ".debug_ranges", display_debug_not_supported
},
9571 { ".debug_static_func", display_debug_not_supported
},
9572 { ".debug_static_vars", display_debug_not_supported
},
9573 { ".debug_types", display_debug_not_supported
},
9574 { ".debug_weaknames", display_debug_not_supported
}
9578 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
9580 char *name
= SECTION_NAME (section
);
9581 bfd_size_type length
;
9582 unsigned char *start
;
9585 length
= section
->sh_size
;
9588 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9592 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
9593 _("debug section data"));
9597 /* See if we know how to display the contents of this section. */
9598 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9599 name
= ".debug_info";
9601 for (i
= NUM_ELEM (debug_displays
); i
--;)
9602 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9604 debug_displays
[i
].display (section
, start
, file
);
9609 printf (_("Unrecognized debug section: %s\n"), name
);
9613 /* If we loaded in the abbrev section at some point,
9614 we must release it here. */
9621 process_section_contents (FILE *file
)
9623 Elf_Internal_Shdr
*section
;
9629 for (i
= 0, section
= section_headers
;
9630 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9633 #ifdef SUPPORT_DISASSEMBLY
9634 if (dump_sects
[i
] & DISASS_DUMP
)
9635 disassemble_section (section
, file
);
9637 if (dump_sects
[i
] & HEX_DUMP
)
9638 dump_section (section
, file
);
9640 if (dump_sects
[i
] & DEBUG_DUMP
)
9641 display_debug_section (section
, file
);
9644 if (i
< num_dump_sects
)
9645 warn (_("Some sections were not dumped because they do not exist!\n"));
9651 process_mips_fpe_exception (int mask
)
9656 if (mask
& OEX_FPU_INEX
)
9657 fputs ("INEX", stdout
), first
= 0;
9658 if (mask
& OEX_FPU_UFLO
)
9659 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9660 if (mask
& OEX_FPU_OFLO
)
9661 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9662 if (mask
& OEX_FPU_DIV0
)
9663 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9664 if (mask
& OEX_FPU_INVAL
)
9665 printf ("%sINVAL", first
? "" : "|");
9668 fputs ("0", stdout
);
9672 process_mips_specific (FILE *file
)
9674 Elf_Internal_Dyn
*entry
;
9675 size_t liblist_offset
= 0;
9676 size_t liblistno
= 0;
9677 size_t conflictsno
= 0;
9678 size_t options_offset
= 0;
9679 size_t conflicts_offset
= 0;
9681 /* We have a lot of special sections. Thanks SGI! */
9682 if (dynamic_segment
== NULL
)
9683 /* No information available. */
9686 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9687 switch (entry
->d_tag
)
9689 case DT_MIPS_LIBLIST
:
9691 = offset_from_vma (file
, entry
->d_un
.d_val
,
9692 liblistno
* sizeof (Elf32_External_Lib
));
9694 case DT_MIPS_LIBLISTNO
:
9695 liblistno
= entry
->d_un
.d_val
;
9697 case DT_MIPS_OPTIONS
:
9698 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9700 case DT_MIPS_CONFLICT
:
9702 = offset_from_vma (file
, entry
->d_un
.d_val
,
9703 conflictsno
* sizeof (Elf32_External_Conflict
));
9705 case DT_MIPS_CONFLICTNO
:
9706 conflictsno
= entry
->d_un
.d_val
;
9712 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9714 Elf32_External_Lib
*elib
;
9717 elib
= get_data (NULL
, file
, liblist_offset
,
9718 liblistno
* sizeof (Elf32_External_Lib
),
9722 printf ("\nSection '.liblist' contains %lu entries:\n",
9723 (unsigned long) liblistno
);
9724 fputs (" Library Time Stamp Checksum Version Flags\n",
9727 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9734 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9735 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9736 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9737 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9738 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9740 tmp
= gmtime (&time
);
9741 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9742 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9743 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9745 printf ("%3lu: ", (unsigned long) cnt
);
9746 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9747 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9750 if (liblist
.l_flags
== 0)
9761 { " EXACT_MATCH", LL_EXACT_MATCH
},
9762 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9763 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9764 { " EXPORTS", LL_EXPORTS
},
9765 { " DELAY_LOAD", LL_DELAY_LOAD
},
9766 { " DELTA", LL_DELTA
}
9768 int flags
= liblist
.l_flags
;
9772 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9774 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9776 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9777 flags
^= l_flags_vals
[fcnt
].bit
;
9780 printf (" %#x", (unsigned int) flags
);
9790 if (options_offset
!= 0)
9792 Elf_External_Options
*eopt
;
9793 Elf_Internal_Shdr
*sect
= section_headers
;
9794 Elf_Internal_Options
*iopt
;
9795 Elf_Internal_Options
*option
;
9799 /* Find the section header so that we get the size. */
9800 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9803 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
9807 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
9810 error (_("Out of memory"));
9817 while (offset
< sect
->sh_size
)
9819 Elf_External_Options
*eoption
;
9821 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9823 option
->kind
= BYTE_GET (eoption
->kind
);
9824 option
->size
= BYTE_GET (eoption
->size
);
9825 option
->section
= BYTE_GET (eoption
->section
);
9826 option
->info
= BYTE_GET (eoption
->info
);
9828 offset
+= option
->size
;
9834 printf (_("\nSection '%s' contains %d entries:\n"),
9835 SECTION_NAME (sect
), cnt
);
9843 switch (option
->kind
)
9846 /* This shouldn't happen. */
9847 printf (" NULL %d %lx", option
->section
, option
->info
);
9850 printf (" REGINFO ");
9851 if (elf_header
.e_machine
== EM_MIPS
)
9854 Elf32_External_RegInfo
*ereg
;
9855 Elf32_RegInfo reginfo
;
9857 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9858 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9859 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9860 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9861 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9862 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9863 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9865 printf ("GPR %08lx GP 0x%lx\n",
9867 (unsigned long) reginfo
.ri_gp_value
);
9868 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9869 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9870 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9875 Elf64_External_RegInfo
*ereg
;
9876 Elf64_Internal_RegInfo reginfo
;
9878 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9879 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9880 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9881 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9882 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9883 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9884 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9886 printf ("GPR %08lx GP 0x",
9887 reginfo
.ri_gprmask
);
9888 printf_vma (reginfo
.ri_gp_value
);
9891 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9892 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9893 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9897 case ODK_EXCEPTIONS
:
9898 fputs (" EXCEPTIONS fpe_min(", stdout
);
9899 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9900 fputs (") fpe_max(", stdout
);
9901 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9902 fputs (")", stdout
);
9904 if (option
->info
& OEX_PAGE0
)
9905 fputs (" PAGE0", stdout
);
9906 if (option
->info
& OEX_SMM
)
9907 fputs (" SMM", stdout
);
9908 if (option
->info
& OEX_FPDBUG
)
9909 fputs (" FPDBUG", stdout
);
9910 if (option
->info
& OEX_DISMISS
)
9911 fputs (" DISMISS", stdout
);
9914 fputs (" PAD ", stdout
);
9915 if (option
->info
& OPAD_PREFIX
)
9916 fputs (" PREFIX", stdout
);
9917 if (option
->info
& OPAD_POSTFIX
)
9918 fputs (" POSTFIX", stdout
);
9919 if (option
->info
& OPAD_SYMBOL
)
9920 fputs (" SYMBOL", stdout
);
9923 fputs (" HWPATCH ", stdout
);
9924 if (option
->info
& OHW_R4KEOP
)
9925 fputs (" R4KEOP", stdout
);
9926 if (option
->info
& OHW_R8KPFETCH
)
9927 fputs (" R8KPFETCH", stdout
);
9928 if (option
->info
& OHW_R5KEOP
)
9929 fputs (" R5KEOP", stdout
);
9930 if (option
->info
& OHW_R5KCVTL
)
9931 fputs (" R5KCVTL", stdout
);
9934 fputs (" FILL ", stdout
);
9935 /* XXX Print content of info word? */
9938 fputs (" TAGS ", stdout
);
9939 /* XXX Print content of info word? */
9942 fputs (" HWAND ", stdout
);
9943 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9944 fputs (" R4KEOP_CHECKED", stdout
);
9945 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9946 fputs (" R4KEOP_CLEAN", stdout
);
9949 fputs (" HWOR ", stdout
);
9950 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9951 fputs (" R4KEOP_CHECKED", stdout
);
9952 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9953 fputs (" R4KEOP_CLEAN", stdout
);
9956 printf (" GP_GROUP %#06lx self-contained %#06lx",
9957 option
->info
& OGP_GROUP
,
9958 (option
->info
& OGP_SELF
) >> 16);
9961 printf (" IDENT %#06lx self-contained %#06lx",
9962 option
->info
& OGP_GROUP
,
9963 (option
->info
& OGP_SELF
) >> 16);
9966 /* This shouldn't happen. */
9967 printf (" %3d ??? %d %lx",
9968 option
->kind
, option
->section
, option
->info
);
9972 len
= sizeof (*eopt
);
9973 while (len
< option
->size
)
9974 if (((char *) option
)[len
] >= ' '
9975 && ((char *) option
)[len
] < 0x7f)
9976 printf ("%c", ((char *) option
)[len
++]);
9978 printf ("\\%03o", ((char *) option
)[len
++]);
9980 fputs ("\n", stdout
);
9988 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9990 Elf32_Conflict
*iconf
;
9993 if (dynamic_symbols
== NULL
)
9995 error (_("conflict list found without a dynamic symbol table"));
9999 iconf
= malloc (conflictsno
* sizeof (*iconf
));
10002 error (_("Out of memory"));
10008 Elf32_External_Conflict
*econf32
;
10010 econf32
= get_data (NULL
, file
, conflicts_offset
,
10011 conflictsno
* sizeof (*econf32
), _("conflict"));
10015 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10016 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10022 Elf64_External_Conflict
*econf64
;
10024 econf64
= get_data (NULL
, file
, conflicts_offset
,
10025 conflictsno
* sizeof (*econf64
), _("conflict"));
10029 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10030 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10035 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10036 (unsigned long) conflictsno
);
10037 puts (_(" Num: Index Value Name"));
10039 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10041 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
10043 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10044 print_vma (psym
->st_value
, FULL_HEX
);
10046 print_symbol (25, dynamic_strings
+ psym
->st_name
);
10057 process_gnu_liblist (FILE *file
)
10059 Elf_Internal_Shdr
*section
, *string_sec
;
10060 Elf32_External_Lib
*elib
;
10068 for (i
= 0, section
= section_headers
;
10069 i
< elf_header
.e_shnum
;
10072 switch (section
->sh_type
)
10074 case SHT_GNU_LIBLIST
:
10075 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
10080 string_sec
= SECTION_HEADER (section
->sh_link
);
10082 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
10083 string_sec
->sh_size
, _("liblist string table"));
10086 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10092 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10093 SECTION_NAME (section
),
10094 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10096 puts (" Library Time Stamp Checksum Version Flags");
10098 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10106 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10107 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10108 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10109 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10110 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10112 tmp
= gmtime (&time
);
10113 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10114 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10115 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10117 printf ("%3lu: ", (unsigned long) cnt
);
10119 printf ("%-20s", strtab
+ liblist
.l_name
);
10121 printf ("%-20.20s", strtab
+ liblist
.l_name
);
10122 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10123 liblist
.l_version
, liblist
.l_flags
);
10133 static const char *
10134 get_note_type (unsigned e_type
)
10136 static char buff
[64];
10140 case NT_AUXV
: return _("NT_AUXV (auxiliary vector)");
10141 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
10142 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
10143 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
10144 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
10145 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
10146 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
10147 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
10148 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
10149 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
10150 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
10151 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10153 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10158 static const char *
10159 get_netbsd_elfcore_note_type (unsigned e_type
)
10161 static char buff
[64];
10163 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10165 /* NetBSD core "procinfo" structure. */
10166 return _("NetBSD procinfo structure");
10169 /* As of Jan 2002 there are no other machine-independent notes
10170 defined for NetBSD core files. If the note type is less
10171 than the start of the machine-dependent note types, we don't
10174 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10176 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10180 switch (elf_header
.e_machine
)
10182 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10183 and PT_GETFPREGS == mach+2. */
10188 case EM_SPARC32PLUS
:
10192 case NT_NETBSDCORE_FIRSTMACH
+0:
10193 return _("PT_GETREGS (reg structure)");
10194 case NT_NETBSDCORE_FIRSTMACH
+2:
10195 return _("PT_GETFPREGS (fpreg structure)");
10201 /* On all other arch's, PT_GETREGS == mach+1 and
10202 PT_GETFPREGS == mach+3. */
10206 case NT_NETBSDCORE_FIRSTMACH
+1:
10207 return _("PT_GETREGS (reg structure)");
10208 case NT_NETBSDCORE_FIRSTMACH
+3:
10209 return _("PT_GETFPREGS (fpreg structure)");
10215 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
10219 /* Note that by the ELF standard, the name field is already null byte
10220 terminated, and namesz includes the terminating null byte.
10221 I.E. the value of namesz for the name "FSF" is 4.
10223 If the value of namesz is zero, there is no name present. */
10225 process_note (Elf_Internal_Note
*pnote
)
10229 if (pnote
->namesz
== 0)
10231 /* If there is no note name, then use the default set of
10232 note type strings. */
10233 nt
= get_note_type (pnote
->type
);
10235 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
10237 /* NetBSD-specific core file notes. */
10238 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10242 /* Don't recognize this note name; just use the default set of
10243 note type strings. */
10244 nt
= get_note_type (pnote
->type
);
10247 printf (" %s\t\t0x%08lx\t%s\n",
10248 pnote
->namesz
? pnote
->namedata
: "(NONE)",
10249 pnote
->descsz
, nt
);
10255 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10257 Elf_External_Note
*pnotes
;
10258 Elf_External_Note
*external
;
10264 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
10270 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10271 (unsigned long) offset
, (unsigned long) length
);
10272 printf (_(" Owner\t\tData size\tDescription\n"));
10274 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10276 Elf_External_Note
*next
;
10277 Elf_Internal_Note inote
;
10280 inote
.type
= BYTE_GET (external
->type
);
10281 inote
.namesz
= BYTE_GET (external
->namesz
);
10282 inote
.namedata
= external
->name
;
10283 inote
.descsz
= BYTE_GET (external
->descsz
);
10284 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10285 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10287 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10289 if (((char *) next
) > (((char *) pnotes
) + length
))
10291 warn (_("corrupt note found at offset %x into core notes\n"),
10292 ((char *) external
) - ((char *) pnotes
));
10293 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10294 inote
.type
, inote
.namesz
, inote
.descsz
);
10300 /* Verify that name is null terminated. It appears that at least
10301 one version of Linux (RedHat 6.0) generates corefiles that don't
10302 comply with the ELF spec by failing to include the null byte in
10304 if (inote
.namedata
[inote
.namesz
] != '\0')
10306 temp
= malloc (inote
.namesz
+ 1);
10310 error (_("Out of memory\n"));
10315 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10316 temp
[inote
.namesz
] = 0;
10318 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10319 inote
.namedata
= temp
;
10322 res
&= process_note (& inote
);
10337 process_corefile_note_segments (FILE *file
)
10339 Elf_Internal_Phdr
*segment
;
10343 if (! get_program_headers (file
))
10346 for (i
= 0, segment
= program_headers
;
10347 i
< elf_header
.e_phnum
;
10350 if (segment
->p_type
== PT_NOTE
)
10351 res
&= process_corefile_note_segment (file
,
10352 (bfd_vma
) segment
->p_offset
,
10353 (bfd_vma
) segment
->p_filesz
);
10360 process_corefile_contents (FILE *file
)
10362 /* If we have not been asked to display the notes then do nothing. */
10366 /* If file is not a core file then exit. */
10367 if (elf_header
.e_type
!= ET_CORE
)
10370 /* No program headers means no NOTE segment. */
10371 if (elf_header
.e_phnum
== 0)
10373 printf (_("No note segments present in the core file.\n"));
10377 return process_corefile_note_segments (file
);
10381 process_arch_specific (FILE *file
)
10386 switch (elf_header
.e_machine
)
10389 case EM_MIPS_RS3_LE
:
10390 return process_mips_specific (file
);
10399 get_file_header (FILE *file
)
10401 /* Read in the identity array. */
10402 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10405 /* Determine how to read the rest of the header. */
10406 switch (elf_header
.e_ident
[EI_DATA
])
10408 default: /* fall through */
10409 case ELFDATANONE
: /* fall through */
10411 byte_get
= byte_get_little_endian
;
10412 byte_put
= byte_put_little_endian
;
10415 byte_get
= byte_get_big_endian
;
10416 byte_put
= byte_put_big_endian
;
10420 /* For now we only support 32 bit and 64 bit ELF files. */
10421 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10423 /* Read in the rest of the header. */
10426 Elf32_External_Ehdr ehdr32
;
10428 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10431 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10432 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10433 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10434 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10435 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10436 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10437 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10438 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10439 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10440 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10441 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10442 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10443 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10447 Elf64_External_Ehdr ehdr64
;
10449 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10450 we will not be able to cope with the 64bit data found in
10451 64 ELF files. Detect this now and abort before we start
10452 overwriting things. */
10453 if (sizeof (bfd_vma
) < 8)
10455 error (_("This instance of readelf has been built without support for a\n\
10456 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10460 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10463 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10464 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10465 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10466 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10467 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10468 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10469 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10470 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10471 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10472 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10473 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10474 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10475 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10478 if (elf_header
.e_shoff
)
10480 /* There may be some extensions in the first section header. Don't
10481 bomb if we can't read it. */
10483 get_32bit_section_headers (file
, 1);
10485 get_64bit_section_headers (file
, 1);
10491 /* Process one ELF object file according to the command line options.
10492 This file may actually be stored in an archive. The file is
10493 positioned at the start of the ELF object. */
10496 process_object (char *file_name
, FILE *file
)
10500 if (! get_file_header (file
))
10502 error (_("%s: Failed to read file header\n"), file_name
);
10506 /* Initialise per file variables. */
10507 for (i
= NUM_ELEM (version_info
); i
--;)
10508 version_info
[i
] = 0;
10510 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10511 dynamic_info
[i
] = 0;
10513 /* Process the file. */
10515 printf (_("\nFile: %s\n"), file_name
);
10517 if (! process_file_header ())
10520 if (! process_section_headers (file
)
10521 || ! process_section_groups (file
))
10523 /* Without loaded section headers and section groups we
10524 cannot process lots of things. */
10525 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10527 if (! do_using_dynamic
)
10528 do_syms
= do_reloc
= 0;
10531 if (process_program_headers (file
))
10532 process_dynamic_segment (file
);
10534 process_relocs (file
);
10536 process_unwind (file
);
10538 process_symbol_table (file
);
10540 process_syminfo (file
);
10542 process_version_sections (file
);
10544 process_section_contents (file
);
10546 process_corefile_contents (file
);
10548 process_gnu_liblist (file
);
10550 process_arch_specific (file
);
10552 if (program_headers
)
10554 free (program_headers
);
10555 program_headers
= NULL
;
10558 if (section_headers
)
10560 free (section_headers
);
10561 section_headers
= NULL
;
10566 free (string_table
);
10567 string_table
= NULL
;
10568 string_table_length
= 0;
10571 if (dynamic_strings
)
10573 free (dynamic_strings
);
10574 dynamic_strings
= NULL
;
10577 if (dynamic_symbols
)
10579 free (dynamic_symbols
);
10580 dynamic_symbols
= NULL
;
10581 num_dynamic_syms
= 0;
10584 if (dynamic_syminfo
)
10586 free (dynamic_syminfo
);
10587 dynamic_syminfo
= NULL
;
10590 if (section_headers_groups
)
10592 free (section_headers_groups
);
10593 section_headers_groups
= NULL
;
10596 if (section_groups
)
10598 struct group_list
*g
, *next
;
10600 for (i
= 0; i
< group_count
; i
++)
10602 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10609 free (section_groups
);
10610 section_groups
= NULL
;
10616 /* Process an ELF archive. The file is positioned just after the
10620 process_archive (char *file_name
, FILE *file
)
10622 struct ar_hdr arhdr
;
10624 unsigned long size
;
10625 char *longnames
= NULL
;
10626 unsigned long longnames_size
= 0;
10627 size_t file_name_size
;
10632 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10633 if (got
!= sizeof arhdr
)
10638 error (_("%s: failed to read archive header\n"), file_name
);
10642 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
10644 /* This is the archive symbol table. Skip it.
10645 FIXME: We should have an option to dump it. */
10646 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10647 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
10649 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10653 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10654 if (got
!= sizeof arhdr
)
10659 error (_("%s: failed to read archive header\n"), file_name
);
10664 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
10666 /* This is the archive string table holding long member
10669 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10671 longnames
= malloc (longnames_size
);
10672 if (longnames
== NULL
)
10674 error (_("Out of memory\n"));
10678 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10681 error(_("%s: failed to read string table\n"), file_name
);
10685 if ((longnames_size
& 1) != 0)
10688 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10689 if (got
!= sizeof arhdr
)
10696 error (_("%s: failed to read archive header\n"), file_name
);
10701 file_name_size
= strlen (file_name
);
10710 if (arhdr
.ar_name
[0] == '/')
10714 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10715 if (off
>= longnames_size
)
10717 error (_("%s: invalid archive string table offset %lu\n"), off
);
10722 name
= longnames
+ off
;
10723 nameend
= memchr (name
, '/', longnames_size
- off
);
10727 name
= arhdr
.ar_name
;
10728 nameend
= memchr (name
, '/', 16);
10731 if (nameend
== NULL
)
10733 error (_("%s: bad archive file name\n"));
10738 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10739 if (namealc
== NULL
)
10741 error (_("Out of memory\n"));
10746 memcpy (namealc
, file_name
, file_name_size
);
10747 namealc
[file_name_size
] = '(';
10748 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10749 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10750 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10752 archive_file_offset
= ftell (file
);
10753 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10755 ret
|= process_object (namealc
, file
);
10760 (archive_file_offset
10761 + archive_file_size
10762 + (archive_file_size
& 1)),
10765 error (_("%s: failed to seek to next archive header\n"), file_name
);
10770 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10771 if (got
!= sizeof arhdr
)
10776 error (_("%s: failed to read archive header\n"), file_name
);
10782 if (longnames
!= 0)
10789 process_file (char *file_name
)
10792 struct stat statbuf
;
10793 char armag
[SARMAG
];
10796 if (stat (file_name
, &statbuf
) < 0)
10798 if (errno
== ENOENT
)
10799 error (_("'%s': No such file\n"), file_name
);
10801 error (_("Could not locate '%s'. System error message: %s\n"),
10802 file_name
, strerror (errno
));
10806 if (! S_ISREG (statbuf
.st_mode
))
10808 error (_("'%s' is not an ordinary file\n"), file_name
);
10812 file
= fopen (file_name
, "rb");
10815 error (_("Input file '%s' is not readable.\n"), file_name
);
10819 if (fread (armag
, SARMAG
, 1, file
) != 1)
10821 error (_("%s: Failed to read file header\n"), file_name
);
10826 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10827 ret
= process_archive (file_name
, file
);
10831 archive_file_size
= archive_file_offset
= 0;
10832 ret
= process_object (file_name
, file
);
10840 #ifdef SUPPORT_DISASSEMBLY
10841 /* Needed by the i386 disassembler. For extra credit, someone could
10842 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10846 print_address (unsigned int addr
, FILE *outfile
)
10848 fprintf (outfile
,"0x%8.8x", addr
);
10851 /* Needed by the i386 disassembler. */
10853 db_task_printsym (unsigned int addr
)
10855 print_address (addr
, stderr
);
10860 main (int argc
, char **argv
)
10863 char *cmdline_dump_sects
= NULL
;
10864 unsigned num_cmdline_dump_sects
= 0;
10866 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10867 setlocale (LC_MESSAGES
, "");
10869 #if defined (HAVE_SETLOCALE)
10870 setlocale (LC_CTYPE
, "");
10872 bindtextdomain (PACKAGE
, LOCALEDIR
);
10873 textdomain (PACKAGE
);
10875 parse_args (argc
, argv
);
10877 if (optind
< (argc
- 1))
10880 /* When processing more than one file remember the dump requests
10881 issued on command line to reset them after each file. */
10882 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
10884 cmdline_dump_sects
= malloc (num_dump_sects
);
10885 if (cmdline_dump_sects
== NULL
)
10886 error (_("Out of memory allocating dump request table."));
10889 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
10890 num_cmdline_dump_sects
= num_dump_sects
;
10895 while (optind
< argc
)
10897 err
|= process_file (argv
[optind
++]);
10899 /* Reset dump requests. */
10900 if (optind
< argc
&& dump_sects
!= NULL
)
10902 num_dump_sects
= num_cmdline_dump_sects
;
10903 if (num_cmdline_dump_sects
> 0)
10904 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
10908 if (dump_sects
!= NULL
)
10910 if (cmdline_dump_sects
!= NULL
)
10911 free (cmdline_dump_sects
);