1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
45 #include <sys/types.h>
51 /* Define BFD64 here, even if our default architecture is 32 bit ELF
52 as this will allow us to read in and parse 64bit and 32bit ELF files.
53 Only do this if we believe that the compiler can support a 64 bit
54 data type. For now we only rely on GCC being able to do this. */
60 #include "elf/common.h"
61 #include "elf/external.h"
62 #include "elf/internal.h"
63 #include "elf/dwarf2.h"
65 /* The following headers use the elf/reloc-macros.h file to
66 automatically generate relocation recognition functions
67 such as elf_mips_reloc_type() */
69 #define RELOC_MACROS_GEN_FUNC
71 #include "elf/alpha.h"
91 #include "elf/m68hc11.h"
92 #include "elf/mcore.h"
95 #include "elf/mn10200.h"
96 #include "elf/mn10300.h"
97 #include "elf/msp430.h"
101 #include "elf/ppc64.h"
102 #include "elf/s390.h"
104 #include "elf/sparc.h"
105 #include "elf/v850.h"
107 #include "elf/x86-64.h"
108 #include "elf/xstormy16.h"
110 #include "elf/iq2000.h"
111 #include "elf/xtensa.h"
117 #include "libiberty.h"
119 char *program_name
= "readelf";
120 long archive_file_offset
;
121 unsigned long archive_file_size
;
122 unsigned long dynamic_addr
;
123 bfd_size_type dynamic_size
;
124 unsigned int dynamic_nent
;
125 char *dynamic_strings
;
127 unsigned long string_table_length
;
128 unsigned long num_dynamic_syms
;
129 Elf_Internal_Sym
*dynamic_symbols
;
130 Elf_Internal_Syminfo
*dynamic_syminfo
;
131 unsigned long dynamic_syminfo_offset
;
132 unsigned int dynamic_syminfo_nent
;
133 char program_interpreter
[64];
134 bfd_vma dynamic_info
[DT_JMPREL
+ 1];
135 bfd_vma version_info
[16];
136 Elf_Internal_Ehdr elf_header
;
137 Elf_Internal_Shdr
*section_headers
;
138 Elf_Internal_Phdr
*program_headers
;
139 Elf_Internal_Dyn
*dynamic_section
;
140 Elf_Internal_Shdr
*symtab_shndx_hdr
;
146 int do_section_groups
;
149 int do_using_dynamic
;
157 int do_debug_abbrevs
;
159 int do_debug_pubnames
;
160 int do_debug_aranges
;
162 int do_debug_frames_interp
;
163 int do_debug_macinfo
;
172 struct group_list
*next
;
173 unsigned int section_index
;
178 struct group_list
*root
;
179 unsigned int group_index
;
182 struct group
*section_groups
;
183 size_t group_count
= 0;
185 struct group
**section_headers_groups
;
187 /* A dynamic array of flags indicating which sections require dumping. */
188 char *dump_sects
= NULL
;
189 unsigned int num_dump_sects
= 0;
191 #define HEX_DUMP (1 << 0)
192 #define DISASS_DUMP (1 << 1)
193 #define DEBUG_DUMP (1 << 2)
195 /* How to rpint a vma value. */
196 typedef enum print_mode
208 static bfd_vma (*byte_get
) (unsigned char *, int);
209 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
213 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
214 ((X)->sh_name >= string_table_length \
215 ? "<corrupt>" : string_table + (X)->sh_name))
217 /* Given st_shndx I, map to section_headers index. */
218 #define SECTION_HEADER_INDEX(I) \
219 ((I) < SHN_LORESERVE \
221 : ((I) <= SHN_HIRESERVE \
223 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
225 /* Reverse of the above. */
226 #define SECTION_HEADER_NUM(N) \
227 ((N) < SHN_LORESERVE \
229 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
231 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
233 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
235 #define BYTE_GET(field) byte_get (field, sizeof (field))
237 /* If we can support a 64 bit data type then BFD64 should be defined
238 and sizeof (bfd_vma) == 8. In this case when translating from an
239 external 8 byte field to an internal field, we can assume that the
240 internal field is also 8 bytes wide and so we can extract all the data.
241 If, however, BFD64 is not defined, then we must assume that the
242 internal data structure only has 4 byte wide fields that are the
243 equivalent of the 8 byte wide external counterparts, and so we must
244 truncate the data. */
246 #define BYTE_GET8(field) byte_get (field, -8)
248 #define BYTE_GET8(field) byte_get (field, 8)
251 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
253 #define GET_ELF_SYMBOLS(file, section) \
254 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
255 : get_64bit_elf_symbols (file, section))
259 error (const char *message
, ...)
263 va_start (args
, message
);
264 fprintf (stderr
, _("%s: Error: "), program_name
);
265 vfprintf (stderr
, message
, args
);
270 warn (const char *message
, ...)
274 va_start (args
, message
);
275 fprintf (stderr
, _("%s: Warning: "), program_name
);
276 vfprintf (stderr
, message
, args
);
281 get_data (void *var
, FILE *file
, long offset
, size_t size
, const char *reason
)
288 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
290 error (_("Unable to seek to 0x%x for %s\n"),
291 archive_file_offset
+ offset
, reason
);
298 mvar
= malloc (size
);
302 error (_("Out of memory allocating 0x%x bytes for %s\n"),
308 if (fread (mvar
, size
, 1, file
) != 1)
310 error (_("Unable to read in 0x%x bytes of %s\n"), size
, reason
);
320 byte_get_little_endian (unsigned char *field
, int size
)
328 return ((unsigned int) (field
[0]))
329 | (((unsigned int) (field
[1])) << 8);
333 /* We want to extract data from an 8 byte wide field and
334 place it into a 4 byte wide field. Since this is a little
335 endian source we can just use the 4 byte extraction code. */
339 return ((unsigned long) (field
[0]))
340 | (((unsigned long) (field
[1])) << 8)
341 | (((unsigned long) (field
[2])) << 16)
342 | (((unsigned long) (field
[3])) << 24);
347 /* This is a special case, generated by the BYTE_GET8 macro.
348 It means that we are loading an 8 byte value from a field
349 in an external structure into an 8 byte value in a field
350 in an internal structure. */
351 return ((bfd_vma
) (field
[0]))
352 | (((bfd_vma
) (field
[1])) << 8)
353 | (((bfd_vma
) (field
[2])) << 16)
354 | (((bfd_vma
) (field
[3])) << 24)
355 | (((bfd_vma
) (field
[4])) << 32)
356 | (((bfd_vma
) (field
[5])) << 40)
357 | (((bfd_vma
) (field
[6])) << 48)
358 | (((bfd_vma
) (field
[7])) << 56);
361 error (_("Unhandled data length: %d\n"), size
);
367 byte_get_signed (unsigned char *field
, int size
)
369 bfd_vma x
= byte_get (field
, size
);
374 return (x
^ 0x80) - 0x80;
376 return (x
^ 0x8000) - 0x8000;
378 return (x
^ 0x80000000) - 0x80000000;
388 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
393 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
394 field
[6] = ((value
>> 24) >> 24) & 0xff;
395 field
[5] = ((value
>> 24) >> 16) & 0xff;
396 field
[4] = ((value
>> 24) >> 8) & 0xff;
399 field
[3] = (value
>> 24) & 0xff;
400 field
[2] = (value
>> 16) & 0xff;
403 field
[1] = (value
>> 8) & 0xff;
406 field
[0] = value
& 0xff;
410 error (_("Unhandled data length: %d\n"), size
);
415 /* Print a VMA value. */
417 print_vma (bfd_vma vma
, print_mode mode
)
429 printf ("%8.8lx", (unsigned long) vma
);
435 printf ("%5ld", (long) vma
);
443 printf ("%lx", (unsigned long) vma
);
447 printf ("%ld", (unsigned long) vma
);
451 printf ("%lu", (unsigned long) vma
);
473 #if BFD_HOST_64BIT_LONG
476 if (_bfd_int64_high (vma
))
477 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
479 printf ("%lx", _bfd_int64_low (vma
));
484 #if BFD_HOST_64BIT_LONG
487 if (_bfd_int64_high (vma
))
489 printf ("++%ld", _bfd_int64_low (vma
));
491 printf ("%ld", _bfd_int64_low (vma
));
496 #if BFD_HOST_64BIT_LONG
498 printf ("%5ld", vma
);
500 printf ("%#lx", vma
);
502 if (_bfd_int64_high (vma
))
504 printf ("++%ld", _bfd_int64_low (vma
));
505 else if (vma
<= 99999)
506 printf ("%5ld", _bfd_int64_low (vma
));
508 printf ("%#lx", _bfd_int64_low (vma
));
513 #if BFD_HOST_64BIT_LONG
516 if (_bfd_int64_high (vma
))
518 printf ("++%lu", _bfd_int64_low (vma
));
520 printf ("%lu", _bfd_int64_low (vma
));
528 /* Display a symbol on stdout. If do_wide is not true then
529 format the symbol to be at most WIDTH characters,
530 truncating as necessary. If WIDTH is negative then
531 format the string to be exactly - WIDTH characters,
532 truncating or padding as necessary. */
535 print_symbol (int width
, const char *symbol
)
538 printf ("%s", symbol
);
540 printf ("%-*.*s", width
, width
, symbol
);
542 printf ("%-.*s", width
, symbol
);
546 byte_get_big_endian (unsigned char *field
, int size
)
554 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
557 return ((unsigned long) (field
[3]))
558 | (((unsigned long) (field
[2])) << 8)
559 | (((unsigned long) (field
[1])) << 16)
560 | (((unsigned long) (field
[0])) << 24);
564 /* Although we are extracing data from an 8 byte wide field, we
565 are returning only 4 bytes of data. */
566 return ((unsigned long) (field
[7]))
567 | (((unsigned long) (field
[6])) << 8)
568 | (((unsigned long) (field
[5])) << 16)
569 | (((unsigned long) (field
[4])) << 24);
573 /* This is a special case, generated by the BYTE_GET8 macro.
574 It means that we are loading an 8 byte value from a field
575 in an external structure into an 8 byte value in a field
576 in an internal structure. */
577 return ((bfd_vma
) (field
[7]))
578 | (((bfd_vma
) (field
[6])) << 8)
579 | (((bfd_vma
) (field
[5])) << 16)
580 | (((bfd_vma
) (field
[4])) << 24)
581 | (((bfd_vma
) (field
[3])) << 32)
582 | (((bfd_vma
) (field
[2])) << 40)
583 | (((bfd_vma
) (field
[1])) << 48)
584 | (((bfd_vma
) (field
[0])) << 56);
588 error (_("Unhandled data length: %d\n"), size
);
594 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
599 field
[7] = value
& 0xff;
600 field
[6] = (value
>> 8) & 0xff;
601 field
[5] = (value
>> 16) & 0xff;
602 field
[4] = (value
>> 24) & 0xff;
607 field
[3] = value
& 0xff;
608 field
[2] = (value
>> 8) & 0xff;
612 field
[1] = value
& 0xff;
616 field
[0] = value
& 0xff;
620 error (_("Unhandled data length: %d\n"), size
);
625 /* Guess the relocation size commonly used by the specific machines. */
628 guess_is_rela (unsigned long e_machine
)
632 /* Targets that use REL relocations. */
647 /* Targets that use RELA relocations. */
662 case EM_CYGNUS_MN10200
:
664 case EM_CYGNUS_MN10300
:
711 warn (_("Don't know about relocations on this machine architecture\n"));
717 slurp_rela_relocs (FILE *file
,
718 unsigned long rel_offset
,
719 unsigned long rel_size
,
720 Elf_Internal_Rela
**relasp
,
721 unsigned long *nrelasp
)
723 Elf_Internal_Rela
*relas
;
724 unsigned long nrelas
;
729 Elf32_External_Rela
*erelas
;
731 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
735 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
737 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
741 error(_("out of memory parsing relocs"));
745 for (i
= 0; i
< nrelas
; i
++)
747 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
748 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
749 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
756 Elf64_External_Rela
*erelas
;
758 erelas
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
762 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
764 relas
= malloc (nrelas
* sizeof (Elf_Internal_Rela
));
768 error(_("out of memory parsing relocs"));
772 for (i
= 0; i
< nrelas
; i
++)
774 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
775 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
776 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
787 slurp_rel_relocs (FILE *file
,
788 unsigned long rel_offset
,
789 unsigned long rel_size
,
790 Elf_Internal_Rela
**relsp
,
791 unsigned long *nrelsp
)
793 Elf_Internal_Rela
*rels
;
799 Elf32_External_Rel
*erels
;
801 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
805 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
807 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
811 error(_("out of memory parsing relocs"));
815 for (i
= 0; i
< nrels
; i
++)
817 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
818 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
819 rels
[i
].r_addend
= 0;
826 Elf64_External_Rel
*erels
;
828 erels
= get_data (NULL
, file
, rel_offset
, rel_size
, _("relocs"));
832 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
834 rels
= malloc (nrels
* sizeof (Elf_Internal_Rela
));
838 error(_("out of memory parsing relocs"));
842 for (i
= 0; i
< nrels
; i
++)
844 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
845 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
846 rels
[i
].r_addend
= 0;
856 /* Display the contents of the relocation data found at the specified
860 dump_relocations (FILE *file
,
861 unsigned long rel_offset
,
862 unsigned long rel_size
,
863 Elf_Internal_Sym
*symtab
,
869 Elf_Internal_Rela
*rels
;
872 if (is_rela
== UNKNOWN
)
873 is_rela
= guess_is_rela (elf_header
.e_machine
);
877 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
882 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
891 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
893 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
898 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
900 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
908 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
910 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
915 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
917 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
921 for (i
= 0; i
< rel_size
; i
++)
924 const char *rtype2
= NULL
;
925 const char *rtype3
= NULL
;
928 bfd_vma symtab_index
;
933 offset
= rels
[i
].r_offset
;
934 info
= rels
[i
].r_info
;
938 type
= ELF32_R_TYPE (info
);
939 symtab_index
= ELF32_R_SYM (info
);
943 /* The #ifdef BFD64 below is to prevent a compile time warning.
944 We know that if we do not have a 64 bit data type that we
945 will never execute this code anyway. */
947 if (elf_header
.e_machine
== EM_MIPS
)
949 /* In little-endian objects, r_info isn't really a 64-bit
950 little-endian value: it has a 32-bit little-endian
951 symbol index followed by four individual byte fields.
952 Reorder INFO accordingly. */
953 if (elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
954 info
= (((info
& 0xffffffff) << 32)
955 | ((info
>> 56) & 0xff)
956 | ((info
>> 40) & 0xff00)
957 | ((info
>> 24) & 0xff0000)
958 | ((info
>> 8) & 0xff000000));
959 type
= ELF64_MIPS_R_TYPE (info
);
960 type2
= ELF64_MIPS_R_TYPE2 (info
);
961 type3
= ELF64_MIPS_R_TYPE3 (info
);
963 else if (elf_header
.e_machine
== EM_SPARCV9
)
964 type
= ELF64_R_TYPE_ID (info
);
966 type
= ELF64_R_TYPE (info
);
968 symtab_index
= ELF64_R_SYM (info
);
974 #ifdef _bfd_int64_low
975 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
977 printf ("%8.8lx %8.8lx ", offset
, info
);
982 #ifdef _bfd_int64_low
984 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
985 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
986 _bfd_int64_high (offset
),
987 _bfd_int64_low (offset
),
988 _bfd_int64_high (info
),
989 _bfd_int64_low (info
));
992 ? "%16.16lx %16.16lx "
993 : "%12.12lx %12.12lx ",
998 switch (elf_header
.e_machine
)
1005 case EM_CYGNUS_M32R
:
1006 rtype
= elf_m32r_reloc_type (type
);
1011 rtype
= elf_i386_reloc_type (type
);
1016 rtype
= elf_m68hc11_reloc_type (type
);
1020 rtype
= elf_m68k_reloc_type (type
);
1024 rtype
= elf_i960_reloc_type (type
);
1029 rtype
= elf_avr_reloc_type (type
);
1032 case EM_OLD_SPARCV9
:
1033 case EM_SPARC32PLUS
:
1036 rtype
= elf_sparc_reloc_type (type
);
1040 case EM_CYGNUS_V850
:
1041 rtype
= v850_reloc_type (type
);
1045 case EM_CYGNUS_D10V
:
1046 rtype
= elf_d10v_reloc_type (type
);
1050 case EM_CYGNUS_D30V
:
1051 rtype
= elf_d30v_reloc_type (type
);
1055 rtype
= elf_dlx_reloc_type (type
);
1059 rtype
= elf_sh_reloc_type (type
);
1063 case EM_CYGNUS_MN10300
:
1064 rtype
= elf_mn10300_reloc_type (type
);
1068 case EM_CYGNUS_MN10200
:
1069 rtype
= elf_mn10200_reloc_type (type
);
1073 case EM_CYGNUS_FR30
:
1074 rtype
= elf_fr30_reloc_type (type
);
1078 rtype
= elf_frv_reloc_type (type
);
1082 rtype
= elf_mcore_reloc_type (type
);
1086 rtype
= elf_mmix_reloc_type (type
);
1091 rtype
= elf_msp430_reloc_type (type
);
1095 rtype
= elf_ppc_reloc_type (type
);
1099 rtype
= elf_ppc64_reloc_type (type
);
1103 case EM_MIPS_RS3_LE
:
1104 rtype
= elf_mips_reloc_type (type
);
1107 rtype2
= elf_mips_reloc_type (type2
);
1108 rtype3
= elf_mips_reloc_type (type3
);
1113 rtype
= elf_alpha_reloc_type (type
);
1117 rtype
= elf_arm_reloc_type (type
);
1121 rtype
= elf_arc_reloc_type (type
);
1125 rtype
= elf_hppa_reloc_type (type
);
1131 rtype
= elf_h8_reloc_type (type
);
1136 rtype
= elf_or32_reloc_type (type
);
1141 rtype
= elf_pj_reloc_type (type
);
1144 rtype
= elf_ia64_reloc_type (type
);
1148 rtype
= elf_cris_reloc_type (type
);
1152 rtype
= elf_i860_reloc_type (type
);
1156 rtype
= elf_x86_64_reloc_type (type
);
1160 rtype
= i370_reloc_type (type
);
1165 rtype
= elf_s390_reloc_type (type
);
1169 rtype
= elf_xstormy16_reloc_type (type
);
1173 rtype
= elf_crx_reloc_type (type
);
1177 rtype
= elf_vax_reloc_type (type
);
1182 rtype
= elf_ip2k_reloc_type (type
);
1186 rtype
= elf_iq2000_reloc_type (type
);
1191 rtype
= elf_xtensa_reloc_type (type
);
1196 #ifdef _bfd_int64_low
1197 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type
));
1199 printf (_("unrecognized: %-7lx"), type
);
1202 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1206 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1207 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1210 Elf_Internal_Sym
*psym
;
1212 psym
= symtab
+ symtab_index
;
1215 print_vma (psym
->st_value
, LONG_HEX
);
1216 printf (is_32bit_elf
? " " : " ");
1218 if (psym
->st_name
== 0)
1220 const char *sec_name
= "<null>";
1223 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1225 bfd_vma sec_index
= (bfd_vma
) -1;
1227 if (psym
->st_shndx
< SHN_LORESERVE
)
1228 sec_index
= psym
->st_shndx
;
1229 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1230 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1233 if (sec_index
!= (bfd_vma
) -1)
1234 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1235 else if (psym
->st_shndx
== SHN_ABS
)
1237 else if (psym
->st_shndx
== SHN_COMMON
)
1238 sec_name
= "COMMON";
1239 else if (elf_header
.e_machine
== EM_IA_64
1240 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1241 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1242 sec_name
= "ANSI_COM";
1245 sprintf (name_buf
, "<section 0x%x>",
1246 (unsigned int) psym
->st_shndx
);
1247 sec_name
= name_buf
;
1250 print_symbol (22, sec_name
);
1252 else if (strtab
== NULL
)
1253 printf (_("<string table index %3ld>"), psym
->st_name
);
1255 print_symbol (22, strtab
+ psym
->st_name
);
1258 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1263 printf ("%*c", is_32bit_elf
? (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1264 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1267 if (elf_header
.e_machine
== EM_SPARCV9
1268 && !strcmp (rtype
, "R_SPARC_OLO10"))
1269 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1273 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1275 printf (" Type2: ");
1278 #ifdef _bfd_int64_low
1279 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2
));
1281 printf (_("unrecognized: %-7lx"), type2
);
1284 printf ("%-17.17s", rtype2
);
1286 printf("\n Type3: ");
1289 #ifdef _bfd_int64_low
1290 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3
));
1292 printf (_("unrecognized: %-7lx"), type3
);
1295 printf ("%-17.17s", rtype3
);
1307 get_mips_dynamic_type (unsigned long type
)
1311 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1312 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1313 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1314 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1315 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1316 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1317 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1318 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1319 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1320 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1321 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1322 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1323 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1324 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1325 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1326 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1327 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1328 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1329 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1330 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1331 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1332 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1333 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1334 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1335 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1336 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1337 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1338 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1339 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1340 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1341 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1342 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1343 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1344 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1345 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1346 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1347 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1348 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1349 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1350 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1351 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1352 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1353 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1360 get_sparc64_dynamic_type (unsigned long type
)
1364 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1371 get_ppc64_dynamic_type (unsigned long type
)
1375 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1376 case DT_PPC64_OPD
: return "PPC64_OPD";
1377 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1384 get_parisc_dynamic_type (unsigned long type
)
1388 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1389 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1390 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1391 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1392 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1393 case DT_HP_PREINIT
: return "HP_PREINIT";
1394 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1395 case DT_HP_NEEDED
: return "HP_NEEDED";
1396 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1397 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1398 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1399 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1400 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1407 get_ia64_dynamic_type (unsigned long type
)
1411 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1418 get_dynamic_type (unsigned long type
)
1420 static char buff
[32];
1424 case DT_NULL
: return "NULL";
1425 case DT_NEEDED
: return "NEEDED";
1426 case DT_PLTRELSZ
: return "PLTRELSZ";
1427 case DT_PLTGOT
: return "PLTGOT";
1428 case DT_HASH
: return "HASH";
1429 case DT_STRTAB
: return "STRTAB";
1430 case DT_SYMTAB
: return "SYMTAB";
1431 case DT_RELA
: return "RELA";
1432 case DT_RELASZ
: return "RELASZ";
1433 case DT_RELAENT
: return "RELAENT";
1434 case DT_STRSZ
: return "STRSZ";
1435 case DT_SYMENT
: return "SYMENT";
1436 case DT_INIT
: return "INIT";
1437 case DT_FINI
: return "FINI";
1438 case DT_SONAME
: return "SONAME";
1439 case DT_RPATH
: return "RPATH";
1440 case DT_SYMBOLIC
: return "SYMBOLIC";
1441 case DT_REL
: return "REL";
1442 case DT_RELSZ
: return "RELSZ";
1443 case DT_RELENT
: return "RELENT";
1444 case DT_PLTREL
: return "PLTREL";
1445 case DT_DEBUG
: return "DEBUG";
1446 case DT_TEXTREL
: return "TEXTREL";
1447 case DT_JMPREL
: return "JMPREL";
1448 case DT_BIND_NOW
: return "BIND_NOW";
1449 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1450 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1451 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1452 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1453 case DT_RUNPATH
: return "RUNPATH";
1454 case DT_FLAGS
: return "FLAGS";
1456 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1457 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1459 case DT_CHECKSUM
: return "CHECKSUM";
1460 case DT_PLTPADSZ
: return "PLTPADSZ";
1461 case DT_MOVEENT
: return "MOVEENT";
1462 case DT_MOVESZ
: return "MOVESZ";
1463 case DT_FEATURE
: return "FEATURE";
1464 case DT_POSFLAG_1
: return "POSFLAG_1";
1465 case DT_SYMINSZ
: return "SYMINSZ";
1466 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1468 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1469 case DT_CONFIG
: return "CONFIG";
1470 case DT_DEPAUDIT
: return "DEPAUDIT";
1471 case DT_AUDIT
: return "AUDIT";
1472 case DT_PLTPAD
: return "PLTPAD";
1473 case DT_MOVETAB
: return "MOVETAB";
1474 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1476 case DT_VERSYM
: return "VERSYM";
1478 case DT_RELACOUNT
: return "RELACOUNT";
1479 case DT_RELCOUNT
: return "RELCOUNT";
1480 case DT_FLAGS_1
: return "FLAGS_1";
1481 case DT_VERDEF
: return "VERDEF";
1482 case DT_VERDEFNUM
: return "VERDEFNUM";
1483 case DT_VERNEED
: return "VERNEED";
1484 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1486 case DT_AUXILIARY
: return "AUXILIARY";
1487 case DT_USED
: return "USED";
1488 case DT_FILTER
: return "FILTER";
1490 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1491 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1492 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1493 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1494 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1497 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1501 switch (elf_header
.e_machine
)
1504 case EM_MIPS_RS3_LE
:
1505 result
= get_mips_dynamic_type (type
);
1508 result
= get_sparc64_dynamic_type (type
);
1511 result
= get_ppc64_dynamic_type (type
);
1514 result
= get_ia64_dynamic_type (type
);
1524 sprintf (buff
, _("Processor Specific: %lx"), type
);
1526 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1530 switch (elf_header
.e_machine
)
1533 result
= get_parisc_dynamic_type (type
);
1543 sprintf (buff
, _("Operating System specific: %lx"), type
);
1546 sprintf (buff
, _("<unknown>: %lx"), type
);
1553 get_file_type (unsigned e_type
)
1555 static char buff
[32];
1559 case ET_NONE
: return _("NONE (None)");
1560 case ET_REL
: return _("REL (Relocatable file)");
1561 case ET_EXEC
: return _("EXEC (Executable file)");
1562 case ET_DYN
: return _("DYN (Shared object file)");
1563 case ET_CORE
: return _("CORE (Core file)");
1566 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1567 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1568 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1569 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1571 sprintf (buff
, _("<unknown>: %x"), e_type
);
1577 get_machine_name (unsigned e_machine
)
1579 static char buff
[64]; /* XXX */
1583 case EM_NONE
: return _("None");
1584 case EM_M32
: return "WE32100";
1585 case EM_SPARC
: return "Sparc";
1586 case EM_386
: return "Intel 80386";
1587 case EM_68K
: return "MC68000";
1588 case EM_88K
: return "MC88000";
1589 case EM_486
: return "Intel 80486";
1590 case EM_860
: return "Intel 80860";
1591 case EM_MIPS
: return "MIPS R3000";
1592 case EM_S370
: return "IBM System/370";
1593 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1594 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1595 case EM_PARISC
: return "HPPA";
1596 case EM_PPC_OLD
: return "Power PC (old)";
1597 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1598 case EM_960
: return "Intel 90860";
1599 case EM_PPC
: return "PowerPC";
1600 case EM_PPC64
: return "PowerPC64";
1601 case EM_V800
: return "NEC V800";
1602 case EM_FR20
: return "Fujitsu FR20";
1603 case EM_RH32
: return "TRW RH32";
1604 case EM_MCORE
: return "MCORE";
1605 case EM_ARM
: return "ARM";
1606 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1607 case EM_SH
: return "Renesas / SuperH SH";
1608 case EM_SPARCV9
: return "Sparc v9";
1609 case EM_TRICORE
: return "Siemens Tricore";
1610 case EM_ARC
: return "ARC";
1611 case EM_H8_300
: return "Renesas H8/300";
1612 case EM_H8_300H
: return "Renesas H8/300H";
1613 case EM_H8S
: return "Renesas H8S";
1614 case EM_H8_500
: return "Renesas H8/500";
1615 case EM_IA_64
: return "Intel IA-64";
1616 case EM_MIPS_X
: return "Stanford MIPS-X";
1617 case EM_COLDFIRE
: return "Motorola Coldfire";
1618 case EM_68HC12
: return "Motorola M68HC12";
1619 case EM_ALPHA
: return "Alpha";
1620 case EM_CYGNUS_D10V
:
1621 case EM_D10V
: return "d10v";
1622 case EM_CYGNUS_D30V
:
1623 case EM_D30V
: return "d30v";
1624 case EM_CYGNUS_M32R
:
1625 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1626 case EM_CYGNUS_V850
:
1627 case EM_V850
: return "NEC v850";
1628 case EM_CYGNUS_MN10300
:
1629 case EM_MN10300
: return "mn10300";
1630 case EM_CYGNUS_MN10200
:
1631 case EM_MN10200
: return "mn10200";
1632 case EM_CYGNUS_FR30
:
1633 case EM_FR30
: return "Fujitsu FR30";
1634 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1636 case EM_PJ
: return "picoJava";
1637 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1638 case EM_PCP
: return "Siemens PCP";
1639 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1640 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1641 case EM_STARCORE
: return "Motorola Star*Core processor";
1642 case EM_ME16
: return "Toyota ME16 processor";
1643 case EM_ST100
: return "STMicroelectronics ST100 processor";
1644 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1645 case EM_FX66
: return "Siemens FX66 microcontroller";
1646 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1647 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1648 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1649 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1650 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1651 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1652 case EM_SVX
: return "Silicon Graphics SVx";
1653 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1654 case EM_VAX
: return "Digital VAX";
1656 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1657 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1658 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1659 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1660 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1661 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1662 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1663 case EM_PRISM
: return "Vitesse Prism";
1664 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1666 case EM_S390
: return "IBM S/390";
1667 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1669 case EM_OR32
: return "OpenRISC";
1670 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1671 case EM_DLX
: return "OpenDLX";
1673 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1674 case EM_IQ2000
: return "Vitesse IQ2000";
1676 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1678 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1684 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1689 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1690 e_flags
&= ~ EF_ARM_EABIMASK
;
1692 /* Handle "generic" ARM flags. */
1693 if (e_flags
& EF_ARM_RELEXEC
)
1695 strcat (buf
, ", relocatable executable");
1696 e_flags
&= ~ EF_ARM_RELEXEC
;
1699 if (e_flags
& EF_ARM_HASENTRY
)
1701 strcat (buf
, ", has entry point");
1702 e_flags
&= ~ EF_ARM_HASENTRY
;
1705 /* Now handle EABI specific flags. */
1709 strcat (buf
, ", <unrecognized EABI>");
1714 case EF_ARM_EABI_VER1
:
1715 strcat (buf
, ", Version1 EABI");
1720 /* Process flags one bit at a time. */
1721 flag
= e_flags
& - e_flags
;
1726 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1727 strcat (buf
, ", sorted symbol tables");
1737 case EF_ARM_EABI_VER2
:
1738 strcat (buf
, ", Version2 EABI");
1743 /* Process flags one bit at a time. */
1744 flag
= e_flags
& - e_flags
;
1749 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1750 strcat (buf
, ", sorted symbol tables");
1753 case EF_ARM_DYNSYMSUSESEGIDX
:
1754 strcat (buf
, ", dynamic symbols use segment index");
1757 case EF_ARM_MAPSYMSFIRST
:
1758 strcat (buf
, ", mapping symbols precede others");
1768 case EF_ARM_EABI_VER3
:
1769 strcat (buf
, ", Version3 EABI");
1772 case EF_ARM_EABI_VER4
:
1773 strcat (buf
, ", Version4 EABI");
1778 /* Process flags one bit at a time. */
1779 flag
= e_flags
& - e_flags
;
1785 strcat (buf
, ", BE8");
1789 strcat (buf
, ", LE8");
1799 case EF_ARM_EABI_UNKNOWN
:
1800 strcat (buf
, ", GNU EABI");
1805 /* Process flags one bit at a time. */
1806 flag
= e_flags
& - e_flags
;
1811 case EF_ARM_INTERWORK
:
1812 strcat (buf
, ", interworking enabled");
1815 case EF_ARM_APCS_26
:
1816 strcat (buf
, ", uses APCS/26");
1819 case EF_ARM_APCS_FLOAT
:
1820 strcat (buf
, ", uses APCS/float");
1824 strcat (buf
, ", position independent");
1828 strcat (buf
, ", 8 bit structure alignment");
1831 case EF_ARM_NEW_ABI
:
1832 strcat (buf
, ", uses new ABI");
1835 case EF_ARM_OLD_ABI
:
1836 strcat (buf
, ", uses old ABI");
1839 case EF_ARM_SOFT_FLOAT
:
1840 strcat (buf
, ", software FP");
1843 case EF_ARM_VFP_FLOAT
:
1844 strcat (buf
, ", VFP");
1847 case EF_ARM_MAVERICK_FLOAT
:
1848 strcat (buf
, ", Maverick FP");
1859 strcat (buf
,", <unknown>");
1863 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1865 static char buf
[1024];
1877 decode_ARM_machine_flags (e_flags
, buf
);
1881 switch (e_flags
& EF_FRV_CPU_MASK
)
1883 case EF_FRV_CPU_GENERIC
:
1887 strcat (buf
, ", fr???");
1890 case EF_FRV_CPU_FR300
:
1891 strcat (buf
, ", fr300");
1894 case EF_FRV_CPU_FR400
:
1895 strcat (buf
, ", fr400");
1897 case EF_FRV_CPU_FR405
:
1898 strcat (buf
, ", fr405");
1901 case EF_FRV_CPU_FR450
:
1902 strcat (buf
, ", fr450");
1905 case EF_FRV_CPU_FR500
:
1906 strcat (buf
, ", fr500");
1908 case EF_FRV_CPU_FR550
:
1909 strcat (buf
, ", fr550");
1912 case EF_FRV_CPU_SIMPLE
:
1913 strcat (buf
, ", simple");
1915 case EF_FRV_CPU_TOMCAT
:
1916 strcat (buf
, ", tomcat");
1922 if (e_flags
& EF_CPU32
)
1923 strcat (buf
, ", cpu32");
1924 if (e_flags
& EF_M68000
)
1925 strcat (buf
, ", m68000");
1929 if (e_flags
& EF_PPC_EMB
)
1930 strcat (buf
, ", emb");
1932 if (e_flags
& EF_PPC_RELOCATABLE
)
1933 strcat (buf
, ", relocatable");
1935 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1936 strcat (buf
, ", relocatable-lib");
1940 case EM_CYGNUS_V850
:
1941 switch (e_flags
& EF_V850_ARCH
)
1944 strcat (buf
, ", v850e1");
1947 strcat (buf
, ", v850e");
1950 strcat (buf
, ", v850");
1953 strcat (buf
, ", unknown v850 architecture variant");
1959 case EM_CYGNUS_M32R
:
1960 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1961 strcat (buf
, ", m32r");
1966 case EM_MIPS_RS3_LE
:
1967 if (e_flags
& EF_MIPS_NOREORDER
)
1968 strcat (buf
, ", noreorder");
1970 if (e_flags
& EF_MIPS_PIC
)
1971 strcat (buf
, ", pic");
1973 if (e_flags
& EF_MIPS_CPIC
)
1974 strcat (buf
, ", cpic");
1976 if (e_flags
& EF_MIPS_UCODE
)
1977 strcat (buf
, ", ugen_reserved");
1979 if (e_flags
& EF_MIPS_ABI2
)
1980 strcat (buf
, ", abi2");
1982 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1983 strcat (buf
, ", odk first");
1985 if (e_flags
& EF_MIPS_32BITMODE
)
1986 strcat (buf
, ", 32bitmode");
1988 switch ((e_flags
& EF_MIPS_MACH
))
1990 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1991 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1992 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1993 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1994 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1995 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1996 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1997 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1998 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2000 /* We simply ignore the field in this case to avoid confusion:
2001 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2004 default: strcat (buf
, ", unknown CPU"); break;
2007 switch ((e_flags
& EF_MIPS_ABI
))
2009 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2010 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2011 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2012 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2014 /* We simply ignore the field in this case to avoid confusion:
2015 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2016 This means it is likely to be an o32 file, but not for
2019 default: strcat (buf
, ", unknown ABI"); break;
2022 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2023 strcat (buf
, ", mdmx");
2025 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2026 strcat (buf
, ", mips16");
2028 switch ((e_flags
& EF_MIPS_ARCH
))
2030 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2031 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2032 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2033 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2034 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2035 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2036 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2037 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2038 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2039 default: strcat (buf
, ", unknown ISA"); break;
2045 switch ((e_flags
& EF_SH_MACH_MASK
))
2047 case EF_SH1
: strcat (buf
, ", sh1"); break;
2048 case EF_SH2
: strcat (buf
, ", sh2"); break;
2049 case EF_SH3
: strcat (buf
, ", sh3"); break;
2050 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2051 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2052 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2053 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2054 case EF_SH4
: strcat (buf
, ", sh4"); break;
2055 case EF_SH5
: strcat (buf
, ", sh5"); break;
2056 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2057 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2058 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2059 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2060 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2061 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2062 default: strcat (buf
, ", unknown ISA"); break;
2068 if (e_flags
& EF_SPARC_32PLUS
)
2069 strcat (buf
, ", v8+");
2071 if (e_flags
& EF_SPARC_SUN_US1
)
2072 strcat (buf
, ", ultrasparcI");
2074 if (e_flags
& EF_SPARC_SUN_US3
)
2075 strcat (buf
, ", ultrasparcIII");
2077 if (e_flags
& EF_SPARC_HAL_R1
)
2078 strcat (buf
, ", halr1");
2080 if (e_flags
& EF_SPARC_LEDATA
)
2081 strcat (buf
, ", ledata");
2083 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2084 strcat (buf
, ", tso");
2086 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2087 strcat (buf
, ", pso");
2089 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2090 strcat (buf
, ", rmo");
2094 switch (e_flags
& EF_PARISC_ARCH
)
2096 case EFA_PARISC_1_0
:
2097 strcpy (buf
, ", PA-RISC 1.0");
2099 case EFA_PARISC_1_1
:
2100 strcpy (buf
, ", PA-RISC 1.1");
2102 case EFA_PARISC_2_0
:
2103 strcpy (buf
, ", PA-RISC 2.0");
2108 if (e_flags
& EF_PARISC_TRAPNIL
)
2109 strcat (buf
, ", trapnil");
2110 if (e_flags
& EF_PARISC_EXT
)
2111 strcat (buf
, ", ext");
2112 if (e_flags
& EF_PARISC_LSB
)
2113 strcat (buf
, ", lsb");
2114 if (e_flags
& EF_PARISC_WIDE
)
2115 strcat (buf
, ", wide");
2116 if (e_flags
& EF_PARISC_NO_KABP
)
2117 strcat (buf
, ", no kabp");
2118 if (e_flags
& EF_PARISC_LAZYSWAP
)
2119 strcat (buf
, ", lazyswap");
2124 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2125 strcat (buf
, ", new calling convention");
2127 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2128 strcat (buf
, ", gnu calling convention");
2132 if ((e_flags
& EF_IA_64_ABI64
))
2133 strcat (buf
, ", 64-bit");
2135 strcat (buf
, ", 32-bit");
2136 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2137 strcat (buf
, ", reduced fp model");
2138 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2139 strcat (buf
, ", no function descriptors, constant gp");
2140 else if ((e_flags
& EF_IA_64_CONS_GP
))
2141 strcat (buf
, ", constant gp");
2142 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2143 strcat (buf
, ", absolute");
2147 if ((e_flags
& EF_VAX_NONPIC
))
2148 strcat (buf
, ", non-PIC");
2149 if ((e_flags
& EF_VAX_DFLOAT
))
2150 strcat (buf
, ", D-Float");
2151 if ((e_flags
& EF_VAX_GFLOAT
))
2152 strcat (buf
, ", G-Float");
2161 get_osabi_name (unsigned int osabi
)
2163 static char buff
[32];
2167 case ELFOSABI_NONE
: return "UNIX - System V";
2168 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2169 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2170 case ELFOSABI_LINUX
: return "UNIX - Linux";
2171 case ELFOSABI_HURD
: return "GNU/Hurd";
2172 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2173 case ELFOSABI_AIX
: return "UNIX - AIX";
2174 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2175 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2176 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2177 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2178 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2179 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2180 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2181 case ELFOSABI_AROS
: return "Amiga Research OS";
2182 case ELFOSABI_STANDALONE
: return _("Standalone App");
2183 case ELFOSABI_ARM
: return "ARM";
2185 sprintf (buff
, _("<unknown: %x>"), osabi
);
2191 get_mips_segment_type (unsigned long type
)
2195 case PT_MIPS_REGINFO
:
2197 case PT_MIPS_RTPROC
:
2199 case PT_MIPS_OPTIONS
:
2209 get_parisc_segment_type (unsigned long type
)
2213 case PT_HP_TLS
: return "HP_TLS";
2214 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2215 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2216 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2217 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2218 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2219 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2220 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2221 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2222 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2223 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2224 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2225 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2226 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2235 get_ia64_segment_type (unsigned long type
)
2239 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2240 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2241 case PT_HP_TLS
: return "HP_TLS";
2242 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2243 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2244 case PT_IA_64_HP_STACK
: return "HP_STACK";
2253 get_segment_type (unsigned long p_type
)
2255 static char buff
[32];
2259 case PT_NULL
: return "NULL";
2260 case PT_LOAD
: return "LOAD";
2261 case PT_DYNAMIC
: return "DYNAMIC";
2262 case PT_INTERP
: return "INTERP";
2263 case PT_NOTE
: return "NOTE";
2264 case PT_SHLIB
: return "SHLIB";
2265 case PT_PHDR
: return "PHDR";
2266 case PT_TLS
: return "TLS";
2268 case PT_GNU_EH_FRAME
:
2269 return "GNU_EH_FRAME";
2270 case PT_GNU_STACK
: return "GNU_STACK";
2271 case PT_GNU_RELRO
: return "GNU_RELRO";
2274 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2278 switch (elf_header
.e_machine
)
2281 case EM_MIPS_RS3_LE
:
2282 result
= get_mips_segment_type (p_type
);
2285 result
= get_parisc_segment_type (p_type
);
2288 result
= get_ia64_segment_type (p_type
);
2298 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2300 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2304 switch (elf_header
.e_machine
)
2307 result
= get_parisc_segment_type (p_type
);
2310 result
= get_ia64_segment_type (p_type
);
2320 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2323 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2330 get_mips_section_type_name (unsigned int sh_type
)
2334 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2335 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2336 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2337 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2338 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2339 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2340 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2341 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2342 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2343 case SHT_MIPS_RELD
: return "MIPS_RELD";
2344 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2345 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2346 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2347 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2348 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2349 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2350 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2351 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2352 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2353 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2354 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2355 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2356 case SHT_MIPS_LINE
: return "MIPS_LINE";
2357 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2358 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2359 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2360 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2361 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2362 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2363 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2364 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2365 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2366 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2367 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2368 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2369 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2370 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2371 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2372 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2380 get_parisc_section_type_name (unsigned int sh_type
)
2384 case SHT_PARISC_EXT
: return "PARISC_EXT";
2385 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2386 case SHT_PARISC_DOC
: return "PARISC_DOC";
2394 get_ia64_section_type_name (unsigned int sh_type
)
2396 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2397 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2398 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2402 case SHT_IA_64_EXT
: return "IA_64_EXT";
2403 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2404 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2412 get_x86_64_section_type_name (unsigned int sh_type
)
2416 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2424 get_arm_section_type_name (unsigned int sh_type
)
2437 get_section_type_name (unsigned int sh_type
)
2439 static char buff
[32];
2443 case SHT_NULL
: return "NULL";
2444 case SHT_PROGBITS
: return "PROGBITS";
2445 case SHT_SYMTAB
: return "SYMTAB";
2446 case SHT_STRTAB
: return "STRTAB";
2447 case SHT_RELA
: return "RELA";
2448 case SHT_HASH
: return "HASH";
2449 case SHT_DYNAMIC
: return "DYNAMIC";
2450 case SHT_NOTE
: return "NOTE";
2451 case SHT_NOBITS
: return "NOBITS";
2452 case SHT_REL
: return "REL";
2453 case SHT_SHLIB
: return "SHLIB";
2454 case SHT_DYNSYM
: return "DYNSYM";
2455 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2456 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2457 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2458 case SHT_GROUP
: return "GROUP";
2459 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2460 case SHT_GNU_verdef
: return "VERDEF";
2461 case SHT_GNU_verneed
: return "VERNEED";
2462 case SHT_GNU_versym
: return "VERSYM";
2463 case 0x6ffffff0: return "VERSYM";
2464 case 0x6ffffffc: return "VERDEF";
2465 case 0x7ffffffd: return "AUXILIARY";
2466 case 0x7fffffff: return "FILTER";
2467 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2470 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2474 switch (elf_header
.e_machine
)
2477 case EM_MIPS_RS3_LE
:
2478 result
= get_mips_section_type_name (sh_type
);
2481 result
= get_parisc_section_type_name (sh_type
);
2484 result
= get_ia64_section_type_name (sh_type
);
2487 result
= get_x86_64_section_type_name (sh_type
);
2490 result
= get_arm_section_type_name (sh_type
);
2500 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2502 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2503 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2504 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2505 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2507 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2513 #define OPTION_DEBUG_DUMP 512
2515 struct option options
[] =
2517 {"all", no_argument
, 0, 'a'},
2518 {"file-header", no_argument
, 0, 'h'},
2519 {"program-headers", no_argument
, 0, 'l'},
2520 {"headers", no_argument
, 0, 'e'},
2521 {"histogram", no_argument
, 0, 'I'},
2522 {"segments", no_argument
, 0, 'l'},
2523 {"sections", no_argument
, 0, 'S'},
2524 {"section-headers", no_argument
, 0, 'S'},
2525 {"section-groups", no_argument
, 0, 'g'},
2526 {"symbols", no_argument
, 0, 's'},
2527 {"syms", no_argument
, 0, 's'},
2528 {"relocs", no_argument
, 0, 'r'},
2529 {"notes", no_argument
, 0, 'n'},
2530 {"dynamic", no_argument
, 0, 'd'},
2531 {"arch-specific", no_argument
, 0, 'A'},
2532 {"version-info", no_argument
, 0, 'V'},
2533 {"use-dynamic", no_argument
, 0, 'D'},
2534 {"hex-dump", required_argument
, 0, 'x'},
2535 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2536 {"unwind", no_argument
, 0, 'u'},
2537 #ifdef SUPPORT_DISASSEMBLY
2538 {"instruction-dump", required_argument
, 0, 'i'},
2541 {"version", no_argument
, 0, 'v'},
2542 {"wide", no_argument
, 0, 'W'},
2543 {"help", no_argument
, 0, 'H'},
2544 {0, no_argument
, 0, 0}
2550 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2551 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2552 fprintf (stdout
, _(" Options are:\n\
2553 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2554 -h --file-header Display the ELF file header\n\
2555 -l --program-headers Display the program headers\n\
2556 --segments An alias for --program-headers\n\
2557 -S --section-headers Display the sections' header\n\
2558 --sections An alias for --section-headers\n\
2559 -g --section-groups Display the section groups\n\
2560 -e --headers Equivalent to: -h -l -S\n\
2561 -s --syms Display the symbol table\n\
2562 --symbols An alias for --syms\n\
2563 -n --notes Display the core notes (if present)\n\
2564 -r --relocs Display the relocations (if present)\n\
2565 -u --unwind Display the unwind info (if present)\n\
2566 -d --dynamic Display the dynamic section (if present)\n\
2567 -V --version-info Display the version sections (if present)\n\
2568 -A --arch-specific Display architecture specific information (if any).\n\
2569 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2570 -x --hex-dump=<number> Dump the contents of section <number>\n\
2571 -w[liaprmfFso] or\n\
2572 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2573 Display the contents of DWARF2 debug sections\n"));
2574 #ifdef SUPPORT_DISASSEMBLY
2575 fprintf (stdout
, _("\
2576 -i --instruction-dump=<number>\n\
2577 Disassemble the contents of section <number>\n"));
2579 fprintf (stdout
, _("\
2580 -I --histogram Display histogram of bucket list lengths\n\
2581 -W --wide Allow output width to exceed 80 characters\n\
2582 -H --help Display this information\n\
2583 -v --version Display the version number of readelf\n"));
2584 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2590 request_dump (unsigned int section
, int type
)
2592 if (section
>= num_dump_sects
)
2594 char *new_dump_sects
;
2596 new_dump_sects
= calloc (section
+ 1, 1);
2598 if (new_dump_sects
== NULL
)
2599 error (_("Out of memory allocating dump request table."));
2602 /* Copy current flag settings. */
2603 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2607 dump_sects
= new_dump_sects
;
2608 num_dump_sects
= section
+ 1;
2613 dump_sects
[section
] |= type
;
2619 parse_args (int argc
, char **argv
)
2626 while ((c
= getopt_long
2627 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2648 do_section_groups
++;
2656 do_section_groups
++;
2698 section
= strtoul (optarg
, & cp
, 0);
2699 if (! *cp
&& section
>= 0)
2701 request_dump (section
, HEX_DUMP
);
2711 unsigned int index
= 0;
2715 while (optarg
[index
])
2716 switch (optarg
[index
++])
2725 do_debug_abbrevs
= 1;
2735 do_debug_pubnames
= 1;
2740 do_debug_aranges
= 1;
2744 do_debug_frames_interp
= 1;
2746 do_debug_frames
= 1;
2751 do_debug_macinfo
= 1;
2765 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2770 case OPTION_DEBUG_DUMP
:
2776 static const char *debug_dump_opt
[]
2777 = { "line", "info", "abbrev", "pubnames", "ranges",
2778 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2787 for (index
= 0; debug_dump_opt
[index
]; index
++)
2789 size_t len
= strlen (debug_dump_opt
[index
]);
2791 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2792 && (p
[len
] == ',' || p
[len
] == '\0'))
2801 do_debug_abbrevs
= 1;
2812 do_debug_pubnames
= 1;
2816 do_debug_aranges
= 1;
2821 do_debug_frames_interp
= 1;
2822 do_debug_frames
= 1;
2826 do_debug_macinfo
= 1;
2839 if (debug_dump_opt
[index
] == NULL
)
2841 warn (_("Unrecognized debug option '%s'\n"), p
);
2842 p
= strchr (p
, ',');
2852 #ifdef SUPPORT_DISASSEMBLY
2855 section
= strtoul (optarg
, & cp
, 0);
2856 if (! *cp
&& section
>= 0)
2858 request_dump (section
, DISASS_DUMP
);
2864 print_version (program_name
);
2874 /* xgettext:c-format */
2875 error (_("Invalid option '-%c'\n"), c
);
2882 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2883 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2884 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2885 && !do_section_groups
)
2889 warn (_("Nothing to do.\n"));
2895 get_elf_class (unsigned int elf_class
)
2897 static char buff
[32];
2901 case ELFCLASSNONE
: return _("none");
2902 case ELFCLASS32
: return "ELF32";
2903 case ELFCLASS64
: return "ELF64";
2905 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2911 get_data_encoding (unsigned int encoding
)
2913 static char buff
[32];
2917 case ELFDATANONE
: return _("none");
2918 case ELFDATA2LSB
: return _("2's complement, little endian");
2919 case ELFDATA2MSB
: return _("2's complement, big endian");
2921 sprintf (buff
, _("<unknown: %x>"), encoding
);
2926 /* Decode the data held in 'elf_header'. */
2929 process_file_header (void)
2931 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2932 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2933 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2934 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2937 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2945 printf (_("ELF Header:\n"));
2946 printf (_(" Magic: "));
2947 for (i
= 0; i
< EI_NIDENT
; i
++)
2948 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2950 printf (_(" Class: %s\n"),
2951 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2952 printf (_(" Data: %s\n"),
2953 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2954 printf (_(" Version: %d %s\n"),
2955 elf_header
.e_ident
[EI_VERSION
],
2956 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2958 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2961 printf (_(" OS/ABI: %s\n"),
2962 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2963 printf (_(" ABI Version: %d\n"),
2964 elf_header
.e_ident
[EI_ABIVERSION
]);
2965 printf (_(" Type: %s\n"),
2966 get_file_type (elf_header
.e_type
));
2967 printf (_(" Machine: %s\n"),
2968 get_machine_name (elf_header
.e_machine
));
2969 printf (_(" Version: 0x%lx\n"),
2970 (unsigned long) elf_header
.e_version
);
2972 printf (_(" Entry point address: "));
2973 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2974 printf (_("\n Start of program headers: "));
2975 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2976 printf (_(" (bytes into file)\n Start of section headers: "));
2977 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2978 printf (_(" (bytes into file)\n"));
2980 printf (_(" Flags: 0x%lx%s\n"),
2981 (unsigned long) elf_header
.e_flags
,
2982 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2983 printf (_(" Size of this header: %ld (bytes)\n"),
2984 (long) elf_header
.e_ehsize
);
2985 printf (_(" Size of program headers: %ld (bytes)\n"),
2986 (long) elf_header
.e_phentsize
);
2987 printf (_(" Number of program headers: %ld\n"),
2988 (long) elf_header
.e_phnum
);
2989 printf (_(" Size of section headers: %ld (bytes)\n"),
2990 (long) elf_header
.e_shentsize
);
2991 printf (_(" Number of section headers: %ld"),
2992 (long) elf_header
.e_shnum
);
2993 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2994 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2995 putc ('\n', stdout
);
2996 printf (_(" Section header string table index: %ld"),
2997 (long) elf_header
.e_shstrndx
);
2998 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2999 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3000 putc ('\n', stdout
);
3003 if (section_headers
!= NULL
)
3005 if (elf_header
.e_shnum
== 0)
3006 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3007 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3008 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3009 free (section_headers
);
3010 section_headers
= NULL
;
3018 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3020 Elf32_External_Phdr
*phdrs
;
3021 Elf32_External_Phdr
*external
;
3022 Elf_Internal_Phdr
*internal
;
3025 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3026 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3027 _("program headers"));
3031 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3032 i
< elf_header
.e_phnum
;
3033 i
++, internal
++, external
++)
3035 internal
->p_type
= BYTE_GET (external
->p_type
);
3036 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3037 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3038 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3039 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3040 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3041 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3042 internal
->p_align
= BYTE_GET (external
->p_align
);
3051 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3053 Elf64_External_Phdr
*phdrs
;
3054 Elf64_External_Phdr
*external
;
3055 Elf_Internal_Phdr
*internal
;
3058 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3059 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3060 _("program headers"));
3064 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3065 i
< elf_header
.e_phnum
;
3066 i
++, internal
++, external
++)
3068 internal
->p_type
= BYTE_GET (external
->p_type
);
3069 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3070 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
3071 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
3072 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
3073 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
3074 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
3075 internal
->p_align
= BYTE_GET8 (external
->p_align
);
3083 /* Returns 1 if the program headers were read into `program_headers'. */
3086 get_program_headers (FILE *file
)
3088 Elf_Internal_Phdr
*phdrs
;
3090 /* Check cache of prior read. */
3091 if (program_headers
!= NULL
)
3094 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3098 error (_("Out of memory\n"));
3103 ? get_32bit_program_headers (file
, phdrs
)
3104 : get_64bit_program_headers (file
, phdrs
))
3106 program_headers
= phdrs
;
3114 /* Returns 1 if the program headers were loaded. */
3117 process_program_headers (FILE *file
)
3119 Elf_Internal_Phdr
*segment
;
3122 if (elf_header
.e_phnum
== 0)
3125 printf (_("\nThere are no program headers in this file.\n"));
3129 if (do_segments
&& !do_header
)
3131 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3132 printf (_("Entry point "));
3133 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3134 printf (_("\nThere are %d program headers, starting at offset "),
3135 elf_header
.e_phnum
);
3136 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3140 if (! get_program_headers (file
))
3145 if (elf_header
.e_phnum
> 1)
3146 printf (_("\nProgram Headers:\n"));
3148 printf (_("\nProgram Headers:\n"));
3152 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3155 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3159 (_(" Type Offset VirtAddr PhysAddr\n"));
3161 (_(" FileSiz MemSiz Flags Align\n"));
3168 for (i
= 0, segment
= program_headers
;
3169 i
< elf_header
.e_phnum
;
3174 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3178 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3179 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3180 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3181 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3182 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3184 (segment
->p_flags
& PF_R
? 'R' : ' '),
3185 (segment
->p_flags
& PF_W
? 'W' : ' '),
3186 (segment
->p_flags
& PF_X
? 'E' : ' '));
3187 printf ("%#lx", (unsigned long) segment
->p_align
);
3191 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3192 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3195 print_vma (segment
->p_offset
, FULL_HEX
);
3199 print_vma (segment
->p_vaddr
, FULL_HEX
);
3201 print_vma (segment
->p_paddr
, FULL_HEX
);
3204 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3205 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3208 print_vma (segment
->p_filesz
, FULL_HEX
);
3212 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3213 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3216 print_vma (segment
->p_offset
, FULL_HEX
);
3220 (segment
->p_flags
& PF_R
? 'R' : ' '),
3221 (segment
->p_flags
& PF_W
? 'W' : ' '),
3222 (segment
->p_flags
& PF_X
? 'E' : ' '));
3224 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3225 printf ("%#lx", (unsigned long) segment
->p_align
);
3228 print_vma (segment
->p_align
, PREFIX_HEX
);
3233 print_vma (segment
->p_offset
, FULL_HEX
);
3235 print_vma (segment
->p_vaddr
, FULL_HEX
);
3237 print_vma (segment
->p_paddr
, FULL_HEX
);
3239 print_vma (segment
->p_filesz
, FULL_HEX
);
3241 print_vma (segment
->p_memsz
, FULL_HEX
);
3243 (segment
->p_flags
& PF_R
? 'R' : ' '),
3244 (segment
->p_flags
& PF_W
? 'W' : ' '),
3245 (segment
->p_flags
& PF_X
? 'E' : ' '));
3246 print_vma (segment
->p_align
, HEX
);
3250 switch (segment
->p_type
)
3254 error (_("more than one dynamic segment\n"));
3256 /* Try to locate the .dynamic section. If there is
3257 a section header table, we can easily locate it. */
3258 if (section_headers
!= NULL
)
3260 Elf_Internal_Shdr
*sec
;
3263 for (j
= 0, sec
= section_headers
;
3264 j
< elf_header
.e_shnum
;
3266 if (strcmp (SECTION_NAME (sec
), ".dynamic") == 0)
3269 if (j
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
3271 error (_("no .dynamic section in the dynamic segment"));
3275 dynamic_addr
= sec
->sh_offset
;
3276 dynamic_size
= sec
->sh_size
;
3278 if (dynamic_addr
< segment
->p_offset
3279 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3280 warn (_("the .dynamic section is not contained within the dynamic segment"));
3281 else if (dynamic_addr
> segment
->p_offset
)
3282 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3286 /* Otherwise, we can only assume that the .dynamic
3287 section is the first section in the DYNAMIC segment. */
3288 dynamic_addr
= segment
->p_offset
;
3289 dynamic_size
= segment
->p_filesz
;
3294 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3296 error (_("Unable to find program interpreter name\n"));
3299 program_interpreter
[0] = 0;
3300 fscanf (file
, "%63s", program_interpreter
);
3303 printf (_("\n [Requesting program interpreter: %s]"),
3304 program_interpreter
);
3310 putc ('\n', stdout
);
3313 if (do_segments
&& section_headers
!= NULL
)
3315 printf (_("\n Section to Segment mapping:\n"));
3316 printf (_(" Segment Sections...\n"));
3318 assert (string_table
!= NULL
);
3320 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3323 Elf_Internal_Shdr
*section
;
3325 segment
= program_headers
+ i
;
3326 section
= section_headers
;
3328 printf (" %2.2d ", i
);
3330 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3332 if (section
->sh_size
> 0
3333 /* Compare allocated sections by VMA, unallocated
3334 sections by file offset. */
3335 && (section
->sh_flags
& SHF_ALLOC
3336 ? (section
->sh_addr
>= segment
->p_vaddr
3337 && section
->sh_addr
+ section
->sh_size
3338 <= segment
->p_vaddr
+ segment
->p_memsz
)
3339 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3340 && (section
->sh_offset
+ section
->sh_size
3341 <= segment
->p_offset
+ segment
->p_filesz
)))
3342 /* .tbss is special. It doesn't contribute memory space
3343 to normal segments. */
3344 && (!((section
->sh_flags
& SHF_TLS
) != 0
3345 && section
->sh_type
== SHT_NOBITS
)
3346 || segment
->p_type
== PT_TLS
))
3347 printf ("%s ", SECTION_NAME (section
));
3358 /* Find the file offset corresponding to VMA by using the program headers. */
3361 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3363 Elf_Internal_Phdr
*seg
;
3365 if (! get_program_headers (file
))
3367 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3371 for (seg
= program_headers
;
3372 seg
< program_headers
+ elf_header
.e_phnum
;
3375 if (seg
->p_type
!= PT_LOAD
)
3378 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3379 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3380 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3383 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3390 get_32bit_section_headers (FILE *file
, unsigned int num
)
3392 Elf32_External_Shdr
*shdrs
;
3393 Elf_Internal_Shdr
*internal
;
3396 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3397 elf_header
.e_shentsize
* num
, _("section headers"));
3401 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3403 if (section_headers
== NULL
)
3405 error (_("Out of memory\n"));
3409 for (i
= 0, internal
= section_headers
;
3413 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3414 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3415 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3416 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3417 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3418 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3419 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3420 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3421 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3422 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3431 get_64bit_section_headers (FILE *file
, unsigned int num
)
3433 Elf64_External_Shdr
*shdrs
;
3434 Elf_Internal_Shdr
*internal
;
3437 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3438 elf_header
.e_shentsize
* num
, _("section headers"));
3442 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3444 if (section_headers
== NULL
)
3446 error (_("Out of memory\n"));
3450 for (i
= 0, internal
= section_headers
;
3454 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3455 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3456 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
3457 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3458 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3459 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3460 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3461 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3462 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3463 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3471 static Elf_Internal_Sym
*
3472 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3474 unsigned long number
;
3475 Elf32_External_Sym
*esyms
;
3476 Elf_External_Sym_Shndx
*shndx
;
3477 Elf_Internal_Sym
*isyms
;
3478 Elf_Internal_Sym
*psym
;
3481 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3487 if (symtab_shndx_hdr
!= NULL
3488 && (symtab_shndx_hdr
->sh_link
3489 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3491 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3492 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3500 number
= section
->sh_size
/ section
->sh_entsize
;
3501 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3505 error (_("Out of memory\n"));
3512 for (j
= 0, psym
= isyms
;
3516 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3517 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3518 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3519 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3520 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3522 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3523 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3524 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3534 static Elf_Internal_Sym
*
3535 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3537 unsigned long number
;
3538 Elf64_External_Sym
*esyms
;
3539 Elf_External_Sym_Shndx
*shndx
;
3540 Elf_Internal_Sym
*isyms
;
3541 Elf_Internal_Sym
*psym
;
3544 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3550 if (symtab_shndx_hdr
!= NULL
3551 && (symtab_shndx_hdr
->sh_link
3552 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3554 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3555 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3563 number
= section
->sh_size
/ section
->sh_entsize
;
3564 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3568 error (_("Out of memory\n"));
3575 for (j
= 0, psym
= isyms
;
3579 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3580 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3581 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3582 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3583 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3585 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3586 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3587 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3598 get_elf_section_flags (bfd_vma sh_flags
)
3600 static char buff
[32];
3608 flag
= sh_flags
& - sh_flags
;
3613 case SHF_WRITE
: strcat (buff
, "W"); break;
3614 case SHF_ALLOC
: strcat (buff
, "A"); break;
3615 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3616 case SHF_MERGE
: strcat (buff
, "M"); break;
3617 case SHF_STRINGS
: strcat (buff
, "S"); break;
3618 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3619 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3620 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3621 case SHF_GROUP
: strcat (buff
, "G"); break;
3622 case SHF_TLS
: strcat (buff
, "T"); break;
3625 if (flag
& SHF_MASKOS
)
3628 sh_flags
&= ~ SHF_MASKOS
;
3630 else if (flag
& SHF_MASKPROC
)
3633 sh_flags
&= ~ SHF_MASKPROC
;
3645 process_section_headers (FILE *file
)
3647 Elf_Internal_Shdr
*section
;
3650 section_headers
= NULL
;
3652 if (elf_header
.e_shnum
== 0)
3655 printf (_("\nThere are no sections in this file.\n"));
3660 if (do_sections
&& !do_header
)
3661 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3662 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3666 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3669 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3672 /* Read in the string table, so that we have names to display. */
3673 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3675 if (section
->sh_size
!= 0)
3677 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3678 section
->sh_size
, _("string table"));
3680 if (string_table
== NULL
)
3683 string_table_length
= section
->sh_size
;
3686 /* Scan the sections for the dynamic symbol table
3687 and dynamic string table and debug sections. */
3688 dynamic_symbols
= NULL
;
3689 dynamic_strings
= NULL
;
3690 dynamic_syminfo
= NULL
;
3691 symtab_shndx_hdr
= NULL
;
3693 for (i
= 0, section
= section_headers
;
3694 i
< elf_header
.e_shnum
;
3697 char *name
= SECTION_NAME (section
);
3699 if (section
->sh_type
== SHT_DYNSYM
)
3701 if (dynamic_symbols
!= NULL
)
3703 error (_("File contains multiple dynamic symbol tables\n"));
3707 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3708 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3710 else if (section
->sh_type
== SHT_STRTAB
3711 && strcmp (name
, ".dynstr") == 0)
3713 if (dynamic_strings
!= NULL
)
3715 error (_("File contains multiple dynamic string tables\n"));
3719 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3720 section
->sh_size
, _("dynamic strings"));
3722 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3724 if (symtab_shndx_hdr
!= NULL
)
3726 error (_("File contains multiple symtab shndx tables\n"));
3729 symtab_shndx_hdr
= section
;
3731 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3732 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3733 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3735 && strncmp (name
, ".debug_", 7) == 0)
3740 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3741 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3742 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3743 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3744 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3745 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3746 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3747 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3748 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3750 request_dump (i
, DEBUG_DUMP
);
3752 /* linkonce section to be combined with .debug_info at link time. */
3753 else if ((do_debugging
|| do_debug_info
)
3754 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3755 request_dump (i
, DEBUG_DUMP
);
3756 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3757 request_dump (i
, DEBUG_DUMP
);
3763 if (elf_header
.e_shnum
> 1)
3764 printf (_("\nSection Headers:\n"));
3766 printf (_("\nSection Header:\n"));
3770 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3773 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3776 printf (_(" [Nr] Name Type Address Offset\n"));
3777 printf (_(" Size EntSize Flags Link Info Align\n"));
3780 for (i
= 0, section
= section_headers
;
3781 i
< elf_header
.e_shnum
;
3784 printf (" [%2u] %-17.17s %-15.15s ",
3785 SECTION_HEADER_NUM (i
),
3786 SECTION_NAME (section
),
3787 get_section_type_name (section
->sh_type
));
3791 print_vma (section
->sh_addr
, LONG_HEX
);
3793 printf ( " %6.6lx %6.6lx %2.2lx",
3794 (unsigned long) section
->sh_offset
,
3795 (unsigned long) section
->sh_size
,
3796 (unsigned long) section
->sh_entsize
);
3798 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3800 printf ("%2ld %3lu %2ld\n",
3801 (unsigned long) section
->sh_link
,
3802 (unsigned long) section
->sh_info
,
3803 (unsigned long) section
->sh_addralign
);
3807 print_vma (section
->sh_addr
, LONG_HEX
);
3809 if ((long) section
->sh_offset
== section
->sh_offset
)
3810 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3814 print_vma (section
->sh_offset
, LONG_HEX
);
3817 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3818 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3822 print_vma (section
->sh_size
, LONG_HEX
);
3825 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3826 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3830 print_vma (section
->sh_entsize
, LONG_HEX
);
3833 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3835 printf ("%2ld %3lu ",
3836 (unsigned long) section
->sh_link
,
3837 (unsigned long) section
->sh_info
);
3839 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3840 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3843 print_vma (section
->sh_addralign
, DEC
);
3850 print_vma (section
->sh_addr
, LONG_HEX
);
3851 if ((long) section
->sh_offset
== section
->sh_offset
)
3852 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3856 print_vma (section
->sh_offset
, LONG_HEX
);
3859 print_vma (section
->sh_size
, LONG_HEX
);
3861 print_vma (section
->sh_entsize
, LONG_HEX
);
3863 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3865 printf (" %2ld %3lu %ld\n",
3866 (unsigned long) section
->sh_link
,
3867 (unsigned long) section
->sh_info
,
3868 (unsigned long) section
->sh_addralign
);
3872 printf (_("Key to Flags:\n\
3873 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3874 I (info), L (link order), G (group), x (unknown)\n\
3875 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3881 get_group_flags (unsigned int flags
)
3883 static char buff
[32];
3890 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3897 process_section_groups (FILE *file
)
3899 Elf_Internal_Shdr
*section
;
3901 struct group
*group
;
3903 if (elf_header
.e_shnum
== 0)
3905 if (do_section_groups
)
3906 printf (_("\nThere are no section groups in this file.\n"));
3911 if (section_headers
== NULL
)
3913 error (_("Section headers are not available!\n"));
3917 section_headers_groups
= calloc (elf_header
.e_shnum
,
3918 sizeof (struct group
*));
3920 if (section_headers_groups
== NULL
)
3922 error (_("Out of memory\n"));
3926 /* Scan the sections for the group section. */
3927 for (i
= 0, section
= section_headers
;
3928 i
< elf_header
.e_shnum
;
3930 if (section
->sh_type
== SHT_GROUP
)
3933 section_groups
= calloc (group_count
, sizeof (struct group
));
3935 if (section_groups
== NULL
)
3937 error (_("Out of memory\n"));
3941 for (i
= 0, section
= section_headers
, group
= section_groups
;
3942 i
< elf_header
.e_shnum
;
3945 if (section
->sh_type
== SHT_GROUP
)
3947 char *name
= SECTION_NAME (section
);
3948 char *group_name
, *strtab
, *start
, *indices
;
3949 unsigned int entry
, j
, size
;
3950 Elf_Internal_Sym
*sym
;
3951 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
, *sec
;
3952 Elf_Internal_Sym
*symtab
;
3954 /* Get the symbol table. */
3955 symtab_sec
= SECTION_HEADER (section
->sh_link
);
3956 if (symtab_sec
->sh_type
!= SHT_SYMTAB
)
3958 error (_("Bad sh_link in group section `%s'\n"), name
);
3961 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
3963 sym
= symtab
+ section
->sh_info
;
3965 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3967 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
3970 error (_("Bad sh_info in group section `%s'\n"), name
);
3974 group_name
= SECTION_NAME (section_headers
+ sec_index
);
3979 /* Get the string table. */
3980 strtab_sec
= SECTION_HEADER (symtab_sec
->sh_link
);
3981 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
3982 strtab_sec
->sh_size
,
3985 group_name
= strtab
+ sym
->st_name
;
3988 start
= get_data (NULL
, file
, section
->sh_offset
,
3989 section
->sh_size
, _("section data"));
3992 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
3993 entry
= byte_get (indices
, 4);
3996 if (do_section_groups
)
3998 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
3999 get_group_flags (entry
), name
, group_name
, size
);
4001 printf (_(" [Index] Name\n"));
4004 group
->group_index
= i
;
4006 for (j
= 0; j
< size
; j
++)
4008 struct group_list
*g
;
4010 entry
= byte_get (indices
, 4);
4013 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4016 error (_("section [%5u] already in group section [%5u]\n"),
4017 entry
, section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4021 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4024 if (do_section_groups
)
4026 sec
= SECTION_HEADER (entry
);
4027 printf (" [%5u] %s\n",
4028 entry
, SECTION_NAME (sec
));
4031 g
= xmalloc (sizeof (struct group_list
));
4032 g
->section_index
= entry
;
4033 g
->next
= group
->root
;
4057 } dynamic_relocations
[] =
4059 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4060 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4061 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4064 /* Process the reloc section. */
4066 process_relocs (FILE *file
)
4068 unsigned long rel_size
;
4069 unsigned long rel_offset
;
4075 if (do_using_dynamic
)
4079 int has_dynamic_reloc
;
4082 has_dynamic_reloc
= 0;
4084 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4086 is_rela
= dynamic_relocations
[i
].rela
;
4087 name
= dynamic_relocations
[i
].name
;
4088 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4089 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4091 has_dynamic_reloc
|= rel_size
;
4093 if (is_rela
== UNKNOWN
)
4095 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4096 switch (dynamic_info
[DT_PLTREL
])
4110 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4111 name
, rel_offset
, rel_size
);
4113 dump_relocations (file
,
4114 offset_from_vma (file
, rel_offset
, rel_size
),
4116 dynamic_symbols
, num_dynamic_syms
,
4117 dynamic_strings
, is_rela
);
4121 if (! has_dynamic_reloc
)
4122 printf (_("\nThere are no dynamic relocations in this file.\n"));
4126 Elf_Internal_Shdr
*section
;
4130 for (i
= 0, section
= section_headers
;
4131 i
< elf_header
.e_shnum
;
4134 if ( section
->sh_type
!= SHT_RELA
4135 && section
->sh_type
!= SHT_REL
)
4138 rel_offset
= section
->sh_offset
;
4139 rel_size
= section
->sh_size
;
4143 Elf_Internal_Shdr
*strsec
;
4144 Elf_Internal_Sym
*symtab
;
4147 unsigned long nsyms
;
4149 printf (_("\nRelocation section "));
4151 if (string_table
== NULL
)
4152 printf ("%d", section
->sh_name
);
4154 printf (_("'%s'"), SECTION_NAME (section
));
4156 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4157 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4162 if (section
->sh_link
)
4164 Elf_Internal_Shdr
*symsec
;
4166 symsec
= SECTION_HEADER (section
->sh_link
);
4167 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4168 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4173 strsec
= SECTION_HEADER (symsec
->sh_link
);
4175 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4176 strsec
->sh_size
, _("string table"));
4178 is_rela
= section
->sh_type
== SHT_RELA
;
4180 dump_relocations (file
, rel_offset
, rel_size
,
4181 symtab
, nsyms
, strtab
, is_rela
);
4193 printf (_("\nThere are no relocations in this file.\n"));
4199 #include "unwind-ia64.h"
4201 /* An absolute address consists of a section and an offset. If the
4202 section is NULL, the offset itself is the address, otherwise, the
4203 address equals to LOAD_ADDRESS(section) + offset. */
4207 unsigned short section
;
4213 struct unw_table_entry
4215 struct absaddr start
;
4217 struct absaddr info
;
4219 *table
; /* Unwind table. */
4220 unsigned long table_len
; /* Length of unwind table. */
4221 unsigned char *info
; /* Unwind info. */
4222 unsigned long info_size
; /* Size of unwind info. */
4223 bfd_vma info_addr
; /* starting address of unwind info. */
4224 bfd_vma seg_base
; /* Starting address of segment. */
4225 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4226 unsigned long nsyms
; /* Number of symbols. */
4227 char *strtab
; /* The string table. */
4228 unsigned long strtab_size
; /* Size of string table. */
4232 find_symbol_for_address (struct unw_aux_info
*aux
,
4233 struct absaddr addr
,
4234 const char **symname
,
4237 bfd_vma dist
= 0x100000;
4238 Elf_Internal_Sym
*sym
, *best
= NULL
;
4241 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
4243 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4244 && sym
->st_name
!= 0
4245 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4246 && addr
.offset
>= sym
->st_value
4247 && addr
.offset
- sym
->st_value
< dist
)
4250 dist
= addr
.offset
- sym
->st_value
;
4257 *symname
= (best
->st_name
>= aux
->strtab_size
4258 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
4263 *offset
= addr
.offset
;
4267 dump_ia64_unwind (struct unw_aux_info
*aux
)
4270 struct unw_table_entry
*tp
;
4273 addr_size
= is_32bit_elf
? 4 : 8;
4275 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4279 const unsigned char *dp
;
4280 const unsigned char *head
;
4281 const char *procname
;
4283 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
4285 fputs ("\n<", stdout
);
4289 fputs (procname
, stdout
);
4292 printf ("+%lx", (unsigned long) offset
);
4295 fputs (">: [", stdout
);
4296 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4297 fputc ('-', stdout
);
4298 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4299 printf ("], info at +0x%lx\n",
4300 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4302 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4303 stamp
= BYTE_GET8 ((unsigned char *) head
);
4305 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4306 (unsigned) UNW_VER (stamp
),
4307 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4308 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4309 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4310 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4312 if (UNW_VER (stamp
) != 1)
4314 printf ("\tUnknown version.\n");
4319 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4320 dp
= unw_decode (dp
, in_body
, & in_body
);
4325 slurp_ia64_unwind_table (FILE *file
,
4326 struct unw_aux_info
*aux
,
4327 Elf_Internal_Shdr
*sec
)
4329 unsigned long size
, addr_size
, nrelas
, i
;
4330 Elf_Internal_Phdr
*seg
;
4331 struct unw_table_entry
*tep
;
4332 Elf_Internal_Shdr
*relsec
;
4333 Elf_Internal_Rela
*rela
, *rp
;
4334 unsigned char *table
, *tp
;
4335 Elf_Internal_Sym
*sym
;
4336 const char *relname
;
4338 addr_size
= is_32bit_elf
? 4 : 8;
4340 /* First, find the starting address of the segment that includes
4343 if (elf_header
.e_phnum
)
4345 if (! get_program_headers (file
))
4348 for (seg
= program_headers
;
4349 seg
< program_headers
+ elf_header
.e_phnum
;
4352 if (seg
->p_type
!= PT_LOAD
)
4355 if (sec
->sh_addr
>= seg
->p_vaddr
4356 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4358 aux
->seg_base
= seg
->p_vaddr
;
4364 /* Second, build the unwind table from the contents of the unwind section: */
4365 size
= sec
->sh_size
;
4366 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4370 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4371 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4373 tep
->start
.section
= SHN_UNDEF
;
4374 tep
->end
.section
= SHN_UNDEF
;
4375 tep
->info
.section
= SHN_UNDEF
;
4378 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4379 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4380 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4384 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4385 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4386 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4388 tep
->start
.offset
+= aux
->seg_base
;
4389 tep
->end
.offset
+= aux
->seg_base
;
4390 tep
->info
.offset
+= aux
->seg_base
;
4394 /* Third, apply any relocations to the unwind table: */
4396 for (relsec
= section_headers
;
4397 relsec
< section_headers
+ elf_header
.e_shnum
;
4400 if (relsec
->sh_type
!= SHT_RELA
4401 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4404 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4408 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4412 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4413 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4415 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4417 warn (_("Skipping unexpected symbol type %u\n"),
4418 ELF32_ST_TYPE (sym
->st_info
));
4424 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4425 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4427 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4429 warn (_("Skipping unexpected symbol type %u\n"),
4430 ELF64_ST_TYPE (sym
->st_info
));
4435 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4437 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4441 i
= rp
->r_offset
/ (3 * addr_size
);
4443 switch (rp
->r_offset
/addr_size
% 3)
4446 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4447 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4450 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4451 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4454 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4455 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4465 aux
->table_len
= size
/ (3 * addr_size
);
4470 process_unwind (FILE *file
)
4472 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4473 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4474 struct unw_aux_info aux
;
4479 if (elf_header
.e_machine
!= EM_IA_64
)
4481 printf (_("\nThere are no unwind sections in this file.\n"));
4485 memset (& aux
, 0, sizeof (aux
));
4487 addr_size
= is_32bit_elf
? 4 : 8;
4489 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4491 if (sec
->sh_type
== SHT_SYMTAB
)
4493 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4494 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4496 strsec
= SECTION_HEADER (sec
->sh_link
);
4497 aux
.strtab_size
= strsec
->sh_size
;
4498 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4499 aux
.strtab_size
, _("string table"));
4501 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4506 printf (_("\nThere are no unwind sections in this file.\n"));
4508 while (unwcount
-- > 0)
4513 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4514 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4515 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4522 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4524 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4526 /* We need to find which section group it is in. */
4527 struct group_list
*g
= section_headers_groups
[i
]->root
;
4529 for (; g
!= NULL
; g
= g
->next
)
4531 sec
= SECTION_HEADER (g
->section_index
);
4532 if (strcmp (SECTION_NAME (sec
),
4533 ELF_STRING_ia64_unwind_info
) == 0)
4538 i
= elf_header
.e_shnum
;
4540 else if (strncmp (SECTION_NAME (unwsec
),
4541 ELF_STRING_ia64_unwind_once
, len
) == 0)
4543 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4544 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4545 suffix
= SECTION_NAME (unwsec
) + len
;
4546 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4548 if (strncmp (SECTION_NAME (sec
),
4549 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4550 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4555 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4556 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4557 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4558 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4560 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4562 suffix
= SECTION_NAME (unwsec
) + len
;
4563 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4565 if (strncmp (SECTION_NAME (sec
),
4566 ELF_STRING_ia64_unwind_info
, len2
) == 0
4567 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4571 if (i
== elf_header
.e_shnum
)
4573 printf (_("\nCould not find unwind info section for "));
4575 if (string_table
== NULL
)
4576 printf ("%d", unwsec
->sh_name
);
4578 printf (_("'%s'"), SECTION_NAME (unwsec
));
4582 aux
.info_size
= sec
->sh_size
;
4583 aux
.info_addr
= sec
->sh_addr
;
4584 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4587 printf (_("\nUnwind section "));
4589 if (string_table
== NULL
)
4590 printf ("%d", unwsec
->sh_name
);
4592 printf (_("'%s'"), SECTION_NAME (unwsec
));
4594 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4595 (unsigned long) unwsec
->sh_offset
,
4596 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4598 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4600 if (aux
.table_len
> 0)
4601 dump_ia64_unwind (& aux
);
4604 free ((char *) aux
.table
);
4606 free ((char *) aux
.info
);
4615 free ((char *) aux
.strtab
);
4621 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
4623 switch (entry
->d_tag
)
4626 if (entry
->d_un
.d_val
== 0)
4630 static const char * opts
[] =
4632 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4633 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4634 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4635 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4640 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4641 if (entry
->d_un
.d_val
& (1 << cnt
))
4643 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4650 case DT_MIPS_IVERSION
:
4651 if (dynamic_strings
!= NULL
)
4652 printf ("Interface Version: %s\n",
4653 dynamic_strings
+ entry
->d_un
.d_val
);
4655 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4658 case DT_MIPS_TIME_STAMP
:
4663 time_t time
= entry
->d_un
.d_val
;
4664 tmp
= gmtime (&time
);
4665 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4666 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4667 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4668 printf ("Time Stamp: %s\n", timebuf
);
4672 case DT_MIPS_RLD_VERSION
:
4673 case DT_MIPS_LOCAL_GOTNO
:
4674 case DT_MIPS_CONFLICTNO
:
4675 case DT_MIPS_LIBLISTNO
:
4676 case DT_MIPS_SYMTABNO
:
4677 case DT_MIPS_UNREFEXTNO
:
4678 case DT_MIPS_HIPAGENO
:
4679 case DT_MIPS_DELTA_CLASS_NO
:
4680 case DT_MIPS_DELTA_INSTANCE_NO
:
4681 case DT_MIPS_DELTA_RELOC_NO
:
4682 case DT_MIPS_DELTA_SYM_NO
:
4683 case DT_MIPS_DELTA_CLASSSYM_NO
:
4684 case DT_MIPS_COMPACT_SIZE
:
4685 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4689 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4695 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
4697 switch (entry
->d_tag
)
4699 case DT_HP_DLD_FLAGS
:
4708 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4709 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4710 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4711 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4712 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4713 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4714 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4715 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4716 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4717 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4718 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4722 bfd_vma val
= entry
->d_un
.d_val
;
4724 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4725 if (val
& flags
[cnt
].bit
)
4729 fputs (flags
[cnt
].str
, stdout
);
4731 val
^= flags
[cnt
].bit
;
4734 if (val
!= 0 || first
)
4738 print_vma (val
, HEX
);
4744 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4751 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
4753 switch (entry
->d_tag
)
4755 case DT_IA_64_PLT_RESERVE
:
4756 /* First 3 slots reserved. */
4757 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4759 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
4763 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4770 get_32bit_dynamic_section (FILE *file
)
4772 Elf32_External_Dyn
*edyn
, *ext
;
4773 Elf_Internal_Dyn
*entry
;
4775 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4776 _("dynamic section"));
4780 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4781 might not have the luxury of section headers. Look for the DT_NULL
4782 terminator to determine the number of entries. */
4783 for (ext
= edyn
, dynamic_nent
= 0;
4784 (char *) ext
< (char *) edyn
+ dynamic_size
;
4788 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
4792 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4793 if (dynamic_section
== NULL
)
4795 error (_("Out of memory\n"));
4800 for (ext
= edyn
, entry
= dynamic_section
;
4801 entry
< dynamic_section
+ dynamic_nent
;
4804 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
4805 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
4814 get_64bit_dynamic_section (FILE *file
)
4816 Elf64_External_Dyn
*edyn
, *ext
;
4817 Elf_Internal_Dyn
*entry
;
4819 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4820 _("dynamic section"));
4824 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4825 might not have the luxury of section headers. Look for the DT_NULL
4826 terminator to determine the number of entries. */
4827 for (ext
= edyn
, dynamic_nent
= 0;
4828 (char *) ext
< (char *) edyn
+ dynamic_size
;
4832 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
4836 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4837 if (dynamic_section
== NULL
)
4839 error (_("Out of memory\n"));
4844 for (ext
= edyn
, entry
= dynamic_section
;
4845 entry
< dynamic_section
+ dynamic_nent
;
4848 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
4849 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
4858 get_dynamic_flags (bfd_vma flags
)
4860 static char buff
[128];
4868 flag
= flags
& - flags
;
4876 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4877 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4878 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4879 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4880 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4881 default: strcpy (p
, "unknown"); break;
4884 p
= strchr (p
, '\0');
4889 /* Parse and display the contents of the dynamic section. */
4892 process_dynamic_section (FILE *file
)
4894 Elf_Internal_Dyn
*entry
;
4896 if (dynamic_size
== 0)
4899 printf (_("\nThere is no dynamic section in this file.\n"));
4906 if (! get_32bit_dynamic_section (file
))
4909 else if (! get_64bit_dynamic_section (file
))
4912 /* Find the appropriate symbol table. */
4913 if (dynamic_symbols
== NULL
)
4915 for (entry
= dynamic_section
;
4916 entry
< dynamic_section
+ dynamic_nent
;
4919 Elf_Internal_Shdr section
;
4921 if (entry
->d_tag
!= DT_SYMTAB
)
4924 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4926 /* Since we do not know how big the symbol table is,
4927 we default to reading in the entire file (!) and
4928 processing that. This is overkill, I know, but it
4930 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4932 if (archive_file_offset
!= 0)
4933 section
.sh_size
= archive_file_size
- section
.sh_offset
;
4936 if (fseek (file
, 0, SEEK_END
))
4937 error (_("Unable to seek to end of file!"));
4939 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4943 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4945 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4947 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4948 if (num_dynamic_syms
< 1)
4950 error (_("Unable to determine the number of symbols to load\n"));
4954 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4958 /* Similarly find a string table. */
4959 if (dynamic_strings
== NULL
)
4961 for (entry
= dynamic_section
;
4962 entry
< dynamic_section
+ dynamic_nent
;
4965 unsigned long offset
;
4968 if (entry
->d_tag
!= DT_STRTAB
)
4971 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4973 /* Since we do not know how big the string table is,
4974 we default to reading in the entire file (!) and
4975 processing that. This is overkill, I know, but it
4978 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4980 if (archive_file_offset
!= 0)
4981 str_tab_len
= archive_file_size
- offset
;
4984 if (fseek (file
, 0, SEEK_END
))
4985 error (_("Unable to seek to end of file\n"));
4986 str_tab_len
= ftell (file
) - offset
;
4989 if (str_tab_len
< 1)
4992 (_("Unable to determine the length of the dynamic string table\n"));
4996 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
4997 _("dynamic string table"));
5002 /* And find the syminfo section if available. */
5003 if (dynamic_syminfo
== NULL
)
5005 unsigned long syminsz
= 0;
5007 for (entry
= dynamic_section
;
5008 entry
< dynamic_section
+ dynamic_nent
;
5011 if (entry
->d_tag
== DT_SYMINENT
)
5013 /* Note: these braces are necessary to avoid a syntax
5014 error from the SunOS4 C compiler. */
5015 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5017 else if (entry
->d_tag
== DT_SYMINSZ
)
5018 syminsz
= entry
->d_un
.d_val
;
5019 else if (entry
->d_tag
== DT_SYMINFO
)
5020 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5024 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5026 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5027 Elf_Internal_Syminfo
*syminfo
;
5029 /* There is a syminfo section. Read the data. */
5030 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
5031 _("symbol information"));
5035 dynamic_syminfo
= malloc (syminsz
);
5036 if (dynamic_syminfo
== NULL
)
5038 error (_("Out of memory\n"));
5042 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5043 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5044 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5045 ++syminfo
, ++extsym
)
5047 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5048 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5055 if (do_dynamic
&& dynamic_addr
)
5056 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5057 dynamic_addr
, dynamic_nent
);
5059 printf (_(" Tag Type Name/Value\n"));
5061 for (entry
= dynamic_section
;
5062 entry
< dynamic_section
+ dynamic_nent
;
5070 print_vma (entry
->d_tag
, FULL_HEX
);
5071 dtype
= get_dynamic_type (entry
->d_tag
);
5072 printf (" (%s)%*s", dtype
,
5073 ((is_32bit_elf
? 27 : 19)
5074 - (int) strlen (dtype
)),
5078 switch (entry
->d_tag
)
5082 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5092 switch (entry
->d_tag
)
5095 printf (_("Auxiliary library"));
5099 printf (_("Filter library"));
5103 printf (_("Configuration file"));
5107 printf (_("Dependency audit library"));
5111 printf (_("Audit library"));
5115 if (dynamic_strings
)
5116 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
5120 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5129 printf (_("Flags:"));
5131 if (entry
->d_un
.d_val
== 0)
5132 printf (_(" None\n"));
5135 unsigned long int val
= entry
->d_un
.d_val
;
5137 if (val
& DTF_1_PARINIT
)
5139 printf (" PARINIT");
5140 val
^= DTF_1_PARINIT
;
5142 if (val
& DTF_1_CONFEXP
)
5144 printf (" CONFEXP");
5145 val
^= DTF_1_CONFEXP
;
5148 printf (" %lx", val
);
5157 printf (_("Flags:"));
5159 if (entry
->d_un
.d_val
== 0)
5160 printf (_(" None\n"));
5163 unsigned long int val
= entry
->d_un
.d_val
;
5165 if (val
& DF_P1_LAZYLOAD
)
5167 printf (" LAZYLOAD");
5168 val
^= DF_P1_LAZYLOAD
;
5170 if (val
& DF_P1_GROUPPERM
)
5172 printf (" GROUPPERM");
5173 val
^= DF_P1_GROUPPERM
;
5176 printf (" %lx", val
);
5185 printf (_("Flags:"));
5186 if (entry
->d_un
.d_val
== 0)
5187 printf (_(" None\n"));
5190 unsigned long int val
= entry
->d_un
.d_val
;
5197 if (val
& DF_1_GLOBAL
)
5202 if (val
& DF_1_GROUP
)
5207 if (val
& DF_1_NODELETE
)
5209 printf (" NODELETE");
5210 val
^= DF_1_NODELETE
;
5212 if (val
& DF_1_LOADFLTR
)
5214 printf (" LOADFLTR");
5215 val
^= DF_1_LOADFLTR
;
5217 if (val
& DF_1_INITFIRST
)
5219 printf (" INITFIRST");
5220 val
^= DF_1_INITFIRST
;
5222 if (val
& DF_1_NOOPEN
)
5227 if (val
& DF_1_ORIGIN
)
5232 if (val
& DF_1_DIRECT
)
5237 if (val
& DF_1_TRANS
)
5242 if (val
& DF_1_INTERPOSE
)
5244 printf (" INTERPOSE");
5245 val
^= DF_1_INTERPOSE
;
5247 if (val
& DF_1_NODEFLIB
)
5249 printf (" NODEFLIB");
5250 val
^= DF_1_NODEFLIB
;
5252 if (val
& DF_1_NODUMP
)
5257 if (val
& DF_1_CONLFAT
)
5259 printf (" CONLFAT");
5260 val
^= DF_1_CONLFAT
;
5263 printf (" %lx", val
);
5270 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5272 puts (get_dynamic_type (entry
->d_un
.d_val
));
5292 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5298 if (dynamic_strings
== NULL
)
5301 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5305 switch (entry
->d_tag
)
5308 printf (_("Shared library: [%s]"), name
);
5310 if (strcmp (name
, program_interpreter
) == 0)
5311 printf (_(" program interpreter"));
5315 printf (_("Library soname: [%s]"), name
);
5319 printf (_("Library rpath: [%s]"), name
);
5323 printf (_("Library runpath: [%s]"), name
);
5327 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5332 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5345 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5349 case DT_INIT_ARRAYSZ
:
5350 case DT_FINI_ARRAYSZ
:
5351 case DT_GNU_CONFLICTSZ
:
5352 case DT_GNU_LIBLISTSZ
:
5355 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5356 printf (" (bytes)\n");
5366 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5379 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
5383 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5387 printf (_("Not needed object: [%s]\n"), name
);
5392 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5398 /* The value of this entry is ignored. */
5403 case DT_GNU_PRELINKED
:
5407 time_t time
= entry
->d_un
.d_val
;
5409 tmp
= gmtime (&time
);
5410 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5411 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5412 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5418 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5419 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5424 switch (elf_header
.e_machine
)
5427 case EM_MIPS_RS3_LE
:
5428 dynamic_section_mips_val (entry
);
5431 dynamic_section_parisc_val (entry
);
5434 dynamic_section_ia64_val (entry
);
5437 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5449 get_ver_flags (unsigned int flags
)
5451 static char buff
[32];
5458 if (flags
& VER_FLG_BASE
)
5459 strcat (buff
, "BASE ");
5461 if (flags
& VER_FLG_WEAK
)
5463 if (flags
& VER_FLG_BASE
)
5464 strcat (buff
, "| ");
5466 strcat (buff
, "WEAK ");
5469 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5470 strcat (buff
, "| <unknown>");
5475 /* Display the contents of the version sections. */
5477 process_version_sections (FILE *file
)
5479 Elf_Internal_Shdr
*section
;
5486 for (i
= 0, section
= section_headers
;
5487 i
< elf_header
.e_shnum
;
5490 switch (section
->sh_type
)
5492 case SHT_GNU_verdef
:
5494 Elf_External_Verdef
*edefs
;
5501 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5502 SECTION_NAME (section
), section
->sh_info
);
5504 printf (_(" Addr: 0x"));
5505 printf_vma (section
->sh_addr
);
5506 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5507 (unsigned long) section
->sh_offset
, section
->sh_link
,
5508 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5510 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5511 _("version definition section"));
5515 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5518 Elf_External_Verdef
*edef
;
5519 Elf_Internal_Verdef ent
;
5520 Elf_External_Verdaux
*eaux
;
5521 Elf_Internal_Verdaux aux
;
5525 vstart
= ((char *) edefs
) + idx
;
5527 edef
= (Elf_External_Verdef
*) vstart
;
5529 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5530 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5531 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5532 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5533 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5534 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5535 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5537 printf (_(" %#06x: Rev: %d Flags: %s"),
5538 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5540 printf (_(" Index: %d Cnt: %d "),
5541 ent
.vd_ndx
, ent
.vd_cnt
);
5543 vstart
+= ent
.vd_aux
;
5545 eaux
= (Elf_External_Verdaux
*) vstart
;
5547 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5548 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5550 if (dynamic_strings
)
5551 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5553 printf (_("Name index: %ld\n"), aux
.vda_name
);
5555 isum
= idx
+ ent
.vd_aux
;
5557 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5559 isum
+= aux
.vda_next
;
5560 vstart
+= aux
.vda_next
;
5562 eaux
= (Elf_External_Verdaux
*) vstart
;
5564 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5565 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5567 if (dynamic_strings
)
5568 printf (_(" %#06x: Parent %d: %s\n"),
5569 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5571 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5572 isum
, j
, aux
.vda_name
);
5582 case SHT_GNU_verneed
:
5584 Elf_External_Verneed
*eneed
;
5590 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5591 SECTION_NAME (section
), section
->sh_info
);
5593 printf (_(" Addr: 0x"));
5594 printf_vma (section
->sh_addr
);
5595 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5596 (unsigned long) section
->sh_offset
, section
->sh_link
,
5597 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5599 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5600 _("version need section"));
5604 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5606 Elf_External_Verneed
*entry
;
5607 Elf_Internal_Verneed ent
;
5612 vstart
= ((char *) eneed
) + idx
;
5614 entry
= (Elf_External_Verneed
*) vstart
;
5616 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5617 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5618 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5619 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5620 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5622 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5624 if (dynamic_strings
)
5625 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5627 printf (_(" File: %lx"), ent
.vn_file
);
5629 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5631 vstart
+= ent
.vn_aux
;
5633 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5635 Elf_External_Vernaux
*eaux
;
5636 Elf_Internal_Vernaux aux
;
5638 eaux
= (Elf_External_Vernaux
*) vstart
;
5640 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5641 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5642 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5643 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5644 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5646 if (dynamic_strings
)
5647 printf (_(" %#06x: Name: %s"),
5648 isum
, dynamic_strings
+ aux
.vna_name
);
5650 printf (_(" %#06x: Name index: %lx"),
5651 isum
, aux
.vna_name
);
5653 printf (_(" Flags: %s Version: %d\n"),
5654 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5656 isum
+= aux
.vna_next
;
5657 vstart
+= aux
.vna_next
;
5667 case SHT_GNU_versym
:
5669 Elf_Internal_Shdr
*link_section
;
5672 unsigned char *edata
;
5673 unsigned short *data
;
5675 Elf_Internal_Sym
*symbols
;
5676 Elf_Internal_Shdr
*string_sec
;
5679 link_section
= SECTION_HEADER (section
->sh_link
);
5680 total
= section
->sh_size
/ section
->sh_entsize
;
5684 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5686 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5688 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5689 string_sec
->sh_size
, _("version string table"));
5693 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5694 SECTION_NAME (section
), total
);
5696 printf (_(" Addr: "));
5697 printf_vma (section
->sh_addr
);
5698 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5699 (unsigned long) section
->sh_offset
, section
->sh_link
,
5700 SECTION_NAME (link_section
));
5702 off
= offset_from_vma (file
,
5703 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5704 total
* sizeof (short));
5705 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
5706 _("version symbol data"));
5713 data
= malloc (total
* sizeof (short));
5715 for (cnt
= total
; cnt
--;)
5716 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5721 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5724 int check_def
, check_need
;
5727 printf (" %03x:", cnt
);
5729 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5730 switch (data
[cnt
+ j
])
5733 fputs (_(" 0 (*local*) "), stdout
);
5737 fputs (_(" 1 (*global*) "), stdout
);
5741 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5742 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5746 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5749 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5756 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5758 Elf_Internal_Verneed ivn
;
5759 unsigned long offset
;
5761 offset
= offset_from_vma
5762 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5763 sizeof (Elf_External_Verneed
));
5767 Elf_Internal_Vernaux ivna
;
5768 Elf_External_Verneed evn
;
5769 Elf_External_Vernaux evna
;
5770 unsigned long a_off
;
5772 get_data (&evn
, file
, offset
, sizeof (evn
),
5775 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5776 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5778 a_off
= offset
+ ivn
.vn_aux
;
5782 get_data (&evna
, file
, a_off
, sizeof (evna
),
5783 _("version need aux (2)"));
5785 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5786 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5788 a_off
+= ivna
.vna_next
;
5790 while (ivna
.vna_other
!= data
[cnt
+ j
]
5791 && ivna
.vna_next
!= 0);
5793 if (ivna
.vna_other
== data
[cnt
+ j
])
5795 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5797 name
= strtab
+ ivna
.vna_name
;
5798 nn
+= printf ("(%s%-*s",
5800 12 - (int) strlen (name
),
5806 offset
+= ivn
.vn_next
;
5808 while (ivn
.vn_next
);
5811 if (check_def
&& data
[cnt
+ j
] != 0x8001
5812 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5814 Elf_Internal_Verdef ivd
;
5815 Elf_External_Verdef evd
;
5816 unsigned long offset
;
5818 offset
= offset_from_vma
5819 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5824 get_data (&evd
, file
, offset
, sizeof (evd
),
5827 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5828 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5830 offset
+= ivd
.vd_next
;
5832 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5833 && ivd
.vd_next
!= 0);
5835 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5837 Elf_External_Verdaux evda
;
5838 Elf_Internal_Verdaux ivda
;
5840 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5842 get_data (&evda
, file
,
5843 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5844 sizeof (evda
), _("version def aux"));
5846 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5848 name
= strtab
+ ivda
.vda_name
;
5849 nn
+= printf ("(%s%-*s",
5851 12 - (int) strlen (name
),
5857 printf ("%*c", 18 - nn
, ' ');
5875 printf (_("\nNo version information found in this file.\n"));
5881 get_symbol_binding (unsigned int binding
)
5883 static char buff
[32];
5887 case STB_LOCAL
: return "LOCAL";
5888 case STB_GLOBAL
: return "GLOBAL";
5889 case STB_WEAK
: return "WEAK";
5891 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5892 sprintf (buff
, _("<processor specific>: %d"), binding
);
5893 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5894 sprintf (buff
, _("<OS specific>: %d"), binding
);
5896 sprintf (buff
, _("<unknown>: %d"), binding
);
5902 get_symbol_type (unsigned int type
)
5904 static char buff
[32];
5908 case STT_NOTYPE
: return "NOTYPE";
5909 case STT_OBJECT
: return "OBJECT";
5910 case STT_FUNC
: return "FUNC";
5911 case STT_SECTION
: return "SECTION";
5912 case STT_FILE
: return "FILE";
5913 case STT_COMMON
: return "COMMON";
5914 case STT_TLS
: return "TLS";
5916 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5918 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5919 return "THUMB_FUNC";
5921 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5924 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5925 return "PARISC_MILLI";
5927 sprintf (buff
, _("<processor specific>: %d"), type
);
5929 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5931 if (elf_header
.e_machine
== EM_PARISC
)
5933 if (type
== STT_HP_OPAQUE
)
5935 if (type
== STT_HP_STUB
)
5939 sprintf (buff
, _("<OS specific>: %d"), type
);
5942 sprintf (buff
, _("<unknown>: %d"), type
);
5948 get_symbol_visibility (unsigned int visibility
)
5952 case STV_DEFAULT
: return "DEFAULT";
5953 case STV_INTERNAL
: return "INTERNAL";
5954 case STV_HIDDEN
: return "HIDDEN";
5955 case STV_PROTECTED
: return "PROTECTED";
5961 get_symbol_index_type (unsigned int type
)
5963 static char buff
[32];
5967 case SHN_UNDEF
: return "UND";
5968 case SHN_ABS
: return "ABS";
5969 case SHN_COMMON
: return "COM";
5971 if (type
== SHN_IA_64_ANSI_COMMON
5972 && elf_header
.e_machine
== EM_IA_64
5973 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
5975 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5976 sprintf (buff
, "PRC[0x%04x]", type
);
5977 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5978 sprintf (buff
, "OS [0x%04x]", type
);
5979 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5980 sprintf (buff
, "RSV[0x%04x]", type
);
5982 sprintf (buff
, "%3d", type
);
5990 get_dynamic_data (FILE *file
, unsigned int number
)
5992 unsigned char *e_data
;
5995 e_data
= malloc (number
* 4);
5999 error (_("Out of memory\n"));
6003 if (fread (e_data
, 4, number
, file
) != number
)
6005 error (_("Unable to read in dynamic data\n"));
6009 i_data
= malloc (number
* sizeof (*i_data
));
6013 error (_("Out of memory\n"));
6019 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
6026 /* Dump the symbol table. */
6028 process_symbol_table (FILE *file
)
6030 Elf_Internal_Shdr
*section
;
6031 unsigned char nb
[4];
6032 unsigned char nc
[4];
6035 int *buckets
= NULL
;
6038 if (! do_syms
&& !do_histogram
)
6041 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6045 (archive_file_offset
6046 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6047 sizeof nb
+ sizeof nc
)),
6050 error (_("Unable to seek to start of dynamic information"));
6054 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
6056 error (_("Failed to read in number of buckets\n"));
6060 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
6062 error (_("Failed to read in number of chains\n"));
6066 nbuckets
= byte_get (nb
, 4);
6067 nchains
= byte_get (nc
, 4);
6069 buckets
= get_dynamic_data (file
, nbuckets
);
6070 chains
= get_dynamic_data (file
, nchains
);
6072 if (buckets
== NULL
|| chains
== NULL
)
6077 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6082 printf (_("\nSymbol table for image:\n"));
6084 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6086 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6088 for (hn
= 0; hn
< nbuckets
; hn
++)
6093 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6095 Elf_Internal_Sym
*psym
;
6097 psym
= dynamic_symbols
+ si
;
6099 printf (" %3d %3d: ", si
, hn
);
6100 print_vma (psym
->st_value
, LONG_HEX
);
6102 print_vma (psym
->st_size
, DEC_5
);
6104 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6105 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6106 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6107 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6108 print_symbol (25, dynamic_strings
+ psym
->st_name
);
6113 else if (do_syms
&& !do_using_dynamic
)
6117 for (i
= 0, section
= section_headers
;
6118 i
< elf_header
.e_shnum
;
6123 Elf_Internal_Sym
*symtab
;
6124 Elf_Internal_Sym
*psym
;
6127 if ( section
->sh_type
!= SHT_SYMTAB
6128 && section
->sh_type
!= SHT_DYNSYM
)
6131 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6132 SECTION_NAME (section
),
6133 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6135 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6137 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6139 symtab
= GET_ELF_SYMBOLS (file
, section
);
6143 if (section
->sh_link
== elf_header
.e_shstrndx
)
6144 strtab
= string_table
;
6147 Elf_Internal_Shdr
*string_sec
;
6149 string_sec
= SECTION_HEADER (section
->sh_link
);
6151 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6152 string_sec
->sh_size
, _("string table"));
6155 for (si
= 0, psym
= symtab
;
6156 si
< section
->sh_size
/ section
->sh_entsize
;
6159 printf ("%6d: ", si
);
6160 print_vma (psym
->st_value
, LONG_HEX
);
6162 print_vma (psym
->st_size
, DEC_5
);
6163 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6164 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6165 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6166 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6167 print_symbol (25, strtab
+ psym
->st_name
);
6169 if (section
->sh_type
== SHT_DYNSYM
&&
6170 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6172 unsigned char data
[2];
6173 unsigned short vers_data
;
6174 unsigned long offset
;
6178 offset
= offset_from_vma
6179 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6180 sizeof data
+ si
* sizeof (vers_data
));
6182 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6183 sizeof (data
), _("version data"));
6185 vers_data
= byte_get (data
, 2);
6187 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6190 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6192 if ((vers_data
& 0x8000) || vers_data
> 1)
6194 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6195 && (is_nobits
|| ! check_def
))
6197 Elf_External_Verneed evn
;
6198 Elf_Internal_Verneed ivn
;
6199 Elf_Internal_Vernaux ivna
;
6201 /* We must test both. */
6202 offset
= offset_from_vma
6203 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6208 unsigned long vna_off
;
6210 get_data (&evn
, file
, offset
, sizeof (evn
),
6213 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6214 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6216 vna_off
= offset
+ ivn
.vn_aux
;
6220 Elf_External_Vernaux evna
;
6222 get_data (&evna
, file
, vna_off
,
6224 _("version need aux (3)"));
6226 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6227 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6228 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6230 vna_off
+= ivna
.vna_next
;
6232 while (ivna
.vna_other
!= vers_data
6233 && ivna
.vna_next
!= 0);
6235 if (ivna
.vna_other
== vers_data
)
6238 offset
+= ivn
.vn_next
;
6240 while (ivn
.vn_next
!= 0);
6242 if (ivna
.vna_other
== vers_data
)
6245 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6248 else if (! is_nobits
)
6249 error (_("bad dynamic symbol"));
6256 if (vers_data
!= 0x8001
6257 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6259 Elf_Internal_Verdef ivd
;
6260 Elf_Internal_Verdaux ivda
;
6261 Elf_External_Verdaux evda
;
6262 unsigned long offset
;
6264 offset
= offset_from_vma
6266 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6267 sizeof (Elf_External_Verdef
));
6271 Elf_External_Verdef evd
;
6273 get_data (&evd
, file
, offset
, sizeof (evd
),
6276 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6277 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6278 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6280 offset
+= ivd
.vd_next
;
6282 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6283 && ivd
.vd_next
!= 0);
6285 offset
-= ivd
.vd_next
;
6286 offset
+= ivd
.vd_aux
;
6288 get_data (&evda
, file
, offset
, sizeof (evda
),
6289 _("version def aux"));
6291 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6293 if (psym
->st_name
!= ivda
.vda_name
)
6294 printf ((vers_data
& 0x8000)
6296 strtab
+ ivda
.vda_name
);
6306 if (strtab
!= string_table
)
6312 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6314 if (do_histogram
&& buckets
!= NULL
)
6321 int nzero_counts
= 0;
6324 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6326 printf (_(" Length Number %% of total Coverage\n"));
6328 lengths
= calloc (nbuckets
, sizeof (int));
6329 if (lengths
== NULL
)
6331 error (_("Out of memory"));
6334 for (hn
= 0; hn
< nbuckets
; ++hn
)
6339 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6342 if (maxlength
< ++lengths
[hn
])
6347 counts
= calloc (maxlength
+ 1, sizeof (int));
6350 error (_("Out of memory"));
6354 for (hn
= 0; hn
< nbuckets
; ++hn
)
6355 ++counts
[lengths
[hn
]];
6359 printf (" 0 %-10d (%5.1f%%)\n",
6360 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6361 for (si
= 1; si
<= maxlength
; ++si
)
6363 nzero_counts
+= counts
[si
] * si
;
6364 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6365 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6366 (nzero_counts
* 100.0) / nsyms
);
6374 if (buckets
!= NULL
)
6384 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6388 if (dynamic_syminfo
== NULL
6390 /* No syminfo, this is ok. */
6393 /* There better should be a dynamic symbol section. */
6394 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6398 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6399 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6401 printf (_(" Num: Name BoundTo Flags\n"));
6402 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6404 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6406 printf ("%4d: ", i
);
6407 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
6410 switch (dynamic_syminfo
[i
].si_boundto
)
6412 case SYMINFO_BT_SELF
:
6413 fputs ("SELF ", stdout
);
6415 case SYMINFO_BT_PARENT
:
6416 fputs ("PARENT ", stdout
);
6419 if (dynamic_syminfo
[i
].si_boundto
> 0
6420 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
)
6425 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6429 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6433 if (flags
& SYMINFO_FLG_DIRECT
)
6435 if (flags
& SYMINFO_FLG_PASSTHRU
)
6436 printf (" PASSTHRU");
6437 if (flags
& SYMINFO_FLG_COPY
)
6439 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6440 printf (" LAZYLOAD");
6448 #ifdef SUPPORT_DISASSEMBLY
6450 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6452 printf (_("\nAssembly dump of section %s\n"),
6453 SECTION_NAME (section
));
6455 /* XXX -- to be done --- XXX */
6462 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6464 bfd_size_type bytes
;
6466 unsigned char *data
;
6467 unsigned char *start
;
6469 bytes
= section
->sh_size
;
6471 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6473 printf (_("\nSection '%s' has no data to dump.\n"),
6474 SECTION_NAME (section
));
6478 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6480 addr
= section
->sh_addr
;
6482 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6494 lbytes
= (bytes
> 16 ? 16 : bytes
);
6496 printf (" 0x%8.8lx ", (unsigned long) addr
);
6498 switch (elf_header
.e_ident
[EI_DATA
])
6502 for (j
= 15; j
>= 0; j
--)
6505 printf ("%2.2x", data
[j
]);
6515 for (j
= 0; j
< 16; j
++)
6518 printf ("%2.2x", data
[j
]);
6528 for (j
= 0; j
< lbytes
; j
++)
6531 if (k
>= ' ' && k
< 0x7f)
6550 static unsigned long int
6551 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6553 unsigned long int result
= 0;
6554 unsigned int num_read
= 0;
6563 result
|= (byte
& 0x7f) << shift
;
6568 while (byte
& 0x80);
6570 if (length_return
!= NULL
)
6571 *length_return
= num_read
;
6573 if (sign
&& (shift
< 32) && (byte
& 0x40))
6574 result
|= -1 << shift
;
6579 typedef struct State_Machine_Registers
6581 unsigned long address
;
6584 unsigned int column
;
6588 /* This variable hold the number of the last entry seen
6589 in the File Table. */
6590 unsigned int last_file_entry
;
6593 static SMR state_machine_regs
;
6596 reset_state_machine (int is_stmt
)
6598 state_machine_regs
.address
= 0;
6599 state_machine_regs
.file
= 1;
6600 state_machine_regs
.line
= 1;
6601 state_machine_regs
.column
= 0;
6602 state_machine_regs
.is_stmt
= is_stmt
;
6603 state_machine_regs
.basic_block
= 0;
6604 state_machine_regs
.end_sequence
= 0;
6605 state_machine_regs
.last_file_entry
= 0;
6608 /* Handled an extend line op. Returns true if this is the end
6611 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6613 unsigned char op_code
;
6616 unsigned char *name
;
6619 len
= read_leb128 (data
, & bytes_read
, 0);
6624 warn (_("badly formed extended line op encountered!\n"));
6631 printf (_(" Extended opcode %d: "), op_code
);
6635 case DW_LNE_end_sequence
:
6636 printf (_("End of Sequence\n\n"));
6637 reset_state_machine (is_stmt
);
6640 case DW_LNE_set_address
:
6641 adr
= byte_get (data
, pointer_size
);
6642 printf (_("set Address to 0x%lx\n"), adr
);
6643 state_machine_regs
.address
= adr
;
6646 case DW_LNE_define_file
:
6647 printf (_(" define new File Table entry\n"));
6648 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6650 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6652 data
+= strlen ((char *) data
) + 1;
6653 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6655 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6657 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6658 printf (_("%s\n\n"), name
);
6662 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6669 /* Finds section NAME inside FILE and returns a
6670 pointer to it, or NULL upon failure. */
6672 static Elf_Internal_Shdr
*
6673 find_section (const char * name
)
6675 Elf_Internal_Shdr
*sec
;
6678 for (i
= elf_header
.e_shnum
, sec
= section_headers
+ i
- 1;
6680 if (strcmp (SECTION_NAME (sec
), name
) == 0)
6683 if (i
&& sec
&& sec
->sh_size
!= 0)
6689 /* Size of pointers in the .debug_line section. This information is not
6690 really present in that section. It's obtained before dumping the debug
6691 sections by doing some pre-scan of the .debug_info section. */
6692 static unsigned int * debug_line_pointer_sizes
= NULL
;
6693 static unsigned int num_debug_line_pointer_sizes
= 0;
6695 /* Locate and scan the .debug_info section in the file and record the pointer
6696 sizes for the compilation units in it. Usually an executable will have
6697 just one pointer size, but this is not guaranteed, and so we try not to
6698 make any assumptions. Returns zero upon failure, or the number of
6699 compilation units upon success. */
6702 get_debug_line_pointer_sizes (FILE * file
)
6704 Elf_Internal_Shdr
* section
;
6705 unsigned char * start
;
6706 unsigned char * end
;
6707 unsigned char * begin
;
6708 unsigned long length
;
6709 unsigned int num_units
;
6712 section
= find_section (".debug_info");
6713 if (section
== NULL
)
6716 length
= section
->sh_size
;
6717 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6718 _("extracting pointer sizes from .debug_info section"));
6722 end
= start
+ section
->sh_size
;
6723 /* First scan the section to get the number of comp units. */
6724 for (begin
= start
, num_units
= 0; begin
< end
; num_units
++)
6726 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
6727 be the length. For a 64-bit DWARF section, it'll be the escape
6728 code 0xffffffff followed by an 8 byte length. */
6729 length
= byte_get (begin
, 4);
6731 if (length
== 0xffffffff)
6733 length
= byte_get (begin
+ 4, 8);
6734 begin
+= length
+ 12;
6737 begin
+= length
+ 4;
6742 error (_("No comp units in .debug_info section ?"));
6747 /* Then allocate an array to hold the pointer sizes. */
6748 debug_line_pointer_sizes
= malloc (num_units
* sizeof * debug_line_pointer_sizes
);
6749 if (debug_line_pointer_sizes
== NULL
)
6751 error (_("Not enough memory for a pointer size array of %u entries"),
6757 /* Populate the array. */
6758 for (begin
= start
, unit
= 0; begin
< end
; unit
++)
6760 length
= byte_get (begin
, 4);
6761 if (length
== 0xffffffff)
6763 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
6764 from the start of the section. This is computed as follows:
6766 unit_length: 12 bytes
6768 debug_abbrev_offset: 8 bytes
6769 -----------------------------
6772 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 22, 1);
6773 length
= byte_get (begin
+ 4, 8);
6774 begin
+= length
+ 12;
6778 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
6779 the start of the section:
6781 unit_length: 4 bytes
6783 debug_abbrev_offset: 4 bytes
6784 -----------------------------
6787 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 10, 1);
6788 begin
+= length
+ 4;
6793 num_debug_line_pointer_sizes
= num_units
;
6798 display_debug_lines (Elf_Internal_Shdr
*section
,
6799 unsigned char *start
, FILE *file
)
6801 unsigned char *hdrptr
;
6802 DWARF2_Internal_LineInfo info
;
6803 unsigned char *standard_opcodes
;
6804 unsigned char *data
= start
;
6805 unsigned char *end
= start
+ section
->sh_size
;
6806 unsigned char *end_of_sequence
;
6809 int initial_length_size
;
6810 unsigned int comp_unit
= 0;
6812 printf (_("\nDump of debug contents of section %s:\n\n"),
6813 SECTION_NAME (section
));
6815 if (num_debug_line_pointer_sizes
== 0)
6816 get_debug_line_pointer_sizes (file
);
6820 unsigned int pointer_size
;
6824 /* Check the length of the block. */
6825 info
.li_length
= byte_get (hdrptr
, 4);
6828 if (info
.li_length
== 0xffffffff)
6830 /* This section is 64-bit DWARF 3. */
6831 info
.li_length
= byte_get (hdrptr
, 8);
6834 initial_length_size
= 12;
6839 initial_length_size
= 4;
6842 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
6845 (_("The line info appears to be corrupt - the section is too small\n"));
6849 /* Check its version number. */
6850 info
.li_version
= byte_get (hdrptr
, 2);
6852 if (info
.li_version
!= 2 && info
.li_version
!= 3)
6854 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6858 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
6859 hdrptr
+= offset_size
;
6860 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
6862 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
6864 info
.li_line_base
= byte_get (hdrptr
, 1);
6866 info
.li_line_range
= byte_get (hdrptr
, 1);
6868 info
.li_opcode_base
= byte_get (hdrptr
, 1);
6871 /* Sign extend the line base field. */
6872 info
.li_line_base
<<= 24;
6873 info
.li_line_base
>>= 24;
6875 /* Get the pointer size from the comp unit associated
6876 with this block of line number information. */
6877 if (comp_unit
>= num_debug_line_pointer_sizes
)
6879 error (_("Not enough comp units for .debug_lines section\n"));
6884 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
6888 printf (_(" Length: %ld\n"), info
.li_length
);
6889 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6890 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6891 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6892 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6893 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6894 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6895 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6896 printf (_(" (Pointer size: %u)\n"), pointer_size
);
6898 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
6900 reset_state_machine (info
.li_default_is_stmt
);
6902 /* Display the contents of the Opcodes table. */
6903 standard_opcodes
= hdrptr
;
6905 printf (_("\n Opcodes:\n"));
6907 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6908 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6910 /* Display the contents of the Directory table. */
6911 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6914 printf (_("\n The Directory Table is empty.\n"));
6917 printf (_("\n The Directory Table:\n"));
6921 printf (_(" %s\n"), data
);
6923 data
+= strlen ((char *) data
) + 1;
6927 /* Skip the NUL at the end of the table. */
6930 /* Display the contents of the File Name table. */
6932 printf (_("\n The File Name Table is empty.\n"));
6935 printf (_("\n The File Name Table:\n"));
6936 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6940 unsigned char *name
;
6943 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6946 data
+= strlen ((char *) data
) + 1;
6948 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6950 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6952 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6954 printf (_("%s\n"), name
);
6958 /* Skip the NUL at the end of the table. */
6961 /* Now display the statements. */
6962 printf (_("\n Line Number Statements:\n"));
6965 while (data
< end_of_sequence
)
6967 unsigned char op_code
;
6973 if (op_code
>= info
.li_opcode_base
)
6975 op_code
-= info
.li_opcode_base
;
6976 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6977 state_machine_regs
.address
+= adv
;
6978 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6979 op_code
, adv
, state_machine_regs
.address
);
6980 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6981 state_machine_regs
.line
+= adv
;
6982 printf (_(" and Line by %d to %d\n"),
6983 adv
, state_machine_regs
.line
);
6985 else switch (op_code
)
6987 case DW_LNS_extended_op
:
6988 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6993 printf (_(" Copy\n"));
6996 case DW_LNS_advance_pc
:
6997 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6999 state_machine_regs
.address
+= adv
;
7000 printf (_(" Advance PC by %d to %lx\n"), adv
,
7001 state_machine_regs
.address
);
7004 case DW_LNS_advance_line
:
7005 adv
= read_leb128 (data
, & bytes_read
, 1);
7007 state_machine_regs
.line
+= adv
;
7008 printf (_(" Advance Line by %d to %d\n"), adv
,
7009 state_machine_regs
.line
);
7012 case DW_LNS_set_file
:
7013 adv
= read_leb128 (data
, & bytes_read
, 0);
7015 printf (_(" Set File Name to entry %d in the File Name Table\n"),
7017 state_machine_regs
.file
= adv
;
7020 case DW_LNS_set_column
:
7021 adv
= read_leb128 (data
, & bytes_read
, 0);
7023 printf (_(" Set column to %d\n"), adv
);
7024 state_machine_regs
.column
= adv
;
7027 case DW_LNS_negate_stmt
:
7028 adv
= state_machine_regs
.is_stmt
;
7030 printf (_(" Set is_stmt to %d\n"), adv
);
7031 state_machine_regs
.is_stmt
= adv
;
7034 case DW_LNS_set_basic_block
:
7035 printf (_(" Set basic block\n"));
7036 state_machine_regs
.basic_block
= 1;
7039 case DW_LNS_const_add_pc
:
7040 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
7041 * info
.li_min_insn_length
);
7042 state_machine_regs
.address
+= adv
;
7043 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
7044 state_machine_regs
.address
);
7047 case DW_LNS_fixed_advance_pc
:
7048 adv
= byte_get (data
, 2);
7050 state_machine_regs
.address
+= adv
;
7051 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
7052 adv
, state_machine_regs
.address
);
7055 case DW_LNS_set_prologue_end
:
7056 printf (_(" Set prologue_end to true\n"));
7059 case DW_LNS_set_epilogue_begin
:
7060 printf (_(" Set epilogue_begin to true\n"));
7063 case DW_LNS_set_isa
:
7064 adv
= read_leb128 (data
, & bytes_read
, 0);
7066 printf (_(" Set ISA to %d\n"), adv
);
7070 printf (_(" Unknown opcode %d with operands: "), op_code
);
7073 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
7075 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
7076 i
== 1 ? "" : ", ");
7091 display_debug_pubnames (Elf_Internal_Shdr
*section
,
7092 unsigned char *start
,
7093 FILE *file ATTRIBUTE_UNUSED
)
7095 DWARF2_Internal_PubNames pubnames
;
7098 end
= start
+ section
->sh_size
;
7100 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7104 unsigned char *data
;
7105 unsigned long offset
;
7106 int offset_size
, initial_length_size
;
7110 pubnames
.pn_length
= byte_get (data
, 4);
7112 if (pubnames
.pn_length
== 0xffffffff)
7114 pubnames
.pn_length
= byte_get (data
, 8);
7117 initial_length_size
= 12;
7122 initial_length_size
= 4;
7125 pubnames
.pn_version
= byte_get (data
, 2);
7127 pubnames
.pn_offset
= byte_get (data
, offset_size
);
7128 data
+= offset_size
;
7129 pubnames
.pn_size
= byte_get (data
, offset_size
);
7130 data
+= offset_size
;
7132 start
+= pubnames
.pn_length
+ initial_length_size
;
7134 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
7136 static int warned
= 0;
7140 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
7147 printf (_(" Length: %ld\n"),
7148 pubnames
.pn_length
);
7149 printf (_(" Version: %d\n"),
7150 pubnames
.pn_version
);
7151 printf (_(" Offset into .debug_info section: %ld\n"),
7152 pubnames
.pn_offset
);
7153 printf (_(" Size of area in .debug_info section: %ld\n"),
7156 printf (_("\n Offset\tName\n"));
7160 offset
= byte_get (data
, offset_size
);
7164 data
+= offset_size
;
7165 printf (" %-6ld\t\t%s\n", offset
, data
);
7166 data
+= strlen ((char *) data
) + 1;
7169 while (offset
!= 0);
7177 get_TAG_name (unsigned long tag
)
7181 case DW_TAG_padding
: return "DW_TAG_padding";
7182 case DW_TAG_array_type
: return "DW_TAG_array_type";
7183 case DW_TAG_class_type
: return "DW_TAG_class_type";
7184 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7185 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7186 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7187 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7188 case DW_TAG_label
: return "DW_TAG_label";
7189 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7190 case DW_TAG_member
: return "DW_TAG_member";
7191 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7192 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7193 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7194 case DW_TAG_string_type
: return "DW_TAG_string_type";
7195 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7196 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7197 case DW_TAG_typedef
: return "DW_TAG_typedef";
7198 case DW_TAG_union_type
: return "DW_TAG_union_type";
7199 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7200 case DW_TAG_variant
: return "DW_TAG_variant";
7201 case DW_TAG_common_block
: return "DW_TAG_common_block";
7202 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7203 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7204 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7205 case DW_TAG_module
: return "DW_TAG_module";
7206 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7207 case DW_TAG_set_type
: return "DW_TAG_set_type";
7208 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7209 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7210 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7211 case DW_TAG_base_type
: return "DW_TAG_base_type";
7212 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7213 case DW_TAG_const_type
: return "DW_TAG_const_type";
7214 case DW_TAG_constant
: return "DW_TAG_constant";
7215 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7216 case DW_TAG_file_type
: return "DW_TAG_file_type";
7217 case DW_TAG_friend
: return "DW_TAG_friend";
7218 case DW_TAG_namelist
: return "DW_TAG_namelist";
7219 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7220 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7221 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7222 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7223 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7224 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7225 case DW_TAG_try_block
: return "DW_TAG_try_block";
7226 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7227 case DW_TAG_variable
: return "DW_TAG_variable";
7228 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7229 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7230 case DW_TAG_format_label
: return "DW_TAG_format_label";
7231 case DW_TAG_function_template
: return "DW_TAG_function_template";
7232 case DW_TAG_class_template
: return "DW_TAG_class_template";
7233 /* DWARF 2.1 values. */
7234 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7235 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7236 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7237 case DW_TAG_namespace
: return "DW_TAG_namespace";
7238 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7239 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7240 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7241 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7243 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7244 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7245 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7248 static char buffer
[100];
7250 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7257 get_AT_name (unsigned long attribute
)
7261 case DW_AT_sibling
: return "DW_AT_sibling";
7262 case DW_AT_location
: return "DW_AT_location";
7263 case DW_AT_name
: return "DW_AT_name";
7264 case DW_AT_ordering
: return "DW_AT_ordering";
7265 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
7266 case DW_AT_byte_size
: return "DW_AT_byte_size";
7267 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
7268 case DW_AT_bit_size
: return "DW_AT_bit_size";
7269 case DW_AT_element_list
: return "DW_AT_element_list";
7270 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
7271 case DW_AT_low_pc
: return "DW_AT_low_pc";
7272 case DW_AT_high_pc
: return "DW_AT_high_pc";
7273 case DW_AT_language
: return "DW_AT_language";
7274 case DW_AT_member
: return "DW_AT_member";
7275 case DW_AT_discr
: return "DW_AT_discr";
7276 case DW_AT_discr_value
: return "DW_AT_discr_value";
7277 case DW_AT_visibility
: return "DW_AT_visibility";
7278 case DW_AT_import
: return "DW_AT_import";
7279 case DW_AT_string_length
: return "DW_AT_string_length";
7280 case DW_AT_common_reference
: return "DW_AT_common_reference";
7281 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
7282 case DW_AT_const_value
: return "DW_AT_const_value";
7283 case DW_AT_containing_type
: return "DW_AT_containing_type";
7284 case DW_AT_default_value
: return "DW_AT_default_value";
7285 case DW_AT_inline
: return "DW_AT_inline";
7286 case DW_AT_is_optional
: return "DW_AT_is_optional";
7287 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
7288 case DW_AT_producer
: return "DW_AT_producer";
7289 case DW_AT_prototyped
: return "DW_AT_prototyped";
7290 case DW_AT_return_addr
: return "DW_AT_return_addr";
7291 case DW_AT_start_scope
: return "DW_AT_start_scope";
7292 case DW_AT_stride_size
: return "DW_AT_stride_size";
7293 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
7294 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
7295 case DW_AT_accessibility
: return "DW_AT_accessibility";
7296 case DW_AT_address_class
: return "DW_AT_address_class";
7297 case DW_AT_artificial
: return "DW_AT_artificial";
7298 case DW_AT_base_types
: return "DW_AT_base_types";
7299 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
7300 case DW_AT_count
: return "DW_AT_count";
7301 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
7302 case DW_AT_decl_column
: return "DW_AT_decl_column";
7303 case DW_AT_decl_file
: return "DW_AT_decl_file";
7304 case DW_AT_decl_line
: return "DW_AT_decl_line";
7305 case DW_AT_declaration
: return "DW_AT_declaration";
7306 case DW_AT_discr_list
: return "DW_AT_discr_list";
7307 case DW_AT_encoding
: return "DW_AT_encoding";
7308 case DW_AT_external
: return "DW_AT_external";
7309 case DW_AT_frame_base
: return "DW_AT_frame_base";
7310 case DW_AT_friend
: return "DW_AT_friend";
7311 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
7312 case DW_AT_macro_info
: return "DW_AT_macro_info";
7313 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
7314 case DW_AT_priority
: return "DW_AT_priority";
7315 case DW_AT_segment
: return "DW_AT_segment";
7316 case DW_AT_specification
: return "DW_AT_specification";
7317 case DW_AT_static_link
: return "DW_AT_static_link";
7318 case DW_AT_type
: return "DW_AT_type";
7319 case DW_AT_use_location
: return "DW_AT_use_location";
7320 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
7321 case DW_AT_virtuality
: return "DW_AT_virtuality";
7322 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
7323 /* DWARF 2.1 values. */
7324 case DW_AT_allocated
: return "DW_AT_allocated";
7325 case DW_AT_associated
: return "DW_AT_associated";
7326 case DW_AT_data_location
: return "DW_AT_data_location";
7327 case DW_AT_stride
: return "DW_AT_stride";
7328 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
7329 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
7330 case DW_AT_extension
: return "DW_AT_extension";
7331 case DW_AT_ranges
: return "DW_AT_ranges";
7332 case DW_AT_trampoline
: return "DW_AT_trampoline";
7333 case DW_AT_call_column
: return "DW_AT_call_column";
7334 case DW_AT_call_file
: return "DW_AT_call_file";
7335 case DW_AT_call_line
: return "DW_AT_call_line";
7336 /* SGI/MIPS extensions. */
7337 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
7338 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
7339 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
7340 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
7341 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
7342 case DW_AT_MIPS_software_pipeline_depth
:
7343 return "DW_AT_MIPS_software_pipeline_depth";
7344 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
7345 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
7346 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
7347 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
7348 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
7349 /* GNU extensions. */
7350 case DW_AT_sf_names
: return "DW_AT_sf_names";
7351 case DW_AT_src_info
: return "DW_AT_src_info";
7352 case DW_AT_mac_info
: return "DW_AT_mac_info";
7353 case DW_AT_src_coords
: return "DW_AT_src_coords";
7354 case DW_AT_body_begin
: return "DW_AT_body_begin";
7355 case DW_AT_body_end
: return "DW_AT_body_end";
7356 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
7357 /* UPC extension. */
7358 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
7361 static char buffer
[100];
7363 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
7370 get_FORM_name (unsigned long form
)
7374 case DW_FORM_addr
: return "DW_FORM_addr";
7375 case DW_FORM_block2
: return "DW_FORM_block2";
7376 case DW_FORM_block4
: return "DW_FORM_block4";
7377 case DW_FORM_data2
: return "DW_FORM_data2";
7378 case DW_FORM_data4
: return "DW_FORM_data4";
7379 case DW_FORM_data8
: return "DW_FORM_data8";
7380 case DW_FORM_string
: return "DW_FORM_string";
7381 case DW_FORM_block
: return "DW_FORM_block";
7382 case DW_FORM_block1
: return "DW_FORM_block1";
7383 case DW_FORM_data1
: return "DW_FORM_data1";
7384 case DW_FORM_flag
: return "DW_FORM_flag";
7385 case DW_FORM_sdata
: return "DW_FORM_sdata";
7386 case DW_FORM_strp
: return "DW_FORM_strp";
7387 case DW_FORM_udata
: return "DW_FORM_udata";
7388 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7389 case DW_FORM_ref1
: return "DW_FORM_ref1";
7390 case DW_FORM_ref2
: return "DW_FORM_ref2";
7391 case DW_FORM_ref4
: return "DW_FORM_ref4";
7392 case DW_FORM_ref8
: return "DW_FORM_ref8";
7393 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7394 case DW_FORM_indirect
: return "DW_FORM_indirect";
7397 static char buffer
[100];
7399 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7405 /* FIXME: There are better and more efficient ways to handle
7406 these structures. For now though, I just want something that
7407 is simple to implement. */
7408 typedef struct abbrev_attr
7410 unsigned long attribute
;
7412 struct abbrev_attr
*next
;
7416 typedef struct abbrev_entry
7418 unsigned long entry
;
7421 struct abbrev_attr
*first_attr
;
7422 struct abbrev_attr
*last_attr
;
7423 struct abbrev_entry
*next
;
7427 static abbrev_entry
*first_abbrev
= NULL
;
7428 static abbrev_entry
*last_abbrev
= NULL
;
7433 abbrev_entry
*abbrev
;
7435 for (abbrev
= first_abbrev
; abbrev
;)
7437 abbrev_entry
*next
= abbrev
->next
;
7440 for (attr
= abbrev
->first_attr
; attr
;)
7442 abbrev_attr
*next
= attr
->next
;
7452 last_abbrev
= first_abbrev
= NULL
;
7456 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7458 abbrev_entry
*entry
;
7460 entry
= malloc (sizeof (*entry
));
7466 entry
->entry
= number
;
7468 entry
->children
= children
;
7469 entry
->first_attr
= NULL
;
7470 entry
->last_attr
= NULL
;
7473 if (first_abbrev
== NULL
)
7474 first_abbrev
= entry
;
7476 last_abbrev
->next
= entry
;
7478 last_abbrev
= entry
;
7482 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7486 attr
= malloc (sizeof (*attr
));
7492 attr
->attribute
= attribute
;
7496 if (last_abbrev
->first_attr
== NULL
)
7497 last_abbrev
->first_attr
= attr
;
7499 last_abbrev
->last_attr
->next
= attr
;
7501 last_abbrev
->last_attr
= attr
;
7504 /* Processes the (partial) contents of a .debug_abbrev section.
7505 Returns NULL if the end of the section was encountered.
7506 Returns the address after the last byte read if the end of
7507 an abbreviation set was found. */
7509 static unsigned char *
7510 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7512 if (first_abbrev
!= NULL
)
7518 unsigned long entry
;
7520 unsigned long attribute
;
7523 entry
= read_leb128 (start
, & bytes_read
, 0);
7524 start
+= bytes_read
;
7526 /* A single zero is supposed to end the section according
7527 to the standard. If there's more, then signal that to
7530 return start
== end
? NULL
: start
;
7532 tag
= read_leb128 (start
, & bytes_read
, 0);
7533 start
+= bytes_read
;
7535 children
= *start
++;
7537 add_abbrev (entry
, tag
, children
);
7543 attribute
= read_leb128 (start
, & bytes_read
, 0);
7544 start
+= bytes_read
;
7546 form
= read_leb128 (start
, & bytes_read
, 0);
7547 start
+= bytes_read
;
7550 add_abbrev_attr (attribute
, form
);
7552 while (attribute
!= 0);
7560 display_debug_macinfo (Elf_Internal_Shdr
*section
,
7561 unsigned char *start
,
7562 FILE *file ATTRIBUTE_UNUSED
)
7564 unsigned char *end
= start
+ section
->sh_size
;
7565 unsigned char *curr
= start
;
7566 unsigned int bytes_read
;
7567 enum dwarf_macinfo_record_type op
;
7569 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7573 unsigned int lineno
;
7581 case DW_MACINFO_start_file
:
7583 unsigned int filenum
;
7585 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7587 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7590 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7594 case DW_MACINFO_end_file
:
7595 printf (_(" DW_MACINFO_end_file\n"));
7598 case DW_MACINFO_define
:
7599 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7602 curr
+= strlen (string
) + 1;
7603 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7606 case DW_MACINFO_undef
:
7607 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7610 curr
+= strlen (string
) + 1;
7611 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7614 case DW_MACINFO_vendor_ext
:
7616 unsigned int constant
;
7618 constant
= read_leb128 (curr
, & bytes_read
, 0);
7621 curr
+= strlen (string
) + 1;
7622 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7633 display_debug_abbrev (Elf_Internal_Shdr
*section
,
7634 unsigned char *start
,
7635 FILE *file ATTRIBUTE_UNUSED
)
7637 abbrev_entry
*entry
;
7638 unsigned char *end
= start
+ section
->sh_size
;
7640 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7644 start
= process_abbrev_section (start
, end
);
7646 if (first_abbrev
== NULL
)
7649 printf (_(" Number TAG\n"));
7651 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7655 printf (_(" %ld %s [%s]\n"),
7657 get_TAG_name (entry
->tag
),
7658 entry
->children
? _("has children") : _("no children"));
7660 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7662 printf (_(" %-18s %s\n"),
7663 get_AT_name (attr
->attribute
),
7664 get_FORM_name (attr
->form
));
7678 static unsigned char *
7679 display_block (unsigned char *data
, unsigned long length
)
7681 printf (_(" %lu byte block: "), length
);
7684 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7690 decode_location_expression (unsigned char * data
,
7691 unsigned int pointer_size
,
7692 unsigned long length
)
7696 unsigned long uvalue
;
7697 unsigned char *end
= data
+ length
;
7706 printf ("DW_OP_addr: %lx",
7707 (unsigned long) byte_get (data
, pointer_size
));
7708 data
+= pointer_size
;
7711 printf ("DW_OP_deref");
7714 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7717 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7720 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7724 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7728 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7732 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7736 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7737 (unsigned long) byte_get (data
+ 4, 4));
7741 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7742 (long) byte_get (data
+ 4, 4));
7746 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7750 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7754 printf ("DW_OP_dup");
7757 printf ("DW_OP_drop");
7760 printf ("DW_OP_over");
7763 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7766 printf ("DW_OP_swap");
7769 printf ("DW_OP_rot");
7772 printf ("DW_OP_xderef");
7775 printf ("DW_OP_abs");
7778 printf ("DW_OP_and");
7781 printf ("DW_OP_div");
7784 printf ("DW_OP_minus");
7787 printf ("DW_OP_mod");
7790 printf ("DW_OP_mul");
7793 printf ("DW_OP_neg");
7796 printf ("DW_OP_not");
7799 printf ("DW_OP_or");
7802 printf ("DW_OP_plus");
7804 case DW_OP_plus_uconst
:
7805 printf ("DW_OP_plus_uconst: %lu",
7806 read_leb128 (data
, &bytes_read
, 0));
7810 printf ("DW_OP_shl");
7813 printf ("DW_OP_shr");
7816 printf ("DW_OP_shra");
7819 printf ("DW_OP_xor");
7822 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7826 printf ("DW_OP_eq");
7829 printf ("DW_OP_ge");
7832 printf ("DW_OP_gt");
7835 printf ("DW_OP_le");
7838 printf ("DW_OP_lt");
7841 printf ("DW_OP_ne");
7844 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7880 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7915 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7950 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7951 read_leb128 (data
, &bytes_read
, 1));
7956 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7960 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7964 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7966 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7967 read_leb128 (data
, &bytes_read
, 1));
7971 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7974 case DW_OP_deref_size
:
7975 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7977 case DW_OP_xderef_size
:
7978 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7981 printf ("DW_OP_nop");
7984 /* DWARF 3 extensions. */
7985 case DW_OP_push_object_address
:
7986 printf ("DW_OP_push_object_address");
7989 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7993 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7996 case DW_OP_call_ref
:
7997 printf ("DW_OP_call_ref");
8000 /* GNU extensions. */
8001 case DW_OP_GNU_push_tls_address
:
8002 printf ("DW_OP_GNU_push_tls_address");
8006 if (op
>= DW_OP_lo_user
8007 && op
<= DW_OP_hi_user
)
8008 printf (_("(User defined location op)"));
8010 printf (_("(Unknown location op)"));
8011 /* No way to tell where the next op is, so just bail. */
8015 /* Separate the ops. */
8021 static const char *debug_loc_contents
;
8022 static bfd_vma debug_loc_size
;
8025 load_debug_loc (FILE *file
)
8027 Elf_Internal_Shdr
*sec
;
8029 /* If it is already loaded, do nothing. */
8030 if (debug_loc_contents
!= NULL
)
8033 /* Locate the .debug_loc section. */
8034 sec
= find_section (".debug_loc");
8038 debug_loc_size
= sec
->sh_size
;
8040 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8041 _("debug_loc section data"));
8045 free_debug_loc (void)
8047 if (debug_loc_contents
== NULL
)
8050 free ((char *) debug_loc_contents
);
8051 debug_loc_contents
= NULL
;
8057 display_debug_loc (Elf_Internal_Shdr
*section
,
8058 unsigned char *start
, FILE *file
)
8060 unsigned char *section_end
;
8061 unsigned long bytes
;
8062 unsigned char *section_begin
= start
;
8064 unsigned int comp_unit
= 0;
8066 addr
= section
->sh_addr
;
8067 bytes
= section
->sh_size
;
8068 section_end
= start
+ bytes
;
8072 printf (_("\nThe .debug_loc section is empty.\n"));
8076 if (num_debug_line_pointer_sizes
== 0)
8077 get_debug_line_pointer_sizes (file
);
8079 printf (_("Contents of the .debug_loc section:\n\n"));
8080 printf (_("\n Offset Begin End Expression\n"));
8082 while (start
< section_end
)
8084 unsigned long begin
;
8086 unsigned short length
;
8087 unsigned long offset
;
8088 unsigned int pointer_size
;
8090 offset
= start
- section_begin
;
8092 /* Get the pointer size from the comp unit associated
8093 with this block of location information. */
8094 if (comp_unit
>= num_debug_line_pointer_sizes
)
8096 error (_("Not enough comp units for .debug_loc section\n"));
8101 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
8107 begin
= byte_get (start
, pointer_size
);
8108 start
+= pointer_size
;
8109 end
= byte_get (start
, pointer_size
);
8110 start
+= pointer_size
;
8112 if (begin
== 0 && end
== 0)
8115 /* For now, skip any base address specifiers. */
8116 if (begin
== 0xffffffff)
8122 length
= byte_get (start
, 2);
8125 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
8126 decode_location_expression (start
, pointer_size
, length
);
8136 static const char *debug_str_contents
;
8137 static bfd_vma debug_str_size
;
8140 load_debug_str (FILE *file
)
8142 Elf_Internal_Shdr
*sec
;
8144 /* If it is already loaded, do nothing. */
8145 if (debug_str_contents
!= NULL
)
8148 /* Locate the .debug_str section. */
8149 sec
= find_section (".debug_str");
8153 debug_str_size
= sec
->sh_size
;
8155 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8156 _("debug_str section data"));
8160 free_debug_str (void)
8162 if (debug_str_contents
== NULL
)
8165 free ((char *) debug_str_contents
);
8166 debug_str_contents
= NULL
;
8171 fetch_indirect_string (unsigned long offset
)
8173 if (debug_str_contents
== NULL
)
8174 return _("<no .debug_str section>");
8176 if (offset
> debug_str_size
)
8177 return _("<offset is too big>");
8179 return debug_str_contents
+ offset
;
8183 display_debug_str (Elf_Internal_Shdr
*section
,
8184 unsigned char *start
,
8185 FILE *file ATTRIBUTE_UNUSED
)
8187 unsigned long bytes
;
8190 addr
= section
->sh_addr
;
8191 bytes
= section
->sh_size
;
8195 printf (_("\nThe .debug_str section is empty.\n"));
8199 printf (_("Contents of the .debug_str section:\n\n"));
8207 lbytes
= (bytes
> 16 ? 16 : bytes
);
8209 printf (" 0x%8.8lx ", (unsigned long) addr
);
8211 for (j
= 0; j
< 16; j
++)
8214 printf ("%2.2x", start
[j
]);
8222 for (j
= 0; j
< lbytes
; j
++)
8225 if (k
>= ' ' && k
< 0x80)
8241 static unsigned char *
8242 read_and_display_attr_value (unsigned long attribute
,
8244 unsigned char *data
,
8245 unsigned long cu_offset
,
8246 unsigned long pointer_size
,
8247 unsigned long offset_size
,
8250 unsigned long uvalue
= 0;
8251 unsigned char *block_start
= NULL
;
8259 case DW_FORM_ref_addr
:
8260 if (dwarf_version
== 2)
8262 uvalue
= byte_get (data
, pointer_size
);
8263 data
+= pointer_size
;
8265 else if (dwarf_version
== 3)
8267 uvalue
= byte_get (data
, offset_size
);
8268 data
+= offset_size
;
8272 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8277 uvalue
= byte_get (data
, pointer_size
);
8278 data
+= pointer_size
;
8282 uvalue
= byte_get (data
, offset_size
);
8283 data
+= offset_size
;
8289 uvalue
= byte_get (data
++, 1);
8294 uvalue
= byte_get (data
, 2);
8300 uvalue
= byte_get (data
, 4);
8305 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8309 case DW_FORM_ref_udata
:
8311 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8315 case DW_FORM_indirect
:
8316 form
= read_leb128 (data
, & bytes_read
, 0);
8318 printf (" %s", get_FORM_name (form
));
8319 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8320 pointer_size
, offset_size
,
8326 case DW_FORM_ref_addr
:
8327 printf (" <#%lx>", uvalue
);
8333 case DW_FORM_ref_udata
:
8334 printf (" <%lx>", uvalue
+ cu_offset
);
8338 printf (" %#lx", uvalue
);
8347 printf (" %ld", uvalue
);
8352 uvalue
= byte_get (data
, 4);
8353 printf (" %lx", uvalue
);
8354 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8358 case DW_FORM_string
:
8359 printf (" %s", data
);
8360 data
+= strlen ((char *) data
) + 1;
8364 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8365 block_start
= data
+ bytes_read
;
8366 data
= display_block (block_start
, uvalue
);
8369 case DW_FORM_block1
:
8370 uvalue
= byte_get (data
, 1);
8371 block_start
= data
+ 1;
8372 data
= display_block (block_start
, uvalue
);
8375 case DW_FORM_block2
:
8376 uvalue
= byte_get (data
, 2);
8377 block_start
= data
+ 2;
8378 data
= display_block (block_start
, uvalue
);
8381 case DW_FORM_block4
:
8382 uvalue
= byte_get (data
, 4);
8383 block_start
= data
+ 4;
8384 data
= display_block (block_start
, uvalue
);
8388 printf (_(" (indirect string, offset: 0x%lx): %s"),
8389 uvalue
, fetch_indirect_string (uvalue
));
8392 case DW_FORM_indirect
:
8393 /* Handled above. */
8397 warn (_("Unrecognized form: %d\n"), form
);
8401 /* For some attributes we can display further information. */
8410 case DW_INL_not_inlined
:
8411 printf (_("(not inlined)"));
8413 case DW_INL_inlined
:
8414 printf (_("(inlined)"));
8416 case DW_INL_declared_not_inlined
:
8417 printf (_("(declared as inline but ignored)"));
8419 case DW_INL_declared_inlined
:
8420 printf (_("(declared as inline and inlined)"));
8423 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8428 case DW_AT_language
:
8431 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8432 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8433 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8434 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8435 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8436 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8437 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8438 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8439 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8440 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8441 /* DWARF 2.1 values. */
8442 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8443 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8444 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8445 /* MIPS extension. */
8446 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8447 /* UPC extension. */
8448 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8450 printf ("(Unknown: %lx)", uvalue
);
8455 case DW_AT_encoding
:
8458 case DW_ATE_void
: printf ("(void)"); break;
8459 case DW_ATE_address
: printf ("(machine address)"); break;
8460 case DW_ATE_boolean
: printf ("(boolean)"); break;
8461 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8462 case DW_ATE_float
: printf ("(float)"); break;
8463 case DW_ATE_signed
: printf ("(signed)"); break;
8464 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8465 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8466 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8467 /* DWARF 2.1 value. */
8468 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8470 if (uvalue
>= DW_ATE_lo_user
8471 && uvalue
<= DW_ATE_hi_user
)
8472 printf ("(user defined type)");
8474 printf ("(unknown type)");
8479 case DW_AT_accessibility
:
8482 case DW_ACCESS_public
: printf ("(public)"); break;
8483 case DW_ACCESS_protected
: printf ("(protected)"); break;
8484 case DW_ACCESS_private
: printf ("(private)"); break;
8486 printf ("(unknown accessibility)");
8491 case DW_AT_visibility
:
8494 case DW_VIS_local
: printf ("(local)"); break;
8495 case DW_VIS_exported
: printf ("(exported)"); break;
8496 case DW_VIS_qualified
: printf ("(qualified)"); break;
8497 default: printf ("(unknown visibility)"); break;
8501 case DW_AT_virtuality
:
8504 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8505 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8506 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8507 default: printf ("(unknown virtuality)"); break;
8511 case DW_AT_identifier_case
:
8514 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8515 case DW_ID_up_case
: printf ("(up_case)"); break;
8516 case DW_ID_down_case
: printf ("(down_case)"); break;
8517 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8518 default: printf ("(unknown case)"); break;
8522 case DW_AT_calling_convention
:
8525 case DW_CC_normal
: printf ("(normal)"); break;
8526 case DW_CC_program
: printf ("(program)"); break;
8527 case DW_CC_nocall
: printf ("(nocall)"); break;
8529 if (uvalue
>= DW_CC_lo_user
8530 && uvalue
<= DW_CC_hi_user
)
8531 printf ("(user defined)");
8533 printf ("(unknown convention)");
8537 case DW_AT_ordering
:
8540 case -1: printf ("(undefined)"); break;
8541 case 0: printf ("(row major)"); break;
8542 case 1: printf ("(column major)"); break;
8546 case DW_AT_frame_base
:
8547 case DW_AT_location
:
8548 case DW_AT_data_member_location
:
8549 case DW_AT_vtable_elem_location
:
8550 case DW_AT_allocated
:
8551 case DW_AT_associated
:
8552 case DW_AT_data_location
:
8554 case DW_AT_upper_bound
:
8555 case DW_AT_lower_bound
:
8559 decode_location_expression (block_start
, pointer_size
, uvalue
);
8562 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8565 printf ("location list");
8577 static unsigned char *
8578 read_and_display_attr (unsigned long attribute
,
8580 unsigned char *data
,
8581 unsigned long cu_offset
,
8582 unsigned long pointer_size
,
8583 unsigned long offset_size
,
8586 printf (" %-18s:", get_AT_name (attribute
));
8587 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8588 pointer_size
, offset_size
, dwarf_version
);
8593 /* Apply addends of RELA relocations. */
8596 debug_apply_rela_addends (FILE *file
,
8597 Elf_Internal_Shdr
*section
,
8599 unsigned char *sec_data
,
8600 unsigned char *start
,
8603 Elf_Internal_Shdr
*relsec
;
8605 if (end
- start
< reloc_size
)
8608 for (relsec
= section_headers
;
8609 relsec
< section_headers
+ elf_header
.e_shnum
;
8612 unsigned long nrelas
;
8613 Elf_Internal_Rela
*rela
, *rp
;
8614 Elf_Internal_Shdr
*symsec
;
8615 Elf_Internal_Sym
*symtab
;
8616 Elf_Internal_Sym
*sym
;
8618 if (relsec
->sh_type
!= SHT_RELA
8619 || SECTION_HEADER (relsec
->sh_info
) != section
8620 || relsec
->sh_size
== 0)
8623 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8627 symsec
= SECTION_HEADER (relsec
->sh_link
);
8628 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8630 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8634 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
8635 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
8636 loc
= sec_data
+ rp
->r_offset
;
8642 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8644 if (ELF32_R_SYM (rp
->r_info
) != 0
8645 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8647 warn (_("Skipping unexpected symbol type %u\n"),
8648 ELF32_ST_TYPE (sym
->st_info
));
8654 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8656 if (ELF64_R_SYM (rp
->r_info
) != 0
8657 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8659 warn (_("Skipping unexpected symbol type %u\n"),
8660 ELF64_ST_TYPE (sym
->st_info
));
8665 byte_put (loc
, rp
->r_addend
, reloc_size
);
8676 display_debug_info (Elf_Internal_Shdr
*section
,
8677 unsigned char *start
,
8680 unsigned char *end
= start
+ section
->sh_size
;
8681 unsigned char *section_begin
= start
;
8683 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8685 load_debug_str (file
);
8686 load_debug_loc (file
);
8690 DWARF2_Internal_CompUnit compunit
;
8691 unsigned char *hdrptr
;
8692 unsigned char *cu_abbrev_offset_ptr
;
8693 unsigned char *tags
;
8695 unsigned long cu_offset
;
8697 int initial_length_size
;
8701 compunit
.cu_length
= byte_get (hdrptr
, 4);
8704 if (compunit
.cu_length
== 0xffffffff)
8706 compunit
.cu_length
= byte_get (hdrptr
, 8);
8709 initial_length_size
= 12;
8714 initial_length_size
= 4;
8717 compunit
.cu_version
= byte_get (hdrptr
, 2);
8720 cu_offset
= start
- section_begin
;
8721 start
+= compunit
.cu_length
+ initial_length_size
;
8723 if (elf_header
.e_type
== ET_REL
8724 && !debug_apply_rela_addends (file
, section
, offset_size
,
8725 section_begin
, hdrptr
, start
))
8728 cu_abbrev_offset_ptr
= hdrptr
;
8729 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8730 hdrptr
+= offset_size
;
8732 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8737 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8738 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8739 printf (_(" Version: %d\n"), compunit
.cu_version
);
8740 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8741 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8743 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8745 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8751 /* Read in the abbrevs used by this compilation unit. */
8753 Elf_Internal_Shdr
*sec
;
8754 unsigned char *begin
;
8756 /* Locate the .debug_abbrev section and process it. */
8757 sec
= find_section (".debug_abbrev");
8760 warn (_("Unable to locate .debug_abbrev section!\n"));
8764 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8765 _("debug_abbrev section data"));
8769 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8770 begin
+ sec
->sh_size
);
8776 while (tags
< start
)
8779 unsigned long abbrev_number
;
8780 abbrev_entry
*entry
;
8783 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8786 /* A null DIE marks the end of a list of children. */
8787 if (abbrev_number
== 0)
8793 /* Scan through the abbreviation list until we reach the
8795 for (entry
= first_abbrev
;
8796 entry
&& entry
->entry
!= abbrev_number
;
8797 entry
= entry
->next
)
8802 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8807 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8809 (unsigned long) (tags
- section_begin
- bytes_read
),
8811 get_TAG_name (entry
->tag
));
8813 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8814 tags
= read_and_display_attr (attr
->attribute
,
8817 compunit
.cu_pointer_size
,
8819 compunit
.cu_version
);
8821 if (entry
->children
)
8835 display_debug_aranges (Elf_Internal_Shdr
*section
,
8836 unsigned char *start
,
8837 FILE *file ATTRIBUTE_UNUSED
)
8839 unsigned char *end
= start
+ section
->sh_size
;
8841 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8845 unsigned char *hdrptr
;
8846 DWARF2_Internal_ARange arange
;
8847 unsigned char *ranges
;
8848 unsigned long length
;
8849 unsigned long address
;
8852 int initial_length_size
;
8856 arange
.ar_length
= byte_get (hdrptr
, 4);
8859 if (arange
.ar_length
== 0xffffffff)
8861 arange
.ar_length
= byte_get (hdrptr
, 8);
8864 initial_length_size
= 12;
8869 initial_length_size
= 4;
8872 arange
.ar_version
= byte_get (hdrptr
, 2);
8875 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
8876 hdrptr
+= offset_size
;
8878 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
8881 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
8884 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
8886 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8890 printf (_(" Length: %ld\n"), arange
.ar_length
);
8891 printf (_(" Version: %d\n"), arange
.ar_version
);
8892 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8893 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8894 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8896 printf (_("\n Address Length\n"));
8900 /* Must pad to an alignment boundary that is twice the pointer size. */
8901 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
8903 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8907 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8909 ranges
+= arange
.ar_pointer_size
;
8911 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8913 ranges
+= arange
.ar_pointer_size
;
8915 /* A pair of zeros marks the end of the list. */
8916 if (address
== 0 && length
== 0)
8919 printf (" %8.8lx %lu\n", address
, length
);
8922 start
+= arange
.ar_length
+ initial_length_size
;
8930 typedef struct Frame_Chunk
8932 struct Frame_Chunk
*next
;
8933 unsigned char *chunk_start
;
8935 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8936 short int *col_type
;
8939 unsigned int code_factor
;
8941 unsigned long pc_begin
;
8942 unsigned long pc_range
;
8946 unsigned char fde_encoding
;
8947 unsigned char cfa_exp
;
8951 /* A marker for a col_type that means this column was never referenced
8952 in the frame info. */
8953 #define DW_CFA_unreferenced (-1)
8956 frame_need_space (Frame_Chunk
*fc
, int reg
)
8958 int prev
= fc
->ncols
;
8960 if (reg
< fc
->ncols
)
8963 fc
->ncols
= reg
+ 1;
8964 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
8965 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
8967 while (prev
< fc
->ncols
)
8969 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8970 fc
->col_offset
[prev
] = 0;
8976 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
8981 if (*max_regs
< fc
->ncols
)
8982 *max_regs
= fc
->ncols
;
8984 if (*need_col_headers
)
8986 *need_col_headers
= 0;
8988 printf (" LOC CFA ");
8990 for (r
= 0; r
< *max_regs
; r
++)
8991 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8996 printf ("r%-4d", r
);
9002 printf ("%08lx ", fc
->pc_begin
);
9004 strcpy (tmp
, "exp");
9006 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
9007 printf ("%-8s ", tmp
);
9009 for (r
= 0; r
< fc
->ncols
; r
++)
9011 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
9013 switch (fc
->col_type
[r
])
9015 case DW_CFA_undefined
:
9018 case DW_CFA_same_value
:
9022 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
9024 case DW_CFA_register
:
9025 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
9027 case DW_CFA_expression
:
9028 strcpy (tmp
, "exp");
9031 strcpy (tmp
, "n/a");
9034 printf ("%-5s", tmp
);
9041 size_of_encoded_value (int encoding
)
9043 switch (encoding
& 0x7)
9046 case 0: return is_32bit_elf
? 4 : 8;
9054 get_encoded_value (unsigned char *data
, int encoding
)
9056 int size
= size_of_encoded_value (encoding
);
9057 if (encoding
& DW_EH_PE_signed
)
9058 return byte_get_signed (data
, size
);
9060 return byte_get (data
, size
);
9063 #define GET(N) byte_get (start, N); start += N
9064 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9065 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9068 display_debug_frames (Elf_Internal_Shdr
*section
,
9069 unsigned char *start
,
9070 FILE *file ATTRIBUTE_UNUSED
)
9072 unsigned char *end
= start
+ section
->sh_size
;
9073 unsigned char *section_start
= start
;
9074 Frame_Chunk
*chunks
= 0;
9075 Frame_Chunk
*remembered_state
= 0;
9077 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
9080 int addr_size
= is_32bit_elf
? 4 : 8;
9082 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
9086 unsigned char *saved_start
;
9087 unsigned char *block_end
;
9088 unsigned long length
;
9089 unsigned long cie_id
;
9092 int need_col_headers
= 1;
9093 unsigned char *augmentation_data
= NULL
;
9094 unsigned long augmentation_data_len
= 0;
9095 int encoded_ptr_size
= addr_size
;
9097 int initial_length_size
;
9099 saved_start
= start
;
9100 length
= byte_get (start
, 4); start
+= 4;
9104 printf ("\n%08lx ZERO terminator\n\n",
9105 (unsigned long)(saved_start
- section_start
));
9109 if (length
== 0xffffffff)
9111 length
= byte_get (start
, 8);
9114 initial_length_size
= 12;
9119 initial_length_size
= 4;
9122 block_end
= saved_start
+ length
+ initial_length_size
;
9123 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
9125 if (elf_header
.e_type
== ET_REL
9126 && !debug_apply_rela_addends (file
, section
, offset_size
,
9127 section_start
, start
, block_end
))
9130 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
9134 fc
= xmalloc (sizeof (Frame_Chunk
));
9135 memset (fc
, 0, sizeof (Frame_Chunk
));
9139 fc
->chunk_start
= saved_start
;
9141 fc
->col_type
= xmalloc (sizeof (short int));
9142 fc
->col_offset
= xmalloc (sizeof (int));
9143 frame_need_space (fc
, max_regs
-1);
9147 fc
->augmentation
= start
;
9148 start
= strchr (start
, '\0') + 1;
9150 if (fc
->augmentation
[0] == 'z')
9152 fc
->code_factor
= LEB ();
9153 fc
->data_factor
= SLEB ();
9162 augmentation_data_len
= LEB ();
9163 augmentation_data
= start
;
9164 start
+= augmentation_data_len
;
9166 else if (strcmp (fc
->augmentation
, "eh") == 0)
9169 fc
->code_factor
= LEB ();
9170 fc
->data_factor
= SLEB ();
9182 fc
->code_factor
= LEB ();
9183 fc
->data_factor
= SLEB ();
9195 if (do_debug_frames_interp
)
9196 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
9197 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9198 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
9202 printf ("\n%08lx %08lx %08lx CIE\n",
9203 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
9204 printf (" Version: %d\n", version
);
9205 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9206 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9207 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9208 printf (" Return address column: %d\n", fc
->ra
);
9210 if (augmentation_data_len
)
9213 printf (" Augmentation data: ");
9214 for (i
= 0; i
< augmentation_data_len
; ++i
)
9215 printf (" %02x", augmentation_data
[i
]);
9221 if (augmentation_data_len
)
9223 unsigned char *p
, *q
;
9224 p
= fc
->augmentation
+ 1;
9225 q
= augmentation_data
;
9232 q
+= 1 + size_of_encoded_value (*q
);
9234 fc
->fde_encoding
= *q
++;
9240 if (fc
->fde_encoding
)
9241 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9244 frame_need_space (fc
, fc
->ra
);
9248 unsigned char *look_for
;
9249 static Frame_Chunk fde_fc
;
9252 memset (fc
, 0, sizeof (Frame_Chunk
));
9254 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
9256 for (cie
= chunks
; cie
; cie
= cie
->next
)
9257 if (cie
->chunk_start
== look_for
)
9262 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9263 cie_id
, saved_start
);
9266 fc
->col_type
= xmalloc (sizeof (short int));
9267 fc
->col_offset
= xmalloc (sizeof (int));
9268 frame_need_space (fc
, max_regs
- 1);
9270 fc
->augmentation
= "";
9271 fc
->fde_encoding
= 0;
9275 fc
->ncols
= cie
->ncols
;
9276 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
9277 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
9278 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9279 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9280 fc
->augmentation
= cie
->augmentation
;
9281 fc
->code_factor
= cie
->code_factor
;
9282 fc
->data_factor
= cie
->data_factor
;
9283 fc
->cfa_reg
= cie
->cfa_reg
;
9284 fc
->cfa_offset
= cie
->cfa_offset
;
9286 frame_need_space (fc
, max_regs
-1);
9287 fc
->fde_encoding
= cie
->fde_encoding
;
9290 if (fc
->fde_encoding
)
9291 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9293 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
9294 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9295 /* Don't adjust for ET_REL since there's invariably a pcrel
9296 reloc here, which we haven't applied. */
9297 && elf_header
.e_type
!= ET_REL
)
9298 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
9299 start
+= encoded_ptr_size
;
9300 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
9301 start
+= encoded_ptr_size
;
9303 if (cie
->augmentation
[0] == 'z')
9305 augmentation_data_len
= LEB ();
9306 augmentation_data
= start
;
9307 start
+= augmentation_data_len
;
9310 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9311 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9312 (unsigned long)(cie
->chunk_start
- section_start
),
9313 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
9314 if (! do_debug_frames_interp
&& augmentation_data_len
)
9317 printf (" Augmentation data: ");
9318 for (i
= 0; i
< augmentation_data_len
; ++i
)
9319 printf (" %02x", augmentation_data
[i
]);
9325 /* At this point, fc is the current chunk, cie (if any) is set, and we're
9326 about to interpret instructions for the chunk. */
9327 /* ??? At present we need to do this always, since this sizes the
9328 fc->col_type and fc->col_offset arrays, which we write into always.
9329 We should probably split the interpreted and non-interpreted bits
9330 into two different routines, since there's so much that doesn't
9331 really overlap between them. */
9332 if (1 || do_debug_frames_interp
)
9334 /* Start by making a pass over the chunk, allocating storage
9335 and taking note of what registers are used. */
9336 unsigned char *tmp
= start
;
9338 while (start
< block_end
)
9341 unsigned long reg
, tmp
;
9348 /* Warning: if you add any more cases to this switch, be
9349 sure to add them to the corresponding switch below. */
9352 case DW_CFA_advance_loc
:
9356 frame_need_space (fc
, opa
);
9357 fc
->col_type
[opa
] = DW_CFA_undefined
;
9359 case DW_CFA_restore
:
9360 frame_need_space (fc
, opa
);
9361 fc
->col_type
[opa
] = DW_CFA_undefined
;
9363 case DW_CFA_set_loc
:
9364 start
+= encoded_ptr_size
;
9366 case DW_CFA_advance_loc1
:
9369 case DW_CFA_advance_loc2
:
9372 case DW_CFA_advance_loc4
:
9375 case DW_CFA_offset_extended
:
9376 reg
= LEB (); LEB ();
9377 frame_need_space (fc
, reg
);
9378 fc
->col_type
[reg
] = DW_CFA_undefined
;
9380 case DW_CFA_restore_extended
:
9382 frame_need_space (fc
, reg
);
9383 fc
->col_type
[reg
] = DW_CFA_undefined
;
9385 case DW_CFA_undefined
:
9387 frame_need_space (fc
, reg
);
9388 fc
->col_type
[reg
] = DW_CFA_undefined
;
9390 case DW_CFA_same_value
:
9392 frame_need_space (fc
, reg
);
9393 fc
->col_type
[reg
] = DW_CFA_undefined
;
9395 case DW_CFA_register
:
9396 reg
= LEB (); LEB ();
9397 frame_need_space (fc
, reg
);
9398 fc
->col_type
[reg
] = DW_CFA_undefined
;
9400 case DW_CFA_def_cfa
:
9403 case DW_CFA_def_cfa_register
:
9406 case DW_CFA_def_cfa_offset
:
9409 case DW_CFA_def_cfa_expression
:
9413 case DW_CFA_expression
:
9417 frame_need_space (fc
, reg
);
9418 fc
->col_type
[reg
] = DW_CFA_undefined
;
9420 case DW_CFA_offset_extended_sf
:
9421 reg
= LEB (); SLEB ();
9422 frame_need_space (fc
, reg
);
9423 fc
->col_type
[reg
] = DW_CFA_undefined
;
9425 case DW_CFA_def_cfa_sf
:
9428 case DW_CFA_def_cfa_offset_sf
:
9431 case DW_CFA_MIPS_advance_loc8
:
9434 case DW_CFA_GNU_args_size
:
9437 case DW_CFA_GNU_negative_offset_extended
:
9438 reg
= LEB (); LEB ();
9439 frame_need_space (fc
, reg
);
9440 fc
->col_type
[reg
] = DW_CFA_undefined
;
9449 /* Now we know what registers are used, make a second pass over
9450 the chunk, this time actually printing out the info. */
9452 while (start
< block_end
)
9455 unsigned long ul
, reg
, roffs
;
9464 /* Warning: if you add any more cases to this switch, be
9465 sure to add them to the corresponding switch above. */
9468 case DW_CFA_advance_loc
:
9469 if (do_debug_frames_interp
)
9470 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9472 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9473 opa
* fc
->code_factor
,
9474 fc
->pc_begin
+ opa
* fc
->code_factor
);
9475 fc
->pc_begin
+= opa
* fc
->code_factor
;
9480 if (! do_debug_frames_interp
)
9481 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9482 opa
, roffs
* fc
->data_factor
);
9483 fc
->col_type
[opa
] = DW_CFA_offset
;
9484 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9487 case DW_CFA_restore
:
9488 if (! do_debug_frames_interp
)
9489 printf (" DW_CFA_restore: r%d\n", opa
);
9490 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9491 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9494 case DW_CFA_set_loc
:
9495 vma
= get_encoded_value (start
, fc
->fde_encoding
);
9496 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9497 && elf_header
.e_type
!= ET_REL
)
9498 vma
+= section
->sh_addr
+ (start
- section_start
);
9499 start
+= encoded_ptr_size
;
9500 if (do_debug_frames_interp
)
9501 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9503 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
9507 case DW_CFA_advance_loc1
:
9508 ofs
= byte_get (start
, 1); start
+= 1;
9509 if (do_debug_frames_interp
)
9510 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9512 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9513 ofs
* fc
->code_factor
,
9514 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9515 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9518 case DW_CFA_advance_loc2
:
9519 ofs
= byte_get (start
, 2); start
+= 2;
9520 if (do_debug_frames_interp
)
9521 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9523 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9524 ofs
* fc
->code_factor
,
9525 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9526 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9529 case DW_CFA_advance_loc4
:
9530 ofs
= byte_get (start
, 4); start
+= 4;
9531 if (do_debug_frames_interp
)
9532 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9534 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9535 ofs
* fc
->code_factor
,
9536 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9537 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9540 case DW_CFA_offset_extended
:
9543 if (! do_debug_frames_interp
)
9544 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9545 reg
, roffs
* fc
->data_factor
);
9546 fc
->col_type
[reg
] = DW_CFA_offset
;
9547 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9550 case DW_CFA_restore_extended
:
9552 if (! do_debug_frames_interp
)
9553 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
9554 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9555 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9558 case DW_CFA_undefined
:
9560 if (! do_debug_frames_interp
)
9561 printf (" DW_CFA_undefined: r%ld\n", reg
);
9562 fc
->col_type
[reg
] = DW_CFA_undefined
;
9563 fc
->col_offset
[reg
] = 0;
9566 case DW_CFA_same_value
:
9568 if (! do_debug_frames_interp
)
9569 printf (" DW_CFA_same_value: r%ld\n", reg
);
9570 fc
->col_type
[reg
] = DW_CFA_same_value
;
9571 fc
->col_offset
[reg
] = 0;
9574 case DW_CFA_register
:
9577 if (! do_debug_frames_interp
)
9578 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
9579 fc
->col_type
[reg
] = DW_CFA_register
;
9580 fc
->col_offset
[reg
] = roffs
;
9583 case DW_CFA_remember_state
:
9584 if (! do_debug_frames_interp
)
9585 printf (" DW_CFA_remember_state\n");
9586 rs
= xmalloc (sizeof (Frame_Chunk
));
9587 rs
->ncols
= fc
->ncols
;
9588 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
9589 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
9590 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
9591 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
9592 rs
->next
= remembered_state
;
9593 remembered_state
= rs
;
9596 case DW_CFA_restore_state
:
9597 if (! do_debug_frames_interp
)
9598 printf (" DW_CFA_restore_state\n");
9599 rs
= remembered_state
;
9602 remembered_state
= rs
->next
;
9603 frame_need_space (fc
, rs
->ncols
-1);
9604 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
9605 memcpy (fc
->col_offset
, rs
->col_offset
,
9606 rs
->ncols
* sizeof (int));
9607 free (rs
->col_type
);
9608 free (rs
->col_offset
);
9611 else if (do_debug_frames_interp
)
9612 printf ("Mismatched DW_CFA_restore_state\n");
9615 case DW_CFA_def_cfa
:
9616 fc
->cfa_reg
= LEB ();
9617 fc
->cfa_offset
= LEB ();
9619 if (! do_debug_frames_interp
)
9620 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9621 fc
->cfa_reg
, fc
->cfa_offset
);
9624 case DW_CFA_def_cfa_register
:
9625 fc
->cfa_reg
= LEB ();
9627 if (! do_debug_frames_interp
)
9628 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9631 case DW_CFA_def_cfa_offset
:
9632 fc
->cfa_offset
= LEB ();
9633 if (! do_debug_frames_interp
)
9634 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9638 if (! do_debug_frames_interp
)
9639 printf (" DW_CFA_nop\n");
9642 case DW_CFA_def_cfa_expression
:
9644 if (! do_debug_frames_interp
)
9646 printf (" DW_CFA_def_cfa_expression (");
9647 decode_location_expression (start
, addr_size
, ul
);
9654 case DW_CFA_expression
:
9657 if (! do_debug_frames_interp
)
9659 printf (" DW_CFA_expression: r%ld (", reg
);
9660 decode_location_expression (start
, addr_size
, ul
);
9663 fc
->col_type
[reg
] = DW_CFA_expression
;
9667 case DW_CFA_offset_extended_sf
:
9670 frame_need_space (fc
, reg
);
9671 if (! do_debug_frames_interp
)
9672 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9673 reg
, l
* fc
->data_factor
);
9674 fc
->col_type
[reg
] = DW_CFA_offset
;
9675 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9678 case DW_CFA_def_cfa_sf
:
9679 fc
->cfa_reg
= LEB ();
9680 fc
->cfa_offset
= SLEB ();
9682 if (! do_debug_frames_interp
)
9683 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9684 fc
->cfa_reg
, fc
->cfa_offset
);
9687 case DW_CFA_def_cfa_offset_sf
:
9688 fc
->cfa_offset
= SLEB ();
9689 if (! do_debug_frames_interp
)
9690 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9693 case DW_CFA_MIPS_advance_loc8
:
9694 ofs
= byte_get (start
, 8); start
+= 8;
9695 if (do_debug_frames_interp
)
9696 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9698 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9699 ofs
* fc
->code_factor
,
9700 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9701 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9704 case DW_CFA_GNU_window_save
:
9705 if (! do_debug_frames_interp
)
9706 printf (" DW_CFA_GNU_window_save\n");
9709 case DW_CFA_GNU_args_size
:
9711 if (! do_debug_frames_interp
)
9712 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9715 case DW_CFA_GNU_negative_offset_extended
:
9718 frame_need_space (fc
, reg
);
9719 if (! do_debug_frames_interp
)
9720 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9721 reg
, l
* fc
->data_factor
);
9722 fc
->col_type
[reg
] = DW_CFA_offset
;
9723 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9727 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9732 if (do_debug_frames_interp
)
9733 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9748 display_debug_not_supported (Elf_Internal_Shdr
*section
,
9749 unsigned char *start ATTRIBUTE_UNUSED
,
9750 FILE *file ATTRIBUTE_UNUSED
)
9752 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9753 SECTION_NAME (section
));
9758 /* A structure containing the name of a debug section
9759 and a pointer to a function that can decode it. */
9762 const char *const name
;
9763 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
9767 { ".debug_abbrev", display_debug_abbrev
},
9768 { ".debug_aranges", display_debug_aranges
},
9769 { ".debug_frame", display_debug_frames
},
9770 { ".debug_info", display_debug_info
},
9771 { ".debug_line", display_debug_lines
},
9772 { ".debug_pubnames", display_debug_pubnames
},
9773 { ".eh_frame", display_debug_frames
},
9774 { ".debug_macinfo", display_debug_macinfo
},
9775 { ".debug_str", display_debug_str
},
9776 { ".debug_loc", display_debug_loc
},
9777 { ".debug_pubtypes", display_debug_pubnames
},
9778 { ".debug_ranges", display_debug_not_supported
},
9779 { ".debug_static_func", display_debug_not_supported
},
9780 { ".debug_static_vars", display_debug_not_supported
},
9781 { ".debug_types", display_debug_not_supported
},
9782 { ".debug_weaknames", display_debug_not_supported
}
9786 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
9788 char *name
= SECTION_NAME (section
);
9789 bfd_size_type length
;
9790 unsigned char *start
;
9793 length
= section
->sh_size
;
9796 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9800 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
9801 _("debug section data"));
9805 /* See if we know how to display the contents of this section. */
9806 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9807 name
= ".debug_info";
9809 for (i
= NUM_ELEM (debug_displays
); i
--;)
9810 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9812 debug_displays
[i
].display (section
, start
, file
);
9817 printf (_("Unrecognized debug section: %s\n"), name
);
9821 /* If we loaded in the abbrev section at some point,
9822 we must release it here. */
9829 process_section_contents (FILE *file
)
9831 Elf_Internal_Shdr
*section
;
9837 for (i
= 0, section
= section_headers
;
9838 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9841 #ifdef SUPPORT_DISASSEMBLY
9842 if (dump_sects
[i
] & DISASS_DUMP
)
9843 disassemble_section (section
, file
);
9845 if (dump_sects
[i
] & HEX_DUMP
)
9846 dump_section (section
, file
);
9848 if (dump_sects
[i
] & DEBUG_DUMP
)
9849 display_debug_section (section
, file
);
9852 if (i
< num_dump_sects
)
9853 warn (_("Some sections were not dumped because they do not exist!\n"));
9859 process_mips_fpe_exception (int mask
)
9864 if (mask
& OEX_FPU_INEX
)
9865 fputs ("INEX", stdout
), first
= 0;
9866 if (mask
& OEX_FPU_UFLO
)
9867 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9868 if (mask
& OEX_FPU_OFLO
)
9869 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9870 if (mask
& OEX_FPU_DIV0
)
9871 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9872 if (mask
& OEX_FPU_INVAL
)
9873 printf ("%sINVAL", first
? "" : "|");
9876 fputs ("0", stdout
);
9880 process_mips_specific (FILE *file
)
9882 Elf_Internal_Dyn
*entry
;
9883 size_t liblist_offset
= 0;
9884 size_t liblistno
= 0;
9885 size_t conflictsno
= 0;
9886 size_t options_offset
= 0;
9887 size_t conflicts_offset
= 0;
9889 /* We have a lot of special sections. Thanks SGI! */
9890 if (dynamic_section
== NULL
)
9891 /* No information available. */
9894 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9895 switch (entry
->d_tag
)
9897 case DT_MIPS_LIBLIST
:
9899 = offset_from_vma (file
, entry
->d_un
.d_val
,
9900 liblistno
* sizeof (Elf32_External_Lib
));
9902 case DT_MIPS_LIBLISTNO
:
9903 liblistno
= entry
->d_un
.d_val
;
9905 case DT_MIPS_OPTIONS
:
9906 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9908 case DT_MIPS_CONFLICT
:
9910 = offset_from_vma (file
, entry
->d_un
.d_val
,
9911 conflictsno
* sizeof (Elf32_External_Conflict
));
9913 case DT_MIPS_CONFLICTNO
:
9914 conflictsno
= entry
->d_un
.d_val
;
9920 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9922 Elf32_External_Lib
*elib
;
9925 elib
= get_data (NULL
, file
, liblist_offset
,
9926 liblistno
* sizeof (Elf32_External_Lib
),
9930 printf ("\nSection '.liblist' contains %lu entries:\n",
9931 (unsigned long) liblistno
);
9932 fputs (" Library Time Stamp Checksum Version Flags\n",
9935 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9942 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9943 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9944 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9945 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9946 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9948 tmp
= gmtime (&time
);
9949 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9950 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9951 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9953 printf ("%3lu: ", (unsigned long) cnt
);
9954 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9955 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9958 if (liblist
.l_flags
== 0)
9969 { " EXACT_MATCH", LL_EXACT_MATCH
},
9970 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9971 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9972 { " EXPORTS", LL_EXPORTS
},
9973 { " DELAY_LOAD", LL_DELAY_LOAD
},
9974 { " DELTA", LL_DELTA
}
9976 int flags
= liblist
.l_flags
;
9980 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9982 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9984 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9985 flags
^= l_flags_vals
[fcnt
].bit
;
9988 printf (" %#x", (unsigned int) flags
);
9998 if (options_offset
!= 0)
10000 Elf_External_Options
*eopt
;
10001 Elf_Internal_Shdr
*sect
= section_headers
;
10002 Elf_Internal_Options
*iopt
;
10003 Elf_Internal_Options
*option
;
10007 /* Find the section header so that we get the size. */
10008 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
10011 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
10015 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
10018 error (_("Out of memory"));
10025 while (offset
< sect
->sh_size
)
10027 Elf_External_Options
*eoption
;
10029 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
10031 option
->kind
= BYTE_GET (eoption
->kind
);
10032 option
->size
= BYTE_GET (eoption
->size
);
10033 option
->section
= BYTE_GET (eoption
->section
);
10034 option
->info
= BYTE_GET (eoption
->info
);
10036 offset
+= option
->size
;
10042 printf (_("\nSection '%s' contains %d entries:\n"),
10043 SECTION_NAME (sect
), cnt
);
10051 switch (option
->kind
)
10054 /* This shouldn't happen. */
10055 printf (" NULL %d %lx", option
->section
, option
->info
);
10058 printf (" REGINFO ");
10059 if (elf_header
.e_machine
== EM_MIPS
)
10062 Elf32_External_RegInfo
*ereg
;
10063 Elf32_RegInfo reginfo
;
10065 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10066 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10067 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10068 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10069 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10070 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10071 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10073 printf ("GPR %08lx GP 0x%lx\n",
10074 reginfo
.ri_gprmask
,
10075 (unsigned long) reginfo
.ri_gp_value
);
10076 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10077 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10078 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10083 Elf64_External_RegInfo
*ereg
;
10084 Elf64_Internal_RegInfo reginfo
;
10086 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10087 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10088 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10089 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10090 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10091 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10092 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
10094 printf ("GPR %08lx GP 0x",
10095 reginfo
.ri_gprmask
);
10096 printf_vma (reginfo
.ri_gp_value
);
10099 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10100 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10101 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10105 case ODK_EXCEPTIONS
:
10106 fputs (" EXCEPTIONS fpe_min(", stdout
);
10107 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10108 fputs (") fpe_max(", stdout
);
10109 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10110 fputs (")", stdout
);
10112 if (option
->info
& OEX_PAGE0
)
10113 fputs (" PAGE0", stdout
);
10114 if (option
->info
& OEX_SMM
)
10115 fputs (" SMM", stdout
);
10116 if (option
->info
& OEX_FPDBUG
)
10117 fputs (" FPDBUG", stdout
);
10118 if (option
->info
& OEX_DISMISS
)
10119 fputs (" DISMISS", stdout
);
10122 fputs (" PAD ", stdout
);
10123 if (option
->info
& OPAD_PREFIX
)
10124 fputs (" PREFIX", stdout
);
10125 if (option
->info
& OPAD_POSTFIX
)
10126 fputs (" POSTFIX", stdout
);
10127 if (option
->info
& OPAD_SYMBOL
)
10128 fputs (" SYMBOL", stdout
);
10131 fputs (" HWPATCH ", stdout
);
10132 if (option
->info
& OHW_R4KEOP
)
10133 fputs (" R4KEOP", stdout
);
10134 if (option
->info
& OHW_R8KPFETCH
)
10135 fputs (" R8KPFETCH", stdout
);
10136 if (option
->info
& OHW_R5KEOP
)
10137 fputs (" R5KEOP", stdout
);
10138 if (option
->info
& OHW_R5KCVTL
)
10139 fputs (" R5KCVTL", stdout
);
10142 fputs (" FILL ", stdout
);
10143 /* XXX Print content of info word? */
10146 fputs (" TAGS ", stdout
);
10147 /* XXX Print content of info word? */
10150 fputs (" HWAND ", stdout
);
10151 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10152 fputs (" R4KEOP_CHECKED", stdout
);
10153 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10154 fputs (" R4KEOP_CLEAN", stdout
);
10157 fputs (" HWOR ", stdout
);
10158 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10159 fputs (" R4KEOP_CHECKED", stdout
);
10160 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10161 fputs (" R4KEOP_CLEAN", stdout
);
10164 printf (" GP_GROUP %#06lx self-contained %#06lx",
10165 option
->info
& OGP_GROUP
,
10166 (option
->info
& OGP_SELF
) >> 16);
10169 printf (" IDENT %#06lx self-contained %#06lx",
10170 option
->info
& OGP_GROUP
,
10171 (option
->info
& OGP_SELF
) >> 16);
10174 /* This shouldn't happen. */
10175 printf (" %3d ??? %d %lx",
10176 option
->kind
, option
->section
, option
->info
);
10180 len
= sizeof (*eopt
);
10181 while (len
< option
->size
)
10182 if (((char *) option
)[len
] >= ' '
10183 && ((char *) option
)[len
] < 0x7f)
10184 printf ("%c", ((char *) option
)[len
++]);
10186 printf ("\\%03o", ((char *) option
)[len
++]);
10188 fputs ("\n", stdout
);
10196 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10198 Elf32_Conflict
*iconf
;
10201 if (dynamic_symbols
== NULL
)
10203 error (_("conflict list found without a dynamic symbol table"));
10207 iconf
= malloc (conflictsno
* sizeof (*iconf
));
10210 error (_("Out of memory"));
10216 Elf32_External_Conflict
*econf32
;
10218 econf32
= get_data (NULL
, file
, conflicts_offset
,
10219 conflictsno
* sizeof (*econf32
), _("conflict"));
10223 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10224 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10230 Elf64_External_Conflict
*econf64
;
10232 econf64
= get_data (NULL
, file
, conflicts_offset
,
10233 conflictsno
* sizeof (*econf64
), _("conflict"));
10237 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10238 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10243 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10244 (unsigned long) conflictsno
);
10245 puts (_(" Num: Index Value Name"));
10247 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10249 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
10251 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10252 print_vma (psym
->st_value
, FULL_HEX
);
10254 print_symbol (25, dynamic_strings
+ psym
->st_name
);
10265 process_gnu_liblist (FILE *file
)
10267 Elf_Internal_Shdr
*section
, *string_sec
;
10268 Elf32_External_Lib
*elib
;
10276 for (i
= 0, section
= section_headers
;
10277 i
< elf_header
.e_shnum
;
10280 switch (section
->sh_type
)
10282 case SHT_GNU_LIBLIST
:
10283 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
10288 string_sec
= SECTION_HEADER (section
->sh_link
);
10290 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
10291 string_sec
->sh_size
, _("liblist string table"));
10294 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10300 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10301 SECTION_NAME (section
),
10302 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10304 puts (" Library Time Stamp Checksum Version Flags");
10306 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10314 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10315 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10316 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10317 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10318 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10320 tmp
= gmtime (&time
);
10321 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10322 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10323 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10325 printf ("%3lu: ", (unsigned long) cnt
);
10327 printf ("%-20s", strtab
+ liblist
.l_name
);
10329 printf ("%-20.20s", strtab
+ liblist
.l_name
);
10330 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10331 liblist
.l_version
, liblist
.l_flags
);
10341 static const char *
10342 get_note_type (unsigned e_type
)
10344 static char buff
[64];
10348 case NT_AUXV
: return _("NT_AUXV (auxiliary vector)");
10349 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
10350 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
10351 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
10352 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
10353 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
10354 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
10355 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
10356 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
10357 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
10358 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
10359 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10361 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10366 static const char *
10367 get_netbsd_elfcore_note_type (unsigned e_type
)
10369 static char buff
[64];
10371 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10373 /* NetBSD core "procinfo" structure. */
10374 return _("NetBSD procinfo structure");
10377 /* As of Jan 2002 there are no other machine-independent notes
10378 defined for NetBSD core files. If the note type is less
10379 than the start of the machine-dependent note types, we don't
10382 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10384 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10388 switch (elf_header
.e_machine
)
10390 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10391 and PT_GETFPREGS == mach+2. */
10396 case EM_SPARC32PLUS
:
10400 case NT_NETBSDCORE_FIRSTMACH
+0:
10401 return _("PT_GETREGS (reg structure)");
10402 case NT_NETBSDCORE_FIRSTMACH
+2:
10403 return _("PT_GETFPREGS (fpreg structure)");
10409 /* On all other arch's, PT_GETREGS == mach+1 and
10410 PT_GETFPREGS == mach+3. */
10414 case NT_NETBSDCORE_FIRSTMACH
+1:
10415 return _("PT_GETREGS (reg structure)");
10416 case NT_NETBSDCORE_FIRSTMACH
+3:
10417 return _("PT_GETFPREGS (fpreg structure)");
10423 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
10427 /* Note that by the ELF standard, the name field is already null byte
10428 terminated, and namesz includes the terminating null byte.
10429 I.E. the value of namesz for the name "FSF" is 4.
10431 If the value of namesz is zero, there is no name present. */
10433 process_note (Elf_Internal_Note
*pnote
)
10437 if (pnote
->namesz
== 0)
10439 /* If there is no note name, then use the default set of
10440 note type strings. */
10441 nt
= get_note_type (pnote
->type
);
10443 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
10445 /* NetBSD-specific core file notes. */
10446 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10450 /* Don't recognize this note name; just use the default set of
10451 note type strings. */
10452 nt
= get_note_type (pnote
->type
);
10455 printf (" %s\t\t0x%08lx\t%s\n",
10456 pnote
->namesz
? pnote
->namedata
: "(NONE)",
10457 pnote
->descsz
, nt
);
10463 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10465 Elf_External_Note
*pnotes
;
10466 Elf_External_Note
*external
;
10472 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
10478 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10479 (unsigned long) offset
, (unsigned long) length
);
10480 printf (_(" Owner\t\tData size\tDescription\n"));
10482 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10484 Elf_External_Note
*next
;
10485 Elf_Internal_Note inote
;
10488 inote
.type
= BYTE_GET (external
->type
);
10489 inote
.namesz
= BYTE_GET (external
->namesz
);
10490 inote
.namedata
= external
->name
;
10491 inote
.descsz
= BYTE_GET (external
->descsz
);
10492 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10493 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10495 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10497 if (((char *) next
) > (((char *) pnotes
) + length
))
10499 warn (_("corrupt note found at offset %x into core notes\n"),
10500 ((char *) external
) - ((char *) pnotes
));
10501 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10502 inote
.type
, inote
.namesz
, inote
.descsz
);
10508 /* Verify that name is null terminated. It appears that at least
10509 one version of Linux (RedHat 6.0) generates corefiles that don't
10510 comply with the ELF spec by failing to include the null byte in
10512 if (inote
.namedata
[inote
.namesz
] != '\0')
10514 temp
= malloc (inote
.namesz
+ 1);
10518 error (_("Out of memory\n"));
10523 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10524 temp
[inote
.namesz
] = 0;
10526 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10527 inote
.namedata
= temp
;
10530 res
&= process_note (& inote
);
10545 process_corefile_note_segments (FILE *file
)
10547 Elf_Internal_Phdr
*segment
;
10551 if (! get_program_headers (file
))
10554 for (i
= 0, segment
= program_headers
;
10555 i
< elf_header
.e_phnum
;
10558 if (segment
->p_type
== PT_NOTE
)
10559 res
&= process_corefile_note_segment (file
,
10560 (bfd_vma
) segment
->p_offset
,
10561 (bfd_vma
) segment
->p_filesz
);
10568 process_corefile_contents (FILE *file
)
10570 /* If we have not been asked to display the notes then do nothing. */
10574 /* If file is not a core file then exit. */
10575 if (elf_header
.e_type
!= ET_CORE
)
10578 /* No program headers means no NOTE segment. */
10579 if (elf_header
.e_phnum
== 0)
10581 printf (_("No note segments present in the core file.\n"));
10585 return process_corefile_note_segments (file
);
10589 process_arch_specific (FILE *file
)
10594 switch (elf_header
.e_machine
)
10597 case EM_MIPS_RS3_LE
:
10598 return process_mips_specific (file
);
10607 get_file_header (FILE *file
)
10609 /* Read in the identity array. */
10610 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10613 /* Determine how to read the rest of the header. */
10614 switch (elf_header
.e_ident
[EI_DATA
])
10616 default: /* fall through */
10617 case ELFDATANONE
: /* fall through */
10619 byte_get
= byte_get_little_endian
;
10620 byte_put
= byte_put_little_endian
;
10623 byte_get
= byte_get_big_endian
;
10624 byte_put
= byte_put_big_endian
;
10628 /* For now we only support 32 bit and 64 bit ELF files. */
10629 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10631 /* Read in the rest of the header. */
10634 Elf32_External_Ehdr ehdr32
;
10636 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10639 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10640 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10641 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10642 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10643 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10644 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10645 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10646 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10647 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10648 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10649 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10650 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10651 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10655 Elf64_External_Ehdr ehdr64
;
10657 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10658 we will not be able to cope with the 64bit data found in
10659 64 ELF files. Detect this now and abort before we start
10660 overwriting things. */
10661 if (sizeof (bfd_vma
) < 8)
10663 error (_("This instance of readelf has been built without support for a\n\
10664 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10668 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10671 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10672 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10673 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10674 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10675 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10676 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10677 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10678 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10679 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10680 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10681 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10682 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10683 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10686 if (elf_header
.e_shoff
)
10688 /* There may be some extensions in the first section header. Don't
10689 bomb if we can't read it. */
10691 get_32bit_section_headers (file
, 1);
10693 get_64bit_section_headers (file
, 1);
10699 /* Process one ELF object file according to the command line options.
10700 This file may actually be stored in an archive. The file is
10701 positioned at the start of the ELF object. */
10704 process_object (char *file_name
, FILE *file
)
10708 if (! get_file_header (file
))
10710 error (_("%s: Failed to read file header\n"), file_name
);
10714 /* Initialise per file variables. */
10715 for (i
= NUM_ELEM (version_info
); i
--;)
10716 version_info
[i
] = 0;
10718 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10719 dynamic_info
[i
] = 0;
10721 /* Process the file. */
10723 printf (_("\nFile: %s\n"), file_name
);
10725 if (! process_file_header ())
10728 if (! process_section_headers (file
)
10729 || ! process_section_groups (file
))
10731 /* Without loaded section headers and section groups we
10732 cannot process lots of things. */
10733 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10735 if (! do_using_dynamic
)
10736 do_syms
= do_reloc
= 0;
10739 if (process_program_headers (file
))
10740 process_dynamic_section (file
);
10742 process_relocs (file
);
10744 process_unwind (file
);
10746 process_symbol_table (file
);
10748 process_syminfo (file
);
10750 process_version_sections (file
);
10752 process_section_contents (file
);
10754 process_corefile_contents (file
);
10756 process_gnu_liblist (file
);
10758 process_arch_specific (file
);
10760 if (program_headers
)
10762 free (program_headers
);
10763 program_headers
= NULL
;
10766 if (section_headers
)
10768 free (section_headers
);
10769 section_headers
= NULL
;
10774 free (string_table
);
10775 string_table
= NULL
;
10776 string_table_length
= 0;
10779 if (dynamic_strings
)
10781 free (dynamic_strings
);
10782 dynamic_strings
= NULL
;
10785 if (dynamic_symbols
)
10787 free (dynamic_symbols
);
10788 dynamic_symbols
= NULL
;
10789 num_dynamic_syms
= 0;
10792 if (dynamic_syminfo
)
10794 free (dynamic_syminfo
);
10795 dynamic_syminfo
= NULL
;
10798 if (section_headers_groups
)
10800 free (section_headers_groups
);
10801 section_headers_groups
= NULL
;
10804 if (section_groups
)
10806 struct group_list
*g
, *next
;
10808 for (i
= 0; i
< group_count
; i
++)
10810 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10817 free (section_groups
);
10818 section_groups
= NULL
;
10824 /* Process an ELF archive. The file is positioned just after the
10828 process_archive (char *file_name
, FILE *file
)
10830 struct ar_hdr arhdr
;
10832 unsigned long size
;
10833 char *longnames
= NULL
;
10834 unsigned long longnames_size
= 0;
10835 size_t file_name_size
;
10840 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10841 if (got
!= sizeof arhdr
)
10846 error (_("%s: failed to read archive header\n"), file_name
);
10850 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
10852 /* This is the archive symbol table. Skip it.
10853 FIXME: We should have an option to dump it. */
10854 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10855 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
10857 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10861 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10862 if (got
!= sizeof arhdr
)
10867 error (_("%s: failed to read archive header\n"), file_name
);
10872 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
10874 /* This is the archive string table holding long member
10877 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10879 longnames
= malloc (longnames_size
);
10880 if (longnames
== NULL
)
10882 error (_("Out of memory\n"));
10886 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10889 error(_("%s: failed to read string table\n"), file_name
);
10893 if ((longnames_size
& 1) != 0)
10896 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10897 if (got
!= sizeof arhdr
)
10904 error (_("%s: failed to read archive header\n"), file_name
);
10909 file_name_size
= strlen (file_name
);
10918 if (arhdr
.ar_name
[0] == '/')
10922 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10923 if (off
>= longnames_size
)
10925 error (_("%s: invalid archive string table offset %lu\n"), off
);
10930 name
= longnames
+ off
;
10931 nameend
= memchr (name
, '/', longnames_size
- off
);
10935 name
= arhdr
.ar_name
;
10936 nameend
= memchr (name
, '/', 16);
10939 if (nameend
== NULL
)
10941 error (_("%s: bad archive file name\n"));
10946 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10947 if (namealc
== NULL
)
10949 error (_("Out of memory\n"));
10954 memcpy (namealc
, file_name
, file_name_size
);
10955 namealc
[file_name_size
] = '(';
10956 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10957 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10958 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10960 archive_file_offset
= ftell (file
);
10961 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10963 ret
|= process_object (namealc
, file
);
10968 (archive_file_offset
10969 + archive_file_size
10970 + (archive_file_size
& 1)),
10973 error (_("%s: failed to seek to next archive header\n"), file_name
);
10978 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10979 if (got
!= sizeof arhdr
)
10984 error (_("%s: failed to read archive header\n"), file_name
);
10990 if (longnames
!= 0)
10997 process_file (char *file_name
)
11000 struct stat statbuf
;
11001 char armag
[SARMAG
];
11004 if (stat (file_name
, &statbuf
) < 0)
11006 if (errno
== ENOENT
)
11007 error (_("'%s': No such file\n"), file_name
);
11009 error (_("Could not locate '%s'. System error message: %s\n"),
11010 file_name
, strerror (errno
));
11014 if (! S_ISREG (statbuf
.st_mode
))
11016 error (_("'%s' is not an ordinary file\n"), file_name
);
11020 file
= fopen (file_name
, "rb");
11023 error (_("Input file '%s' is not readable.\n"), file_name
);
11027 if (fread (armag
, SARMAG
, 1, file
) != 1)
11029 error (_("%s: Failed to read file header\n"), file_name
);
11034 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
11035 ret
= process_archive (file_name
, file
);
11039 archive_file_size
= archive_file_offset
= 0;
11040 ret
= process_object (file_name
, file
);
11048 #ifdef SUPPORT_DISASSEMBLY
11049 /* Needed by the i386 disassembler. For extra credit, someone could
11050 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11054 print_address (unsigned int addr
, FILE *outfile
)
11056 fprintf (outfile
,"0x%8.8x", addr
);
11059 /* Needed by the i386 disassembler. */
11061 db_task_printsym (unsigned int addr
)
11063 print_address (addr
, stderr
);
11068 main (int argc
, char **argv
)
11071 char *cmdline_dump_sects
= NULL
;
11072 unsigned num_cmdline_dump_sects
= 0;
11074 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11075 setlocale (LC_MESSAGES
, "");
11077 #if defined (HAVE_SETLOCALE)
11078 setlocale (LC_CTYPE
, "");
11080 bindtextdomain (PACKAGE
, LOCALEDIR
);
11081 textdomain (PACKAGE
);
11083 parse_args (argc
, argv
);
11085 if (optind
< (argc
- 1))
11088 /* When processing more than one file remember the dump requests
11089 issued on command line to reset them after each file. */
11090 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
11092 cmdline_dump_sects
= malloc (num_dump_sects
);
11093 if (cmdline_dump_sects
== NULL
)
11094 error (_("Out of memory allocating dump request table."));
11097 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
11098 num_cmdline_dump_sects
= num_dump_sects
;
11103 while (optind
< argc
)
11105 err
|= process_file (argv
[optind
++]);
11107 /* Reset dump requests. */
11108 if (optind
< argc
&& dump_sects
!= NULL
)
11110 num_dump_sects
= num_cmdline_dump_sects
;
11111 if (num_cmdline_dump_sects
> 0)
11112 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11116 if (dump_sects
!= NULL
)
11118 if (cmdline_dump_sects
!= NULL
)
11119 free (cmdline_dump_sects
);