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
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we believe that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
52 #include "elf/alpha.h"
72 #include "elf/m68hc11.h"
73 #include "elf/mcore.h"
76 #include "elf/mn10200.h"
77 #include "elf/mn10300.h"
78 #include "elf/msp430.h"
82 #include "elf/ppc64.h"
85 #include "elf/sparc.h"
88 #include "elf/x86-64.h"
89 #include "elf/xstormy16.h"
90 #include "elf/iq2000.h"
91 #include "elf/xtensa.h"
97 #include "libiberty.h"
99 char *program_name
= "readelf";
100 long archive_file_offset
;
101 unsigned long archive_file_size
;
102 unsigned long dynamic_addr
;
103 bfd_size_type dynamic_size
;
104 char *dynamic_strings
;
106 unsigned long string_table_length
;
107 unsigned long num_dynamic_syms
;
108 Elf_Internal_Sym
*dynamic_symbols
;
109 Elf_Internal_Syminfo
*dynamic_syminfo
;
110 unsigned long dynamic_syminfo_offset
;
111 unsigned int dynamic_syminfo_nent
;
112 char program_interpreter
[64];
113 bfd_vma dynamic_info
[DT_JMPREL
+ 1];
114 bfd_vma version_info
[16];
115 Elf_Internal_Ehdr elf_header
;
116 Elf_Internal_Shdr
*section_headers
;
117 Elf_Internal_Phdr
*program_headers
;
118 Elf_Internal_Dyn
*dynamic_segment
;
119 Elf_Internal_Shdr
*symtab_shndx_hdr
;
127 int do_using_dynamic
;
135 int do_debug_abbrevs
;
137 int do_debug_pubnames
;
138 int do_debug_aranges
;
140 int do_debug_frames_interp
;
141 int do_debug_macinfo
;
148 /* A dynamic array of flags indicating which sections require dumping. */
149 char *dump_sects
= NULL
;
150 unsigned int num_dump_sects
= 0;
152 #define HEX_DUMP (1 << 0)
153 #define DISASS_DUMP (1 << 1)
154 #define DEBUG_DUMP (1 << 2)
156 /* How to rpint a vma value. */
157 typedef enum print_mode
169 static bfd_vma (*byte_get
) (unsigned char *, int);
170 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
172 typedef int Elf32_Word
;
176 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
177 ((X)->sh_name >= string_table_length \
178 ? "<corrupt>" : string_table + (X)->sh_name))
180 /* Given st_shndx I, map to section_headers index. */
181 #define SECTION_HEADER_INDEX(I) \
182 ((I) < SHN_LORESERVE \
184 : ((I) <= SHN_HIRESERVE \
186 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
188 /* Reverse of the above. */
189 #define SECTION_HEADER_NUM(N) \
190 ((N) < SHN_LORESERVE \
192 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
194 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
196 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
198 #define BYTE_GET(field) byte_get (field, sizeof (field))
200 /* If we can support a 64 bit data type then BFD64 should be defined
201 and sizeof (bfd_vma) == 8. In this case when translating from an
202 external 8 byte field to an internal field, we can assume that the
203 internal field is also 8 bytes wide and so we can extract all the data.
204 If, however, BFD64 is not defined, then we must assume that the
205 internal data structure only has 4 byte wide fields that are the
206 equivalent of the 8 byte wide external counterparts, and so we must
207 truncate the data. */
209 #define BYTE_GET8(field) byte_get (field, -8)
211 #define BYTE_GET8(field) byte_get (field, 8)
214 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
216 #define GET_ELF_SYMBOLS(file, section) \
217 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
218 : get_64bit_elf_symbols (file, section))
222 error (const char *message
, ...)
226 va_start (args
, message
);
227 fprintf (stderr
, _("%s: Error: "), program_name
);
228 vfprintf (stderr
, message
, args
);
233 warn (const char *message
, ...)
237 va_start (args
, message
);
238 fprintf (stderr
, _("%s: Warning: "), program_name
);
239 vfprintf (stderr
, message
, args
);
244 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
251 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
253 error (_("Unable to seek to 0x%x for %s\n"),
254 archive_file_offset
+ offset
, reason
);
261 mvar
= malloc (size
);
265 error (_("Out of memory allocating 0x%x bytes for %s\n"),
271 if (fread (mvar
, size
, 1, file
) != 1)
273 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
283 byte_get_little_endian (unsigned char *field
, int size
)
291 return ((unsigned int) (field
[0]))
292 | (((unsigned int) (field
[1])) << 8);
296 /* We want to extract data from an 8 byte wide field and
297 place it into a 4 byte wide field. Since this is a little
298 endian source we can just use the 4 byte extraction code. */
302 return ((unsigned long) (field
[0]))
303 | (((unsigned long) (field
[1])) << 8)
304 | (((unsigned long) (field
[2])) << 16)
305 | (((unsigned long) (field
[3])) << 24);
310 /* This is a special case, generated by the BYTE_GET8 macro.
311 It means that we are loading an 8 byte value from a field
312 in an external structure into an 8 byte value in a field
313 in an internal strcuture. */
314 return ((bfd_vma
) (field
[0]))
315 | (((bfd_vma
) (field
[1])) << 8)
316 | (((bfd_vma
) (field
[2])) << 16)
317 | (((bfd_vma
) (field
[3])) << 24)
318 | (((bfd_vma
) (field
[4])) << 32)
319 | (((bfd_vma
) (field
[5])) << 40)
320 | (((bfd_vma
) (field
[6])) << 48)
321 | (((bfd_vma
) (field
[7])) << 56);
324 error (_("Unhandled data length: %d\n"), size
);
330 byte_get_signed (unsigned char *field
, int size
)
332 bfd_vma x
= byte_get (field
, size
);
337 return (x
^ 0x80) - 0x80;
339 return (x
^ 0x8000) - 0x8000;
341 return (x
^ 0x80000000) - 0x80000000;
351 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
356 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
357 field
[6] = ((value
>> 24) >> 24) & 0xff;
358 field
[5] = ((value
>> 24) >> 16) & 0xff;
359 field
[4] = ((value
>> 24) >> 8) & 0xff;
362 field
[3] = (value
>> 24) & 0xff;
363 field
[2] = (value
>> 16) & 0xff;
366 field
[1] = (value
>> 8) & 0xff;
369 field
[0] = value
& 0xff;
373 error (_("Unhandled data length: %d\n"), size
);
378 /* Print a VMA value. */
380 print_vma (bfd_vma vma
, print_mode mode
)
392 printf ("%8.8lx", (unsigned long) vma
);
398 printf ("%5ld", (long) vma
);
406 printf ("%lx", (unsigned long) vma
);
410 printf ("%ld", (unsigned long) vma
);
414 printf ("%lu", (unsigned long) vma
);
436 #if BFD_HOST_64BIT_LONG
439 if (_bfd_int64_high (vma
))
440 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
442 printf ("%lx", _bfd_int64_low (vma
));
447 #if BFD_HOST_64BIT_LONG
450 if (_bfd_int64_high (vma
))
452 printf ("++%ld", _bfd_int64_low (vma
));
454 printf ("%ld", _bfd_int64_low (vma
));
459 #if BFD_HOST_64BIT_LONG
461 printf ("%5ld", vma
);
463 printf ("%#lx", vma
);
465 if (_bfd_int64_high (vma
))
467 printf ("++%ld", _bfd_int64_low (vma
));
468 else if (vma
<= 99999)
469 printf ("%5ld", _bfd_int64_low (vma
));
471 printf ("%#lx", _bfd_int64_low (vma
));
476 #if BFD_HOST_64BIT_LONG
479 if (_bfd_int64_high (vma
))
481 printf ("++%lu", _bfd_int64_low (vma
));
483 printf ("%lu", _bfd_int64_low (vma
));
491 /* Display a symbol on stdout. If do_wide is not true then
492 format the symbol to be at most WIDTH characters,
493 truncating as necessary. If WIDTH is negative then
494 format the string to be exactly - WIDTH characters,
495 truncating or padding as necessary. */
498 print_symbol (int width
, const char *symbol
)
501 printf ("%s", symbol
);
503 printf ("%-*.*s", width
, width
, symbol
);
505 printf ("%-.*s", width
, symbol
);
509 byte_get_big_endian (unsigned char *field
, int size
)
517 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
520 return ((unsigned long) (field
[3]))
521 | (((unsigned long) (field
[2])) << 8)
522 | (((unsigned long) (field
[1])) << 16)
523 | (((unsigned long) (field
[0])) << 24);
527 /* Although we are extracing data from an 8 byte wide field, we
528 are returning only 4 bytes of data. */
529 return ((unsigned long) (field
[7]))
530 | (((unsigned long) (field
[6])) << 8)
531 | (((unsigned long) (field
[5])) << 16)
532 | (((unsigned long) (field
[4])) << 24);
536 /* This is a special case, generated by the BYTE_GET8 macro.
537 It means that we are loading an 8 byte value from a field
538 in an external structure into an 8 byte value in a field
539 in an internal strcuture. */
540 return ((bfd_vma
) (field
[7]))
541 | (((bfd_vma
) (field
[6])) << 8)
542 | (((bfd_vma
) (field
[5])) << 16)
543 | (((bfd_vma
) (field
[4])) << 24)
544 | (((bfd_vma
) (field
[3])) << 32)
545 | (((bfd_vma
) (field
[2])) << 40)
546 | (((bfd_vma
) (field
[1])) << 48)
547 | (((bfd_vma
) (field
[0])) << 56);
551 error (_("Unhandled data length: %d\n"), size
);
557 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
562 field
[7] = value
& 0xff;
563 field
[6] = (value
>> 8) & 0xff;
564 field
[5] = (value
>> 16) & 0xff;
565 field
[4] = (value
>> 24) & 0xff;
570 field
[3] = value
& 0xff;
571 field
[2] = (value
>> 8) & 0xff;
575 field
[1] = value
& 0xff;
579 field
[0] = value
& 0xff;
583 error (_("Unhandled data length: %d\n"), size
);
588 /* Guess the relocation size commonly used by the specific machines. */
591 guess_is_rela (unsigned long e_machine
)
595 /* Targets that use REL relocations. */
611 /* Targets that use RELA relocations. */
626 case EM_CYGNUS_MN10200
:
628 case EM_CYGNUS_MN10300
:
673 warn (_("Don't know about relocations on this machine architecture\n"));
679 slurp_rela_relocs (FILE *file
,
680 unsigned long rel_offset
,
681 unsigned long rel_size
,
682 Elf_Internal_Rela
**relasp
,
683 unsigned long *nrelasp
)
685 Elf_Internal_Rela
*relas
;
686 unsigned long nrelas
;
691 Elf32_External_Rela
*erelas
;
693 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
697 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
699 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
703 error(_("out of memory parsing relocs"));
707 for (i
= 0; i
< nrelas
; i
++)
709 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
710 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
711 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
718 Elf64_External_Rela
*erelas
;
720 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
724 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
726 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
730 error(_("out of memory parsing relocs"));
734 for (i
= 0; i
< nrelas
; i
++)
736 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
737 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
738 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
749 slurp_rel_relocs (FILE *file
,
750 unsigned long rel_offset
,
751 unsigned long rel_size
,
752 Elf_Internal_Rela
**relsp
,
753 unsigned long *nrelsp
)
755 Elf_Internal_Rela
*rels
;
761 Elf32_External_Rel
*erels
;
763 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
767 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
769 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
773 error(_("out of memory parsing relocs"));
777 for (i
= 0; i
< nrels
; i
++)
779 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
780 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
781 rels
[i
].r_addend
= 0;
788 Elf64_External_Rel
*erels
;
790 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
794 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
796 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
800 error(_("out of memory parsing relocs"));
804 for (i
= 0; i
< nrels
; i
++)
806 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
807 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
808 rels
[i
].r_addend
= 0;
818 /* Display the contents of the relocation data found at the specified
822 dump_relocations (FILE *file
,
823 unsigned long rel_offset
,
824 unsigned long rel_size
,
825 Elf_Internal_Sym
*symtab
,
831 Elf_Internal_Rela
*rels
;
834 if (is_rela
== UNKNOWN
)
835 is_rela
= guess_is_rela (elf_header
.e_machine
);
839 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
844 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
853 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
855 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
860 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
862 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
870 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
872 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
877 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
879 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
883 for (i
= 0; i
< rel_size
; i
++)
886 const char *rtype2
= NULL
;
887 const char *rtype3
= NULL
;
890 bfd_vma symtab_index
;
895 offset
= rels
[i
].r_offset
;
896 info
= rels
[i
].r_info
;
900 type
= ELF32_R_TYPE (info
);
901 symtab_index
= ELF32_R_SYM (info
);
905 /* The #ifdef BFD64 below is to prevent a compile time warning.
906 We know that if we do not have a 64 bit data type that we
907 will never execute this code anyway. */
909 if (elf_header
.e_machine
== EM_MIPS
)
911 /* In little-endian objects, r_info isn't really a 64-bit
912 little-endian value: it has a 32-bit little-endian
913 symbol index followed by four individual byte fields.
914 Reorder INFO accordingly. */
915 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
916 info
= (((info
& 0xffffffff) << 32)
917 | ((info
>> 56) & 0xff)
918 | ((info
>> 40) & 0xff00)
919 | ((info
>> 24) & 0xff0000)
920 | ((info
>> 8) & 0xff000000));
921 type
= ELF64_MIPS_R_TYPE (info
);
922 type2
= ELF64_MIPS_R_TYPE2 (info
);
923 type3
= ELF64_MIPS_R_TYPE3 (info
);
925 else if (elf_header
.e_machine
== EM_SPARCV9
)
926 type
= ELF64_R_TYPE_ID (info
);
928 type
= ELF64_R_TYPE (info
);
930 symtab_index
= ELF64_R_SYM (info
);
936 #ifdef _bfd_int64_low
937 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
939 printf ("%8.8lx %8.8lx ", offset
, info
);
944 #ifdef _bfd_int64_low
946 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
947 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
948 _bfd_int64_high (offset
),
949 _bfd_int64_low (offset
),
950 _bfd_int64_high (info
),
951 _bfd_int64_low (info
));
954 ? "%16.16lx %16.16lx "
955 : "%12.12lx %12.12lx ",
960 switch (elf_header
.e_machine
)
968 rtype
= elf_m32r_reloc_type (type
);
973 rtype
= elf_i386_reloc_type (type
);
978 rtype
= elf_m68hc11_reloc_type (type
);
982 rtype
= elf_m68k_reloc_type (type
);
986 rtype
= elf_i960_reloc_type (type
);
991 rtype
= elf_avr_reloc_type (type
);
998 rtype
= elf_sparc_reloc_type (type
);
1002 case EM_CYGNUS_V850
:
1003 rtype
= v850_reloc_type (type
);
1007 case EM_CYGNUS_D10V
:
1008 rtype
= elf_d10v_reloc_type (type
);
1012 case EM_CYGNUS_D30V
:
1013 rtype
= elf_d30v_reloc_type (type
);
1017 rtype
= elf_dlx_reloc_type (type
);
1021 rtype
= elf_sh_reloc_type (type
);
1025 case EM_CYGNUS_MN10300
:
1026 rtype
= elf_mn10300_reloc_type (type
);
1030 case EM_CYGNUS_MN10200
:
1031 rtype
= elf_mn10200_reloc_type (type
);
1035 case EM_CYGNUS_FR30
:
1036 rtype
= elf_fr30_reloc_type (type
);
1040 rtype
= elf_frv_reloc_type (type
);
1044 rtype
= elf_mcore_reloc_type (type
);
1048 rtype
= elf_mmix_reloc_type (type
);
1053 rtype
= elf_msp430_reloc_type (type
);
1057 rtype
= elf_ppc_reloc_type (type
);
1061 rtype
= elf_ppc64_reloc_type (type
);
1065 case EM_MIPS_RS3_LE
:
1066 rtype
= elf_mips_reloc_type (type
);
1069 rtype2
= elf_mips_reloc_type (type2
);
1070 rtype3
= elf_mips_reloc_type (type3
);
1075 rtype
= elf_alpha_reloc_type (type
);
1079 rtype
= elf_arm_reloc_type (type
);
1083 rtype
= elf_arc_reloc_type (type
);
1087 rtype
= elf_hppa_reloc_type (type
);
1093 rtype
= elf_h8_reloc_type (type
);
1098 rtype
= elf_or32_reloc_type (type
);
1103 rtype
= elf_pj_reloc_type (type
);
1106 rtype
= elf_ia64_reloc_type (type
);
1110 rtype
= elf_cris_reloc_type (type
);
1114 rtype
= elf_i860_reloc_type (type
);
1118 rtype
= elf_x86_64_reloc_type (type
);
1122 rtype
= i370_reloc_type (type
);
1127 rtype
= elf_s390_reloc_type (type
);
1131 rtype
= elf_xstormy16_reloc_type (type
);
1135 rtype
= elf_vax_reloc_type (type
);
1140 rtype
= elf_ip2k_reloc_type (type
);
1144 rtype
= elf_iq2000_reloc_type (type
);
1149 rtype
= elf_xtensa_reloc_type (type
);
1154 #ifdef _bfd_int64_low
1155 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1157 printf (_("unrecognized: %-7lx"), type
);
1160 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1164 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1165 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1168 Elf_Internal_Sym
*psym
;
1170 psym
= symtab
+ symtab_index
;
1173 print_vma (psym
->st_value
, LONG_HEX
);
1174 printf (is_32bit_elf
? " " : " ");
1176 if (psym
->st_name
== 0)
1178 const char *sec_name
= "<null>";
1181 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1183 bfd_vma sec_index
= (bfd_vma
) -1;
1185 if (psym
->st_shndx
< SHN_LORESERVE
)
1186 sec_index
= psym
->st_shndx
;
1187 else if (psym
->st_shndx
> SHN_LORESERVE
)
1188 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1191 if (sec_index
!= (bfd_vma
) -1)
1192 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1193 else if (psym
->st_shndx
== SHN_ABS
)
1195 else if (psym
->st_shndx
== SHN_COMMON
)
1196 sec_name
= "COMMON";
1199 sprintf (name_buf
, "<section 0x%x>",
1200 (unsigned int) psym
->st_shndx
);
1201 sec_name
= name_buf
;
1204 print_symbol (22, sec_name
);
1206 else if (strtab
== NULL
)
1207 printf (_("<string table index %3ld>"), psym
->st_name
);
1209 print_symbol (22, strtab
+ psym
->st_name
);
1212 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1217 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1218 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1221 if (elf_header
.e_machine
== EM_SPARCV9
1222 && !strcmp (rtype
, "R_SPARC_OLO10"))
1223 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1227 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1229 printf (" Type2: ");
1232 #ifdef _bfd_int64_low
1233 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1235 printf (_("unrecognized: %-7lx"), type2
);
1238 printf ("%-17.17s", rtype2
);
1240 printf("\n Type3: ");
1243 #ifdef _bfd_int64_low
1244 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1246 printf (_("unrecognized: %-7lx"), type3
);
1249 printf ("%-17.17s", rtype3
);
1261 get_mips_dynamic_type (unsigned long type
)
1265 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1266 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1267 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1268 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1269 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1270 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1271 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1272 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1273 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1274 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1275 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1276 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1277 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1278 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1279 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1280 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1281 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1282 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1283 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1284 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1285 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1286 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1287 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1288 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1289 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1290 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1291 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1292 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1293 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1294 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1295 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1296 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1297 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1298 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1299 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1300 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1301 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1302 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1303 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1304 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1305 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1306 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1307 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1314 get_sparc64_dynamic_type (unsigned long type
)
1318 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1325 get_ppc64_dynamic_type (unsigned long type
)
1329 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1330 case DT_PPC64_OPD
: return "PPC64_OPD";
1331 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1338 get_parisc_dynamic_type (unsigned long type
)
1342 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1343 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1344 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1345 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1346 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1347 case DT_HP_PREINIT
: return "HP_PREINIT";
1348 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1349 case DT_HP_NEEDED
: return "HP_NEEDED";
1350 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1351 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1352 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1353 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1354 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1361 get_ia64_dynamic_type (unsigned long type
)
1365 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1372 get_dynamic_type (unsigned long type
)
1374 static char buff
[32];
1378 case DT_NULL
: return "NULL";
1379 case DT_NEEDED
: return "NEEDED";
1380 case DT_PLTRELSZ
: return "PLTRELSZ";
1381 case DT_PLTGOT
: return "PLTGOT";
1382 case DT_HASH
: return "HASH";
1383 case DT_STRTAB
: return "STRTAB";
1384 case DT_SYMTAB
: return "SYMTAB";
1385 case DT_RELA
: return "RELA";
1386 case DT_RELASZ
: return "RELASZ";
1387 case DT_RELAENT
: return "RELAENT";
1388 case DT_STRSZ
: return "STRSZ";
1389 case DT_SYMENT
: return "SYMENT";
1390 case DT_INIT
: return "INIT";
1391 case DT_FINI
: return "FINI";
1392 case DT_SONAME
: return "SONAME";
1393 case DT_RPATH
: return "RPATH";
1394 case DT_SYMBOLIC
: return "SYMBOLIC";
1395 case DT_REL
: return "REL";
1396 case DT_RELSZ
: return "RELSZ";
1397 case DT_RELENT
: return "RELENT";
1398 case DT_PLTREL
: return "PLTREL";
1399 case DT_DEBUG
: return "DEBUG";
1400 case DT_TEXTREL
: return "TEXTREL";
1401 case DT_JMPREL
: return "JMPREL";
1402 case DT_BIND_NOW
: return "BIND_NOW";
1403 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1404 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1405 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1406 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1407 case DT_RUNPATH
: return "RUNPATH";
1408 case DT_FLAGS
: return "FLAGS";
1410 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1411 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1413 case DT_CHECKSUM
: return "CHECKSUM";
1414 case DT_PLTPADSZ
: return "PLTPADSZ";
1415 case DT_MOVEENT
: return "MOVEENT";
1416 case DT_MOVESZ
: return "MOVESZ";
1417 case DT_FEATURE
: return "FEATURE";
1418 case DT_POSFLAG_1
: return "POSFLAG_1";
1419 case DT_SYMINSZ
: return "SYMINSZ";
1420 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1422 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1423 case DT_CONFIG
: return "CONFIG";
1424 case DT_DEPAUDIT
: return "DEPAUDIT";
1425 case DT_AUDIT
: return "AUDIT";
1426 case DT_PLTPAD
: return "PLTPAD";
1427 case DT_MOVETAB
: return "MOVETAB";
1428 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1430 case DT_VERSYM
: return "VERSYM";
1432 case DT_RELACOUNT
: return "RELACOUNT";
1433 case DT_RELCOUNT
: return "RELCOUNT";
1434 case DT_FLAGS_1
: return "FLAGS_1";
1435 case DT_VERDEF
: return "VERDEF";
1436 case DT_VERDEFNUM
: return "VERDEFNUM";
1437 case DT_VERNEED
: return "VERNEED";
1438 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1440 case DT_AUXILIARY
: return "AUXILIARY";
1441 case DT_USED
: return "USED";
1442 case DT_FILTER
: return "FILTER";
1444 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1445 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1446 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1447 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1448 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1451 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1455 switch (elf_header
.e_machine
)
1458 case EM_MIPS_RS3_LE
:
1459 result
= get_mips_dynamic_type (type
);
1462 result
= get_sparc64_dynamic_type (type
);
1465 result
= get_ppc64_dynamic_type (type
);
1468 result
= get_ia64_dynamic_type (type
);
1478 sprintf (buff
, _("Processor Specific: %lx"), type
);
1480 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1484 switch (elf_header
.e_machine
)
1487 result
= get_parisc_dynamic_type (type
);
1497 sprintf (buff
, _("Operating System specific: %lx"), type
);
1500 sprintf (buff
, _("<unknown>: %lx"), type
);
1507 get_file_type (unsigned e_type
)
1509 static char buff
[32];
1513 case ET_NONE
: return _("NONE (None)");
1514 case ET_REL
: return _("REL (Relocatable file)");
1515 case ET_EXEC
: return _("EXEC (Executable file)");
1516 case ET_DYN
: return _("DYN (Shared object file)");
1517 case ET_CORE
: return _("CORE (Core file)");
1520 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1521 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1522 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1523 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1525 sprintf (buff
, _("<unknown>: %x"), e_type
);
1531 get_machine_name (unsigned e_machine
)
1533 static char buff
[64]; /* XXX */
1537 case EM_NONE
: return _("None");
1538 case EM_M32
: return "WE32100";
1539 case EM_SPARC
: return "Sparc";
1540 case EM_386
: return "Intel 80386";
1541 case EM_68K
: return "MC68000";
1542 case EM_88K
: return "MC88000";
1543 case EM_486
: return "Intel 80486";
1544 case EM_860
: return "Intel 80860";
1545 case EM_MIPS
: return "MIPS R3000";
1546 case EM_S370
: return "IBM System/370";
1547 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1548 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1549 case EM_PARISC
: return "HPPA";
1550 case EM_PPC_OLD
: return "Power PC (old)";
1551 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1552 case EM_960
: return "Intel 90860";
1553 case EM_PPC
: return "PowerPC";
1554 case EM_PPC64
: return "PowerPC64";
1555 case EM_V800
: return "NEC V800";
1556 case EM_FR20
: return "Fujitsu FR20";
1557 case EM_RH32
: return "TRW RH32";
1558 case EM_MCORE
: return "MCORE";
1559 case EM_ARM
: return "ARM";
1560 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1561 case EM_SH
: return "Renesas / SuperH SH";
1562 case EM_SPARCV9
: return "Sparc v9";
1563 case EM_TRICORE
: return "Siemens Tricore";
1564 case EM_ARC
: return "ARC";
1565 case EM_H8_300
: return "Renesas H8/300";
1566 case EM_H8_300H
: return "Renesas H8/300H";
1567 case EM_H8S
: return "Renesas H8S";
1568 case EM_H8_500
: return "Renesas H8/500";
1569 case EM_IA_64
: return "Intel IA-64";
1570 case EM_MIPS_X
: return "Stanford MIPS-X";
1571 case EM_COLDFIRE
: return "Motorola Coldfire";
1572 case EM_68HC12
: return "Motorola M68HC12";
1573 case EM_ALPHA
: return "Alpha";
1574 case EM_CYGNUS_D10V
:
1575 case EM_D10V
: return "d10v";
1576 case EM_CYGNUS_D30V
:
1577 case EM_D30V
: return "d30v";
1578 case EM_CYGNUS_M32R
:
1579 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1580 case EM_CYGNUS_V850
:
1581 case EM_V850
: return "NEC v850";
1582 case EM_CYGNUS_MN10300
:
1583 case EM_MN10300
: return "mn10300";
1584 case EM_CYGNUS_MN10200
:
1585 case EM_MN10200
: return "mn10200";
1586 case EM_CYGNUS_FR30
:
1587 case EM_FR30
: return "Fujitsu FR30";
1588 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1590 case EM_PJ
: return "picoJava";
1591 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1592 case EM_PCP
: return "Siemens PCP";
1593 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1594 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1595 case EM_STARCORE
: return "Motorola Star*Core processor";
1596 case EM_ME16
: return "Toyota ME16 processor";
1597 case EM_ST100
: return "STMicroelectronics ST100 processor";
1598 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1599 case EM_FX66
: return "Siemens FX66 microcontroller";
1600 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1601 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1602 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1603 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1604 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1605 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1606 case EM_SVX
: return "Silicon Graphics SVx";
1607 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1608 case EM_VAX
: return "Digital VAX";
1610 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1611 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1612 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1613 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1614 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1615 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1616 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1617 case EM_PRISM
: return "Vitesse Prism";
1618 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1620 case EM_S390
: return "IBM S/390";
1621 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1623 case EM_OR32
: return "OpenRISC";
1624 case EM_DLX
: return "OpenDLX";
1626 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1627 case EM_IQ2000
: return "Vitesse IQ2000";
1629 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1631 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1637 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1642 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1643 e_flags
&= ~ EF_ARM_EABIMASK
;
1645 /* Handle "generic" ARM flags. */
1646 if (e_flags
& EF_ARM_RELEXEC
)
1648 strcat (buf
, ", relocatable executable");
1649 e_flags
&= ~ EF_ARM_RELEXEC
;
1652 if (e_flags
& EF_ARM_HASENTRY
)
1654 strcat (buf
, ", has entry point");
1655 e_flags
&= ~ EF_ARM_HASENTRY
;
1658 /* Now handle EABI specific flags. */
1662 strcat (buf
, ", <unrecognized EABI>");
1667 case EF_ARM_EABI_VER1
:
1668 strcat (buf
, ", Version1 EABI");
1673 /* Process flags one bit at a time. */
1674 flag
= e_flags
& - e_flags
;
1679 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1680 strcat (buf
, ", sorted symbol tables");
1690 case EF_ARM_EABI_VER2
:
1691 strcat (buf
, ", Version2 EABI");
1696 /* Process flags one bit at a time. */
1697 flag
= e_flags
& - e_flags
;
1702 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1703 strcat (buf
, ", sorted symbol tables");
1706 case EF_ARM_DYNSYMSUSESEGIDX
:
1707 strcat (buf
, ", dynamic symbols use segment index");
1710 case EF_ARM_MAPSYMSFIRST
:
1711 strcat (buf
, ", mapping symbols precede others");
1721 case EF_ARM_EABI_UNKNOWN
:
1722 strcat (buf
, ", GNU EABI");
1727 /* Process flags one bit at a time. */
1728 flag
= e_flags
& - e_flags
;
1733 case EF_ARM_INTERWORK
:
1734 strcat (buf
, ", interworking enabled");
1737 case EF_ARM_APCS_26
:
1738 strcat (buf
, ", uses APCS/26");
1741 case EF_ARM_APCS_FLOAT
:
1742 strcat (buf
, ", uses APCS/float");
1746 strcat (buf
, ", position independent");
1750 strcat (buf
, ", 8 bit structure alignment");
1753 case EF_ARM_NEW_ABI
:
1754 strcat (buf
, ", uses new ABI");
1757 case EF_ARM_OLD_ABI
:
1758 strcat (buf
, ", uses old ABI");
1761 case EF_ARM_SOFT_FLOAT
:
1762 strcat (buf
, ", software FP");
1765 case EF_ARM_MAVERICK_FLOAT
:
1766 strcat (buf
, ", Maverick FP");
1777 strcat (buf
,", <unknown>");
1781 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1783 static char buf
[1024];
1795 decode_ARM_machine_flags (e_flags
, buf
);
1799 if (e_flags
& EF_CPU32
)
1800 strcat (buf
, ", cpu32");
1801 if (e_flags
& EF_M68000
)
1802 strcat (buf
, ", m68000");
1806 if (e_flags
& EF_PPC_EMB
)
1807 strcat (buf
, ", emb");
1809 if (e_flags
& EF_PPC_RELOCATABLE
)
1810 strcat (buf
, ", relocatable");
1812 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1813 strcat (buf
, ", relocatable-lib");
1817 case EM_CYGNUS_V850
:
1818 switch (e_flags
& EF_V850_ARCH
)
1821 strcat (buf
, ", v850e1");
1824 strcat (buf
, ", v850e");
1827 strcat (buf
, ", v850");
1830 strcat (buf
, ", unknown v850 architecture variant");
1836 case EM_CYGNUS_M32R
:
1837 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1838 strcat (buf
, ", m32r");
1843 case EM_MIPS_RS3_LE
:
1844 if (e_flags
& EF_MIPS_NOREORDER
)
1845 strcat (buf
, ", noreorder");
1847 if (e_flags
& EF_MIPS_PIC
)
1848 strcat (buf
, ", pic");
1850 if (e_flags
& EF_MIPS_CPIC
)
1851 strcat (buf
, ", cpic");
1853 if (e_flags
& EF_MIPS_UCODE
)
1854 strcat (buf
, ", ugen_reserved");
1856 if (e_flags
& EF_MIPS_ABI2
)
1857 strcat (buf
, ", abi2");
1859 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1860 strcat (buf
, ", odk first");
1862 if (e_flags
& EF_MIPS_32BITMODE
)
1863 strcat (buf
, ", 32bitmode");
1865 switch ((e_flags
& EF_MIPS_MACH
))
1867 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1868 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1869 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1870 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1871 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1872 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1873 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1874 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1875 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1877 /* We simply ignore the field in this case to avoid confusion:
1878 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1881 default: strcat (buf
, ", unknown CPU"); break;
1884 switch ((e_flags
& EF_MIPS_ABI
))
1886 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
1887 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
1888 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
1889 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
1891 /* We simply ignore the field in this case to avoid confusion:
1892 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
1893 This means it is likely to be an o32 file, but not for
1896 default: strcat (buf
, ", unknown ABI"); break;
1899 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
1900 strcat (buf
, ", mdmx");
1902 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
1903 strcat (buf
, ", mips16");
1905 switch ((e_flags
& EF_MIPS_ARCH
))
1907 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
1908 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
1909 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
1910 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
1911 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
1912 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
1913 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
1914 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
1915 default: strcat (buf
, ", unknown ISA"); break;
1921 if (e_flags
& EF_SPARC_32PLUS
)
1922 strcat (buf
, ", v8+");
1924 if (e_flags
& EF_SPARC_SUN_US1
)
1925 strcat (buf
, ", ultrasparcI");
1927 if (e_flags
& EF_SPARC_SUN_US3
)
1928 strcat (buf
, ", ultrasparcIII");
1930 if (e_flags
& EF_SPARC_HAL_R1
)
1931 strcat (buf
, ", halr1");
1933 if (e_flags
& EF_SPARC_LEDATA
)
1934 strcat (buf
, ", ledata");
1936 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1937 strcat (buf
, ", tso");
1939 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1940 strcat (buf
, ", pso");
1942 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1943 strcat (buf
, ", rmo");
1947 switch (e_flags
& EF_PARISC_ARCH
)
1949 case EFA_PARISC_1_0
:
1950 strcpy (buf
, ", PA-RISC 1.0");
1952 case EFA_PARISC_1_1
:
1953 strcpy (buf
, ", PA-RISC 1.1");
1955 case EFA_PARISC_2_0
:
1956 strcpy (buf
, ", PA-RISC 2.0");
1961 if (e_flags
& EF_PARISC_TRAPNIL
)
1962 strcat (buf
, ", trapnil");
1963 if (e_flags
& EF_PARISC_EXT
)
1964 strcat (buf
, ", ext");
1965 if (e_flags
& EF_PARISC_LSB
)
1966 strcat (buf
, ", lsb");
1967 if (e_flags
& EF_PARISC_WIDE
)
1968 strcat (buf
, ", wide");
1969 if (e_flags
& EF_PARISC_NO_KABP
)
1970 strcat (buf
, ", no kabp");
1971 if (e_flags
& EF_PARISC_LAZYSWAP
)
1972 strcat (buf
, ", lazyswap");
1977 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1978 strcat (buf
, ", new calling convention");
1980 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1981 strcat (buf
, ", gnu calling convention");
1985 if ((e_flags
& EF_IA_64_ABI64
))
1986 strcat (buf
, ", 64-bit");
1988 strcat (buf
, ", 32-bit");
1989 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1990 strcat (buf
, ", reduced fp model");
1991 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1992 strcat (buf
, ", no function descriptors, constant gp");
1993 else if ((e_flags
& EF_IA_64_CONS_GP
))
1994 strcat (buf
, ", constant gp");
1995 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1996 strcat (buf
, ", absolute");
2000 if ((e_flags
& EF_VAX_NONPIC
))
2001 strcat (buf
, ", non-PIC");
2002 if ((e_flags
& EF_VAX_DFLOAT
))
2003 strcat (buf
, ", D-Float");
2004 if ((e_flags
& EF_VAX_GFLOAT
))
2005 strcat (buf
, ", G-Float");
2014 get_osabi_name (unsigned int osabi
)
2016 static char buff
[32];
2020 case ELFOSABI_NONE
: return "UNIX - System V";
2021 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2022 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2023 case ELFOSABI_LINUX
: return "UNIX - Linux";
2024 case ELFOSABI_HURD
: return "GNU/Hurd";
2025 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2026 case ELFOSABI_AIX
: return "UNIX - AIX";
2027 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2028 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2029 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2030 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2031 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2032 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2033 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2034 case ELFOSABI_AROS
: return "Amiga Research OS";
2035 case ELFOSABI_STANDALONE
: return _("Standalone App");
2036 case ELFOSABI_ARM
: return "ARM";
2038 sprintf (buff
, _("<unknown: %x>"), osabi
);
2044 get_mips_segment_type (unsigned long type
)
2048 case PT_MIPS_REGINFO
:
2050 case PT_MIPS_RTPROC
:
2052 case PT_MIPS_OPTIONS
:
2062 get_parisc_segment_type (unsigned long type
)
2066 case PT_HP_TLS
: return "HP_TLS";
2067 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2068 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2069 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2070 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2071 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2072 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2073 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2074 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2075 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2076 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2077 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2078 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2079 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2088 get_ia64_segment_type (unsigned long type
)
2092 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2093 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2094 case PT_HP_TLS
: return "HP_TLS";
2095 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2096 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2097 case PT_IA_64_HP_STACK
: return "HP_STACK";
2106 get_segment_type (unsigned long p_type
)
2108 static char buff
[32];
2112 case PT_NULL
: return "NULL";
2113 case PT_LOAD
: return "LOAD";
2114 case PT_DYNAMIC
: return "DYNAMIC";
2115 case PT_INTERP
: return "INTERP";
2116 case PT_NOTE
: return "NOTE";
2117 case PT_SHLIB
: return "SHLIB";
2118 case PT_PHDR
: return "PHDR";
2119 case PT_TLS
: return "TLS";
2121 case PT_GNU_EH_FRAME
:
2122 return "GNU_EH_FRAME";
2123 case PT_GNU_STACK
: return "STACK";
2126 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2130 switch (elf_header
.e_machine
)
2133 case EM_MIPS_RS3_LE
:
2134 result
= get_mips_segment_type (p_type
);
2137 result
= get_parisc_segment_type (p_type
);
2140 result
= get_ia64_segment_type (p_type
);
2150 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2152 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2156 switch (elf_header
.e_machine
)
2159 result
= get_parisc_segment_type (p_type
);
2162 result
= get_ia64_segment_type (p_type
);
2172 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2175 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2182 get_mips_section_type_name (unsigned int sh_type
)
2186 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2187 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2188 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2189 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2190 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2191 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2192 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2193 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2194 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2195 case SHT_MIPS_RELD
: return "MIPS_RELD";
2196 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2197 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2198 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2199 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2200 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2201 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2202 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2203 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2204 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2205 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2206 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2207 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2208 case SHT_MIPS_LINE
: return "MIPS_LINE";
2209 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2210 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2211 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2212 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2213 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2214 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2215 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2216 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2217 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2218 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2219 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2220 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2221 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2222 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2223 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2224 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2232 get_parisc_section_type_name (unsigned int sh_type
)
2236 case SHT_PARISC_EXT
: return "PARISC_EXT";
2237 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2238 case SHT_PARISC_DOC
: return "PARISC_DOC";
2246 get_ia64_section_type_name (unsigned int sh_type
)
2248 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2249 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2250 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2254 case SHT_IA_64_EXT
: return "IA_64_EXT";
2255 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2256 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2264 get_section_type_name (unsigned int sh_type
)
2266 static char buff
[32];
2270 case SHT_NULL
: return "NULL";
2271 case SHT_PROGBITS
: return "PROGBITS";
2272 case SHT_SYMTAB
: return "SYMTAB";
2273 case SHT_STRTAB
: return "STRTAB";
2274 case SHT_RELA
: return "RELA";
2275 case SHT_HASH
: return "HASH";
2276 case SHT_DYNAMIC
: return "DYNAMIC";
2277 case SHT_NOTE
: return "NOTE";
2278 case SHT_NOBITS
: return "NOBITS";
2279 case SHT_REL
: return "REL";
2280 case SHT_SHLIB
: return "SHLIB";
2281 case SHT_DYNSYM
: return "DYNSYM";
2282 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2283 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2284 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2285 case SHT_GROUP
: return "GROUP";
2286 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2287 case SHT_GNU_verdef
: return "VERDEF";
2288 case SHT_GNU_verneed
: return "VERNEED";
2289 case SHT_GNU_versym
: return "VERSYM";
2290 case 0x6ffffff0: return "VERSYM";
2291 case 0x6ffffffc: return "VERDEF";
2292 case 0x7ffffffd: return "AUXILIARY";
2293 case 0x7fffffff: return "FILTER";
2294 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2297 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2301 switch (elf_header
.e_machine
)
2304 case EM_MIPS_RS3_LE
:
2305 result
= get_mips_section_type_name (sh_type
);
2308 result
= get_parisc_section_type_name (sh_type
);
2311 result
= get_ia64_section_type_name (sh_type
);
2321 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2323 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2324 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2325 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2326 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2328 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2334 #define OPTION_DEBUG_DUMP 512
2336 struct option options
[] =
2338 {"all", no_argument
, 0, 'a'},
2339 {"file-header", no_argument
, 0, 'h'},
2340 {"program-headers", no_argument
, 0, 'l'},
2341 {"headers", no_argument
, 0, 'e'},
2342 {"histogram", no_argument
, 0, 'I'},
2343 {"segments", no_argument
, 0, 'l'},
2344 {"sections", no_argument
, 0, 'S'},
2345 {"section-headers", no_argument
, 0, 'S'},
2346 {"symbols", no_argument
, 0, 's'},
2347 {"syms", no_argument
, 0, 's'},
2348 {"relocs", no_argument
, 0, 'r'},
2349 {"notes", no_argument
, 0, 'n'},
2350 {"dynamic", no_argument
, 0, 'd'},
2351 {"arch-specific", no_argument
, 0, 'A'},
2352 {"version-info", no_argument
, 0, 'V'},
2353 {"use-dynamic", no_argument
, 0, 'D'},
2354 {"hex-dump", required_argument
, 0, 'x'},
2355 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2356 {"unwind", no_argument
, 0, 'u'},
2357 #ifdef SUPPORT_DISASSEMBLY
2358 {"instruction-dump", required_argument
, 0, 'i'},
2361 {"version", no_argument
, 0, 'v'},
2362 {"wide", no_argument
, 0, 'W'},
2363 {"help", no_argument
, 0, 'H'},
2364 {0, no_argument
, 0, 0}
2370 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2371 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2372 fprintf (stdout
, _(" Options are:\n\
2373 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2374 -h --file-header Display the ELF file header\n\
2375 -l --program-headers Display the program headers\n\
2376 --segments An alias for --program-headers\n\
2377 -S --section-headers Display the sections' header\n\
2378 --sections An alias for --section-headers\n\
2379 -e --headers Equivalent to: -h -l -S\n\
2380 -s --syms Display the symbol table\n\
2381 --symbols An alias for --syms\n\
2382 -n --notes Display the core notes (if present)\n\
2383 -r --relocs Display the relocations (if present)\n\
2384 -u --unwind Display the unwind info (if present)\n\
2385 -d --dynamic Display the dynamic segment (if present)\n\
2386 -V --version-info Display the version sections (if present)\n\
2387 -A --arch-specific Display architecture specific information (if any).\n\
2388 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2389 -x --hex-dump=<number> Dump the contents of section <number>\n\
2390 -w[liaprmfFso] or\n\
2391 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2392 Display the contents of DWARF2 debug sections\n"));
2393 #ifdef SUPPORT_DISASSEMBLY
2394 fprintf (stdout
, _("\
2395 -i --instruction-dump=<number>\n\
2396 Disassemble the contents of section <number>\n"));
2398 fprintf (stdout
, _("\
2399 -I --histogram Display histogram of bucket list lengths\n\
2400 -W --wide Allow output width to exceed 80 characters\n\
2401 -H --help Display this information\n\
2402 -v --version Display the version number of readelf\n"));
2403 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2409 request_dump (unsigned int section
, int type
)
2411 if (section
>= num_dump_sects
)
2413 char *new_dump_sects
;
2415 new_dump_sects
= calloc (section
+ 1, 1);
2417 if (new_dump_sects
== NULL
)
2418 error (_("Out of memory allocating dump request table."));
2421 /* Copy current flag settings. */
2422 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2426 dump_sects
= new_dump_sects
;
2427 num_dump_sects
= section
+ 1;
2432 dump_sects
[section
] |= type
;
2438 parse_args (int argc
, char **argv
)
2445 while ((c
= getopt_long
2446 (argc
, argv
, "ersuahnldSDAIw::x:i:vVWH", options
, NULL
)) != EOF
)
2513 section
= strtoul (optarg
, & cp
, 0);
2514 if (! *cp
&& section
>= 0)
2516 request_dump (section
, HEX_DUMP
);
2526 unsigned int index
= 0;
2530 while (optarg
[index
])
2531 switch (optarg
[index
++])
2540 do_debug_abbrevs
= 1;
2550 do_debug_pubnames
= 1;
2555 do_debug_aranges
= 1;
2559 do_debug_frames_interp
= 1;
2561 do_debug_frames
= 1;
2566 do_debug_macinfo
= 1;
2580 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2585 case OPTION_DEBUG_DUMP
:
2591 static const char *debug_dump_opt
[]
2592 = { "line", "info", "abbrev", "pubnames", "ranges",
2593 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2602 for (index
= 0; debug_dump_opt
[index
]; index
++)
2604 size_t len
= strlen (debug_dump_opt
[index
]);
2606 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2607 && (p
[len
] == ',' || p
[len
] == '\0'))
2616 do_debug_abbrevs
= 1;
2627 do_debug_pubnames
= 1;
2631 do_debug_aranges
= 1;
2636 do_debug_frames_interp
= 1;
2637 do_debug_frames
= 1;
2641 do_debug_macinfo
= 1;
2654 if (debug_dump_opt
[index
] == NULL
)
2656 warn (_("Unrecognized debug option '%s'\n"), p
);
2657 p
= strchr (p
, ',');
2667 #ifdef SUPPORT_DISASSEMBLY
2670 section
= strtoul (optarg
, & cp
, 0);
2671 if (! *cp
&& section
>= 0)
2673 request_dump (section
, DISASS_DUMP
);
2679 print_version (program_name
);
2689 /* xgettext:c-format */
2690 error (_("Invalid option '-%c'\n"), c
);
2697 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2698 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2699 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2703 warn (_("Nothing to do.\n"));
2709 get_elf_class (unsigned int elf_class
)
2711 static char buff
[32];
2715 case ELFCLASSNONE
: return _("none");
2716 case ELFCLASS32
: return "ELF32";
2717 case ELFCLASS64
: return "ELF64";
2719 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2725 get_data_encoding (unsigned int encoding
)
2727 static char buff
[32];
2731 case ELFDATANONE
: return _("none");
2732 case ELFDATA2LSB
: return _("2's complement, little endian");
2733 case ELFDATA2MSB
: return _("2's complement, big endian");
2735 sprintf (buff
, _("<unknown: %x>"), encoding
);
2740 /* Decode the data held in 'elf_header'. */
2743 process_file_header (void)
2745 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2746 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2747 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2748 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2751 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2759 printf (_("ELF Header:\n"));
2760 printf (_(" Magic: "));
2761 for (i
= 0; i
< EI_NIDENT
; i
++)
2762 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2764 printf (_(" Class: %s\n"),
2765 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2766 printf (_(" Data: %s\n"),
2767 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2768 printf (_(" Version: %d %s\n"),
2769 elf_header
.e_ident
[EI_VERSION
],
2770 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2772 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2775 printf (_(" OS/ABI: %s\n"),
2776 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2777 printf (_(" ABI Version: %d\n"),
2778 elf_header
.e_ident
[EI_ABIVERSION
]);
2779 printf (_(" Type: %s\n"),
2780 get_file_type (elf_header
.e_type
));
2781 printf (_(" Machine: %s\n"),
2782 get_machine_name (elf_header
.e_machine
));
2783 printf (_(" Version: 0x%lx\n"),
2784 (unsigned long) elf_header
.e_version
);
2786 printf (_(" Entry point address: "));
2787 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2788 printf (_("\n Start of program headers: "));
2789 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2790 printf (_(" (bytes into file)\n Start of section headers: "));
2791 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2792 printf (_(" (bytes into file)\n"));
2794 printf (_(" Flags: 0x%lx%s\n"),
2795 (unsigned long) elf_header
.e_flags
,
2796 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2797 printf (_(" Size of this header: %ld (bytes)\n"),
2798 (long) elf_header
.e_ehsize
);
2799 printf (_(" Size of program headers: %ld (bytes)\n"),
2800 (long) elf_header
.e_phentsize
);
2801 printf (_(" Number of program headers: %ld\n"),
2802 (long) elf_header
.e_phnum
);
2803 printf (_(" Size of section headers: %ld (bytes)\n"),
2804 (long) elf_header
.e_shentsize
);
2805 printf (_(" Number of section headers: %ld"),
2806 (long) elf_header
.e_shnum
);
2807 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2808 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2809 putc ('\n', stdout
);
2810 printf (_(" Section header string table index: %ld"),
2811 (long) elf_header
.e_shstrndx
);
2812 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2813 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2814 putc ('\n', stdout
);
2817 if (section_headers
!= NULL
)
2819 if (elf_header
.e_shnum
== 0)
2820 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2821 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2822 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2823 free (section_headers
);
2824 section_headers
= NULL
;
2832 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
2834 Elf32_External_Phdr
*phdrs
;
2835 Elf32_External_Phdr
*external
;
2836 Elf_Internal_Phdr
*internal
;
2839 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
2840 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2841 _("program headers"));
2845 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2846 i
< elf_header
.e_phnum
;
2847 i
++, internal
++, external
++)
2849 internal
->p_type
= BYTE_GET (external
->p_type
);
2850 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2851 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2852 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2853 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2854 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2855 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2856 internal
->p_align
= BYTE_GET (external
->p_align
);
2865 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
2867 Elf64_External_Phdr
*phdrs
;
2868 Elf64_External_Phdr
*external
;
2869 Elf_Internal_Phdr
*internal
;
2872 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
2873 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2874 _("program headers"));
2878 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2879 i
< elf_header
.e_phnum
;
2880 i
++, internal
++, external
++)
2882 internal
->p_type
= BYTE_GET (external
->p_type
);
2883 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2884 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2885 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2886 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2887 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2888 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2889 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2897 /* Returns 1 if the program headers were read into `program_headers'. */
2900 get_program_headers (FILE *file
)
2902 Elf_Internal_Phdr
*phdrs
;
2904 /* Check cache of prior read. */
2905 if (program_headers
!= NULL
)
2908 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2912 error (_("Out of memory\n"));
2917 ? get_32bit_program_headers (file
, phdrs
)
2918 : get_64bit_program_headers (file
, phdrs
))
2920 program_headers
= phdrs
;
2928 /* Returns 1 if the program headers were loaded. */
2931 process_program_headers (FILE *file
)
2933 Elf_Internal_Phdr
*segment
;
2936 if (elf_header
.e_phnum
== 0)
2939 printf (_("\nThere are no program headers in this file.\n"));
2943 if (do_segments
&& !do_header
)
2945 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2946 printf (_("Entry point "));
2947 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2948 printf (_("\nThere are %d program headers, starting at offset "),
2949 elf_header
.e_phnum
);
2950 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2954 if (! get_program_headers (file
))
2959 if (elf_header
.e_phnum
> 1)
2960 printf (_("\nProgram Headers:\n"));
2962 printf (_("\nProgram Headers:\n"));
2966 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2969 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2973 (_(" Type Offset VirtAddr PhysAddr\n"));
2975 (_(" FileSiz MemSiz Flags Align\n"));
2982 for (i
= 0, segment
= program_headers
;
2983 i
< elf_header
.e_phnum
;
2988 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2992 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2993 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2994 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2995 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2996 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2998 (segment
->p_flags
& PF_R
? 'R' : ' '),
2999 (segment
->p_flags
& PF_W
? 'W' : ' '),
3000 (segment
->p_flags
& PF_X
? 'E' : ' '));
3001 printf ("%#lx", (unsigned long) segment
->p_align
);
3005 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3006 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3009 print_vma (segment
->p_offset
, FULL_HEX
);
3013 print_vma (segment
->p_vaddr
, FULL_HEX
);
3015 print_vma (segment
->p_paddr
, FULL_HEX
);
3018 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3019 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3022 print_vma (segment
->p_filesz
, FULL_HEX
);
3026 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3027 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3030 print_vma (segment
->p_offset
, FULL_HEX
);
3034 (segment
->p_flags
& PF_R
? 'R' : ' '),
3035 (segment
->p_flags
& PF_W
? 'W' : ' '),
3036 (segment
->p_flags
& PF_X
? 'E' : ' '));
3038 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3039 printf ("%#lx", (unsigned long) segment
->p_align
);
3042 print_vma (segment
->p_align
, PREFIX_HEX
);
3047 print_vma (segment
->p_offset
, FULL_HEX
);
3049 print_vma (segment
->p_vaddr
, FULL_HEX
);
3051 print_vma (segment
->p_paddr
, FULL_HEX
);
3053 print_vma (segment
->p_filesz
, FULL_HEX
);
3055 print_vma (segment
->p_memsz
, FULL_HEX
);
3057 (segment
->p_flags
& PF_R
? 'R' : ' '),
3058 (segment
->p_flags
& PF_W
? 'W' : ' '),
3059 (segment
->p_flags
& PF_X
? 'E' : ' '));
3060 print_vma (segment
->p_align
, HEX
);
3064 switch (segment
->p_type
)
3068 error (_("more than one dynamic segment\n"));
3070 dynamic_addr
= segment
->p_offset
;
3071 dynamic_size
= segment
->p_filesz
;
3075 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3077 error (_("Unable to find program interpreter name\n"));
3080 program_interpreter
[0] = 0;
3081 fscanf (file
, "%63s", program_interpreter
);
3084 printf (_("\n [Requesting program interpreter: %s]"),
3085 program_interpreter
);
3091 putc ('\n', stdout
);
3094 if (do_segments
&& section_headers
!= NULL
)
3096 printf (_("\n Section to Segment mapping:\n"));
3097 printf (_(" Segment Sections...\n"));
3099 assert (string_table
!= NULL
);
3101 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3104 Elf_Internal_Shdr
*section
;
3106 segment
= program_headers
+ i
;
3107 section
= section_headers
;
3109 printf (" %2.2d ", i
);
3111 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3113 if (section
->sh_size
> 0
3114 /* Compare allocated sections by VMA, unallocated
3115 sections by file offset. */
3116 && (section
->sh_flags
& SHF_ALLOC
3117 ? (section
->sh_addr
>= segment
->p_vaddr
3118 && section
->sh_addr
+ section
->sh_size
3119 <= segment
->p_vaddr
+ segment
->p_memsz
)
3120 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3121 && (section
->sh_offset
+ section
->sh_size
3122 <= segment
->p_offset
+ segment
->p_filesz
))))
3123 printf ("%s ", SECTION_NAME (section
));
3134 /* Find the file offset corresponding to VMA by using the program headers. */
3137 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3139 Elf_Internal_Phdr
*seg
;
3141 if (! get_program_headers (file
))
3143 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3147 for (seg
= program_headers
;
3148 seg
< program_headers
+ elf_header
.e_phnum
;
3151 if (seg
->p_type
!= PT_LOAD
)
3154 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3155 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3156 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3159 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3166 get_32bit_section_headers (FILE *file
, unsigned int num
)
3168 Elf32_External_Shdr
*shdrs
;
3169 Elf_Internal_Shdr
*internal
;
3172 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3173 elf_header
.e_shentsize
* num
, _("section headers"));
3177 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3179 if (section_headers
== NULL
)
3181 error (_("Out of memory\n"));
3185 for (i
= 0, internal
= section_headers
;
3189 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3190 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3191 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3192 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3193 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3194 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3195 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3196 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3197 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3198 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3207 get_64bit_section_headers (FILE *file
, unsigned int num
)
3209 Elf64_External_Shdr
*shdrs
;
3210 Elf_Internal_Shdr
*internal
;
3213 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3214 elf_header
.e_shentsize
* num
, _("section headers"));
3218 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3220 if (section_headers
== NULL
)
3222 error (_("Out of memory\n"));
3226 for (i
= 0, internal
= section_headers
;
3230 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3231 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3232 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3233 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3234 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3235 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3236 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3237 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3238 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3239 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3247 static Elf_Internal_Sym
*
3248 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3250 unsigned long number
;
3251 Elf32_External_Sym
*esyms
;
3252 Elf_External_Sym_Shndx
*shndx
;
3253 Elf_Internal_Sym
*isyms
;
3254 Elf_Internal_Sym
*psym
;
3257 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3263 if (symtab_shndx_hdr
!= NULL
3264 && (symtab_shndx_hdr
->sh_link
3265 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3267 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3268 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3276 number
= section
->sh_size
/ section
->sh_entsize
;
3277 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3281 error (_("Out of memory\n"));
3288 for (j
= 0, psym
= isyms
;
3292 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3293 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3294 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3295 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3296 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3298 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3299 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3300 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3310 static Elf_Internal_Sym
*
3311 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3313 unsigned long number
;
3314 Elf64_External_Sym
*esyms
;
3315 Elf_External_Sym_Shndx
*shndx
;
3316 Elf_Internal_Sym
*isyms
;
3317 Elf_Internal_Sym
*psym
;
3320 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3326 if (symtab_shndx_hdr
!= NULL
3327 && (symtab_shndx_hdr
->sh_link
3328 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3330 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3331 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3339 number
= section
->sh_size
/ section
->sh_entsize
;
3340 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3344 error (_("Out of memory\n"));
3351 for (j
= 0, psym
= isyms
;
3355 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3356 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3357 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3358 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3359 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3361 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3362 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3363 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3374 get_elf_section_flags (bfd_vma sh_flags
)
3376 static char buff
[32];
3384 flag
= sh_flags
& - sh_flags
;
3389 case SHF_WRITE
: strcat (buff
, "W"); break;
3390 case SHF_ALLOC
: strcat (buff
, "A"); break;
3391 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3392 case SHF_MERGE
: strcat (buff
, "M"); break;
3393 case SHF_STRINGS
: strcat (buff
, "S"); break;
3394 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3395 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3396 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3397 case SHF_GROUP
: strcat (buff
, "G"); break;
3398 case SHF_TLS
: strcat (buff
, "T"); break;
3401 if (flag
& SHF_MASKOS
)
3404 sh_flags
&= ~ SHF_MASKOS
;
3406 else if (flag
& SHF_MASKPROC
)
3409 sh_flags
&= ~ SHF_MASKPROC
;
3421 process_section_headers (FILE *file
)
3423 Elf_Internal_Shdr
*section
;
3426 section_headers
= NULL
;
3428 if (elf_header
.e_shnum
== 0)
3431 printf (_("\nThere are no sections in this file.\n"));
3436 if (do_sections
&& !do_header
)
3437 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3438 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3442 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3445 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3448 /* Read in the string table, so that we have names to display. */
3449 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3451 if (section
->sh_size
!= 0)
3453 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3454 section
->sh_size
, _("string table"));
3456 if (string_table
== NULL
)
3459 string_table_length
= section
->sh_size
;
3462 /* Scan the sections for the dynamic symbol table
3463 and dynamic string table and debug sections. */
3464 dynamic_symbols
= NULL
;
3465 dynamic_strings
= NULL
;
3466 dynamic_syminfo
= NULL
;
3467 symtab_shndx_hdr
= NULL
;
3469 for (i
= 0, section
= section_headers
;
3470 i
< elf_header
.e_shnum
;
3473 char *name
= SECTION_NAME (section
);
3475 if (section
->sh_type
== SHT_DYNSYM
)
3477 if (dynamic_symbols
!= NULL
)
3479 error (_("File contains multiple dynamic symbol tables\n"));
3483 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3484 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3486 else if (section
->sh_type
== SHT_STRTAB
3487 && strcmp (name
, ".dynstr") == 0)
3489 if (dynamic_strings
!= NULL
)
3491 error (_("File contains multiple dynamic string tables\n"));
3495 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3496 section
->sh_size
, _("dynamic strings"));
3498 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3500 if (symtab_shndx_hdr
!= NULL
)
3502 error (_("File contains multiple symtab shndx tables\n"));
3505 symtab_shndx_hdr
= section
;
3507 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3508 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3509 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3511 && strncmp (name
, ".debug_", 7) == 0)
3516 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3517 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3518 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3519 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3520 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3521 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3522 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3523 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3524 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3526 request_dump (i
, DEBUG_DUMP
);
3528 /* linkonce section to be combined with .debug_info at link time. */
3529 else if ((do_debugging
|| do_debug_info
)
3530 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3531 request_dump (i
, DEBUG_DUMP
);
3532 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3533 request_dump (i
, DEBUG_DUMP
);
3539 if (elf_header
.e_shnum
> 1)
3540 printf (_("\nSection Headers:\n"));
3542 printf (_("\nSection Header:\n"));
3546 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3549 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3552 printf (_(" [Nr] Name Type Address Offset\n"));
3553 printf (_(" Size EntSize Flags Link Info Align\n"));
3556 for (i
= 0, section
= section_headers
;
3557 i
< elf_header
.e_shnum
;
3560 printf (" [%2u] %-17.17s %-15.15s ",
3561 SECTION_HEADER_NUM (i
),
3562 SECTION_NAME (section
),
3563 get_section_type_name (section
->sh_type
));
3567 print_vma (section
->sh_addr
, LONG_HEX
);
3569 printf ( " %6.6lx %6.6lx %2.2lx",
3570 (unsigned long) section
->sh_offset
,
3571 (unsigned long) section
->sh_size
,
3572 (unsigned long) section
->sh_entsize
);
3574 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3576 printf ("%2ld %3lx %2ld\n",
3577 (unsigned long) section
->sh_link
,
3578 (unsigned long) section
->sh_info
,
3579 (unsigned long) section
->sh_addralign
);
3583 print_vma (section
->sh_addr
, LONG_HEX
);
3585 if ((long) section
->sh_offset
== section
->sh_offset
)
3586 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3590 print_vma (section
->sh_offset
, LONG_HEX
);
3593 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3594 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3598 print_vma (section
->sh_size
, LONG_HEX
);
3601 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3602 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3606 print_vma (section
->sh_entsize
, LONG_HEX
);
3609 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3611 printf ("%2ld %3lx ",
3612 (unsigned long) section
->sh_link
,
3613 (unsigned long) section
->sh_info
);
3615 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3616 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3619 print_vma (section
->sh_addralign
, DEC
);
3626 print_vma (section
->sh_addr
, LONG_HEX
);
3627 if ((long) section
->sh_offset
== section
->sh_offset
)
3628 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3632 print_vma (section
->sh_offset
, LONG_HEX
);
3635 print_vma (section
->sh_size
, LONG_HEX
);
3637 print_vma (section
->sh_entsize
, LONG_HEX
);
3639 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3641 printf (" %2ld %3lx %ld\n",
3642 (unsigned long) section
->sh_link
,
3643 (unsigned long) section
->sh_info
,
3644 (unsigned long) section
->sh_addralign
);
3648 printf (_("Key to Flags:\n\
3649 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3650 I (info), L (link order), G (group), x (unknown)\n\
3651 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3662 } dynamic_relocations
[] =
3664 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
3665 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
3666 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
3669 /* Process the reloc section. */
3671 process_relocs (FILE *file
)
3673 unsigned long rel_size
;
3674 unsigned long rel_offset
;
3680 if (do_using_dynamic
)
3684 int has_dynamic_reloc
;
3687 has_dynamic_reloc
= 0;
3689 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
3691 is_rela
= dynamic_relocations
[i
].rela
;
3692 name
= dynamic_relocations
[i
].name
;
3693 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
3694 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
3696 has_dynamic_reloc
|= rel_size
;
3698 if (is_rela
== UNKNOWN
)
3700 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
3701 switch (dynamic_info
[DT_PLTREL
])
3715 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
3716 name
, rel_offset
, rel_size
);
3718 dump_relocations (file
,
3719 offset_from_vma (file
, rel_offset
, rel_size
),
3721 dynamic_symbols
, num_dynamic_syms
,
3722 dynamic_strings
, is_rela
);
3726 if (! has_dynamic_reloc
)
3727 printf (_("\nThere are no dynamic relocations in this file.\n"));
3731 Elf_Internal_Shdr
*section
;
3735 for (i
= 0, section
= section_headers
;
3736 i
< elf_header
.e_shnum
;
3739 if ( section
->sh_type
!= SHT_RELA
3740 && section
->sh_type
!= SHT_REL
)
3743 rel_offset
= section
->sh_offset
;
3744 rel_size
= section
->sh_size
;
3748 Elf_Internal_Shdr
*strsec
;
3749 Elf_Internal_Sym
*symtab
;
3752 unsigned long nsyms
;
3754 printf (_("\nRelocation section "));
3756 if (string_table
== NULL
)
3757 printf ("%d", section
->sh_name
);
3759 printf (_("'%s'"), SECTION_NAME (section
));
3761 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3762 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3767 if (section
->sh_link
)
3769 Elf_Internal_Shdr
*symsec
;
3771 symsec
= SECTION_HEADER (section
->sh_link
);
3772 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3773 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
3778 strsec
= SECTION_HEADER (symsec
->sh_link
);
3780 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
3781 strsec
->sh_size
, _("string table"));
3783 is_rela
= section
->sh_type
== SHT_RELA
;
3785 dump_relocations (file
, rel_offset
, rel_size
,
3786 symtab
, nsyms
, strtab
, is_rela
);
3798 printf (_("\nThere are no relocations in this file.\n"));
3804 #include "unwind-ia64.h"
3806 /* An absolute address consists of a section and an offset. If the
3807 section is NULL, the offset itself is the address, otherwise, the
3808 address equals to LOAD_ADDRESS(section) + offset. */
3812 unsigned short section
;
3818 struct unw_table_entry
3820 struct absaddr start
;
3822 struct absaddr info
;
3824 *table
; /* Unwind table. */
3825 unsigned long table_len
; /* Length of unwind table. */
3826 unsigned char *info
; /* Unwind info. */
3827 unsigned long info_size
; /* Size of unwind info. */
3828 bfd_vma info_addr
; /* starting address of unwind info. */
3829 bfd_vma seg_base
; /* Starting address of segment. */
3830 Elf_Internal_Sym
*symtab
; /* The symbol table. */
3831 unsigned long nsyms
; /* Number of symbols. */
3832 char *strtab
; /* The string table. */
3833 unsigned long strtab_size
; /* Size of string table. */
3837 find_symbol_for_address (struct unw_aux_info
*aux
,
3838 struct absaddr addr
,
3839 const char **symname
,
3842 bfd_vma dist
= 0x100000;
3843 Elf_Internal_Sym
*sym
, *best
= NULL
;
3846 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3848 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3849 && sym
->st_name
!= 0
3850 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3851 && addr
.offset
>= sym
->st_value
3852 && addr
.offset
- sym
->st_value
< dist
)
3855 dist
= addr
.offset
- sym
->st_value
;
3862 *symname
= (best
->st_name
>= aux
->strtab_size
3863 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3868 *offset
= addr
.offset
;
3872 dump_ia64_unwind (struct unw_aux_info
*aux
)
3875 struct unw_table_entry
*tp
;
3878 addr_size
= is_32bit_elf
? 4 : 8;
3880 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3884 const unsigned char *dp
;
3885 const unsigned char *head
;
3886 const char *procname
;
3888 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3890 fputs ("\n<", stdout
);
3894 fputs (procname
, stdout
);
3897 printf ("+%lx", (unsigned long) offset
);
3900 fputs (">: [", stdout
);
3901 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3902 fputc ('-', stdout
);
3903 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3904 printf ("], info at +0x%lx\n",
3905 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3907 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3908 stamp
= BYTE_GET8 ((unsigned char *) head
);
3910 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
3911 (unsigned) UNW_VER (stamp
),
3912 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3913 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3914 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3915 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3917 if (UNW_VER (stamp
) != 1)
3919 printf ("\tUnknown version.\n");
3924 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3925 dp
= unw_decode (dp
, in_body
, & in_body
);
3930 slurp_ia64_unwind_table (FILE *file
,
3931 struct unw_aux_info
*aux
,
3932 Elf_Internal_Shdr
*sec
)
3934 unsigned long size
, addr_size
, nrelas
, i
;
3935 Elf_Internal_Phdr
*seg
;
3936 struct unw_table_entry
*tep
;
3937 Elf_Internal_Shdr
*relsec
;
3938 Elf_Internal_Rela
*rela
, *rp
;
3939 unsigned char *table
, *tp
;
3940 Elf_Internal_Sym
*sym
;
3941 const char *relname
;
3943 addr_size
= is_32bit_elf
? 4 : 8;
3945 /* First, find the starting address of the segment that includes
3948 if (elf_header
.e_phnum
)
3950 if (! get_program_headers (file
))
3953 for (seg
= program_headers
;
3954 seg
< program_headers
+ elf_header
.e_phnum
;
3957 if (seg
->p_type
!= PT_LOAD
)
3960 if (sec
->sh_addr
>= seg
->p_vaddr
3961 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3963 aux
->seg_base
= seg
->p_vaddr
;
3969 /* Second, build the unwind table from the contents of the unwind section: */
3970 size
= sec
->sh_size
;
3971 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
3975 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3976 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
3978 tep
->start
.section
= SHN_UNDEF
;
3979 tep
->end
.section
= SHN_UNDEF
;
3980 tep
->info
.section
= SHN_UNDEF
;
3983 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3984 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3985 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3989 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3990 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3991 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3993 tep
->start
.offset
+= aux
->seg_base
;
3994 tep
->end
.offset
+= aux
->seg_base
;
3995 tep
->info
.offset
+= aux
->seg_base
;
3999 /* Third, apply any relocations to the unwind table: */
4001 for (relsec
= section_headers
;
4002 relsec
< section_headers
+ elf_header
.e_shnum
;
4005 if (relsec
->sh_type
!= SHT_RELA
4006 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4009 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4013 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4017 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4018 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4020 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4022 warn (_("Skipping unexpected symbol type %u\n"),
4023 ELF32_ST_TYPE (sym
->st_info
));
4029 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4030 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4032 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4034 warn (_("Skipping unexpected symbol type %u\n"),
4035 ELF64_ST_TYPE (sym
->st_info
));
4040 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4042 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4046 i
= rp
->r_offset
/ (3 * addr_size
);
4048 switch (rp
->r_offset
/addr_size
% 3)
4051 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4052 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4055 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4056 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4059 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4060 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4070 aux
->table_len
= size
/ (3 * addr_size
);
4075 process_unwind (FILE *file
)
4077 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4078 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4079 struct unw_aux_info aux
;
4084 if (elf_header
.e_machine
!= EM_IA_64
)
4086 printf (_("\nThere are no unwind sections in this file.\n"));
4090 memset (& aux
, 0, sizeof (aux
));
4092 addr_size
= is_32bit_elf
? 4 : 8;
4094 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4096 if (sec
->sh_type
== SHT_SYMTAB
)
4098 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4099 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4101 strsec
= SECTION_HEADER (sec
->sh_link
);
4102 aux
.strtab_size
= strsec
->sh_size
;
4103 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4104 aux
.strtab_size
, _("string table"));
4106 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4111 printf (_("\nThere are no unwind sections in this file.\n"));
4113 while (unwcount
-- > 0)
4118 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4119 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4120 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4127 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4129 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
4132 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4133 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4134 suffix
= SECTION_NAME (unwsec
) + len
;
4135 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4137 if (strncmp (SECTION_NAME (sec
),
4138 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4139 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4144 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4145 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4146 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4147 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4149 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4151 suffix
= SECTION_NAME (unwsec
) + len
;
4152 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4154 if (strncmp (SECTION_NAME (sec
),
4155 ELF_STRING_ia64_unwind_info
, len2
) == 0
4156 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4160 if (i
== elf_header
.e_shnum
)
4162 printf (_("\nCould not find unwind info section for "));
4164 if (string_table
== NULL
)
4165 printf ("%d", unwsec
->sh_name
);
4167 printf (_("'%s'"), SECTION_NAME (unwsec
));
4171 aux
.info_size
= sec
->sh_size
;
4172 aux
.info_addr
= sec
->sh_addr
;
4173 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4176 printf (_("\nUnwind section "));
4178 if (string_table
== NULL
)
4179 printf ("%d", unwsec
->sh_name
);
4181 printf (_("'%s'"), SECTION_NAME (unwsec
));
4183 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4184 (unsigned long) unwsec
->sh_offset
,
4185 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4187 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4189 if (aux
.table_len
> 0)
4190 dump_ia64_unwind (& aux
);
4193 free ((char *) aux
.table
);
4195 free ((char *) aux
.info
);
4204 free ((char *) aux
.strtab
);
4210 dynamic_segment_mips_val (Elf_Internal_Dyn
*entry
)
4212 switch (entry
->d_tag
)
4215 if (entry
->d_un
.d_val
== 0)
4219 static const char * opts
[] =
4221 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4222 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4223 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4224 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4229 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4230 if (entry
->d_un
.d_val
& (1 << cnt
))
4232 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4239 case DT_MIPS_IVERSION
:
4240 if (dynamic_strings
!= NULL
)
4241 printf ("Interface Version: %s\n",
4242 dynamic_strings
+ entry
->d_un
.d_val
);
4244 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4247 case DT_MIPS_TIME_STAMP
:
4252 time_t time
= entry
->d_un
.d_val
;
4253 tmp
= gmtime (&time
);
4254 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4255 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4256 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4257 printf ("Time Stamp: %s\n", timebuf
);
4261 case DT_MIPS_RLD_VERSION
:
4262 case DT_MIPS_LOCAL_GOTNO
:
4263 case DT_MIPS_CONFLICTNO
:
4264 case DT_MIPS_LIBLISTNO
:
4265 case DT_MIPS_SYMTABNO
:
4266 case DT_MIPS_UNREFEXTNO
:
4267 case DT_MIPS_HIPAGENO
:
4268 case DT_MIPS_DELTA_CLASS_NO
:
4269 case DT_MIPS_DELTA_INSTANCE_NO
:
4270 case DT_MIPS_DELTA_RELOC_NO
:
4271 case DT_MIPS_DELTA_SYM_NO
:
4272 case DT_MIPS_DELTA_CLASSSYM_NO
:
4273 case DT_MIPS_COMPACT_SIZE
:
4274 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4278 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4284 dynamic_segment_parisc_val (Elf_Internal_Dyn
*entry
)
4286 switch (entry
->d_tag
)
4288 case DT_HP_DLD_FLAGS
:
4297 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4298 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4299 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4300 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4301 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4302 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4303 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4304 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4305 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4306 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4307 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4311 bfd_vma val
= entry
->d_un
.d_val
;
4313 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4314 if (val
& flags
[cnt
].bit
)
4318 fputs (flags
[cnt
].str
, stdout
);
4320 val
^= flags
[cnt
].bit
;
4323 if (val
!= 0 || first
)
4327 print_vma (val
, HEX
);
4333 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4340 dynamic_segment_ia64_val (Elf_Internal_Dyn
*entry
)
4342 switch (entry
->d_tag
)
4344 case DT_IA_64_PLT_RESERVE
:
4345 /* First 3 slots reserved. */
4346 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4348 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
4352 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4359 get_32bit_dynamic_segment (FILE *file
)
4361 Elf32_External_Dyn
*edyn
;
4362 Elf_Internal_Dyn
*entry
;
4365 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4366 _("dynamic segment"));
4370 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4371 how large this .dynamic is now. We can do this even before the byte
4372 swapping since the DT_NULL tag is recognizable. */
4374 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4377 dynamic_segment
= malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4379 if (dynamic_segment
== NULL
)
4381 error (_("Out of memory\n"));
4386 for (i
= 0, entry
= dynamic_segment
;
4390 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
4391 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
4400 get_64bit_dynamic_segment (FILE *file
)
4402 Elf64_External_Dyn
*edyn
;
4403 Elf_Internal_Dyn
*entry
;
4406 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4407 _("dynamic segment"));
4411 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
4412 how large this .dynamic is now. We can do this even before the byte
4413 swapping since the DT_NULL tag is recognizable. */
4415 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
4418 dynamic_segment
= malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
4420 if (dynamic_segment
== NULL
)
4422 error (_("Out of memory\n"));
4427 for (i
= 0, entry
= dynamic_segment
;
4431 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
4432 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
4441 get_dynamic_flags (bfd_vma flags
)
4443 static char buff
[128];
4451 flag
= flags
& - flags
;
4459 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4460 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4461 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4462 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4463 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4464 default: strcpy (p
, "unknown"); break;
4467 p
= strchr (p
, '\0');
4472 /* Parse and display the contents of the dynamic segment. */
4474 process_dynamic_segment (FILE *file
)
4476 Elf_Internal_Dyn
*entry
;
4479 if (dynamic_size
== 0)
4482 printf (_("\nThere is no dynamic segment in this file.\n"));
4489 if (! get_32bit_dynamic_segment (file
))
4492 else if (! get_64bit_dynamic_segment (file
))
4495 /* Find the appropriate symbol table. */
4496 if (dynamic_symbols
== NULL
)
4498 for (i
= 0, entry
= dynamic_segment
;
4502 Elf_Internal_Shdr section
;
4504 if (entry
->d_tag
!= DT_SYMTAB
)
4507 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4509 /* Since we do not know how big the symbol table is,
4510 we default to reading in the entire file (!) and
4511 processing that. This is overkill, I know, but it
4513 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4515 if (archive_file_offset
!= 0)
4516 section
.sh_size
= archive_file_size
- section
.sh_offset
;
4519 if (fseek (file
, 0, SEEK_END
))
4520 error (_("Unable to seek to end of file!"));
4522 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4526 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4528 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4530 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4531 if (num_dynamic_syms
< 1)
4533 error (_("Unable to determine the number of symbols to load\n"));
4537 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4541 /* Similarly find a string table. */
4542 if (dynamic_strings
== NULL
)
4544 for (i
= 0, entry
= dynamic_segment
;
4548 unsigned long offset
;
4551 if (entry
->d_tag
!= DT_STRTAB
)
4554 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4556 /* Since we do not know how big the string table is,
4557 we default to reading in the entire file (!) and
4558 processing that. This is overkill, I know, but it
4561 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4563 if (archive_file_offset
!= 0)
4564 str_tab_len
= archive_file_size
- offset
;
4567 if (fseek (file
, 0, SEEK_END
))
4568 error (_("Unable to seek to end of file\n"));
4569 str_tab_len
= ftell (file
) - offset
;
4572 if (str_tab_len
< 1)
4575 (_("Unable to determine the length of the dynamic string table\n"));
4579 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
4580 _("dynamic string table"));
4585 /* And find the syminfo section if available. */
4586 if (dynamic_syminfo
== NULL
)
4588 unsigned long syminsz
= 0;
4590 for (i
= 0, entry
= dynamic_segment
;
4594 if (entry
->d_tag
== DT_SYMINENT
)
4596 /* Note: these braces are necessary to avoid a syntax
4597 error from the SunOS4 C compiler. */
4598 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4600 else if (entry
->d_tag
== DT_SYMINSZ
)
4601 syminsz
= entry
->d_un
.d_val
;
4602 else if (entry
->d_tag
== DT_SYMINFO
)
4603 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
4607 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4609 Elf_External_Syminfo
*extsyminfo
;
4610 Elf_Internal_Syminfo
*syminfo
;
4612 /* There is a syminfo section. Read the data. */
4613 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
4614 _("symbol information"));
4618 dynamic_syminfo
= malloc (syminsz
);
4619 if (dynamic_syminfo
== NULL
)
4621 error (_("Out of memory\n"));
4625 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4626 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4629 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4630 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4637 if (do_dynamic
&& dynamic_addr
)
4638 printf (_("\nDynamic segment at offset 0x%lx contains %ld entries:\n"),
4639 dynamic_addr
, (long) dynamic_size
);
4641 printf (_(" Tag Type Name/Value\n"));
4643 for (i
= 0, entry
= dynamic_segment
;
4652 print_vma (entry
->d_tag
, FULL_HEX
);
4653 dtype
= get_dynamic_type (entry
->d_tag
);
4654 printf (" (%s)%*s", dtype
,
4655 ((is_32bit_elf
? 27 : 19)
4656 - (int) strlen (dtype
)),
4660 switch (entry
->d_tag
)
4664 puts (get_dynamic_flags (entry
->d_un
.d_val
));
4674 switch (entry
->d_tag
)
4677 printf (_("Auxiliary library"));
4681 printf (_("Filter library"));
4685 printf (_("Configuration file"));
4689 printf (_("Dependency audit library"));
4693 printf (_("Audit library"));
4697 if (dynamic_strings
)
4698 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4702 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4711 printf (_("Flags:"));
4713 if (entry
->d_un
.d_val
== 0)
4714 printf (_(" None\n"));
4717 unsigned long int val
= entry
->d_un
.d_val
;
4719 if (val
& DTF_1_PARINIT
)
4721 printf (" PARINIT");
4722 val
^= DTF_1_PARINIT
;
4724 if (val
& DTF_1_CONFEXP
)
4726 printf (" CONFEXP");
4727 val
^= DTF_1_CONFEXP
;
4730 printf (" %lx", val
);
4739 printf (_("Flags:"));
4741 if (entry
->d_un
.d_val
== 0)
4742 printf (_(" None\n"));
4745 unsigned long int val
= entry
->d_un
.d_val
;
4747 if (val
& DF_P1_LAZYLOAD
)
4749 printf (" LAZYLOAD");
4750 val
^= DF_P1_LAZYLOAD
;
4752 if (val
& DF_P1_GROUPPERM
)
4754 printf (" GROUPPERM");
4755 val
^= DF_P1_GROUPPERM
;
4758 printf (" %lx", val
);
4767 printf (_("Flags:"));
4768 if (entry
->d_un
.d_val
== 0)
4769 printf (_(" None\n"));
4772 unsigned long int val
= entry
->d_un
.d_val
;
4779 if (val
& DF_1_GLOBAL
)
4784 if (val
& DF_1_GROUP
)
4789 if (val
& DF_1_NODELETE
)
4791 printf (" NODELETE");
4792 val
^= DF_1_NODELETE
;
4794 if (val
& DF_1_LOADFLTR
)
4796 printf (" LOADFLTR");
4797 val
^= DF_1_LOADFLTR
;
4799 if (val
& DF_1_INITFIRST
)
4801 printf (" INITFIRST");
4802 val
^= DF_1_INITFIRST
;
4804 if (val
& DF_1_NOOPEN
)
4809 if (val
& DF_1_ORIGIN
)
4814 if (val
& DF_1_DIRECT
)
4819 if (val
& DF_1_TRANS
)
4824 if (val
& DF_1_INTERPOSE
)
4826 printf (" INTERPOSE");
4827 val
^= DF_1_INTERPOSE
;
4829 if (val
& DF_1_NODEFLIB
)
4831 printf (" NODEFLIB");
4832 val
^= DF_1_NODEFLIB
;
4834 if (val
& DF_1_NODUMP
)
4839 if (val
& DF_1_CONLFAT
)
4841 printf (" CONLFAT");
4842 val
^= DF_1_CONLFAT
;
4845 printf (" %lx", val
);
4852 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4854 puts (get_dynamic_type (entry
->d_un
.d_val
));
4874 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4880 if (dynamic_strings
== NULL
)
4883 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4887 switch (entry
->d_tag
)
4890 printf (_("Shared library: [%s]"), name
);
4892 if (strcmp (name
, program_interpreter
) == 0)
4893 printf (_(" program interpreter"));
4897 printf (_("Library soname: [%s]"), name
);
4901 printf (_("Library rpath: [%s]"), name
);
4905 printf (_("Library runpath: [%s]"), name
);
4909 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4914 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4927 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4931 case DT_INIT_ARRAYSZ
:
4932 case DT_FINI_ARRAYSZ
:
4933 case DT_GNU_CONFLICTSZ
:
4934 case DT_GNU_LIBLISTSZ
:
4937 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4938 printf (" (bytes)\n");
4948 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4961 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4965 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4969 printf (_("Not needed object: [%s]\n"), name
);
4974 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4980 /* The value of this entry is ignored. */
4985 case DT_GNU_PRELINKED
:
4989 time_t time
= entry
->d_un
.d_val
;
4991 tmp
= gmtime (&time
);
4992 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
4993 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4994 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5000 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5001 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5006 switch (elf_header
.e_machine
)
5009 case EM_MIPS_RS3_LE
:
5010 dynamic_segment_mips_val (entry
);
5013 dynamic_segment_parisc_val (entry
);
5016 dynamic_segment_ia64_val (entry
);
5019 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5031 get_ver_flags (unsigned int flags
)
5033 static char buff
[32];
5040 if (flags
& VER_FLG_BASE
)
5041 strcat (buff
, "BASE ");
5043 if (flags
& VER_FLG_WEAK
)
5045 if (flags
& VER_FLG_BASE
)
5046 strcat (buff
, "| ");
5048 strcat (buff
, "WEAK ");
5051 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5052 strcat (buff
, "| <unknown>");
5057 /* Display the contents of the version sections. */
5059 process_version_sections (FILE *file
)
5061 Elf_Internal_Shdr
*section
;
5068 for (i
= 0, section
= section_headers
;
5069 i
< elf_header
.e_shnum
;
5072 switch (section
->sh_type
)
5074 case SHT_GNU_verdef
:
5076 Elf_External_Verdef
*edefs
;
5083 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5084 SECTION_NAME (section
), section
->sh_info
);
5086 printf (_(" Addr: 0x"));
5087 printf_vma (section
->sh_addr
);
5088 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5089 (unsigned long) section
->sh_offset
, section
->sh_link
,
5090 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5092 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5093 _("version definition section"));
5097 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5100 Elf_External_Verdef
*edef
;
5101 Elf_Internal_Verdef ent
;
5102 Elf_External_Verdaux
*eaux
;
5103 Elf_Internal_Verdaux aux
;
5107 vstart
= ((char *) edefs
) + idx
;
5109 edef
= (Elf_External_Verdef
*) vstart
;
5111 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5112 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5113 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5114 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5115 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5116 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5117 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5119 printf (_(" %#06x: Rev: %d Flags: %s"),
5120 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5122 printf (_(" Index: %d Cnt: %d "),
5123 ent
.vd_ndx
, ent
.vd_cnt
);
5125 vstart
+= ent
.vd_aux
;
5127 eaux
= (Elf_External_Verdaux
*) vstart
;
5129 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5130 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5132 if (dynamic_strings
)
5133 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5135 printf (_("Name index: %ld\n"), aux
.vda_name
);
5137 isum
= idx
+ ent
.vd_aux
;
5139 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5141 isum
+= aux
.vda_next
;
5142 vstart
+= aux
.vda_next
;
5144 eaux
= (Elf_External_Verdaux
*) vstart
;
5146 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5147 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5149 if (dynamic_strings
)
5150 printf (_(" %#06x: Parent %d: %s\n"),
5151 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5153 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5154 isum
, j
, aux
.vda_name
);
5164 case SHT_GNU_verneed
:
5166 Elf_External_Verneed
*eneed
;
5172 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5173 SECTION_NAME (section
), section
->sh_info
);
5175 printf (_(" Addr: 0x"));
5176 printf_vma (section
->sh_addr
);
5177 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5178 (unsigned long) section
->sh_offset
, section
->sh_link
,
5179 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5181 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5182 _("version need section"));
5186 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5188 Elf_External_Verneed
*entry
;
5189 Elf_Internal_Verneed ent
;
5194 vstart
= ((char *) eneed
) + idx
;
5196 entry
= (Elf_External_Verneed
*) vstart
;
5198 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5199 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5200 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5201 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5202 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5204 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5206 if (dynamic_strings
)
5207 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5209 printf (_(" File: %lx"), ent
.vn_file
);
5211 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5213 vstart
+= ent
.vn_aux
;
5215 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5217 Elf_External_Vernaux
*eaux
;
5218 Elf_Internal_Vernaux aux
;
5220 eaux
= (Elf_External_Vernaux
*) vstart
;
5222 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5223 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5224 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5225 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5226 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5228 if (dynamic_strings
)
5229 printf (_(" %#06x: Name: %s"),
5230 isum
, dynamic_strings
+ aux
.vna_name
);
5232 printf (_(" %#06x: Name index: %lx"),
5233 isum
, aux
.vna_name
);
5235 printf (_(" Flags: %s Version: %d\n"),
5236 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5238 isum
+= aux
.vna_next
;
5239 vstart
+= aux
.vna_next
;
5249 case SHT_GNU_versym
:
5251 Elf_Internal_Shdr
*link_section
;
5254 unsigned char *edata
;
5255 unsigned short *data
;
5257 Elf_Internal_Sym
*symbols
;
5258 Elf_Internal_Shdr
*string_sec
;
5261 link_section
= SECTION_HEADER (section
->sh_link
);
5262 total
= section
->sh_size
/ section
->sh_entsize
;
5266 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5268 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5270 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5271 string_sec
->sh_size
, _("version string table"));
5275 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5276 SECTION_NAME (section
), total
);
5278 printf (_(" Addr: "));
5279 printf_vma (section
->sh_addr
);
5280 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5281 (unsigned long) section
->sh_offset
, section
->sh_link
,
5282 SECTION_NAME (link_section
));
5284 off
= offset_from_vma (file
,
5285 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5286 total
* sizeof (short));
5287 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
5288 _("version symbol data"));
5295 data
= malloc (total
* sizeof (short));
5297 for (cnt
= total
; cnt
--;)
5298 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5303 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5306 int check_def
, check_need
;
5309 printf (" %03x:", cnt
);
5311 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5312 switch (data
[cnt
+ j
])
5315 fputs (_(" 0 (*local*) "), stdout
);
5319 fputs (_(" 1 (*global*) "), stdout
);
5323 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5324 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5328 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5331 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5338 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5340 Elf_Internal_Verneed ivn
;
5341 unsigned long offset
;
5343 offset
= offset_from_vma
5344 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5345 sizeof (Elf_External_Verneed
));
5349 Elf_Internal_Vernaux ivna
;
5350 Elf_External_Verneed evn
;
5351 Elf_External_Vernaux evna
;
5352 unsigned long a_off
;
5354 get_data (&evn
, file
, offset
, sizeof (evn
),
5357 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5358 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5360 a_off
= offset
+ ivn
.vn_aux
;
5364 get_data (&evna
, file
, a_off
, sizeof (evna
),
5365 _("version need aux (2)"));
5367 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5368 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5370 a_off
+= ivna
.vna_next
;
5372 while (ivna
.vna_other
!= data
[cnt
+ j
]
5373 && ivna
.vna_next
!= 0);
5375 if (ivna
.vna_other
== data
[cnt
+ j
])
5377 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5379 name
= strtab
+ ivna
.vna_name
;
5380 nn
+= printf ("(%s%-*s",
5382 12 - (int) strlen (name
),
5388 offset
+= ivn
.vn_next
;
5390 while (ivn
.vn_next
);
5393 if (check_def
&& data
[cnt
+ j
] != 0x8001
5394 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5396 Elf_Internal_Verdef ivd
;
5397 Elf_External_Verdef evd
;
5398 unsigned long offset
;
5400 offset
= offset_from_vma
5401 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5406 get_data (&evd
, file
, offset
, sizeof (evd
),
5409 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5410 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5412 offset
+= ivd
.vd_next
;
5414 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5415 && ivd
.vd_next
!= 0);
5417 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5419 Elf_External_Verdaux evda
;
5420 Elf_Internal_Verdaux ivda
;
5422 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5424 get_data (&evda
, file
,
5425 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5426 sizeof (evda
), _("version def aux"));
5428 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5430 name
= strtab
+ ivda
.vda_name
;
5431 nn
+= printf ("(%s%-*s",
5433 12 - (int) strlen (name
),
5439 printf ("%*c", 18 - nn
, ' ');
5457 printf (_("\nNo version information found in this file.\n"));
5463 get_symbol_binding (unsigned int binding
)
5465 static char buff
[32];
5469 case STB_LOCAL
: return "LOCAL";
5470 case STB_GLOBAL
: return "GLOBAL";
5471 case STB_WEAK
: return "WEAK";
5473 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5474 sprintf (buff
, _("<processor specific>: %d"), binding
);
5475 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5476 sprintf (buff
, _("<OS specific>: %d"), binding
);
5478 sprintf (buff
, _("<unknown>: %d"), binding
);
5484 get_symbol_type (unsigned int type
)
5486 static char buff
[32];
5490 case STT_NOTYPE
: return "NOTYPE";
5491 case STT_OBJECT
: return "OBJECT";
5492 case STT_FUNC
: return "FUNC";
5493 case STT_SECTION
: return "SECTION";
5494 case STT_FILE
: return "FILE";
5495 case STT_COMMON
: return "COMMON";
5496 case STT_TLS
: return "TLS";
5498 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5500 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5501 return "THUMB_FUNC";
5503 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5506 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5507 return "PARISC_MILLI";
5509 sprintf (buff
, _("<processor specific>: %d"), type
);
5511 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5513 if (elf_header
.e_machine
== EM_PARISC
)
5515 if (type
== STT_HP_OPAQUE
)
5517 if (type
== STT_HP_STUB
)
5521 sprintf (buff
, _("<OS specific>: %d"), type
);
5524 sprintf (buff
, _("<unknown>: %d"), type
);
5530 get_symbol_visibility (unsigned int visibility
)
5534 case STV_DEFAULT
: return "DEFAULT";
5535 case STV_INTERNAL
: return "INTERNAL";
5536 case STV_HIDDEN
: return "HIDDEN";
5537 case STV_PROTECTED
: return "PROTECTED";
5543 get_symbol_index_type (unsigned int type
)
5545 static char buff
[32];
5549 case SHN_UNDEF
: return "UND";
5550 case SHN_ABS
: return "ABS";
5551 case SHN_COMMON
: return "COM";
5553 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5554 sprintf (buff
, "PRC[0x%04x]", type
);
5555 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5556 sprintf (buff
, "OS [0x%04x]", type
);
5557 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5558 sprintf (buff
, "RSV[0x%04x]", type
);
5560 sprintf (buff
, "%3d", type
);
5568 get_dynamic_data (FILE *file
, unsigned int number
)
5570 unsigned char *e_data
;
5573 e_data
= malloc (number
* 4);
5577 error (_("Out of memory\n"));
5581 if (fread (e_data
, 4, number
, file
) != number
)
5583 error (_("Unable to read in dynamic data\n"));
5587 i_data
= malloc (number
* sizeof (*i_data
));
5591 error (_("Out of memory\n"));
5597 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5604 /* Dump the symbol table. */
5606 process_symbol_table (FILE *file
)
5608 Elf_Internal_Shdr
*section
;
5609 unsigned char nb
[4];
5610 unsigned char nc
[4];
5613 int *buckets
= NULL
;
5616 if (! do_syms
&& !do_histogram
)
5619 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5623 (archive_file_offset
5624 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
5625 sizeof nb
+ sizeof nc
)),
5628 error (_("Unable to seek to start of dynamic information"));
5632 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5634 error (_("Failed to read in number of buckets\n"));
5638 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5640 error (_("Failed to read in number of chains\n"));
5644 nbuckets
= byte_get (nb
, 4);
5645 nchains
= byte_get (nc
, 4);
5647 buckets
= get_dynamic_data (file
, nbuckets
);
5648 chains
= get_dynamic_data (file
, nchains
);
5650 if (buckets
== NULL
|| chains
== NULL
)
5655 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5660 printf (_("\nSymbol table for image:\n"));
5662 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5664 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5666 for (hn
= 0; hn
< nbuckets
; hn
++)
5671 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5673 Elf_Internal_Sym
*psym
;
5675 psym
= dynamic_symbols
+ si
;
5677 printf (" %3d %3d: ", si
, hn
);
5678 print_vma (psym
->st_value
, LONG_HEX
);
5680 print_vma (psym
->st_size
, DEC_5
);
5682 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5683 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5684 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5685 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
5686 print_symbol (25, dynamic_strings
+ psym
->st_name
);
5691 else if (do_syms
&& !do_using_dynamic
)
5695 for (i
= 0, section
= section_headers
;
5696 i
< elf_header
.e_shnum
;
5701 Elf_Internal_Sym
*symtab
;
5702 Elf_Internal_Sym
*psym
;
5705 if ( section
->sh_type
!= SHT_SYMTAB
5706 && section
->sh_type
!= SHT_DYNSYM
)
5709 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5710 SECTION_NAME (section
),
5711 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5713 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5715 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5717 symtab
= GET_ELF_SYMBOLS (file
, section
);
5721 if (section
->sh_link
== elf_header
.e_shstrndx
)
5722 strtab
= string_table
;
5725 Elf_Internal_Shdr
*string_sec
;
5727 string_sec
= SECTION_HEADER (section
->sh_link
);
5729 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5730 string_sec
->sh_size
, _("string table"));
5733 for (si
= 0, psym
= symtab
;
5734 si
< section
->sh_size
/ section
->sh_entsize
;
5737 printf ("%6d: ", si
);
5738 print_vma (psym
->st_value
, LONG_HEX
);
5740 print_vma (psym
->st_size
, DEC_5
);
5741 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5742 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5743 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5744 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
5745 print_symbol (25, strtab
+ psym
->st_name
);
5747 if (section
->sh_type
== SHT_DYNSYM
&&
5748 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5750 unsigned char data
[2];
5751 unsigned short vers_data
;
5752 unsigned long offset
;
5756 offset
= offset_from_vma
5757 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5758 sizeof data
+ si
* sizeof (vers_data
));
5760 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5761 sizeof (data
), _("version data"));
5763 vers_data
= byte_get (data
, 2);
5765 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
5768 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5770 if ((vers_data
& 0x8000) || vers_data
> 1)
5772 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5773 && (is_nobits
|| ! check_def
))
5775 Elf_External_Verneed evn
;
5776 Elf_Internal_Verneed ivn
;
5777 Elf_Internal_Vernaux ivna
;
5779 /* We must test both. */
5780 offset
= offset_from_vma
5781 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5786 unsigned long vna_off
;
5788 get_data (&evn
, file
, offset
, sizeof (evn
),
5791 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5792 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5794 vna_off
= offset
+ ivn
.vn_aux
;
5798 Elf_External_Vernaux evna
;
5800 get_data (&evna
, file
, vna_off
,
5802 _("version need aux (3)"));
5804 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5805 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5806 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5808 vna_off
+= ivna
.vna_next
;
5810 while (ivna
.vna_other
!= vers_data
5811 && ivna
.vna_next
!= 0);
5813 if (ivna
.vna_other
== vers_data
)
5816 offset
+= ivn
.vn_next
;
5818 while (ivn
.vn_next
!= 0);
5820 if (ivna
.vna_other
== vers_data
)
5823 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5826 else if (! is_nobits
)
5827 error (_("bad dynamic symbol"));
5834 if (vers_data
!= 0x8001
5835 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5837 Elf_Internal_Verdef ivd
;
5838 Elf_Internal_Verdaux ivda
;
5839 Elf_External_Verdaux evda
;
5840 unsigned long offset
;
5842 offset
= offset_from_vma
5844 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5845 sizeof (Elf_External_Verdef
));
5849 Elf_External_Verdef evd
;
5851 get_data (&evd
, file
, offset
, sizeof (evd
),
5854 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5855 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5856 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5858 offset
+= ivd
.vd_next
;
5860 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5861 && ivd
.vd_next
!= 0);
5863 offset
-= ivd
.vd_next
;
5864 offset
+= ivd
.vd_aux
;
5866 get_data (&evda
, file
, offset
, sizeof (evda
),
5867 _("version def aux"));
5869 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5871 if (psym
->st_name
!= ivda
.vda_name
)
5872 printf ((vers_data
& 0x8000)
5874 strtab
+ ivda
.vda_name
);
5884 if (strtab
!= string_table
)
5890 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5892 if (do_histogram
&& buckets
!= NULL
)
5899 int nzero_counts
= 0;
5902 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5904 printf (_(" Length Number %% of total Coverage\n"));
5906 lengths
= calloc (nbuckets
, sizeof (int));
5907 if (lengths
== NULL
)
5909 error (_("Out of memory"));
5912 for (hn
= 0; hn
< nbuckets
; ++hn
)
5917 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5920 if (maxlength
< ++lengths
[hn
])
5925 counts
= calloc (maxlength
+ 1, sizeof (int));
5928 error (_("Out of memory"));
5932 for (hn
= 0; hn
< nbuckets
; ++hn
)
5933 ++counts
[lengths
[hn
]];
5937 printf (" 0 %-10d (%5.1f%%)\n",
5938 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5939 for (si
= 1; si
<= maxlength
; ++si
)
5941 nzero_counts
+= counts
[si
] * si
;
5942 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5943 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5944 (nzero_counts
* 100.0) / nsyms
);
5952 if (buckets
!= NULL
)
5962 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
5966 if (dynamic_syminfo
== NULL
5968 /* No syminfo, this is ok. */
5971 /* There better should be a dynamic symbol section. */
5972 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5976 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5977 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5979 printf (_(" Num: Name BoundTo Flags\n"));
5980 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5982 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5984 printf ("%4d: ", i
);
5985 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5988 switch (dynamic_syminfo
[i
].si_boundto
)
5990 case SYMINFO_BT_SELF
:
5991 fputs ("SELF ", stdout
);
5993 case SYMINFO_BT_PARENT
:
5994 fputs ("PARENT ", stdout
);
5997 if (dynamic_syminfo
[i
].si_boundto
> 0
5998 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
6003 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6007 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6011 if (flags
& SYMINFO_FLG_DIRECT
)
6013 if (flags
& SYMINFO_FLG_PASSTHRU
)
6014 printf (" PASSTHRU");
6015 if (flags
& SYMINFO_FLG_COPY
)
6017 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6018 printf (" LAZYLOAD");
6026 #ifdef SUPPORT_DISASSEMBLY
6028 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6030 printf (_("\nAssembly dump of section %s\n"),
6031 SECTION_NAME (section
));
6033 /* XXX -- to be done --- XXX */
6040 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6042 bfd_size_type bytes
;
6044 unsigned char *data
;
6045 unsigned char *start
;
6047 bytes
= section
->sh_size
;
6051 printf (_("\nSection '%s' has no data to dump.\n"),
6052 SECTION_NAME (section
));
6056 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6058 addr
= section
->sh_addr
;
6060 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6072 lbytes
= (bytes
> 16 ? 16 : bytes
);
6074 printf (" 0x%8.8lx ", (unsigned long) addr
);
6076 switch (elf_header
.e_ident
[EI_DATA
])
6080 for (j
= 15; j
>= 0; j
--)
6083 printf ("%2.2x", data
[j
]);
6093 for (j
= 0; j
< 16; j
++)
6096 printf ("%2.2x", data
[j
]);
6106 for (j
= 0; j
< lbytes
; j
++)
6109 if (k
>= ' ' && k
< 0x80)
6128 static unsigned long int
6129 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6131 unsigned long int result
= 0;
6132 unsigned int num_read
= 0;
6141 result
|= (byte
& 0x7f) << shift
;
6146 while (byte
& 0x80);
6148 if (length_return
!= NULL
)
6149 *length_return
= num_read
;
6151 if (sign
&& (shift
< 32) && (byte
& 0x40))
6152 result
|= -1 << shift
;
6157 typedef struct State_Machine_Registers
6159 unsigned long address
;
6162 unsigned int column
;
6166 /* This variable hold the number of the last entry seen
6167 in the File Table. */
6168 unsigned int last_file_entry
;
6171 static SMR state_machine_regs
;
6174 reset_state_machine (int is_stmt
)
6176 state_machine_regs
.address
= 0;
6177 state_machine_regs
.file
= 1;
6178 state_machine_regs
.line
= 1;
6179 state_machine_regs
.column
= 0;
6180 state_machine_regs
.is_stmt
= is_stmt
;
6181 state_machine_regs
.basic_block
= 0;
6182 state_machine_regs
.end_sequence
= 0;
6183 state_machine_regs
.last_file_entry
= 0;
6186 /* Handled an extend line op. Returns true if this is the end
6189 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6191 unsigned char op_code
;
6194 unsigned char *name
;
6197 len
= read_leb128 (data
, & bytes_read
, 0);
6202 warn (_("badly formed extended line op encountered!\n"));
6209 printf (_(" Extended opcode %d: "), op_code
);
6213 case DW_LNE_end_sequence
:
6214 printf (_("End of Sequence\n\n"));
6215 reset_state_machine (is_stmt
);
6218 case DW_LNE_set_address
:
6219 adr
= byte_get (data
, pointer_size
);
6220 printf (_("set Address to 0x%lx\n"), adr
);
6221 state_machine_regs
.address
= adr
;
6224 case DW_LNE_define_file
:
6225 printf (_(" define new File Table entry\n"));
6226 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6228 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6230 data
+= strlen ((char *) data
) + 1;
6231 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6233 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6235 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6236 printf (_("%s\n\n"), name
);
6240 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6247 /* Size of pointers in the .debug_line section. This information is not
6248 really present in that section. It's obtained before dumping the debug
6249 sections by doing some pre-scan of the .debug_info section. */
6250 static int debug_line_pointer_size
= 4;
6253 display_debug_lines (Elf_Internal_Shdr
*section
,
6254 unsigned char * start
,
6255 FILE *file ATTRIBUTE_UNUSED
)
6257 unsigned char *hdrptr
;
6258 DWARF2_Internal_LineInfo info
;
6259 unsigned char *standard_opcodes
;
6260 unsigned char *data
= start
;
6261 unsigned char *end
= start
+ section
->sh_size
;
6262 unsigned char *end_of_sequence
;
6265 int initial_length_size
;
6267 printf (_("\nDump of debug contents of section %s:\n\n"),
6268 SECTION_NAME (section
));
6274 /* Check the length of the block. */
6275 info
.li_length
= byte_get (hdrptr
, 4);
6278 if (info
.li_length
== 0xffffffff)
6280 /* This section is 64-bit DWARF 3. */
6281 info
.li_length
= byte_get (hdrptr
, 8);
6284 initial_length_size
= 12;
6289 initial_length_size
= 4;
6292 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
6295 (_("The line info appears to be corrupt - the section is too small\n"));
6299 /* Check its version number. */
6300 info
.li_version
= byte_get (hdrptr
, 2);
6302 if (info
.li_version
!= 2 && info
.li_version
!= 3)
6304 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6308 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
6309 hdrptr
+= offset_size
;
6310 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
6312 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
6314 info
.li_line_base
= byte_get (hdrptr
, 1);
6316 info
.li_line_range
= byte_get (hdrptr
, 1);
6318 info
.li_opcode_base
= byte_get (hdrptr
, 1);
6321 /* Sign extend the line base field. */
6322 info
.li_line_base
<<= 24;
6323 info
.li_line_base
>>= 24;
6325 printf (_(" Length: %ld\n"), info
.li_length
);
6326 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6327 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6328 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6329 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6330 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6331 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6332 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6334 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
6336 reset_state_machine (info
.li_default_is_stmt
);
6338 /* Display the contents of the Opcodes table. */
6339 standard_opcodes
= hdrptr
;
6341 printf (_("\n Opcodes:\n"));
6343 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6344 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6346 /* Display the contents of the Directory table. */
6347 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6350 printf (_("\n The Directory Table is empty.\n"));
6353 printf (_("\n The Directory Table:\n"));
6357 printf (_(" %s\n"), data
);
6359 data
+= strlen ((char *) data
) + 1;
6363 /* Skip the NUL at the end of the table. */
6366 /* Display the contents of the File Name table. */
6368 printf (_("\n The File Name Table is empty.\n"));
6371 printf (_("\n The File Name Table:\n"));
6372 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6376 unsigned char *name
;
6379 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6382 data
+= strlen ((char *) data
) + 1;
6384 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6386 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6388 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6390 printf (_("%s\n"), name
);
6394 /* Skip the NUL at the end of the table. */
6397 /* Now display the statements. */
6398 printf (_("\n Line Number Statements:\n"));
6401 while (data
< end_of_sequence
)
6403 unsigned char op_code
;
6409 if (op_code
>= info
.li_opcode_base
)
6411 op_code
-= info
.li_opcode_base
;
6412 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6413 state_machine_regs
.address
+= adv
;
6414 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6415 op_code
, adv
, state_machine_regs
.address
);
6416 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6417 state_machine_regs
.line
+= adv
;
6418 printf (_(" and Line by %d to %d\n"),
6419 adv
, state_machine_regs
.line
);
6421 else switch (op_code
)
6423 case DW_LNS_extended_op
:
6424 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6425 debug_line_pointer_size
);
6429 printf (_(" Copy\n"));
6432 case DW_LNS_advance_pc
:
6433 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6435 state_machine_regs
.address
+= adv
;
6436 printf (_(" Advance PC by %d to %lx\n"), adv
,
6437 state_machine_regs
.address
);
6440 case DW_LNS_advance_line
:
6441 adv
= read_leb128 (data
, & bytes_read
, 1);
6443 state_machine_regs
.line
+= adv
;
6444 printf (_(" Advance Line by %d to %d\n"), adv
,
6445 state_machine_regs
.line
);
6448 case DW_LNS_set_file
:
6449 adv
= read_leb128 (data
, & bytes_read
, 0);
6451 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6453 state_machine_regs
.file
= adv
;
6456 case DW_LNS_set_column
:
6457 adv
= read_leb128 (data
, & bytes_read
, 0);
6459 printf (_(" Set column to %d\n"), adv
);
6460 state_machine_regs
.column
= adv
;
6463 case DW_LNS_negate_stmt
:
6464 adv
= state_machine_regs
.is_stmt
;
6466 printf (_(" Set is_stmt to %d\n"), adv
);
6467 state_machine_regs
.is_stmt
= adv
;
6470 case DW_LNS_set_basic_block
:
6471 printf (_(" Set basic block\n"));
6472 state_machine_regs
.basic_block
= 1;
6475 case DW_LNS_const_add_pc
:
6476 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6477 * info
.li_min_insn_length
);
6478 state_machine_regs
.address
+= adv
;
6479 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
6480 state_machine_regs
.address
);
6483 case DW_LNS_fixed_advance_pc
:
6484 adv
= byte_get (data
, 2);
6486 state_machine_regs
.address
+= adv
;
6487 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
6488 adv
, state_machine_regs
.address
);
6491 case DW_LNS_set_prologue_end
:
6492 printf (_(" Set prologue_end to true\n"));
6495 case DW_LNS_set_epilogue_begin
:
6496 printf (_(" Set epilogue_begin to true\n"));
6499 case DW_LNS_set_isa
:
6500 adv
= read_leb128 (data
, & bytes_read
, 0);
6502 printf (_(" Set ISA to %d\n"), adv
);
6506 printf (_(" Unknown opcode %d with operands: "), op_code
);
6509 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
6511 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
6512 i
== 1 ? "" : ", ");
6527 display_debug_pubnames (Elf_Internal_Shdr
*section
,
6528 unsigned char *start
,
6529 FILE *file ATTRIBUTE_UNUSED
)
6531 DWARF2_Internal_PubNames pubnames
;
6534 end
= start
+ section
->sh_size
;
6536 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6540 unsigned char *data
;
6541 unsigned long offset
;
6542 int offset_size
, initial_length_size
;
6546 pubnames
.pn_length
= byte_get (data
, 4);
6548 if (pubnames
.pn_length
== 0xffffffff)
6550 pubnames
.pn_length
= byte_get (data
, 8);
6553 initial_length_size
= 12;
6558 initial_length_size
= 4;
6561 pubnames
.pn_version
= byte_get (data
, 2);
6563 pubnames
.pn_offset
= byte_get (data
, offset_size
);
6564 data
+= offset_size
;
6565 pubnames
.pn_size
= byte_get (data
, offset_size
);
6566 data
+= offset_size
;
6568 start
+= pubnames
.pn_length
+ initial_length_size
;
6570 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
6572 static int warned
= 0;
6576 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
6583 printf (_(" Length: %ld\n"),
6584 pubnames
.pn_length
);
6585 printf (_(" Version: %d\n"),
6586 pubnames
.pn_version
);
6587 printf (_(" Offset into .debug_info section: %ld\n"),
6588 pubnames
.pn_offset
);
6589 printf (_(" Size of area in .debug_info section: %ld\n"),
6592 printf (_("\n Offset\tName\n"));
6596 offset
= byte_get (data
, offset_size
);
6600 data
+= offset_size
;
6601 printf (" %ld\t\t%s\n", offset
, data
);
6602 data
+= strlen ((char *) data
) + 1;
6605 while (offset
!= 0);
6613 get_TAG_name (unsigned long tag
)
6617 case DW_TAG_padding
: return "DW_TAG_padding";
6618 case DW_TAG_array_type
: return "DW_TAG_array_type";
6619 case DW_TAG_class_type
: return "DW_TAG_class_type";
6620 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6621 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6622 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6623 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6624 case DW_TAG_label
: return "DW_TAG_label";
6625 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6626 case DW_TAG_member
: return "DW_TAG_member";
6627 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6628 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6629 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6630 case DW_TAG_string_type
: return "DW_TAG_string_type";
6631 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6632 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6633 case DW_TAG_typedef
: return "DW_TAG_typedef";
6634 case DW_TAG_union_type
: return "DW_TAG_union_type";
6635 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6636 case DW_TAG_variant
: return "DW_TAG_variant";
6637 case DW_TAG_common_block
: return "DW_TAG_common_block";
6638 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6639 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6640 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6641 case DW_TAG_module
: return "DW_TAG_module";
6642 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6643 case DW_TAG_set_type
: return "DW_TAG_set_type";
6644 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6645 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6646 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6647 case DW_TAG_base_type
: return "DW_TAG_base_type";
6648 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6649 case DW_TAG_const_type
: return "DW_TAG_const_type";
6650 case DW_TAG_constant
: return "DW_TAG_constant";
6651 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6652 case DW_TAG_file_type
: return "DW_TAG_file_type";
6653 case DW_TAG_friend
: return "DW_TAG_friend";
6654 case DW_TAG_namelist
: return "DW_TAG_namelist";
6655 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6656 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6657 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6658 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6659 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6660 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6661 case DW_TAG_try_block
: return "DW_TAG_try_block";
6662 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6663 case DW_TAG_variable
: return "DW_TAG_variable";
6664 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6665 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6666 case DW_TAG_format_label
: return "DW_TAG_format_label";
6667 case DW_TAG_function_template
: return "DW_TAG_function_template";
6668 case DW_TAG_class_template
: return "DW_TAG_class_template";
6669 /* DWARF 2.1 values. */
6670 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6671 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6672 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6673 case DW_TAG_namespace
: return "DW_TAG_namespace";
6674 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6675 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6676 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6677 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6679 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
6680 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
6681 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
6684 static char buffer
[100];
6686 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6693 get_AT_name (unsigned long attribute
)
6697 case DW_AT_sibling
: return "DW_AT_sibling";
6698 case DW_AT_location
: return "DW_AT_location";
6699 case DW_AT_name
: return "DW_AT_name";
6700 case DW_AT_ordering
: return "DW_AT_ordering";
6701 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6702 case DW_AT_byte_size
: return "DW_AT_byte_size";
6703 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6704 case DW_AT_bit_size
: return "DW_AT_bit_size";
6705 case DW_AT_element_list
: return "DW_AT_element_list";
6706 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6707 case DW_AT_low_pc
: return "DW_AT_low_pc";
6708 case DW_AT_high_pc
: return "DW_AT_high_pc";
6709 case DW_AT_language
: return "DW_AT_language";
6710 case DW_AT_member
: return "DW_AT_member";
6711 case DW_AT_discr
: return "DW_AT_discr";
6712 case DW_AT_discr_value
: return "DW_AT_discr_value";
6713 case DW_AT_visibility
: return "DW_AT_visibility";
6714 case DW_AT_import
: return "DW_AT_import";
6715 case DW_AT_string_length
: return "DW_AT_string_length";
6716 case DW_AT_common_reference
: return "DW_AT_common_reference";
6717 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6718 case DW_AT_const_value
: return "DW_AT_const_value";
6719 case DW_AT_containing_type
: return "DW_AT_containing_type";
6720 case DW_AT_default_value
: return "DW_AT_default_value";
6721 case DW_AT_inline
: return "DW_AT_inline";
6722 case DW_AT_is_optional
: return "DW_AT_is_optional";
6723 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6724 case DW_AT_producer
: return "DW_AT_producer";
6725 case DW_AT_prototyped
: return "DW_AT_prototyped";
6726 case DW_AT_return_addr
: return "DW_AT_return_addr";
6727 case DW_AT_start_scope
: return "DW_AT_start_scope";
6728 case DW_AT_stride_size
: return "DW_AT_stride_size";
6729 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6730 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6731 case DW_AT_accessibility
: return "DW_AT_accessibility";
6732 case DW_AT_address_class
: return "DW_AT_address_class";
6733 case DW_AT_artificial
: return "DW_AT_artificial";
6734 case DW_AT_base_types
: return "DW_AT_base_types";
6735 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6736 case DW_AT_count
: return "DW_AT_count";
6737 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6738 case DW_AT_decl_column
: return "DW_AT_decl_column";
6739 case DW_AT_decl_file
: return "DW_AT_decl_file";
6740 case DW_AT_decl_line
: return "DW_AT_decl_line";
6741 case DW_AT_declaration
: return "DW_AT_declaration";
6742 case DW_AT_discr_list
: return "DW_AT_discr_list";
6743 case DW_AT_encoding
: return "DW_AT_encoding";
6744 case DW_AT_external
: return "DW_AT_external";
6745 case DW_AT_frame_base
: return "DW_AT_frame_base";
6746 case DW_AT_friend
: return "DW_AT_friend";
6747 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6748 case DW_AT_macro_info
: return "DW_AT_macro_info";
6749 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6750 case DW_AT_priority
: return "DW_AT_priority";
6751 case DW_AT_segment
: return "DW_AT_segment";
6752 case DW_AT_specification
: return "DW_AT_specification";
6753 case DW_AT_static_link
: return "DW_AT_static_link";
6754 case DW_AT_type
: return "DW_AT_type";
6755 case DW_AT_use_location
: return "DW_AT_use_location";
6756 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6757 case DW_AT_virtuality
: return "DW_AT_virtuality";
6758 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6759 /* DWARF 2.1 values. */
6760 case DW_AT_allocated
: return "DW_AT_allocated";
6761 case DW_AT_associated
: return "DW_AT_associated";
6762 case DW_AT_data_location
: return "DW_AT_data_location";
6763 case DW_AT_stride
: return "DW_AT_stride";
6764 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6765 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6766 case DW_AT_extension
: return "DW_AT_extension";
6767 case DW_AT_ranges
: return "DW_AT_ranges";
6768 case DW_AT_trampoline
: return "DW_AT_trampoline";
6769 case DW_AT_call_column
: return "DW_AT_call_column";
6770 case DW_AT_call_file
: return "DW_AT_call_file";
6771 case DW_AT_call_line
: return "DW_AT_call_line";
6772 /* SGI/MIPS extensions. */
6773 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6774 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6775 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6776 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6777 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6778 case DW_AT_MIPS_software_pipeline_depth
:
6779 return "DW_AT_MIPS_software_pipeline_depth";
6780 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6781 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6782 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6783 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6784 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6785 /* GNU extensions. */
6786 case DW_AT_sf_names
: return "DW_AT_sf_names";
6787 case DW_AT_src_info
: return "DW_AT_src_info";
6788 case DW_AT_mac_info
: return "DW_AT_mac_info";
6789 case DW_AT_src_coords
: return "DW_AT_src_coords";
6790 case DW_AT_body_begin
: return "DW_AT_body_begin";
6791 case DW_AT_body_end
: return "DW_AT_body_end";
6792 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
6793 /* UPC extension. */
6794 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
6797 static char buffer
[100];
6799 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6806 get_FORM_name (unsigned long form
)
6810 case DW_FORM_addr
: return "DW_FORM_addr";
6811 case DW_FORM_block2
: return "DW_FORM_block2";
6812 case DW_FORM_block4
: return "DW_FORM_block4";
6813 case DW_FORM_data2
: return "DW_FORM_data2";
6814 case DW_FORM_data4
: return "DW_FORM_data4";
6815 case DW_FORM_data8
: return "DW_FORM_data8";
6816 case DW_FORM_string
: return "DW_FORM_string";
6817 case DW_FORM_block
: return "DW_FORM_block";
6818 case DW_FORM_block1
: return "DW_FORM_block1";
6819 case DW_FORM_data1
: return "DW_FORM_data1";
6820 case DW_FORM_flag
: return "DW_FORM_flag";
6821 case DW_FORM_sdata
: return "DW_FORM_sdata";
6822 case DW_FORM_strp
: return "DW_FORM_strp";
6823 case DW_FORM_udata
: return "DW_FORM_udata";
6824 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6825 case DW_FORM_ref1
: return "DW_FORM_ref1";
6826 case DW_FORM_ref2
: return "DW_FORM_ref2";
6827 case DW_FORM_ref4
: return "DW_FORM_ref4";
6828 case DW_FORM_ref8
: return "DW_FORM_ref8";
6829 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6830 case DW_FORM_indirect
: return "DW_FORM_indirect";
6833 static char buffer
[100];
6835 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6841 /* FIXME: There are better and more effiecint ways to handle
6842 these structures. For now though, I just want something that
6843 is simple to implement. */
6844 typedef struct abbrev_attr
6846 unsigned long attribute
;
6848 struct abbrev_attr
*next
;
6852 typedef struct abbrev_entry
6854 unsigned long entry
;
6857 struct abbrev_attr
*first_attr
;
6858 struct abbrev_attr
*last_attr
;
6859 struct abbrev_entry
*next
;
6863 static abbrev_entry
*first_abbrev
= NULL
;
6864 static abbrev_entry
*last_abbrev
= NULL
;
6869 abbrev_entry
*abbrev
;
6871 for (abbrev
= first_abbrev
; abbrev
;)
6873 abbrev_entry
*next
= abbrev
->next
;
6876 for (attr
= abbrev
->first_attr
; attr
;)
6878 abbrev_attr
*next
= attr
->next
;
6888 last_abbrev
= first_abbrev
= NULL
;
6892 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
6894 abbrev_entry
*entry
;
6896 entry
= malloc (sizeof (*entry
));
6902 entry
->entry
= number
;
6904 entry
->children
= children
;
6905 entry
->first_attr
= NULL
;
6906 entry
->last_attr
= NULL
;
6909 if (first_abbrev
== NULL
)
6910 first_abbrev
= entry
;
6912 last_abbrev
->next
= entry
;
6914 last_abbrev
= entry
;
6918 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
6922 attr
= malloc (sizeof (*attr
));
6928 attr
->attribute
= attribute
;
6932 if (last_abbrev
->first_attr
== NULL
)
6933 last_abbrev
->first_attr
= attr
;
6935 last_abbrev
->last_attr
->next
= attr
;
6937 last_abbrev
->last_attr
= attr
;
6940 /* Processes the (partial) contents of a .debug_abbrev section.
6941 Returns NULL if the end of the section was encountered.
6942 Returns the address after the last byte read if the end of
6943 an abbreviation set was found. */
6945 static unsigned char *
6946 process_abbrev_section (unsigned char *start
, unsigned char *end
)
6948 if (first_abbrev
!= NULL
)
6954 unsigned long entry
;
6956 unsigned long attribute
;
6959 entry
= read_leb128 (start
, & bytes_read
, 0);
6960 start
+= bytes_read
;
6962 /* A single zero is supposed to end the section according
6963 to the standard. If there's more, then signal that to
6966 return start
== end
? NULL
: start
;
6968 tag
= read_leb128 (start
, & bytes_read
, 0);
6969 start
+= bytes_read
;
6971 children
= *start
++;
6973 add_abbrev (entry
, tag
, children
);
6979 attribute
= read_leb128 (start
, & bytes_read
, 0);
6980 start
+= bytes_read
;
6982 form
= read_leb128 (start
, & bytes_read
, 0);
6983 start
+= bytes_read
;
6986 add_abbrev_attr (attribute
, form
);
6988 while (attribute
!= 0);
6996 display_debug_macinfo (Elf_Internal_Shdr
*section
,
6997 unsigned char *start
,
6998 FILE *file ATTRIBUTE_UNUSED
)
7000 unsigned char *end
= start
+ section
->sh_size
;
7001 unsigned char *curr
= start
;
7002 unsigned int bytes_read
;
7003 enum dwarf_macinfo_record_type op
;
7005 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7009 unsigned int lineno
;
7017 case DW_MACINFO_start_file
:
7019 unsigned int filenum
;
7021 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7023 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7026 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7030 case DW_MACINFO_end_file
:
7031 printf (_(" DW_MACINFO_end_file\n"));
7034 case DW_MACINFO_define
:
7035 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7038 curr
+= strlen (string
) + 1;
7039 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7042 case DW_MACINFO_undef
:
7043 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7046 curr
+= strlen (string
) + 1;
7047 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7050 case DW_MACINFO_vendor_ext
:
7052 unsigned int constant
;
7054 constant
= read_leb128 (curr
, & bytes_read
, 0);
7057 curr
+= strlen (string
) + 1;
7058 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7069 display_debug_abbrev (Elf_Internal_Shdr
*section
,
7070 unsigned char *start
,
7071 FILE *file ATTRIBUTE_UNUSED
)
7073 abbrev_entry
*entry
;
7074 unsigned char *end
= start
+ section
->sh_size
;
7076 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7080 start
= process_abbrev_section (start
, end
);
7082 if (first_abbrev
== NULL
)
7085 printf (_(" Number TAG\n"));
7087 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7091 printf (_(" %ld %s [%s]\n"),
7093 get_TAG_name (entry
->tag
),
7094 entry
->children
? _("has children") : _("no children"));
7096 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7098 printf (_(" %-18s %s\n"),
7099 get_AT_name (attr
->attribute
),
7100 get_FORM_name (attr
->form
));
7114 static unsigned char *
7115 display_block (unsigned char *data
, unsigned long length
)
7117 printf (_(" %lu byte block: "), length
);
7120 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7126 decode_location_expression (unsigned char * data
,
7127 unsigned int pointer_size
,
7128 unsigned long length
)
7132 unsigned long uvalue
;
7133 unsigned char *end
= data
+ length
;
7142 printf ("DW_OP_addr: %lx",
7143 (unsigned long) byte_get (data
, pointer_size
));
7144 data
+= pointer_size
;
7147 printf ("DW_OP_deref");
7150 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7153 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
7156 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7160 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
7164 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7168 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
7172 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7173 (unsigned long) byte_get (data
+ 4, 4));
7177 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7178 (long) byte_get (data
+ 4, 4));
7182 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7186 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7190 printf ("DW_OP_dup");
7193 printf ("DW_OP_drop");
7196 printf ("DW_OP_over");
7199 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7202 printf ("DW_OP_swap");
7205 printf ("DW_OP_rot");
7208 printf ("DW_OP_xderef");
7211 printf ("DW_OP_abs");
7214 printf ("DW_OP_and");
7217 printf ("DW_OP_div");
7220 printf ("DW_OP_minus");
7223 printf ("DW_OP_mod");
7226 printf ("DW_OP_mul");
7229 printf ("DW_OP_neg");
7232 printf ("DW_OP_not");
7235 printf ("DW_OP_or");
7238 printf ("DW_OP_plus");
7240 case DW_OP_plus_uconst
:
7241 printf ("DW_OP_plus_uconst: %lu",
7242 read_leb128 (data
, &bytes_read
, 0));
7246 printf ("DW_OP_shl");
7249 printf ("DW_OP_shr");
7252 printf ("DW_OP_shra");
7255 printf ("DW_OP_xor");
7258 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
7262 printf ("DW_OP_eq");
7265 printf ("DW_OP_ge");
7268 printf ("DW_OP_gt");
7271 printf ("DW_OP_le");
7274 printf ("DW_OP_lt");
7277 printf ("DW_OP_ne");
7280 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
7316 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7351 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7386 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7387 read_leb128 (data
, &bytes_read
, 1));
7392 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7396 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7400 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7402 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7403 read_leb128 (data
, &bytes_read
, 1));
7407 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7410 case DW_OP_deref_size
:
7411 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7413 case DW_OP_xderef_size
:
7414 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7417 printf ("DW_OP_nop");
7420 /* DWARF 3 extensions. */
7421 case DW_OP_push_object_address
:
7422 printf ("DW_OP_push_object_address");
7425 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7429 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7432 case DW_OP_call_ref
:
7433 printf ("DW_OP_call_ref");
7436 /* GNU extensions. */
7437 case DW_OP_GNU_push_tls_address
:
7438 printf ("DW_OP_GNU_push_tls_address");
7442 if (op
>= DW_OP_lo_user
7443 && op
<= DW_OP_hi_user
)
7444 printf (_("(User defined location op)"));
7446 printf (_("(Unknown location op)"));
7447 /* No way to tell where the next op is, so just bail. */
7451 /* Separate the ops. */
7457 static const char *debug_loc_contents
;
7458 static bfd_vma debug_loc_size
;
7461 load_debug_loc (FILE *file
)
7463 Elf_Internal_Shdr
*sec
;
7466 /* If it is already loaded, do nothing. */
7467 if (debug_loc_contents
!= NULL
)
7470 /* Locate the .debug_loc section. */
7471 for (i
= 0, sec
= section_headers
;
7472 i
< elf_header
.e_shnum
;
7474 if (strcmp (SECTION_NAME (sec
), ".debug_loc") == 0)
7477 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7480 debug_loc_size
= sec
->sh_size
;
7482 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7483 _("debug_loc section data"));
7487 free_debug_loc (void)
7489 if (debug_loc_contents
== NULL
)
7492 free ((char *) debug_loc_contents
);
7493 debug_loc_contents
= NULL
;
7499 display_debug_loc (Elf_Internal_Shdr
*section
,
7500 unsigned char *start
,
7501 FILE *file ATTRIBUTE_UNUSED
)
7503 unsigned char *section_end
;
7504 unsigned long bytes
;
7505 unsigned char *section_begin
= start
;
7508 addr
= section
->sh_addr
;
7509 bytes
= section
->sh_size
;
7510 section_end
= start
+ bytes
;
7514 printf (_("\nThe .debug_loc section is empty.\n"));
7518 printf (_("Contents of the .debug_loc section:\n\n"));
7519 printf (_("\n Offset Begin End Expression\n"));
7521 while (start
< section_end
)
7523 unsigned long begin
;
7525 unsigned short length
;
7526 unsigned long offset
;
7528 offset
= start
- section_begin
;
7532 /* Normally, the lists in the debug_loc section are related to a
7533 given compilation unit, and thus, we would use the pointer size
7534 of that compilation unit. However, since we are displaying it
7535 seperately here, we either have to store pointer sizes of all
7536 compilation units, or assume they don't change. We assume,
7537 like the debug_line display, that it doesn't change. */
7538 begin
= byte_get (start
, debug_line_pointer_size
);
7539 start
+= debug_line_pointer_size
;
7540 end
= byte_get (start
, debug_line_pointer_size
);
7541 start
+= debug_line_pointer_size
;
7543 if (begin
== 0 && end
== 0)
7546 /* For now, skip any base address specifiers. */
7547 if (begin
== 0xffffffff)
7553 length
= byte_get (start
, 2);
7556 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
7557 decode_location_expression (start
, debug_line_pointer_size
, length
);
7567 static const char *debug_str_contents
;
7568 static bfd_vma debug_str_size
;
7571 load_debug_str (FILE *file
)
7573 Elf_Internal_Shdr
*sec
;
7576 /* If it is already loaded, do nothing. */
7577 if (debug_str_contents
!= NULL
)
7580 /* Locate the .debug_str section. */
7581 for (i
= 0, sec
= section_headers
;
7582 i
< elf_header
.e_shnum
;
7584 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0)
7587 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7590 debug_str_size
= sec
->sh_size
;
7592 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7593 _("debug_str section data"));
7597 free_debug_str (void)
7599 if (debug_str_contents
== NULL
)
7602 free ((char *) debug_str_contents
);
7603 debug_str_contents
= NULL
;
7608 fetch_indirect_string (unsigned long offset
)
7610 if (debug_str_contents
== NULL
)
7611 return _("<no .debug_str section>");
7613 if (offset
> debug_str_size
)
7614 return _("<offset is too big>");
7616 return debug_str_contents
+ offset
;
7620 display_debug_str (Elf_Internal_Shdr
*section
,
7621 unsigned char *start
,
7622 FILE *file ATTRIBUTE_UNUSED
)
7624 unsigned long bytes
;
7627 addr
= section
->sh_addr
;
7628 bytes
= section
->sh_size
;
7632 printf (_("\nThe .debug_str section is empty.\n"));
7636 printf (_("Contents of the .debug_str section:\n\n"));
7644 lbytes
= (bytes
> 16 ? 16 : bytes
);
7646 printf (" 0x%8.8lx ", (unsigned long) addr
);
7648 for (j
= 0; j
< 16; j
++)
7651 printf ("%2.2x", start
[j
]);
7659 for (j
= 0; j
< lbytes
; j
++)
7662 if (k
>= ' ' && k
< 0x80)
7678 static unsigned char *
7679 read_and_display_attr_value (unsigned long attribute
,
7681 unsigned char *data
,
7682 unsigned long cu_offset
,
7683 unsigned long pointer_size
,
7684 unsigned long offset_size
,
7687 unsigned long uvalue
= 0;
7688 unsigned char *block_start
= NULL
;
7696 case DW_FORM_ref_addr
:
7697 if (dwarf_version
== 2)
7699 uvalue
= byte_get (data
, pointer_size
);
7700 data
+= pointer_size
;
7702 else if (dwarf_version
== 3)
7704 uvalue
= byte_get (data
, offset_size
);
7705 data
+= offset_size
;
7709 error (_("Internal error: DWARF version is not 2 or 3.\n"));
7714 uvalue
= byte_get (data
, pointer_size
);
7715 data
+= pointer_size
;
7719 uvalue
= byte_get (data
, offset_size
);
7720 data
+= offset_size
;
7726 uvalue
= byte_get (data
++, 1);
7731 uvalue
= byte_get (data
, 2);
7737 uvalue
= byte_get (data
, 4);
7742 uvalue
= read_leb128 (data
, & bytes_read
, 1);
7746 case DW_FORM_ref_udata
:
7748 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7752 case DW_FORM_indirect
:
7753 form
= read_leb128 (data
, & bytes_read
, 0);
7755 printf (" %s", get_FORM_name (form
));
7756 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7757 pointer_size
, offset_size
,
7763 case DW_FORM_ref_addr
:
7764 printf (" <#%lx>", uvalue
);
7770 case DW_FORM_ref_udata
:
7771 printf (" <%lx>", uvalue
+ cu_offset
);
7775 printf (" %#lx", uvalue
);
7783 printf (" %ld", uvalue
);
7788 uvalue
= byte_get (data
, 4);
7789 printf (" %lx", uvalue
);
7790 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7794 case DW_FORM_string
:
7795 printf (" %s", data
);
7796 data
+= strlen ((char *) data
) + 1;
7800 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7801 block_start
= data
+ bytes_read
;
7802 data
= display_block (block_start
, uvalue
);
7805 case DW_FORM_block1
:
7806 uvalue
= byte_get (data
, 1);
7807 block_start
= data
+ 1;
7808 data
= display_block (block_start
, uvalue
);
7811 case DW_FORM_block2
:
7812 uvalue
= byte_get (data
, 2);
7813 block_start
= data
+ 2;
7814 data
= display_block (block_start
, uvalue
);
7817 case DW_FORM_block4
:
7818 uvalue
= byte_get (data
, 4);
7819 block_start
= data
+ 4;
7820 data
= display_block (block_start
, uvalue
);
7824 printf (_(" (indirect string, offset: 0x%lx): %s"),
7825 uvalue
, fetch_indirect_string (uvalue
));
7828 case DW_FORM_indirect
:
7829 /* Handled above. */
7833 warn (_("Unrecognized form: %d\n"), form
);
7837 /* For some attributes we can display futher information. */
7846 case DW_INL_not_inlined
:
7847 printf (_("(not inlined)"));
7849 case DW_INL_inlined
:
7850 printf (_("(inlined)"));
7852 case DW_INL_declared_not_inlined
:
7853 printf (_("(declared as inline but ignored)"));
7855 case DW_INL_declared_inlined
:
7856 printf (_("(declared as inline and inlined)"));
7859 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
7864 case DW_AT_language
:
7867 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7868 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7869 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7870 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7871 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7872 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7873 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7874 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7875 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7876 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7877 /* DWARF 2.1 values. */
7878 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7879 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7880 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7881 /* MIPS extension. */
7882 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7883 /* UPC extension. */
7884 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
7886 printf ("(Unknown: %lx)", uvalue
);
7891 case DW_AT_encoding
:
7894 case DW_ATE_void
: printf ("(void)"); break;
7895 case DW_ATE_address
: printf ("(machine address)"); break;
7896 case DW_ATE_boolean
: printf ("(boolean)"); break;
7897 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7898 case DW_ATE_float
: printf ("(float)"); break;
7899 case DW_ATE_signed
: printf ("(signed)"); break;
7900 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7901 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7902 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7903 /* DWARF 2.1 value. */
7904 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7906 if (uvalue
>= DW_ATE_lo_user
7907 && uvalue
<= DW_ATE_hi_user
)
7908 printf ("(user defined type)");
7910 printf ("(unknown type)");
7915 case DW_AT_accessibility
:
7918 case DW_ACCESS_public
: printf ("(public)"); break;
7919 case DW_ACCESS_protected
: printf ("(protected)"); break;
7920 case DW_ACCESS_private
: printf ("(private)"); break;
7922 printf ("(unknown accessibility)");
7927 case DW_AT_visibility
:
7930 case DW_VIS_local
: printf ("(local)"); break;
7931 case DW_VIS_exported
: printf ("(exported)"); break;
7932 case DW_VIS_qualified
: printf ("(qualified)"); break;
7933 default: printf ("(unknown visibility)"); break;
7937 case DW_AT_virtuality
:
7940 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7941 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7942 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7943 default: printf ("(unknown virtuality)"); break;
7947 case DW_AT_identifier_case
:
7950 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7951 case DW_ID_up_case
: printf ("(up_case)"); break;
7952 case DW_ID_down_case
: printf ("(down_case)"); break;
7953 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7954 default: printf ("(unknown case)"); break;
7958 case DW_AT_calling_convention
:
7961 case DW_CC_normal
: printf ("(normal)"); break;
7962 case DW_CC_program
: printf ("(program)"); break;
7963 case DW_CC_nocall
: printf ("(nocall)"); break;
7965 if (uvalue
>= DW_CC_lo_user
7966 && uvalue
<= DW_CC_hi_user
)
7967 printf ("(user defined)");
7969 printf ("(unknown convention)");
7973 case DW_AT_ordering
:
7976 case -1: printf ("(undefined)"); break;
7977 case 0: printf ("(row major)"); break;
7978 case 1: printf ("(column major)"); break;
7982 case DW_AT_frame_base
:
7983 case DW_AT_location
:
7984 case DW_AT_data_member_location
:
7985 case DW_AT_vtable_elem_location
:
7986 case DW_AT_allocated
:
7987 case DW_AT_associated
:
7988 case DW_AT_data_location
:
7990 case DW_AT_upper_bound
:
7991 case DW_AT_lower_bound
:
7995 decode_location_expression (block_start
, pointer_size
, uvalue
);
7998 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8001 printf ("location list");
8013 static unsigned char *
8014 read_and_display_attr (unsigned long attribute
,
8016 unsigned char *data
,
8017 unsigned long cu_offset
,
8018 unsigned long pointer_size
,
8019 unsigned long offset_size
,
8022 printf (" %-18s:", get_AT_name (attribute
));
8023 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8024 pointer_size
, offset_size
, dwarf_version
);
8030 display_debug_info (Elf_Internal_Shdr
*section
,
8031 unsigned char *start
,
8034 unsigned char *end
= start
+ section
->sh_size
;
8035 unsigned char *section_begin
= start
;
8037 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8039 load_debug_str (file
);
8040 load_debug_loc (file
);
8044 DWARF2_Internal_CompUnit compunit
;
8045 Elf_Internal_Shdr
*relsec
;
8046 unsigned char *hdrptr
;
8047 unsigned char *cu_abbrev_offset_ptr
;
8048 unsigned char *tags
;
8051 unsigned long cu_offset
;
8053 int initial_length_size
;
8057 compunit
.cu_length
= byte_get (hdrptr
, 4);
8060 if (compunit
.cu_length
== 0xffffffff)
8062 compunit
.cu_length
= byte_get (hdrptr
, 8);
8065 initial_length_size
= 12;
8070 initial_length_size
= 4;
8073 compunit
.cu_version
= byte_get (hdrptr
, 2);
8076 /* Apply addends of RELA relocations. */
8077 for (relsec
= section_headers
;
8078 relsec
< section_headers
+ elf_header
.e_shnum
;
8081 unsigned long nrelas
;
8082 Elf_Internal_Rela
*rela
, *rp
;
8083 Elf_Internal_Shdr
*symsec
;
8084 Elf_Internal_Sym
*symtab
;
8085 Elf_Internal_Sym
*sym
;
8087 if (relsec
->sh_type
!= SHT_RELA
8088 || SECTION_HEADER (relsec
->sh_info
) != section
8089 || relsec
->sh_size
== 0)
8092 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8096 symsec
= SECTION_HEADER (relsec
->sh_link
);
8097 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8099 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8103 if (rp
->r_offset
>= (bfd_vma
) (hdrptr
- section_begin
)
8104 && section
->sh_size
> (bfd_vma
) offset_size
8105 && rp
->r_offset
<= section
->sh_size
- offset_size
)
8106 loc
= section_begin
+ rp
->r_offset
;
8112 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8114 if (ELF32_R_SYM (rp
->r_info
) != 0
8115 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8117 warn (_("Skipping unexpected symbol type %u\n"),
8118 ELF32_ST_TYPE (sym
->st_info
));
8124 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8126 if (ELF64_R_SYM (rp
->r_info
) != 0
8127 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8129 warn (_("Skipping unexpected symbol type %u\n"),
8130 ELF64_ST_TYPE (sym
->st_info
));
8135 byte_put (loc
, rp
->r_addend
, offset_size
);
8142 cu_abbrev_offset_ptr
= hdrptr
;
8143 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8144 hdrptr
+= offset_size
;
8146 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8150 cu_offset
= start
- section_begin
;
8151 start
+= compunit
.cu_length
+ initial_length_size
;
8153 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8154 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8155 printf (_(" Version: %d\n"), compunit
.cu_version
);
8156 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8157 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8159 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8161 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8167 /* Read in the abbrevs used by this compilation unit. */
8169 Elf_Internal_Shdr
*sec
;
8170 unsigned char *begin
;
8172 /* Locate the .debug_abbrev section and process it. */
8173 for (i
= 0, sec
= section_headers
;
8174 i
< elf_header
.e_shnum
;
8176 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
8179 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
8181 warn (_("Unable to locate .debug_abbrev section!\n"));
8185 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8186 _("debug_abbrev section data"));
8190 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8191 begin
+ sec
->sh_size
);
8197 while (tags
< start
)
8200 unsigned long abbrev_number
;
8201 abbrev_entry
*entry
;
8204 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8207 /* A null DIE marks the end of a list of children. */
8208 if (abbrev_number
== 0)
8214 /* Scan through the abbreviation list until we reach the
8216 for (entry
= first_abbrev
;
8217 entry
&& entry
->entry
!= abbrev_number
;
8218 entry
= entry
->next
)
8223 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8228 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8230 (unsigned long) (tags
- section_begin
- bytes_read
),
8232 get_TAG_name (entry
->tag
));
8234 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8235 tags
= read_and_display_attr (attr
->attribute
,
8238 compunit
.cu_pointer_size
,
8240 compunit
.cu_version
);
8242 if (entry
->children
)
8256 display_debug_aranges (Elf_Internal_Shdr
*section
,
8257 unsigned char *start
,
8258 FILE *file ATTRIBUTE_UNUSED
)
8260 unsigned char *end
= start
+ section
->sh_size
;
8262 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8266 unsigned char *hdrptr
;
8267 DWARF2_Internal_ARange arange
;
8268 unsigned char *ranges
;
8269 unsigned long length
;
8270 unsigned long address
;
8273 int initial_length_size
;
8277 arange
.ar_length
= byte_get (hdrptr
, 4);
8280 if (arange
.ar_length
== 0xffffffff)
8282 arange
.ar_length
= byte_get (hdrptr
, 8);
8285 initial_length_size
= 12;
8290 initial_length_size
= 4;
8293 arange
.ar_version
= byte_get (hdrptr
, 2);
8296 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
8297 hdrptr
+= offset_size
;
8299 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
8302 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
8305 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
8307 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8311 printf (_(" Length: %ld\n"), arange
.ar_length
);
8312 printf (_(" Version: %d\n"), arange
.ar_version
);
8313 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8314 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8315 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8317 printf (_("\n Address Length\n"));
8321 /* Must pad to an alignment boundary that is twice the pointer size. */
8322 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
8324 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8328 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8330 ranges
+= arange
.ar_pointer_size
;
8332 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8334 ranges
+= arange
.ar_pointer_size
;
8336 /* A pair of zeros marks the end of the list. */
8337 if (address
== 0 && length
== 0)
8340 printf (" %8.8lx %lu\n", address
, length
);
8343 start
+= arange
.ar_length
+ initial_length_size
;
8351 typedef struct Frame_Chunk
8353 struct Frame_Chunk
*next
;
8354 unsigned char *chunk_start
;
8356 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8357 short int *col_type
;
8360 unsigned int code_factor
;
8362 unsigned long pc_begin
;
8363 unsigned long pc_range
;
8367 unsigned char fde_encoding
;
8368 unsigned char cfa_exp
;
8372 /* A marker for a col_type that means this column was never referenced
8373 in the frame info. */
8374 #define DW_CFA_unreferenced (-1)
8377 frame_need_space (Frame_Chunk
*fc
, int reg
)
8379 int prev
= fc
->ncols
;
8381 if (reg
< fc
->ncols
)
8384 fc
->ncols
= reg
+ 1;
8385 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
8386 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
8388 while (prev
< fc
->ncols
)
8390 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8391 fc
->col_offset
[prev
] = 0;
8397 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
8402 if (*max_regs
< fc
->ncols
)
8403 *max_regs
= fc
->ncols
;
8405 if (*need_col_headers
)
8407 *need_col_headers
= 0;
8409 printf (" LOC CFA ");
8411 for (r
= 0; r
< *max_regs
; r
++)
8412 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8417 printf ("r%-4d", r
);
8423 printf ("%08lx ", fc
->pc_begin
);
8425 strcpy (tmp
, "exp");
8427 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8428 printf ("%-8s ", tmp
);
8430 for (r
= 0; r
< fc
->ncols
; r
++)
8432 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8434 switch (fc
->col_type
[r
])
8436 case DW_CFA_undefined
:
8439 case DW_CFA_same_value
:
8443 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8445 case DW_CFA_register
:
8446 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8448 case DW_CFA_expression
:
8449 strcpy (tmp
, "exp");
8452 strcpy (tmp
, "n/a");
8455 printf ("%-5s", tmp
);
8462 size_of_encoded_value (int encoding
)
8464 switch (encoding
& 0x7)
8467 case 0: return is_32bit_elf
? 4 : 8;
8475 get_encoded_value (unsigned char *data
, int encoding
)
8477 int size
= size_of_encoded_value (encoding
);
8478 if (encoding
& DW_EH_PE_signed
)
8479 return byte_get_signed (data
, size
);
8481 return byte_get (data
, size
);
8484 #define GET(N) byte_get (start, N); start += N
8485 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
8486 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
8489 display_debug_frames (Elf_Internal_Shdr
*section
,
8490 unsigned char *start
,
8491 FILE *file ATTRIBUTE_UNUSED
)
8493 unsigned char *end
= start
+ section
->sh_size
;
8494 unsigned char *section_start
= start
;
8495 Frame_Chunk
*chunks
= 0;
8496 Frame_Chunk
*remembered_state
= 0;
8498 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
8501 int addr_size
= is_32bit_elf
? 4 : 8;
8503 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
8507 unsigned char *saved_start
;
8508 unsigned char *block_end
;
8509 unsigned long length
;
8510 unsigned long cie_id
;
8513 int need_col_headers
= 1;
8514 unsigned char *augmentation_data
= NULL
;
8515 unsigned long augmentation_data_len
= 0;
8516 int encoded_ptr_size
= addr_size
;
8518 int initial_length_size
;
8520 saved_start
= start
;
8521 length
= byte_get (start
, 4); start
+= 4;
8525 printf ("\n%08lx ZERO terminator\n\n",
8526 (unsigned long)(saved_start
- section_start
));
8530 if (length
== 0xffffffff)
8532 length
= byte_get (start
, 8);
8535 initial_length_size
= 12;
8540 initial_length_size
= 4;
8543 block_end
= saved_start
+ length
+ initial_length_size
;
8544 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
8546 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
8550 fc
= xmalloc (sizeof (Frame_Chunk
));
8551 memset (fc
, 0, sizeof (Frame_Chunk
));
8555 fc
->chunk_start
= saved_start
;
8557 fc
->col_type
= xmalloc (sizeof (short int));
8558 fc
->col_offset
= xmalloc (sizeof (int));
8559 frame_need_space (fc
, max_regs
-1);
8563 fc
->augmentation
= start
;
8564 start
= strchr (start
, '\0') + 1;
8566 if (fc
->augmentation
[0] == 'z')
8568 fc
->code_factor
= LEB ();
8569 fc
->data_factor
= SLEB ();
8570 fc
->ra
= byte_get (start
, 1); start
+= 1;
8571 augmentation_data_len
= LEB ();
8572 augmentation_data
= start
;
8573 start
+= augmentation_data_len
;
8575 else if (strcmp (fc
->augmentation
, "eh") == 0)
8578 fc
->code_factor
= LEB ();
8579 fc
->data_factor
= SLEB ();
8580 fc
->ra
= byte_get (start
, 1); start
+= 1;
8584 fc
->code_factor
= LEB ();
8585 fc
->data_factor
= SLEB ();
8586 fc
->ra
= byte_get (start
, 1); start
+= 1;
8590 if (do_debug_frames_interp
)
8591 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
8592 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8593 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
8597 printf ("\n%08lx %08lx %08lx CIE\n",
8598 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
8599 printf (" Version: %d\n", version
);
8600 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
8601 printf (" Code alignment factor: %u\n", fc
->code_factor
);
8602 printf (" Data alignment factor: %d\n", fc
->data_factor
);
8603 printf (" Return address column: %d\n", fc
->ra
);
8605 if (augmentation_data_len
)
8608 printf (" Augmentation data: ");
8609 for (i
= 0; i
< augmentation_data_len
; ++i
)
8610 printf (" %02x", augmentation_data
[i
]);
8616 if (augmentation_data_len
)
8618 unsigned char *p
, *q
;
8619 p
= fc
->augmentation
+ 1;
8620 q
= augmentation_data
;
8627 q
+= 1 + size_of_encoded_value (*q
);
8629 fc
->fde_encoding
= *q
++;
8635 if (fc
->fde_encoding
)
8636 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8639 frame_need_space (fc
, fc
->ra
);
8643 unsigned char *look_for
;
8644 static Frame_Chunk fde_fc
;
8647 memset (fc
, 0, sizeof (Frame_Chunk
));
8649 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
8651 for (cie
= chunks
; cie
; cie
= cie
->next
)
8652 if (cie
->chunk_start
== look_for
)
8657 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
8658 cie_id
, saved_start
);
8661 fc
->col_type
= xmalloc (sizeof (short int));
8662 fc
->col_offset
= xmalloc (sizeof (int));
8663 frame_need_space (fc
, max_regs
- 1);
8665 fc
->augmentation
= "";
8666 fc
->fde_encoding
= 0;
8670 fc
->ncols
= cie
->ncols
;
8671 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
8672 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
8673 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
8674 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
8675 fc
->augmentation
= cie
->augmentation
;
8676 fc
->code_factor
= cie
->code_factor
;
8677 fc
->data_factor
= cie
->data_factor
;
8678 fc
->cfa_reg
= cie
->cfa_reg
;
8679 fc
->cfa_offset
= cie
->cfa_offset
;
8681 frame_need_space (fc
, max_regs
-1);
8682 fc
->fde_encoding
= cie
->fde_encoding
;
8685 if (fc
->fde_encoding
)
8686 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
8688 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
8689 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8690 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
8691 start
+= encoded_ptr_size
;
8692 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
8693 start
+= encoded_ptr_size
;
8695 if (cie
->augmentation
[0] == 'z')
8697 augmentation_data_len
= LEB ();
8698 augmentation_data
= start
;
8699 start
+= augmentation_data_len
;
8702 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
8703 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
8704 (unsigned long)(cie
->chunk_start
- section_start
),
8705 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
8706 if (! do_debug_frames_interp
&& augmentation_data_len
)
8709 printf (" Augmentation data: ");
8710 for (i
= 0; i
< augmentation_data_len
; ++i
)
8711 printf (" %02x", augmentation_data
[i
]);
8717 /* At this point, fc is the current chunk, cie (if any) is set, and we're
8718 about to interpret instructions for the chunk. */
8719 /* ??? At present we need to do this always, since this sizes the
8720 fc->col_type and fc->col_offset arrays, which we write into always.
8721 We should probably split the interpreted and non-interpreted bits
8722 into two different routines, since there's so much that doesn't
8723 really overlap between them. */
8724 if (1 || do_debug_frames_interp
)
8726 /* Start by making a pass over the chunk, allocating storage
8727 and taking note of what registers are used. */
8728 unsigned char *tmp
= start
;
8730 while (start
< block_end
)
8733 unsigned long reg
, tmp
;
8740 /* Warning: if you add any more cases to this switch, be
8741 sure to add them to the corresponding switch below. */
8744 case DW_CFA_advance_loc
:
8748 frame_need_space (fc
, opa
);
8749 fc
->col_type
[opa
] = DW_CFA_undefined
;
8751 case DW_CFA_restore
:
8752 frame_need_space (fc
, opa
);
8753 fc
->col_type
[opa
] = DW_CFA_undefined
;
8755 case DW_CFA_set_loc
:
8756 start
+= encoded_ptr_size
;
8758 case DW_CFA_advance_loc1
:
8761 case DW_CFA_advance_loc2
:
8764 case DW_CFA_advance_loc4
:
8767 case DW_CFA_offset_extended
:
8768 reg
= LEB (); LEB ();
8769 frame_need_space (fc
, reg
);
8770 fc
->col_type
[reg
] = DW_CFA_undefined
;
8772 case DW_CFA_restore_extended
:
8774 frame_need_space (fc
, reg
);
8775 fc
->col_type
[reg
] = DW_CFA_undefined
;
8777 case DW_CFA_undefined
:
8779 frame_need_space (fc
, reg
);
8780 fc
->col_type
[reg
] = DW_CFA_undefined
;
8782 case DW_CFA_same_value
:
8784 frame_need_space (fc
, reg
);
8785 fc
->col_type
[reg
] = DW_CFA_undefined
;
8787 case DW_CFA_register
:
8788 reg
= LEB (); LEB ();
8789 frame_need_space (fc
, reg
);
8790 fc
->col_type
[reg
] = DW_CFA_undefined
;
8792 case DW_CFA_def_cfa
:
8795 case DW_CFA_def_cfa_register
:
8798 case DW_CFA_def_cfa_offset
:
8801 case DW_CFA_def_cfa_expression
:
8805 case DW_CFA_expression
:
8809 frame_need_space (fc
, reg
);
8810 fc
->col_type
[reg
] = DW_CFA_undefined
;
8812 case DW_CFA_offset_extended_sf
:
8813 reg
= LEB (); SLEB ();
8814 frame_need_space (fc
, reg
);
8815 fc
->col_type
[reg
] = DW_CFA_undefined
;
8817 case DW_CFA_def_cfa_sf
:
8820 case DW_CFA_def_cfa_offset_sf
:
8823 case DW_CFA_MIPS_advance_loc8
:
8826 case DW_CFA_GNU_args_size
:
8829 case DW_CFA_GNU_negative_offset_extended
:
8830 reg
= LEB (); LEB ();
8831 frame_need_space (fc
, reg
);
8832 fc
->col_type
[reg
] = DW_CFA_undefined
;
8841 /* Now we know what registers are used, make a second pass over
8842 the chunk, this time actually printing out the info. */
8844 while (start
< block_end
)
8847 unsigned long ul
, reg
, roffs
;
8856 /* Warning: if you add any more cases to this switch, be
8857 sure to add them to the corresponding switch above. */
8860 case DW_CFA_advance_loc
:
8861 if (do_debug_frames_interp
)
8862 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8864 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8865 opa
* fc
->code_factor
,
8866 fc
->pc_begin
+ opa
* fc
->code_factor
);
8867 fc
->pc_begin
+= opa
* fc
->code_factor
;
8872 if (! do_debug_frames_interp
)
8873 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8874 opa
, roffs
* fc
->data_factor
);
8875 fc
->col_type
[opa
] = DW_CFA_offset
;
8876 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8879 case DW_CFA_restore
:
8880 if (! do_debug_frames_interp
)
8881 printf (" DW_CFA_restore: r%d\n", opa
);
8882 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8883 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8886 case DW_CFA_set_loc
:
8887 vma
= get_encoded_value (start
, fc
->fde_encoding
);
8888 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
8889 vma
+= section
->sh_addr
+ (start
- section_start
);
8890 start
+= encoded_ptr_size
;
8891 if (do_debug_frames_interp
)
8892 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8894 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8898 case DW_CFA_advance_loc1
:
8899 ofs
= byte_get (start
, 1); start
+= 1;
8900 if (do_debug_frames_interp
)
8901 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8903 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8904 ofs
* fc
->code_factor
,
8905 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8906 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8909 case DW_CFA_advance_loc2
:
8910 ofs
= byte_get (start
, 2); start
+= 2;
8911 if (do_debug_frames_interp
)
8912 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8914 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8915 ofs
* fc
->code_factor
,
8916 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8917 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8920 case DW_CFA_advance_loc4
:
8921 ofs
= byte_get (start
, 4); start
+= 4;
8922 if (do_debug_frames_interp
)
8923 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8925 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8926 ofs
* fc
->code_factor
,
8927 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8928 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8931 case DW_CFA_offset_extended
:
8934 if (! do_debug_frames_interp
)
8935 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8936 reg
, roffs
* fc
->data_factor
);
8937 fc
->col_type
[reg
] = DW_CFA_offset
;
8938 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8941 case DW_CFA_restore_extended
:
8943 if (! do_debug_frames_interp
)
8944 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8945 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8946 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8949 case DW_CFA_undefined
:
8951 if (! do_debug_frames_interp
)
8952 printf (" DW_CFA_undefined: r%ld\n", reg
);
8953 fc
->col_type
[reg
] = DW_CFA_undefined
;
8954 fc
->col_offset
[reg
] = 0;
8957 case DW_CFA_same_value
:
8959 if (! do_debug_frames_interp
)
8960 printf (" DW_CFA_same_value: r%ld\n", reg
);
8961 fc
->col_type
[reg
] = DW_CFA_same_value
;
8962 fc
->col_offset
[reg
] = 0;
8965 case DW_CFA_register
:
8968 if (! do_debug_frames_interp
)
8969 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
8970 fc
->col_type
[reg
] = DW_CFA_register
;
8971 fc
->col_offset
[reg
] = roffs
;
8974 case DW_CFA_remember_state
:
8975 if (! do_debug_frames_interp
)
8976 printf (" DW_CFA_remember_state\n");
8977 rs
= xmalloc (sizeof (Frame_Chunk
));
8978 rs
->ncols
= fc
->ncols
;
8979 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
8980 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
8981 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8982 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8983 rs
->next
= remembered_state
;
8984 remembered_state
= rs
;
8987 case DW_CFA_restore_state
:
8988 if (! do_debug_frames_interp
)
8989 printf (" DW_CFA_restore_state\n");
8990 rs
= remembered_state
;
8991 remembered_state
= rs
->next
;
8992 frame_need_space (fc
, rs
->ncols
-1);
8993 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8994 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8995 free (rs
->col_type
);
8996 free (rs
->col_offset
);
9000 case DW_CFA_def_cfa
:
9001 fc
->cfa_reg
= LEB ();
9002 fc
->cfa_offset
= LEB ();
9004 if (! do_debug_frames_interp
)
9005 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9006 fc
->cfa_reg
, fc
->cfa_offset
);
9009 case DW_CFA_def_cfa_register
:
9010 fc
->cfa_reg
= LEB ();
9012 if (! do_debug_frames_interp
)
9013 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9016 case DW_CFA_def_cfa_offset
:
9017 fc
->cfa_offset
= LEB ();
9018 if (! do_debug_frames_interp
)
9019 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9023 if (! do_debug_frames_interp
)
9024 printf (" DW_CFA_nop\n");
9027 case DW_CFA_def_cfa_expression
:
9029 if (! do_debug_frames_interp
)
9031 printf (" DW_CFA_def_cfa_expression (");
9032 decode_location_expression (start
, addr_size
, ul
);
9039 case DW_CFA_expression
:
9042 if (! do_debug_frames_interp
)
9044 printf (" DW_CFA_expression: r%ld (", reg
);
9045 decode_location_expression (start
, addr_size
, ul
);
9048 fc
->col_type
[reg
] = DW_CFA_expression
;
9052 case DW_CFA_offset_extended_sf
:
9055 frame_need_space (fc
, reg
);
9056 if (! do_debug_frames_interp
)
9057 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9058 reg
, l
* fc
->data_factor
);
9059 fc
->col_type
[reg
] = DW_CFA_offset
;
9060 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9063 case DW_CFA_def_cfa_sf
:
9064 fc
->cfa_reg
= LEB ();
9065 fc
->cfa_offset
= SLEB ();
9067 if (! do_debug_frames_interp
)
9068 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9069 fc
->cfa_reg
, fc
->cfa_offset
);
9072 case DW_CFA_def_cfa_offset_sf
:
9073 fc
->cfa_offset
= SLEB ();
9074 if (! do_debug_frames_interp
)
9075 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9078 case DW_CFA_MIPS_advance_loc8
:
9079 ofs
= byte_get (start
, 8); start
+= 8;
9080 if (do_debug_frames_interp
)
9081 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9083 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9084 ofs
* fc
->code_factor
,
9085 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9086 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9089 case DW_CFA_GNU_window_save
:
9090 if (! do_debug_frames_interp
)
9091 printf (" DW_CFA_GNU_window_save\n");
9094 case DW_CFA_GNU_args_size
:
9096 if (! do_debug_frames_interp
)
9097 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9100 case DW_CFA_GNU_negative_offset_extended
:
9103 frame_need_space (fc
, reg
);
9104 if (! do_debug_frames_interp
)
9105 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9106 reg
, l
* fc
->data_factor
);
9107 fc
->col_type
[reg
] = DW_CFA_offset
;
9108 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9112 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9117 if (do_debug_frames_interp
)
9118 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9133 display_debug_not_supported (Elf_Internal_Shdr
*section
,
9134 unsigned char *start ATTRIBUTE_UNUSED
,
9135 FILE *file ATTRIBUTE_UNUSED
)
9137 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9138 SECTION_NAME (section
));
9143 /* Pre-scan the .debug_info section to record the size of address.
9144 When dumping the .debug_line, we use that size information, assuming
9145 that all compilation units have the same address size. */
9147 prescan_debug_info (Elf_Internal_Shdr
*section ATTRIBUTE_UNUSED
,
9148 unsigned char *start
,
9149 FILE *file ATTRIBUTE_UNUSED
)
9151 unsigned long length
;
9153 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
9154 be the length. For a 64-bit DWARF section, it'll be the escape
9155 code 0xffffffff followed by an 8 byte length. For the purposes
9156 of this prescan, we don't care about the actual length, but the
9157 presence of the escape bytes does affect the location of the byte
9158 which describes the address size. */
9159 length
= byte_get (start
, 4);
9161 if (length
== 0xffffffff)
9163 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
9164 from the start of the section. This is computed as follows:
9166 unit_length: 12 bytes
9168 debug_abbrev_offset: 8 bytes
9169 -----------------------------
9172 debug_line_pointer_size
= byte_get (start
+ 22, 1);
9176 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
9177 the start of the section:
9178 unit_length: 4 bytes
9180 debug_abbrev_offset: 4 bytes
9181 -----------------------------
9184 debug_line_pointer_size
= byte_get (start
+ 10, 1);
9189 /* A structure containing the name of a debug section and a pointer
9190 to a function that can decode it. The third field is a prescan
9191 function to be run over the section before displaying any of the
9195 const char *const name
;
9196 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
9197 int (*prescan
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
9201 { ".debug_abbrev", display_debug_abbrev
, NULL
},
9202 { ".debug_aranges", display_debug_aranges
, NULL
},
9203 { ".debug_frame", display_debug_frames
, NULL
},
9204 { ".debug_info", display_debug_info
, prescan_debug_info
},
9205 { ".debug_line", display_debug_lines
, NULL
},
9206 { ".debug_pubnames", display_debug_pubnames
, NULL
},
9207 { ".eh_frame", display_debug_frames
, NULL
},
9208 { ".debug_macinfo", display_debug_macinfo
, NULL
},
9209 { ".debug_str", display_debug_str
, NULL
},
9210 { ".debug_loc", display_debug_loc
, NULL
},
9211 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
9212 { ".debug_ranges", display_debug_not_supported
, NULL
},
9213 { ".debug_static_func", display_debug_not_supported
, NULL
},
9214 { ".debug_static_vars", display_debug_not_supported
, NULL
},
9215 { ".debug_types", display_debug_not_supported
, NULL
},
9216 { ".debug_weaknames", display_debug_not_supported
, NULL
}
9220 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
9222 char *name
= SECTION_NAME (section
);
9223 bfd_size_type length
;
9224 unsigned char *start
;
9227 length
= section
->sh_size
;
9230 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9234 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
9235 _("debug section data"));
9239 /* See if we know how to display the contents of this section. */
9240 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9241 name
= ".debug_info";
9243 for (i
= NUM_ELEM (debug_displays
); i
--;)
9244 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9246 debug_displays
[i
].display (section
, start
, file
);
9251 printf (_("Unrecognized debug section: %s\n"), name
);
9255 /* If we loaded in the abbrev section at some point,
9256 we must release it here. */
9263 process_section_contents (FILE *file
)
9265 Elf_Internal_Shdr
*section
;
9271 /* Pre-scan the debug sections to find some debug information not
9272 present in some of them. For the .debug_line, we must find out the
9273 size of address (specified in .debug_info and .debug_aranges). */
9274 for (i
= 0, section
= section_headers
;
9275 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9278 char *name
= SECTION_NAME (section
);
9281 if (section
->sh_size
== 0)
9284 /* See if there is some pre-scan operation for this section. */
9285 for (j
= NUM_ELEM (debug_displays
); j
--;)
9286 if (strcmp (debug_displays
[j
].name
, name
) == 0)
9288 if (debug_displays
[j
].prescan
!= NULL
)
9290 bfd_size_type length
;
9291 unsigned char *start
;
9293 length
= section
->sh_size
;
9294 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
9295 _("debug section data"));
9299 debug_displays
[j
].prescan (section
, start
, file
);
9307 for (i
= 0, section
= section_headers
;
9308 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9311 #ifdef SUPPORT_DISASSEMBLY
9312 if (dump_sects
[i
] & DISASS_DUMP
)
9313 disassemble_section (section
, file
);
9315 if (dump_sects
[i
] & HEX_DUMP
)
9316 dump_section (section
, file
);
9318 if (dump_sects
[i
] & DEBUG_DUMP
)
9319 display_debug_section (section
, file
);
9322 if (i
< num_dump_sects
)
9323 warn (_("Some sections were not dumped because they do not exist!\n"));
9329 process_mips_fpe_exception (int mask
)
9334 if (mask
& OEX_FPU_INEX
)
9335 fputs ("INEX", stdout
), first
= 0;
9336 if (mask
& OEX_FPU_UFLO
)
9337 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9338 if (mask
& OEX_FPU_OFLO
)
9339 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9340 if (mask
& OEX_FPU_DIV0
)
9341 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9342 if (mask
& OEX_FPU_INVAL
)
9343 printf ("%sINVAL", first
? "" : "|");
9346 fputs ("0", stdout
);
9350 process_mips_specific (FILE *file
)
9352 Elf_Internal_Dyn
*entry
;
9353 size_t liblist_offset
= 0;
9354 size_t liblistno
= 0;
9355 size_t conflictsno
= 0;
9356 size_t options_offset
= 0;
9357 size_t conflicts_offset
= 0;
9359 /* We have a lot of special sections. Thanks SGI! */
9360 if (dynamic_segment
== NULL
)
9361 /* No information available. */
9364 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
9365 switch (entry
->d_tag
)
9367 case DT_MIPS_LIBLIST
:
9369 = offset_from_vma (file
, entry
->d_un
.d_val
,
9370 liblistno
* sizeof (Elf32_External_Lib
));
9372 case DT_MIPS_LIBLISTNO
:
9373 liblistno
= entry
->d_un
.d_val
;
9375 case DT_MIPS_OPTIONS
:
9376 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9378 case DT_MIPS_CONFLICT
:
9380 = offset_from_vma (file
, entry
->d_un
.d_val
,
9381 conflictsno
* sizeof (Elf32_External_Conflict
));
9383 case DT_MIPS_CONFLICTNO
:
9384 conflictsno
= entry
->d_un
.d_val
;
9390 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9392 Elf32_External_Lib
*elib
;
9395 elib
= get_data (NULL
, file
, liblist_offset
,
9396 liblistno
* sizeof (Elf32_External_Lib
),
9400 printf ("\nSection '.liblist' contains %lu entries:\n",
9401 (unsigned long) liblistno
);
9402 fputs (" Library Time Stamp Checksum Version Flags\n",
9405 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9412 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9413 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9414 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9415 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9416 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9418 tmp
= gmtime (&time
);
9419 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9420 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9421 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9423 printf ("%3lu: ", (unsigned long) cnt
);
9424 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9425 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9428 if (liblist
.l_flags
== 0)
9439 { " EXACT_MATCH", LL_EXACT_MATCH
},
9440 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9441 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9442 { " EXPORTS", LL_EXPORTS
},
9443 { " DELAY_LOAD", LL_DELAY_LOAD
},
9444 { " DELTA", LL_DELTA
}
9446 int flags
= liblist
.l_flags
;
9450 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9452 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9454 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9455 flags
^= l_flags_vals
[fcnt
].bit
;
9458 printf (" %#x", (unsigned int) flags
);
9468 if (options_offset
!= 0)
9470 Elf_External_Options
*eopt
;
9471 Elf_Internal_Shdr
*sect
= section_headers
;
9472 Elf_Internal_Options
*iopt
;
9473 Elf_Internal_Options
*option
;
9477 /* Find the section header so that we get the size. */
9478 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9481 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
9485 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
9488 error (_("Out of memory"));
9495 while (offset
< sect
->sh_size
)
9497 Elf_External_Options
*eoption
;
9499 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9501 option
->kind
= BYTE_GET (eoption
->kind
);
9502 option
->size
= BYTE_GET (eoption
->size
);
9503 option
->section
= BYTE_GET (eoption
->section
);
9504 option
->info
= BYTE_GET (eoption
->info
);
9506 offset
+= option
->size
;
9512 printf (_("\nSection '%s' contains %d entries:\n"),
9513 SECTION_NAME (sect
), cnt
);
9521 switch (option
->kind
)
9524 /* This shouldn't happen. */
9525 printf (" NULL %d %lx", option
->section
, option
->info
);
9528 printf (" REGINFO ");
9529 if (elf_header
.e_machine
== EM_MIPS
)
9532 Elf32_External_RegInfo
*ereg
;
9533 Elf32_RegInfo reginfo
;
9535 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9536 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9537 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9538 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9539 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9540 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9541 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9543 printf ("GPR %08lx GP 0x%lx\n",
9545 (unsigned long) reginfo
.ri_gp_value
);
9546 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9547 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9548 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9553 Elf64_External_RegInfo
*ereg
;
9554 Elf64_Internal_RegInfo reginfo
;
9556 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9557 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9558 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9559 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9560 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9561 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9562 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
9564 printf ("GPR %08lx GP 0x",
9565 reginfo
.ri_gprmask
);
9566 printf_vma (reginfo
.ri_gp_value
);
9569 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9570 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9571 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9575 case ODK_EXCEPTIONS
:
9576 fputs (" EXCEPTIONS fpe_min(", stdout
);
9577 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9578 fputs (") fpe_max(", stdout
);
9579 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9580 fputs (")", stdout
);
9582 if (option
->info
& OEX_PAGE0
)
9583 fputs (" PAGE0", stdout
);
9584 if (option
->info
& OEX_SMM
)
9585 fputs (" SMM", stdout
);
9586 if (option
->info
& OEX_FPDBUG
)
9587 fputs (" FPDBUG", stdout
);
9588 if (option
->info
& OEX_DISMISS
)
9589 fputs (" DISMISS", stdout
);
9592 fputs (" PAD ", stdout
);
9593 if (option
->info
& OPAD_PREFIX
)
9594 fputs (" PREFIX", stdout
);
9595 if (option
->info
& OPAD_POSTFIX
)
9596 fputs (" POSTFIX", stdout
);
9597 if (option
->info
& OPAD_SYMBOL
)
9598 fputs (" SYMBOL", stdout
);
9601 fputs (" HWPATCH ", stdout
);
9602 if (option
->info
& OHW_R4KEOP
)
9603 fputs (" R4KEOP", stdout
);
9604 if (option
->info
& OHW_R8KPFETCH
)
9605 fputs (" R8KPFETCH", stdout
);
9606 if (option
->info
& OHW_R5KEOP
)
9607 fputs (" R5KEOP", stdout
);
9608 if (option
->info
& OHW_R5KCVTL
)
9609 fputs (" R5KCVTL", stdout
);
9612 fputs (" FILL ", stdout
);
9613 /* XXX Print content of info word? */
9616 fputs (" TAGS ", stdout
);
9617 /* XXX Print content of info word? */
9620 fputs (" HWAND ", stdout
);
9621 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9622 fputs (" R4KEOP_CHECKED", stdout
);
9623 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9624 fputs (" R4KEOP_CLEAN", stdout
);
9627 fputs (" HWOR ", stdout
);
9628 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9629 fputs (" R4KEOP_CHECKED", stdout
);
9630 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9631 fputs (" R4KEOP_CLEAN", stdout
);
9634 printf (" GP_GROUP %#06lx self-contained %#06lx",
9635 option
->info
& OGP_GROUP
,
9636 (option
->info
& OGP_SELF
) >> 16);
9639 printf (" IDENT %#06lx self-contained %#06lx",
9640 option
->info
& OGP_GROUP
,
9641 (option
->info
& OGP_SELF
) >> 16);
9644 /* This shouldn't happen. */
9645 printf (" %3d ??? %d %lx",
9646 option
->kind
, option
->section
, option
->info
);
9650 len
= sizeof (*eopt
);
9651 while (len
< option
->size
)
9652 if (((char *) option
)[len
] >= ' '
9653 && ((char *) option
)[len
] < 0x7f)
9654 printf ("%c", ((char *) option
)[len
++]);
9656 printf ("\\%03o", ((char *) option
)[len
++]);
9658 fputs ("\n", stdout
);
9666 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9668 Elf32_Conflict
*iconf
;
9671 if (dynamic_symbols
== NULL
)
9673 error (_("conflict list found without a dynamic symbol table"));
9677 iconf
= malloc (conflictsno
* sizeof (*iconf
));
9680 error (_("Out of memory"));
9686 Elf32_External_Conflict
*econf32
;
9688 econf32
= get_data (NULL
, file
, conflicts_offset
,
9689 conflictsno
* sizeof (*econf32
), _("conflict"));
9693 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9694 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9700 Elf64_External_Conflict
*econf64
;
9702 econf64
= get_data (NULL
, file
, conflicts_offset
,
9703 conflictsno
* sizeof (*econf64
), _("conflict"));
9707 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9708 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9713 printf (_("\nSection '.conflict' contains %ld entries:\n"),
9714 (long) conflictsno
);
9715 puts (_(" Num: Index Value Name"));
9717 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9719 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9721 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9722 print_vma (psym
->st_value
, FULL_HEX
);
9724 print_symbol (25, dynamic_strings
+ psym
->st_name
);
9735 process_gnu_liblist (FILE *file
)
9737 Elf_Internal_Shdr
*section
, *string_sec
;
9738 Elf32_External_Lib
*elib
;
9746 for (i
= 0, section
= section_headers
;
9747 i
< elf_header
.e_shnum
;
9750 switch (section
->sh_type
)
9752 case SHT_GNU_LIBLIST
:
9753 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
9758 string_sec
= SECTION_HEADER (section
->sh_link
);
9760 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
9761 string_sec
->sh_size
, _("liblist string table"));
9764 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9770 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9771 SECTION_NAME (section
),
9772 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9774 puts (" Library Time Stamp Checksum Version Flags");
9776 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9784 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9785 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9786 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9787 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9788 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9790 tmp
= gmtime (&time
);
9791 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9792 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9793 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9795 printf ("%3lu: ", (unsigned long) cnt
);
9797 printf ("%-20s", strtab
+ liblist
.l_name
);
9799 printf ("%-20.20s", strtab
+ liblist
.l_name
);
9800 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9801 liblist
.l_version
, liblist
.l_flags
);
9812 get_note_type (unsigned e_type
)
9814 static char buff
[64];
9818 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
9819 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
9820 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
9821 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
9822 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
9823 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
9824 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
9825 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
9826 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
9827 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
9828 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9830 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9836 get_netbsd_elfcore_note_type (unsigned e_type
)
9838 static char buff
[64];
9840 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9842 /* NetBSD core "procinfo" structure. */
9843 return _("NetBSD procinfo structure");
9846 /* As of Jan 2002 there are no other machine-independent notes
9847 defined for NetBSD core files. If the note type is less
9848 than the start of the machine-dependent note types, we don't
9851 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9853 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
9857 switch (elf_header
.e_machine
)
9859 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9860 and PT_GETFPREGS == mach+2. */
9865 case EM_SPARC32PLUS
:
9869 case NT_NETBSDCORE_FIRSTMACH
+0:
9870 return _("PT_GETREGS (reg structure)");
9871 case NT_NETBSDCORE_FIRSTMACH
+2:
9872 return _("PT_GETFPREGS (fpreg structure)");
9878 /* On all other arch's, PT_GETREGS == mach+1 and
9879 PT_GETFPREGS == mach+3. */
9883 case NT_NETBSDCORE_FIRSTMACH
+1:
9884 return _("PT_GETREGS (reg structure)");
9885 case NT_NETBSDCORE_FIRSTMACH
+3:
9886 return _("PT_GETFPREGS (fpreg structure)");
9892 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
9896 /* Note that by the ELF standard, the name field is already null byte
9897 terminated, and namesz includes the terminating null byte.
9898 I.E. the value of namesz for the name "FSF" is 4.
9900 If the value of namesz is zero, there is no name present. */
9902 process_note (Elf_Internal_Note
*pnote
)
9906 if (pnote
->namesz
== 0)
9908 /* If there is no note name, then use the default set of
9909 note type strings. */
9910 nt
= get_note_type (pnote
->type
);
9912 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
9914 /* NetBSD-specific core file notes. */
9915 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9919 /* Don't recognize this note name; just use the default set of
9920 note type strings. */
9921 nt
= get_note_type (pnote
->type
);
9924 printf (" %s\t\t0x%08lx\t%s\n",
9925 pnote
->namesz
? pnote
->namedata
: "(NONE)",
9932 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
9934 Elf_External_Note
*pnotes
;
9935 Elf_External_Note
*external
;
9941 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
9947 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9948 (unsigned long) offset
, (unsigned long) length
);
9949 printf (_(" Owner\t\tData size\tDescription\n"));
9951 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9953 Elf_External_Note
*next
;
9954 Elf_Internal_Note inote
;
9957 inote
.type
= BYTE_GET (external
->type
);
9958 inote
.namesz
= BYTE_GET (external
->namesz
);
9959 inote
.namedata
= external
->name
;
9960 inote
.descsz
= BYTE_GET (external
->descsz
);
9961 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9962 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9964 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9966 if (((char *) next
) > (((char *) pnotes
) + length
))
9968 warn (_("corrupt note found at offset %x into core notes\n"),
9969 ((char *) external
) - ((char *) pnotes
));
9970 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
9971 inote
.type
, inote
.namesz
, inote
.descsz
);
9977 /* Verify that name is null terminated. It appears that at least
9978 one version of Linux (RedHat 6.0) generates corefiles that don't
9979 comply with the ELF spec by failing to include the null byte in
9981 if (inote
.namedata
[inote
.namesz
] != '\0')
9983 temp
= malloc (inote
.namesz
+ 1);
9987 error (_("Out of memory\n"));
9992 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9993 temp
[inote
.namesz
] = 0;
9995 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9996 inote
.namedata
= temp
;
9999 res
&= process_note (& inote
);
10014 process_corefile_note_segments (FILE *file
)
10016 Elf_Internal_Phdr
*segment
;
10020 if (! get_program_headers (file
))
10023 for (i
= 0, segment
= program_headers
;
10024 i
< elf_header
.e_phnum
;
10027 if (segment
->p_type
== PT_NOTE
)
10028 res
&= process_corefile_note_segment (file
,
10029 (bfd_vma
) segment
->p_offset
,
10030 (bfd_vma
) segment
->p_filesz
);
10037 process_corefile_contents (FILE *file
)
10039 /* If we have not been asked to display the notes then do nothing. */
10043 /* If file is not a core file then exit. */
10044 if (elf_header
.e_type
!= ET_CORE
)
10047 /* No program headers means no NOTE segment. */
10048 if (elf_header
.e_phnum
== 0)
10050 printf (_("No note segments present in the core file.\n"));
10054 return process_corefile_note_segments (file
);
10058 process_arch_specific (FILE *file
)
10063 switch (elf_header
.e_machine
)
10066 case EM_MIPS_RS3_LE
:
10067 return process_mips_specific (file
);
10076 get_file_header (FILE *file
)
10078 /* Read in the identity array. */
10079 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10082 /* Determine how to read the rest of the header. */
10083 switch (elf_header
.e_ident
[EI_DATA
])
10085 default: /* fall through */
10086 case ELFDATANONE
: /* fall through */
10088 byte_get
= byte_get_little_endian
;
10089 byte_put
= byte_put_little_endian
;
10092 byte_get
= byte_get_big_endian
;
10093 byte_put
= byte_put_big_endian
;
10097 /* For now we only support 32 bit and 64 bit ELF files. */
10098 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10100 /* Read in the rest of the header. */
10103 Elf32_External_Ehdr ehdr32
;
10105 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10108 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10109 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10110 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10111 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10112 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10113 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10114 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10115 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10116 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10117 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10118 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10119 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10120 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10124 Elf64_External_Ehdr ehdr64
;
10126 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10127 we will not be able to cope with the 64bit data found in
10128 64 ELF files. Detect this now and abort before we start
10129 overwritting things. */
10130 if (sizeof (bfd_vma
) < 8)
10132 error (_("This instance of readelf has been built without support for a\n\
10133 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10137 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10140 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10141 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10142 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10143 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10144 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10145 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10146 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10147 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10148 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10149 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10150 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10151 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10152 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10155 if (elf_header
.e_shoff
)
10157 /* There may be some extensions in the first section header. Don't
10158 bomb if we can't read it. */
10160 get_32bit_section_headers (file
, 1);
10162 get_64bit_section_headers (file
, 1);
10168 /* Process one ELF object file according to the command line options.
10169 This file may actually be stored in an archive. The file is
10170 positioned at the start of the ELF object. */
10173 process_object (char *file_name
, FILE *file
)
10177 if (! get_file_header (file
))
10179 error (_("%s: Failed to read file header\n"), file_name
);
10183 /* Initialise per file variables. */
10184 for (i
= NUM_ELEM (version_info
); i
--;)
10185 version_info
[i
] = 0;
10187 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10188 dynamic_info
[i
] = 0;
10190 /* Process the file. */
10192 printf (_("\nFile: %s\n"), file_name
);
10194 if (! process_file_header ())
10197 if (! process_section_headers (file
))
10199 /* Without loaded section headers we
10200 cannot process lots of things. */
10201 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10203 if (! do_using_dynamic
)
10204 do_syms
= do_reloc
= 0;
10207 if (process_program_headers (file
))
10208 process_dynamic_segment (file
);
10210 process_relocs (file
);
10212 process_unwind (file
);
10214 process_symbol_table (file
);
10216 process_syminfo (file
);
10218 process_version_sections (file
);
10220 process_section_contents (file
);
10222 process_corefile_contents (file
);
10224 process_gnu_liblist (file
);
10226 process_arch_specific (file
);
10228 if (program_headers
)
10230 free (program_headers
);
10231 program_headers
= NULL
;
10234 if (section_headers
)
10236 free (section_headers
);
10237 section_headers
= NULL
;
10242 free (string_table
);
10243 string_table
= NULL
;
10244 string_table_length
= 0;
10247 if (dynamic_strings
)
10249 free (dynamic_strings
);
10250 dynamic_strings
= NULL
;
10253 if (dynamic_symbols
)
10255 free (dynamic_symbols
);
10256 dynamic_symbols
= NULL
;
10257 num_dynamic_syms
= 0;
10260 if (dynamic_syminfo
)
10262 free (dynamic_syminfo
);
10263 dynamic_syminfo
= NULL
;
10269 /* Process an ELF archive. The file is positioned just after the
10273 process_archive (char *file_name
, FILE *file
)
10275 struct ar_hdr arhdr
;
10277 unsigned long size
;
10278 char *longnames
= NULL
;
10279 unsigned long longnames_size
= 0;
10280 size_t file_name_size
;
10285 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10286 if (got
!= sizeof arhdr
)
10291 error (_("%s: failed to read archive header\n"), file_name
);
10295 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
10297 /* This is the archive symbol table. Skip it.
10298 FIXME: We should have an option to dump it. */
10299 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10300 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
10302 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10306 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10307 if (got
!= sizeof arhdr
)
10312 error (_("%s: failed to read archive header\n"), file_name
);
10317 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
10319 /* This is the archive string table holding long member
10322 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10324 longnames
= malloc (longnames_size
);
10325 if (longnames
== NULL
)
10327 error (_("Out of memory\n"));
10331 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10334 error(_("%s: failed to read string table\n"), file_name
);
10338 if ((longnames_size
& 1) != 0)
10341 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10342 if (got
!= sizeof arhdr
)
10349 error (_("%s: failed to read archive header\n"), file_name
);
10354 file_name_size
= strlen (file_name
);
10363 if (arhdr
.ar_name
[0] == '/')
10367 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10368 if (off
>= longnames_size
)
10370 error (_("%s: invalid archive string table offset %lu\n"), off
);
10375 name
= longnames
+ off
;
10376 nameend
= memchr (name
, '/', longnames_size
- off
);
10380 name
= arhdr
.ar_name
;
10381 nameend
= memchr (name
, '/', 16);
10384 if (nameend
== NULL
)
10386 error (_("%s: bad archive file name\n"));
10391 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10392 if (namealc
== NULL
)
10394 error (_("Out of memory\n"));
10399 memcpy (namealc
, file_name
, file_name_size
);
10400 namealc
[file_name_size
] = '(';
10401 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10402 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10403 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10405 archive_file_offset
= ftell (file
);
10406 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10408 ret
|= process_object (namealc
, file
);
10413 (archive_file_offset
10414 + archive_file_size
10415 + (archive_file_size
& 1)),
10418 error (_("%s: failed to seek to next archive header\n"), file_name
);
10423 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10424 if (got
!= sizeof arhdr
)
10429 error (_("%s: failed to read archive header\n"), file_name
);
10435 if (longnames
!= 0)
10442 process_file (char *file_name
)
10445 struct stat statbuf
;
10446 char armag
[SARMAG
];
10449 if (stat (file_name
, &statbuf
) < 0)
10451 error (_("Cannot stat input file %s.\n"), file_name
);
10455 file
= fopen (file_name
, "rb");
10458 error (_("Input file %s not found.\n"), file_name
);
10462 if (fread (armag
, SARMAG
, 1, file
) != 1)
10464 error (_("%s: Failed to read file header\n"), file_name
);
10469 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10470 ret
= process_archive (file_name
, file
);
10474 archive_file_size
= archive_file_offset
= 0;
10475 ret
= process_object (file_name
, file
);
10483 #ifdef SUPPORT_DISASSEMBLY
10484 /* Needed by the i386 disassembler. For extra credit, someone could
10485 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10489 print_address (unsigned int addr
, FILE *outfile
)
10491 fprintf (outfile
,"0x%8.8x", addr
);
10494 /* Needed by the i386 disassembler. */
10496 db_task_printsym (unsigned int addr
)
10498 print_address (addr
, stderr
);
10503 main (int argc
, char **argv
)
10506 char *cmdline_dump_sects
= NULL
;
10507 unsigned num_cmdline_dump_sects
= 0;
10509 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10510 setlocale (LC_MESSAGES
, "");
10512 #if defined (HAVE_SETLOCALE)
10513 setlocale (LC_CTYPE
, "");
10515 bindtextdomain (PACKAGE
, LOCALEDIR
);
10516 textdomain (PACKAGE
);
10518 parse_args (argc
, argv
);
10520 if (optind
< (argc
- 1))
10523 /* When processing more than one file remember the dump requests
10524 issued on command line to reset them after each file. */
10525 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
10527 cmdline_dump_sects
= malloc (num_dump_sects
);
10528 if (cmdline_dump_sects
== NULL
)
10529 error (_("Out of memory allocating dump request table."));
10532 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
10533 num_cmdline_dump_sects
= num_dump_sects
;
10538 while (optind
< argc
)
10540 err
|= process_file (argv
[optind
++]);
10542 /* Reset dump requests. */
10543 if (optind
< argc
&& dump_sects
!= NULL
)
10545 num_dump_sects
= num_cmdline_dump_sects
;
10546 if (num_cmdline_dump_sects
> 0)
10547 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
10551 if (dump_sects
!= NULL
)
10553 if (cmdline_dump_sects
!= NULL
)
10554 free (cmdline_dump_sects
);