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");
1774 /* Process flags one bit at a time. */
1775 flag
= e_flags
& - e_flags
;
1781 strcat (buf
, ", BE8");
1785 strcat (buf
, ", LE8");
1795 case EF_ARM_EABI_UNKNOWN
:
1796 strcat (buf
, ", GNU EABI");
1801 /* Process flags one bit at a time. */
1802 flag
= e_flags
& - e_flags
;
1807 case EF_ARM_INTERWORK
:
1808 strcat (buf
, ", interworking enabled");
1811 case EF_ARM_APCS_26
:
1812 strcat (buf
, ", uses APCS/26");
1815 case EF_ARM_APCS_FLOAT
:
1816 strcat (buf
, ", uses APCS/float");
1820 strcat (buf
, ", position independent");
1824 strcat (buf
, ", 8 bit structure alignment");
1827 case EF_ARM_NEW_ABI
:
1828 strcat (buf
, ", uses new ABI");
1831 case EF_ARM_OLD_ABI
:
1832 strcat (buf
, ", uses old ABI");
1835 case EF_ARM_SOFT_FLOAT
:
1836 strcat (buf
, ", software FP");
1839 case EF_ARM_VFP_FLOAT
:
1840 strcat (buf
, ", VFP");
1843 case EF_ARM_MAVERICK_FLOAT
:
1844 strcat (buf
, ", Maverick FP");
1855 strcat (buf
,", <unknown>");
1859 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
1861 static char buf
[1024];
1873 decode_ARM_machine_flags (e_flags
, buf
);
1877 switch (e_flags
& EF_FRV_CPU_MASK
)
1879 case EF_FRV_CPU_GENERIC
:
1883 strcat (buf
, ", fr???");
1886 case EF_FRV_CPU_FR300
:
1887 strcat (buf
, ", fr300");
1890 case EF_FRV_CPU_FR400
:
1891 strcat (buf
, ", fr400");
1893 case EF_FRV_CPU_FR405
:
1894 strcat (buf
, ", fr405");
1897 case EF_FRV_CPU_FR450
:
1898 strcat (buf
, ", fr450");
1901 case EF_FRV_CPU_FR500
:
1902 strcat (buf
, ", fr500");
1904 case EF_FRV_CPU_FR550
:
1905 strcat (buf
, ", fr550");
1908 case EF_FRV_CPU_SIMPLE
:
1909 strcat (buf
, ", simple");
1911 case EF_FRV_CPU_TOMCAT
:
1912 strcat (buf
, ", tomcat");
1917 if (e_flags
& EF_CPU32
)
1918 strcat (buf
, ", cpu32");
1919 if (e_flags
& EF_M68000
)
1920 strcat (buf
, ", m68000");
1924 if (e_flags
& EF_PPC_EMB
)
1925 strcat (buf
, ", emb");
1927 if (e_flags
& EF_PPC_RELOCATABLE
)
1928 strcat (buf
, ", relocatable");
1930 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1931 strcat (buf
, ", relocatable-lib");
1935 case EM_CYGNUS_V850
:
1936 switch (e_flags
& EF_V850_ARCH
)
1939 strcat (buf
, ", v850e1");
1942 strcat (buf
, ", v850e");
1945 strcat (buf
, ", v850");
1948 strcat (buf
, ", unknown v850 architecture variant");
1954 case EM_CYGNUS_M32R
:
1955 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1956 strcat (buf
, ", m32r");
1961 case EM_MIPS_RS3_LE
:
1962 if (e_flags
& EF_MIPS_NOREORDER
)
1963 strcat (buf
, ", noreorder");
1965 if (e_flags
& EF_MIPS_PIC
)
1966 strcat (buf
, ", pic");
1968 if (e_flags
& EF_MIPS_CPIC
)
1969 strcat (buf
, ", cpic");
1971 if (e_flags
& EF_MIPS_UCODE
)
1972 strcat (buf
, ", ugen_reserved");
1974 if (e_flags
& EF_MIPS_ABI2
)
1975 strcat (buf
, ", abi2");
1977 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
1978 strcat (buf
, ", odk first");
1980 if (e_flags
& EF_MIPS_32BITMODE
)
1981 strcat (buf
, ", 32bitmode");
1983 switch ((e_flags
& EF_MIPS_MACH
))
1985 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1986 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1987 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1988 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1989 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
1990 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1991 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
1992 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
1993 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1995 /* We simply ignore the field in this case to avoid confusion:
1996 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
1999 default: strcat (buf
, ", unknown CPU"); break;
2002 switch ((e_flags
& EF_MIPS_ABI
))
2004 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2005 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2006 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2007 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2009 /* We simply ignore the field in this case to avoid confusion:
2010 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2011 This means it is likely to be an o32 file, but not for
2014 default: strcat (buf
, ", unknown ABI"); break;
2017 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2018 strcat (buf
, ", mdmx");
2020 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2021 strcat (buf
, ", mips16");
2023 switch ((e_flags
& EF_MIPS_ARCH
))
2025 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2026 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2027 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2028 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2029 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2030 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2031 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2032 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2033 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2034 default: strcat (buf
, ", unknown ISA"); break;
2040 switch ((e_flags
& EF_SH_MACH_MASK
))
2042 case EF_SH1
: strcat (buf
, ", sh1"); break;
2043 case EF_SH2
: strcat (buf
, ", sh2"); break;
2044 case EF_SH3
: strcat (buf
, ", sh3"); break;
2045 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2046 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2047 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2048 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2049 case EF_SH4
: strcat (buf
, ", sh4"); break;
2050 case EF_SH5
: strcat (buf
, ", sh5"); break;
2051 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2052 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2053 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2054 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2055 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2056 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2057 default: strcat (buf
, ", unknown ISA"); break;
2063 if (e_flags
& EF_SPARC_32PLUS
)
2064 strcat (buf
, ", v8+");
2066 if (e_flags
& EF_SPARC_SUN_US1
)
2067 strcat (buf
, ", ultrasparcI");
2069 if (e_flags
& EF_SPARC_SUN_US3
)
2070 strcat (buf
, ", ultrasparcIII");
2072 if (e_flags
& EF_SPARC_HAL_R1
)
2073 strcat (buf
, ", halr1");
2075 if (e_flags
& EF_SPARC_LEDATA
)
2076 strcat (buf
, ", ledata");
2078 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2079 strcat (buf
, ", tso");
2081 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2082 strcat (buf
, ", pso");
2084 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2085 strcat (buf
, ", rmo");
2089 switch (e_flags
& EF_PARISC_ARCH
)
2091 case EFA_PARISC_1_0
:
2092 strcpy (buf
, ", PA-RISC 1.0");
2094 case EFA_PARISC_1_1
:
2095 strcpy (buf
, ", PA-RISC 1.1");
2097 case EFA_PARISC_2_0
:
2098 strcpy (buf
, ", PA-RISC 2.0");
2103 if (e_flags
& EF_PARISC_TRAPNIL
)
2104 strcat (buf
, ", trapnil");
2105 if (e_flags
& EF_PARISC_EXT
)
2106 strcat (buf
, ", ext");
2107 if (e_flags
& EF_PARISC_LSB
)
2108 strcat (buf
, ", lsb");
2109 if (e_flags
& EF_PARISC_WIDE
)
2110 strcat (buf
, ", wide");
2111 if (e_flags
& EF_PARISC_NO_KABP
)
2112 strcat (buf
, ", no kabp");
2113 if (e_flags
& EF_PARISC_LAZYSWAP
)
2114 strcat (buf
, ", lazyswap");
2119 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2120 strcat (buf
, ", new calling convention");
2122 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2123 strcat (buf
, ", gnu calling convention");
2127 if ((e_flags
& EF_IA_64_ABI64
))
2128 strcat (buf
, ", 64-bit");
2130 strcat (buf
, ", 32-bit");
2131 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2132 strcat (buf
, ", reduced fp model");
2133 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2134 strcat (buf
, ", no function descriptors, constant gp");
2135 else if ((e_flags
& EF_IA_64_CONS_GP
))
2136 strcat (buf
, ", constant gp");
2137 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2138 strcat (buf
, ", absolute");
2142 if ((e_flags
& EF_VAX_NONPIC
))
2143 strcat (buf
, ", non-PIC");
2144 if ((e_flags
& EF_VAX_DFLOAT
))
2145 strcat (buf
, ", D-Float");
2146 if ((e_flags
& EF_VAX_GFLOAT
))
2147 strcat (buf
, ", G-Float");
2156 get_osabi_name (unsigned int osabi
)
2158 static char buff
[32];
2162 case ELFOSABI_NONE
: return "UNIX - System V";
2163 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2164 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2165 case ELFOSABI_LINUX
: return "UNIX - Linux";
2166 case ELFOSABI_HURD
: return "GNU/Hurd";
2167 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2168 case ELFOSABI_AIX
: return "UNIX - AIX";
2169 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2170 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2171 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2172 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2173 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2174 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2175 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2176 case ELFOSABI_AROS
: return "Amiga Research OS";
2177 case ELFOSABI_STANDALONE
: return _("Standalone App");
2178 case ELFOSABI_ARM
: return "ARM";
2180 sprintf (buff
, _("<unknown: %x>"), osabi
);
2186 get_mips_segment_type (unsigned long type
)
2190 case PT_MIPS_REGINFO
:
2192 case PT_MIPS_RTPROC
:
2194 case PT_MIPS_OPTIONS
:
2204 get_parisc_segment_type (unsigned long type
)
2208 case PT_HP_TLS
: return "HP_TLS";
2209 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2210 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2211 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2212 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2213 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2214 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2215 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2216 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2217 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2218 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2219 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2220 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2221 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2230 get_ia64_segment_type (unsigned long type
)
2234 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2235 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2236 case PT_HP_TLS
: return "HP_TLS";
2237 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2238 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2239 case PT_IA_64_HP_STACK
: return "HP_STACK";
2248 get_segment_type (unsigned long p_type
)
2250 static char buff
[32];
2254 case PT_NULL
: return "NULL";
2255 case PT_LOAD
: return "LOAD";
2256 case PT_DYNAMIC
: return "DYNAMIC";
2257 case PT_INTERP
: return "INTERP";
2258 case PT_NOTE
: return "NOTE";
2259 case PT_SHLIB
: return "SHLIB";
2260 case PT_PHDR
: return "PHDR";
2261 case PT_TLS
: return "TLS";
2263 case PT_GNU_EH_FRAME
:
2264 return "GNU_EH_FRAME";
2265 case PT_GNU_STACK
: return "GNU_STACK";
2266 case PT_GNU_RELRO
: return "GNU_RELRO";
2269 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2273 switch (elf_header
.e_machine
)
2276 case EM_MIPS_RS3_LE
:
2277 result
= get_mips_segment_type (p_type
);
2280 result
= get_parisc_segment_type (p_type
);
2283 result
= get_ia64_segment_type (p_type
);
2293 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2295 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2299 switch (elf_header
.e_machine
)
2302 result
= get_parisc_segment_type (p_type
);
2305 result
= get_ia64_segment_type (p_type
);
2315 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2318 sprintf (buff
, _("<unknown>: %lx"), p_type
);
2325 get_mips_section_type_name (unsigned int sh_type
)
2329 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2330 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2331 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2332 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2333 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2334 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2335 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2336 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2337 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2338 case SHT_MIPS_RELD
: return "MIPS_RELD";
2339 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2340 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2341 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2342 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2343 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2344 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2345 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2346 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2347 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2348 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2349 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2350 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2351 case SHT_MIPS_LINE
: return "MIPS_LINE";
2352 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2353 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2354 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2355 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2356 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2357 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2358 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2359 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2360 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2361 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2362 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2363 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2364 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2365 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2366 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2367 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2375 get_parisc_section_type_name (unsigned int sh_type
)
2379 case SHT_PARISC_EXT
: return "PARISC_EXT";
2380 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2381 case SHT_PARISC_DOC
: return "PARISC_DOC";
2389 get_ia64_section_type_name (unsigned int sh_type
)
2391 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2392 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2393 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2397 case SHT_IA_64_EXT
: return "IA_64_EXT";
2398 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2399 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2407 get_section_type_name (unsigned int sh_type
)
2409 static char buff
[32];
2413 case SHT_NULL
: return "NULL";
2414 case SHT_PROGBITS
: return "PROGBITS";
2415 case SHT_SYMTAB
: return "SYMTAB";
2416 case SHT_STRTAB
: return "STRTAB";
2417 case SHT_RELA
: return "RELA";
2418 case SHT_HASH
: return "HASH";
2419 case SHT_DYNAMIC
: return "DYNAMIC";
2420 case SHT_NOTE
: return "NOTE";
2421 case SHT_NOBITS
: return "NOBITS";
2422 case SHT_REL
: return "REL";
2423 case SHT_SHLIB
: return "SHLIB";
2424 case SHT_DYNSYM
: return "DYNSYM";
2425 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2426 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2427 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2428 case SHT_GROUP
: return "GROUP";
2429 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2430 case SHT_GNU_verdef
: return "VERDEF";
2431 case SHT_GNU_verneed
: return "VERNEED";
2432 case SHT_GNU_versym
: return "VERSYM";
2433 case 0x6ffffff0: return "VERSYM";
2434 case 0x6ffffffc: return "VERDEF";
2435 case 0x7ffffffd: return "AUXILIARY";
2436 case 0x7fffffff: return "FILTER";
2437 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2440 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2444 switch (elf_header
.e_machine
)
2447 case EM_MIPS_RS3_LE
:
2448 result
= get_mips_section_type_name (sh_type
);
2451 result
= get_parisc_section_type_name (sh_type
);
2454 result
= get_ia64_section_type_name (sh_type
);
2464 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2466 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2467 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2468 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2469 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2471 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2477 #define OPTION_DEBUG_DUMP 512
2479 struct option options
[] =
2481 {"all", no_argument
, 0, 'a'},
2482 {"file-header", no_argument
, 0, 'h'},
2483 {"program-headers", no_argument
, 0, 'l'},
2484 {"headers", no_argument
, 0, 'e'},
2485 {"histogram", no_argument
, 0, 'I'},
2486 {"segments", no_argument
, 0, 'l'},
2487 {"sections", no_argument
, 0, 'S'},
2488 {"section-headers", no_argument
, 0, 'S'},
2489 {"section-groups", no_argument
, 0, 'g'},
2490 {"symbols", no_argument
, 0, 's'},
2491 {"syms", no_argument
, 0, 's'},
2492 {"relocs", no_argument
, 0, 'r'},
2493 {"notes", no_argument
, 0, 'n'},
2494 {"dynamic", no_argument
, 0, 'd'},
2495 {"arch-specific", no_argument
, 0, 'A'},
2496 {"version-info", no_argument
, 0, 'V'},
2497 {"use-dynamic", no_argument
, 0, 'D'},
2498 {"hex-dump", required_argument
, 0, 'x'},
2499 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2500 {"unwind", no_argument
, 0, 'u'},
2501 #ifdef SUPPORT_DISASSEMBLY
2502 {"instruction-dump", required_argument
, 0, 'i'},
2505 {"version", no_argument
, 0, 'v'},
2506 {"wide", no_argument
, 0, 'W'},
2507 {"help", no_argument
, 0, 'H'},
2508 {0, no_argument
, 0, 0}
2514 fprintf (stdout
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2515 fprintf (stdout
, _(" Display information about the contents of ELF format files\n"));
2516 fprintf (stdout
, _(" Options are:\n\
2517 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2518 -h --file-header Display the ELF file header\n\
2519 -l --program-headers Display the program headers\n\
2520 --segments An alias for --program-headers\n\
2521 -S --section-headers Display the sections' header\n\
2522 --sections An alias for --section-headers\n\
2523 -g --section-groups Display the section groups\n\
2524 -e --headers Equivalent to: -h -l -S\n\
2525 -s --syms Display the symbol table\n\
2526 --symbols An alias for --syms\n\
2527 -n --notes Display the core notes (if present)\n\
2528 -r --relocs Display the relocations (if present)\n\
2529 -u --unwind Display the unwind info (if present)\n\
2530 -d --dynamic Display the dynamic section (if present)\n\
2531 -V --version-info Display the version sections (if present)\n\
2532 -A --arch-specific Display architecture specific information (if any).\n\
2533 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2534 -x --hex-dump=<number> Dump the contents of section <number>\n\
2535 -w[liaprmfFso] or\n\
2536 --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames,=str,=loc]\n\
2537 Display the contents of DWARF2 debug sections\n"));
2538 #ifdef SUPPORT_DISASSEMBLY
2539 fprintf (stdout
, _("\
2540 -i --instruction-dump=<number>\n\
2541 Disassemble the contents of section <number>\n"));
2543 fprintf (stdout
, _("\
2544 -I --histogram Display histogram of bucket list lengths\n\
2545 -W --wide Allow output width to exceed 80 characters\n\
2546 -H --help Display this information\n\
2547 -v --version Display the version number of readelf\n"));
2548 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2554 request_dump (unsigned int section
, int type
)
2556 if (section
>= num_dump_sects
)
2558 char *new_dump_sects
;
2560 new_dump_sects
= calloc (section
+ 1, 1);
2562 if (new_dump_sects
== NULL
)
2563 error (_("Out of memory allocating dump request table."));
2566 /* Copy current flag settings. */
2567 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2571 dump_sects
= new_dump_sects
;
2572 num_dump_sects
= section
+ 1;
2577 dump_sects
[section
] |= type
;
2583 parse_args (int argc
, char **argv
)
2590 while ((c
= getopt_long
2591 (argc
, argv
, "ersuahnldSDAIgw::x:i:vVWH", options
, NULL
)) != EOF
)
2612 do_section_groups
++;
2620 do_section_groups
++;
2662 section
= strtoul (optarg
, & cp
, 0);
2663 if (! *cp
&& section
>= 0)
2665 request_dump (section
, HEX_DUMP
);
2675 unsigned int index
= 0;
2679 while (optarg
[index
])
2680 switch (optarg
[index
++])
2689 do_debug_abbrevs
= 1;
2699 do_debug_pubnames
= 1;
2704 do_debug_aranges
= 1;
2708 do_debug_frames_interp
= 1;
2710 do_debug_frames
= 1;
2715 do_debug_macinfo
= 1;
2729 warn (_("Unrecognized debug option '%s'\n"), optarg
);
2734 case OPTION_DEBUG_DUMP
:
2740 static const char *debug_dump_opt
[]
2741 = { "line", "info", "abbrev", "pubnames", "ranges",
2742 "macro", "frames", "frames-interp", "str", "loc", NULL
};
2751 for (index
= 0; debug_dump_opt
[index
]; index
++)
2753 size_t len
= strlen (debug_dump_opt
[index
]);
2755 if (strncmp (p
, debug_dump_opt
[index
], len
) == 0
2756 && (p
[len
] == ',' || p
[len
] == '\0'))
2765 do_debug_abbrevs
= 1;
2776 do_debug_pubnames
= 1;
2780 do_debug_aranges
= 1;
2785 do_debug_frames_interp
= 1;
2786 do_debug_frames
= 1;
2790 do_debug_macinfo
= 1;
2803 if (debug_dump_opt
[index
] == NULL
)
2805 warn (_("Unrecognized debug option '%s'\n"), p
);
2806 p
= strchr (p
, ',');
2816 #ifdef SUPPORT_DISASSEMBLY
2819 section
= strtoul (optarg
, & cp
, 0);
2820 if (! *cp
&& section
>= 0)
2822 request_dump (section
, DISASS_DUMP
);
2828 print_version (program_name
);
2838 /* xgettext:c-format */
2839 error (_("Invalid option '-%c'\n"), c
);
2846 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2847 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2848 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
2849 && !do_section_groups
)
2853 warn (_("Nothing to do.\n"));
2859 get_elf_class (unsigned int elf_class
)
2861 static char buff
[32];
2865 case ELFCLASSNONE
: return _("none");
2866 case ELFCLASS32
: return "ELF32";
2867 case ELFCLASS64
: return "ELF64";
2869 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2875 get_data_encoding (unsigned int encoding
)
2877 static char buff
[32];
2881 case ELFDATANONE
: return _("none");
2882 case ELFDATA2LSB
: return _("2's complement, little endian");
2883 case ELFDATA2MSB
: return _("2's complement, big endian");
2885 sprintf (buff
, _("<unknown: %x>"), encoding
);
2890 /* Decode the data held in 'elf_header'. */
2893 process_file_header (void)
2895 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2896 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2897 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2898 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2901 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2909 printf (_("ELF Header:\n"));
2910 printf (_(" Magic: "));
2911 for (i
= 0; i
< EI_NIDENT
; i
++)
2912 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2914 printf (_(" Class: %s\n"),
2915 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2916 printf (_(" Data: %s\n"),
2917 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2918 printf (_(" Version: %d %s\n"),
2919 elf_header
.e_ident
[EI_VERSION
],
2920 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2922 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2925 printf (_(" OS/ABI: %s\n"),
2926 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2927 printf (_(" ABI Version: %d\n"),
2928 elf_header
.e_ident
[EI_ABIVERSION
]);
2929 printf (_(" Type: %s\n"),
2930 get_file_type (elf_header
.e_type
));
2931 printf (_(" Machine: %s\n"),
2932 get_machine_name (elf_header
.e_machine
));
2933 printf (_(" Version: 0x%lx\n"),
2934 (unsigned long) elf_header
.e_version
);
2936 printf (_(" Entry point address: "));
2937 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2938 printf (_("\n Start of program headers: "));
2939 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2940 printf (_(" (bytes into file)\n Start of section headers: "));
2941 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2942 printf (_(" (bytes into file)\n"));
2944 printf (_(" Flags: 0x%lx%s\n"),
2945 (unsigned long) elf_header
.e_flags
,
2946 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2947 printf (_(" Size of this header: %ld (bytes)\n"),
2948 (long) elf_header
.e_ehsize
);
2949 printf (_(" Size of program headers: %ld (bytes)\n"),
2950 (long) elf_header
.e_phentsize
);
2951 printf (_(" Number of program headers: %ld\n"),
2952 (long) elf_header
.e_phnum
);
2953 printf (_(" Size of section headers: %ld (bytes)\n"),
2954 (long) elf_header
.e_shentsize
);
2955 printf (_(" Number of section headers: %ld"),
2956 (long) elf_header
.e_shnum
);
2957 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
2958 printf (" (%ld)", (long) section_headers
[0].sh_size
);
2959 putc ('\n', stdout
);
2960 printf (_(" Section header string table index: %ld"),
2961 (long) elf_header
.e_shstrndx
);
2962 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
2963 printf (" (%ld)", (long) section_headers
[0].sh_link
);
2964 putc ('\n', stdout
);
2967 if (section_headers
!= NULL
)
2969 if (elf_header
.e_shnum
== 0)
2970 elf_header
.e_shnum
= section_headers
[0].sh_size
;
2971 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
2972 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
2973 free (section_headers
);
2974 section_headers
= NULL
;
2982 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
2984 Elf32_External_Phdr
*phdrs
;
2985 Elf32_External_Phdr
*external
;
2986 Elf_Internal_Phdr
*internal
;
2989 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
2990 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2991 _("program headers"));
2995 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2996 i
< elf_header
.e_phnum
;
2997 i
++, internal
++, external
++)
2999 internal
->p_type
= BYTE_GET (external
->p_type
);
3000 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3001 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3002 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3003 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3004 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3005 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3006 internal
->p_align
= BYTE_GET (external
->p_align
);
3015 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3017 Elf64_External_Phdr
*phdrs
;
3018 Elf64_External_Phdr
*external
;
3019 Elf_Internal_Phdr
*internal
;
3022 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3023 elf_header
.e_phentsize
* elf_header
.e_phnum
,
3024 _("program headers"));
3028 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3029 i
< elf_header
.e_phnum
;
3030 i
++, internal
++, external
++)
3032 internal
->p_type
= BYTE_GET (external
->p_type
);
3033 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3034 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
3035 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
3036 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
3037 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
3038 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
3039 internal
->p_align
= BYTE_GET8 (external
->p_align
);
3047 /* Returns 1 if the program headers were read into `program_headers'. */
3050 get_program_headers (FILE *file
)
3052 Elf_Internal_Phdr
*phdrs
;
3054 /* Check cache of prior read. */
3055 if (program_headers
!= NULL
)
3058 phdrs
= malloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3062 error (_("Out of memory\n"));
3067 ? get_32bit_program_headers (file
, phdrs
)
3068 : get_64bit_program_headers (file
, phdrs
))
3070 program_headers
= phdrs
;
3078 /* Returns 1 if the program headers were loaded. */
3081 process_program_headers (FILE *file
)
3083 Elf_Internal_Phdr
*segment
;
3086 if (elf_header
.e_phnum
== 0)
3089 printf (_("\nThere are no program headers in this file.\n"));
3093 if (do_segments
&& !do_header
)
3095 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3096 printf (_("Entry point "));
3097 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3098 printf (_("\nThere are %d program headers, starting at offset "),
3099 elf_header
.e_phnum
);
3100 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3104 if (! get_program_headers (file
))
3109 if (elf_header
.e_phnum
> 1)
3110 printf (_("\nProgram Headers:\n"));
3112 printf (_("\nProgram Headers:\n"));
3116 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3119 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3123 (_(" Type Offset VirtAddr PhysAddr\n"));
3125 (_(" FileSiz MemSiz Flags Align\n"));
3132 for (i
= 0, segment
= program_headers
;
3133 i
< elf_header
.e_phnum
;
3138 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3142 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3143 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3144 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3145 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3146 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3148 (segment
->p_flags
& PF_R
? 'R' : ' '),
3149 (segment
->p_flags
& PF_W
? 'W' : ' '),
3150 (segment
->p_flags
& PF_X
? 'E' : ' '));
3151 printf ("%#lx", (unsigned long) segment
->p_align
);
3155 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3156 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3159 print_vma (segment
->p_offset
, FULL_HEX
);
3163 print_vma (segment
->p_vaddr
, FULL_HEX
);
3165 print_vma (segment
->p_paddr
, FULL_HEX
);
3168 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3169 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3172 print_vma (segment
->p_filesz
, FULL_HEX
);
3176 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3177 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3180 print_vma (segment
->p_offset
, FULL_HEX
);
3184 (segment
->p_flags
& PF_R
? 'R' : ' '),
3185 (segment
->p_flags
& PF_W
? 'W' : ' '),
3186 (segment
->p_flags
& PF_X
? 'E' : ' '));
3188 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3189 printf ("%#lx", (unsigned long) segment
->p_align
);
3192 print_vma (segment
->p_align
, PREFIX_HEX
);
3197 print_vma (segment
->p_offset
, FULL_HEX
);
3199 print_vma (segment
->p_vaddr
, FULL_HEX
);
3201 print_vma (segment
->p_paddr
, FULL_HEX
);
3203 print_vma (segment
->p_filesz
, FULL_HEX
);
3205 print_vma (segment
->p_memsz
, FULL_HEX
);
3207 (segment
->p_flags
& PF_R
? 'R' : ' '),
3208 (segment
->p_flags
& PF_W
? 'W' : ' '),
3209 (segment
->p_flags
& PF_X
? 'E' : ' '));
3210 print_vma (segment
->p_align
, HEX
);
3214 switch (segment
->p_type
)
3218 error (_("more than one dynamic segment\n"));
3220 /* Try to locate the .dynamic section. If there is
3221 a section header table, we can easily locate it. */
3222 if (section_headers
!= NULL
)
3224 Elf_Internal_Shdr
*sec
;
3227 for (j
= 0, sec
= section_headers
;
3228 j
< elf_header
.e_shnum
;
3230 if (strcmp (SECTION_NAME (sec
), ".dynamic") == 0)
3233 if (j
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
3235 error (_("no .dynamic section in the dynamic segment"));
3239 dynamic_addr
= sec
->sh_offset
;
3240 dynamic_size
= sec
->sh_size
;
3242 if (dynamic_addr
< segment
->p_offset
3243 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3244 warn (_("the .dynamic section is not contained within the dynamic segment"));
3245 else if (dynamic_addr
> segment
->p_offset
)
3246 warn (_("the .dynamic section is not the first section in the dynamic segment."));
3250 /* Otherwise, we can only assume that the .dynamic
3251 section is the first section in the DYNAMIC segment. */
3252 dynamic_addr
= segment
->p_offset
;
3253 dynamic_size
= segment
->p_filesz
;
3258 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3260 error (_("Unable to find program interpreter name\n"));
3263 program_interpreter
[0] = 0;
3264 fscanf (file
, "%63s", program_interpreter
);
3267 printf (_("\n [Requesting program interpreter: %s]"),
3268 program_interpreter
);
3274 putc ('\n', stdout
);
3277 if (do_segments
&& section_headers
!= NULL
)
3279 printf (_("\n Section to Segment mapping:\n"));
3280 printf (_(" Segment Sections...\n"));
3282 assert (string_table
!= NULL
);
3284 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3287 Elf_Internal_Shdr
*section
;
3289 segment
= program_headers
+ i
;
3290 section
= section_headers
;
3292 printf (" %2.2d ", i
);
3294 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3296 if (section
->sh_size
> 0
3297 /* Compare allocated sections by VMA, unallocated
3298 sections by file offset. */
3299 && (section
->sh_flags
& SHF_ALLOC
3300 ? (section
->sh_addr
>= segment
->p_vaddr
3301 && section
->sh_addr
+ section
->sh_size
3302 <= segment
->p_vaddr
+ segment
->p_memsz
)
3303 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
3304 && (section
->sh_offset
+ section
->sh_size
3305 <= segment
->p_offset
+ segment
->p_filesz
))))
3306 printf ("%s ", SECTION_NAME (section
));
3317 /* Find the file offset corresponding to VMA by using the program headers. */
3320 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3322 Elf_Internal_Phdr
*seg
;
3324 if (! get_program_headers (file
))
3326 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3330 for (seg
= program_headers
;
3331 seg
< program_headers
+ elf_header
.e_phnum
;
3334 if (seg
->p_type
!= PT_LOAD
)
3337 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3338 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3339 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3342 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3349 get_32bit_section_headers (FILE *file
, unsigned int num
)
3351 Elf32_External_Shdr
*shdrs
;
3352 Elf_Internal_Shdr
*internal
;
3355 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3356 elf_header
.e_shentsize
* num
, _("section headers"));
3360 section_headers
= malloc (num
* sizeof (Elf_Internal_Shdr
));
3362 if (section_headers
== NULL
)
3364 error (_("Out of memory\n"));
3368 for (i
= 0, internal
= section_headers
;
3372 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3373 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3374 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3375 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3376 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3377 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3378 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3379 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3380 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3381 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3390 get_64bit_section_headers (FILE *file
, unsigned int num
)
3392 Elf64_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_GET8 (shdrs
[i
].sh_flags
);
3416 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
3417 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
3418 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
3419 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3420 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3421 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3422 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3430 static Elf_Internal_Sym
*
3431 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3433 unsigned long number
;
3434 Elf32_External_Sym
*esyms
;
3435 Elf_External_Sym_Shndx
*shndx
;
3436 Elf_Internal_Sym
*isyms
;
3437 Elf_Internal_Sym
*psym
;
3440 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3446 if (symtab_shndx_hdr
!= NULL
3447 && (symtab_shndx_hdr
->sh_link
3448 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3450 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3451 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3459 number
= section
->sh_size
/ section
->sh_entsize
;
3460 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3464 error (_("Out of memory\n"));
3471 for (j
= 0, psym
= isyms
;
3475 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3476 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3477 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3478 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3479 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3481 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3482 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3483 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3493 static Elf_Internal_Sym
*
3494 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3496 unsigned long number
;
3497 Elf64_External_Sym
*esyms
;
3498 Elf_External_Sym_Shndx
*shndx
;
3499 Elf_Internal_Sym
*isyms
;
3500 Elf_Internal_Sym
*psym
;
3503 esyms
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
3509 if (symtab_shndx_hdr
!= NULL
3510 && (symtab_shndx_hdr
->sh_link
3511 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3513 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3514 symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3522 number
= section
->sh_size
/ section
->sh_entsize
;
3523 isyms
= malloc (number
* sizeof (Elf_Internal_Sym
));
3527 error (_("Out of memory\n"));
3534 for (j
= 0, psym
= isyms
;
3538 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3539 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3540 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3541 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3542 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3544 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3545 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
3546 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
3557 get_elf_section_flags (bfd_vma sh_flags
)
3559 static char buff
[32];
3567 flag
= sh_flags
& - sh_flags
;
3572 case SHF_WRITE
: strcat (buff
, "W"); break;
3573 case SHF_ALLOC
: strcat (buff
, "A"); break;
3574 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
3575 case SHF_MERGE
: strcat (buff
, "M"); break;
3576 case SHF_STRINGS
: strcat (buff
, "S"); break;
3577 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
3578 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
3579 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
3580 case SHF_GROUP
: strcat (buff
, "G"); break;
3581 case SHF_TLS
: strcat (buff
, "T"); break;
3584 if (flag
& SHF_MASKOS
)
3587 sh_flags
&= ~ SHF_MASKOS
;
3589 else if (flag
& SHF_MASKPROC
)
3592 sh_flags
&= ~ SHF_MASKPROC
;
3604 process_section_headers (FILE *file
)
3606 Elf_Internal_Shdr
*section
;
3609 section_headers
= NULL
;
3611 if (elf_header
.e_shnum
== 0)
3614 printf (_("\nThere are no sections in this file.\n"));
3619 if (do_sections
&& !do_header
)
3620 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
3621 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
3625 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
3628 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
3631 /* Read in the string table, so that we have names to display. */
3632 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
3634 if (section
->sh_size
!= 0)
3636 string_table
= get_data (NULL
, file
, section
->sh_offset
,
3637 section
->sh_size
, _("string table"));
3639 if (string_table
== NULL
)
3642 string_table_length
= section
->sh_size
;
3645 /* Scan the sections for the dynamic symbol table
3646 and dynamic string table and debug sections. */
3647 dynamic_symbols
= NULL
;
3648 dynamic_strings
= NULL
;
3649 dynamic_syminfo
= NULL
;
3650 symtab_shndx_hdr
= NULL
;
3652 for (i
= 0, section
= section_headers
;
3653 i
< elf_header
.e_shnum
;
3656 char *name
= SECTION_NAME (section
);
3658 if (section
->sh_type
== SHT_DYNSYM
)
3660 if (dynamic_symbols
!= NULL
)
3662 error (_("File contains multiple dynamic symbol tables\n"));
3666 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3667 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
3669 else if (section
->sh_type
== SHT_STRTAB
3670 && strcmp (name
, ".dynstr") == 0)
3672 if (dynamic_strings
!= NULL
)
3674 error (_("File contains multiple dynamic string tables\n"));
3678 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
3679 section
->sh_size
, _("dynamic strings"));
3681 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
3683 if (symtab_shndx_hdr
!= NULL
)
3685 error (_("File contains multiple symtab shndx tables\n"));
3688 symtab_shndx_hdr
= section
;
3690 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3691 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3692 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
3694 && strncmp (name
, ".debug_", 7) == 0)
3699 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3700 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3701 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3702 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3703 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3704 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3705 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3706 || (do_debug_str
&& (strcmp (name
, "str") == 0))
3707 || (do_debug_loc
&& (strcmp (name
, "loc") == 0))
3709 request_dump (i
, DEBUG_DUMP
);
3711 /* linkonce section to be combined with .debug_info at link time. */
3712 else if ((do_debugging
|| do_debug_info
)
3713 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3714 request_dump (i
, DEBUG_DUMP
);
3715 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3716 request_dump (i
, DEBUG_DUMP
);
3722 if (elf_header
.e_shnum
> 1)
3723 printf (_("\nSection Headers:\n"));
3725 printf (_("\nSection Header:\n"));
3729 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3732 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3735 printf (_(" [Nr] Name Type Address Offset\n"));
3736 printf (_(" Size EntSize Flags Link Info Align\n"));
3739 for (i
= 0, section
= section_headers
;
3740 i
< elf_header
.e_shnum
;
3743 printf (" [%2u] %-17.17s %-15.15s ",
3744 SECTION_HEADER_NUM (i
),
3745 SECTION_NAME (section
),
3746 get_section_type_name (section
->sh_type
));
3750 print_vma (section
->sh_addr
, LONG_HEX
);
3752 printf ( " %6.6lx %6.6lx %2.2lx",
3753 (unsigned long) section
->sh_offset
,
3754 (unsigned long) section
->sh_size
,
3755 (unsigned long) section
->sh_entsize
);
3757 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3759 printf ("%2ld %3lu %2ld\n",
3760 (unsigned long) section
->sh_link
,
3761 (unsigned long) section
->sh_info
,
3762 (unsigned long) section
->sh_addralign
);
3766 print_vma (section
->sh_addr
, LONG_HEX
);
3768 if ((long) section
->sh_offset
== section
->sh_offset
)
3769 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3773 print_vma (section
->sh_offset
, LONG_HEX
);
3776 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3777 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3781 print_vma (section
->sh_size
, LONG_HEX
);
3784 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3785 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3789 print_vma (section
->sh_entsize
, LONG_HEX
);
3792 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3794 printf ("%2ld %3lu ",
3795 (unsigned long) section
->sh_link
,
3796 (unsigned long) section
->sh_info
);
3798 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3799 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3802 print_vma (section
->sh_addralign
, DEC
);
3809 print_vma (section
->sh_addr
, LONG_HEX
);
3810 if ((long) section
->sh_offset
== section
->sh_offset
)
3811 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3815 print_vma (section
->sh_offset
, LONG_HEX
);
3818 print_vma (section
->sh_size
, LONG_HEX
);
3820 print_vma (section
->sh_entsize
, LONG_HEX
);
3822 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3824 printf (" %2ld %3lu %ld\n",
3825 (unsigned long) section
->sh_link
,
3826 (unsigned long) section
->sh_info
,
3827 (unsigned long) section
->sh_addralign
);
3831 printf (_("Key to Flags:\n\
3832 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
3833 I (info), L (link order), G (group), x (unknown)\n\
3834 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3840 get_group_flags (unsigned int flags
)
3842 static char buff
[32];
3849 sprintf (buff
, _("[<unknown>: 0x%x]"), flags
);
3856 process_section_groups (FILE *file
)
3858 Elf_Internal_Shdr
*section
;
3860 struct group
*group
;
3862 if (elf_header
.e_shnum
== 0)
3864 if (do_section_groups
)
3865 printf (_("\nThere are no section groups in this file.\n"));
3870 if (section_headers
== NULL
)
3872 error (_("Section headers are not available!\n"));
3876 section_headers_groups
= calloc (elf_header
.e_shnum
,
3877 sizeof (struct group
*));
3879 if (section_headers_groups
== NULL
)
3881 error (_("Out of memory\n"));
3885 /* Scan the sections for the group section. */
3886 for (i
= 0, section
= section_headers
;
3887 i
< elf_header
.e_shnum
;
3889 if (section
->sh_type
== SHT_GROUP
)
3892 section_groups
= calloc (group_count
, sizeof (struct group
));
3894 if (section_groups
== NULL
)
3896 error (_("Out of memory\n"));
3900 for (i
= 0, section
= section_headers
, group
= section_groups
;
3901 i
< elf_header
.e_shnum
;
3904 if (section
->sh_type
== SHT_GROUP
)
3906 char *name
= SECTION_NAME (section
);
3907 char *group_name
, *strtab
, *start
, *indices
;
3908 unsigned int entry
, j
, size
;
3909 Elf_Internal_Sym
*sym
;
3910 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
, *sec
;
3911 Elf_Internal_Sym
*symtab
;
3913 /* Get the symbol table. */
3914 symtab_sec
= SECTION_HEADER (section
->sh_link
);
3915 if (symtab_sec
->sh_type
!= SHT_SYMTAB
)
3917 error (_("Bad sh_link in group section `%s'\n"), name
);
3920 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
3922 sym
= symtab
+ section
->sh_info
;
3924 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3926 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
3929 error (_("Bad sh_info in group section `%s'\n"), name
);
3933 group_name
= SECTION_NAME (section_headers
+ sec_index
);
3938 /* Get the string table. */
3939 strtab_sec
= SECTION_HEADER (symtab_sec
->sh_link
);
3940 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
3941 strtab_sec
->sh_size
,
3944 group_name
= strtab
+ sym
->st_name
;
3947 start
= get_data (NULL
, file
, section
->sh_offset
,
3948 section
->sh_size
, _("section data"));
3951 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
3952 entry
= byte_get (indices
, 4);
3955 if (do_section_groups
)
3957 printf ("\n%s group section `%s' [%s] contains %u sections:\n",
3958 get_group_flags (entry
), name
, group_name
, size
);
3960 printf (_(" [Index] Name\n"));
3963 group
->group_index
= i
;
3965 for (j
= 0; j
< size
; j
++)
3967 struct group_list
*g
;
3969 entry
= byte_get (indices
, 4);
3972 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
3975 error (_("section [%5u] already in group section [%5u]\n"),
3976 entry
, section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
3980 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
3983 if (do_section_groups
)
3985 sec
= SECTION_HEADER (entry
);
3986 printf (" [%5u] %s\n",
3987 entry
, SECTION_NAME (sec
));
3990 g
= xmalloc (sizeof (struct group_list
));
3991 g
->section_index
= entry
;
3992 g
->next
= group
->root
;
4014 } dynamic_relocations
[] =
4016 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4017 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4018 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4021 /* Process the reloc section. */
4023 process_relocs (FILE *file
)
4025 unsigned long rel_size
;
4026 unsigned long rel_offset
;
4032 if (do_using_dynamic
)
4036 int has_dynamic_reloc
;
4039 has_dynamic_reloc
= 0;
4041 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4043 is_rela
= dynamic_relocations
[i
].rela
;
4044 name
= dynamic_relocations
[i
].name
;
4045 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4046 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4048 has_dynamic_reloc
|= rel_size
;
4050 if (is_rela
== UNKNOWN
)
4052 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4053 switch (dynamic_info
[DT_PLTREL
])
4067 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4068 name
, rel_offset
, rel_size
);
4070 dump_relocations (file
,
4071 offset_from_vma (file
, rel_offset
, rel_size
),
4073 dynamic_symbols
, num_dynamic_syms
,
4074 dynamic_strings
, is_rela
);
4078 if (! has_dynamic_reloc
)
4079 printf (_("\nThere are no dynamic relocations in this file.\n"));
4083 Elf_Internal_Shdr
*section
;
4087 for (i
= 0, section
= section_headers
;
4088 i
< elf_header
.e_shnum
;
4091 if ( section
->sh_type
!= SHT_RELA
4092 && section
->sh_type
!= SHT_REL
)
4095 rel_offset
= section
->sh_offset
;
4096 rel_size
= section
->sh_size
;
4100 Elf_Internal_Shdr
*strsec
;
4101 Elf_Internal_Sym
*symtab
;
4104 unsigned long nsyms
;
4106 printf (_("\nRelocation section "));
4108 if (string_table
== NULL
)
4109 printf ("%d", section
->sh_name
);
4111 printf (_("'%s'"), SECTION_NAME (section
));
4113 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4114 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4119 if (section
->sh_link
)
4121 Elf_Internal_Shdr
*symsec
;
4123 symsec
= SECTION_HEADER (section
->sh_link
);
4124 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4125 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4130 strsec
= SECTION_HEADER (symsec
->sh_link
);
4132 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4133 strsec
->sh_size
, _("string table"));
4135 is_rela
= section
->sh_type
== SHT_RELA
;
4137 dump_relocations (file
, rel_offset
, rel_size
,
4138 symtab
, nsyms
, strtab
, is_rela
);
4150 printf (_("\nThere are no relocations in this file.\n"));
4156 #include "unwind-ia64.h"
4158 /* An absolute address consists of a section and an offset. If the
4159 section is NULL, the offset itself is the address, otherwise, the
4160 address equals to LOAD_ADDRESS(section) + offset. */
4164 unsigned short section
;
4170 struct unw_table_entry
4172 struct absaddr start
;
4174 struct absaddr info
;
4176 *table
; /* Unwind table. */
4177 unsigned long table_len
; /* Length of unwind table. */
4178 unsigned char *info
; /* Unwind info. */
4179 unsigned long info_size
; /* Size of unwind info. */
4180 bfd_vma info_addr
; /* starting address of unwind info. */
4181 bfd_vma seg_base
; /* Starting address of segment. */
4182 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4183 unsigned long nsyms
; /* Number of symbols. */
4184 char *strtab
; /* The string table. */
4185 unsigned long strtab_size
; /* Size of string table. */
4189 find_symbol_for_address (struct unw_aux_info
*aux
,
4190 struct absaddr addr
,
4191 const char **symname
,
4194 bfd_vma dist
= 0x100000;
4195 Elf_Internal_Sym
*sym
, *best
= NULL
;
4198 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
4200 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4201 && sym
->st_name
!= 0
4202 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4203 && addr
.offset
>= sym
->st_value
4204 && addr
.offset
- sym
->st_value
< dist
)
4207 dist
= addr
.offset
- sym
->st_value
;
4214 *symname
= (best
->st_name
>= aux
->strtab_size
4215 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
4220 *offset
= addr
.offset
;
4224 dump_ia64_unwind (struct unw_aux_info
*aux
)
4227 struct unw_table_entry
*tp
;
4230 addr_size
= is_32bit_elf
? 4 : 8;
4232 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4236 const unsigned char *dp
;
4237 const unsigned char *head
;
4238 const char *procname
;
4240 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
4242 fputs ("\n<", stdout
);
4246 fputs (procname
, stdout
);
4249 printf ("+%lx", (unsigned long) offset
);
4252 fputs (">: [", stdout
);
4253 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4254 fputc ('-', stdout
);
4255 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4256 printf ("], info at +0x%lx\n",
4257 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4259 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
4260 stamp
= BYTE_GET8 ((unsigned char *) head
);
4262 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4263 (unsigned) UNW_VER (stamp
),
4264 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4265 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4266 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4267 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
4269 if (UNW_VER (stamp
) != 1)
4271 printf ("\tUnknown version.\n");
4276 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
4277 dp
= unw_decode (dp
, in_body
, & in_body
);
4282 slurp_ia64_unwind_table (FILE *file
,
4283 struct unw_aux_info
*aux
,
4284 Elf_Internal_Shdr
*sec
)
4286 unsigned long size
, addr_size
, nrelas
, i
;
4287 Elf_Internal_Phdr
*seg
;
4288 struct unw_table_entry
*tep
;
4289 Elf_Internal_Shdr
*relsec
;
4290 Elf_Internal_Rela
*rela
, *rp
;
4291 unsigned char *table
, *tp
;
4292 Elf_Internal_Sym
*sym
;
4293 const char *relname
;
4295 addr_size
= is_32bit_elf
? 4 : 8;
4297 /* First, find the starting address of the segment that includes
4300 if (elf_header
.e_phnum
)
4302 if (! get_program_headers (file
))
4305 for (seg
= program_headers
;
4306 seg
< program_headers
+ elf_header
.e_phnum
;
4309 if (seg
->p_type
!= PT_LOAD
)
4312 if (sec
->sh_addr
>= seg
->p_vaddr
4313 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4315 aux
->seg_base
= seg
->p_vaddr
;
4321 /* Second, build the unwind table from the contents of the unwind section: */
4322 size
= sec
->sh_size
;
4323 table
= get_data (NULL
, file
, sec
->sh_offset
, size
, _("unwind table"));
4327 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
4328 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++tep
)
4330 tep
->start
.section
= SHN_UNDEF
;
4331 tep
->end
.section
= SHN_UNDEF
;
4332 tep
->info
.section
= SHN_UNDEF
;
4335 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
4336 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
4337 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
4341 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
4342 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
4343 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
4345 tep
->start
.offset
+= aux
->seg_base
;
4346 tep
->end
.offset
+= aux
->seg_base
;
4347 tep
->info
.offset
+= aux
->seg_base
;
4351 /* Third, apply any relocations to the unwind table: */
4353 for (relsec
= section_headers
;
4354 relsec
< section_headers
+ elf_header
.e_shnum
;
4357 if (relsec
->sh_type
!= SHT_RELA
4358 || SECTION_HEADER (relsec
->sh_info
) != sec
)
4361 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
4365 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
4369 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
4370 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
4372 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4374 warn (_("Skipping unexpected symbol type %u\n"),
4375 ELF32_ST_TYPE (sym
->st_info
));
4381 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
4382 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
4384 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4386 warn (_("Skipping unexpected symbol type %u\n"),
4387 ELF64_ST_TYPE (sym
->st_info
));
4392 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
4394 warn (_("Skipping unexpected relocation type %s\n"), relname
);
4398 i
= rp
->r_offset
/ (3 * addr_size
);
4400 switch (rp
->r_offset
/addr_size
% 3)
4403 aux
->table
[i
].start
.section
= sym
->st_shndx
;
4404 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
4407 aux
->table
[i
].end
.section
= sym
->st_shndx
;
4408 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
4411 aux
->table
[i
].info
.section
= sym
->st_shndx
;
4412 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
4422 aux
->table_len
= size
/ (3 * addr_size
);
4427 process_unwind (FILE *file
)
4429 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
4430 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
4431 struct unw_aux_info aux
;
4436 if (elf_header
.e_machine
!= EM_IA_64
)
4438 printf (_("\nThere are no unwind sections in this file.\n"));
4442 memset (& aux
, 0, sizeof (aux
));
4444 addr_size
= is_32bit_elf
? 4 : 8;
4446 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
4448 if (sec
->sh_type
== SHT_SYMTAB
)
4450 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
4451 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
4453 strsec
= SECTION_HEADER (sec
->sh_link
);
4454 aux
.strtab_size
= strsec
->sh_size
;
4455 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4456 aux
.strtab_size
, _("string table"));
4458 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4463 printf (_("\nThere are no unwind sections in this file.\n"));
4465 while (unwcount
-- > 0)
4470 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
4471 i
< elf_header
.e_shnum
; ++i
, ++sec
)
4472 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
4479 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
4481 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
4483 /* We need to find which section group it is in. */
4484 struct group_list
*g
= section_headers_groups
[i
]->root
;
4486 for (; g
!= NULL
; g
= g
->next
)
4488 sec
= SECTION_HEADER (g
->section_index
);
4489 if (strcmp (SECTION_NAME (sec
),
4490 ELF_STRING_ia64_unwind_info
) == 0)
4495 i
= elf_header
.e_shnum
;
4497 else if (strncmp (SECTION_NAME (unwsec
),
4498 ELF_STRING_ia64_unwind_once
, len
) == 0)
4500 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
4501 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
4502 suffix
= SECTION_NAME (unwsec
) + len
;
4503 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4505 if (strncmp (SECTION_NAME (sec
),
4506 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
4507 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4512 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
4513 .IA_64.unwind or BAR -> .IA_64.unwind_info */
4514 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
4515 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
4517 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
4519 suffix
= SECTION_NAME (unwsec
) + len
;
4520 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
4522 if (strncmp (SECTION_NAME (sec
),
4523 ELF_STRING_ia64_unwind_info
, len2
) == 0
4524 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
4528 if (i
== elf_header
.e_shnum
)
4530 printf (_("\nCould not find unwind info section for "));
4532 if (string_table
== NULL
)
4533 printf ("%d", unwsec
->sh_name
);
4535 printf (_("'%s'"), SECTION_NAME (unwsec
));
4539 aux
.info_size
= sec
->sh_size
;
4540 aux
.info_addr
= sec
->sh_addr
;
4541 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, aux
.info_size
,
4544 printf (_("\nUnwind section "));
4546 if (string_table
== NULL
)
4547 printf ("%d", unwsec
->sh_name
);
4549 printf (_("'%s'"), SECTION_NAME (unwsec
));
4551 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4552 (unsigned long) unwsec
->sh_offset
,
4553 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
4555 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
4557 if (aux
.table_len
> 0)
4558 dump_ia64_unwind (& aux
);
4561 free ((char *) aux
.table
);
4563 free ((char *) aux
.info
);
4572 free ((char *) aux
.strtab
);
4578 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
4580 switch (entry
->d_tag
)
4583 if (entry
->d_un
.d_val
== 0)
4587 static const char * opts
[] =
4589 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
4590 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
4591 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
4592 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
4597 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++cnt
)
4598 if (entry
->d_un
.d_val
& (1 << cnt
))
4600 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
4607 case DT_MIPS_IVERSION
:
4608 if (dynamic_strings
!= NULL
)
4609 printf ("Interface Version: %s\n",
4610 dynamic_strings
+ entry
->d_un
.d_val
);
4612 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4615 case DT_MIPS_TIME_STAMP
:
4620 time_t time
= entry
->d_un
.d_val
;
4621 tmp
= gmtime (&time
);
4622 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
4623 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
4624 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
4625 printf ("Time Stamp: %s\n", timebuf
);
4629 case DT_MIPS_RLD_VERSION
:
4630 case DT_MIPS_LOCAL_GOTNO
:
4631 case DT_MIPS_CONFLICTNO
:
4632 case DT_MIPS_LIBLISTNO
:
4633 case DT_MIPS_SYMTABNO
:
4634 case DT_MIPS_UNREFEXTNO
:
4635 case DT_MIPS_HIPAGENO
:
4636 case DT_MIPS_DELTA_CLASS_NO
:
4637 case DT_MIPS_DELTA_INSTANCE_NO
:
4638 case DT_MIPS_DELTA_RELOC_NO
:
4639 case DT_MIPS_DELTA_SYM_NO
:
4640 case DT_MIPS_DELTA_CLASSSYM_NO
:
4641 case DT_MIPS_COMPACT_SIZE
:
4642 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
4646 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
4652 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
4654 switch (entry
->d_tag
)
4656 case DT_HP_DLD_FLAGS
:
4665 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
4666 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
4667 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
4668 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
4669 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
4670 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
4671 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
4672 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
4673 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
4674 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
4675 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
4679 bfd_vma val
= entry
->d_un
.d_val
;
4681 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
4682 if (val
& flags
[cnt
].bit
)
4686 fputs (flags
[cnt
].str
, stdout
);
4688 val
^= flags
[cnt
].bit
;
4691 if (val
!= 0 || first
)
4695 print_vma (val
, HEX
);
4701 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4708 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
4710 switch (entry
->d_tag
)
4712 case DT_IA_64_PLT_RESERVE
:
4713 /* First 3 slots reserved. */
4714 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4716 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
4720 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
4727 get_32bit_dynamic_section (FILE *file
)
4729 Elf32_External_Dyn
*edyn
, *ext
;
4730 Elf_Internal_Dyn
*entry
;
4732 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4733 _("dynamic section"));
4737 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4738 might not have the luxury of section headers. Look for the DT_NULL
4739 terminator to determine the number of entries. */
4740 for (ext
= edyn
, dynamic_nent
= 0;
4741 (char *) ext
< (char *) edyn
+ dynamic_size
;
4745 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
4749 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4750 if (dynamic_section
== NULL
)
4752 error (_("Out of memory\n"));
4757 for (ext
= edyn
, entry
= dynamic_section
;
4758 entry
< dynamic_section
+ dynamic_nent
;
4761 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
4762 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
4771 get_64bit_dynamic_section (FILE *file
)
4773 Elf64_External_Dyn
*edyn
, *ext
;
4774 Elf_Internal_Dyn
*entry
;
4776 edyn
= get_data (NULL
, file
, dynamic_addr
, dynamic_size
,
4777 _("dynamic section"));
4781 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
4782 might not have the luxury of section headers. Look for the DT_NULL
4783 terminator to determine the number of entries. */
4784 for (ext
= edyn
, dynamic_nent
= 0;
4785 (char *) ext
< (char *) edyn
+ dynamic_size
;
4789 if (BYTE_GET8 (ext
->d_tag
) == DT_NULL
)
4793 dynamic_section
= malloc (dynamic_nent
* sizeof (*entry
));
4794 if (dynamic_section
== NULL
)
4796 error (_("Out of memory\n"));
4801 for (ext
= edyn
, entry
= dynamic_section
;
4802 entry
< dynamic_section
+ dynamic_nent
;
4805 entry
->d_tag
= BYTE_GET8 (ext
->d_tag
);
4806 entry
->d_un
.d_val
= BYTE_GET8 (ext
->d_un
.d_val
);
4815 get_dynamic_flags (bfd_vma flags
)
4817 static char buff
[128];
4825 flag
= flags
& - flags
;
4833 case DF_ORIGIN
: strcpy (p
, "ORIGIN"); break;
4834 case DF_SYMBOLIC
: strcpy (p
, "SYMBOLIC"); break;
4835 case DF_TEXTREL
: strcpy (p
, "TEXTREL"); break;
4836 case DF_BIND_NOW
: strcpy (p
, "BIND_NOW"); break;
4837 case DF_STATIC_TLS
: strcpy (p
, "STATIC_TLS"); break;
4838 default: strcpy (p
, "unknown"); break;
4841 p
= strchr (p
, '\0');
4846 /* Parse and display the contents of the dynamic section. */
4849 process_dynamic_section (FILE *file
)
4851 Elf_Internal_Dyn
*entry
;
4853 if (dynamic_size
== 0)
4856 printf (_("\nThere is no dynamic section in this file.\n"));
4863 if (! get_32bit_dynamic_section (file
))
4866 else if (! get_64bit_dynamic_section (file
))
4869 /* Find the appropriate symbol table. */
4870 if (dynamic_symbols
== NULL
)
4872 for (entry
= dynamic_section
;
4873 entry
< dynamic_section
+ dynamic_nent
;
4876 Elf_Internal_Shdr section
;
4878 if (entry
->d_tag
!= DT_SYMTAB
)
4881 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4883 /* Since we do not know how big the symbol table is,
4884 we default to reading in the entire file (!) and
4885 processing that. This is overkill, I know, but it
4887 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4889 if (archive_file_offset
!= 0)
4890 section
.sh_size
= archive_file_size
- section
.sh_offset
;
4893 if (fseek (file
, 0, SEEK_END
))
4894 error (_("Unable to seek to end of file!"));
4896 section
.sh_size
= ftell (file
) - section
.sh_offset
;
4900 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
4902 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
4904 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
4905 if (num_dynamic_syms
< 1)
4907 error (_("Unable to determine the number of symbols to load\n"));
4911 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
4915 /* Similarly find a string table. */
4916 if (dynamic_strings
== NULL
)
4918 for (entry
= dynamic_section
;
4919 entry
< dynamic_section
+ dynamic_nent
;
4922 unsigned long offset
;
4925 if (entry
->d_tag
!= DT_STRTAB
)
4928 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4930 /* Since we do not know how big the string table is,
4931 we default to reading in the entire file (!) and
4932 processing that. This is overkill, I know, but it
4935 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
4937 if (archive_file_offset
!= 0)
4938 str_tab_len
= archive_file_size
- offset
;
4941 if (fseek (file
, 0, SEEK_END
))
4942 error (_("Unable to seek to end of file\n"));
4943 str_tab_len
= ftell (file
) - offset
;
4946 if (str_tab_len
< 1)
4949 (_("Unable to determine the length of the dynamic string table\n"));
4953 dynamic_strings
= get_data (NULL
, file
, offset
, str_tab_len
,
4954 _("dynamic string table"));
4959 /* And find the syminfo section if available. */
4960 if (dynamic_syminfo
== NULL
)
4962 unsigned long syminsz
= 0;
4964 for (entry
= dynamic_section
;
4965 entry
< dynamic_section
+ dynamic_nent
;
4968 if (entry
->d_tag
== DT_SYMINENT
)
4970 /* Note: these braces are necessary to avoid a syntax
4971 error from the SunOS4 C compiler. */
4972 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4974 else if (entry
->d_tag
== DT_SYMINSZ
)
4975 syminsz
= entry
->d_un
.d_val
;
4976 else if (entry
->d_tag
== DT_SYMINFO
)
4977 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
4981 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4983 Elf_External_Syminfo
*extsyminfo
, *extsym
;
4984 Elf_Internal_Syminfo
*syminfo
;
4986 /* There is a syminfo section. Read the data. */
4987 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, syminsz
,
4988 _("symbol information"));
4992 dynamic_syminfo
= malloc (syminsz
);
4993 if (dynamic_syminfo
== NULL
)
4995 error (_("Out of memory\n"));
4999 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
5000 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
5001 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
5002 ++syminfo
, ++extsym
)
5004 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
5005 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
5012 if (do_dynamic
&& dynamic_addr
)
5013 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5014 dynamic_addr
, dynamic_nent
);
5016 printf (_(" Tag Type Name/Value\n"));
5018 for (entry
= dynamic_section
;
5019 entry
< dynamic_section
+ dynamic_nent
;
5027 print_vma (entry
->d_tag
, FULL_HEX
);
5028 dtype
= get_dynamic_type (entry
->d_tag
);
5029 printf (" (%s)%*s", dtype
,
5030 ((is_32bit_elf
? 27 : 19)
5031 - (int) strlen (dtype
)),
5035 switch (entry
->d_tag
)
5039 puts (get_dynamic_flags (entry
->d_un
.d_val
));
5049 switch (entry
->d_tag
)
5052 printf (_("Auxiliary library"));
5056 printf (_("Filter library"));
5060 printf (_("Configuration file"));
5064 printf (_("Dependency audit library"));
5068 printf (_("Audit library"));
5072 if (dynamic_strings
)
5073 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
5077 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5086 printf (_("Flags:"));
5088 if (entry
->d_un
.d_val
== 0)
5089 printf (_(" None\n"));
5092 unsigned long int val
= entry
->d_un
.d_val
;
5094 if (val
& DTF_1_PARINIT
)
5096 printf (" PARINIT");
5097 val
^= DTF_1_PARINIT
;
5099 if (val
& DTF_1_CONFEXP
)
5101 printf (" CONFEXP");
5102 val
^= DTF_1_CONFEXP
;
5105 printf (" %lx", val
);
5114 printf (_("Flags:"));
5116 if (entry
->d_un
.d_val
== 0)
5117 printf (_(" None\n"));
5120 unsigned long int val
= entry
->d_un
.d_val
;
5122 if (val
& DF_P1_LAZYLOAD
)
5124 printf (" LAZYLOAD");
5125 val
^= DF_P1_LAZYLOAD
;
5127 if (val
& DF_P1_GROUPPERM
)
5129 printf (" GROUPPERM");
5130 val
^= DF_P1_GROUPPERM
;
5133 printf (" %lx", val
);
5142 printf (_("Flags:"));
5143 if (entry
->d_un
.d_val
== 0)
5144 printf (_(" None\n"));
5147 unsigned long int val
= entry
->d_un
.d_val
;
5154 if (val
& DF_1_GLOBAL
)
5159 if (val
& DF_1_GROUP
)
5164 if (val
& DF_1_NODELETE
)
5166 printf (" NODELETE");
5167 val
^= DF_1_NODELETE
;
5169 if (val
& DF_1_LOADFLTR
)
5171 printf (" LOADFLTR");
5172 val
^= DF_1_LOADFLTR
;
5174 if (val
& DF_1_INITFIRST
)
5176 printf (" INITFIRST");
5177 val
^= DF_1_INITFIRST
;
5179 if (val
& DF_1_NOOPEN
)
5184 if (val
& DF_1_ORIGIN
)
5189 if (val
& DF_1_DIRECT
)
5194 if (val
& DF_1_TRANS
)
5199 if (val
& DF_1_INTERPOSE
)
5201 printf (" INTERPOSE");
5202 val
^= DF_1_INTERPOSE
;
5204 if (val
& DF_1_NODEFLIB
)
5206 printf (" NODEFLIB");
5207 val
^= DF_1_NODEFLIB
;
5209 if (val
& DF_1_NODUMP
)
5214 if (val
& DF_1_CONLFAT
)
5216 printf (" CONLFAT");
5217 val
^= DF_1_CONLFAT
;
5220 printf (" %lx", val
);
5227 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5229 puts (get_dynamic_type (entry
->d_un
.d_val
));
5249 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5255 if (dynamic_strings
== NULL
)
5258 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5262 switch (entry
->d_tag
)
5265 printf (_("Shared library: [%s]"), name
);
5267 if (strcmp (name
, program_interpreter
) == 0)
5268 printf (_(" program interpreter"));
5272 printf (_("Library soname: [%s]"), name
);
5276 printf (_("Library rpath: [%s]"), name
);
5280 printf (_("Library runpath: [%s]"), name
);
5284 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5289 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5302 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
5306 case DT_INIT_ARRAYSZ
:
5307 case DT_FINI_ARRAYSZ
:
5308 case DT_GNU_CONFLICTSZ
:
5309 case DT_GNU_LIBLISTSZ
:
5312 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5313 printf (" (bytes)\n");
5323 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
5336 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
5340 name
= dynamic_strings
+ entry
->d_un
.d_val
;
5344 printf (_("Not needed object: [%s]\n"), name
);
5349 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5355 /* The value of this entry is ignored. */
5360 case DT_GNU_PRELINKED
:
5364 time_t time
= entry
->d_un
.d_val
;
5366 tmp
= gmtime (&time
);
5367 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
5368 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5369 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5375 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
5376 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
5381 switch (elf_header
.e_machine
)
5384 case EM_MIPS_RS3_LE
:
5385 dynamic_section_mips_val (entry
);
5388 dynamic_section_parisc_val (entry
);
5391 dynamic_section_ia64_val (entry
);
5394 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
5406 get_ver_flags (unsigned int flags
)
5408 static char buff
[32];
5415 if (flags
& VER_FLG_BASE
)
5416 strcat (buff
, "BASE ");
5418 if (flags
& VER_FLG_WEAK
)
5420 if (flags
& VER_FLG_BASE
)
5421 strcat (buff
, "| ");
5423 strcat (buff
, "WEAK ");
5426 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
5427 strcat (buff
, "| <unknown>");
5432 /* Display the contents of the version sections. */
5434 process_version_sections (FILE *file
)
5436 Elf_Internal_Shdr
*section
;
5443 for (i
= 0, section
= section_headers
;
5444 i
< elf_header
.e_shnum
;
5447 switch (section
->sh_type
)
5449 case SHT_GNU_verdef
:
5451 Elf_External_Verdef
*edefs
;
5458 (_("\nVersion definition section '%s' contains %ld entries:\n"),
5459 SECTION_NAME (section
), section
->sh_info
);
5461 printf (_(" Addr: 0x"));
5462 printf_vma (section
->sh_addr
);
5463 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5464 (unsigned long) section
->sh_offset
, section
->sh_link
,
5465 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5467 edefs
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5468 _("version definition section"));
5472 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5475 Elf_External_Verdef
*edef
;
5476 Elf_Internal_Verdef ent
;
5477 Elf_External_Verdaux
*eaux
;
5478 Elf_Internal_Verdaux aux
;
5482 vstart
= ((char *) edefs
) + idx
;
5484 edef
= (Elf_External_Verdef
*) vstart
;
5486 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
5487 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
5488 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
5489 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
5490 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
5491 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
5492 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
5494 printf (_(" %#06x: Rev: %d Flags: %s"),
5495 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
5497 printf (_(" Index: %d Cnt: %d "),
5498 ent
.vd_ndx
, ent
.vd_cnt
);
5500 vstart
+= ent
.vd_aux
;
5502 eaux
= (Elf_External_Verdaux
*) vstart
;
5504 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5505 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5507 if (dynamic_strings
)
5508 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
5510 printf (_("Name index: %ld\n"), aux
.vda_name
);
5512 isum
= idx
+ ent
.vd_aux
;
5514 for (j
= 1; j
< ent
.vd_cnt
; j
++)
5516 isum
+= aux
.vda_next
;
5517 vstart
+= aux
.vda_next
;
5519 eaux
= (Elf_External_Verdaux
*) vstart
;
5521 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
5522 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
5524 if (dynamic_strings
)
5525 printf (_(" %#06x: Parent %d: %s\n"),
5526 isum
, j
, dynamic_strings
+ aux
.vda_name
);
5528 printf (_(" %#06x: Parent %d, name index: %ld\n"),
5529 isum
, j
, aux
.vda_name
);
5539 case SHT_GNU_verneed
:
5541 Elf_External_Verneed
*eneed
;
5547 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
5548 SECTION_NAME (section
), section
->sh_info
);
5550 printf (_(" Addr: 0x"));
5551 printf_vma (section
->sh_addr
);
5552 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
5553 (unsigned long) section
->sh_offset
, section
->sh_link
,
5554 SECTION_NAME (SECTION_HEADER (section
->sh_link
)));
5556 eneed
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
5557 _("version need section"));
5561 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
5563 Elf_External_Verneed
*entry
;
5564 Elf_Internal_Verneed ent
;
5569 vstart
= ((char *) eneed
) + idx
;
5571 entry
= (Elf_External_Verneed
*) vstart
;
5573 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
5574 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
5575 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
5576 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
5577 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
5579 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
5581 if (dynamic_strings
)
5582 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
5584 printf (_(" File: %lx"), ent
.vn_file
);
5586 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
5588 vstart
+= ent
.vn_aux
;
5590 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
5592 Elf_External_Vernaux
*eaux
;
5593 Elf_Internal_Vernaux aux
;
5595 eaux
= (Elf_External_Vernaux
*) vstart
;
5597 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
5598 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
5599 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
5600 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
5601 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
5603 if (dynamic_strings
)
5604 printf (_(" %#06x: Name: %s"),
5605 isum
, dynamic_strings
+ aux
.vna_name
);
5607 printf (_(" %#06x: Name index: %lx"),
5608 isum
, aux
.vna_name
);
5610 printf (_(" Flags: %s Version: %d\n"),
5611 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
5613 isum
+= aux
.vna_next
;
5614 vstart
+= aux
.vna_next
;
5624 case SHT_GNU_versym
:
5626 Elf_Internal_Shdr
*link_section
;
5629 unsigned char *edata
;
5630 unsigned short *data
;
5632 Elf_Internal_Sym
*symbols
;
5633 Elf_Internal_Shdr
*string_sec
;
5636 link_section
= SECTION_HEADER (section
->sh_link
);
5637 total
= section
->sh_size
/ section
->sh_entsize
;
5641 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
5643 string_sec
= SECTION_HEADER (link_section
->sh_link
);
5645 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
5646 string_sec
->sh_size
, _("version string table"));
5650 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
5651 SECTION_NAME (section
), total
);
5653 printf (_(" Addr: "));
5654 printf_vma (section
->sh_addr
);
5655 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
5656 (unsigned long) section
->sh_offset
, section
->sh_link
,
5657 SECTION_NAME (link_section
));
5659 off
= offset_from_vma (file
,
5660 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
5661 total
* sizeof (short));
5662 edata
= get_data (NULL
, file
, off
, total
* sizeof (short),
5663 _("version symbol data"));
5670 data
= malloc (total
* sizeof (short));
5672 for (cnt
= total
; cnt
--;)
5673 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
5678 for (cnt
= 0; cnt
< total
; cnt
+= 4)
5681 int check_def
, check_need
;
5684 printf (" %03x:", cnt
);
5686 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
5687 switch (data
[cnt
+ j
])
5690 fputs (_(" 0 (*local*) "), stdout
);
5694 fputs (_(" 1 (*global*) "), stdout
);
5698 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
5699 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
5703 if (SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
5706 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
5713 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
5715 Elf_Internal_Verneed ivn
;
5716 unsigned long offset
;
5718 offset
= offset_from_vma
5719 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
5720 sizeof (Elf_External_Verneed
));
5724 Elf_Internal_Vernaux ivna
;
5725 Elf_External_Verneed evn
;
5726 Elf_External_Vernaux evna
;
5727 unsigned long a_off
;
5729 get_data (&evn
, file
, offset
, sizeof (evn
),
5732 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5733 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5735 a_off
= offset
+ ivn
.vn_aux
;
5739 get_data (&evna
, file
, a_off
, sizeof (evna
),
5740 _("version need aux (2)"));
5742 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5743 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5745 a_off
+= ivna
.vna_next
;
5747 while (ivna
.vna_other
!= data
[cnt
+ j
]
5748 && ivna
.vna_next
!= 0);
5750 if (ivna
.vna_other
== data
[cnt
+ j
])
5752 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5754 name
= strtab
+ ivna
.vna_name
;
5755 nn
+= printf ("(%s%-*s",
5757 12 - (int) strlen (name
),
5763 offset
+= ivn
.vn_next
;
5765 while (ivn
.vn_next
);
5768 if (check_def
&& data
[cnt
+ j
] != 0x8001
5769 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5771 Elf_Internal_Verdef ivd
;
5772 Elf_External_Verdef evd
;
5773 unsigned long offset
;
5775 offset
= offset_from_vma
5776 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
5781 get_data (&evd
, file
, offset
, sizeof (evd
),
5784 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5785 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5787 offset
+= ivd
.vd_next
;
5789 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
5790 && ivd
.vd_next
!= 0);
5792 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
5794 Elf_External_Verdaux evda
;
5795 Elf_Internal_Verdaux ivda
;
5797 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5799 get_data (&evda
, file
,
5800 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
5801 sizeof (evda
), _("version def aux"));
5803 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5805 name
= strtab
+ ivda
.vda_name
;
5806 nn
+= printf ("(%s%-*s",
5808 12 - (int) strlen (name
),
5814 printf ("%*c", 18 - nn
, ' ');
5832 printf (_("\nNo version information found in this file.\n"));
5838 get_symbol_binding (unsigned int binding
)
5840 static char buff
[32];
5844 case STB_LOCAL
: return "LOCAL";
5845 case STB_GLOBAL
: return "GLOBAL";
5846 case STB_WEAK
: return "WEAK";
5848 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
5849 sprintf (buff
, _("<processor specific>: %d"), binding
);
5850 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
5851 sprintf (buff
, _("<OS specific>: %d"), binding
);
5853 sprintf (buff
, _("<unknown>: %d"), binding
);
5859 get_symbol_type (unsigned int type
)
5861 static char buff
[32];
5865 case STT_NOTYPE
: return "NOTYPE";
5866 case STT_OBJECT
: return "OBJECT";
5867 case STT_FUNC
: return "FUNC";
5868 case STT_SECTION
: return "SECTION";
5869 case STT_FILE
: return "FILE";
5870 case STT_COMMON
: return "COMMON";
5871 case STT_TLS
: return "TLS";
5873 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
5875 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
5876 return "THUMB_FUNC";
5878 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
5881 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
5882 return "PARISC_MILLI";
5884 sprintf (buff
, _("<processor specific>: %d"), type
);
5886 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5888 if (elf_header
.e_machine
== EM_PARISC
)
5890 if (type
== STT_HP_OPAQUE
)
5892 if (type
== STT_HP_STUB
)
5896 sprintf (buff
, _("<OS specific>: %d"), type
);
5899 sprintf (buff
, _("<unknown>: %d"), type
);
5905 get_symbol_visibility (unsigned int visibility
)
5909 case STV_DEFAULT
: return "DEFAULT";
5910 case STV_INTERNAL
: return "INTERNAL";
5911 case STV_HIDDEN
: return "HIDDEN";
5912 case STV_PROTECTED
: return "PROTECTED";
5918 get_symbol_index_type (unsigned int type
)
5920 static char buff
[32];
5924 case SHN_UNDEF
: return "UND";
5925 case SHN_ABS
: return "ABS";
5926 case SHN_COMMON
: return "COM";
5928 if (type
== SHN_IA_64_ANSI_COMMON
5929 && elf_header
.e_machine
== EM_IA_64
5930 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
5932 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5933 sprintf (buff
, "PRC[0x%04x]", type
);
5934 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5935 sprintf (buff
, "OS [0x%04x]", type
);
5936 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5937 sprintf (buff
, "RSV[0x%04x]", type
);
5939 sprintf (buff
, "%3d", type
);
5947 get_dynamic_data (FILE *file
, unsigned int number
)
5949 unsigned char *e_data
;
5952 e_data
= malloc (number
* 4);
5956 error (_("Out of memory\n"));
5960 if (fread (e_data
, 4, number
, file
) != number
)
5962 error (_("Unable to read in dynamic data\n"));
5966 i_data
= malloc (number
* sizeof (*i_data
));
5970 error (_("Out of memory\n"));
5976 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5983 /* Dump the symbol table. */
5985 process_symbol_table (FILE *file
)
5987 Elf_Internal_Shdr
*section
;
5988 unsigned char nb
[4];
5989 unsigned char nc
[4];
5992 int *buckets
= NULL
;
5995 if (! do_syms
&& !do_histogram
)
5998 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
6002 (archive_file_offset
6003 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
6004 sizeof nb
+ sizeof nc
)),
6007 error (_("Unable to seek to start of dynamic information"));
6011 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
6013 error (_("Failed to read in number of buckets\n"));
6017 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
6019 error (_("Failed to read in number of chains\n"));
6023 nbuckets
= byte_get (nb
, 4);
6024 nchains
= byte_get (nc
, 4);
6026 buckets
= get_dynamic_data (file
, nbuckets
);
6027 chains
= get_dynamic_data (file
, nchains
);
6029 if (buckets
== NULL
|| chains
== NULL
)
6034 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
6039 printf (_("\nSymbol table for image:\n"));
6041 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6043 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
6045 for (hn
= 0; hn
< nbuckets
; hn
++)
6050 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
6052 Elf_Internal_Sym
*psym
;
6054 psym
= dynamic_symbols
+ si
;
6056 printf (" %3d %3d: ", si
, hn
);
6057 print_vma (psym
->st_value
, LONG_HEX
);
6059 print_vma (psym
->st_size
, DEC_5
);
6061 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6062 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6063 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6064 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
6065 print_symbol (25, dynamic_strings
+ psym
->st_name
);
6070 else if (do_syms
&& !do_using_dynamic
)
6074 for (i
= 0, section
= section_headers
;
6075 i
< elf_header
.e_shnum
;
6080 Elf_Internal_Sym
*symtab
;
6081 Elf_Internal_Sym
*psym
;
6084 if ( section
->sh_type
!= SHT_SYMTAB
6085 && section
->sh_type
!= SHT_DYNSYM
)
6088 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
6089 SECTION_NAME (section
),
6090 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
6092 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6094 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
6096 symtab
= GET_ELF_SYMBOLS (file
, section
);
6100 if (section
->sh_link
== elf_header
.e_shstrndx
)
6101 strtab
= string_table
;
6104 Elf_Internal_Shdr
*string_sec
;
6106 string_sec
= SECTION_HEADER (section
->sh_link
);
6108 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
6109 string_sec
->sh_size
, _("string table"));
6112 for (si
= 0, psym
= symtab
;
6113 si
< section
->sh_size
/ section
->sh_entsize
;
6116 printf ("%6d: ", si
);
6117 print_vma (psym
->st_value
, LONG_HEX
);
6119 print_vma (psym
->st_size
, DEC_5
);
6120 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
6121 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
6122 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
6123 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
6124 print_symbol (25, strtab
+ psym
->st_name
);
6126 if (section
->sh_type
== SHT_DYNSYM
&&
6127 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
6129 unsigned char data
[2];
6130 unsigned short vers_data
;
6131 unsigned long offset
;
6135 offset
= offset_from_vma
6136 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6137 sizeof data
+ si
* sizeof (vers_data
));
6139 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
6140 sizeof (data
), _("version data"));
6142 vers_data
= byte_get (data
, 2);
6144 is_nobits
= (SECTION_HEADER (psym
->st_shndx
)->sh_type
6147 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
6149 if ((vers_data
& 0x8000) || vers_data
> 1)
6151 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
6152 && (is_nobits
|| ! check_def
))
6154 Elf_External_Verneed evn
;
6155 Elf_Internal_Verneed ivn
;
6156 Elf_Internal_Vernaux ivna
;
6158 /* We must test both. */
6159 offset
= offset_from_vma
6160 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6165 unsigned long vna_off
;
6167 get_data (&evn
, file
, offset
, sizeof (evn
),
6170 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6171 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6173 vna_off
= offset
+ ivn
.vn_aux
;
6177 Elf_External_Vernaux evna
;
6179 get_data (&evna
, file
, vna_off
,
6181 _("version need aux (3)"));
6183 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6184 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6185 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6187 vna_off
+= ivna
.vna_next
;
6189 while (ivna
.vna_other
!= vers_data
6190 && ivna
.vna_next
!= 0);
6192 if (ivna
.vna_other
== vers_data
)
6195 offset
+= ivn
.vn_next
;
6197 while (ivn
.vn_next
!= 0);
6199 if (ivna
.vna_other
== vers_data
)
6202 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
6205 else if (! is_nobits
)
6206 error (_("bad dynamic symbol"));
6213 if (vers_data
!= 0x8001
6214 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6216 Elf_Internal_Verdef ivd
;
6217 Elf_Internal_Verdaux ivda
;
6218 Elf_External_Verdaux evda
;
6219 unsigned long offset
;
6221 offset
= offset_from_vma
6223 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6224 sizeof (Elf_External_Verdef
));
6228 Elf_External_Verdef evd
;
6230 get_data (&evd
, file
, offset
, sizeof (evd
),
6233 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6234 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6235 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6237 offset
+= ivd
.vd_next
;
6239 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
6240 && ivd
.vd_next
!= 0);
6242 offset
-= ivd
.vd_next
;
6243 offset
+= ivd
.vd_aux
;
6245 get_data (&evda
, file
, offset
, sizeof (evda
),
6246 _("version def aux"));
6248 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6250 if (psym
->st_name
!= ivda
.vda_name
)
6251 printf ((vers_data
& 0x8000)
6253 strtab
+ ivda
.vda_name
);
6263 if (strtab
!= string_table
)
6269 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
6271 if (do_histogram
&& buckets
!= NULL
)
6278 int nzero_counts
= 0;
6281 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
6283 printf (_(" Length Number %% of total Coverage\n"));
6285 lengths
= calloc (nbuckets
, sizeof (int));
6286 if (lengths
== NULL
)
6288 error (_("Out of memory"));
6291 for (hn
= 0; hn
< nbuckets
; ++hn
)
6296 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
6299 if (maxlength
< ++lengths
[hn
])
6304 counts
= calloc (maxlength
+ 1, sizeof (int));
6307 error (_("Out of memory"));
6311 for (hn
= 0; hn
< nbuckets
; ++hn
)
6312 ++counts
[lengths
[hn
]];
6316 printf (" 0 %-10d (%5.1f%%)\n",
6317 counts
[0], (counts
[0] * 100.0) / nbuckets
);
6318 for (si
= 1; si
<= maxlength
; ++si
)
6320 nzero_counts
+= counts
[si
] * si
;
6321 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
6322 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
6323 (nzero_counts
* 100.0) / nsyms
);
6331 if (buckets
!= NULL
)
6341 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
6345 if (dynamic_syminfo
== NULL
6347 /* No syminfo, this is ok. */
6350 /* There better should be a dynamic symbol section. */
6351 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
6355 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
6356 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
6358 printf (_(" Num: Name BoundTo Flags\n"));
6359 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
6361 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
6363 printf ("%4d: ", i
);
6364 print_symbol (30, dynamic_strings
+ dynamic_symbols
[i
].st_name
);
6367 switch (dynamic_syminfo
[i
].si_boundto
)
6369 case SYMINFO_BT_SELF
:
6370 fputs ("SELF ", stdout
);
6372 case SYMINFO_BT_PARENT
:
6373 fputs ("PARENT ", stdout
);
6376 if (dynamic_syminfo
[i
].si_boundto
> 0
6377 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
)
6382 [dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
6386 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
6390 if (flags
& SYMINFO_FLG_DIRECT
)
6392 if (flags
& SYMINFO_FLG_PASSTHRU
)
6393 printf (" PASSTHRU");
6394 if (flags
& SYMINFO_FLG_COPY
)
6396 if (flags
& SYMINFO_FLG_LAZYLOAD
)
6397 printf (" LAZYLOAD");
6405 #ifdef SUPPORT_DISASSEMBLY
6407 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
6409 printf (_("\nAssembly dump of section %s\n"),
6410 SECTION_NAME (section
));
6412 /* XXX -- to be done --- XXX */
6419 dump_section (Elf_Internal_Shdr
*section
, FILE *file
)
6421 bfd_size_type bytes
;
6423 unsigned char *data
;
6424 unsigned char *start
;
6426 bytes
= section
->sh_size
;
6428 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
6430 printf (_("\nSection '%s' has no data to dump.\n"),
6431 SECTION_NAME (section
));
6435 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
6437 addr
= section
->sh_addr
;
6439 start
= get_data (NULL
, file
, section
->sh_offset
, bytes
, _("section data"));
6451 lbytes
= (bytes
> 16 ? 16 : bytes
);
6453 printf (" 0x%8.8lx ", (unsigned long) addr
);
6455 switch (elf_header
.e_ident
[EI_DATA
])
6459 for (j
= 15; j
>= 0; j
--)
6462 printf ("%2.2x", data
[j
]);
6472 for (j
= 0; j
< 16; j
++)
6475 printf ("%2.2x", data
[j
]);
6485 for (j
= 0; j
< lbytes
; j
++)
6488 if (k
>= ' ' && k
< 0x7f)
6507 static unsigned long int
6508 read_leb128 (unsigned char *data
, int *length_return
, int sign
)
6510 unsigned long int result
= 0;
6511 unsigned int num_read
= 0;
6520 result
|= (byte
& 0x7f) << shift
;
6525 while (byte
& 0x80);
6527 if (length_return
!= NULL
)
6528 *length_return
= num_read
;
6530 if (sign
&& (shift
< 32) && (byte
& 0x40))
6531 result
|= -1 << shift
;
6536 typedef struct State_Machine_Registers
6538 unsigned long address
;
6541 unsigned int column
;
6545 /* This variable hold the number of the last entry seen
6546 in the File Table. */
6547 unsigned int last_file_entry
;
6550 static SMR state_machine_regs
;
6553 reset_state_machine (int is_stmt
)
6555 state_machine_regs
.address
= 0;
6556 state_machine_regs
.file
= 1;
6557 state_machine_regs
.line
= 1;
6558 state_machine_regs
.column
= 0;
6559 state_machine_regs
.is_stmt
= is_stmt
;
6560 state_machine_regs
.basic_block
= 0;
6561 state_machine_regs
.end_sequence
= 0;
6562 state_machine_regs
.last_file_entry
= 0;
6565 /* Handled an extend line op. Returns true if this is the end
6568 process_extended_line_op (unsigned char *data
, int is_stmt
, int pointer_size
)
6570 unsigned char op_code
;
6573 unsigned char *name
;
6576 len
= read_leb128 (data
, & bytes_read
, 0);
6581 warn (_("badly formed extended line op encountered!\n"));
6588 printf (_(" Extended opcode %d: "), op_code
);
6592 case DW_LNE_end_sequence
:
6593 printf (_("End of Sequence\n\n"));
6594 reset_state_machine (is_stmt
);
6597 case DW_LNE_set_address
:
6598 adr
= byte_get (data
, pointer_size
);
6599 printf (_("set Address to 0x%lx\n"), adr
);
6600 state_machine_regs
.address
= adr
;
6603 case DW_LNE_define_file
:
6604 printf (_(" define new File Table entry\n"));
6605 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6607 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6609 data
+= strlen ((char *) data
) + 1;
6610 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6612 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6614 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6615 printf (_("%s\n\n"), name
);
6619 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
6626 /* Finds section NAME inside FILE and returns a
6627 pointer to it, or NULL upon failure. */
6629 static Elf_Internal_Shdr
*
6630 find_section (const char * name
)
6632 Elf_Internal_Shdr
*sec
;
6635 for (i
= elf_header
.e_shnum
, sec
= section_headers
+ i
- 1;
6637 if (strcmp (SECTION_NAME (sec
), name
) == 0)
6640 if (i
&& sec
&& sec
->sh_size
!= 0)
6646 /* Size of pointers in the .debug_line section. This information is not
6647 really present in that section. It's obtained before dumping the debug
6648 sections by doing some pre-scan of the .debug_info section. */
6649 static unsigned int * debug_line_pointer_sizes
= NULL
;
6650 static unsigned int num_debug_line_pointer_sizes
= 0;
6652 /* Locate and scan the .debug_info section in the file and record the pointer
6653 sizes for the compilation units in it. Usually an executable will have
6654 just one pointer size, but this is not guaranteed, and so we try not to
6655 make any assumptions. Returns zero upon failure, or the number of
6656 compilation units upon success. */
6659 get_debug_line_pointer_sizes (FILE * file
)
6661 Elf_Internal_Shdr
* section
;
6662 unsigned char * start
;
6663 unsigned char * end
;
6664 unsigned char * begin
;
6665 unsigned long length
;
6666 unsigned int num_units
;
6669 section
= find_section (".debug_info");
6670 if (section
== NULL
)
6673 length
= section
->sh_size
;
6674 start
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
6675 _("extracting pointer sizes from .debug_info section"));
6679 end
= start
+ section
->sh_size
;
6680 /* First scan the section to get the number of comp units. */
6681 for (begin
= start
, num_units
= 0; begin
< end
; num_units
++)
6683 /* Read the first 4 bytes. For a 32-bit DWARF section, this will
6684 be the length. For a 64-bit DWARF section, it'll be the escape
6685 code 0xffffffff followed by an 8 byte length. */
6686 length
= byte_get (begin
, 4);
6688 if (length
== 0xffffffff)
6690 length
= byte_get (begin
+ 4, 8);
6691 begin
+= length
+ 12;
6694 begin
+= length
+ 4;
6699 error (_("No comp units in .debug_info section ?"));
6704 /* Then allocate an array to hold the pointer sizes. */
6705 debug_line_pointer_sizes
= malloc (num_units
* sizeof * debug_line_pointer_sizes
);
6706 if (debug_line_pointer_sizes
== NULL
)
6708 error (_("Not enough memory for a pointer size array of %u entries"),
6714 /* Populate the array. */
6715 for (begin
= start
, unit
= 0; begin
< end
; unit
++)
6717 length
= byte_get (begin
, 4);
6718 if (length
== 0xffffffff)
6720 /* For 64-bit DWARF, the 1-byte address_size field is 22 bytes
6721 from the start of the section. This is computed as follows:
6723 unit_length: 12 bytes
6725 debug_abbrev_offset: 8 bytes
6726 -----------------------------
6729 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 22, 1);
6730 length
= byte_get (begin
+ 4, 8);
6731 begin
+= length
+ 12;
6735 /* For 32-bit DWARF, the 1-byte address_size field is 10 bytes from
6736 the start of the section:
6738 unit_length: 4 bytes
6740 debug_abbrev_offset: 4 bytes
6741 -----------------------------
6744 debug_line_pointer_sizes
[unit
] = byte_get (begin
+ 10, 1);
6745 begin
+= length
+ 4;
6750 num_debug_line_pointer_sizes
= num_units
;
6755 display_debug_lines (Elf_Internal_Shdr
*section
,
6756 unsigned char *start
, FILE *file
)
6758 unsigned char *hdrptr
;
6759 DWARF2_Internal_LineInfo info
;
6760 unsigned char *standard_opcodes
;
6761 unsigned char *data
= start
;
6762 unsigned char *end
= start
+ section
->sh_size
;
6763 unsigned char *end_of_sequence
;
6766 int initial_length_size
;
6767 unsigned int comp_unit
= 0;
6769 printf (_("\nDump of debug contents of section %s:\n\n"),
6770 SECTION_NAME (section
));
6772 if (num_debug_line_pointer_sizes
== 0)
6773 get_debug_line_pointer_sizes (file
);
6777 unsigned int pointer_size
;
6781 /* Check the length of the block. */
6782 info
.li_length
= byte_get (hdrptr
, 4);
6785 if (info
.li_length
== 0xffffffff)
6787 /* This section is 64-bit DWARF 3. */
6788 info
.li_length
= byte_get (hdrptr
, 8);
6791 initial_length_size
= 12;
6796 initial_length_size
= 4;
6799 if (info
.li_length
+ initial_length_size
> section
->sh_size
)
6802 (_("The line info appears to be corrupt - the section is too small\n"));
6806 /* Check its version number. */
6807 info
.li_version
= byte_get (hdrptr
, 2);
6809 if (info
.li_version
!= 2 && info
.li_version
!= 3)
6811 warn (_("Only DWARF version 2 and 3 line info is currently supported.\n"));
6815 info
.li_prologue_length
= byte_get (hdrptr
, offset_size
);
6816 hdrptr
+= offset_size
;
6817 info
.li_min_insn_length
= byte_get (hdrptr
, 1);
6819 info
.li_default_is_stmt
= byte_get (hdrptr
, 1);
6821 info
.li_line_base
= byte_get (hdrptr
, 1);
6823 info
.li_line_range
= byte_get (hdrptr
, 1);
6825 info
.li_opcode_base
= byte_get (hdrptr
, 1);
6828 /* Sign extend the line base field. */
6829 info
.li_line_base
<<= 24;
6830 info
.li_line_base
>>= 24;
6832 /* Get the pointer size from the comp unit associated
6833 with this block of line number information. */
6834 if (comp_unit
>= num_debug_line_pointer_sizes
)
6836 error (_("Not enough comp units for .debug_lines section\n"));
6841 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
6845 printf (_(" Length: %ld\n"), info
.li_length
);
6846 printf (_(" DWARF Version: %d\n"), info
.li_version
);
6847 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
6848 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
6849 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
6850 printf (_(" Line Base: %d\n"), info
.li_line_base
);
6851 printf (_(" Line Range: %d\n"), info
.li_line_range
);
6852 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
6853 printf (_(" (Pointer size: %u)\n"), pointer_size
);
6855 end_of_sequence
= data
+ info
.li_length
+ initial_length_size
;
6857 reset_state_machine (info
.li_default_is_stmt
);
6859 /* Display the contents of the Opcodes table. */
6860 standard_opcodes
= hdrptr
;
6862 printf (_("\n Opcodes:\n"));
6864 for (i
= 1; i
< info
.li_opcode_base
; i
++)
6865 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
6867 /* Display the contents of the Directory table. */
6868 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
6871 printf (_("\n The Directory Table is empty.\n"));
6874 printf (_("\n The Directory Table:\n"));
6878 printf (_(" %s\n"), data
);
6880 data
+= strlen ((char *) data
) + 1;
6884 /* Skip the NUL at the end of the table. */
6887 /* Display the contents of the File Name table. */
6889 printf (_("\n The File Name Table is empty.\n"));
6892 printf (_("\n The File Name Table:\n"));
6893 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
6897 unsigned char *name
;
6900 printf (_(" %d\t"), ++state_machine_regs
.last_file_entry
);
6903 data
+= strlen ((char *) data
) + 1;
6905 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6907 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6909 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
6911 printf (_("%s\n"), name
);
6915 /* Skip the NUL at the end of the table. */
6918 /* Now display the statements. */
6919 printf (_("\n Line Number Statements:\n"));
6922 while (data
< end_of_sequence
)
6924 unsigned char op_code
;
6930 if (op_code
>= info
.li_opcode_base
)
6932 op_code
-= info
.li_opcode_base
;
6933 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
6934 state_machine_regs
.address
+= adv
;
6935 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
6936 op_code
, adv
, state_machine_regs
.address
);
6937 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
6938 state_machine_regs
.line
+= adv
;
6939 printf (_(" and Line by %d to %d\n"),
6940 adv
, state_machine_regs
.line
);
6942 else switch (op_code
)
6944 case DW_LNS_extended_op
:
6945 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
6950 printf (_(" Copy\n"));
6953 case DW_LNS_advance_pc
:
6954 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
6956 state_machine_regs
.address
+= adv
;
6957 printf (_(" Advance PC by %d to %lx\n"), adv
,
6958 state_machine_regs
.address
);
6961 case DW_LNS_advance_line
:
6962 adv
= read_leb128 (data
, & bytes_read
, 1);
6964 state_machine_regs
.line
+= adv
;
6965 printf (_(" Advance Line by %d to %d\n"), adv
,
6966 state_machine_regs
.line
);
6969 case DW_LNS_set_file
:
6970 adv
= read_leb128 (data
, & bytes_read
, 0);
6972 printf (_(" Set File Name to entry %d in the File Name Table\n"),
6974 state_machine_regs
.file
= adv
;
6977 case DW_LNS_set_column
:
6978 adv
= read_leb128 (data
, & bytes_read
, 0);
6980 printf (_(" Set column to %d\n"), adv
);
6981 state_machine_regs
.column
= adv
;
6984 case DW_LNS_negate_stmt
:
6985 adv
= state_machine_regs
.is_stmt
;
6987 printf (_(" Set is_stmt to %d\n"), adv
);
6988 state_machine_regs
.is_stmt
= adv
;
6991 case DW_LNS_set_basic_block
:
6992 printf (_(" Set basic block\n"));
6993 state_machine_regs
.basic_block
= 1;
6996 case DW_LNS_const_add_pc
:
6997 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
6998 * info
.li_min_insn_length
);
6999 state_machine_regs
.address
+= adv
;
7000 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
7001 state_machine_regs
.address
);
7004 case DW_LNS_fixed_advance_pc
:
7005 adv
= byte_get (data
, 2);
7007 state_machine_regs
.address
+= adv
;
7008 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
7009 adv
, state_machine_regs
.address
);
7012 case DW_LNS_set_prologue_end
:
7013 printf (_(" Set prologue_end to true\n"));
7016 case DW_LNS_set_epilogue_begin
:
7017 printf (_(" Set epilogue_begin to true\n"));
7020 case DW_LNS_set_isa
:
7021 adv
= read_leb128 (data
, & bytes_read
, 0);
7023 printf (_(" Set ISA to %d\n"), adv
);
7027 printf (_(" Unknown opcode %d with operands: "), op_code
);
7030 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
7032 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
7033 i
== 1 ? "" : ", ");
7048 display_debug_pubnames (Elf_Internal_Shdr
*section
,
7049 unsigned char *start
,
7050 FILE *file ATTRIBUTE_UNUSED
)
7052 DWARF2_Internal_PubNames pubnames
;
7055 end
= start
+ section
->sh_size
;
7057 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7061 unsigned char *data
;
7062 unsigned long offset
;
7063 int offset_size
, initial_length_size
;
7067 pubnames
.pn_length
= byte_get (data
, 4);
7069 if (pubnames
.pn_length
== 0xffffffff)
7071 pubnames
.pn_length
= byte_get (data
, 8);
7074 initial_length_size
= 12;
7079 initial_length_size
= 4;
7082 pubnames
.pn_version
= byte_get (data
, 2);
7084 pubnames
.pn_offset
= byte_get (data
, offset_size
);
7085 data
+= offset_size
;
7086 pubnames
.pn_size
= byte_get (data
, offset_size
);
7087 data
+= offset_size
;
7089 start
+= pubnames
.pn_length
+ initial_length_size
;
7091 if (pubnames
.pn_version
!= 2 && pubnames
.pn_version
!= 3)
7093 static int warned
= 0;
7097 warn (_("Only DWARF 2 and 3 pubnames are currently supported\n"));
7104 printf (_(" Length: %ld\n"),
7105 pubnames
.pn_length
);
7106 printf (_(" Version: %d\n"),
7107 pubnames
.pn_version
);
7108 printf (_(" Offset into .debug_info section: %ld\n"),
7109 pubnames
.pn_offset
);
7110 printf (_(" Size of area in .debug_info section: %ld\n"),
7113 printf (_("\n Offset\tName\n"));
7117 offset
= byte_get (data
, offset_size
);
7121 data
+= offset_size
;
7122 printf (" %-6ld\t\t%s\n", offset
, data
);
7123 data
+= strlen ((char *) data
) + 1;
7126 while (offset
!= 0);
7134 get_TAG_name (unsigned long tag
)
7138 case DW_TAG_padding
: return "DW_TAG_padding";
7139 case DW_TAG_array_type
: return "DW_TAG_array_type";
7140 case DW_TAG_class_type
: return "DW_TAG_class_type";
7141 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
7142 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
7143 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
7144 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
7145 case DW_TAG_label
: return "DW_TAG_label";
7146 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
7147 case DW_TAG_member
: return "DW_TAG_member";
7148 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
7149 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
7150 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
7151 case DW_TAG_string_type
: return "DW_TAG_string_type";
7152 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
7153 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
7154 case DW_TAG_typedef
: return "DW_TAG_typedef";
7155 case DW_TAG_union_type
: return "DW_TAG_union_type";
7156 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
7157 case DW_TAG_variant
: return "DW_TAG_variant";
7158 case DW_TAG_common_block
: return "DW_TAG_common_block";
7159 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
7160 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
7161 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
7162 case DW_TAG_module
: return "DW_TAG_module";
7163 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
7164 case DW_TAG_set_type
: return "DW_TAG_set_type";
7165 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
7166 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
7167 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
7168 case DW_TAG_base_type
: return "DW_TAG_base_type";
7169 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
7170 case DW_TAG_const_type
: return "DW_TAG_const_type";
7171 case DW_TAG_constant
: return "DW_TAG_constant";
7172 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
7173 case DW_TAG_file_type
: return "DW_TAG_file_type";
7174 case DW_TAG_friend
: return "DW_TAG_friend";
7175 case DW_TAG_namelist
: return "DW_TAG_namelist";
7176 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
7177 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
7178 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
7179 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
7180 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
7181 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
7182 case DW_TAG_try_block
: return "DW_TAG_try_block";
7183 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
7184 case DW_TAG_variable
: return "DW_TAG_variable";
7185 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
7186 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
7187 case DW_TAG_format_label
: return "DW_TAG_format_label";
7188 case DW_TAG_function_template
: return "DW_TAG_function_template";
7189 case DW_TAG_class_template
: return "DW_TAG_class_template";
7190 /* DWARF 2.1 values. */
7191 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
7192 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
7193 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
7194 case DW_TAG_namespace
: return "DW_TAG_namespace";
7195 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
7196 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
7197 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
7198 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
7200 case DW_TAG_upc_shared_type
: return "DW_TAG_upc_shared_type";
7201 case DW_TAG_upc_strict_type
: return "DW_TAG_upc_strict_type";
7202 case DW_TAG_upc_relaxed_type
: return "DW_TAG_upc_relaxed_type";
7205 static char buffer
[100];
7207 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
7214 get_AT_name (unsigned long attribute
)
7218 case DW_AT_sibling
: return "DW_AT_sibling";
7219 case DW_AT_location
: return "DW_AT_location";
7220 case DW_AT_name
: return "DW_AT_name";
7221 case DW_AT_ordering
: return "DW_AT_ordering";
7222 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
7223 case DW_AT_byte_size
: return "DW_AT_byte_size";
7224 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
7225 case DW_AT_bit_size
: return "DW_AT_bit_size";
7226 case DW_AT_element_list
: return "DW_AT_element_list";
7227 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
7228 case DW_AT_low_pc
: return "DW_AT_low_pc";
7229 case DW_AT_high_pc
: return "DW_AT_high_pc";
7230 case DW_AT_language
: return "DW_AT_language";
7231 case DW_AT_member
: return "DW_AT_member";
7232 case DW_AT_discr
: return "DW_AT_discr";
7233 case DW_AT_discr_value
: return "DW_AT_discr_value";
7234 case DW_AT_visibility
: return "DW_AT_visibility";
7235 case DW_AT_import
: return "DW_AT_import";
7236 case DW_AT_string_length
: return "DW_AT_string_length";
7237 case DW_AT_common_reference
: return "DW_AT_common_reference";
7238 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
7239 case DW_AT_const_value
: return "DW_AT_const_value";
7240 case DW_AT_containing_type
: return "DW_AT_containing_type";
7241 case DW_AT_default_value
: return "DW_AT_default_value";
7242 case DW_AT_inline
: return "DW_AT_inline";
7243 case DW_AT_is_optional
: return "DW_AT_is_optional";
7244 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
7245 case DW_AT_producer
: return "DW_AT_producer";
7246 case DW_AT_prototyped
: return "DW_AT_prototyped";
7247 case DW_AT_return_addr
: return "DW_AT_return_addr";
7248 case DW_AT_start_scope
: return "DW_AT_start_scope";
7249 case DW_AT_stride_size
: return "DW_AT_stride_size";
7250 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
7251 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
7252 case DW_AT_accessibility
: return "DW_AT_accessibility";
7253 case DW_AT_address_class
: return "DW_AT_address_class";
7254 case DW_AT_artificial
: return "DW_AT_artificial";
7255 case DW_AT_base_types
: return "DW_AT_base_types";
7256 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
7257 case DW_AT_count
: return "DW_AT_count";
7258 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
7259 case DW_AT_decl_column
: return "DW_AT_decl_column";
7260 case DW_AT_decl_file
: return "DW_AT_decl_file";
7261 case DW_AT_decl_line
: return "DW_AT_decl_line";
7262 case DW_AT_declaration
: return "DW_AT_declaration";
7263 case DW_AT_discr_list
: return "DW_AT_discr_list";
7264 case DW_AT_encoding
: return "DW_AT_encoding";
7265 case DW_AT_external
: return "DW_AT_external";
7266 case DW_AT_frame_base
: return "DW_AT_frame_base";
7267 case DW_AT_friend
: return "DW_AT_friend";
7268 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
7269 case DW_AT_macro_info
: return "DW_AT_macro_info";
7270 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
7271 case DW_AT_priority
: return "DW_AT_priority";
7272 case DW_AT_segment
: return "DW_AT_segment";
7273 case DW_AT_specification
: return "DW_AT_specification";
7274 case DW_AT_static_link
: return "DW_AT_static_link";
7275 case DW_AT_type
: return "DW_AT_type";
7276 case DW_AT_use_location
: return "DW_AT_use_location";
7277 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
7278 case DW_AT_virtuality
: return "DW_AT_virtuality";
7279 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
7280 /* DWARF 2.1 values. */
7281 case DW_AT_allocated
: return "DW_AT_allocated";
7282 case DW_AT_associated
: return "DW_AT_associated";
7283 case DW_AT_data_location
: return "DW_AT_data_location";
7284 case DW_AT_stride
: return "DW_AT_stride";
7285 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
7286 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
7287 case DW_AT_extension
: return "DW_AT_extension";
7288 case DW_AT_ranges
: return "DW_AT_ranges";
7289 case DW_AT_trampoline
: return "DW_AT_trampoline";
7290 case DW_AT_call_column
: return "DW_AT_call_column";
7291 case DW_AT_call_file
: return "DW_AT_call_file";
7292 case DW_AT_call_line
: return "DW_AT_call_line";
7293 /* SGI/MIPS extensions. */
7294 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
7295 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
7296 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
7297 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
7298 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
7299 case DW_AT_MIPS_software_pipeline_depth
:
7300 return "DW_AT_MIPS_software_pipeline_depth";
7301 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
7302 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
7303 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
7304 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
7305 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
7306 /* GNU extensions. */
7307 case DW_AT_sf_names
: return "DW_AT_sf_names";
7308 case DW_AT_src_info
: return "DW_AT_src_info";
7309 case DW_AT_mac_info
: return "DW_AT_mac_info";
7310 case DW_AT_src_coords
: return "DW_AT_src_coords";
7311 case DW_AT_body_begin
: return "DW_AT_body_begin";
7312 case DW_AT_body_end
: return "DW_AT_body_end";
7313 case DW_AT_GNU_vector
: return "DW_AT_GNU_vector";
7314 /* UPC extension. */
7315 case DW_AT_upc_threads_scaled
: return "DW_AT_upc_threads_scaled";
7318 static char buffer
[100];
7320 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
7327 get_FORM_name (unsigned long form
)
7331 case DW_FORM_addr
: return "DW_FORM_addr";
7332 case DW_FORM_block2
: return "DW_FORM_block2";
7333 case DW_FORM_block4
: return "DW_FORM_block4";
7334 case DW_FORM_data2
: return "DW_FORM_data2";
7335 case DW_FORM_data4
: return "DW_FORM_data4";
7336 case DW_FORM_data8
: return "DW_FORM_data8";
7337 case DW_FORM_string
: return "DW_FORM_string";
7338 case DW_FORM_block
: return "DW_FORM_block";
7339 case DW_FORM_block1
: return "DW_FORM_block1";
7340 case DW_FORM_data1
: return "DW_FORM_data1";
7341 case DW_FORM_flag
: return "DW_FORM_flag";
7342 case DW_FORM_sdata
: return "DW_FORM_sdata";
7343 case DW_FORM_strp
: return "DW_FORM_strp";
7344 case DW_FORM_udata
: return "DW_FORM_udata";
7345 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
7346 case DW_FORM_ref1
: return "DW_FORM_ref1";
7347 case DW_FORM_ref2
: return "DW_FORM_ref2";
7348 case DW_FORM_ref4
: return "DW_FORM_ref4";
7349 case DW_FORM_ref8
: return "DW_FORM_ref8";
7350 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
7351 case DW_FORM_indirect
: return "DW_FORM_indirect";
7354 static char buffer
[100];
7356 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
7362 /* FIXME: There are better and more efficient ways to handle
7363 these structures. For now though, I just want something that
7364 is simple to implement. */
7365 typedef struct abbrev_attr
7367 unsigned long attribute
;
7369 struct abbrev_attr
*next
;
7373 typedef struct abbrev_entry
7375 unsigned long entry
;
7378 struct abbrev_attr
*first_attr
;
7379 struct abbrev_attr
*last_attr
;
7380 struct abbrev_entry
*next
;
7384 static abbrev_entry
*first_abbrev
= NULL
;
7385 static abbrev_entry
*last_abbrev
= NULL
;
7390 abbrev_entry
*abbrev
;
7392 for (abbrev
= first_abbrev
; abbrev
;)
7394 abbrev_entry
*next
= abbrev
->next
;
7397 for (attr
= abbrev
->first_attr
; attr
;)
7399 abbrev_attr
*next
= attr
->next
;
7409 last_abbrev
= first_abbrev
= NULL
;
7413 add_abbrev (unsigned long number
, unsigned long tag
, int children
)
7415 abbrev_entry
*entry
;
7417 entry
= malloc (sizeof (*entry
));
7423 entry
->entry
= number
;
7425 entry
->children
= children
;
7426 entry
->first_attr
= NULL
;
7427 entry
->last_attr
= NULL
;
7430 if (first_abbrev
== NULL
)
7431 first_abbrev
= entry
;
7433 last_abbrev
->next
= entry
;
7435 last_abbrev
= entry
;
7439 add_abbrev_attr (unsigned long attribute
, unsigned long form
)
7443 attr
= malloc (sizeof (*attr
));
7449 attr
->attribute
= attribute
;
7453 if (last_abbrev
->first_attr
== NULL
)
7454 last_abbrev
->first_attr
= attr
;
7456 last_abbrev
->last_attr
->next
= attr
;
7458 last_abbrev
->last_attr
= attr
;
7461 /* Processes the (partial) contents of a .debug_abbrev section.
7462 Returns NULL if the end of the section was encountered.
7463 Returns the address after the last byte read if the end of
7464 an abbreviation set was found. */
7466 static unsigned char *
7467 process_abbrev_section (unsigned char *start
, unsigned char *end
)
7469 if (first_abbrev
!= NULL
)
7475 unsigned long entry
;
7477 unsigned long attribute
;
7480 entry
= read_leb128 (start
, & bytes_read
, 0);
7481 start
+= bytes_read
;
7483 /* A single zero is supposed to end the section according
7484 to the standard. If there's more, then signal that to
7487 return start
== end
? NULL
: start
;
7489 tag
= read_leb128 (start
, & bytes_read
, 0);
7490 start
+= bytes_read
;
7492 children
= *start
++;
7494 add_abbrev (entry
, tag
, children
);
7500 attribute
= read_leb128 (start
, & bytes_read
, 0);
7501 start
+= bytes_read
;
7503 form
= read_leb128 (start
, & bytes_read
, 0);
7504 start
+= bytes_read
;
7507 add_abbrev_attr (attribute
, form
);
7509 while (attribute
!= 0);
7517 display_debug_macinfo (Elf_Internal_Shdr
*section
,
7518 unsigned char *start
,
7519 FILE *file ATTRIBUTE_UNUSED
)
7521 unsigned char *end
= start
+ section
->sh_size
;
7522 unsigned char *curr
= start
;
7523 unsigned int bytes_read
;
7524 enum dwarf_macinfo_record_type op
;
7526 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7530 unsigned int lineno
;
7538 case DW_MACINFO_start_file
:
7540 unsigned int filenum
;
7542 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7544 filenum
= read_leb128 (curr
, & bytes_read
, 0);
7547 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
7551 case DW_MACINFO_end_file
:
7552 printf (_(" DW_MACINFO_end_file\n"));
7555 case DW_MACINFO_define
:
7556 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7559 curr
+= strlen (string
) + 1;
7560 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
7563 case DW_MACINFO_undef
:
7564 lineno
= read_leb128 (curr
, & bytes_read
, 0);
7567 curr
+= strlen (string
) + 1;
7568 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
7571 case DW_MACINFO_vendor_ext
:
7573 unsigned int constant
;
7575 constant
= read_leb128 (curr
, & bytes_read
, 0);
7578 curr
+= strlen (string
) + 1;
7579 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
7590 display_debug_abbrev (Elf_Internal_Shdr
*section
,
7591 unsigned char *start
,
7592 FILE *file ATTRIBUTE_UNUSED
)
7594 abbrev_entry
*entry
;
7595 unsigned char *end
= start
+ section
->sh_size
;
7597 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
7601 start
= process_abbrev_section (start
, end
);
7603 if (first_abbrev
== NULL
)
7606 printf (_(" Number TAG\n"));
7608 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
7612 printf (_(" %ld %s [%s]\n"),
7614 get_TAG_name (entry
->tag
),
7615 entry
->children
? _("has children") : _("no children"));
7617 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7619 printf (_(" %-18s %s\n"),
7620 get_AT_name (attr
->attribute
),
7621 get_FORM_name (attr
->form
));
7635 static unsigned char *
7636 display_block (unsigned char *data
, unsigned long length
)
7638 printf (_(" %lu byte block: "), length
);
7641 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
7647 decode_location_expression (unsigned char * data
,
7648 unsigned int pointer_size
,
7649 unsigned long length
)
7653 unsigned long uvalue
;
7654 unsigned char *end
= data
+ length
;
7663 printf ("DW_OP_addr: %lx",
7664 (unsigned long) byte_get (data
, pointer_size
));
7665 data
+= pointer_size
;
7668 printf ("DW_OP_deref");
7671 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
7674 printf ("DW_OP_const1s: %ld", (long) byte_get_signed (data
++, 1));
7677 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
7681 printf ("DW_OP_const2s: %ld", (long) byte_get_signed (data
, 2));
7685 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
7689 printf ("DW_OP_const4s: %ld", (long) byte_get_signed (data
, 4));
7693 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
7694 (unsigned long) byte_get (data
+ 4, 4));
7698 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
7699 (long) byte_get (data
+ 4, 4));
7703 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
7707 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
7711 printf ("DW_OP_dup");
7714 printf ("DW_OP_drop");
7717 printf ("DW_OP_over");
7720 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
7723 printf ("DW_OP_swap");
7726 printf ("DW_OP_rot");
7729 printf ("DW_OP_xderef");
7732 printf ("DW_OP_abs");
7735 printf ("DW_OP_and");
7738 printf ("DW_OP_div");
7741 printf ("DW_OP_minus");
7744 printf ("DW_OP_mod");
7747 printf ("DW_OP_mul");
7750 printf ("DW_OP_neg");
7753 printf ("DW_OP_not");
7756 printf ("DW_OP_or");
7759 printf ("DW_OP_plus");
7761 case DW_OP_plus_uconst
:
7762 printf ("DW_OP_plus_uconst: %lu",
7763 read_leb128 (data
, &bytes_read
, 0));
7767 printf ("DW_OP_shl");
7770 printf ("DW_OP_shr");
7773 printf ("DW_OP_shra");
7776 printf ("DW_OP_xor");
7779 printf ("DW_OP_bra: %ld", (long) byte_get_signed (data
, 2));
7783 printf ("DW_OP_eq");
7786 printf ("DW_OP_ge");
7789 printf ("DW_OP_gt");
7792 printf ("DW_OP_le");
7795 printf ("DW_OP_lt");
7798 printf ("DW_OP_ne");
7801 printf ("DW_OP_skip: %ld", (long) byte_get_signed (data
, 2));
7837 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
7872 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
7907 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
7908 read_leb128 (data
, &bytes_read
, 1));
7913 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
7917 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
7921 uvalue
= read_leb128 (data
, &bytes_read
, 0);
7923 printf ("DW_OP_bregx: %lu %ld", uvalue
,
7924 read_leb128 (data
, &bytes_read
, 1));
7928 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
7931 case DW_OP_deref_size
:
7932 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
7934 case DW_OP_xderef_size
:
7935 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
7938 printf ("DW_OP_nop");
7941 /* DWARF 3 extensions. */
7942 case DW_OP_push_object_address
:
7943 printf ("DW_OP_push_object_address");
7946 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
7950 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
7953 case DW_OP_call_ref
:
7954 printf ("DW_OP_call_ref");
7957 /* GNU extensions. */
7958 case DW_OP_GNU_push_tls_address
:
7959 printf ("DW_OP_GNU_push_tls_address");
7963 if (op
>= DW_OP_lo_user
7964 && op
<= DW_OP_hi_user
)
7965 printf (_("(User defined location op)"));
7967 printf (_("(Unknown location op)"));
7968 /* No way to tell where the next op is, so just bail. */
7972 /* Separate the ops. */
7978 static const char *debug_loc_contents
;
7979 static bfd_vma debug_loc_size
;
7982 load_debug_loc (FILE *file
)
7984 Elf_Internal_Shdr
*sec
;
7986 /* If it is already loaded, do nothing. */
7987 if (debug_loc_contents
!= NULL
)
7990 /* Locate the .debug_loc section. */
7991 sec
= find_section (".debug_loc");
7995 debug_loc_size
= sec
->sh_size
;
7997 debug_loc_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7998 _("debug_loc section data"));
8002 free_debug_loc (void)
8004 if (debug_loc_contents
== NULL
)
8007 free ((char *) debug_loc_contents
);
8008 debug_loc_contents
= NULL
;
8014 display_debug_loc (Elf_Internal_Shdr
*section
,
8015 unsigned char *start
, FILE *file
)
8017 unsigned char *section_end
;
8018 unsigned long bytes
;
8019 unsigned char *section_begin
= start
;
8021 unsigned int comp_unit
= 0;
8023 addr
= section
->sh_addr
;
8024 bytes
= section
->sh_size
;
8025 section_end
= start
+ bytes
;
8029 printf (_("\nThe .debug_loc section is empty.\n"));
8033 if (num_debug_line_pointer_sizes
== 0)
8034 get_debug_line_pointer_sizes (file
);
8036 printf (_("Contents of the .debug_loc section:\n\n"));
8037 printf (_("\n Offset Begin End Expression\n"));
8039 while (start
< section_end
)
8041 unsigned long begin
;
8043 unsigned short length
;
8044 unsigned long offset
;
8045 unsigned int pointer_size
;
8047 offset
= start
- section_begin
;
8049 /* Get the pointer size from the comp unit associated
8050 with this block of location information. */
8051 if (comp_unit
>= num_debug_line_pointer_sizes
)
8053 error (_("Not enough comp units for .debug_loc section\n"));
8058 pointer_size
= debug_line_pointer_sizes
[comp_unit
];
8064 begin
= byte_get (start
, pointer_size
);
8065 start
+= pointer_size
;
8066 end
= byte_get (start
, pointer_size
);
8067 start
+= pointer_size
;
8069 if (begin
== 0 && end
== 0)
8072 /* For now, skip any base address specifiers. */
8073 if (begin
== 0xffffffff)
8079 length
= byte_get (start
, 2);
8082 printf (" %8.8lx %8.8lx %8.8lx (", offset
, begin
, end
);
8083 decode_location_expression (start
, pointer_size
, length
);
8093 static const char *debug_str_contents
;
8094 static bfd_vma debug_str_size
;
8097 load_debug_str (FILE *file
)
8099 Elf_Internal_Shdr
*sec
;
8101 /* If it is already loaded, do nothing. */
8102 if (debug_str_contents
!= NULL
)
8105 /* Locate the .debug_str section. */
8106 sec
= find_section (".debug_str");
8110 debug_str_size
= sec
->sh_size
;
8112 debug_str_contents
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8113 _("debug_str section data"));
8117 free_debug_str (void)
8119 if (debug_str_contents
== NULL
)
8122 free ((char *) debug_str_contents
);
8123 debug_str_contents
= NULL
;
8128 fetch_indirect_string (unsigned long offset
)
8130 if (debug_str_contents
== NULL
)
8131 return _("<no .debug_str section>");
8133 if (offset
> debug_str_size
)
8134 return _("<offset is too big>");
8136 return debug_str_contents
+ offset
;
8140 display_debug_str (Elf_Internal_Shdr
*section
,
8141 unsigned char *start
,
8142 FILE *file ATTRIBUTE_UNUSED
)
8144 unsigned long bytes
;
8147 addr
= section
->sh_addr
;
8148 bytes
= section
->sh_size
;
8152 printf (_("\nThe .debug_str section is empty.\n"));
8156 printf (_("Contents of the .debug_str section:\n\n"));
8164 lbytes
= (bytes
> 16 ? 16 : bytes
);
8166 printf (" 0x%8.8lx ", (unsigned long) addr
);
8168 for (j
= 0; j
< 16; j
++)
8171 printf ("%2.2x", start
[j
]);
8179 for (j
= 0; j
< lbytes
; j
++)
8182 if (k
>= ' ' && k
< 0x80)
8198 static unsigned char *
8199 read_and_display_attr_value (unsigned long attribute
,
8201 unsigned char *data
,
8202 unsigned long cu_offset
,
8203 unsigned long pointer_size
,
8204 unsigned long offset_size
,
8207 unsigned long uvalue
= 0;
8208 unsigned char *block_start
= NULL
;
8216 case DW_FORM_ref_addr
:
8217 if (dwarf_version
== 2)
8219 uvalue
= byte_get (data
, pointer_size
);
8220 data
+= pointer_size
;
8222 else if (dwarf_version
== 3)
8224 uvalue
= byte_get (data
, offset_size
);
8225 data
+= offset_size
;
8229 error (_("Internal error: DWARF version is not 2 or 3.\n"));
8234 uvalue
= byte_get (data
, pointer_size
);
8235 data
+= pointer_size
;
8239 uvalue
= byte_get (data
, offset_size
);
8240 data
+= offset_size
;
8246 uvalue
= byte_get (data
++, 1);
8251 uvalue
= byte_get (data
, 2);
8257 uvalue
= byte_get (data
, 4);
8262 uvalue
= read_leb128 (data
, & bytes_read
, 1);
8266 case DW_FORM_ref_udata
:
8268 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8272 case DW_FORM_indirect
:
8273 form
= read_leb128 (data
, & bytes_read
, 0);
8275 printf (" %s", get_FORM_name (form
));
8276 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8277 pointer_size
, offset_size
,
8283 case DW_FORM_ref_addr
:
8284 printf (" <#%lx>", uvalue
);
8290 case DW_FORM_ref_udata
:
8291 printf (" <%lx>", uvalue
+ cu_offset
);
8295 printf (" %#lx", uvalue
);
8304 printf (" %ld", uvalue
);
8309 uvalue
= byte_get (data
, 4);
8310 printf (" %lx", uvalue
);
8311 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
8315 case DW_FORM_string
:
8316 printf (" %s", data
);
8317 data
+= strlen ((char *) data
) + 1;
8321 uvalue
= read_leb128 (data
, & bytes_read
, 0);
8322 block_start
= data
+ bytes_read
;
8323 data
= display_block (block_start
, uvalue
);
8326 case DW_FORM_block1
:
8327 uvalue
= byte_get (data
, 1);
8328 block_start
= data
+ 1;
8329 data
= display_block (block_start
, uvalue
);
8332 case DW_FORM_block2
:
8333 uvalue
= byte_get (data
, 2);
8334 block_start
= data
+ 2;
8335 data
= display_block (block_start
, uvalue
);
8338 case DW_FORM_block4
:
8339 uvalue
= byte_get (data
, 4);
8340 block_start
= data
+ 4;
8341 data
= display_block (block_start
, uvalue
);
8345 printf (_(" (indirect string, offset: 0x%lx): %s"),
8346 uvalue
, fetch_indirect_string (uvalue
));
8349 case DW_FORM_indirect
:
8350 /* Handled above. */
8354 warn (_("Unrecognized form: %d\n"), form
);
8358 /* For some attributes we can display further information. */
8367 case DW_INL_not_inlined
:
8368 printf (_("(not inlined)"));
8370 case DW_INL_inlined
:
8371 printf (_("(inlined)"));
8373 case DW_INL_declared_not_inlined
:
8374 printf (_("(declared as inline but ignored)"));
8376 case DW_INL_declared_inlined
:
8377 printf (_("(declared as inline and inlined)"));
8380 printf (_(" (Unknown inline attribute value: %lx)"), uvalue
);
8385 case DW_AT_language
:
8388 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
8389 case DW_LANG_C89
: printf ("(ANSI C)"); break;
8390 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
8391 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
8392 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
8393 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
8394 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
8395 case DW_LANG_Ada83
: printf ("(Ada)"); break;
8396 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
8397 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
8398 /* DWARF 2.1 values. */
8399 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
8400 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
8401 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
8402 /* MIPS extension. */
8403 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
8404 /* UPC extension. */
8405 case DW_LANG_Upc
: printf ("(Unified Parallel C)"); break;
8407 printf ("(Unknown: %lx)", uvalue
);
8412 case DW_AT_encoding
:
8415 case DW_ATE_void
: printf ("(void)"); break;
8416 case DW_ATE_address
: printf ("(machine address)"); break;
8417 case DW_ATE_boolean
: printf ("(boolean)"); break;
8418 case DW_ATE_complex_float
: printf ("(complex float)"); break;
8419 case DW_ATE_float
: printf ("(float)"); break;
8420 case DW_ATE_signed
: printf ("(signed)"); break;
8421 case DW_ATE_signed_char
: printf ("(signed char)"); break;
8422 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
8423 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
8424 /* DWARF 2.1 value. */
8425 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
8427 if (uvalue
>= DW_ATE_lo_user
8428 && uvalue
<= DW_ATE_hi_user
)
8429 printf ("(user defined type)");
8431 printf ("(unknown type)");
8436 case DW_AT_accessibility
:
8439 case DW_ACCESS_public
: printf ("(public)"); break;
8440 case DW_ACCESS_protected
: printf ("(protected)"); break;
8441 case DW_ACCESS_private
: printf ("(private)"); break;
8443 printf ("(unknown accessibility)");
8448 case DW_AT_visibility
:
8451 case DW_VIS_local
: printf ("(local)"); break;
8452 case DW_VIS_exported
: printf ("(exported)"); break;
8453 case DW_VIS_qualified
: printf ("(qualified)"); break;
8454 default: printf ("(unknown visibility)"); break;
8458 case DW_AT_virtuality
:
8461 case DW_VIRTUALITY_none
: printf ("(none)"); break;
8462 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
8463 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
8464 default: printf ("(unknown virtuality)"); break;
8468 case DW_AT_identifier_case
:
8471 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
8472 case DW_ID_up_case
: printf ("(up_case)"); break;
8473 case DW_ID_down_case
: printf ("(down_case)"); break;
8474 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
8475 default: printf ("(unknown case)"); break;
8479 case DW_AT_calling_convention
:
8482 case DW_CC_normal
: printf ("(normal)"); break;
8483 case DW_CC_program
: printf ("(program)"); break;
8484 case DW_CC_nocall
: printf ("(nocall)"); break;
8486 if (uvalue
>= DW_CC_lo_user
8487 && uvalue
<= DW_CC_hi_user
)
8488 printf ("(user defined)");
8490 printf ("(unknown convention)");
8494 case DW_AT_ordering
:
8497 case -1: printf ("(undefined)"); break;
8498 case 0: printf ("(row major)"); break;
8499 case 1: printf ("(column major)"); break;
8503 case DW_AT_frame_base
:
8504 case DW_AT_location
:
8505 case DW_AT_data_member_location
:
8506 case DW_AT_vtable_elem_location
:
8507 case DW_AT_allocated
:
8508 case DW_AT_associated
:
8509 case DW_AT_data_location
:
8511 case DW_AT_upper_bound
:
8512 case DW_AT_lower_bound
:
8516 decode_location_expression (block_start
, pointer_size
, uvalue
);
8519 else if (form
== DW_FORM_data4
|| form
== DW_FORM_data8
)
8522 printf ("location list");
8534 static unsigned char *
8535 read_and_display_attr (unsigned long attribute
,
8537 unsigned char *data
,
8538 unsigned long cu_offset
,
8539 unsigned long pointer_size
,
8540 unsigned long offset_size
,
8543 printf (" %-18s:", get_AT_name (attribute
));
8544 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
8545 pointer_size
, offset_size
, dwarf_version
);
8550 /* Apply addends of RELA relocations. */
8553 debug_apply_rela_addends (FILE *file
,
8554 Elf_Internal_Shdr
*section
,
8556 unsigned char *sec_data
,
8557 unsigned char *start
,
8560 Elf_Internal_Shdr
*relsec
;
8562 if (end
- start
< reloc_size
)
8565 for (relsec
= section_headers
;
8566 relsec
< section_headers
+ elf_header
.e_shnum
;
8569 unsigned long nrelas
;
8570 Elf_Internal_Rela
*rela
, *rp
;
8571 Elf_Internal_Shdr
*symsec
;
8572 Elf_Internal_Sym
*symtab
;
8573 Elf_Internal_Sym
*sym
;
8575 if (relsec
->sh_type
!= SHT_RELA
8576 || SECTION_HEADER (relsec
->sh_info
) != section
8577 || relsec
->sh_size
== 0)
8580 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8584 symsec
= SECTION_HEADER (relsec
->sh_link
);
8585 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8587 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8591 if (rp
->r_offset
>= (bfd_vma
) (start
- sec_data
)
8592 && rp
->r_offset
< (bfd_vma
) (end
- sec_data
) - reloc_size
)
8593 loc
= sec_data
+ rp
->r_offset
;
8599 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
8601 if (ELF32_R_SYM (rp
->r_info
) != 0
8602 && ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8604 warn (_("Skipping unexpected symbol type %u\n"),
8605 ELF32_ST_TYPE (sym
->st_info
));
8611 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
8613 if (ELF64_R_SYM (rp
->r_info
) != 0
8614 && ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
8616 warn (_("Skipping unexpected symbol type %u\n"),
8617 ELF64_ST_TYPE (sym
->st_info
));
8622 byte_put (loc
, rp
->r_addend
, reloc_size
);
8633 display_debug_info (Elf_Internal_Shdr
*section
,
8634 unsigned char *start
,
8637 unsigned char *end
= start
+ section
->sh_size
;
8638 unsigned char *section_begin
= start
;
8640 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8642 load_debug_str (file
);
8643 load_debug_loc (file
);
8647 DWARF2_Internal_CompUnit compunit
;
8648 unsigned char *hdrptr
;
8649 unsigned char *cu_abbrev_offset_ptr
;
8650 unsigned char *tags
;
8652 unsigned long cu_offset
;
8654 int initial_length_size
;
8658 compunit
.cu_length
= byte_get (hdrptr
, 4);
8661 if (compunit
.cu_length
== 0xffffffff)
8663 compunit
.cu_length
= byte_get (hdrptr
, 8);
8666 initial_length_size
= 12;
8671 initial_length_size
= 4;
8674 compunit
.cu_version
= byte_get (hdrptr
, 2);
8677 cu_offset
= start
- section_begin
;
8678 start
+= compunit
.cu_length
+ initial_length_size
;
8680 if (elf_header
.e_type
== ET_REL
8681 && !debug_apply_rela_addends (file
, section
, offset_size
,
8682 section_begin
, hdrptr
, start
))
8685 cu_abbrev_offset_ptr
= hdrptr
;
8686 compunit
.cu_abbrev_offset
= byte_get (hdrptr
, offset_size
);
8687 hdrptr
+= offset_size
;
8689 compunit
.cu_pointer_size
= byte_get (hdrptr
, 1);
8694 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
8695 printf (_(" Length: %ld\n"), compunit
.cu_length
);
8696 printf (_(" Version: %d\n"), compunit
.cu_version
);
8697 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
8698 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
8700 if (compunit
.cu_version
!= 2 && compunit
.cu_version
!= 3)
8702 warn (_("Only version 2 and 3 DWARF debug information is currently supported.\n"));
8708 /* Read in the abbrevs used by this compilation unit. */
8710 Elf_Internal_Shdr
*sec
;
8711 unsigned char *begin
;
8713 /* Locate the .debug_abbrev section and process it. */
8714 sec
= find_section (".debug_abbrev");
8717 warn (_("Unable to locate .debug_abbrev section!\n"));
8721 begin
= get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
8722 _("debug_abbrev section data"));
8726 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
8727 begin
+ sec
->sh_size
);
8733 while (tags
< start
)
8736 unsigned long abbrev_number
;
8737 abbrev_entry
*entry
;
8740 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
8743 /* A null DIE marks the end of a list of children. */
8744 if (abbrev_number
== 0)
8750 /* Scan through the abbreviation list until we reach the
8752 for (entry
= first_abbrev
;
8753 entry
&& entry
->entry
!= abbrev_number
;
8754 entry
= entry
->next
)
8759 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
8764 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
8766 (unsigned long) (tags
- section_begin
- bytes_read
),
8768 get_TAG_name (entry
->tag
));
8770 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
8771 tags
= read_and_display_attr (attr
->attribute
,
8774 compunit
.cu_pointer_size
,
8776 compunit
.cu_version
);
8778 if (entry
->children
)
8792 display_debug_aranges (Elf_Internal_Shdr
*section
,
8793 unsigned char *start
,
8794 FILE *file ATTRIBUTE_UNUSED
)
8796 unsigned char *end
= start
+ section
->sh_size
;
8798 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
8802 unsigned char *hdrptr
;
8803 DWARF2_Internal_ARange arange
;
8804 unsigned char *ranges
;
8805 unsigned long length
;
8806 unsigned long address
;
8809 int initial_length_size
;
8813 arange
.ar_length
= byte_get (hdrptr
, 4);
8816 if (arange
.ar_length
== 0xffffffff)
8818 arange
.ar_length
= byte_get (hdrptr
, 8);
8821 initial_length_size
= 12;
8826 initial_length_size
= 4;
8829 arange
.ar_version
= byte_get (hdrptr
, 2);
8832 arange
.ar_info_offset
= byte_get (hdrptr
, offset_size
);
8833 hdrptr
+= offset_size
;
8835 arange
.ar_pointer_size
= byte_get (hdrptr
, 1);
8838 arange
.ar_segment_size
= byte_get (hdrptr
, 1);
8841 if (arange
.ar_version
!= 2 && arange
.ar_version
!= 3)
8843 warn (_("Only DWARF 2 and 3 aranges are currently supported.\n"));
8847 printf (_(" Length: %ld\n"), arange
.ar_length
);
8848 printf (_(" Version: %d\n"), arange
.ar_version
);
8849 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
8850 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
8851 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
8853 printf (_("\n Address Length\n"));
8857 /* Must pad to an alignment boundary that is twice the pointer size. */
8858 excess
= (hdrptr
- start
) % (2 * arange
.ar_pointer_size
);
8860 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
8864 address
= byte_get (ranges
, arange
.ar_pointer_size
);
8866 ranges
+= arange
.ar_pointer_size
;
8868 length
= byte_get (ranges
, arange
.ar_pointer_size
);
8870 ranges
+= arange
.ar_pointer_size
;
8872 /* A pair of zeros marks the end of the list. */
8873 if (address
== 0 && length
== 0)
8876 printf (" %8.8lx %lu\n", address
, length
);
8879 start
+= arange
.ar_length
+ initial_length_size
;
8887 typedef struct Frame_Chunk
8889 struct Frame_Chunk
*next
;
8890 unsigned char *chunk_start
;
8892 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
8893 short int *col_type
;
8896 unsigned int code_factor
;
8898 unsigned long pc_begin
;
8899 unsigned long pc_range
;
8903 unsigned char fde_encoding
;
8904 unsigned char cfa_exp
;
8908 /* A marker for a col_type that means this column was never referenced
8909 in the frame info. */
8910 #define DW_CFA_unreferenced (-1)
8913 frame_need_space (Frame_Chunk
*fc
, int reg
)
8915 int prev
= fc
->ncols
;
8917 if (reg
< fc
->ncols
)
8920 fc
->ncols
= reg
+ 1;
8921 fc
->col_type
= xrealloc (fc
->col_type
, fc
->ncols
* sizeof (short int));
8922 fc
->col_offset
= xrealloc (fc
->col_offset
, fc
->ncols
* sizeof (int));
8924 while (prev
< fc
->ncols
)
8926 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
8927 fc
->col_offset
[prev
] = 0;
8933 frame_display_row (Frame_Chunk
*fc
, int *need_col_headers
, int *max_regs
)
8938 if (*max_regs
< fc
->ncols
)
8939 *max_regs
= fc
->ncols
;
8941 if (*need_col_headers
)
8943 *need_col_headers
= 0;
8945 printf (" LOC CFA ");
8947 for (r
= 0; r
< *max_regs
; r
++)
8948 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8953 printf ("r%-4d", r
);
8959 printf ("%08lx ", fc
->pc_begin
);
8961 strcpy (tmp
, "exp");
8963 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
8964 printf ("%-8s ", tmp
);
8966 for (r
= 0; r
< fc
->ncols
; r
++)
8968 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
8970 switch (fc
->col_type
[r
])
8972 case DW_CFA_undefined
:
8975 case DW_CFA_same_value
:
8979 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
8981 case DW_CFA_register
:
8982 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
8984 case DW_CFA_expression
:
8985 strcpy (tmp
, "exp");
8988 strcpy (tmp
, "n/a");
8991 printf ("%-5s", tmp
);
8998 size_of_encoded_value (int encoding
)
9000 switch (encoding
& 0x7)
9003 case 0: return is_32bit_elf
? 4 : 8;
9011 get_encoded_value (unsigned char *data
, int encoding
)
9013 int size
= size_of_encoded_value (encoding
);
9014 if (encoding
& DW_EH_PE_signed
)
9015 return byte_get_signed (data
, size
);
9017 return byte_get (data
, size
);
9020 #define GET(N) byte_get (start, N); start += N
9021 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
9022 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
9025 display_debug_frames (Elf_Internal_Shdr
*section
,
9026 unsigned char *start
,
9027 FILE *file ATTRIBUTE_UNUSED
)
9029 unsigned char *end
= start
+ section
->sh_size
;
9030 unsigned char *section_start
= start
;
9031 Frame_Chunk
*chunks
= 0;
9032 Frame_Chunk
*remembered_state
= 0;
9034 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
9037 int addr_size
= is_32bit_elf
? 4 : 8;
9039 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
9043 unsigned char *saved_start
;
9044 unsigned char *block_end
;
9045 unsigned long length
;
9046 unsigned long cie_id
;
9049 int need_col_headers
= 1;
9050 unsigned char *augmentation_data
= NULL
;
9051 unsigned long augmentation_data_len
= 0;
9052 int encoded_ptr_size
= addr_size
;
9054 int initial_length_size
;
9056 saved_start
= start
;
9057 length
= byte_get (start
, 4); start
+= 4;
9061 printf ("\n%08lx ZERO terminator\n\n",
9062 (unsigned long)(saved_start
- section_start
));
9066 if (length
== 0xffffffff)
9068 length
= byte_get (start
, 8);
9071 initial_length_size
= 12;
9076 initial_length_size
= 4;
9079 block_end
= saved_start
+ length
+ initial_length_size
;
9080 cie_id
= byte_get (start
, offset_size
); start
+= offset_size
;
9082 if (elf_header
.e_type
== ET_REL
9083 && !debug_apply_rela_addends (file
, section
, offset_size
,
9084 section_start
, start
, block_end
))
9087 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
9091 fc
= xmalloc (sizeof (Frame_Chunk
));
9092 memset (fc
, 0, sizeof (Frame_Chunk
));
9096 fc
->chunk_start
= saved_start
;
9098 fc
->col_type
= xmalloc (sizeof (short int));
9099 fc
->col_offset
= xmalloc (sizeof (int));
9100 frame_need_space (fc
, max_regs
-1);
9104 fc
->augmentation
= start
;
9105 start
= strchr (start
, '\0') + 1;
9107 if (fc
->augmentation
[0] == 'z')
9109 fc
->code_factor
= LEB ();
9110 fc
->data_factor
= SLEB ();
9119 augmentation_data_len
= LEB ();
9120 augmentation_data
= start
;
9121 start
+= augmentation_data_len
;
9123 else if (strcmp (fc
->augmentation
, "eh") == 0)
9126 fc
->code_factor
= LEB ();
9127 fc
->data_factor
= SLEB ();
9139 fc
->code_factor
= LEB ();
9140 fc
->data_factor
= SLEB ();
9152 if (do_debug_frames_interp
)
9153 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
9154 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9155 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
9159 printf ("\n%08lx %08lx %08lx CIE\n",
9160 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
9161 printf (" Version: %d\n", version
);
9162 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
9163 printf (" Code alignment factor: %u\n", fc
->code_factor
);
9164 printf (" Data alignment factor: %d\n", fc
->data_factor
);
9165 printf (" Return address column: %d\n", fc
->ra
);
9167 if (augmentation_data_len
)
9170 printf (" Augmentation data: ");
9171 for (i
= 0; i
< augmentation_data_len
; ++i
)
9172 printf (" %02x", augmentation_data
[i
]);
9178 if (augmentation_data_len
)
9180 unsigned char *p
, *q
;
9181 p
= fc
->augmentation
+ 1;
9182 q
= augmentation_data
;
9189 q
+= 1 + size_of_encoded_value (*q
);
9191 fc
->fde_encoding
= *q
++;
9197 if (fc
->fde_encoding
)
9198 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9201 frame_need_space (fc
, fc
->ra
);
9205 unsigned char *look_for
;
9206 static Frame_Chunk fde_fc
;
9209 memset (fc
, 0, sizeof (Frame_Chunk
));
9211 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
9213 for (cie
= chunks
; cie
; cie
= cie
->next
)
9214 if (cie
->chunk_start
== look_for
)
9219 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
9220 cie_id
, saved_start
);
9223 fc
->col_type
= xmalloc (sizeof (short int));
9224 fc
->col_offset
= xmalloc (sizeof (int));
9225 frame_need_space (fc
, max_regs
- 1);
9227 fc
->augmentation
= "";
9228 fc
->fde_encoding
= 0;
9232 fc
->ncols
= cie
->ncols
;
9233 fc
->col_type
= xmalloc (fc
->ncols
* sizeof (short int));
9234 fc
->col_offset
= xmalloc (fc
->ncols
* sizeof (int));
9235 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
9236 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
9237 fc
->augmentation
= cie
->augmentation
;
9238 fc
->code_factor
= cie
->code_factor
;
9239 fc
->data_factor
= cie
->data_factor
;
9240 fc
->cfa_reg
= cie
->cfa_reg
;
9241 fc
->cfa_offset
= cie
->cfa_offset
;
9243 frame_need_space (fc
, max_regs
-1);
9244 fc
->fde_encoding
= cie
->fde_encoding
;
9247 if (fc
->fde_encoding
)
9248 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
9250 fc
->pc_begin
= get_encoded_value (start
, fc
->fde_encoding
);
9251 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9252 /* Don't adjust for ET_REL since there's invariably a pcrel
9253 reloc here, which we haven't applied. */
9254 && elf_header
.e_type
!= ET_REL
)
9255 fc
->pc_begin
+= section
->sh_addr
+ (start
- section_start
);
9256 start
+= encoded_ptr_size
;
9257 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
9258 start
+= encoded_ptr_size
;
9260 if (cie
->augmentation
[0] == 'z')
9262 augmentation_data_len
= LEB ();
9263 augmentation_data
= start
;
9264 start
+= augmentation_data_len
;
9267 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
9268 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
9269 (unsigned long)(cie
->chunk_start
- section_start
),
9270 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
9271 if (! do_debug_frames_interp
&& augmentation_data_len
)
9274 printf (" Augmentation data: ");
9275 for (i
= 0; i
< augmentation_data_len
; ++i
)
9276 printf (" %02x", augmentation_data
[i
]);
9282 /* At this point, fc is the current chunk, cie (if any) is set, and we're
9283 about to interpret instructions for the chunk. */
9284 /* ??? At present we need to do this always, since this sizes the
9285 fc->col_type and fc->col_offset arrays, which we write into always.
9286 We should probably split the interpreted and non-interpreted bits
9287 into two different routines, since there's so much that doesn't
9288 really overlap between them. */
9289 if (1 || do_debug_frames_interp
)
9291 /* Start by making a pass over the chunk, allocating storage
9292 and taking note of what registers are used. */
9293 unsigned char *tmp
= start
;
9295 while (start
< block_end
)
9298 unsigned long reg
, tmp
;
9305 /* Warning: if you add any more cases to this switch, be
9306 sure to add them to the corresponding switch below. */
9309 case DW_CFA_advance_loc
:
9313 frame_need_space (fc
, opa
);
9314 fc
->col_type
[opa
] = DW_CFA_undefined
;
9316 case DW_CFA_restore
:
9317 frame_need_space (fc
, opa
);
9318 fc
->col_type
[opa
] = DW_CFA_undefined
;
9320 case DW_CFA_set_loc
:
9321 start
+= encoded_ptr_size
;
9323 case DW_CFA_advance_loc1
:
9326 case DW_CFA_advance_loc2
:
9329 case DW_CFA_advance_loc4
:
9332 case DW_CFA_offset_extended
:
9333 reg
= LEB (); LEB ();
9334 frame_need_space (fc
, reg
);
9335 fc
->col_type
[reg
] = DW_CFA_undefined
;
9337 case DW_CFA_restore_extended
:
9339 frame_need_space (fc
, reg
);
9340 fc
->col_type
[reg
] = DW_CFA_undefined
;
9342 case DW_CFA_undefined
:
9344 frame_need_space (fc
, reg
);
9345 fc
->col_type
[reg
] = DW_CFA_undefined
;
9347 case DW_CFA_same_value
:
9349 frame_need_space (fc
, reg
);
9350 fc
->col_type
[reg
] = DW_CFA_undefined
;
9352 case DW_CFA_register
:
9353 reg
= LEB (); LEB ();
9354 frame_need_space (fc
, reg
);
9355 fc
->col_type
[reg
] = DW_CFA_undefined
;
9357 case DW_CFA_def_cfa
:
9360 case DW_CFA_def_cfa_register
:
9363 case DW_CFA_def_cfa_offset
:
9366 case DW_CFA_def_cfa_expression
:
9370 case DW_CFA_expression
:
9374 frame_need_space (fc
, reg
);
9375 fc
->col_type
[reg
] = DW_CFA_undefined
;
9377 case DW_CFA_offset_extended_sf
:
9378 reg
= LEB (); SLEB ();
9379 frame_need_space (fc
, reg
);
9380 fc
->col_type
[reg
] = DW_CFA_undefined
;
9382 case DW_CFA_def_cfa_sf
:
9385 case DW_CFA_def_cfa_offset_sf
:
9388 case DW_CFA_MIPS_advance_loc8
:
9391 case DW_CFA_GNU_args_size
:
9394 case DW_CFA_GNU_negative_offset_extended
:
9395 reg
= LEB (); LEB ();
9396 frame_need_space (fc
, reg
);
9397 fc
->col_type
[reg
] = DW_CFA_undefined
;
9406 /* Now we know what registers are used, make a second pass over
9407 the chunk, this time actually printing out the info. */
9409 while (start
< block_end
)
9412 unsigned long ul
, reg
, roffs
;
9421 /* Warning: if you add any more cases to this switch, be
9422 sure to add them to the corresponding switch above. */
9425 case DW_CFA_advance_loc
:
9426 if (do_debug_frames_interp
)
9427 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9429 printf (" DW_CFA_advance_loc: %d to %08lx\n",
9430 opa
* fc
->code_factor
,
9431 fc
->pc_begin
+ opa
* fc
->code_factor
);
9432 fc
->pc_begin
+= opa
* fc
->code_factor
;
9437 if (! do_debug_frames_interp
)
9438 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
9439 opa
, roffs
* fc
->data_factor
);
9440 fc
->col_type
[opa
] = DW_CFA_offset
;
9441 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
9444 case DW_CFA_restore
:
9445 if (! do_debug_frames_interp
)
9446 printf (" DW_CFA_restore: r%d\n", opa
);
9447 fc
->col_type
[opa
] = cie
->col_type
[opa
];
9448 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
9451 case DW_CFA_set_loc
:
9452 vma
= get_encoded_value (start
, fc
->fde_encoding
);
9453 if ((fc
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
9454 && elf_header
.e_type
!= ET_REL
)
9455 vma
+= section
->sh_addr
+ (start
- section_start
);
9456 start
+= encoded_ptr_size
;
9457 if (do_debug_frames_interp
)
9458 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9460 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
9464 case DW_CFA_advance_loc1
:
9465 ofs
= byte_get (start
, 1); start
+= 1;
9466 if (do_debug_frames_interp
)
9467 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9469 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
9470 ofs
* fc
->code_factor
,
9471 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9472 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9475 case DW_CFA_advance_loc2
:
9476 ofs
= byte_get (start
, 2); start
+= 2;
9477 if (do_debug_frames_interp
)
9478 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9480 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
9481 ofs
* fc
->code_factor
,
9482 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9483 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9486 case DW_CFA_advance_loc4
:
9487 ofs
= byte_get (start
, 4); start
+= 4;
9488 if (do_debug_frames_interp
)
9489 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9491 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
9492 ofs
* fc
->code_factor
,
9493 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9494 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9497 case DW_CFA_offset_extended
:
9500 if (! do_debug_frames_interp
)
9501 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
9502 reg
, roffs
* fc
->data_factor
);
9503 fc
->col_type
[reg
] = DW_CFA_offset
;
9504 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
9507 case DW_CFA_restore_extended
:
9509 if (! do_debug_frames_interp
)
9510 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
9511 fc
->col_type
[reg
] = cie
->col_type
[reg
];
9512 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
9515 case DW_CFA_undefined
:
9517 if (! do_debug_frames_interp
)
9518 printf (" DW_CFA_undefined: r%ld\n", reg
);
9519 fc
->col_type
[reg
] = DW_CFA_undefined
;
9520 fc
->col_offset
[reg
] = 0;
9523 case DW_CFA_same_value
:
9525 if (! do_debug_frames_interp
)
9526 printf (" DW_CFA_same_value: r%ld\n", reg
);
9527 fc
->col_type
[reg
] = DW_CFA_same_value
;
9528 fc
->col_offset
[reg
] = 0;
9531 case DW_CFA_register
:
9534 if (! do_debug_frames_interp
)
9535 printf (" DW_CFA_register: r%ld in r%ld\n", reg
, roffs
);
9536 fc
->col_type
[reg
] = DW_CFA_register
;
9537 fc
->col_offset
[reg
] = roffs
;
9540 case DW_CFA_remember_state
:
9541 if (! do_debug_frames_interp
)
9542 printf (" DW_CFA_remember_state\n");
9543 rs
= xmalloc (sizeof (Frame_Chunk
));
9544 rs
->ncols
= fc
->ncols
;
9545 rs
->col_type
= xmalloc (rs
->ncols
* sizeof (short int));
9546 rs
->col_offset
= xmalloc (rs
->ncols
* sizeof (int));
9547 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
9548 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
9549 rs
->next
= remembered_state
;
9550 remembered_state
= rs
;
9553 case DW_CFA_restore_state
:
9554 if (! do_debug_frames_interp
)
9555 printf (" DW_CFA_restore_state\n");
9556 rs
= remembered_state
;
9559 remembered_state
= rs
->next
;
9560 frame_need_space (fc
, rs
->ncols
-1);
9561 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
9562 memcpy (fc
->col_offset
, rs
->col_offset
,
9563 rs
->ncols
* sizeof (int));
9564 free (rs
->col_type
);
9565 free (rs
->col_offset
);
9568 else if (do_debug_frames_interp
)
9569 printf ("Mismatched DW_CFA_restore_state\n");
9572 case DW_CFA_def_cfa
:
9573 fc
->cfa_reg
= LEB ();
9574 fc
->cfa_offset
= LEB ();
9576 if (! do_debug_frames_interp
)
9577 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
9578 fc
->cfa_reg
, fc
->cfa_offset
);
9581 case DW_CFA_def_cfa_register
:
9582 fc
->cfa_reg
= LEB ();
9584 if (! do_debug_frames_interp
)
9585 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
9588 case DW_CFA_def_cfa_offset
:
9589 fc
->cfa_offset
= LEB ();
9590 if (! do_debug_frames_interp
)
9591 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
9595 if (! do_debug_frames_interp
)
9596 printf (" DW_CFA_nop\n");
9599 case DW_CFA_def_cfa_expression
:
9601 if (! do_debug_frames_interp
)
9603 printf (" DW_CFA_def_cfa_expression (");
9604 decode_location_expression (start
, addr_size
, ul
);
9611 case DW_CFA_expression
:
9614 if (! do_debug_frames_interp
)
9616 printf (" DW_CFA_expression: r%ld (", reg
);
9617 decode_location_expression (start
, addr_size
, ul
);
9620 fc
->col_type
[reg
] = DW_CFA_expression
;
9624 case DW_CFA_offset_extended_sf
:
9627 frame_need_space (fc
, reg
);
9628 if (! do_debug_frames_interp
)
9629 printf (" DW_CFA_offset_extended_sf: r%ld at cfa%+ld\n",
9630 reg
, l
* fc
->data_factor
);
9631 fc
->col_type
[reg
] = DW_CFA_offset
;
9632 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9635 case DW_CFA_def_cfa_sf
:
9636 fc
->cfa_reg
= LEB ();
9637 fc
->cfa_offset
= SLEB ();
9639 if (! do_debug_frames_interp
)
9640 printf (" DW_CFA_def_cfa_sf: r%d ofs %d\n",
9641 fc
->cfa_reg
, fc
->cfa_offset
);
9644 case DW_CFA_def_cfa_offset_sf
:
9645 fc
->cfa_offset
= SLEB ();
9646 if (! do_debug_frames_interp
)
9647 printf (" DW_CFA_def_cfa_offset_sf: %d\n", fc
->cfa_offset
);
9650 case DW_CFA_MIPS_advance_loc8
:
9651 ofs
= byte_get (start
, 8); start
+= 8;
9652 if (do_debug_frames_interp
)
9653 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9655 printf (" DW_CFA_MIPS_advance_loc8: %ld to %08lx\n",
9656 ofs
* fc
->code_factor
,
9657 fc
->pc_begin
+ ofs
* fc
->code_factor
);
9658 fc
->pc_begin
+= ofs
* fc
->code_factor
;
9661 case DW_CFA_GNU_window_save
:
9662 if (! do_debug_frames_interp
)
9663 printf (" DW_CFA_GNU_window_save\n");
9666 case DW_CFA_GNU_args_size
:
9668 if (! do_debug_frames_interp
)
9669 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
9672 case DW_CFA_GNU_negative_offset_extended
:
9675 frame_need_space (fc
, reg
);
9676 if (! do_debug_frames_interp
)
9677 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
9678 reg
, l
* fc
->data_factor
);
9679 fc
->col_type
[reg
] = DW_CFA_offset
;
9680 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
9684 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
9689 if (do_debug_frames_interp
)
9690 frame_display_row (fc
, &need_col_headers
, &max_regs
);
9705 display_debug_not_supported (Elf_Internal_Shdr
*section
,
9706 unsigned char *start ATTRIBUTE_UNUSED
,
9707 FILE *file ATTRIBUTE_UNUSED
)
9709 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
9710 SECTION_NAME (section
));
9715 /* A structure containing the name of a debug section
9716 and a pointer to a function that can decode it. */
9719 const char *const name
;
9720 int (*display
) (Elf_Internal_Shdr
*, unsigned char *, FILE *);
9724 { ".debug_abbrev", display_debug_abbrev
},
9725 { ".debug_aranges", display_debug_aranges
},
9726 { ".debug_frame", display_debug_frames
},
9727 { ".debug_info", display_debug_info
},
9728 { ".debug_line", display_debug_lines
},
9729 { ".debug_pubnames", display_debug_pubnames
},
9730 { ".eh_frame", display_debug_frames
},
9731 { ".debug_macinfo", display_debug_macinfo
},
9732 { ".debug_str", display_debug_str
},
9733 { ".debug_loc", display_debug_loc
},
9734 { ".debug_pubtypes", display_debug_pubnames
},
9735 { ".debug_ranges", display_debug_not_supported
},
9736 { ".debug_static_func", display_debug_not_supported
},
9737 { ".debug_static_vars", display_debug_not_supported
},
9738 { ".debug_types", display_debug_not_supported
},
9739 { ".debug_weaknames", display_debug_not_supported
}
9743 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
9745 char *name
= SECTION_NAME (section
);
9746 bfd_size_type length
;
9747 unsigned char *start
;
9750 length
= section
->sh_size
;
9753 printf (_("\nSection '%s' has no debugging data.\n"), name
);
9757 start
= get_data (NULL
, file
, section
->sh_offset
, length
,
9758 _("debug section data"));
9762 /* See if we know how to display the contents of this section. */
9763 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
9764 name
= ".debug_info";
9766 for (i
= NUM_ELEM (debug_displays
); i
--;)
9767 if (strcmp (debug_displays
[i
].name
, name
) == 0)
9769 debug_displays
[i
].display (section
, start
, file
);
9774 printf (_("Unrecognized debug section: %s\n"), name
);
9778 /* If we loaded in the abbrev section at some point,
9779 we must release it here. */
9786 process_section_contents (FILE *file
)
9788 Elf_Internal_Shdr
*section
;
9794 for (i
= 0, section
= section_headers
;
9795 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
9798 #ifdef SUPPORT_DISASSEMBLY
9799 if (dump_sects
[i
] & DISASS_DUMP
)
9800 disassemble_section (section
, file
);
9802 if (dump_sects
[i
] & HEX_DUMP
)
9803 dump_section (section
, file
);
9805 if (dump_sects
[i
] & DEBUG_DUMP
)
9806 display_debug_section (section
, file
);
9809 if (i
< num_dump_sects
)
9810 warn (_("Some sections were not dumped because they do not exist!\n"));
9816 process_mips_fpe_exception (int mask
)
9821 if (mask
& OEX_FPU_INEX
)
9822 fputs ("INEX", stdout
), first
= 0;
9823 if (mask
& OEX_FPU_UFLO
)
9824 printf ("%sUFLO", first
? "" : "|"), first
= 0;
9825 if (mask
& OEX_FPU_OFLO
)
9826 printf ("%sOFLO", first
? "" : "|"), first
= 0;
9827 if (mask
& OEX_FPU_DIV0
)
9828 printf ("%sDIV0", first
? "" : "|"), first
= 0;
9829 if (mask
& OEX_FPU_INVAL
)
9830 printf ("%sINVAL", first
? "" : "|");
9833 fputs ("0", stdout
);
9837 process_mips_specific (FILE *file
)
9839 Elf_Internal_Dyn
*entry
;
9840 size_t liblist_offset
= 0;
9841 size_t liblistno
= 0;
9842 size_t conflictsno
= 0;
9843 size_t options_offset
= 0;
9844 size_t conflicts_offset
= 0;
9846 /* We have a lot of special sections. Thanks SGI! */
9847 if (dynamic_section
== NULL
)
9848 /* No information available. */
9851 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9852 switch (entry
->d_tag
)
9854 case DT_MIPS_LIBLIST
:
9856 = offset_from_vma (file
, entry
->d_un
.d_val
,
9857 liblistno
* sizeof (Elf32_External_Lib
));
9859 case DT_MIPS_LIBLISTNO
:
9860 liblistno
= entry
->d_un
.d_val
;
9862 case DT_MIPS_OPTIONS
:
9863 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9865 case DT_MIPS_CONFLICT
:
9867 = offset_from_vma (file
, entry
->d_un
.d_val
,
9868 conflictsno
* sizeof (Elf32_External_Conflict
));
9870 case DT_MIPS_CONFLICTNO
:
9871 conflictsno
= entry
->d_un
.d_val
;
9877 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9879 Elf32_External_Lib
*elib
;
9882 elib
= get_data (NULL
, file
, liblist_offset
,
9883 liblistno
* sizeof (Elf32_External_Lib
),
9887 printf ("\nSection '.liblist' contains %lu entries:\n",
9888 (unsigned long) liblistno
);
9889 fputs (" Library Time Stamp Checksum Version Flags\n",
9892 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9899 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9900 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9901 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9902 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9903 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9905 tmp
= gmtime (&time
);
9906 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
9907 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9908 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9910 printf ("%3lu: ", (unsigned long) cnt
);
9911 print_symbol (20, dynamic_strings
+ liblist
.l_name
);
9912 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9915 if (liblist
.l_flags
== 0)
9926 { " EXACT_MATCH", LL_EXACT_MATCH
},
9927 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9928 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9929 { " EXPORTS", LL_EXPORTS
},
9930 { " DELAY_LOAD", LL_DELAY_LOAD
},
9931 { " DELTA", LL_DELTA
}
9933 int flags
= liblist
.l_flags
;
9937 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
9939 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9941 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9942 flags
^= l_flags_vals
[fcnt
].bit
;
9945 printf (" %#x", (unsigned int) flags
);
9955 if (options_offset
!= 0)
9957 Elf_External_Options
*eopt
;
9958 Elf_Internal_Shdr
*sect
= section_headers
;
9959 Elf_Internal_Options
*iopt
;
9960 Elf_Internal_Options
*option
;
9964 /* Find the section header so that we get the size. */
9965 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9968 eopt
= get_data (NULL
, file
, options_offset
, sect
->sh_size
,
9972 iopt
= malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (*iopt
));
9975 error (_("Out of memory"));
9982 while (offset
< sect
->sh_size
)
9984 Elf_External_Options
*eoption
;
9986 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9988 option
->kind
= BYTE_GET (eoption
->kind
);
9989 option
->size
= BYTE_GET (eoption
->size
);
9990 option
->section
= BYTE_GET (eoption
->section
);
9991 option
->info
= BYTE_GET (eoption
->info
);
9993 offset
+= option
->size
;
9999 printf (_("\nSection '%s' contains %d entries:\n"),
10000 SECTION_NAME (sect
), cnt
);
10008 switch (option
->kind
)
10011 /* This shouldn't happen. */
10012 printf (" NULL %d %lx", option
->section
, option
->info
);
10015 printf (" REGINFO ");
10016 if (elf_header
.e_machine
== EM_MIPS
)
10019 Elf32_External_RegInfo
*ereg
;
10020 Elf32_RegInfo reginfo
;
10022 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
10023 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10024 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10025 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10026 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10027 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10028 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
10030 printf ("GPR %08lx GP 0x%lx\n",
10031 reginfo
.ri_gprmask
,
10032 (unsigned long) reginfo
.ri_gp_value
);
10033 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10034 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10035 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10040 Elf64_External_RegInfo
*ereg
;
10041 Elf64_Internal_RegInfo reginfo
;
10043 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
10044 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
10045 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
10046 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
10047 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
10048 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
10049 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
10051 printf ("GPR %08lx GP 0x",
10052 reginfo
.ri_gprmask
);
10053 printf_vma (reginfo
.ri_gp_value
);
10056 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
10057 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
10058 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
10062 case ODK_EXCEPTIONS
:
10063 fputs (" EXCEPTIONS fpe_min(", stdout
);
10064 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
10065 fputs (") fpe_max(", stdout
);
10066 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
10067 fputs (")", stdout
);
10069 if (option
->info
& OEX_PAGE0
)
10070 fputs (" PAGE0", stdout
);
10071 if (option
->info
& OEX_SMM
)
10072 fputs (" SMM", stdout
);
10073 if (option
->info
& OEX_FPDBUG
)
10074 fputs (" FPDBUG", stdout
);
10075 if (option
->info
& OEX_DISMISS
)
10076 fputs (" DISMISS", stdout
);
10079 fputs (" PAD ", stdout
);
10080 if (option
->info
& OPAD_PREFIX
)
10081 fputs (" PREFIX", stdout
);
10082 if (option
->info
& OPAD_POSTFIX
)
10083 fputs (" POSTFIX", stdout
);
10084 if (option
->info
& OPAD_SYMBOL
)
10085 fputs (" SYMBOL", stdout
);
10088 fputs (" HWPATCH ", stdout
);
10089 if (option
->info
& OHW_R4KEOP
)
10090 fputs (" R4KEOP", stdout
);
10091 if (option
->info
& OHW_R8KPFETCH
)
10092 fputs (" R8KPFETCH", stdout
);
10093 if (option
->info
& OHW_R5KEOP
)
10094 fputs (" R5KEOP", stdout
);
10095 if (option
->info
& OHW_R5KCVTL
)
10096 fputs (" R5KCVTL", stdout
);
10099 fputs (" FILL ", stdout
);
10100 /* XXX Print content of info word? */
10103 fputs (" TAGS ", stdout
);
10104 /* XXX Print content of info word? */
10107 fputs (" HWAND ", stdout
);
10108 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10109 fputs (" R4KEOP_CHECKED", stdout
);
10110 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10111 fputs (" R4KEOP_CLEAN", stdout
);
10114 fputs (" HWOR ", stdout
);
10115 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
10116 fputs (" R4KEOP_CHECKED", stdout
);
10117 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
10118 fputs (" R4KEOP_CLEAN", stdout
);
10121 printf (" GP_GROUP %#06lx self-contained %#06lx",
10122 option
->info
& OGP_GROUP
,
10123 (option
->info
& OGP_SELF
) >> 16);
10126 printf (" IDENT %#06lx self-contained %#06lx",
10127 option
->info
& OGP_GROUP
,
10128 (option
->info
& OGP_SELF
) >> 16);
10131 /* This shouldn't happen. */
10132 printf (" %3d ??? %d %lx",
10133 option
->kind
, option
->section
, option
->info
);
10137 len
= sizeof (*eopt
);
10138 while (len
< option
->size
)
10139 if (((char *) option
)[len
] >= ' '
10140 && ((char *) option
)[len
] < 0x7f)
10141 printf ("%c", ((char *) option
)[len
++]);
10143 printf ("\\%03o", ((char *) option
)[len
++]);
10145 fputs ("\n", stdout
);
10153 if (conflicts_offset
!= 0 && conflictsno
!= 0)
10155 Elf32_Conflict
*iconf
;
10158 if (dynamic_symbols
== NULL
)
10160 error (_("conflict list found without a dynamic symbol table"));
10164 iconf
= malloc (conflictsno
* sizeof (*iconf
));
10167 error (_("Out of memory"));
10173 Elf32_External_Conflict
*econf32
;
10175 econf32
= get_data (NULL
, file
, conflicts_offset
,
10176 conflictsno
* sizeof (*econf32
), _("conflict"));
10180 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10181 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
10187 Elf64_External_Conflict
*econf64
;
10189 econf64
= get_data (NULL
, file
, conflicts_offset
,
10190 conflictsno
* sizeof (*econf64
), _("conflict"));
10194 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10195 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
10200 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10201 (unsigned long) conflictsno
);
10202 puts (_(" Num: Index Value Name"));
10204 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
10206 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
10208 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
10209 print_vma (psym
->st_value
, FULL_HEX
);
10211 print_symbol (25, dynamic_strings
+ psym
->st_name
);
10222 process_gnu_liblist (FILE *file
)
10224 Elf_Internal_Shdr
*section
, *string_sec
;
10225 Elf32_External_Lib
*elib
;
10233 for (i
= 0, section
= section_headers
;
10234 i
< elf_header
.e_shnum
;
10237 switch (section
->sh_type
)
10239 case SHT_GNU_LIBLIST
:
10240 elib
= get_data (NULL
, file
, section
->sh_offset
, section
->sh_size
,
10245 string_sec
= SECTION_HEADER (section
->sh_link
);
10247 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
10248 string_sec
->sh_size
, _("liblist string table"));
10251 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
10257 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10258 SECTION_NAME (section
),
10259 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
10261 puts (" Library Time Stamp Checksum Version Flags");
10263 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
10271 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
10272 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
10273 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
10274 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
10275 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
10277 tmp
= gmtime (&time
);
10278 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
10279 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10280 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10282 printf ("%3lu: ", (unsigned long) cnt
);
10284 printf ("%-20s", strtab
+ liblist
.l_name
);
10286 printf ("%-20.20s", strtab
+ liblist
.l_name
);
10287 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
10288 liblist
.l_version
, liblist
.l_flags
);
10298 static const char *
10299 get_note_type (unsigned e_type
)
10301 static char buff
[64];
10305 case NT_AUXV
: return _("NT_AUXV (auxiliary vector)");
10306 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
10307 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
10308 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
10309 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
10310 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
10311 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
10312 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
10313 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
10314 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
10315 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
10316 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10318 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10323 static const char *
10324 get_netbsd_elfcore_note_type (unsigned e_type
)
10326 static char buff
[64];
10328 if (e_type
== NT_NETBSDCORE_PROCINFO
)
10330 /* NetBSD core "procinfo" structure. */
10331 return _("NetBSD procinfo structure");
10334 /* As of Jan 2002 there are no other machine-independent notes
10335 defined for NetBSD core files. If the note type is less
10336 than the start of the machine-dependent note types, we don't
10339 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
10341 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
10345 switch (elf_header
.e_machine
)
10347 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10348 and PT_GETFPREGS == mach+2. */
10353 case EM_SPARC32PLUS
:
10357 case NT_NETBSDCORE_FIRSTMACH
+0:
10358 return _("PT_GETREGS (reg structure)");
10359 case NT_NETBSDCORE_FIRSTMACH
+2:
10360 return _("PT_GETFPREGS (fpreg structure)");
10366 /* On all other arch's, PT_GETREGS == mach+1 and
10367 PT_GETFPREGS == mach+3. */
10371 case NT_NETBSDCORE_FIRSTMACH
+1:
10372 return _("PT_GETREGS (reg structure)");
10373 case NT_NETBSDCORE_FIRSTMACH
+3:
10374 return _("PT_GETFPREGS (fpreg structure)");
10380 sprintf (buff
, _("PT_FIRSTMACH+%d"), e_type
- NT_NETBSDCORE_FIRSTMACH
);
10384 /* Note that by the ELF standard, the name field is already null byte
10385 terminated, and namesz includes the terminating null byte.
10386 I.E. the value of namesz for the name "FSF" is 4.
10388 If the value of namesz is zero, there is no name present. */
10390 process_note (Elf_Internal_Note
*pnote
)
10394 if (pnote
->namesz
== 0)
10396 /* If there is no note name, then use the default set of
10397 note type strings. */
10398 nt
= get_note_type (pnote
->type
);
10400 else if (strncmp (pnote
->namedata
, "NetBSD-CORE", 11) == 0)
10402 /* NetBSD-specific core file notes. */
10403 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
10407 /* Don't recognize this note name; just use the default set of
10408 note type strings. */
10409 nt
= get_note_type (pnote
->type
);
10412 printf (" %s\t\t0x%08lx\t%s\n",
10413 pnote
->namesz
? pnote
->namedata
: "(NONE)",
10414 pnote
->descsz
, nt
);
10420 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
10422 Elf_External_Note
*pnotes
;
10423 Elf_External_Note
*external
;
10429 pnotes
= get_data (NULL
, file
, offset
, length
, _("notes"));
10435 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10436 (unsigned long) offset
, (unsigned long) length
);
10437 printf (_(" Owner\t\tData size\tDescription\n"));
10439 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
10441 Elf_External_Note
*next
;
10442 Elf_Internal_Note inote
;
10445 inote
.type
= BYTE_GET (external
->type
);
10446 inote
.namesz
= BYTE_GET (external
->namesz
);
10447 inote
.namedata
= external
->name
;
10448 inote
.descsz
= BYTE_GET (external
->descsz
);
10449 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
10450 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
10452 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
10454 if (((char *) next
) > (((char *) pnotes
) + length
))
10456 warn (_("corrupt note found at offset %x into core notes\n"),
10457 ((char *) external
) - ((char *) pnotes
));
10458 warn (_(" type: %x, namesize: %08lx, descsize: %08lx\n"),
10459 inote
.type
, inote
.namesz
, inote
.descsz
);
10465 /* Verify that name is null terminated. It appears that at least
10466 one version of Linux (RedHat 6.0) generates corefiles that don't
10467 comply with the ELF spec by failing to include the null byte in
10469 if (inote
.namedata
[inote
.namesz
] != '\0')
10471 temp
= malloc (inote
.namesz
+ 1);
10475 error (_("Out of memory\n"));
10480 strncpy (temp
, inote
.namedata
, inote
.namesz
);
10481 temp
[inote
.namesz
] = 0;
10483 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10484 inote
.namedata
= temp
;
10487 res
&= process_note (& inote
);
10502 process_corefile_note_segments (FILE *file
)
10504 Elf_Internal_Phdr
*segment
;
10508 if (! get_program_headers (file
))
10511 for (i
= 0, segment
= program_headers
;
10512 i
< elf_header
.e_phnum
;
10515 if (segment
->p_type
== PT_NOTE
)
10516 res
&= process_corefile_note_segment (file
,
10517 (bfd_vma
) segment
->p_offset
,
10518 (bfd_vma
) segment
->p_filesz
);
10525 process_corefile_contents (FILE *file
)
10527 /* If we have not been asked to display the notes then do nothing. */
10531 /* If file is not a core file then exit. */
10532 if (elf_header
.e_type
!= ET_CORE
)
10535 /* No program headers means no NOTE segment. */
10536 if (elf_header
.e_phnum
== 0)
10538 printf (_("No note segments present in the core file.\n"));
10542 return process_corefile_note_segments (file
);
10546 process_arch_specific (FILE *file
)
10551 switch (elf_header
.e_machine
)
10554 case EM_MIPS_RS3_LE
:
10555 return process_mips_specific (file
);
10564 get_file_header (FILE *file
)
10566 /* Read in the identity array. */
10567 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
10570 /* Determine how to read the rest of the header. */
10571 switch (elf_header
.e_ident
[EI_DATA
])
10573 default: /* fall through */
10574 case ELFDATANONE
: /* fall through */
10576 byte_get
= byte_get_little_endian
;
10577 byte_put
= byte_put_little_endian
;
10580 byte_get
= byte_get_big_endian
;
10581 byte_put
= byte_put_big_endian
;
10585 /* For now we only support 32 bit and 64 bit ELF files. */
10586 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
10588 /* Read in the rest of the header. */
10591 Elf32_External_Ehdr ehdr32
;
10593 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
10596 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
10597 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
10598 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
10599 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
10600 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
10601 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
10602 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
10603 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
10604 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
10605 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
10606 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
10607 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
10608 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
10612 Elf64_External_Ehdr ehdr64
;
10614 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10615 we will not be able to cope with the 64bit data found in
10616 64 ELF files. Detect this now and abort before we start
10617 overwriting things. */
10618 if (sizeof (bfd_vma
) < 8)
10620 error (_("This instance of readelf has been built without support for a\n\
10621 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10625 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
10628 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
10629 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
10630 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
10631 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
10632 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
10633 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
10634 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
10635 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
10636 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
10637 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
10638 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
10639 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
10640 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
10643 if (elf_header
.e_shoff
)
10645 /* There may be some extensions in the first section header. Don't
10646 bomb if we can't read it. */
10648 get_32bit_section_headers (file
, 1);
10650 get_64bit_section_headers (file
, 1);
10656 /* Process one ELF object file according to the command line options.
10657 This file may actually be stored in an archive. The file is
10658 positioned at the start of the ELF object. */
10661 process_object (char *file_name
, FILE *file
)
10665 if (! get_file_header (file
))
10667 error (_("%s: Failed to read file header\n"), file_name
);
10671 /* Initialise per file variables. */
10672 for (i
= NUM_ELEM (version_info
); i
--;)
10673 version_info
[i
] = 0;
10675 for (i
= NUM_ELEM (dynamic_info
); i
--;)
10676 dynamic_info
[i
] = 0;
10678 /* Process the file. */
10680 printf (_("\nFile: %s\n"), file_name
);
10682 if (! process_file_header ())
10685 if (! process_section_headers (file
)
10686 || ! process_section_groups (file
))
10688 /* Without loaded section headers and section groups we
10689 cannot process lots of things. */
10690 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10692 if (! do_using_dynamic
)
10693 do_syms
= do_reloc
= 0;
10696 if (process_program_headers (file
))
10697 process_dynamic_section (file
);
10699 process_relocs (file
);
10701 process_unwind (file
);
10703 process_symbol_table (file
);
10705 process_syminfo (file
);
10707 process_version_sections (file
);
10709 process_section_contents (file
);
10711 process_corefile_contents (file
);
10713 process_gnu_liblist (file
);
10715 process_arch_specific (file
);
10717 if (program_headers
)
10719 free (program_headers
);
10720 program_headers
= NULL
;
10723 if (section_headers
)
10725 free (section_headers
);
10726 section_headers
= NULL
;
10731 free (string_table
);
10732 string_table
= NULL
;
10733 string_table_length
= 0;
10736 if (dynamic_strings
)
10738 free (dynamic_strings
);
10739 dynamic_strings
= NULL
;
10742 if (dynamic_symbols
)
10744 free (dynamic_symbols
);
10745 dynamic_symbols
= NULL
;
10746 num_dynamic_syms
= 0;
10749 if (dynamic_syminfo
)
10751 free (dynamic_syminfo
);
10752 dynamic_syminfo
= NULL
;
10755 if (section_headers_groups
)
10757 free (section_headers_groups
);
10758 section_headers_groups
= NULL
;
10761 if (section_groups
)
10763 struct group_list
*g
, *next
;
10765 for (i
= 0; i
< group_count
; i
++)
10767 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10774 free (section_groups
);
10775 section_groups
= NULL
;
10781 /* Process an ELF archive. The file is positioned just after the
10785 process_archive (char *file_name
, FILE *file
)
10787 struct ar_hdr arhdr
;
10789 unsigned long size
;
10790 char *longnames
= NULL
;
10791 unsigned long longnames_size
= 0;
10792 size_t file_name_size
;
10797 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10798 if (got
!= sizeof arhdr
)
10803 error (_("%s: failed to read archive header\n"), file_name
);
10807 if (memcmp (arhdr
.ar_name
, "/ ", 16) == 0)
10809 /* This is the archive symbol table. Skip it.
10810 FIXME: We should have an option to dump it. */
10811 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10812 if (fseek (file
, size
+ (size
& 1), SEEK_CUR
) != 0)
10814 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10818 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10819 if (got
!= sizeof arhdr
)
10824 error (_("%s: failed to read archive header\n"), file_name
);
10829 if (memcmp (arhdr
.ar_name
, "// ", 16) == 0)
10831 /* This is the archive string table holding long member
10834 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10836 longnames
= malloc (longnames_size
);
10837 if (longnames
== NULL
)
10839 error (_("Out of memory\n"));
10843 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10846 error(_("%s: failed to read string table\n"), file_name
);
10850 if ((longnames_size
& 1) != 0)
10853 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10854 if (got
!= sizeof arhdr
)
10861 error (_("%s: failed to read archive header\n"), file_name
);
10866 file_name_size
= strlen (file_name
);
10875 if (arhdr
.ar_name
[0] == '/')
10879 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10880 if (off
>= longnames_size
)
10882 error (_("%s: invalid archive string table offset %lu\n"), off
);
10887 name
= longnames
+ off
;
10888 nameend
= memchr (name
, '/', longnames_size
- off
);
10892 name
= arhdr
.ar_name
;
10893 nameend
= memchr (name
, '/', 16);
10896 if (nameend
== NULL
)
10898 error (_("%s: bad archive file name\n"));
10903 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10904 if (namealc
== NULL
)
10906 error (_("Out of memory\n"));
10911 memcpy (namealc
, file_name
, file_name_size
);
10912 namealc
[file_name_size
] = '(';
10913 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10914 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10915 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10917 archive_file_offset
= ftell (file
);
10918 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10920 ret
|= process_object (namealc
, file
);
10925 (archive_file_offset
10926 + archive_file_size
10927 + (archive_file_size
& 1)),
10930 error (_("%s: failed to seek to next archive header\n"), file_name
);
10935 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10936 if (got
!= sizeof arhdr
)
10941 error (_("%s: failed to read archive header\n"), file_name
);
10947 if (longnames
!= 0)
10954 process_file (char *file_name
)
10957 struct stat statbuf
;
10958 char armag
[SARMAG
];
10961 if (stat (file_name
, &statbuf
) < 0)
10963 if (errno
== ENOENT
)
10964 error (_("'%s': No such file\n"), file_name
);
10966 error (_("Could not locate '%s'. System error message: %s\n"),
10967 file_name
, strerror (errno
));
10971 if (! S_ISREG (statbuf
.st_mode
))
10973 error (_("'%s' is not an ordinary file\n"), file_name
);
10977 file
= fopen (file_name
, "rb");
10980 error (_("Input file '%s' is not readable.\n"), file_name
);
10984 if (fread (armag
, SARMAG
, 1, file
) != 1)
10986 error (_("%s: Failed to read file header\n"), file_name
);
10991 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10992 ret
= process_archive (file_name
, file
);
10996 archive_file_size
= archive_file_offset
= 0;
10997 ret
= process_object (file_name
, file
);
11005 #ifdef SUPPORT_DISASSEMBLY
11006 /* Needed by the i386 disassembler. For extra credit, someone could
11007 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11011 print_address (unsigned int addr
, FILE *outfile
)
11013 fprintf (outfile
,"0x%8.8x", addr
);
11016 /* Needed by the i386 disassembler. */
11018 db_task_printsym (unsigned int addr
)
11020 print_address (addr
, stderr
);
11025 main (int argc
, char **argv
)
11028 char *cmdline_dump_sects
= NULL
;
11029 unsigned num_cmdline_dump_sects
= 0;
11031 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11032 setlocale (LC_MESSAGES
, "");
11034 #if defined (HAVE_SETLOCALE)
11035 setlocale (LC_CTYPE
, "");
11037 bindtextdomain (PACKAGE
, LOCALEDIR
);
11038 textdomain (PACKAGE
);
11040 parse_args (argc
, argv
);
11042 if (optind
< (argc
- 1))
11045 /* When processing more than one file remember the dump requests
11046 issued on command line to reset them after each file. */
11047 if (optind
+ 1 < argc
&& dump_sects
!= NULL
)
11049 cmdline_dump_sects
= malloc (num_dump_sects
);
11050 if (cmdline_dump_sects
== NULL
)
11051 error (_("Out of memory allocating dump request table."));
11054 memcpy (cmdline_dump_sects
, dump_sects
, num_dump_sects
);
11055 num_cmdline_dump_sects
= num_dump_sects
;
11060 while (optind
< argc
)
11062 err
|= process_file (argv
[optind
++]);
11064 /* Reset dump requests. */
11065 if (optind
< argc
&& dump_sects
!= NULL
)
11067 num_dump_sects
= num_cmdline_dump_sects
;
11068 if (num_cmdline_dump_sects
> 0)
11069 memcpy (dump_sects
, cmdline_dump_sects
, num_cmdline_dump_sects
);
11073 if (dump_sects
!= NULL
)
11075 if (cmdline_dump_sects
!= NULL
)
11076 free (cmdline_dump_sects
);