1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008 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 3 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., 51 Franklin Street - Fifth Floor, 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. */
56 # ifdef HAVE_SYS_PARAM_H
57 # include <sys/param.h>
61 # define PATH_MAX MAXPATHLEN
63 # define PATH_MAX 1024
69 /* Define BFD64 here, even if our default architecture is 32 bit ELF
70 as this will allow us to read in and parse 64bit and 32bit ELF files.
71 Only do this if we believe that the compiler can support a 64 bit
72 data type. For now we only rely on GCC being able to do this. */
80 #include "elf/common.h"
81 #include "elf/external.h"
82 #include "elf/internal.h"
85 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
86 we can obtain the H8 reloc numbers. We need these for the
87 get_reloc_size() function. We include h8.h again after defining
88 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
93 /* Undo the effects of #including reloc-macros.h. */
95 #undef START_RELOC_NUMBERS
99 #undef END_RELOC_NUMBERS
100 #undef _RELOC_MACROS_H
102 /* The following headers use the elf/reloc-macros.h file to
103 automatically generate relocation recognition functions
104 such as elf_mips_reloc_type() */
106 #define RELOC_MACROS_GEN_FUNC
108 #include "elf/alpha.h"
112 #include "elf/bfin.h"
113 #include "elf/cr16.h"
114 #include "elf/cris.h"
116 #include "elf/d10v.h"
117 #include "elf/d30v.h"
119 #include "elf/fr30.h"
122 #include "elf/hppa.h"
123 #include "elf/i386.h"
124 #include "elf/i370.h"
125 #include "elf/i860.h"
126 #include "elf/i960.h"
127 #include "elf/ia64.h"
128 #include "elf/ip2k.h"
129 #include "elf/iq2000.h"
130 #include "elf/m32c.h"
131 #include "elf/m32r.h"
132 #include "elf/m68k.h"
133 #include "elf/m68hc11.h"
134 #include "elf/mcore.h"
136 #include "elf/mips.h"
137 #include "elf/mmix.h"
138 #include "elf/mn10200.h"
139 #include "elf/mn10300.h"
141 #include "elf/msp430.h"
142 #include "elf/or32.h"
145 #include "elf/ppc64.h"
146 #include "elf/s390.h"
147 #include "elf/score.h"
149 #include "elf/sparc.h"
151 #include "elf/v850.h"
153 #include "elf/x86-64.h"
154 #include "elf/xstormy16.h"
155 #include "elf/xtensa.h"
160 #include "libiberty.h"
161 #include "safe-ctype.h"
163 char *program_name
= "readelf";
164 static long archive_file_offset
;
165 static unsigned long archive_file_size
;
166 static unsigned long dynamic_addr
;
167 static bfd_size_type dynamic_size
;
168 static unsigned int dynamic_nent
;
169 static char *dynamic_strings
;
170 static unsigned long dynamic_strings_length
;
171 static char *string_table
;
172 static unsigned long string_table_length
;
173 static unsigned long num_dynamic_syms
;
174 static Elf_Internal_Sym
*dynamic_symbols
;
175 static Elf_Internal_Syminfo
*dynamic_syminfo
;
176 static unsigned long dynamic_syminfo_offset
;
177 static unsigned int dynamic_syminfo_nent
;
178 static char program_interpreter
[PATH_MAX
];
179 static bfd_vma dynamic_info
[DT_JMPREL
+ 1];
180 static bfd_vma dynamic_info_DT_GNU_HASH
;
181 static bfd_vma version_info
[16];
182 static Elf_Internal_Ehdr elf_header
;
183 static Elf_Internal_Shdr
*section_headers
;
184 static Elf_Internal_Phdr
*program_headers
;
185 static Elf_Internal_Dyn
*dynamic_section
;
186 static Elf_Internal_Shdr
*symtab_shndx_hdr
;
187 static int show_name
;
188 static int do_dynamic
;
191 static int do_sections
;
192 static int do_section_groups
;
193 static int do_section_details
;
194 static int do_segments
;
195 static int do_unwind
;
196 static int do_using_dynamic
;
197 static int do_header
;
199 static int do_version
;
201 static int do_histogram
;
202 static int do_debugging
;
205 static int do_archive_index
;
206 static int is_32bit_elf
;
210 struct group_list
*next
;
211 unsigned int section_index
;
216 struct group_list
*root
;
217 unsigned int group_index
;
220 static size_t group_count
;
221 static struct group
*section_groups
;
222 static struct group
**section_headers_groups
;
225 /* Flag bits indicating particular types of dump. */
226 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
227 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
228 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
229 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
231 typedef unsigned char dump_type
;
233 /* A linked list of the section names for which dumps were requested. */
234 struct dump_list_entry
238 struct dump_list_entry
*next
;
240 static struct dump_list_entry
*dump_sects_byname
;
242 /* A dynamic array of flags indicating for which sections a dump
243 has been requested via command line switches. */
244 static dump_type
* cmdline_dump_sects
= NULL
;
245 static unsigned int num_cmdline_dump_sects
= 0;
247 /* A dynamic array of flags indicating for which sections a dump of
248 some kind has been requested. It is reset on a per-object file
249 basis and then initialised from the cmdline_dump_sects array,
250 the results of interpreting the -w switch, and the
251 dump_sects_byname list. */
252 static dump_type
* dump_sects
= NULL
;
253 static unsigned int num_dump_sects
= 0;
256 /* How to print a vma value. */
257 typedef enum print_mode
269 static void (*byte_put
) (unsigned char *, bfd_vma
, int);
273 #define SECTION_NAME(X) \
274 ((X) == NULL ? "<none>" \
275 : string_table == NULL ? "<no-name>" \
276 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
277 : string_table + (X)->sh_name))
279 /* Given st_shndx I, map to section_headers index. */
280 #define SECTION_HEADER_INDEX(I) \
281 ((I) < SHN_LORESERVE \
283 : ((I) <= SHN_HIRESERVE \
285 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
287 /* Reverse of the above. */
288 #define SECTION_HEADER_NUM(N) \
289 ((N) < SHN_LORESERVE \
291 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
293 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
295 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
297 #define BYTE_GET(field) byte_get (field, sizeof (field))
299 #define GET_ELF_SYMBOLS(file, section) \
300 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
301 : get_64bit_elf_symbols (file, section))
303 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
304 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
305 already been called and verified that the string exists. */
306 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
308 /* This is just a bit of syntatic sugar. */
309 #define streq(a,b) (strcmp ((a), (b)) == 0)
310 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
311 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
314 get_data (void *var
, FILE *file
, long offset
, size_t size
, size_t nmemb
,
319 if (size
== 0 || nmemb
== 0)
322 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
324 error (_("Unable to seek to 0x%lx for %s\n"),
325 archive_file_offset
+ offset
, reason
);
332 /* Check for overflow. */
333 if (nmemb
< (~(size_t) 0 - 1) / size
)
334 /* + 1 so that we can '\0' terminate invalid string table sections. */
335 mvar
= malloc (size
* nmemb
+ 1);
339 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
340 (unsigned long)(size
* nmemb
), reason
);
344 ((char *) mvar
)[size
* nmemb
] = '\0';
347 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
349 error (_("Unable to read in 0x%lx bytes of %s\n"),
350 (unsigned long)(size
* nmemb
), reason
);
360 byte_put_little_endian (unsigned char *field
, bfd_vma value
, int size
)
365 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
366 field
[6] = ((value
>> 24) >> 24) & 0xff;
367 field
[5] = ((value
>> 24) >> 16) & 0xff;
368 field
[4] = ((value
>> 24) >> 8) & 0xff;
371 field
[3] = (value
>> 24) & 0xff;
372 field
[2] = (value
>> 16) & 0xff;
375 field
[1] = (value
>> 8) & 0xff;
378 field
[0] = value
& 0xff;
382 error (_("Unhandled data length: %d\n"), size
);
387 #if defined BFD64 && !BFD_HOST_64BIT_LONG && !BFD_HOST_64BIT_LONG_LONG
389 print_dec_vma (bfd_vma vma
, int is_signed
)
395 if (is_signed
&& (bfd_signed_vma
) vma
< 0)
404 *bufp
++ = '0' + vma
% 10;
416 print_hex_vma (bfd_vma vma
)
424 char digit
= '0' + (vma
& 0x0f);
426 digit
+= 'a' - '0' - 10;
439 /* Print a VMA value. */
441 print_vma (bfd_vma vma
, print_mode mode
)
450 return printf ("0x%8.8lx", (unsigned long) vma
);
453 return printf ("%8.8lx", (unsigned long) vma
);
457 return printf ("%5ld", (long) vma
);
461 return printf ("0x%lx", (unsigned long) vma
);
464 return printf ("%lx", (unsigned long) vma
);
467 return printf ("%ld", (unsigned long) vma
);
470 return printf ("%lu", (unsigned long) vma
);
493 #if BFD_HOST_64BIT_LONG
494 return nc
+ printf ("%lx", vma
);
495 #elif BFD_HOST_64BIT_LONG_LONG
497 return nc
+ printf ("%llx", vma
);
499 return nc
+ printf ("%I64x", vma
);
502 return nc
+ print_hex_vma (vma
);
506 #if BFD_HOST_64BIT_LONG
507 return printf ("%ld", vma
);
508 #elif BFD_HOST_64BIT_LONG_LONG
510 return printf ("%lld", vma
);
512 return printf ("%I64d", vma
);
515 return print_dec_vma (vma
, 1);
519 #if BFD_HOST_64BIT_LONG
521 return printf ("%5ld", vma
);
523 return printf ("%#lx", vma
);
524 #elif BFD_HOST_64BIT_LONG_LONG
527 return printf ("%5lld", vma
);
529 return printf ("%#llx", vma
);
532 return printf ("%5I64d", vma
);
534 return printf ("%#I64x", vma
);
538 return printf ("%5ld", _bfd_int64_low (vma
));
540 return print_hex_vma (vma
);
544 #if BFD_HOST_64BIT_LONG
545 return printf ("%lu", vma
);
546 #elif BFD_HOST_64BIT_LONG_LONG
548 return printf ("%llu", vma
);
550 return printf ("%I64u", vma
);
553 return print_dec_vma (vma
, 0);
561 /* Display a symbol on stdout. If do_wide is not true then
562 format the symbol to be at most WIDTH characters,
563 truncating as necessary. If WIDTH is negative then
564 format the string to be exactly - WIDTH characters,
565 truncating or padding as necessary. */
568 print_symbol (int width
, const char *symbol
)
571 printf ("%s", symbol
);
573 printf ("%-*.*s", width
, width
, symbol
);
575 printf ("%-.*s", width
, symbol
);
579 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
584 field
[7] = value
& 0xff;
585 field
[6] = (value
>> 8) & 0xff;
586 field
[5] = (value
>> 16) & 0xff;
587 field
[4] = (value
>> 24) & 0xff;
592 field
[3] = value
& 0xff;
593 field
[2] = (value
>> 8) & 0xff;
597 field
[1] = value
& 0xff;
601 field
[0] = value
& 0xff;
605 error (_("Unhandled data length: %d\n"), size
);
610 /* Return a pointer to section NAME, or NULL if no such section exists. */
612 static Elf_Internal_Shdr
*
613 find_section (const char *name
)
617 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
618 if (streq (SECTION_NAME (section_headers
+ i
), name
))
619 return section_headers
+ i
;
624 /* Guess the relocation size commonly used by the specific machines. */
627 guess_is_rela (unsigned long e_machine
)
631 /* Targets that use REL relocations. */
647 /* Targets that use RELA relocations. */
651 case EM_ALTERA_NIOS2
:
676 case EM_CYGNUS_MN10200
:
678 case EM_CYGNUS_MN10300
:
719 warn (_("Don't know about relocations on this machine architecture\n"));
725 slurp_rela_relocs (FILE *file
,
726 unsigned long rel_offset
,
727 unsigned long rel_size
,
728 Elf_Internal_Rela
**relasp
,
729 unsigned long *nrelasp
)
731 Elf_Internal_Rela
*relas
;
732 unsigned long nrelas
;
737 Elf32_External_Rela
*erelas
;
739 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
743 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
745 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
750 error (_("out of memory parsing relocs\n"));
754 for (i
= 0; i
< nrelas
; i
++)
756 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
757 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
758 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
765 Elf64_External_Rela
*erelas
;
767 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
771 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
773 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
778 error (_("out of memory parsing relocs\n"));
782 for (i
= 0; i
< nrelas
; i
++)
784 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
785 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
786 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
797 slurp_rel_relocs (FILE *file
,
798 unsigned long rel_offset
,
799 unsigned long rel_size
,
800 Elf_Internal_Rela
**relsp
,
801 unsigned long *nrelsp
)
803 Elf_Internal_Rela
*rels
;
809 Elf32_External_Rel
*erels
;
811 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
815 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
817 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
822 error (_("out of memory parsing relocs\n"));
826 for (i
= 0; i
< nrels
; i
++)
828 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
829 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
830 rels
[i
].r_addend
= 0;
837 Elf64_External_Rel
*erels
;
839 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
843 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
845 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
850 error (_("out of memory parsing relocs\n"));
854 for (i
= 0; i
< nrels
; i
++)
856 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
857 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
858 rels
[i
].r_addend
= 0;
868 /* Returns the reloc type extracted from the reloc info field. */
871 get_reloc_type (bfd_vma reloc_info
)
874 return ELF32_R_TYPE (reloc_info
);
876 switch (elf_header
.e_machine
)
879 /* Note: We assume that reloc_info has already been adjusted for us. */
880 return ELF64_MIPS_R_TYPE (reloc_info
);
883 return ELF64_R_TYPE_ID (reloc_info
);
886 return ELF64_R_TYPE (reloc_info
);
890 /* Return the symbol index extracted from the reloc info field. */
893 get_reloc_symindex (bfd_vma reloc_info
)
895 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
898 /* Display the contents of the relocation data found at the specified
902 dump_relocations (FILE *file
,
903 unsigned long rel_offset
,
904 unsigned long rel_size
,
905 Elf_Internal_Sym
*symtab
,
908 unsigned long strtablen
,
912 Elf_Internal_Rela
*rels
;
915 if (is_rela
== UNKNOWN
)
916 is_rela
= guess_is_rela (elf_header
.e_machine
);
920 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
925 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
934 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
936 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
941 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
943 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
951 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
953 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
958 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
960 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
964 for (i
= 0; i
< rel_size
; i
++)
969 bfd_vma symtab_index
;
972 offset
= rels
[i
].r_offset
;
973 info
= rels
[i
].r_info
;
975 /* The #ifdef BFD64 below is to prevent a compile time warning.
976 We know that if we do not have a 64 bit data type that we
977 will never execute this code anyway. */
980 && elf_header
.e_machine
== EM_MIPS
981 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
983 /* In little-endian objects, r_info isn't really a 64-bit
984 little-endian value: it has a 32-bit little-endian
985 symbol index followed by four individual byte fields.
986 Reorder INFO accordingly. */
987 info
= (((info
& 0xffffffff) << 32)
988 | ((info
>> 56) & 0xff)
989 | ((info
>> 40) & 0xff00)
990 | ((info
>> 24) & 0xff0000)
991 | ((info
>> 8) & 0xff000000));
995 type
= get_reloc_type (info
);
996 symtab_index
= get_reloc_symindex (info
);
1000 printf ("%8.8lx %8.8lx ",
1001 (unsigned long) offset
& 0xffffffff,
1002 (unsigned long) info
& 0xffffffff);
1006 #if BFD_HOST_64BIT_LONG
1008 ? "%16.16lx %16.16lx "
1009 : "%12.12lx %12.12lx ",
1011 #elif BFD_HOST_64BIT_LONG_LONG
1014 ? "%16.16llx %16.16llx "
1015 : "%12.12llx %12.12llx ",
1019 ? "%16.16I64x %16.16I64x "
1020 : "%12.12I64x %12.12I64x ",
1025 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1026 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1027 _bfd_int64_high (offset
),
1028 _bfd_int64_low (offset
),
1029 _bfd_int64_high (info
),
1030 _bfd_int64_low (info
));
1034 switch (elf_header
.e_machine
)
1041 case EM_CYGNUS_M32R
:
1042 rtype
= elf_m32r_reloc_type (type
);
1047 rtype
= elf_i386_reloc_type (type
);
1052 rtype
= elf_m68hc11_reloc_type (type
);
1056 rtype
= elf_m68k_reloc_type (type
);
1060 rtype
= elf_i960_reloc_type (type
);
1065 rtype
= elf_avr_reloc_type (type
);
1068 case EM_OLD_SPARCV9
:
1069 case EM_SPARC32PLUS
:
1072 rtype
= elf_sparc_reloc_type (type
);
1076 rtype
= elf_spu_reloc_type (type
);
1080 case EM_CYGNUS_V850
:
1081 rtype
= v850_reloc_type (type
);
1085 case EM_CYGNUS_D10V
:
1086 rtype
= elf_d10v_reloc_type (type
);
1090 case EM_CYGNUS_D30V
:
1091 rtype
= elf_d30v_reloc_type (type
);
1095 rtype
= elf_dlx_reloc_type (type
);
1099 rtype
= elf_sh_reloc_type (type
);
1103 case EM_CYGNUS_MN10300
:
1104 rtype
= elf_mn10300_reloc_type (type
);
1108 case EM_CYGNUS_MN10200
:
1109 rtype
= elf_mn10200_reloc_type (type
);
1113 case EM_CYGNUS_FR30
:
1114 rtype
= elf_fr30_reloc_type (type
);
1118 rtype
= elf_frv_reloc_type (type
);
1122 rtype
= elf_mcore_reloc_type (type
);
1126 rtype
= elf_mmix_reloc_type (type
);
1131 rtype
= elf_msp430_reloc_type (type
);
1135 rtype
= elf_ppc_reloc_type (type
);
1139 rtype
= elf_ppc64_reloc_type (type
);
1143 case EM_MIPS_RS3_LE
:
1144 rtype
= elf_mips_reloc_type (type
);
1148 rtype
= elf_alpha_reloc_type (type
);
1152 rtype
= elf_arm_reloc_type (type
);
1156 rtype
= elf_arc_reloc_type (type
);
1160 rtype
= elf_hppa_reloc_type (type
);
1166 rtype
= elf_h8_reloc_type (type
);
1171 rtype
= elf_or32_reloc_type (type
);
1176 rtype
= elf_pj_reloc_type (type
);
1179 rtype
= elf_ia64_reloc_type (type
);
1183 rtype
= elf_cris_reloc_type (type
);
1187 rtype
= elf_i860_reloc_type (type
);
1191 rtype
= elf_x86_64_reloc_type (type
);
1195 rtype
= i370_reloc_type (type
);
1200 rtype
= elf_s390_reloc_type (type
);
1204 rtype
= elf_score_reloc_type (type
);
1208 rtype
= elf_xstormy16_reloc_type (type
);
1212 rtype
= elf_crx_reloc_type (type
);
1216 rtype
= elf_vax_reloc_type (type
);
1221 rtype
= elf_ip2k_reloc_type (type
);
1225 rtype
= elf_iq2000_reloc_type (type
);
1230 rtype
= elf_xtensa_reloc_type (type
);
1234 rtype
= elf_m32c_reloc_type (type
);
1238 rtype
= elf_mt_reloc_type (type
);
1242 rtype
= elf_bfin_reloc_type (type
);
1246 rtype
= elf_mep_reloc_type (type
);
1250 rtype
= elf_cr16_reloc_type (type
);
1255 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1257 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1259 if (elf_header
.e_machine
== EM_ALPHA
1261 && streq (rtype
, "R_ALPHA_LITUSE")
1264 switch (rels
[i
].r_addend
)
1266 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1267 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1268 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1269 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1270 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1271 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1272 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1273 default: rtype
= NULL
;
1276 printf (" (%s)", rtype
);
1280 printf (_("<unknown addend: %lx>"),
1281 (unsigned long) rels
[i
].r_addend
);
1284 else if (symtab_index
)
1286 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1287 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1290 Elf_Internal_Sym
*psym
;
1292 psym
= symtab
+ symtab_index
;
1295 print_vma (psym
->st_value
, LONG_HEX
);
1296 printf (is_32bit_elf
? " " : " ");
1298 if (psym
->st_name
== 0)
1300 const char *sec_name
= "<null>";
1303 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1305 bfd_vma sec_index
= (bfd_vma
) -1;
1307 if (psym
->st_shndx
< SHN_LORESERVE
)
1308 sec_index
= psym
->st_shndx
;
1309 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1310 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1313 if (sec_index
!= (bfd_vma
) -1)
1314 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1315 else if (psym
->st_shndx
== SHN_ABS
)
1317 else if (psym
->st_shndx
== SHN_COMMON
)
1318 sec_name
= "COMMON";
1319 else if (elf_header
.e_machine
== EM_MIPS
1320 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1321 sec_name
= "SCOMMON";
1322 else if (elf_header
.e_machine
== EM_MIPS
1323 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1324 sec_name
= "SUNDEF";
1325 else if (elf_header
.e_machine
== EM_X86_64
1326 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1327 sec_name
= "LARGE_COMMON";
1328 else if (elf_header
.e_machine
== EM_IA_64
1329 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1330 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1331 sec_name
= "ANSI_COM";
1334 sprintf (name_buf
, "<section 0x%x>",
1335 (unsigned int) psym
->st_shndx
);
1336 sec_name
= name_buf
;
1339 print_symbol (22, sec_name
);
1341 else if (strtab
== NULL
)
1342 printf (_("<string table index: %3ld>"), psym
->st_name
);
1343 else if (psym
->st_name
>= strtablen
)
1344 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1346 print_symbol (22, strtab
+ psym
->st_name
);
1349 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1354 printf ("%*c", is_32bit_elf
?
1355 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1356 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1359 if (elf_header
.e_machine
== EM_SPARCV9
1361 && streq (rtype
, "R_SPARC_OLO10"))
1362 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1367 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1369 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1370 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1371 const char *rtype2
= elf_mips_reloc_type (type2
);
1372 const char *rtype3
= elf_mips_reloc_type (type3
);
1374 printf (" Type2: ");
1377 printf (_("unrecognized: %-7lx"),
1378 (unsigned long) type2
& 0xffffffff);
1380 printf ("%-17.17s", rtype2
);
1382 printf ("\n Type3: ");
1385 printf (_("unrecognized: %-7lx"),
1386 (unsigned long) type3
& 0xffffffff);
1388 printf ("%-17.17s", rtype3
);
1399 get_mips_dynamic_type (unsigned long type
)
1403 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1404 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1405 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1406 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1407 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1408 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1409 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1410 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1411 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1412 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1413 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1414 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1415 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1416 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1417 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1418 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1419 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1420 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1421 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1422 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1423 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1424 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1425 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1426 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1427 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1428 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1429 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1430 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1431 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1432 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1433 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1434 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1435 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1436 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1437 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1438 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1439 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1440 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1441 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1442 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1443 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1444 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1445 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1452 get_sparc64_dynamic_type (unsigned long type
)
1456 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1463 get_ppc_dynamic_type (unsigned long type
)
1467 case DT_PPC_GOT
: return "PPC_GOT";
1474 get_ppc64_dynamic_type (unsigned long type
)
1478 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1479 case DT_PPC64_OPD
: return "PPC64_OPD";
1480 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1487 get_parisc_dynamic_type (unsigned long type
)
1491 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1492 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1493 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1494 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1495 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1496 case DT_HP_PREINIT
: return "HP_PREINIT";
1497 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1498 case DT_HP_NEEDED
: return "HP_NEEDED";
1499 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1500 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1501 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1502 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1503 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1504 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1505 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1506 case DT_HP_FILTERED
: return "HP_FILTERED";
1507 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1508 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1509 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1510 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1511 case DT_PLT
: return "PLT";
1512 case DT_PLT_SIZE
: return "PLT_SIZE";
1513 case DT_DLT
: return "DLT";
1514 case DT_DLT_SIZE
: return "DLT_SIZE";
1521 get_ia64_dynamic_type (unsigned long type
)
1525 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1532 get_alpha_dynamic_type (unsigned long type
)
1536 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1543 get_score_dynamic_type (unsigned long type
)
1547 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1548 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1549 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1550 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1551 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1552 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1560 get_dynamic_type (unsigned long type
)
1562 static char buff
[64];
1566 case DT_NULL
: return "NULL";
1567 case DT_NEEDED
: return "NEEDED";
1568 case DT_PLTRELSZ
: return "PLTRELSZ";
1569 case DT_PLTGOT
: return "PLTGOT";
1570 case DT_HASH
: return "HASH";
1571 case DT_STRTAB
: return "STRTAB";
1572 case DT_SYMTAB
: return "SYMTAB";
1573 case DT_RELA
: return "RELA";
1574 case DT_RELASZ
: return "RELASZ";
1575 case DT_RELAENT
: return "RELAENT";
1576 case DT_STRSZ
: return "STRSZ";
1577 case DT_SYMENT
: return "SYMENT";
1578 case DT_INIT
: return "INIT";
1579 case DT_FINI
: return "FINI";
1580 case DT_SONAME
: return "SONAME";
1581 case DT_RPATH
: return "RPATH";
1582 case DT_SYMBOLIC
: return "SYMBOLIC";
1583 case DT_REL
: return "REL";
1584 case DT_RELSZ
: return "RELSZ";
1585 case DT_RELENT
: return "RELENT";
1586 case DT_PLTREL
: return "PLTREL";
1587 case DT_DEBUG
: return "DEBUG";
1588 case DT_TEXTREL
: return "TEXTREL";
1589 case DT_JMPREL
: return "JMPREL";
1590 case DT_BIND_NOW
: return "BIND_NOW";
1591 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1592 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1593 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1594 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1595 case DT_RUNPATH
: return "RUNPATH";
1596 case DT_FLAGS
: return "FLAGS";
1598 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1599 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1601 case DT_CHECKSUM
: return "CHECKSUM";
1602 case DT_PLTPADSZ
: return "PLTPADSZ";
1603 case DT_MOVEENT
: return "MOVEENT";
1604 case DT_MOVESZ
: return "MOVESZ";
1605 case DT_FEATURE
: return "FEATURE";
1606 case DT_POSFLAG_1
: return "POSFLAG_1";
1607 case DT_SYMINSZ
: return "SYMINSZ";
1608 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1610 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1611 case DT_CONFIG
: return "CONFIG";
1612 case DT_DEPAUDIT
: return "DEPAUDIT";
1613 case DT_AUDIT
: return "AUDIT";
1614 case DT_PLTPAD
: return "PLTPAD";
1615 case DT_MOVETAB
: return "MOVETAB";
1616 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1618 case DT_VERSYM
: return "VERSYM";
1620 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1621 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1622 case DT_RELACOUNT
: return "RELACOUNT";
1623 case DT_RELCOUNT
: return "RELCOUNT";
1624 case DT_FLAGS_1
: return "FLAGS_1";
1625 case DT_VERDEF
: return "VERDEF";
1626 case DT_VERDEFNUM
: return "VERDEFNUM";
1627 case DT_VERNEED
: return "VERNEED";
1628 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1630 case DT_AUXILIARY
: return "AUXILIARY";
1631 case DT_USED
: return "USED";
1632 case DT_FILTER
: return "FILTER";
1634 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1635 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1636 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1637 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1638 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1639 case DT_GNU_HASH
: return "GNU_HASH";
1642 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1646 switch (elf_header
.e_machine
)
1649 case EM_MIPS_RS3_LE
:
1650 result
= get_mips_dynamic_type (type
);
1653 result
= get_sparc64_dynamic_type (type
);
1656 result
= get_ppc_dynamic_type (type
);
1659 result
= get_ppc64_dynamic_type (type
);
1662 result
= get_ia64_dynamic_type (type
);
1665 result
= get_alpha_dynamic_type (type
);
1668 result
= get_score_dynamic_type (type
);
1678 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1680 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1681 || (elf_header
.e_machine
== EM_PARISC
1682 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1686 switch (elf_header
.e_machine
)
1689 result
= get_parisc_dynamic_type (type
);
1699 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1703 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1710 get_file_type (unsigned e_type
)
1712 static char buff
[32];
1716 case ET_NONE
: return _("NONE (None)");
1717 case ET_REL
: return _("REL (Relocatable file)");
1718 case ET_EXEC
: return _("EXEC (Executable file)");
1719 case ET_DYN
: return _("DYN (Shared object file)");
1720 case ET_CORE
: return _("CORE (Core file)");
1723 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1724 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1725 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1726 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1728 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1734 get_machine_name (unsigned e_machine
)
1736 static char buff
[64]; /* XXX */
1740 case EM_NONE
: return _("None");
1741 case EM_M32
: return "WE32100";
1742 case EM_SPARC
: return "Sparc";
1743 case EM_SPU
: return "SPU";
1744 case EM_386
: return "Intel 80386";
1745 case EM_68K
: return "MC68000";
1746 case EM_88K
: return "MC88000";
1747 case EM_486
: return "Intel 80486";
1748 case EM_860
: return "Intel 80860";
1749 case EM_MIPS
: return "MIPS R3000";
1750 case EM_S370
: return "IBM System/370";
1751 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1752 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1753 case EM_PARISC
: return "HPPA";
1754 case EM_PPC_OLD
: return "Power PC (old)";
1755 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1756 case EM_960
: return "Intel 90860";
1757 case EM_PPC
: return "PowerPC";
1758 case EM_PPC64
: return "PowerPC64";
1759 case EM_V800
: return "NEC V800";
1760 case EM_FR20
: return "Fujitsu FR20";
1761 case EM_RH32
: return "TRW RH32";
1762 case EM_MCORE
: return "MCORE";
1763 case EM_ARM
: return "ARM";
1764 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1765 case EM_SH
: return "Renesas / SuperH SH";
1766 case EM_SPARCV9
: return "Sparc v9";
1767 case EM_TRICORE
: return "Siemens Tricore";
1768 case EM_ARC
: return "ARC";
1769 case EM_H8_300
: return "Renesas H8/300";
1770 case EM_H8_300H
: return "Renesas H8/300H";
1771 case EM_H8S
: return "Renesas H8S";
1772 case EM_H8_500
: return "Renesas H8/500";
1773 case EM_IA_64
: return "Intel IA-64";
1774 case EM_MIPS_X
: return "Stanford MIPS-X";
1775 case EM_COLDFIRE
: return "Motorola Coldfire";
1776 case EM_68HC12
: return "Motorola M68HC12";
1777 case EM_ALPHA
: return "Alpha";
1778 case EM_CYGNUS_D10V
:
1779 case EM_D10V
: return "d10v";
1780 case EM_CYGNUS_D30V
:
1781 case EM_D30V
: return "d30v";
1782 case EM_CYGNUS_M32R
:
1783 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1784 case EM_CYGNUS_V850
:
1785 case EM_V850
: return "NEC v850";
1786 case EM_CYGNUS_MN10300
:
1787 case EM_MN10300
: return "mn10300";
1788 case EM_CYGNUS_MN10200
:
1789 case EM_MN10200
: return "mn10200";
1790 case EM_CYGNUS_FR30
:
1791 case EM_FR30
: return "Fujitsu FR30";
1792 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1794 case EM_PJ
: return "picoJava";
1795 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1796 case EM_PCP
: return "Siemens PCP";
1797 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1798 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1799 case EM_STARCORE
: return "Motorola Star*Core processor";
1800 case EM_ME16
: return "Toyota ME16 processor";
1801 case EM_ST100
: return "STMicroelectronics ST100 processor";
1802 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1803 case EM_FX66
: return "Siemens FX66 microcontroller";
1804 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1805 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1806 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1807 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1808 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1809 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1810 case EM_SVX
: return "Silicon Graphics SVx";
1811 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1812 case EM_VAX
: return "Digital VAX";
1814 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1815 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1816 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1817 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1818 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1819 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1820 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1821 case EM_PRISM
: return "Vitesse Prism";
1822 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1824 case EM_S390
: return "IBM S/390";
1825 case EM_SCORE
: return "SUNPLUS S+Core";
1826 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1828 case EM_OR32
: return "OpenRISC";
1829 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1830 case EM_DLX
: return "OpenDLX";
1832 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1833 case EM_IQ2000
: return "Vitesse IQ2000";
1835 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1836 case EM_M32C
: return "Renesas M32c";
1837 case EM_MT
: return "Morpho Techologies MT processor";
1838 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1839 case EM_NIOS32
: return "Altera Nios";
1840 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1841 case EM_XC16X
: return "Infineon Technologies xc16x";
1842 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1843 case EM_CR16
: return "National Semiconductor's CR16";
1845 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1851 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1856 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1857 e_flags
&= ~ EF_ARM_EABIMASK
;
1859 /* Handle "generic" ARM flags. */
1860 if (e_flags
& EF_ARM_RELEXEC
)
1862 strcat (buf
, ", relocatable executable");
1863 e_flags
&= ~ EF_ARM_RELEXEC
;
1866 if (e_flags
& EF_ARM_HASENTRY
)
1868 strcat (buf
, ", has entry point");
1869 e_flags
&= ~ EF_ARM_HASENTRY
;
1872 /* Now handle EABI specific flags. */
1876 strcat (buf
, ", <unrecognized EABI>");
1881 case EF_ARM_EABI_VER1
:
1882 strcat (buf
, ", Version1 EABI");
1887 /* Process flags one bit at a time. */
1888 flag
= e_flags
& - e_flags
;
1893 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1894 strcat (buf
, ", sorted symbol tables");
1904 case EF_ARM_EABI_VER2
:
1905 strcat (buf
, ", Version2 EABI");
1910 /* Process flags one bit at a time. */
1911 flag
= e_flags
& - e_flags
;
1916 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1917 strcat (buf
, ", sorted symbol tables");
1920 case EF_ARM_DYNSYMSUSESEGIDX
:
1921 strcat (buf
, ", dynamic symbols use segment index");
1924 case EF_ARM_MAPSYMSFIRST
:
1925 strcat (buf
, ", mapping symbols precede others");
1935 case EF_ARM_EABI_VER3
:
1936 strcat (buf
, ", Version3 EABI");
1939 case EF_ARM_EABI_VER4
:
1940 strcat (buf
, ", Version4 EABI");
1943 case EF_ARM_EABI_VER5
:
1944 strcat (buf
, ", Version5 EABI");
1950 /* Process flags one bit at a time. */
1951 flag
= e_flags
& - e_flags
;
1957 strcat (buf
, ", BE8");
1961 strcat (buf
, ", LE8");
1971 case EF_ARM_EABI_UNKNOWN
:
1972 strcat (buf
, ", GNU EABI");
1977 /* Process flags one bit at a time. */
1978 flag
= e_flags
& - e_flags
;
1983 case EF_ARM_INTERWORK
:
1984 strcat (buf
, ", interworking enabled");
1987 case EF_ARM_APCS_26
:
1988 strcat (buf
, ", uses APCS/26");
1991 case EF_ARM_APCS_FLOAT
:
1992 strcat (buf
, ", uses APCS/float");
1996 strcat (buf
, ", position independent");
2000 strcat (buf
, ", 8 bit structure alignment");
2003 case EF_ARM_NEW_ABI
:
2004 strcat (buf
, ", uses new ABI");
2007 case EF_ARM_OLD_ABI
:
2008 strcat (buf
, ", uses old ABI");
2011 case EF_ARM_SOFT_FLOAT
:
2012 strcat (buf
, ", software FP");
2015 case EF_ARM_VFP_FLOAT
:
2016 strcat (buf
, ", VFP");
2019 case EF_ARM_MAVERICK_FLOAT
:
2020 strcat (buf
, ", Maverick FP");
2031 strcat (buf
,", <unknown>");
2035 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2037 static char buf
[1024];
2049 decode_ARM_machine_flags (e_flags
, buf
);
2053 switch (e_flags
& EF_FRV_CPU_MASK
)
2055 case EF_FRV_CPU_GENERIC
:
2059 strcat (buf
, ", fr???");
2062 case EF_FRV_CPU_FR300
:
2063 strcat (buf
, ", fr300");
2066 case EF_FRV_CPU_FR400
:
2067 strcat (buf
, ", fr400");
2069 case EF_FRV_CPU_FR405
:
2070 strcat (buf
, ", fr405");
2073 case EF_FRV_CPU_FR450
:
2074 strcat (buf
, ", fr450");
2077 case EF_FRV_CPU_FR500
:
2078 strcat (buf
, ", fr500");
2080 case EF_FRV_CPU_FR550
:
2081 strcat (buf
, ", fr550");
2084 case EF_FRV_CPU_SIMPLE
:
2085 strcat (buf
, ", simple");
2087 case EF_FRV_CPU_TOMCAT
:
2088 strcat (buf
, ", tomcat");
2094 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2095 strcat (buf
, ", m68000");
2096 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2097 strcat (buf
, ", cpu32");
2098 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2099 strcat (buf
, ", fido_a");
2102 char const *isa
= _("unknown");
2103 char const *mac
= _("unknown mac");
2104 char const *additional
= NULL
;
2106 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2108 case EF_M68K_CF_ISA_A_NODIV
:
2110 additional
= ", nodiv";
2112 case EF_M68K_CF_ISA_A
:
2115 case EF_M68K_CF_ISA_A_PLUS
:
2118 case EF_M68K_CF_ISA_B_NOUSP
:
2120 additional
= ", nousp";
2122 case EF_M68K_CF_ISA_B
:
2126 strcat (buf
, ", cf, isa ");
2129 strcat (buf
, additional
);
2130 if (e_flags
& EF_M68K_CF_FLOAT
)
2131 strcat (buf
, ", float");
2132 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2137 case EF_M68K_CF_MAC
:
2140 case EF_M68K_CF_EMAC
:
2153 if (e_flags
& EF_PPC_EMB
)
2154 strcat (buf
, ", emb");
2156 if (e_flags
& EF_PPC_RELOCATABLE
)
2157 strcat (buf
, ", relocatable");
2159 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2160 strcat (buf
, ", relocatable-lib");
2164 case EM_CYGNUS_V850
:
2165 switch (e_flags
& EF_V850_ARCH
)
2168 strcat (buf
, ", v850e1");
2171 strcat (buf
, ", v850e");
2174 strcat (buf
, ", v850");
2177 strcat (buf
, ", unknown v850 architecture variant");
2183 case EM_CYGNUS_M32R
:
2184 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2185 strcat (buf
, ", m32r");
2189 case EM_MIPS_RS3_LE
:
2190 if (e_flags
& EF_MIPS_NOREORDER
)
2191 strcat (buf
, ", noreorder");
2193 if (e_flags
& EF_MIPS_PIC
)
2194 strcat (buf
, ", pic");
2196 if (e_flags
& EF_MIPS_CPIC
)
2197 strcat (buf
, ", cpic");
2199 if (e_flags
& EF_MIPS_UCODE
)
2200 strcat (buf
, ", ugen_reserved");
2202 if (e_flags
& EF_MIPS_ABI2
)
2203 strcat (buf
, ", abi2");
2205 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2206 strcat (buf
, ", odk first");
2208 if (e_flags
& EF_MIPS_32BITMODE
)
2209 strcat (buf
, ", 32bitmode");
2211 switch ((e_flags
& EF_MIPS_MACH
))
2213 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2214 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2215 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2216 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2217 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2218 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2219 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2220 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2221 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2222 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2223 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2224 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2226 /* We simply ignore the field in this case to avoid confusion:
2227 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2230 default: strcat (buf
, ", unknown CPU"); break;
2233 switch ((e_flags
& EF_MIPS_ABI
))
2235 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2236 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2237 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2238 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2240 /* We simply ignore the field in this case to avoid confusion:
2241 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2242 This means it is likely to be an o32 file, but not for
2245 default: strcat (buf
, ", unknown ABI"); break;
2248 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2249 strcat (buf
, ", mdmx");
2251 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2252 strcat (buf
, ", mips16");
2254 switch ((e_flags
& EF_MIPS_ARCH
))
2256 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2257 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2258 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2259 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2260 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2261 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2262 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2263 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2264 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2265 default: strcat (buf
, ", unknown ISA"); break;
2271 switch ((e_flags
& EF_SH_MACH_MASK
))
2273 case EF_SH1
: strcat (buf
, ", sh1"); break;
2274 case EF_SH2
: strcat (buf
, ", sh2"); break;
2275 case EF_SH3
: strcat (buf
, ", sh3"); break;
2276 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2277 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2278 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2279 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2280 case EF_SH4
: strcat (buf
, ", sh4"); break;
2281 case EF_SH5
: strcat (buf
, ", sh5"); break;
2282 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2283 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2284 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2285 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2286 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2287 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2288 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2289 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2290 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2291 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2292 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2293 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2294 default: strcat (buf
, ", unknown ISA"); break;
2300 if (e_flags
& EF_SPARC_32PLUS
)
2301 strcat (buf
, ", v8+");
2303 if (e_flags
& EF_SPARC_SUN_US1
)
2304 strcat (buf
, ", ultrasparcI");
2306 if (e_flags
& EF_SPARC_SUN_US3
)
2307 strcat (buf
, ", ultrasparcIII");
2309 if (e_flags
& EF_SPARC_HAL_R1
)
2310 strcat (buf
, ", halr1");
2312 if (e_flags
& EF_SPARC_LEDATA
)
2313 strcat (buf
, ", ledata");
2315 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2316 strcat (buf
, ", tso");
2318 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2319 strcat (buf
, ", pso");
2321 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2322 strcat (buf
, ", rmo");
2326 switch (e_flags
& EF_PARISC_ARCH
)
2328 case EFA_PARISC_1_0
:
2329 strcpy (buf
, ", PA-RISC 1.0");
2331 case EFA_PARISC_1_1
:
2332 strcpy (buf
, ", PA-RISC 1.1");
2334 case EFA_PARISC_2_0
:
2335 strcpy (buf
, ", PA-RISC 2.0");
2340 if (e_flags
& EF_PARISC_TRAPNIL
)
2341 strcat (buf
, ", trapnil");
2342 if (e_flags
& EF_PARISC_EXT
)
2343 strcat (buf
, ", ext");
2344 if (e_flags
& EF_PARISC_LSB
)
2345 strcat (buf
, ", lsb");
2346 if (e_flags
& EF_PARISC_WIDE
)
2347 strcat (buf
, ", wide");
2348 if (e_flags
& EF_PARISC_NO_KABP
)
2349 strcat (buf
, ", no kabp");
2350 if (e_flags
& EF_PARISC_LAZYSWAP
)
2351 strcat (buf
, ", lazyswap");
2356 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2357 strcat (buf
, ", new calling convention");
2359 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2360 strcat (buf
, ", gnu calling convention");
2364 if ((e_flags
& EF_IA_64_ABI64
))
2365 strcat (buf
, ", 64-bit");
2367 strcat (buf
, ", 32-bit");
2368 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2369 strcat (buf
, ", reduced fp model");
2370 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2371 strcat (buf
, ", no function descriptors, constant gp");
2372 else if ((e_flags
& EF_IA_64_CONS_GP
))
2373 strcat (buf
, ", constant gp");
2374 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2375 strcat (buf
, ", absolute");
2379 if ((e_flags
& EF_VAX_NONPIC
))
2380 strcat (buf
, ", non-PIC");
2381 if ((e_flags
& EF_VAX_DFLOAT
))
2382 strcat (buf
, ", D-Float");
2383 if ((e_flags
& EF_VAX_GFLOAT
))
2384 strcat (buf
, ", G-Float");
2393 get_osabi_name (unsigned int osabi
)
2395 static char buff
[32];
2399 case ELFOSABI_NONE
: return "UNIX - System V";
2400 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2401 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2402 case ELFOSABI_LINUX
: return "UNIX - Linux";
2403 case ELFOSABI_HURD
: return "GNU/Hurd";
2404 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2405 case ELFOSABI_AIX
: return "UNIX - AIX";
2406 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2407 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2408 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2409 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2410 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2411 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2412 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2413 case ELFOSABI_AROS
: return "Amiga Research OS";
2414 case ELFOSABI_STANDALONE
: return _("Standalone App");
2415 case ELFOSABI_ARM
: return "ARM";
2417 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2423 get_arm_segment_type (unsigned long type
)
2437 get_mips_segment_type (unsigned long type
)
2441 case PT_MIPS_REGINFO
:
2443 case PT_MIPS_RTPROC
:
2445 case PT_MIPS_OPTIONS
:
2455 get_parisc_segment_type (unsigned long type
)
2459 case PT_HP_TLS
: return "HP_TLS";
2460 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2461 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2462 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2463 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2464 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2465 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2466 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2467 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2468 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2469 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2470 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2471 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2472 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2473 case PT_HP_STACK
: return "HP_STACK";
2474 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2475 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2476 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2477 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2486 get_ia64_segment_type (unsigned long type
)
2490 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2491 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2492 case PT_HP_TLS
: return "HP_TLS";
2493 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2494 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2495 case PT_IA_64_HP_STACK
: return "HP_STACK";
2504 get_segment_type (unsigned long p_type
)
2506 static char buff
[32];
2510 case PT_NULL
: return "NULL";
2511 case PT_LOAD
: return "LOAD";
2512 case PT_DYNAMIC
: return "DYNAMIC";
2513 case PT_INTERP
: return "INTERP";
2514 case PT_NOTE
: return "NOTE";
2515 case PT_SHLIB
: return "SHLIB";
2516 case PT_PHDR
: return "PHDR";
2517 case PT_TLS
: return "TLS";
2519 case PT_GNU_EH_FRAME
:
2520 return "GNU_EH_FRAME";
2521 case PT_GNU_STACK
: return "GNU_STACK";
2522 case PT_GNU_RELRO
: return "GNU_RELRO";
2525 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2529 switch (elf_header
.e_machine
)
2532 result
= get_arm_segment_type (p_type
);
2535 case EM_MIPS_RS3_LE
:
2536 result
= get_mips_segment_type (p_type
);
2539 result
= get_parisc_segment_type (p_type
);
2542 result
= get_ia64_segment_type (p_type
);
2552 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2554 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2558 switch (elf_header
.e_machine
)
2561 result
= get_parisc_segment_type (p_type
);
2564 result
= get_ia64_segment_type (p_type
);
2574 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2577 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2584 get_mips_section_type_name (unsigned int sh_type
)
2588 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2589 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2590 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2591 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2592 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2593 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2594 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2595 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2596 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2597 case SHT_MIPS_RELD
: return "MIPS_RELD";
2598 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2599 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2600 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2601 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2602 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2603 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2604 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2605 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2606 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2607 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2608 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2609 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2610 case SHT_MIPS_LINE
: return "MIPS_LINE";
2611 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2612 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2613 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2614 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2615 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2616 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2617 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2618 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2619 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2620 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2621 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2622 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2623 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2624 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2625 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2626 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2634 get_parisc_section_type_name (unsigned int sh_type
)
2638 case SHT_PARISC_EXT
: return "PARISC_EXT";
2639 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2640 case SHT_PARISC_DOC
: return "PARISC_DOC";
2641 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2642 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2643 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2644 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2652 get_ia64_section_type_name (unsigned int sh_type
)
2654 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2655 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2656 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2660 case SHT_IA_64_EXT
: return "IA_64_EXT";
2661 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2662 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2670 get_x86_64_section_type_name (unsigned int sh_type
)
2674 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2682 get_arm_section_type_name (unsigned int sh_type
)
2688 case SHT_ARM_PREEMPTMAP
:
2689 return "ARM_PREEMPTMAP";
2690 case SHT_ARM_ATTRIBUTES
:
2691 return "ARM_ATTRIBUTES";
2699 get_section_type_name (unsigned int sh_type
)
2701 static char buff
[32];
2705 case SHT_NULL
: return "NULL";
2706 case SHT_PROGBITS
: return "PROGBITS";
2707 case SHT_SYMTAB
: return "SYMTAB";
2708 case SHT_STRTAB
: return "STRTAB";
2709 case SHT_RELA
: return "RELA";
2710 case SHT_HASH
: return "HASH";
2711 case SHT_DYNAMIC
: return "DYNAMIC";
2712 case SHT_NOTE
: return "NOTE";
2713 case SHT_NOBITS
: return "NOBITS";
2714 case SHT_REL
: return "REL";
2715 case SHT_SHLIB
: return "SHLIB";
2716 case SHT_DYNSYM
: return "DYNSYM";
2717 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2718 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2719 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2720 case SHT_GNU_HASH
: return "GNU_HASH";
2721 case SHT_GROUP
: return "GROUP";
2722 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2723 case SHT_GNU_verdef
: return "VERDEF";
2724 case SHT_GNU_verneed
: return "VERNEED";
2725 case SHT_GNU_versym
: return "VERSYM";
2726 case 0x6ffffff0: return "VERSYM";
2727 case 0x6ffffffc: return "VERDEF";
2728 case 0x7ffffffd: return "AUXILIARY";
2729 case 0x7fffffff: return "FILTER";
2730 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2733 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2737 switch (elf_header
.e_machine
)
2740 case EM_MIPS_RS3_LE
:
2741 result
= get_mips_section_type_name (sh_type
);
2744 result
= get_parisc_section_type_name (sh_type
);
2747 result
= get_ia64_section_type_name (sh_type
);
2750 result
= get_x86_64_section_type_name (sh_type
);
2753 result
= get_arm_section_type_name (sh_type
);
2763 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2765 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2766 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2767 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2768 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2770 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2776 #define OPTION_DEBUG_DUMP 512
2778 static struct option options
[] =
2780 {"all", no_argument
, 0, 'a'},
2781 {"file-header", no_argument
, 0, 'h'},
2782 {"program-headers", no_argument
, 0, 'l'},
2783 {"headers", no_argument
, 0, 'e'},
2784 {"histogram", no_argument
, 0, 'I'},
2785 {"segments", no_argument
, 0, 'l'},
2786 {"sections", no_argument
, 0, 'S'},
2787 {"section-headers", no_argument
, 0, 'S'},
2788 {"section-groups", no_argument
, 0, 'g'},
2789 {"section-details", no_argument
, 0, 't'},
2790 {"full-section-name",no_argument
, 0, 'N'},
2791 {"symbols", no_argument
, 0, 's'},
2792 {"syms", no_argument
, 0, 's'},
2793 {"relocs", no_argument
, 0, 'r'},
2794 {"notes", no_argument
, 0, 'n'},
2795 {"dynamic", no_argument
, 0, 'd'},
2796 {"arch-specific", no_argument
, 0, 'A'},
2797 {"version-info", no_argument
, 0, 'V'},
2798 {"use-dynamic", no_argument
, 0, 'D'},
2799 {"unwind", no_argument
, 0, 'u'},
2800 {"archive-index", no_argument
, 0, 'c'},
2801 {"hex-dump", required_argument
, 0, 'x'},
2802 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2803 {"string-dump", required_argument
, 0, 'p'},
2804 #ifdef SUPPORT_DISASSEMBLY
2805 {"instruction-dump", required_argument
, 0, 'i'},
2808 {"version", no_argument
, 0, 'v'},
2809 {"wide", no_argument
, 0, 'W'},
2810 {"help", no_argument
, 0, 'H'},
2811 {0, no_argument
, 0, 0}
2815 usage (FILE *stream
)
2817 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2818 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2819 fprintf (stream
, _(" Options are:\n\
2820 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2821 -h --file-header Display the ELF file header\n\
2822 -l --program-headers Display the program headers\n\
2823 --segments An alias for --program-headers\n\
2824 -S --section-headers Display the sections' header\n\
2825 --sections An alias for --section-headers\n\
2826 -g --section-groups Display the section groups\n\
2827 -t --section-details Display the section details\n\
2828 -e --headers Equivalent to: -h -l -S\n\
2829 -s --syms Display the symbol table\n\
2830 --symbols An alias for --syms\n\
2831 -n --notes Display the core notes (if present)\n\
2832 -r --relocs Display the relocations (if present)\n\
2833 -u --unwind Display the unwind info (if present)\n\
2834 -d --dynamic Display the dynamic section (if present)\n\
2835 -V --version-info Display the version sections (if present)\n\
2836 -A --arch-specific Display architecture specific information (if any).\n\
2837 -c --archive-index Display the symbol/file index in an archive\n\
2838 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2839 -x --hex-dump=<number|name>\n\
2840 Dump the contents of section <number|name> as bytes\n\
2841 -p --string-dump=<number|name>\n\
2842 Dump the contents of section <number|name> as strings\n\
2843 -w[liaprmfFsoR] or\n\
2844 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2845 Display the contents of DWARF2 debug sections\n"));
2846 #ifdef SUPPORT_DISASSEMBLY
2847 fprintf (stream
, _("\
2848 -i --instruction-dump=<number|name>\n\
2849 Disassemble the contents of section <number|name>\n"));
2851 fprintf (stream
, _("\
2852 -I --histogram Display histogram of bucket list lengths\n\
2853 -W --wide Allow output width to exceed 80 characters\n\
2854 @<file> Read options from <file>\n\
2855 -H --help Display this information\n\
2856 -v --version Display the version number of readelf\n"));
2858 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2859 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2861 exit (stream
== stdout
? 0 : 1);
2864 /* Record the fact that the user wants the contents of section number
2865 SECTION to be displayed using the method(s) encoded as flags bits
2866 in TYPE. Note, TYPE can be zero if we are creating the array for
2870 request_dump_bynumber (unsigned int section
, dump_type type
)
2872 if (section
>= num_dump_sects
)
2874 dump_type
*new_dump_sects
;
2876 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2878 if (new_dump_sects
== NULL
)
2879 error (_("Out of memory allocating dump request table.\n"));
2882 /* Copy current flag settings. */
2883 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2887 dump_sects
= new_dump_sects
;
2888 num_dump_sects
= section
+ 1;
2893 dump_sects
[section
] |= type
;
2898 /* Request a dump by section name. */
2901 request_dump_byname (const char *section
, dump_type type
)
2903 struct dump_list_entry
*new_request
;
2905 new_request
= malloc (sizeof (struct dump_list_entry
));
2907 error (_("Out of memory allocating dump request table.\n"));
2909 new_request
->name
= strdup (section
);
2910 if (!new_request
->name
)
2911 error (_("Out of memory allocating dump request table.\n"));
2913 new_request
->type
= type
;
2915 new_request
->next
= dump_sects_byname
;
2916 dump_sects_byname
= new_request
;
2920 parse_args (int argc
, char **argv
)
2927 while ((c
= getopt_long
2928 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
2949 do_section_groups
++;
2957 do_section_groups
++;
2962 do_section_details
++;
3007 section
= strtoul (optarg
, & cp
, 0);
3008 if (! *cp
&& section
>= 0)
3009 request_dump_bynumber (section
, HEX_DUMP
);
3011 request_dump_byname (optarg
, HEX_DUMP
);
3015 section
= strtoul (optarg
, & cp
, 0);
3016 if (! *cp
&& section
>= 0)
3017 request_dump_bynumber (section
, STRING_DUMP
);
3019 request_dump_byname (optarg
, STRING_DUMP
);
3027 unsigned int index
= 0;
3031 while (optarg
[index
])
3032 switch (optarg
[index
++])
3041 do_debug_abbrevs
= 1;
3051 do_debug_pubnames
= 1;
3055 do_debug_aranges
= 1;
3059 do_debug_ranges
= 1;
3063 do_debug_frames_interp
= 1;
3065 do_debug_frames
= 1;
3070 do_debug_macinfo
= 1;
3084 warn (_("Unrecognized debug option '%s'\n"), optarg
);
3089 case OPTION_DEBUG_DUMP
:
3097 const char * option
;
3100 debug_dump_long_opts
;
3102 debug_dump_long_opts opts_table
[] =
3104 /* Please keep this table alpha- sorted. */
3105 { "Ranges", & do_debug_ranges
},
3106 { "abbrev", & do_debug_abbrevs
},
3107 { "aranges", & do_debug_aranges
},
3108 { "frames", & do_debug_frames
},
3109 { "frames-interp", & do_debug_frames_interp
},
3110 { "info", & do_debug_info
},
3111 { "line", & do_debug_lines
},
3112 { "loc", & do_debug_loc
},
3113 { "macro", & do_debug_macinfo
},
3114 { "pubnames", & do_debug_pubnames
},
3115 /* This entry is for compatability
3116 with earlier versions of readelf. */
3117 { "ranges", & do_debug_aranges
},
3118 { "str", & do_debug_str
},
3129 debug_dump_long_opts
* entry
;
3131 for (entry
= opts_table
; entry
->option
; entry
++)
3133 size_t len
= strlen (entry
->option
);
3135 if (strneq (p
, entry
->option
, len
)
3136 && (p
[len
] == ',' || p
[len
] == '\0'))
3138 * entry
->variable
= 1;
3140 /* The --debug-dump=frames-interp option also
3141 enables the --debug-dump=frames option. */
3142 if (do_debug_frames_interp
)
3143 do_debug_frames
= 1;
3150 if (entry
->option
== NULL
)
3152 warn (_("Unrecognized debug option '%s'\n"), p
);
3153 p
= strchr (p
, ',');
3163 #ifdef SUPPORT_DISASSEMBLY
3166 section
= strtoul (optarg
, & cp
, 0);
3167 if (! *cp
&& section
>= 0)
3168 request_dump_bynumber (section
, DISASS_DUMP
);
3170 request_dump_byname (optarg
, DISASS_DUMP
);
3173 print_version (program_name
);
3182 /* xgettext:c-format */
3183 error (_("Invalid option '-%c'\n"), c
);
3190 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3191 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3192 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3193 && !do_section_groups
&& !do_archive_index
)
3197 warn (_("Nothing to do.\n"));
3203 get_elf_class (unsigned int elf_class
)
3205 static char buff
[32];
3209 case ELFCLASSNONE
: return _("none");
3210 case ELFCLASS32
: return "ELF32";
3211 case ELFCLASS64
: return "ELF64";
3213 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3219 get_data_encoding (unsigned int encoding
)
3221 static char buff
[32];
3225 case ELFDATANONE
: return _("none");
3226 case ELFDATA2LSB
: return _("2's complement, little endian");
3227 case ELFDATA2MSB
: return _("2's complement, big endian");
3229 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3234 /* Decode the data held in 'elf_header'. */
3237 process_file_header (void)
3239 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3240 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3241 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3242 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3245 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3253 printf (_("ELF Header:\n"));
3254 printf (_(" Magic: "));
3255 for (i
= 0; i
< EI_NIDENT
; i
++)
3256 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3258 printf (_(" Class: %s\n"),
3259 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3260 printf (_(" Data: %s\n"),
3261 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3262 printf (_(" Version: %d %s\n"),
3263 elf_header
.e_ident
[EI_VERSION
],
3264 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3266 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3269 printf (_(" OS/ABI: %s\n"),
3270 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3271 printf (_(" ABI Version: %d\n"),
3272 elf_header
.e_ident
[EI_ABIVERSION
]);
3273 printf (_(" Type: %s\n"),
3274 get_file_type (elf_header
.e_type
));
3275 printf (_(" Machine: %s\n"),
3276 get_machine_name (elf_header
.e_machine
));
3277 printf (_(" Version: 0x%lx\n"),
3278 (unsigned long) elf_header
.e_version
);
3280 printf (_(" Entry point address: "));
3281 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3282 printf (_("\n Start of program headers: "));
3283 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3284 printf (_(" (bytes into file)\n Start of section headers: "));
3285 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3286 printf (_(" (bytes into file)\n"));
3288 printf (_(" Flags: 0x%lx%s\n"),
3289 (unsigned long) elf_header
.e_flags
,
3290 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3291 printf (_(" Size of this header: %ld (bytes)\n"),
3292 (long) elf_header
.e_ehsize
);
3293 printf (_(" Size of program headers: %ld (bytes)\n"),
3294 (long) elf_header
.e_phentsize
);
3295 printf (_(" Number of program headers: %ld\n"),
3296 (long) elf_header
.e_phnum
);
3297 printf (_(" Size of section headers: %ld (bytes)\n"),
3298 (long) elf_header
.e_shentsize
);
3299 printf (_(" Number of section headers: %ld"),
3300 (long) elf_header
.e_shnum
);
3301 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3302 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3303 putc ('\n', stdout
);
3304 printf (_(" Section header string table index: %ld"),
3305 (long) elf_header
.e_shstrndx
);
3306 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3307 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3308 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3309 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3310 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3311 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3312 printf (" <corrupt: out of range>");
3313 putc ('\n', stdout
);
3316 if (section_headers
!= NULL
)
3318 if (elf_header
.e_shnum
== 0)
3319 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3320 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3321 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3322 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3323 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3324 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3325 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3326 elf_header
.e_shstrndx
= SHN_UNDEF
;
3327 free (section_headers
);
3328 section_headers
= NULL
;
3336 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3338 Elf32_External_Phdr
*phdrs
;
3339 Elf32_External_Phdr
*external
;
3340 Elf_Internal_Phdr
*internal
;
3343 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3344 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3345 _("program headers"));
3349 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3350 i
< elf_header
.e_phnum
;
3351 i
++, internal
++, external
++)
3353 internal
->p_type
= BYTE_GET (external
->p_type
);
3354 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3355 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3356 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3357 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3358 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3359 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3360 internal
->p_align
= BYTE_GET (external
->p_align
);
3369 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3371 Elf64_External_Phdr
*phdrs
;
3372 Elf64_External_Phdr
*external
;
3373 Elf_Internal_Phdr
*internal
;
3376 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3377 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3378 _("program headers"));
3382 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3383 i
< elf_header
.e_phnum
;
3384 i
++, internal
++, external
++)
3386 internal
->p_type
= BYTE_GET (external
->p_type
);
3387 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3388 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3389 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3390 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3391 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3392 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3393 internal
->p_align
= BYTE_GET (external
->p_align
);
3401 /* Returns 1 if the program headers were read into `program_headers'. */
3404 get_program_headers (FILE *file
)
3406 Elf_Internal_Phdr
*phdrs
;
3408 /* Check cache of prior read. */
3409 if (program_headers
!= NULL
)
3412 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3416 error (_("Out of memory\n"));
3421 ? get_32bit_program_headers (file
, phdrs
)
3422 : get_64bit_program_headers (file
, phdrs
))
3424 program_headers
= phdrs
;
3432 /* Returns 1 if the program headers were loaded. */
3435 process_program_headers (FILE *file
)
3437 Elf_Internal_Phdr
*segment
;
3440 if (elf_header
.e_phnum
== 0)
3443 printf (_("\nThere are no program headers in this file.\n"));
3447 if (do_segments
&& !do_header
)
3449 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3450 printf (_("Entry point "));
3451 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3452 printf (_("\nThere are %d program headers, starting at offset "),
3453 elf_header
.e_phnum
);
3454 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3458 if (! get_program_headers (file
))
3463 if (elf_header
.e_phnum
> 1)
3464 printf (_("\nProgram Headers:\n"));
3466 printf (_("\nProgram Headers:\n"));
3470 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3473 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3477 (_(" Type Offset VirtAddr PhysAddr\n"));
3479 (_(" FileSiz MemSiz Flags Align\n"));
3486 for (i
= 0, segment
= program_headers
;
3487 i
< elf_header
.e_phnum
;
3492 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3496 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3497 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3498 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3499 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3500 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3502 (segment
->p_flags
& PF_R
? 'R' : ' '),
3503 (segment
->p_flags
& PF_W
? 'W' : ' '),
3504 (segment
->p_flags
& PF_X
? 'E' : ' '));
3505 printf ("%#lx", (unsigned long) segment
->p_align
);
3509 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3510 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3513 print_vma (segment
->p_offset
, FULL_HEX
);
3517 print_vma (segment
->p_vaddr
, FULL_HEX
);
3519 print_vma (segment
->p_paddr
, FULL_HEX
);
3522 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3523 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3526 print_vma (segment
->p_filesz
, FULL_HEX
);
3530 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3531 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3534 print_vma (segment
->p_offset
, FULL_HEX
);
3538 (segment
->p_flags
& PF_R
? 'R' : ' '),
3539 (segment
->p_flags
& PF_W
? 'W' : ' '),
3540 (segment
->p_flags
& PF_X
? 'E' : ' '));
3542 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3543 printf ("%#lx", (unsigned long) segment
->p_align
);
3546 print_vma (segment
->p_align
, PREFIX_HEX
);
3551 print_vma (segment
->p_offset
, FULL_HEX
);
3553 print_vma (segment
->p_vaddr
, FULL_HEX
);
3555 print_vma (segment
->p_paddr
, FULL_HEX
);
3557 print_vma (segment
->p_filesz
, FULL_HEX
);
3559 print_vma (segment
->p_memsz
, FULL_HEX
);
3561 (segment
->p_flags
& PF_R
? 'R' : ' '),
3562 (segment
->p_flags
& PF_W
? 'W' : ' '),
3563 (segment
->p_flags
& PF_X
? 'E' : ' '));
3564 print_vma (segment
->p_align
, HEX
);
3568 switch (segment
->p_type
)
3572 error (_("more than one dynamic segment\n"));
3574 /* By default, assume that the .dynamic section is the first
3575 section in the DYNAMIC segment. */
3576 dynamic_addr
= segment
->p_offset
;
3577 dynamic_size
= segment
->p_filesz
;
3579 /* Try to locate the .dynamic section. If there is
3580 a section header table, we can easily locate it. */
3581 if (section_headers
!= NULL
)
3583 Elf_Internal_Shdr
*sec
;
3585 sec
= find_section (".dynamic");
3586 if (sec
== NULL
|| sec
->sh_size
== 0)
3588 error (_("no .dynamic section in the dynamic segment\n"));
3592 if (sec
->sh_type
== SHT_NOBITS
)
3598 dynamic_addr
= sec
->sh_offset
;
3599 dynamic_size
= sec
->sh_size
;
3601 if (dynamic_addr
< segment
->p_offset
3602 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3603 warn (_("the .dynamic section is not contained"
3604 " within the dynamic segment\n"));
3605 else if (dynamic_addr
> segment
->p_offset
)
3606 warn (_("the .dynamic section is not the first section"
3607 " in the dynamic segment.\n"));
3612 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3614 error (_("Unable to find program interpreter name\n"));
3618 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3620 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3621 error (_("Internal error: failed to create format string to display program interpreter\n"));
3623 program_interpreter
[0] = 0;
3624 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3625 error (_("Unable to read program interpreter name\n"));
3628 printf (_("\n [Requesting program interpreter: %s]"),
3629 program_interpreter
);
3635 putc ('\n', stdout
);
3638 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3640 printf (_("\n Section to Segment mapping:\n"));
3641 printf (_(" Segment Sections...\n"));
3643 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3646 Elf_Internal_Shdr
*section
;
3648 segment
= program_headers
+ i
;
3649 section
= section_headers
;
3651 printf (" %2.2d ", i
);
3653 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3655 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3656 printf ("%s ", SECTION_NAME (section
));
3667 /* Find the file offset corresponding to VMA by using the program headers. */
3670 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3672 Elf_Internal_Phdr
*seg
;
3674 if (! get_program_headers (file
))
3676 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3680 for (seg
= program_headers
;
3681 seg
< program_headers
+ elf_header
.e_phnum
;
3684 if (seg
->p_type
!= PT_LOAD
)
3687 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3688 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3689 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3692 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3699 get_32bit_section_headers (FILE *file
, unsigned int num
)
3701 Elf32_External_Shdr
*shdrs
;
3702 Elf_Internal_Shdr
*internal
;
3705 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3706 elf_header
.e_shentsize
, num
, _("section headers"));
3710 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3712 if (section_headers
== NULL
)
3714 error (_("Out of memory\n"));
3718 for (i
= 0, internal
= section_headers
;
3722 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3723 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3724 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3725 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3726 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3727 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3728 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3729 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3730 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3731 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3740 get_64bit_section_headers (FILE *file
, unsigned int num
)
3742 Elf64_External_Shdr
*shdrs
;
3743 Elf_Internal_Shdr
*internal
;
3746 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3747 elf_header
.e_shentsize
, num
, _("section headers"));
3751 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3753 if (section_headers
== NULL
)
3755 error (_("Out of memory\n"));
3759 for (i
= 0, internal
= section_headers
;
3763 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3764 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3765 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3766 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3767 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3768 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3769 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3770 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3771 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3772 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3780 static Elf_Internal_Sym
*
3781 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3783 unsigned long number
;
3784 Elf32_External_Sym
*esyms
;
3785 Elf_External_Sym_Shndx
*shndx
;
3786 Elf_Internal_Sym
*isyms
;
3787 Elf_Internal_Sym
*psym
;
3790 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3796 if (symtab_shndx_hdr
!= NULL
3797 && (symtab_shndx_hdr
->sh_link
3798 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3800 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3801 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3809 number
= section
->sh_size
/ section
->sh_entsize
;
3810 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3814 error (_("Out of memory\n"));
3821 for (j
= 0, psym
= isyms
;
3825 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3826 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3827 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3828 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3829 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3831 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3832 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3833 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3843 static Elf_Internal_Sym
*
3844 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3846 unsigned long number
;
3847 Elf64_External_Sym
*esyms
;
3848 Elf_External_Sym_Shndx
*shndx
;
3849 Elf_Internal_Sym
*isyms
;
3850 Elf_Internal_Sym
*psym
;
3853 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3859 if (symtab_shndx_hdr
!= NULL
3860 && (symtab_shndx_hdr
->sh_link
3861 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3863 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3864 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3872 number
= section
->sh_size
/ section
->sh_entsize
;
3873 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3877 error (_("Out of memory\n"));
3884 for (j
= 0, psym
= isyms
;
3888 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3889 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3890 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3891 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3892 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3894 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3895 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3896 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3907 get_elf_section_flags (bfd_vma sh_flags
)
3909 static char buff
[1024];
3911 int field_size
= is_32bit_elf
? 8 : 16;
3912 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3913 bfd_vma os_flags
= 0;
3914 bfd_vma proc_flags
= 0;
3915 bfd_vma unknown_flags
= 0;
3929 { "LINK ORDER", 10 },
3930 { "OS NONCONF", 10 },
3935 if (do_section_details
)
3937 sprintf (buff
, "[%*.*lx]: ",
3938 field_size
, field_size
, (unsigned long) sh_flags
);
3939 p
+= field_size
+ 4;
3946 flag
= sh_flags
& - sh_flags
;
3949 if (do_section_details
)
3953 case SHF_WRITE
: index
= 0; break;
3954 case SHF_ALLOC
: index
= 1; break;
3955 case SHF_EXECINSTR
: index
= 2; break;
3956 case SHF_MERGE
: index
= 3; break;
3957 case SHF_STRINGS
: index
= 4; break;
3958 case SHF_INFO_LINK
: index
= 5; break;
3959 case SHF_LINK_ORDER
: index
= 6; break;
3960 case SHF_OS_NONCONFORMING
: index
= 7; break;
3961 case SHF_GROUP
: index
= 8; break;
3962 case SHF_TLS
: index
= 9; break;
3971 if (p
!= buff
+ field_size
+ 4)
3973 if (size
< (10 + 2))
3980 size
-= flags
[index
].len
;
3981 p
= stpcpy (p
, flags
[index
].str
);
3983 else if (flag
& SHF_MASKOS
)
3985 else if (flag
& SHF_MASKPROC
)
3988 unknown_flags
|= flag
;
3994 case SHF_WRITE
: *p
= 'W'; break;
3995 case SHF_ALLOC
: *p
= 'A'; break;
3996 case SHF_EXECINSTR
: *p
= 'X'; break;
3997 case SHF_MERGE
: *p
= 'M'; break;
3998 case SHF_STRINGS
: *p
= 'S'; break;
3999 case SHF_INFO_LINK
: *p
= 'I'; break;
4000 case SHF_LINK_ORDER
: *p
= 'L'; break;
4001 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4002 case SHF_GROUP
: *p
= 'G'; break;
4003 case SHF_TLS
: *p
= 'T'; break;
4006 if (elf_header
.e_machine
== EM_X86_64
4007 && flag
== SHF_X86_64_LARGE
)
4009 else if (flag
& SHF_MASKOS
)
4012 sh_flags
&= ~ SHF_MASKOS
;
4014 else if (flag
& SHF_MASKPROC
)
4017 sh_flags
&= ~ SHF_MASKPROC
;
4027 if (do_section_details
)
4031 size
-= 5 + field_size
;
4032 if (p
!= buff
+ field_size
+ 4)
4040 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4041 (unsigned long) os_flags
);
4042 p
+= 5 + field_size
;
4046 size
-= 7 + field_size
;
4047 if (p
!= buff
+ field_size
+ 4)
4055 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4056 (unsigned long) proc_flags
);
4057 p
+= 7 + field_size
;
4061 size
-= 10 + field_size
;
4062 if (p
!= buff
+ field_size
+ 4)
4070 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4071 (unsigned long) unknown_flags
);
4072 p
+= 10 + field_size
;
4081 process_section_headers (FILE *file
)
4083 Elf_Internal_Shdr
*section
;
4086 section_headers
= NULL
;
4088 if (elf_header
.e_shnum
== 0)
4091 printf (_("\nThere are no sections in this file.\n"));
4096 if (do_sections
&& !do_header
)
4097 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4098 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4102 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4105 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4108 /* Read in the string table, so that we have names to display. */
4109 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4110 && SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
4112 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
4114 if (section
->sh_size
!= 0)
4116 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4117 1, section
->sh_size
, _("string table"));
4119 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4123 /* Scan the sections for the dynamic symbol table
4124 and dynamic string table and debug sections. */
4125 dynamic_symbols
= NULL
;
4126 dynamic_strings
= NULL
;
4127 dynamic_syminfo
= NULL
;
4128 symtab_shndx_hdr
= NULL
;
4130 eh_addr_size
= is_32bit_elf
? 4 : 8;
4131 switch (elf_header
.e_machine
)
4134 case EM_MIPS_RS3_LE
:
4135 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4136 FDE addresses. However, the ABI also has a semi-official ILP32
4137 variant for which the normal FDE address size rules apply.
4139 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4140 section, where XX is the size of longs in bits. Unfortunately,
4141 earlier compilers provided no way of distinguishing ILP32 objects
4142 from LP64 objects, so if there's any doubt, we should assume that
4143 the official LP64 form is being used. */
4144 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4145 && find_section (".gcc_compiled_long32") == NULL
)
4151 switch (elf_header
.e_flags
& EF_H8_MACH
)
4153 case E_H8_MACH_H8300
:
4154 case E_H8_MACH_H8300HN
:
4155 case E_H8_MACH_H8300SN
:
4156 case E_H8_MACH_H8300SXN
:
4159 case E_H8_MACH_H8300H
:
4160 case E_H8_MACH_H8300S
:
4161 case E_H8_MACH_H8300SX
:
4168 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4170 case EF_M32C_CPU_M16C
:
4177 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4180 size_t expected_entsize \
4181 = is_32bit_elf ? size32 : size64; \
4182 if (section->sh_entsize != expected_entsize) \
4183 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4184 i, (unsigned long int) section->sh_entsize, \
4185 (unsigned long int) expected_entsize); \
4186 section->sh_entsize = expected_entsize; \
4189 #define CHECK_ENTSIZE(section, i, type) \
4190 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4191 sizeof (Elf64_External_##type))
4193 for (i
= 0, section
= section_headers
;
4194 i
< elf_header
.e_shnum
;
4197 char *name
= SECTION_NAME (section
);
4199 if (section
->sh_type
== SHT_DYNSYM
)
4201 if (dynamic_symbols
!= NULL
)
4203 error (_("File contains multiple dynamic symbol tables\n"));
4207 CHECK_ENTSIZE (section
, i
, Sym
);
4208 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4209 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4211 else if (section
->sh_type
== SHT_STRTAB
4212 && streq (name
, ".dynstr"))
4214 if (dynamic_strings
!= NULL
)
4216 error (_("File contains multiple dynamic string tables\n"));
4220 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4221 1, section
->sh_size
, _("dynamic strings"));
4222 dynamic_strings_length
= section
->sh_size
;
4224 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4226 if (symtab_shndx_hdr
!= NULL
)
4228 error (_("File contains multiple symtab shndx tables\n"));
4231 symtab_shndx_hdr
= section
;
4233 else if (section
->sh_type
== SHT_SYMTAB
)
4234 CHECK_ENTSIZE (section
, i
, Sym
);
4235 else if (section
->sh_type
== SHT_GROUP
)
4236 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4237 else if (section
->sh_type
== SHT_REL
)
4238 CHECK_ENTSIZE (section
, i
, Rel
);
4239 else if (section
->sh_type
== SHT_RELA
)
4240 CHECK_ENTSIZE (section
, i
, Rela
);
4241 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4242 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4243 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4244 || do_debug_loc
|| do_debug_ranges
)
4245 && const_strneq (name
, ".debug_"))
4250 || (do_debug_info
&& streq (name
, "info"))
4251 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4252 || (do_debug_lines
&& streq (name
, "line"))
4253 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4254 || (do_debug_aranges
&& streq (name
, "aranges"))
4255 || (do_debug_ranges
&& streq (name
, "ranges"))
4256 || (do_debug_frames
&& streq (name
, "frame"))
4257 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4258 || (do_debug_str
&& streq (name
, "str"))
4259 || (do_debug_loc
&& streq (name
, "loc"))
4261 request_dump_bynumber (i
, DEBUG_DUMP
);
4263 /* linkonce section to be combined with .debug_info at link time. */
4264 else if ((do_debugging
|| do_debug_info
)
4265 && const_strneq (name
, ".gnu.linkonce.wi."))
4266 request_dump_bynumber (i
, DEBUG_DUMP
);
4267 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4268 request_dump_bynumber (i
, DEBUG_DUMP
);
4274 if (elf_header
.e_shnum
> 1)
4275 printf (_("\nSection Headers:\n"));
4277 printf (_("\nSection Header:\n"));
4281 if (do_section_details
)
4283 printf (_(" [Nr] Name\n"));
4284 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4288 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4292 if (do_section_details
)
4294 printf (_(" [Nr] Name\n"));
4295 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4299 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4303 if (do_section_details
)
4305 printf (_(" [Nr] Name\n"));
4306 printf (_(" Type Address Offset Link\n"));
4307 printf (_(" Size EntSize Info Align\n"));
4311 printf (_(" [Nr] Name Type Address Offset\n"));
4312 printf (_(" Size EntSize Flags Link Info Align\n"));
4316 if (do_section_details
)
4317 printf (_(" Flags\n"));
4319 for (i
= 0, section
= section_headers
;
4320 i
< elf_header
.e_shnum
;
4323 if (do_section_details
)
4325 printf (" [%2u] %s\n",
4326 SECTION_HEADER_NUM (i
),
4327 SECTION_NAME (section
));
4328 if (is_32bit_elf
|| do_wide
)
4329 printf (" %-15.15s ",
4330 get_section_type_name (section
->sh_type
));
4333 printf (" [%2u] %-17.17s %-15.15s ",
4334 SECTION_HEADER_NUM (i
),
4335 SECTION_NAME (section
),
4336 get_section_type_name (section
->sh_type
));
4340 print_vma (section
->sh_addr
, LONG_HEX
);
4342 printf ( " %6.6lx %6.6lx %2.2lx",
4343 (unsigned long) section
->sh_offset
,
4344 (unsigned long) section
->sh_size
,
4345 (unsigned long) section
->sh_entsize
);
4347 if (do_section_details
)
4348 fputs (" ", stdout
);
4350 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4352 printf ("%2ld %3lu %2ld\n",
4353 (unsigned long) section
->sh_link
,
4354 (unsigned long) section
->sh_info
,
4355 (unsigned long) section
->sh_addralign
);
4359 print_vma (section
->sh_addr
, LONG_HEX
);
4361 if ((long) section
->sh_offset
== section
->sh_offset
)
4362 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4366 print_vma (section
->sh_offset
, LONG_HEX
);
4369 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4370 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4374 print_vma (section
->sh_size
, LONG_HEX
);
4377 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4378 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4382 print_vma (section
->sh_entsize
, LONG_HEX
);
4385 if (do_section_details
)
4386 fputs (" ", stdout
);
4388 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4390 printf ("%2ld %3lu ",
4391 (unsigned long) section
->sh_link
,
4392 (unsigned long) section
->sh_info
);
4394 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4395 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4398 print_vma (section
->sh_addralign
, DEC
);
4402 else if (do_section_details
)
4404 printf (" %-15.15s ",
4405 get_section_type_name (section
->sh_type
));
4406 print_vma (section
->sh_addr
, LONG_HEX
);
4407 if ((long) section
->sh_offset
== section
->sh_offset
)
4408 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4412 print_vma (section
->sh_offset
, LONG_HEX
);
4414 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4415 print_vma (section
->sh_size
, LONG_HEX
);
4417 print_vma (section
->sh_entsize
, LONG_HEX
);
4419 printf (" %-16lu %ld\n",
4420 (unsigned long) section
->sh_info
,
4421 (unsigned long) section
->sh_addralign
);
4426 print_vma (section
->sh_addr
, LONG_HEX
);
4427 if ((long) section
->sh_offset
== section
->sh_offset
)
4428 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4432 print_vma (section
->sh_offset
, LONG_HEX
);
4435 print_vma (section
->sh_size
, LONG_HEX
);
4437 print_vma (section
->sh_entsize
, LONG_HEX
);
4439 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4441 printf (" %2ld %3lu %ld\n",
4442 (unsigned long) section
->sh_link
,
4443 (unsigned long) section
->sh_info
,
4444 (unsigned long) section
->sh_addralign
);
4447 if (do_section_details
)
4448 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4451 if (!do_section_details
)
4452 printf (_("Key to Flags:\n\
4453 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4454 I (info), L (link order), G (group), x (unknown)\n\
4455 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4461 get_group_flags (unsigned int flags
)
4463 static char buff
[32];
4470 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4477 process_section_groups (FILE *file
)
4479 Elf_Internal_Shdr
*section
;
4481 struct group
*group
;
4482 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4483 Elf_Internal_Sym
*symtab
;
4487 /* Don't process section groups unless needed. */
4488 if (!do_unwind
&& !do_section_groups
)
4491 if (elf_header
.e_shnum
== 0)
4493 if (do_section_groups
)
4494 printf (_("\nThere are no sections in this file.\n"));
4499 if (section_headers
== NULL
)
4501 error (_("Section headers are not available!\n"));
4505 section_headers_groups
= calloc (elf_header
.e_shnum
,
4506 sizeof (struct group
*));
4508 if (section_headers_groups
== NULL
)
4510 error (_("Out of memory\n"));
4514 /* Scan the sections for the group section. */
4516 for (i
= 0, section
= section_headers
;
4517 i
< elf_header
.e_shnum
;
4519 if (section
->sh_type
== SHT_GROUP
)
4522 if (group_count
== 0)
4524 if (do_section_groups
)
4525 printf (_("\nThere are no section groups in this file.\n"));
4530 section_groups
= calloc (group_count
, sizeof (struct group
));
4532 if (section_groups
== NULL
)
4534 error (_("Out of memory\n"));
4543 for (i
= 0, section
= section_headers
, group
= section_groups
;
4544 i
< elf_header
.e_shnum
;
4547 if (section
->sh_type
== SHT_GROUP
)
4549 char *name
= SECTION_NAME (section
);
4551 unsigned char *start
, *indices
;
4552 unsigned int entry
, j
, size
;
4553 Elf_Internal_Shdr
*sec
;
4554 Elf_Internal_Sym
*sym
;
4556 /* Get the symbol table. */
4557 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4558 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4561 error (_("Bad sh_link in group section `%s'\n"), name
);
4565 if (symtab_sec
!= sec
)
4570 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4573 sym
= symtab
+ section
->sh_info
;
4575 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4577 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4580 error (_("Bad sh_info in group section `%s'\n"), name
);
4584 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4593 /* Get the string table. */
4594 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4595 >= elf_header
.e_shnum
)
4604 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4609 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4610 1, strtab_sec
->sh_size
,
4612 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4614 group_name
= sym
->st_name
< strtab_size
4615 ? strtab
+ sym
->st_name
: "<corrupt>";
4618 start
= get_data (NULL
, file
, section
->sh_offset
,
4619 1, section
->sh_size
, _("section data"));
4622 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4623 entry
= byte_get (indices
, 4);
4626 if (do_section_groups
)
4628 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4629 get_group_flags (entry
), i
, name
, group_name
, size
);
4631 printf (_(" [Index] Name\n"));
4634 group
->group_index
= i
;
4636 for (j
= 0; j
< size
; j
++)
4638 struct group_list
*g
;
4640 entry
= byte_get (indices
, 4);
4643 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4645 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4646 entry
, i
, elf_header
.e_shnum
- 1);
4649 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4651 error (_("invalid section [%5u] in group section [%5u]\n"),
4656 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4661 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4663 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4668 /* Intel C/C++ compiler may put section 0 in a
4669 section group. We just warn it the first time
4670 and ignore it afterwards. */
4671 static int warned
= 0;
4674 error (_("section 0 in group section [%5u]\n"),
4675 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4681 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4684 if (do_section_groups
)
4686 sec
= SECTION_HEADER (entry
);
4687 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4690 g
= xmalloc (sizeof (struct group_list
));
4691 g
->section_index
= entry
;
4692 g
->next
= group
->root
;
4716 } dynamic_relocations
[] =
4718 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4719 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4720 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4723 /* Process the reloc section. */
4726 process_relocs (FILE *file
)
4728 unsigned long rel_size
;
4729 unsigned long rel_offset
;
4735 if (do_using_dynamic
)
4739 int has_dynamic_reloc
;
4742 has_dynamic_reloc
= 0;
4744 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4746 is_rela
= dynamic_relocations
[i
].rela
;
4747 name
= dynamic_relocations
[i
].name
;
4748 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4749 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4751 has_dynamic_reloc
|= rel_size
;
4753 if (is_rela
== UNKNOWN
)
4755 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4756 switch (dynamic_info
[DT_PLTREL
])
4770 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4771 name
, rel_offset
, rel_size
);
4773 dump_relocations (file
,
4774 offset_from_vma (file
, rel_offset
, rel_size
),
4776 dynamic_symbols
, num_dynamic_syms
,
4777 dynamic_strings
, dynamic_strings_length
, is_rela
);
4781 if (! has_dynamic_reloc
)
4782 printf (_("\nThere are no dynamic relocations in this file.\n"));
4786 Elf_Internal_Shdr
*section
;
4790 for (i
= 0, section
= section_headers
;
4791 i
< elf_header
.e_shnum
;
4794 if ( section
->sh_type
!= SHT_RELA
4795 && section
->sh_type
!= SHT_REL
)
4798 rel_offset
= section
->sh_offset
;
4799 rel_size
= section
->sh_size
;
4803 Elf_Internal_Shdr
*strsec
;
4806 printf (_("\nRelocation section "));
4808 if (string_table
== NULL
)
4809 printf ("%d", section
->sh_name
);
4811 printf (_("'%s'"), SECTION_NAME (section
));
4813 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4814 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4816 is_rela
= section
->sh_type
== SHT_RELA
;
4818 if (section
->sh_link
4819 && SECTION_HEADER_INDEX (section
->sh_link
)
4820 < elf_header
.e_shnum
)
4822 Elf_Internal_Shdr
*symsec
;
4823 Elf_Internal_Sym
*symtab
;
4824 unsigned long nsyms
;
4825 unsigned long strtablen
= 0;
4826 char *strtab
= NULL
;
4828 symsec
= SECTION_HEADER (section
->sh_link
);
4829 if (symsec
->sh_type
!= SHT_SYMTAB
4830 && symsec
->sh_type
!= SHT_DYNSYM
)
4833 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4834 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4839 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4840 < elf_header
.e_shnum
)
4842 strsec
= SECTION_HEADER (symsec
->sh_link
);
4844 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4847 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4850 dump_relocations (file
, rel_offset
, rel_size
,
4851 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4857 dump_relocations (file
, rel_offset
, rel_size
,
4858 NULL
, 0, NULL
, 0, is_rela
);
4865 printf (_("\nThere are no relocations in this file.\n"));
4871 /* Process the unwind section. */
4873 #include "unwind-ia64.h"
4875 /* An absolute address consists of a section and an offset. If the
4876 section is NULL, the offset itself is the address, otherwise, the
4877 address equals to LOAD_ADDRESS(section) + offset. */
4881 unsigned short section
;
4885 #define ABSADDR(a) \
4887 ? section_headers [(a).section].sh_addr + (a).offset \
4890 struct ia64_unw_aux_info
4892 struct ia64_unw_table_entry
4894 struct absaddr start
;
4896 struct absaddr info
;
4898 *table
; /* Unwind table. */
4899 unsigned long table_len
; /* Length of unwind table. */
4900 unsigned char *info
; /* Unwind info. */
4901 unsigned long info_size
; /* Size of unwind info. */
4902 bfd_vma info_addr
; /* starting address of unwind info. */
4903 bfd_vma seg_base
; /* Starting address of segment. */
4904 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4905 unsigned long nsyms
; /* Number of symbols. */
4906 char *strtab
; /* The string table. */
4907 unsigned long strtab_size
; /* Size of string table. */
4911 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4912 unsigned long nsyms
,
4914 unsigned long strtab_size
,
4915 struct absaddr addr
,
4916 const char **symname
,
4919 bfd_vma dist
= 0x100000;
4920 Elf_Internal_Sym
*sym
, *best
= NULL
;
4923 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4925 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4926 && sym
->st_name
!= 0
4927 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4928 && addr
.offset
>= sym
->st_value
4929 && addr
.offset
- sym
->st_value
< dist
)
4932 dist
= addr
.offset
- sym
->st_value
;
4939 *symname
= (best
->st_name
>= strtab_size
4940 ? "<corrupt>" : strtab
+ best
->st_name
);
4945 *offset
= addr
.offset
;
4949 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4951 struct ia64_unw_table_entry
*tp
;
4954 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4958 const unsigned char *dp
;
4959 const unsigned char *head
;
4960 const char *procname
;
4962 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4963 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4965 fputs ("\n<", stdout
);
4969 fputs (procname
, stdout
);
4972 printf ("+%lx", (unsigned long) offset
);
4975 fputs (">: [", stdout
);
4976 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4977 fputc ('-', stdout
);
4978 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4979 printf ("], info at +0x%lx\n",
4980 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4982 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4983 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4985 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4986 (unsigned) UNW_VER (stamp
),
4987 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4988 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4989 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4990 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4992 if (UNW_VER (stamp
) != 1)
4994 printf ("\tUnknown version.\n");
4999 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5000 dp
= unw_decode (dp
, in_body
, & in_body
);
5005 slurp_ia64_unwind_table (FILE *file
,
5006 struct ia64_unw_aux_info
*aux
,
5007 Elf_Internal_Shdr
*sec
)
5009 unsigned long size
, nrelas
, i
;
5010 Elf_Internal_Phdr
*seg
;
5011 struct ia64_unw_table_entry
*tep
;
5012 Elf_Internal_Shdr
*relsec
;
5013 Elf_Internal_Rela
*rela
, *rp
;
5014 unsigned char *table
, *tp
;
5015 Elf_Internal_Sym
*sym
;
5016 const char *relname
;
5018 /* First, find the starting address of the segment that includes
5021 if (elf_header
.e_phnum
)
5023 if (! get_program_headers (file
))
5026 for (seg
= program_headers
;
5027 seg
< program_headers
+ elf_header
.e_phnum
;
5030 if (seg
->p_type
!= PT_LOAD
)
5033 if (sec
->sh_addr
>= seg
->p_vaddr
5034 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5036 aux
->seg_base
= seg
->p_vaddr
;
5042 /* Second, build the unwind table from the contents of the unwind section: */
5043 size
= sec
->sh_size
;
5044 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5048 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5050 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
5052 tep
->start
.section
= SHN_UNDEF
;
5053 tep
->end
.section
= SHN_UNDEF
;
5054 tep
->info
.section
= SHN_UNDEF
;
5057 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5058 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5059 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
5063 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5064 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5065 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
5067 tep
->start
.offset
+= aux
->seg_base
;
5068 tep
->end
.offset
+= aux
->seg_base
;
5069 tep
->info
.offset
+= aux
->seg_base
;
5073 /* Third, apply any relocations to the unwind table: */
5074 for (relsec
= section_headers
;
5075 relsec
< section_headers
+ elf_header
.e_shnum
;
5078 if (relsec
->sh_type
!= SHT_RELA
5079 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5080 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5083 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5087 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5089 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5090 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5092 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5094 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5098 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5100 switch (rp
->r_offset
/eh_addr_size
% 3)
5103 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5104 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5107 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5108 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5111 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5112 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5122 aux
->table_len
= size
/ (3 * eh_addr_size
);
5127 ia64_process_unwind (FILE *file
)
5129 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5130 unsigned long i
, unwcount
= 0, unwstart
= 0;
5131 struct ia64_unw_aux_info aux
;
5133 memset (& aux
, 0, sizeof (aux
));
5135 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5137 if (sec
->sh_type
== SHT_SYMTAB
5138 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5140 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5141 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5143 strsec
= SECTION_HEADER (sec
->sh_link
);
5144 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5145 1, strsec
->sh_size
, _("string table"));
5146 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5148 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5153 printf (_("\nThere are no unwind sections in this file.\n"));
5155 while (unwcount
-- > 0)
5160 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5161 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5162 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5169 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5171 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5173 /* We need to find which section group it is in. */
5174 struct group_list
*g
= section_headers_groups
[i
]->root
;
5176 for (; g
!= NULL
; g
= g
->next
)
5178 sec
= SECTION_HEADER (g
->section_index
);
5180 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5185 i
= elf_header
.e_shnum
;
5187 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5189 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5190 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5191 suffix
= SECTION_NAME (unwsec
) + len
;
5192 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5194 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5195 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5200 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5201 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5202 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5203 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5205 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5206 suffix
= SECTION_NAME (unwsec
) + len
;
5207 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5209 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5210 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5214 if (i
== elf_header
.e_shnum
)
5216 printf (_("\nCould not find unwind info section for "));
5218 if (string_table
== NULL
)
5219 printf ("%d", unwsec
->sh_name
);
5221 printf (_("'%s'"), SECTION_NAME (unwsec
));
5225 aux
.info_size
= sec
->sh_size
;
5226 aux
.info_addr
= sec
->sh_addr
;
5227 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5230 printf (_("\nUnwind section "));
5232 if (string_table
== NULL
)
5233 printf ("%d", unwsec
->sh_name
);
5235 printf (_("'%s'"), SECTION_NAME (unwsec
));
5237 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5238 (unsigned long) unwsec
->sh_offset
,
5239 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5241 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5243 if (aux
.table_len
> 0)
5244 dump_ia64_unwind (& aux
);
5247 free ((char *) aux
.table
);
5249 free ((char *) aux
.info
);
5258 free ((char *) aux
.strtab
);
5263 struct hppa_unw_aux_info
5265 struct hppa_unw_table_entry
5267 struct absaddr start
;
5269 unsigned int Cannot_unwind
:1; /* 0 */
5270 unsigned int Millicode
:1; /* 1 */
5271 unsigned int Millicode_save_sr0
:1; /* 2 */
5272 unsigned int Region_description
:2; /* 3..4 */
5273 unsigned int reserved1
:1; /* 5 */
5274 unsigned int Entry_SR
:1; /* 6 */
5275 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5276 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5277 unsigned int Args_stored
:1; /* 16 */
5278 unsigned int Variable_Frame
:1; /* 17 */
5279 unsigned int Separate_Package_Body
:1; /* 18 */
5280 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5281 unsigned int Stack_Overflow_Check
:1; /* 20 */
5282 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5283 unsigned int Ada_Region
:1; /* 22 */
5284 unsigned int cxx_info
:1; /* 23 */
5285 unsigned int cxx_try_catch
:1; /* 24 */
5286 unsigned int sched_entry_seq
:1; /* 25 */
5287 unsigned int reserved2
:1; /* 26 */
5288 unsigned int Save_SP
:1; /* 27 */
5289 unsigned int Save_RP
:1; /* 28 */
5290 unsigned int Save_MRP_in_frame
:1; /* 29 */
5291 unsigned int extn_ptr_defined
:1; /* 30 */
5292 unsigned int Cleanup_defined
:1; /* 31 */
5294 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5295 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5296 unsigned int Large_frame
:1; /* 2 */
5297 unsigned int Pseudo_SP_Set
:1; /* 3 */
5298 unsigned int reserved4
:1; /* 4 */
5299 unsigned int Total_frame_size
:27; /* 5..31 */
5301 *table
; /* Unwind table. */
5302 unsigned long table_len
; /* Length of unwind table. */
5303 bfd_vma seg_base
; /* Starting address of segment. */
5304 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5305 unsigned long nsyms
; /* Number of symbols. */
5306 char *strtab
; /* The string table. */
5307 unsigned long strtab_size
; /* Size of string table. */
5311 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5313 struct hppa_unw_table_entry
*tp
;
5315 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5318 const char *procname
;
5320 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5321 aux
->strtab_size
, tp
->start
, &procname
,
5324 fputs ("\n<", stdout
);
5328 fputs (procname
, stdout
);
5331 printf ("+%lx", (unsigned long) offset
);
5334 fputs (">: [", stdout
);
5335 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5336 fputc ('-', stdout
);
5337 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5340 #define PF(_m) if (tp->_m) printf (#_m " ");
5341 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5344 PF(Millicode_save_sr0
);
5345 /* PV(Region_description); */
5351 PF(Separate_Package_Body
);
5352 PF(Frame_Extension_Millicode
);
5353 PF(Stack_Overflow_Check
);
5354 PF(Two_Instruction_SP_Increment
);
5358 PF(sched_entry_seq
);
5361 PF(Save_MRP_in_frame
);
5362 PF(extn_ptr_defined
);
5363 PF(Cleanup_defined
);
5364 PF(MPE_XL_interrupt_marker
);
5365 PF(HP_UX_interrupt_marker
);
5368 PV(Total_frame_size
);
5377 slurp_hppa_unwind_table (FILE *file
,
5378 struct hppa_unw_aux_info
*aux
,
5379 Elf_Internal_Shdr
*sec
)
5381 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5382 Elf_Internal_Phdr
*seg
;
5383 struct hppa_unw_table_entry
*tep
;
5384 Elf_Internal_Shdr
*relsec
;
5385 Elf_Internal_Rela
*rela
, *rp
;
5386 unsigned char *table
, *tp
;
5387 Elf_Internal_Sym
*sym
;
5388 const char *relname
;
5390 /* First, find the starting address of the segment that includes
5393 if (elf_header
.e_phnum
)
5395 if (! get_program_headers (file
))
5398 for (seg
= program_headers
;
5399 seg
< program_headers
+ elf_header
.e_phnum
;
5402 if (seg
->p_type
!= PT_LOAD
)
5405 if (sec
->sh_addr
>= seg
->p_vaddr
5406 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5408 aux
->seg_base
= seg
->p_vaddr
;
5414 /* Second, build the unwind table from the contents of the unwind
5416 size
= sec
->sh_size
;
5417 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5422 nentries
= size
/ unw_ent_size
;
5423 size
= unw_ent_size
* nentries
;
5425 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5427 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5429 unsigned int tmp1
, tmp2
;
5431 tep
->start
.section
= SHN_UNDEF
;
5432 tep
->end
.section
= SHN_UNDEF
;
5434 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5435 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5436 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5437 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5439 tep
->start
.offset
+= aux
->seg_base
;
5440 tep
->end
.offset
+= aux
->seg_base
;
5442 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5443 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5444 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5445 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5446 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5447 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5448 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5449 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5450 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5451 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5452 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5453 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5454 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5455 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5456 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5457 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5458 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5459 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5460 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5461 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5462 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5463 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5464 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5465 tep
->Cleanup_defined
= tmp1
& 0x1;
5467 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5468 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5469 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5470 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5471 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5472 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5476 /* Third, apply any relocations to the unwind table. */
5477 for (relsec
= section_headers
;
5478 relsec
< section_headers
+ elf_header
.e_shnum
;
5481 if (relsec
->sh_type
!= SHT_RELA
5482 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5483 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5486 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5490 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5492 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5493 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5495 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5496 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5498 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5502 i
= rp
->r_offset
/ unw_ent_size
;
5504 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5507 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5508 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5511 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5512 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5522 aux
->table_len
= nentries
;
5528 hppa_process_unwind (FILE *file
)
5530 struct hppa_unw_aux_info aux
;
5531 Elf_Internal_Shdr
*unwsec
= NULL
;
5532 Elf_Internal_Shdr
*strsec
;
5533 Elf_Internal_Shdr
*sec
;
5536 memset (& aux
, 0, sizeof (aux
));
5538 if (string_table
== NULL
)
5541 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5543 if (sec
->sh_type
== SHT_SYMTAB
5544 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5546 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5547 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5549 strsec
= SECTION_HEADER (sec
->sh_link
);
5550 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5551 1, strsec
->sh_size
, _("string table"));
5552 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5554 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5559 printf (_("\nThere are no unwind sections in this file.\n"));
5561 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5563 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5565 printf (_("\nUnwind section "));
5566 printf (_("'%s'"), SECTION_NAME (sec
));
5568 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5569 (unsigned long) sec
->sh_offset
,
5570 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5572 slurp_hppa_unwind_table (file
, &aux
, sec
);
5573 if (aux
.table_len
> 0)
5574 dump_hppa_unwind (&aux
);
5577 free ((char *) aux
.table
);
5585 free ((char *) aux
.strtab
);
5591 process_unwind (FILE *file
)
5593 struct unwind_handler
{
5595 int (*handler
)(FILE *file
);
5597 { EM_IA_64
, ia64_process_unwind
},
5598 { EM_PARISC
, hppa_process_unwind
},
5606 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5607 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5608 return handlers
[i
].handler (file
);
5610 printf (_("\nThere are no unwind sections in this file.\n"));
5615 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5617 switch (entry
->d_tag
)
5620 if (entry
->d_un
.d_val
== 0)
5624 static const char * opts
[] =
5626 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5627 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5628 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5629 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5634 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5635 if (entry
->d_un
.d_val
& (1 << cnt
))
5637 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5644 case DT_MIPS_IVERSION
:
5645 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5646 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5648 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5651 case DT_MIPS_TIME_STAMP
:
5656 time_t time
= entry
->d_un
.d_val
;
5657 tmp
= gmtime (&time
);
5658 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5659 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5660 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5661 printf ("Time Stamp: %s\n", timebuf
);
5665 case DT_MIPS_RLD_VERSION
:
5666 case DT_MIPS_LOCAL_GOTNO
:
5667 case DT_MIPS_CONFLICTNO
:
5668 case DT_MIPS_LIBLISTNO
:
5669 case DT_MIPS_SYMTABNO
:
5670 case DT_MIPS_UNREFEXTNO
:
5671 case DT_MIPS_HIPAGENO
:
5672 case DT_MIPS_DELTA_CLASS_NO
:
5673 case DT_MIPS_DELTA_INSTANCE_NO
:
5674 case DT_MIPS_DELTA_RELOC_NO
:
5675 case DT_MIPS_DELTA_SYM_NO
:
5676 case DT_MIPS_DELTA_CLASSSYM_NO
:
5677 case DT_MIPS_COMPACT_SIZE
:
5678 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5682 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5688 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5690 switch (entry
->d_tag
)
5692 case DT_HP_DLD_FLAGS
:
5701 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5702 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5703 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5704 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5705 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5706 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5707 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5708 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5709 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5710 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5711 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5712 { DT_HP_GST
, "HP_GST" },
5713 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5714 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5715 { DT_HP_NODELETE
, "HP_NODELETE" },
5716 { DT_HP_GROUP
, "HP_GROUP" },
5717 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5721 bfd_vma val
= entry
->d_un
.d_val
;
5723 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5724 if (val
& flags
[cnt
].bit
)
5728 fputs (flags
[cnt
].str
, stdout
);
5730 val
^= flags
[cnt
].bit
;
5733 if (val
!= 0 || first
)
5737 print_vma (val
, HEX
);
5743 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5750 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5752 switch (entry
->d_tag
)
5754 case DT_IA_64_PLT_RESERVE
:
5755 /* First 3 slots reserved. */
5756 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5758 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5762 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5769 get_32bit_dynamic_section (FILE *file
)
5771 Elf32_External_Dyn
*edyn
, *ext
;
5772 Elf_Internal_Dyn
*entry
;
5774 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5775 _("dynamic section"));
5779 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5780 might not have the luxury of section headers. Look for the DT_NULL
5781 terminator to determine the number of entries. */
5782 for (ext
= edyn
, dynamic_nent
= 0;
5783 (char *) ext
< (char *) edyn
+ dynamic_size
;
5787 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5791 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5792 if (dynamic_section
== NULL
)
5794 error (_("Out of memory\n"));
5799 for (ext
= edyn
, entry
= dynamic_section
;
5800 entry
< dynamic_section
+ dynamic_nent
;
5803 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5804 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5813 get_64bit_dynamic_section (FILE *file
)
5815 Elf64_External_Dyn
*edyn
, *ext
;
5816 Elf_Internal_Dyn
*entry
;
5818 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5819 _("dynamic section"));
5823 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5824 might not have the luxury of section headers. Look for the DT_NULL
5825 terminator to determine the number of entries. */
5826 for (ext
= edyn
, dynamic_nent
= 0;
5827 (char *) ext
< (char *) edyn
+ dynamic_size
;
5831 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5835 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5836 if (dynamic_section
== NULL
)
5838 error (_("Out of memory\n"));
5843 for (ext
= edyn
, entry
= dynamic_section
;
5844 entry
< dynamic_section
+ dynamic_nent
;
5847 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5848 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5857 print_dynamic_flags (bfd_vma flags
)
5865 flag
= flags
& - flags
;
5875 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5876 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5877 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5878 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5879 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5880 default: fputs ("unknown", stdout
); break;
5886 /* Parse and display the contents of the dynamic section. */
5889 process_dynamic_section (FILE *file
)
5891 Elf_Internal_Dyn
*entry
;
5893 if (dynamic_size
== 0)
5896 printf (_("\nThere is no dynamic section in this file.\n"));
5903 if (! get_32bit_dynamic_section (file
))
5906 else if (! get_64bit_dynamic_section (file
))
5909 /* Find the appropriate symbol table. */
5910 if (dynamic_symbols
== NULL
)
5912 for (entry
= dynamic_section
;
5913 entry
< dynamic_section
+ dynamic_nent
;
5916 Elf_Internal_Shdr section
;
5918 if (entry
->d_tag
!= DT_SYMTAB
)
5921 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5923 /* Since we do not know how big the symbol table is,
5924 we default to reading in the entire file (!) and
5925 processing that. This is overkill, I know, but it
5927 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5929 if (archive_file_offset
!= 0)
5930 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5933 if (fseek (file
, 0, SEEK_END
))
5934 error (_("Unable to seek to end of file!\n"));
5936 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5940 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5942 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5944 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5945 if (num_dynamic_syms
< 1)
5947 error (_("Unable to determine the number of symbols to load\n"));
5951 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5955 /* Similarly find a string table. */
5956 if (dynamic_strings
== NULL
)
5958 for (entry
= dynamic_section
;
5959 entry
< dynamic_section
+ dynamic_nent
;
5962 unsigned long offset
;
5965 if (entry
->d_tag
!= DT_STRTAB
)
5968 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5970 /* Since we do not know how big the string table is,
5971 we default to reading in the entire file (!) and
5972 processing that. This is overkill, I know, but it
5975 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5977 if (archive_file_offset
!= 0)
5978 str_tab_len
= archive_file_size
- offset
;
5981 if (fseek (file
, 0, SEEK_END
))
5982 error (_("Unable to seek to end of file\n"));
5983 str_tab_len
= ftell (file
) - offset
;
5986 if (str_tab_len
< 1)
5989 (_("Unable to determine the length of the dynamic string table\n"));
5993 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5994 _("dynamic string table"));
5995 dynamic_strings_length
= str_tab_len
;
6000 /* And find the syminfo section if available. */
6001 if (dynamic_syminfo
== NULL
)
6003 unsigned long syminsz
= 0;
6005 for (entry
= dynamic_section
;
6006 entry
< dynamic_section
+ dynamic_nent
;
6009 if (entry
->d_tag
== DT_SYMINENT
)
6011 /* Note: these braces are necessary to avoid a syntax
6012 error from the SunOS4 C compiler. */
6013 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
6015 else if (entry
->d_tag
== DT_SYMINSZ
)
6016 syminsz
= entry
->d_un
.d_val
;
6017 else if (entry
->d_tag
== DT_SYMINFO
)
6018 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
6022 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
6024 Elf_External_Syminfo
*extsyminfo
, *extsym
;
6025 Elf_Internal_Syminfo
*syminfo
;
6027 /* There is a syminfo section. Read the data. */
6028 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
6029 syminsz
, _("symbol information"));
6033 dynamic_syminfo
= malloc (syminsz
);
6034 if (dynamic_syminfo
== NULL
)
6036 error (_("Out of memory\n"));
6040 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6041 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6042 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6043 ++syminfo
, ++extsym
)
6045 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6046 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6053 if (do_dynamic
&& dynamic_addr
)
6054 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6055 dynamic_addr
, dynamic_nent
);
6057 printf (_(" Tag Type Name/Value\n"));
6059 for (entry
= dynamic_section
;
6060 entry
< dynamic_section
+ dynamic_nent
;
6068 print_vma (entry
->d_tag
, FULL_HEX
);
6069 dtype
= get_dynamic_type (entry
->d_tag
);
6070 printf (" (%s)%*s", dtype
,
6071 ((is_32bit_elf
? 27 : 19)
6072 - (int) strlen (dtype
)),
6076 switch (entry
->d_tag
)
6080 print_dynamic_flags (entry
->d_un
.d_val
);
6090 switch (entry
->d_tag
)
6093 printf (_("Auxiliary library"));
6097 printf (_("Filter library"));
6101 printf (_("Configuration file"));
6105 printf (_("Dependency audit library"));
6109 printf (_("Audit library"));
6113 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6114 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6118 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6127 printf (_("Flags:"));
6129 if (entry
->d_un
.d_val
== 0)
6130 printf (_(" None\n"));
6133 unsigned long int val
= entry
->d_un
.d_val
;
6135 if (val
& DTF_1_PARINIT
)
6137 printf (" PARINIT");
6138 val
^= DTF_1_PARINIT
;
6140 if (val
& DTF_1_CONFEXP
)
6142 printf (" CONFEXP");
6143 val
^= DTF_1_CONFEXP
;
6146 printf (" %lx", val
);
6155 printf (_("Flags:"));
6157 if (entry
->d_un
.d_val
== 0)
6158 printf (_(" None\n"));
6161 unsigned long int val
= entry
->d_un
.d_val
;
6163 if (val
& DF_P1_LAZYLOAD
)
6165 printf (" LAZYLOAD");
6166 val
^= DF_P1_LAZYLOAD
;
6168 if (val
& DF_P1_GROUPPERM
)
6170 printf (" GROUPPERM");
6171 val
^= DF_P1_GROUPPERM
;
6174 printf (" %lx", val
);
6183 printf (_("Flags:"));
6184 if (entry
->d_un
.d_val
== 0)
6185 printf (_(" None\n"));
6188 unsigned long int val
= entry
->d_un
.d_val
;
6195 if (val
& DF_1_GLOBAL
)
6200 if (val
& DF_1_GROUP
)
6205 if (val
& DF_1_NODELETE
)
6207 printf (" NODELETE");
6208 val
^= DF_1_NODELETE
;
6210 if (val
& DF_1_LOADFLTR
)
6212 printf (" LOADFLTR");
6213 val
^= DF_1_LOADFLTR
;
6215 if (val
& DF_1_INITFIRST
)
6217 printf (" INITFIRST");
6218 val
^= DF_1_INITFIRST
;
6220 if (val
& DF_1_NOOPEN
)
6225 if (val
& DF_1_ORIGIN
)
6230 if (val
& DF_1_DIRECT
)
6235 if (val
& DF_1_TRANS
)
6240 if (val
& DF_1_INTERPOSE
)
6242 printf (" INTERPOSE");
6243 val
^= DF_1_INTERPOSE
;
6245 if (val
& DF_1_NODEFLIB
)
6247 printf (" NODEFLIB");
6248 val
^= DF_1_NODEFLIB
;
6250 if (val
& DF_1_NODUMP
)
6255 if (val
& DF_1_CONLFAT
)
6257 printf (" CONLFAT");
6258 val
^= DF_1_CONLFAT
;
6261 printf (" %lx", val
);
6268 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6270 puts (get_dynamic_type (entry
->d_un
.d_val
));
6290 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6296 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6297 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6303 switch (entry
->d_tag
)
6306 printf (_("Shared library: [%s]"), name
);
6308 if (streq (name
, program_interpreter
))
6309 printf (_(" program interpreter"));
6313 printf (_("Library soname: [%s]"), name
);
6317 printf (_("Library rpath: [%s]"), name
);
6321 printf (_("Library runpath: [%s]"), name
);
6325 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6330 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6343 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6347 case DT_INIT_ARRAYSZ
:
6348 case DT_FINI_ARRAYSZ
:
6349 case DT_GNU_CONFLICTSZ
:
6350 case DT_GNU_LIBLISTSZ
:
6353 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6354 printf (" (bytes)\n");
6364 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6377 if (entry
->d_tag
== DT_USED
6378 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6380 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6384 printf (_("Not needed object: [%s]\n"), name
);
6389 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6395 /* The value of this entry is ignored. */
6400 case DT_GNU_PRELINKED
:
6404 time_t time
= entry
->d_un
.d_val
;
6406 tmp
= gmtime (&time
);
6407 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6408 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6409 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6415 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6418 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6424 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6425 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6430 switch (elf_header
.e_machine
)
6433 case EM_MIPS_RS3_LE
:
6434 dynamic_section_mips_val (entry
);
6437 dynamic_section_parisc_val (entry
);
6440 dynamic_section_ia64_val (entry
);
6443 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6455 get_ver_flags (unsigned int flags
)
6457 static char buff
[32];
6464 if (flags
& VER_FLG_BASE
)
6465 strcat (buff
, "BASE ");
6467 if (flags
& VER_FLG_WEAK
)
6469 if (flags
& VER_FLG_BASE
)
6470 strcat (buff
, "| ");
6472 strcat (buff
, "WEAK ");
6475 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6476 strcat (buff
, "| <unknown>");
6481 /* Display the contents of the version sections. */
6483 process_version_sections (FILE *file
)
6485 Elf_Internal_Shdr
*section
;
6492 for (i
= 0, section
= section_headers
;
6493 i
< elf_header
.e_shnum
;
6496 switch (section
->sh_type
)
6498 case SHT_GNU_verdef
:
6500 Elf_External_Verdef
*edefs
;
6508 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6509 SECTION_NAME (section
), section
->sh_info
);
6511 printf (_(" Addr: 0x"));
6512 printf_vma (section
->sh_addr
);
6513 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6514 (unsigned long) section
->sh_offset
, section
->sh_link
,
6515 SECTION_HEADER_INDEX (section
->sh_link
)
6516 < elf_header
.e_shnum
6517 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6520 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6522 _("version definition section"));
6523 endbuf
= (char *) edefs
+ section
->sh_size
;
6527 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6530 Elf_External_Verdef
*edef
;
6531 Elf_Internal_Verdef ent
;
6532 Elf_External_Verdaux
*eaux
;
6533 Elf_Internal_Verdaux aux
;
6537 vstart
= ((char *) edefs
) + idx
;
6538 if (vstart
+ sizeof (*edef
) > endbuf
)
6541 edef
= (Elf_External_Verdef
*) vstart
;
6543 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6544 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6545 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6546 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6547 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6548 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6549 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6551 printf (_(" %#06x: Rev: %d Flags: %s"),
6552 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6554 printf (_(" Index: %d Cnt: %d "),
6555 ent
.vd_ndx
, ent
.vd_cnt
);
6557 vstart
+= ent
.vd_aux
;
6559 eaux
= (Elf_External_Verdaux
*) vstart
;
6561 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6562 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6564 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6565 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6567 printf (_("Name index: %ld\n"), aux
.vda_name
);
6569 isum
= idx
+ ent
.vd_aux
;
6571 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6573 isum
+= aux
.vda_next
;
6574 vstart
+= aux
.vda_next
;
6576 eaux
= (Elf_External_Verdaux
*) vstart
;
6577 if (vstart
+ sizeof (*eaux
) > endbuf
)
6580 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6581 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6583 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6584 printf (_(" %#06x: Parent %d: %s\n"),
6585 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6587 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6588 isum
, j
, aux
.vda_name
);
6591 printf (_(" Version def aux past end of section\n"));
6595 if (cnt
< section
->sh_info
)
6596 printf (_(" Version definition past end of section\n"));
6602 case SHT_GNU_verneed
:
6604 Elf_External_Verneed
*eneed
;
6611 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6612 SECTION_NAME (section
), section
->sh_info
);
6614 printf (_(" Addr: 0x"));
6615 printf_vma (section
->sh_addr
);
6616 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6617 (unsigned long) section
->sh_offset
, section
->sh_link
,
6618 SECTION_HEADER_INDEX (section
->sh_link
)
6619 < elf_header
.e_shnum
6620 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6623 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6625 _("version need section"));
6626 endbuf
= (char *) eneed
+ section
->sh_size
;
6630 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6632 Elf_External_Verneed
*entry
;
6633 Elf_Internal_Verneed ent
;
6638 vstart
= ((char *) eneed
) + idx
;
6639 if (vstart
+ sizeof (*entry
) > endbuf
)
6642 entry
= (Elf_External_Verneed
*) vstart
;
6644 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6645 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6646 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6647 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6648 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6650 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6652 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6653 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6655 printf (_(" File: %lx"), ent
.vn_file
);
6657 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6659 vstart
+= ent
.vn_aux
;
6661 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6663 Elf_External_Vernaux
*eaux
;
6664 Elf_Internal_Vernaux aux
;
6666 if (vstart
+ sizeof (*eaux
) > endbuf
)
6668 eaux
= (Elf_External_Vernaux
*) vstart
;
6670 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6671 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6672 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6673 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6674 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6676 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6677 printf (_(" %#06x: Name: %s"),
6678 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6680 printf (_(" %#06x: Name index: %lx"),
6681 isum
, aux
.vna_name
);
6683 printf (_(" Flags: %s Version: %d\n"),
6684 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6686 isum
+= aux
.vna_next
;
6687 vstart
+= aux
.vna_next
;
6690 printf (_(" Version need aux past end of section\n"));
6694 if (cnt
< section
->sh_info
)
6695 printf (_(" Version need past end of section\n"));
6701 case SHT_GNU_versym
:
6703 Elf_Internal_Shdr
*link_section
;
6706 unsigned char *edata
;
6707 unsigned short *data
;
6709 Elf_Internal_Sym
*symbols
;
6710 Elf_Internal_Shdr
*string_sec
;
6713 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6716 link_section
= SECTION_HEADER (section
->sh_link
);
6717 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6719 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6720 >= elf_header
.e_shnum
)
6725 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6727 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6729 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6730 string_sec
->sh_size
, _("version string table"));
6734 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6735 SECTION_NAME (section
), total
);
6737 printf (_(" Addr: "));
6738 printf_vma (section
->sh_addr
);
6739 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6740 (unsigned long) section
->sh_offset
, section
->sh_link
,
6741 SECTION_NAME (link_section
));
6743 off
= offset_from_vma (file
,
6744 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6745 total
* sizeof (short));
6746 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6747 _("version symbol data"));
6754 data
= cmalloc (total
, sizeof (short));
6756 for (cnt
= total
; cnt
--;)
6757 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6762 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6765 int check_def
, check_need
;
6768 printf (" %03x:", cnt
);
6770 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6771 switch (data
[cnt
+ j
])
6774 fputs (_(" 0 (*local*) "), stdout
);
6778 fputs (_(" 1 (*global*) "), stdout
);
6782 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6783 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6787 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6788 >= elf_header
.e_shnum
6789 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6792 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6799 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6801 Elf_Internal_Verneed ivn
;
6802 unsigned long offset
;
6804 offset
= offset_from_vma
6805 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6806 sizeof (Elf_External_Verneed
));
6810 Elf_Internal_Vernaux ivna
;
6811 Elf_External_Verneed evn
;
6812 Elf_External_Vernaux evna
;
6813 unsigned long a_off
;
6815 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6818 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6819 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6821 a_off
= offset
+ ivn
.vn_aux
;
6825 get_data (&evna
, file
, a_off
, sizeof (evna
),
6826 1, _("version need aux (2)"));
6828 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6829 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6831 a_off
+= ivna
.vna_next
;
6833 while (ivna
.vna_other
!= data
[cnt
+ j
]
6834 && ivna
.vna_next
!= 0);
6836 if (ivna
.vna_other
== data
[cnt
+ j
])
6838 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6840 if (ivna
.vna_name
>= string_sec
->sh_size
)
6841 name
= _("*invalid*");
6843 name
= strtab
+ ivna
.vna_name
;
6844 nn
+= printf ("(%s%-*s",
6846 12 - (int) strlen (name
),
6852 offset
+= ivn
.vn_next
;
6854 while (ivn
.vn_next
);
6857 if (check_def
&& data
[cnt
+ j
] != 0x8001
6858 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6860 Elf_Internal_Verdef ivd
;
6861 Elf_External_Verdef evd
;
6862 unsigned long offset
;
6864 offset
= offset_from_vma
6865 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6870 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6873 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6874 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6876 offset
+= ivd
.vd_next
;
6878 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6879 && ivd
.vd_next
!= 0);
6881 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6883 Elf_External_Verdaux evda
;
6884 Elf_Internal_Verdaux ivda
;
6886 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6888 get_data (&evda
, file
,
6889 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6891 _("version def aux"));
6893 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6895 if (ivda
.vda_name
>= string_sec
->sh_size
)
6896 name
= _("*invalid*");
6898 name
= strtab
+ ivda
.vda_name
;
6899 nn
+= printf ("(%s%-*s",
6901 12 - (int) strlen (name
),
6907 printf ("%*c", 18 - nn
, ' ');
6925 printf (_("\nNo version information found in this file.\n"));
6931 get_symbol_binding (unsigned int binding
)
6933 static char buff
[32];
6937 case STB_LOCAL
: return "LOCAL";
6938 case STB_GLOBAL
: return "GLOBAL";
6939 case STB_WEAK
: return "WEAK";
6941 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6942 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6944 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6945 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6947 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6953 get_symbol_type (unsigned int type
)
6955 static char buff
[32];
6959 case STT_NOTYPE
: return "NOTYPE";
6960 case STT_OBJECT
: return "OBJECT";
6961 case STT_FUNC
: return "FUNC";
6962 case STT_SECTION
: return "SECTION";
6963 case STT_FILE
: return "FILE";
6964 case STT_COMMON
: return "COMMON";
6965 case STT_TLS
: return "TLS";
6966 case STT_RELC
: return "RELC";
6967 case STT_SRELC
: return "SRELC";
6969 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6971 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6972 return "THUMB_FUNC";
6974 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6977 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6978 return "PARISC_MILLI";
6980 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6982 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6984 if (elf_header
.e_machine
== EM_PARISC
)
6986 if (type
== STT_HP_OPAQUE
)
6988 if (type
== STT_HP_STUB
)
6992 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6995 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
7001 get_symbol_visibility (unsigned int visibility
)
7005 case STV_DEFAULT
: return "DEFAULT";
7006 case STV_INTERNAL
: return "INTERNAL";
7007 case STV_HIDDEN
: return "HIDDEN";
7008 case STV_PROTECTED
: return "PROTECTED";
7014 get_mips_symbol_other (unsigned int other
)
7018 case STO_OPTIONAL
: return "OPTIONAL";
7019 case STO_MIPS16
: return "MIPS16";
7020 default: return NULL
;
7025 get_symbol_other (unsigned int other
)
7027 const char * result
= NULL
;
7028 static char buff
[32];
7033 switch (elf_header
.e_machine
)
7036 result
= get_mips_symbol_other (other
);
7044 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7049 get_symbol_index_type (unsigned int type
)
7051 static char buff
[32];
7055 case SHN_UNDEF
: return "UND";
7056 case SHN_ABS
: return "ABS";
7057 case SHN_COMMON
: return "COM";
7059 if (type
== SHN_IA_64_ANSI_COMMON
7060 && elf_header
.e_machine
== EM_IA_64
7061 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7063 else if (elf_header
.e_machine
== EM_X86_64
7064 && type
== SHN_X86_64_LCOMMON
)
7066 else if (type
== SHN_MIPS_SCOMMON
7067 && elf_header
.e_machine
== EM_MIPS
)
7069 else if (type
== SHN_MIPS_SUNDEFINED
7070 && elf_header
.e_machine
== EM_MIPS
)
7072 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7073 sprintf (buff
, "PRC[0x%04x]", type
);
7074 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7075 sprintf (buff
, "OS [0x%04x]", type
);
7076 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
7077 sprintf (buff
, "RSV[0x%04x]", type
);
7079 sprintf (buff
, "%3d", type
);
7087 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7089 unsigned char *e_data
;
7092 e_data
= cmalloc (number
, ent_size
);
7096 error (_("Out of memory\n"));
7100 if (fread (e_data
, ent_size
, number
, file
) != number
)
7102 error (_("Unable to read in dynamic data\n"));
7106 i_data
= cmalloc (number
, sizeof (*i_data
));
7110 error (_("Out of memory\n"));
7116 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7124 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7126 Elf_Internal_Sym
*psym
;
7129 psym
= dynamic_symbols
+ si
;
7131 n
= print_vma (si
, DEC_5
);
7133 fputs (" " + n
, stdout
);
7134 printf (" %3lu: ", hn
);
7135 print_vma (psym
->st_value
, LONG_HEX
);
7137 print_vma (psym
->st_size
, DEC_5
);
7139 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7140 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7141 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7142 /* Check to see if any other bits in the st_other field are set.
7143 Note - displaying this information disrupts the layout of the
7144 table being generated, but for the moment this case is very
7146 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7147 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7148 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7149 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7150 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7152 printf (" <corrupt: %14ld>", psym
->st_name
);
7156 /* Dump the symbol table. */
7158 process_symbol_table (FILE *file
)
7160 Elf_Internal_Shdr
*section
;
7161 bfd_vma nbuckets
= 0;
7162 bfd_vma nchains
= 0;
7163 bfd_vma
*buckets
= NULL
;
7164 bfd_vma
*chains
= NULL
;
7165 bfd_vma ngnubuckets
= 0;
7166 bfd_vma
*gnubuckets
= NULL
;
7167 bfd_vma
*gnuchains
= NULL
;
7168 bfd_vma gnusymidx
= 0;
7170 if (! do_syms
&& !do_histogram
)
7173 if (dynamic_info
[DT_HASH
]
7175 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7177 unsigned char nb
[8];
7178 unsigned char nc
[8];
7179 int hash_ent_size
= 4;
7181 if ((elf_header
.e_machine
== EM_ALPHA
7182 || elf_header
.e_machine
== EM_S390
7183 || elf_header
.e_machine
== EM_S390_OLD
)
7184 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7188 (archive_file_offset
7189 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7190 sizeof nb
+ sizeof nc
)),
7193 error (_("Unable to seek to start of dynamic information\n"));
7197 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7199 error (_("Failed to read in number of buckets\n"));
7203 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7205 error (_("Failed to read in number of chains\n"));
7209 nbuckets
= byte_get (nb
, hash_ent_size
);
7210 nchains
= byte_get (nc
, hash_ent_size
);
7212 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7213 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7215 if (buckets
== NULL
|| chains
== NULL
)
7219 if (dynamic_info_DT_GNU_HASH
7221 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7223 unsigned char nb
[16];
7224 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7225 bfd_vma buckets_vma
;
7228 (archive_file_offset
7229 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7233 error (_("Unable to seek to start of dynamic information\n"));
7237 if (fread (nb
, 16, 1, file
) != 1)
7239 error (_("Failed to read in number of buckets\n"));
7243 ngnubuckets
= byte_get (nb
, 4);
7244 gnusymidx
= byte_get (nb
+ 4, 4);
7245 bitmaskwords
= byte_get (nb
+ 8, 4);
7246 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7248 buckets_vma
+= bitmaskwords
* 4;
7250 buckets_vma
+= bitmaskwords
* 8;
7253 (archive_file_offset
7254 + offset_from_vma (file
, buckets_vma
, 4)),
7257 error (_("Unable to seek to start of dynamic information\n"));
7261 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7263 if (gnubuckets
== NULL
)
7266 for (i
= 0; i
< ngnubuckets
; i
++)
7267 if (gnubuckets
[i
] != 0)
7269 if (gnubuckets
[i
] < gnusymidx
)
7272 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7273 maxchain
= gnubuckets
[i
];
7276 if (maxchain
== 0xffffffff)
7279 maxchain
-= gnusymidx
;
7282 (archive_file_offset
7283 + offset_from_vma (file
, buckets_vma
7284 + 4 * (ngnubuckets
+ maxchain
), 4)),
7287 error (_("Unable to seek to start of dynamic information\n"));
7293 if (fread (nb
, 4, 1, file
) != 1)
7295 error (_("Failed to determine last chain length\n"));
7299 if (maxchain
+ 1 == 0)
7304 while ((byte_get (nb
, 4) & 1) == 0);
7307 (archive_file_offset
7308 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7311 error (_("Unable to seek to start of dynamic information\n"));
7315 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7317 if (gnuchains
== NULL
)
7321 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7324 && dynamic_strings
!= NULL
)
7328 if (dynamic_info
[DT_HASH
])
7332 printf (_("\nSymbol table for image:\n"));
7334 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7336 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7338 for (hn
= 0; hn
< nbuckets
; hn
++)
7343 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7344 print_dynamic_symbol (si
, hn
);
7348 if (dynamic_info_DT_GNU_HASH
)
7350 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7352 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7354 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7356 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7357 if (gnubuckets
[hn
] != 0)
7359 bfd_vma si
= gnubuckets
[hn
];
7360 bfd_vma off
= si
- gnusymidx
;
7364 print_dynamic_symbol (si
, hn
);
7367 while ((gnuchains
[off
++] & 1) == 0);
7371 else if (do_syms
&& !do_using_dynamic
)
7375 for (i
= 0, section
= section_headers
;
7376 i
< elf_header
.e_shnum
;
7380 char *strtab
= NULL
;
7381 unsigned long int strtab_size
= 0;
7382 Elf_Internal_Sym
*symtab
;
7383 Elf_Internal_Sym
*psym
;
7386 if ( section
->sh_type
!= SHT_SYMTAB
7387 && section
->sh_type
!= SHT_DYNSYM
)
7390 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7391 SECTION_NAME (section
),
7392 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7394 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7396 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7398 symtab
= GET_ELF_SYMBOLS (file
, section
);
7402 if (section
->sh_link
== elf_header
.e_shstrndx
)
7404 strtab
= string_table
;
7405 strtab_size
= string_table_length
;
7407 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7409 Elf_Internal_Shdr
*string_sec
;
7411 string_sec
= SECTION_HEADER (section
->sh_link
);
7413 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7414 1, string_sec
->sh_size
, _("string table"));
7415 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7418 for (si
= 0, psym
= symtab
;
7419 si
< section
->sh_size
/ section
->sh_entsize
;
7422 printf ("%6d: ", si
);
7423 print_vma (psym
->st_value
, LONG_HEX
);
7425 print_vma (psym
->st_size
, DEC_5
);
7426 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7427 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7428 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7429 /* Check to see if any other bits in the st_other field are set.
7430 Note - displaying this information disrupts the layout of the
7431 table being generated, but for the moment this case is very rare. */
7432 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7433 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7434 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7435 print_symbol (25, psym
->st_name
< strtab_size
7436 ? strtab
+ psym
->st_name
: "<corrupt>");
7438 if (section
->sh_type
== SHT_DYNSYM
&&
7439 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7441 unsigned char data
[2];
7442 unsigned short vers_data
;
7443 unsigned long offset
;
7447 offset
= offset_from_vma
7448 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7449 sizeof data
+ si
* sizeof (vers_data
));
7451 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7452 sizeof (data
), 1, _("version data"));
7454 vers_data
= byte_get (data
, 2);
7456 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7457 < elf_header
.e_shnum
7458 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7461 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7463 if ((vers_data
& 0x8000) || vers_data
> 1)
7465 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7466 && (is_nobits
|| ! check_def
))
7468 Elf_External_Verneed evn
;
7469 Elf_Internal_Verneed ivn
;
7470 Elf_Internal_Vernaux ivna
;
7472 /* We must test both. */
7473 offset
= offset_from_vma
7474 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7479 unsigned long vna_off
;
7481 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7484 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7485 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7487 vna_off
= offset
+ ivn
.vn_aux
;
7491 Elf_External_Vernaux evna
;
7493 get_data (&evna
, file
, vna_off
,
7495 _("version need aux (3)"));
7497 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7498 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7499 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7501 vna_off
+= ivna
.vna_next
;
7503 while (ivna
.vna_other
!= vers_data
7504 && ivna
.vna_next
!= 0);
7506 if (ivna
.vna_other
== vers_data
)
7509 offset
+= ivn
.vn_next
;
7511 while (ivn
.vn_next
!= 0);
7513 if (ivna
.vna_other
== vers_data
)
7516 ivna
.vna_name
< strtab_size
7517 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7521 else if (! is_nobits
)
7522 error (_("bad dynamic symbol\n"));
7529 if (vers_data
!= 0x8001
7530 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7532 Elf_Internal_Verdef ivd
;
7533 Elf_Internal_Verdaux ivda
;
7534 Elf_External_Verdaux evda
;
7535 unsigned long offset
;
7537 offset
= offset_from_vma
7539 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7540 sizeof (Elf_External_Verdef
));
7544 Elf_External_Verdef evd
;
7546 get_data (&evd
, file
, offset
, sizeof (evd
),
7547 1, _("version def"));
7549 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7550 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7551 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7553 offset
+= ivd
.vd_next
;
7555 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7556 && ivd
.vd_next
!= 0);
7558 offset
-= ivd
.vd_next
;
7559 offset
+= ivd
.vd_aux
;
7561 get_data (&evda
, file
, offset
, sizeof (evda
),
7562 1, _("version def aux"));
7564 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7566 if (psym
->st_name
!= ivda
.vda_name
)
7567 printf ((vers_data
& 0x8000)
7569 ivda
.vda_name
< strtab_size
7570 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7580 if (strtab
!= string_table
)
7586 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7588 if (do_histogram
&& buckets
!= NULL
)
7590 unsigned long *lengths
;
7591 unsigned long *counts
;
7594 unsigned long maxlength
= 0;
7595 unsigned long nzero_counts
= 0;
7596 unsigned long nsyms
= 0;
7598 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7599 (unsigned long) nbuckets
);
7600 printf (_(" Length Number %% of total Coverage\n"));
7602 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7603 if (lengths
== NULL
)
7605 error (_("Out of memory\n"));
7608 for (hn
= 0; hn
< nbuckets
; ++hn
)
7610 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7613 if (maxlength
< ++lengths
[hn
])
7618 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7621 error (_("Out of memory\n"));
7625 for (hn
= 0; hn
< nbuckets
; ++hn
)
7626 ++counts
[lengths
[hn
]];
7631 printf (" 0 %-10lu (%5.1f%%)\n",
7632 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7633 for (i
= 1; i
<= maxlength
; ++i
)
7635 nzero_counts
+= counts
[i
] * i
;
7636 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7637 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7638 (nzero_counts
* 100.0) / nsyms
);
7646 if (buckets
!= NULL
)
7652 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7654 unsigned long *lengths
;
7655 unsigned long *counts
;
7657 unsigned long maxlength
= 0;
7658 unsigned long nzero_counts
= 0;
7659 unsigned long nsyms
= 0;
7661 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7662 if (lengths
== NULL
)
7664 error (_("Out of memory\n"));
7668 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7669 (unsigned long) ngnubuckets
);
7670 printf (_(" Length Number %% of total Coverage\n"));
7672 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7673 if (gnubuckets
[hn
] != 0)
7675 bfd_vma off
, length
= 1;
7677 for (off
= gnubuckets
[hn
] - gnusymidx
;
7678 (gnuchains
[off
] & 1) == 0; ++off
)
7680 lengths
[hn
] = length
;
7681 if (length
> maxlength
)
7686 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7689 error (_("Out of memory\n"));
7693 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7694 ++counts
[lengths
[hn
]];
7696 if (ngnubuckets
> 0)
7699 printf (" 0 %-10lu (%5.1f%%)\n",
7700 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7701 for (j
= 1; j
<= maxlength
; ++j
)
7703 nzero_counts
+= counts
[j
] * j
;
7704 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7705 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7706 (nzero_counts
* 100.0) / nsyms
);
7720 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7724 if (dynamic_syminfo
== NULL
7726 /* No syminfo, this is ok. */
7729 /* There better should be a dynamic symbol section. */
7730 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7734 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7735 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7737 printf (_(" Num: Name BoundTo Flags\n"));
7738 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7740 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7742 printf ("%4d: ", i
);
7743 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7744 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7746 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7749 switch (dynamic_syminfo
[i
].si_boundto
)
7751 case SYMINFO_BT_SELF
:
7752 fputs ("SELF ", stdout
);
7754 case SYMINFO_BT_PARENT
:
7755 fputs ("PARENT ", stdout
);
7758 if (dynamic_syminfo
[i
].si_boundto
> 0
7759 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7760 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7762 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7766 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7770 if (flags
& SYMINFO_FLG_DIRECT
)
7772 if (flags
& SYMINFO_FLG_PASSTHRU
)
7773 printf (" PASSTHRU");
7774 if (flags
& SYMINFO_FLG_COPY
)
7776 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7777 printf (" LAZYLOAD");
7785 #ifdef SUPPORT_DISASSEMBLY
7787 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7789 printf (_("\nAssembly dump of section %s\n"),
7790 SECTION_NAME (section
));
7792 /* XXX -- to be done --- XXX */
7799 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7801 Elf_Internal_Shdr
*relsec
;
7802 bfd_size_type num_bytes
;
7807 char *name
= SECTION_NAME (section
);
7808 bfd_boolean some_strings_shown
;
7810 num_bytes
= section
->sh_size
;
7812 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7814 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7818 addr
= section
->sh_addr
;
7820 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7825 printf (_("\nString dump of section '%s':\n"), name
);
7827 /* If the section being dumped has relocations against it the user might
7828 be expecting these relocations to have been applied. Check for this
7829 case and issue a warning message in order to avoid confusion.
7830 FIXME: Maybe we ought to have an option that dumps a section with
7832 for (relsec
= section_headers
;
7833 relsec
< section_headers
+ elf_header
.e_shnum
;
7836 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7837 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7838 || SECTION_HEADER (relsec
->sh_info
) != section
7839 || relsec
->sh_size
== 0
7840 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7843 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7848 end
= start
+ num_bytes
;
7849 some_strings_shown
= FALSE
;
7853 while (!ISPRINT (* data
))
7860 printf (" [%6tx] %s\n", data
- start
, data
);
7862 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
7864 data
+= strlen (data
);
7865 some_strings_shown
= TRUE
;
7869 if (! some_strings_shown
)
7870 printf (_(" No strings found in this section."));
7880 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
7882 Elf_Internal_Shdr
*relsec
;
7883 bfd_size_type bytes
;
7885 unsigned char *data
;
7886 unsigned char *start
;
7888 bytes
= section
->sh_size
;
7890 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7892 printf (_("\nSection '%s' has no data to dump.\n"),
7893 SECTION_NAME (section
));
7897 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7899 addr
= section
->sh_addr
;
7901 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7906 /* If the section being dumped has relocations against it the user might
7907 be expecting these relocations to have been applied. Check for this
7908 case and issue a warning message in order to avoid confusion.
7909 FIXME: Maybe we ought to have an option that dumps a section with
7911 for (relsec
= section_headers
;
7912 relsec
< section_headers
+ elf_header
.e_shnum
;
7915 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7916 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7917 || SECTION_HEADER (relsec
->sh_info
) != section
7918 || relsec
->sh_size
== 0
7919 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7922 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7934 lbytes
= (bytes
> 16 ? 16 : bytes
);
7936 printf (" 0x%8.8lx ", (unsigned long) addr
);
7938 for (j
= 0; j
< 16; j
++)
7941 printf ("%2.2x", data
[j
]);
7949 for (j
= 0; j
< lbytes
; j
++)
7952 if (k
>= ' ' && k
< 0x7f)
7971 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7972 DWARF debug sections. This is a target specific test. Note - we do not
7973 go through the whole including-target-headers-multiple-times route, (as
7974 we have already done with <elf/h8.h>) because this would become very
7975 messy and even then this function would have to contain target specific
7976 information (the names of the relocs instead of their numeric values).
7977 FIXME: This is not the correct way to solve this problem. The proper way
7978 is to have target specific reloc sizing and typing functions created by
7979 the reloc-macros.h header, in the same way that it already creates the
7980 reloc naming functions. */
7983 is_32bit_abs_reloc (unsigned int reloc_type
)
7985 switch (elf_header
.e_machine
)
7989 return reloc_type
== 1; /* R_386_32. */
7991 return reloc_type
== 1; /* R_68K_32. */
7993 return reloc_type
== 1; /* R_860_32. */
7995 return reloc_type
== 1; /* XXX Is this right ? */
7997 return reloc_type
== 1; /* R_ARC_32. */
7999 return reloc_type
== 2; /* R_ARM_ABS32 */
8002 return reloc_type
== 1;
8004 return reloc_type
== 0x12; /* R_byte4_data. */
8006 return reloc_type
== 3; /* R_CRIS_32. */
8008 return reloc_type
== 3; /* R_CR16_NUM32. */
8010 return reloc_type
== 15; /* R_CRX_NUM32. */
8012 return reloc_type
== 1;
8013 case EM_CYGNUS_D10V
:
8015 return reloc_type
== 6; /* R_D10V_32. */
8016 case EM_CYGNUS_D30V
:
8018 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
8020 return reloc_type
== 3; /* R_DLX_RELOC_32. */
8021 case EM_CYGNUS_FR30
:
8023 return reloc_type
== 3; /* R_FR30_32. */
8027 return reloc_type
== 1; /* R_H8_DIR32. */
8029 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
8032 return reloc_type
== 2; /* R_IP2K_32. */
8034 return reloc_type
== 2; /* R_IQ2000_32. */
8036 return reloc_type
== 3; /* R_M32C_32. */
8038 return reloc_type
== 34; /* R_M32R_32_RELA. */
8040 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8042 return reloc_type
== 4; /* R_MEP_32. */
8044 return reloc_type
== 2; /* R_MIPS_32. */
8046 return reloc_type
== 4; /* R_MMIX_32. */
8047 case EM_CYGNUS_MN10200
:
8049 return reloc_type
== 1; /* R_MN10200_32. */
8050 case EM_CYGNUS_MN10300
:
8052 return reloc_type
== 1; /* R_MN10300_32. */
8055 return reloc_type
== 1; /* R_MSP43_32. */
8057 return reloc_type
== 2; /* R_MT_32. */
8058 case EM_ALTERA_NIOS2
:
8060 return reloc_type
== 1; /* R_NIOS_32. */
8063 return reloc_type
== 1; /* R_OR32_32. */
8065 return reloc_type
== 1; /* R_PARISC_DIR32. */
8068 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8070 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8072 return reloc_type
== 1; /* R_PPC_ADDR32. */
8074 return reloc_type
== 1; /* R_I370_ADDR31. */
8077 return reloc_type
== 4; /* R_S390_32. */
8079 return reloc_type
== 8; /* R_SCORE_ABS32. */
8081 return reloc_type
== 1; /* R_SH_DIR32. */
8082 case EM_SPARC32PLUS
:
8085 return reloc_type
== 3 /* R_SPARC_32. */
8086 || reloc_type
== 23; /* R_SPARC_UA32. */
8088 return reloc_type
== 6; /* R_SPU_ADDR32 */
8089 case EM_CYGNUS_V850
:
8091 return reloc_type
== 6; /* R_V850_ABS32. */
8093 return reloc_type
== 1; /* R_VAX_32. */
8095 return reloc_type
== 10; /* R_X86_64_32. */
8097 return reloc_type
== 1; /* R_XSTROMY16_32. */
8100 return reloc_type
== 1; /* R_XTENSA_32. */
8103 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8104 elf_header
.e_machine
);
8109 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8110 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8113 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8115 switch (elf_header
.e_machine
)
8119 return reloc_type
== 2; /* R_386_PC32. */
8121 return reloc_type
== 4; /* R_68K_PC32. */
8123 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8125 return reloc_type
== 3; /* R_ARM_REL32 */
8127 return reloc_type
== 0; /* R_PARISC_NONE. *//* FIXME: This reloc is generated, but it may be a bug. */
8129 return reloc_type
== 26; /* R_PPC_REL32. */
8131 return reloc_type
== 26; /* R_PPC64_REL32. */
8134 return reloc_type
== 5; /* R_390_PC32. */
8136 return reloc_type
== 2; /* R_SH_REL32. */
8137 case EM_SPARC32PLUS
:
8140 return reloc_type
== 6; /* R_SPARC_DISP32. */
8142 return reloc_type
== 13; /* R_SPU_REL32. */
8144 return reloc_type
== 2; /* R_X86_64_PC32. */
8147 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
8149 /* Do not abort or issue an error message here. Not all targets use
8150 pc-relative 32-bit relocs in their DWARF debug information and we
8151 have already tested for target coverage in is_32bit_abs_reloc. A
8152 more helpful warning message will be generated by
8153 debug_apply_relocations anyway, so just return. */
8158 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8159 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8162 is_64bit_abs_reloc (unsigned int reloc_type
)
8164 switch (elf_header
.e_machine
)
8167 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8169 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8171 return reloc_type
== 80; /* R_PARISC_DIR64. */
8173 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8174 case EM_SPARC32PLUS
:
8177 return reloc_type
== 54; /* R_SPARC_UA64. */
8179 return reloc_type
== 1; /* R_X86_64_64. */
8182 return reloc_type
== 22; /* R_S390_64 */
8188 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8189 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8192 is_16bit_abs_reloc (unsigned int reloc_type
)
8194 switch (elf_header
.e_machine
)
8198 return reloc_type
== 4; /* R_AVR_16. */
8199 case EM_CYGNUS_D10V
:
8201 return reloc_type
== 3; /* R_D10V_16. */
8205 return reloc_type
== R_H8_DIR16
;
8208 return reloc_type
== 1; /* R_IP2K_16. */
8210 return reloc_type
== 1; /* R_M32C_16 */
8213 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8214 case EM_ALTERA_NIOS2
:
8216 return reloc_type
== 9; /* R_NIOS_16. */
8222 /* Apply relocations to a debug section. */
8225 debug_apply_relocations (void *file
,
8226 Elf_Internal_Shdr
*section
,
8227 unsigned char *start
)
8229 Elf_Internal_Shdr
*relsec
;
8230 unsigned char *end
= start
+ section
->sh_size
;
8232 if (elf_header
.e_type
!= ET_REL
)
8235 /* Find the reloc section associated with the debug section. */
8236 for (relsec
= section_headers
;
8237 relsec
< section_headers
+ elf_header
.e_shnum
;
8240 bfd_boolean is_rela
;
8241 unsigned long num_relocs
;
8242 Elf_Internal_Rela
*relocs
, *rp
;
8243 Elf_Internal_Shdr
*symsec
;
8244 Elf_Internal_Sym
*symtab
;
8245 Elf_Internal_Sym
*sym
;
8247 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8248 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
8249 || SECTION_HEADER (relsec
->sh_info
) != section
8250 || relsec
->sh_size
== 0
8251 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
8254 is_rela
= relsec
->sh_type
== SHT_RELA
;
8258 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8259 & relocs
, & num_relocs
))
8264 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8265 & relocs
, & num_relocs
))
8269 /* SH uses RELA but uses in place value instead of the addend field. */
8270 if (elf_header
.e_machine
== EM_SH
)
8273 symsec
= SECTION_HEADER (relsec
->sh_link
);
8274 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8276 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8279 unsigned int reloc_type
;
8280 unsigned int reloc_size
;
8281 unsigned char * loc
;
8283 /* In MIPS little-endian objects, r_info isn't really a
8284 64-bit little-endian value: it has a 32-bit little-endian
8285 symbol index followed by four individual byte fields.
8286 Reorder INFO accordingly. */
8288 && elf_header
.e_machine
== EM_MIPS
8289 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
8290 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
8291 | ((rp
->r_info
>> 56) & 0xff)
8292 | ((rp
->r_info
>> 40) & 0xff00)
8293 | ((rp
->r_info
>> 24) & 0xff0000)
8294 | ((rp
->r_info
>> 8) & 0xff000000));
8296 reloc_type
= get_reloc_type (rp
->r_info
);
8298 if (is_32bit_abs_reloc (reloc_type
)
8299 || is_32bit_pcrel_reloc (reloc_type
))
8301 else if (is_64bit_abs_reloc (reloc_type
))
8303 else if (is_16bit_abs_reloc (reloc_type
))
8307 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8308 reloc_type
, SECTION_NAME (section
));
8312 loc
= start
+ rp
->r_offset
;
8313 if ((loc
+ reloc_size
) > end
)
8315 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8316 (unsigned long) rp
->r_offset
,
8317 SECTION_NAME (section
));
8321 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8323 /* If the reloc has a symbol associated with it,
8324 make sure that it is of an appropriate type. */
8326 && ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
8327 /* Relocations against symbols without type can happen.
8328 Gcc -feliminate-dwarf2-dups may generate symbols
8329 without type for debug info. */
8330 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8331 /* Relocations against object symbols can happen,
8332 eg when referencing a global array. For an
8333 example of this see the _clz.o binary in libgcc.a. */
8334 && ELF_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8336 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8337 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8338 (long int)(rp
- relocs
),
8339 SECTION_NAME (relsec
));
8343 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8345 if (is_32bit_pcrel_reloc (reloc_type
))
8346 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8349 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8359 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8361 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8362 Elf_Internal_Shdr
*sec
;
8365 /* If it is already loaded, do nothing. */
8366 if (section
->start
!= NULL
)
8369 /* Locate the debug section. */
8370 sec
= find_section (section
->name
);
8374 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8375 section
->address
= sec
->sh_addr
;
8376 section
->size
= sec
->sh_size
;
8377 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8380 if (debug_displays
[debug
].relocate
)
8381 debug_apply_relocations (file
, sec
, section
->start
);
8383 return section
->start
!= NULL
;
8387 free_debug_section (enum dwarf_section_display_enum debug
)
8389 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8391 if (section
->start
== NULL
)
8394 free ((char *) section
->start
);
8395 section
->start
= NULL
;
8396 section
->address
= 0;
8401 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8403 char *name
= SECTION_NAME (section
);
8404 bfd_size_type length
;
8406 enum dwarf_section_display_enum i
;
8408 length
= section
->sh_size
;
8411 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8415 if (const_strneq (name
, ".gnu.linkonce.wi."))
8416 name
= ".debug_info";
8418 /* See if we know how to display the contents of this section. */
8419 for (i
= 0; i
< max
; i
++)
8420 if (streq (debug_displays
[i
].section
.name
, name
))
8422 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8424 if (load_debug_section (i
, file
))
8426 result
&= debug_displays
[i
].display (sec
, file
);
8428 if (i
!= info
&& i
!= abbrev
)
8429 free_debug_section (i
);
8437 printf (_("Unrecognized debug section: %s\n"), name
);
8444 /* Set DUMP_SECTS for all sections where dumps were requested
8445 based on section name. */
8448 initialise_dumps_byname (void)
8450 struct dump_list_entry
*cur
;
8452 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8457 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8458 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8460 request_dump_bynumber (i
, cur
->type
);
8465 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8471 process_section_contents (FILE *file
)
8473 Elf_Internal_Shdr
*section
;
8479 initialise_dumps_byname ();
8481 for (i
= 0, section
= section_headers
;
8482 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8485 #ifdef SUPPORT_DISASSEMBLY
8486 if (dump_sects
[i
] & DISASS_DUMP
)
8487 disassemble_section (section
, file
);
8489 if (dump_sects
[i
] & HEX_DUMP
)
8490 dump_section_as_bytes (section
, file
);
8492 if (dump_sects
[i
] & DEBUG_DUMP
)
8493 display_debug_section (section
, file
);
8495 if (dump_sects
[i
] & STRING_DUMP
)
8496 dump_section_as_strings (section
, file
);
8499 /* Check to see if the user requested a
8500 dump of a section that does not exist. */
8501 while (i
++ < num_dump_sects
)
8503 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8507 process_mips_fpe_exception (int mask
)
8512 if (mask
& OEX_FPU_INEX
)
8513 fputs ("INEX", stdout
), first
= 0;
8514 if (mask
& OEX_FPU_UFLO
)
8515 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8516 if (mask
& OEX_FPU_OFLO
)
8517 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8518 if (mask
& OEX_FPU_DIV0
)
8519 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8520 if (mask
& OEX_FPU_INVAL
)
8521 printf ("%sINVAL", first
? "" : "|");
8524 fputs ("0", stdout
);
8527 /* ARM EABI attributes section. */
8532 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8535 } arm_attr_public_tag
;
8537 static const char *arm_attr_tag_CPU_arch
[] =
8538 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8540 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8541 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8542 {"No", "Thumb-1", "Thumb-2"};
8543 /* FIXME: VFPv3 encoding was extrapolated! */
8544 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8545 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8546 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8547 static const char *arm_attr_tag_ABI_PCS_config
[] =
8548 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8549 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8550 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8551 {"V6", "SB", "TLS", "Unused"};
8552 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8553 {"Absolute", "PC-relative", "SB-relative", "None"};
8554 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8555 {"Absolute", "PC-relative", "None"};
8556 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8557 {"None", "direct", "GOT-indirect"};
8558 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8559 {"None", "??? 1", "2", "??? 3", "4"};
8560 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8561 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8562 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8563 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8564 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8565 {"Unused", "Finite", "RTABI", "IEEE 754"};
8566 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8567 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8568 {"No", "Yes, except leaf SP", "Yes"};
8569 static const char *arm_attr_tag_ABI_enum_size
[] =
8570 {"Unused", "small", "int", "forced to int"};
8571 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8572 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8573 static const char *arm_attr_tag_ABI_VFP_args
[] =
8574 {"AAPCS", "VFP registers", "custom"};
8575 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8576 {"AAPCS", "WMMX registers", "custom"};
8577 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8578 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8579 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8580 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8581 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8582 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8584 #define LOOKUP(id, name) \
8585 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8586 static arm_attr_public_tag arm_attr_public_tags
[] =
8588 {4, "CPU_raw_name", 1, NULL
},
8589 {5, "CPU_name", 1, NULL
},
8590 LOOKUP(6, CPU_arch
),
8591 {7, "CPU_arch_profile", 0, NULL
},
8592 LOOKUP(8, ARM_ISA_use
),
8593 LOOKUP(9, THUMB_ISA_use
),
8594 LOOKUP(10, VFP_arch
),
8595 LOOKUP(11, WMMX_arch
),
8596 LOOKUP(12, NEON_arch
),
8597 LOOKUP(13, ABI_PCS_config
),
8598 LOOKUP(14, ABI_PCS_R9_use
),
8599 LOOKUP(15, ABI_PCS_RW_data
),
8600 LOOKUP(16, ABI_PCS_RO_DATA
),
8601 LOOKUP(17, ABI_PCS_GOT_use
),
8602 LOOKUP(18, ABI_PCS_wchar_t
),
8603 LOOKUP(19, ABI_FP_rounding
),
8604 LOOKUP(20, ABI_FP_denormal
),
8605 LOOKUP(21, ABI_FP_exceptions
),
8606 LOOKUP(22, ABI_FP_user_exceptions
),
8607 LOOKUP(23, ABI_FP_number_model
),
8608 LOOKUP(24, ABI_align8_needed
),
8609 LOOKUP(25, ABI_align8_preserved
),
8610 LOOKUP(26, ABI_enum_size
),
8611 LOOKUP(27, ABI_HardFP_use
),
8612 LOOKUP(28, ABI_VFP_args
),
8613 LOOKUP(29, ABI_WMMX_args
),
8614 LOOKUP(30, ABI_optimization_goals
),
8615 LOOKUP(31, ABI_FP_optimization_goals
),
8616 {32, "compatibility", 0, NULL
}
8620 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8623 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8637 val
|= ((unsigned int)c
& 0x7f) << shift
;
8646 static unsigned char *
8647 display_arm_attribute (unsigned char *p
)
8652 arm_attr_public_tag
*attr
;
8656 tag
= read_uleb128 (p
, &len
);
8659 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8661 if (arm_attr_public_tags
[i
].tag
== tag
)
8663 attr
= &arm_attr_public_tags
[i
];
8670 printf (" Tag_%s: ", attr
->name
);
8676 case 7: /* Tag_CPU_arch_profile. */
8677 val
= read_uleb128 (p
, &len
);
8681 case 0: printf ("None\n"); break;
8682 case 'A': printf ("Application\n"); break;
8683 case 'R': printf ("Realtime\n"); break;
8684 case 'M': printf ("Microcontroller\n"); break;
8685 default: printf ("??? (%d)\n", val
); break;
8689 case 32: /* Tag_compatibility. */
8690 val
= read_uleb128 (p
, &len
);
8692 printf ("flag = %d, vendor = %s\n", val
, p
);
8693 p
+= strlen((char *)p
) + 1;
8707 assert (attr
->type
& 0x80);
8708 val
= read_uleb128 (p
, &len
);
8710 type
= attr
->type
& 0x7f;
8712 printf ("??? (%d)\n", val
);
8714 printf ("%s\n", attr
->table
[val
]);
8721 type
= 1; /* String. */
8723 type
= 2; /* uleb128. */
8724 printf (" Tag_unknown_%d: ", tag
);
8729 printf ("\"%s\"\n", p
);
8730 p
+= strlen((char *)p
) + 1;
8734 val
= read_uleb128 (p
, &len
);
8736 printf ("%d (0x%x)\n", val
, val
);
8742 static unsigned char *
8743 display_gnu_attribute (unsigned char * p
,
8744 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8751 tag
= read_uleb128 (p
, &len
);
8754 /* Tag_compatibility is the only generic GNU attribute defined at
8758 val
= read_uleb128 (p
, &len
);
8760 printf ("flag = %d, vendor = %s\n", val
, p
);
8761 p
+= strlen ((char *) p
) + 1;
8765 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8766 return display_proc_gnu_attribute (p
, tag
);
8769 type
= 1; /* String. */
8771 type
= 2; /* uleb128. */
8772 printf (" Tag_unknown_%d: ", tag
);
8776 printf ("\"%s\"\n", p
);
8777 p
+= strlen ((char *) p
) + 1;
8781 val
= read_uleb128 (p
, &len
);
8783 printf ("%d (0x%x)\n", val
, val
);
8789 static unsigned char *
8790 display_power_gnu_attribute (unsigned char *p
, int tag
)
8796 if (tag
== Tag_GNU_Power_ABI_FP
)
8798 val
= read_uleb128 (p
, &len
);
8800 printf (" Tag_GNU_Power_ABI_FP: ");
8805 printf ("Hard or soft float\n");
8808 printf ("Hard float\n");
8811 printf ("Soft float\n");
8814 printf ("??? (%d)\n", val
);
8820 if (tag
== Tag_GNU_Power_ABI_Vector
)
8822 val
= read_uleb128 (p
, &len
);
8824 printf (" Tag_GNU_Power_ABI_Vector: ");
8831 printf ("Generic\n");
8834 printf ("AltiVec\n");
8840 printf ("??? (%d)\n", val
);
8847 type
= 1; /* String. */
8849 type
= 2; /* uleb128. */
8850 printf (" Tag_unknown_%d: ", tag
);
8854 printf ("\"%s\"\n", p
);
8855 p
+= strlen ((char *) p
) + 1;
8859 val
= read_uleb128 (p
, &len
);
8861 printf ("%d (0x%x)\n", val
, val
);
8867 static unsigned char *
8868 display_mips_gnu_attribute (unsigned char *p
, int tag
)
8874 if (tag
== Tag_GNU_MIPS_ABI_FP
)
8876 val
= read_uleb128 (p
, &len
);
8878 printf (" Tag_GNU_MIPS_ABI_FP: ");
8883 printf ("Hard or soft float\n");
8886 printf ("Hard float (-mdouble-float)\n");
8889 printf ("Hard float (-msingle-float)\n");
8892 printf ("Soft float\n");
8895 printf ("64-bit float (-mips32r2 -mfp64)\n");
8898 printf ("??? (%d)\n", val
);
8905 type
= 1; /* String. */
8907 type
= 2; /* uleb128. */
8908 printf (" Tag_unknown_%d: ", tag
);
8912 printf ("\"%s\"\n", p
);
8913 p
+= strlen ((char *) p
) + 1;
8917 val
= read_uleb128 (p
, &len
);
8919 printf ("%d (0x%x)\n", val
, val
);
8926 process_attributes (FILE * file
,
8927 const char * public_name
,
8928 unsigned int proc_type
,
8929 unsigned char * (* display_pub_attribute
) (unsigned char *),
8930 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8932 Elf_Internal_Shdr
*sect
;
8933 unsigned char *contents
;
8936 bfd_vma section_len
;
8940 /* Find the section header so that we get the size. */
8941 for (i
= 0, sect
= section_headers
;
8942 i
< elf_header
.e_shnum
;
8945 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
8948 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
8950 if (contents
== NULL
)
8956 len
= sect
->sh_size
- 1;
8962 bfd_boolean public_section
;
8963 bfd_boolean gnu_section
;
8965 section_len
= byte_get (p
, 4);
8968 if (section_len
> len
)
8970 printf (_("ERROR: Bad section length (%d > %d)\n"),
8971 (int) section_len
, (int) len
);
8976 printf ("Attribute Section: %s\n", p
);
8978 if (public_name
&& streq ((char *) p
, public_name
))
8979 public_section
= TRUE
;
8981 public_section
= FALSE
;
8983 if (streq ((char *) p
, "gnu"))
8986 gnu_section
= FALSE
;
8988 namelen
= strlen ((char *) p
) + 1;
8990 section_len
-= namelen
+ 4;
8992 while (section_len
> 0)
8998 size
= byte_get (p
, 4);
8999 if (size
> section_len
)
9001 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9002 (int) size
, (int) section_len
);
9006 section_len
-= size
;
9013 printf ("File Attributes\n");
9016 printf ("Section Attributes:");
9019 printf ("Symbol Attributes:");
9025 val
= read_uleb128 (p
, &i
);
9029 printf (" %d", val
);
9034 printf ("Unknown tag: %d\n", tag
);
9035 public_section
= FALSE
;
9042 p
= display_pub_attribute (p
);
9044 else if (gnu_section
)
9047 p
= display_gnu_attribute (p
,
9048 display_proc_gnu_attribute
);
9052 /* ??? Do something sensible, like dump hex. */
9053 printf (" Unknown section contexts\n");
9060 printf (_("Unknown format '%c'\n"), *p
);
9068 process_arm_specific (FILE *file
)
9070 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9071 display_arm_attribute
, NULL
);
9075 process_power_specific (FILE *file
)
9077 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9078 display_power_gnu_attribute
);
9082 process_mips_specific (FILE *file
)
9084 Elf_Internal_Dyn
*entry
;
9085 size_t liblist_offset
= 0;
9086 size_t liblistno
= 0;
9087 size_t conflictsno
= 0;
9088 size_t options_offset
= 0;
9089 size_t conflicts_offset
= 0;
9091 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9092 display_mips_gnu_attribute
);
9094 /* We have a lot of special sections. Thanks SGI! */
9095 if (dynamic_section
== NULL
)
9096 /* No information available. */
9099 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9100 switch (entry
->d_tag
)
9102 case DT_MIPS_LIBLIST
:
9104 = offset_from_vma (file
, entry
->d_un
.d_val
,
9105 liblistno
* sizeof (Elf32_External_Lib
));
9107 case DT_MIPS_LIBLISTNO
:
9108 liblistno
= entry
->d_un
.d_val
;
9110 case DT_MIPS_OPTIONS
:
9111 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9113 case DT_MIPS_CONFLICT
:
9115 = offset_from_vma (file
, entry
->d_un
.d_val
,
9116 conflictsno
* sizeof (Elf32_External_Conflict
));
9118 case DT_MIPS_CONFLICTNO
:
9119 conflictsno
= entry
->d_un
.d_val
;
9125 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9127 Elf32_External_Lib
*elib
;
9130 elib
= get_data (NULL
, file
, liblist_offset
,
9131 liblistno
, sizeof (Elf32_External_Lib
),
9135 printf ("\nSection '.liblist' contains %lu entries:\n",
9136 (unsigned long) liblistno
);
9137 fputs (" Library Time Stamp Checksum Version Flags\n",
9140 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9147 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9148 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9149 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9150 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9151 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9153 tmp
= gmtime (&time
);
9154 snprintf (timebuf
, sizeof (timebuf
),
9155 "%04u-%02u-%02uT%02u:%02u:%02u",
9156 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9157 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9159 printf ("%3lu: ", (unsigned long) cnt
);
9160 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9161 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9163 printf ("<corrupt: %9ld>", liblist
.l_name
);
9164 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9167 if (liblist
.l_flags
== 0)
9178 { " EXACT_MATCH", LL_EXACT_MATCH
},
9179 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9180 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9181 { " EXPORTS", LL_EXPORTS
},
9182 { " DELAY_LOAD", LL_DELAY_LOAD
},
9183 { " DELTA", LL_DELTA
}
9185 int flags
= liblist
.l_flags
;
9188 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9189 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9191 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9192 flags
^= l_flags_vals
[fcnt
].bit
;
9195 printf (" %#x", (unsigned int) flags
);
9205 if (options_offset
!= 0)
9207 Elf_External_Options
*eopt
;
9208 Elf_Internal_Shdr
*sect
= section_headers
;
9209 Elf_Internal_Options
*iopt
;
9210 Elf_Internal_Options
*option
;
9214 /* Find the section header so that we get the size. */
9215 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9218 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9222 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
9225 error (_("Out of memory\n"));
9232 while (offset
< sect
->sh_size
)
9234 Elf_External_Options
*eoption
;
9236 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9238 option
->kind
= BYTE_GET (eoption
->kind
);
9239 option
->size
= BYTE_GET (eoption
->size
);
9240 option
->section
= BYTE_GET (eoption
->section
);
9241 option
->info
= BYTE_GET (eoption
->info
);
9243 offset
+= option
->size
;
9249 printf (_("\nSection '%s' contains %d entries:\n"),
9250 SECTION_NAME (sect
), cnt
);
9258 switch (option
->kind
)
9261 /* This shouldn't happen. */
9262 printf (" NULL %d %lx", option
->section
, option
->info
);
9265 printf (" REGINFO ");
9266 if (elf_header
.e_machine
== EM_MIPS
)
9269 Elf32_External_RegInfo
*ereg
;
9270 Elf32_RegInfo reginfo
;
9272 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9273 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9274 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9275 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9276 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9277 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9278 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9280 printf ("GPR %08lx GP 0x%lx\n",
9282 (unsigned long) reginfo
.ri_gp_value
);
9283 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9284 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9285 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9290 Elf64_External_RegInfo
*ereg
;
9291 Elf64_Internal_RegInfo reginfo
;
9293 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9294 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9295 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9296 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9297 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9298 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9299 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9301 printf ("GPR %08lx GP 0x",
9302 reginfo
.ri_gprmask
);
9303 printf_vma (reginfo
.ri_gp_value
);
9306 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9307 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9308 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9312 case ODK_EXCEPTIONS
:
9313 fputs (" EXCEPTIONS fpe_min(", stdout
);
9314 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9315 fputs (") fpe_max(", stdout
);
9316 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9317 fputs (")", stdout
);
9319 if (option
->info
& OEX_PAGE0
)
9320 fputs (" PAGE0", stdout
);
9321 if (option
->info
& OEX_SMM
)
9322 fputs (" SMM", stdout
);
9323 if (option
->info
& OEX_FPDBUG
)
9324 fputs (" FPDBUG", stdout
);
9325 if (option
->info
& OEX_DISMISS
)
9326 fputs (" DISMISS", stdout
);
9329 fputs (" PAD ", stdout
);
9330 if (option
->info
& OPAD_PREFIX
)
9331 fputs (" PREFIX", stdout
);
9332 if (option
->info
& OPAD_POSTFIX
)
9333 fputs (" POSTFIX", stdout
);
9334 if (option
->info
& OPAD_SYMBOL
)
9335 fputs (" SYMBOL", stdout
);
9338 fputs (" HWPATCH ", stdout
);
9339 if (option
->info
& OHW_R4KEOP
)
9340 fputs (" R4KEOP", stdout
);
9341 if (option
->info
& OHW_R8KPFETCH
)
9342 fputs (" R8KPFETCH", stdout
);
9343 if (option
->info
& OHW_R5KEOP
)
9344 fputs (" R5KEOP", stdout
);
9345 if (option
->info
& OHW_R5KCVTL
)
9346 fputs (" R5KCVTL", stdout
);
9349 fputs (" FILL ", stdout
);
9350 /* XXX Print content of info word? */
9353 fputs (" TAGS ", stdout
);
9354 /* XXX Print content of info word? */
9357 fputs (" HWAND ", stdout
);
9358 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9359 fputs (" R4KEOP_CHECKED", stdout
);
9360 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9361 fputs (" R4KEOP_CLEAN", stdout
);
9364 fputs (" HWOR ", stdout
);
9365 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9366 fputs (" R4KEOP_CHECKED", stdout
);
9367 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9368 fputs (" R4KEOP_CLEAN", stdout
);
9371 printf (" GP_GROUP %#06lx self-contained %#06lx",
9372 option
->info
& OGP_GROUP
,
9373 (option
->info
& OGP_SELF
) >> 16);
9376 printf (" IDENT %#06lx self-contained %#06lx",
9377 option
->info
& OGP_GROUP
,
9378 (option
->info
& OGP_SELF
) >> 16);
9381 /* This shouldn't happen. */
9382 printf (" %3d ??? %d %lx",
9383 option
->kind
, option
->section
, option
->info
);
9387 len
= sizeof (*eopt
);
9388 while (len
< option
->size
)
9389 if (((char *) option
)[len
] >= ' '
9390 && ((char *) option
)[len
] < 0x7f)
9391 printf ("%c", ((char *) option
)[len
++]);
9393 printf ("\\%03o", ((char *) option
)[len
++]);
9395 fputs ("\n", stdout
);
9403 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9405 Elf32_Conflict
*iconf
;
9408 if (dynamic_symbols
== NULL
)
9410 error (_("conflict list found without a dynamic symbol table\n"));
9414 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9417 error (_("Out of memory\n"));
9423 Elf32_External_Conflict
*econf32
;
9425 econf32
= get_data (NULL
, file
, conflicts_offset
,
9426 conflictsno
, sizeof (*econf32
), _("conflict"));
9430 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9431 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9437 Elf64_External_Conflict
*econf64
;
9439 econf64
= get_data (NULL
, file
, conflicts_offset
,
9440 conflictsno
, sizeof (*econf64
), _("conflict"));
9444 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9445 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9450 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9451 (unsigned long) conflictsno
);
9452 puts (_(" Num: Index Value Name"));
9454 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9456 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9458 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9459 print_vma (psym
->st_value
, FULL_HEX
);
9461 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9462 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9464 printf ("<corrupt: %14ld>", psym
->st_name
);
9475 process_gnu_liblist (FILE *file
)
9477 Elf_Internal_Shdr
*section
, *string_sec
;
9478 Elf32_External_Lib
*elib
;
9487 for (i
= 0, section
= section_headers
;
9488 i
< elf_header
.e_shnum
;
9491 switch (section
->sh_type
)
9493 case SHT_GNU_LIBLIST
:
9494 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
9497 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9502 string_sec
= SECTION_HEADER (section
->sh_link
);
9504 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9505 string_sec
->sh_size
, _("liblist string table"));
9506 strtab_size
= string_sec
->sh_size
;
9509 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9515 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9516 SECTION_NAME (section
),
9517 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9519 puts (" Library Time Stamp Checksum Version Flags");
9521 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9529 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9530 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9531 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9532 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9533 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9535 tmp
= gmtime (&time
);
9536 snprintf (timebuf
, sizeof (timebuf
),
9537 "%04u-%02u-%02uT%02u:%02u:%02u",
9538 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9539 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9541 printf ("%3lu: ", (unsigned long) cnt
);
9543 printf ("%-20s", liblist
.l_name
< strtab_size
9544 ? strtab
+ liblist
.l_name
: "<corrupt>");
9546 printf ("%-20.20s", liblist
.l_name
< strtab_size
9547 ? strtab
+ liblist
.l_name
: "<corrupt>");
9548 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9549 liblist
.l_version
, liblist
.l_flags
);
9560 get_note_type (unsigned e_type
)
9562 static char buff
[64];
9564 if (elf_header
.e_type
== ET_CORE
)
9568 return _("NT_AUXV (auxiliary vector)");
9570 return _("NT_PRSTATUS (prstatus structure)");
9572 return _("NT_FPREGSET (floating point registers)");
9574 return _("NT_PRPSINFO (prpsinfo structure)");
9576 return _("NT_TASKSTRUCT (task structure)");
9578 return _("NT_PRXFPREG (user_xfpregs structure)");
9580 return _("NT_PPC_VMX (ppc Altivec registers)");
9582 return _("NT_PSTATUS (pstatus structure)");
9584 return _("NT_FPREGS (floating point registers)");
9586 return _("NT_PSINFO (psinfo structure)");
9588 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9590 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9591 case NT_WIN32PSTATUS
:
9592 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9600 return _("NT_VERSION (version)");
9602 return _("NT_ARCH (architecture)");
9607 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9612 get_gnu_elf_note_type (unsigned e_type
)
9614 static char buff
[64];
9618 case NT_GNU_ABI_TAG
:
9619 return _("NT_GNU_ABI_TAG (ABI version tag)");
9621 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9622 case NT_GNU_BUILD_ID
:
9623 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9628 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9633 get_netbsd_elfcore_note_type (unsigned e_type
)
9635 static char buff
[64];
9637 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9639 /* NetBSD core "procinfo" structure. */
9640 return _("NetBSD procinfo structure");
9643 /* As of Jan 2002 there are no other machine-independent notes
9644 defined for NetBSD core files. If the note type is less
9645 than the start of the machine-dependent note types, we don't
9648 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9650 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9654 switch (elf_header
.e_machine
)
9656 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9657 and PT_GETFPREGS == mach+2. */
9662 case EM_SPARC32PLUS
:
9666 case NT_NETBSDCORE_FIRSTMACH
+0:
9667 return _("PT_GETREGS (reg structure)");
9668 case NT_NETBSDCORE_FIRSTMACH
+2:
9669 return _("PT_GETFPREGS (fpreg structure)");
9675 /* On all other arch's, PT_GETREGS == mach+1 and
9676 PT_GETFPREGS == mach+3. */
9680 case NT_NETBSDCORE_FIRSTMACH
+1:
9681 return _("PT_GETREGS (reg structure)");
9682 case NT_NETBSDCORE_FIRSTMACH
+3:
9683 return _("PT_GETFPREGS (fpreg structure)");
9689 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
9690 e_type
- NT_NETBSDCORE_FIRSTMACH
);
9694 /* Note that by the ELF standard, the name field is already null byte
9695 terminated, and namesz includes the terminating null byte.
9696 I.E. the value of namesz for the name "FSF" is 4.
9698 If the value of namesz is zero, there is no name present. */
9700 process_note (Elf_Internal_Note
*pnote
)
9702 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
9705 if (pnote
->namesz
== 0)
9706 /* If there is no note name, then use the default set of
9707 note type strings. */
9708 nt
= get_note_type (pnote
->type
);
9710 else if (const_strneq (pnote
->namedata
, "GNU"))
9711 /* GNU-specific object file notes. */
9712 nt
= get_gnu_elf_note_type (pnote
->type
);
9714 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
9715 /* NetBSD-specific core file notes. */
9716 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9718 else if (strneq (pnote
->namedata
, "SPU/", 4))
9720 /* SPU-specific core file notes. */
9721 nt
= pnote
->namedata
+ 4;
9726 /* Don't recognize this note name; just use the default set of
9727 note type strings. */
9728 nt
= get_note_type (pnote
->type
);
9730 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
9736 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
9738 Elf_External_Note
*pnotes
;
9739 Elf_External_Note
*external
;
9745 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
9751 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9752 (unsigned long) offset
, (unsigned long) length
);
9753 printf (_(" Owner\t\tData size\tDescription\n"));
9755 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9757 Elf_External_Note
*next
;
9758 Elf_Internal_Note inote
;
9761 inote
.type
= BYTE_GET (external
->type
);
9762 inote
.namesz
= BYTE_GET (external
->namesz
);
9763 inote
.namedata
= external
->name
;
9764 inote
.descsz
= BYTE_GET (external
->descsz
);
9765 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9766 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9768 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9770 if (((char *) next
) > (((char *) pnotes
) + length
))
9772 warn (_("corrupt note found at offset %lx into core notes\n"),
9773 (long)((char *)external
- (char *)pnotes
));
9774 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
9775 inote
.type
, inote
.namesz
, inote
.descsz
);
9781 /* Verify that name is null terminated. It appears that at least
9782 one version of Linux (RedHat 6.0) generates corefiles that don't
9783 comply with the ELF spec by failing to include the null byte in
9785 if (inote
.namedata
[inote
.namesz
] != '\0')
9787 temp
= malloc (inote
.namesz
+ 1);
9791 error (_("Out of memory\n"));
9796 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9797 temp
[inote
.namesz
] = 0;
9799 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9800 inote
.namedata
= temp
;
9803 res
&= process_note (& inote
);
9818 process_corefile_note_segments (FILE *file
)
9820 Elf_Internal_Phdr
*segment
;
9824 if (! get_program_headers (file
))
9827 for (i
= 0, segment
= program_headers
;
9828 i
< elf_header
.e_phnum
;
9831 if (segment
->p_type
== PT_NOTE
)
9832 res
&= process_corefile_note_segment (file
,
9833 (bfd_vma
) segment
->p_offset
,
9834 (bfd_vma
) segment
->p_filesz
);
9841 process_note_sections (FILE *file
)
9843 Elf_Internal_Shdr
*section
;
9847 for (i
= 0, section
= section_headers
;
9848 i
< elf_header
.e_shnum
;
9850 if (section
->sh_type
== SHT_NOTE
)
9851 res
&= process_corefile_note_segment (file
,
9852 (bfd_vma
) section
->sh_offset
,
9853 (bfd_vma
) section
->sh_size
);
9859 process_notes (FILE *file
)
9861 /* If we have not been asked to display the notes then do nothing. */
9865 if (elf_header
.e_type
!= ET_CORE
)
9866 return process_note_sections (file
);
9868 /* No program headers means no NOTE segment. */
9869 if (elf_header
.e_phnum
> 0)
9870 return process_corefile_note_segments (file
);
9872 printf (_("No note segments present in the core file.\n"));
9877 process_arch_specific (FILE *file
)
9882 switch (elf_header
.e_machine
)
9885 return process_arm_specific (file
);
9887 case EM_MIPS_RS3_LE
:
9888 return process_mips_specific (file
);
9891 return process_power_specific (file
);
9900 get_file_header (FILE *file
)
9902 /* Read in the identity array. */
9903 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9906 /* Determine how to read the rest of the header. */
9907 switch (elf_header
.e_ident
[EI_DATA
])
9909 default: /* fall through */
9910 case ELFDATANONE
: /* fall through */
9912 byte_get
= byte_get_little_endian
;
9913 byte_put
= byte_put_little_endian
;
9916 byte_get
= byte_get_big_endian
;
9917 byte_put
= byte_put_big_endian
;
9921 /* For now we only support 32 bit and 64 bit ELF files. */
9922 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9924 /* Read in the rest of the header. */
9927 Elf32_External_Ehdr ehdr32
;
9929 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9932 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9933 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9934 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9935 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9936 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9937 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9938 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9939 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9940 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9941 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9942 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9943 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9944 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9948 Elf64_External_Ehdr ehdr64
;
9950 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9951 we will not be able to cope with the 64bit data found in
9952 64 ELF files. Detect this now and abort before we start
9953 overwriting things. */
9954 if (sizeof (bfd_vma
) < 8)
9956 error (_("This instance of readelf has been built without support for a\n\
9957 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9961 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9964 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9965 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9966 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9967 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
9968 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
9969 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
9970 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9971 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9972 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9973 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9974 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9975 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9976 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9979 if (elf_header
.e_shoff
)
9981 /* There may be some extensions in the first section header. Don't
9982 bomb if we can't read it. */
9984 get_32bit_section_headers (file
, 1);
9986 get_64bit_section_headers (file
, 1);
9992 /* Process one ELF object file according to the command line options.
9993 This file may actually be stored in an archive. The file is
9994 positioned at the start of the ELF object. */
9997 process_object (char *file_name
, FILE *file
)
10001 if (! get_file_header (file
))
10003 error (_("%s: Failed to read file header\n"), file_name
);
10007 /* Initialise per file variables. */
10008 for (i
= ARRAY_SIZE (version_info
); i
--;)
10009 version_info
[i
] = 0;
10011 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
10012 dynamic_info
[i
] = 0;
10014 /* Process the file. */
10016 printf (_("\nFile: %s\n"), file_name
);
10018 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10019 Note we do this even if cmdline_dump_sects is empty because we
10020 must make sure that the dump_sets array is zeroed out before each
10021 object file is processed. */
10022 if (num_dump_sects
> num_cmdline_dump_sects
)
10023 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
10025 if (num_cmdline_dump_sects
> 0)
10027 if (num_dump_sects
== 0)
10028 /* A sneaky way of allocating the dump_sects array. */
10029 request_dump_bynumber (num_cmdline_dump_sects
, 0);
10031 assert (num_dump_sects
>= num_cmdline_dump_sects
);
10032 memcpy (dump_sects
, cmdline_dump_sects
,
10033 num_cmdline_dump_sects
* sizeof (* dump_sects
));
10036 if (! process_file_header ())
10039 if (! process_section_headers (file
))
10041 /* Without loaded section headers we cannot process lots of
10043 do_unwind
= do_version
= do_dump
= do_arch
= 0;
10045 if (! do_using_dynamic
)
10046 do_syms
= do_reloc
= 0;
10049 if (! process_section_groups (file
))
10051 /* Without loaded section groups we cannot process unwind. */
10055 if (process_program_headers (file
))
10056 process_dynamic_section (file
);
10058 process_relocs (file
);
10060 process_unwind (file
);
10062 process_symbol_table (file
);
10064 process_syminfo (file
);
10066 process_version_sections (file
);
10068 process_section_contents (file
);
10070 process_notes (file
);
10072 process_gnu_liblist (file
);
10074 process_arch_specific (file
);
10076 if (program_headers
)
10078 free (program_headers
);
10079 program_headers
= NULL
;
10082 if (section_headers
)
10084 free (section_headers
);
10085 section_headers
= NULL
;
10090 free (string_table
);
10091 string_table
= NULL
;
10092 string_table_length
= 0;
10095 if (dynamic_strings
)
10097 free (dynamic_strings
);
10098 dynamic_strings
= NULL
;
10099 dynamic_strings_length
= 0;
10102 if (dynamic_symbols
)
10104 free (dynamic_symbols
);
10105 dynamic_symbols
= NULL
;
10106 num_dynamic_syms
= 0;
10109 if (dynamic_syminfo
)
10111 free (dynamic_syminfo
);
10112 dynamic_syminfo
= NULL
;
10115 if (section_headers_groups
)
10117 free (section_headers_groups
);
10118 section_headers_groups
= NULL
;
10121 if (section_groups
)
10123 struct group_list
*g
, *next
;
10125 for (i
= 0; i
< group_count
; i
++)
10127 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10134 free (section_groups
);
10135 section_groups
= NULL
;
10138 free_debug_memory ();
10143 /* Process an ELF archive.
10144 On entry the file is positioned just after the ARMAG string. */
10147 process_archive (char *file_name
, FILE *file
)
10149 struct ar_hdr arhdr
;
10151 unsigned long size
;
10152 unsigned long index_num
= 0;
10153 unsigned long *index_array
= NULL
;
10154 char *sym_table
= NULL
;
10155 unsigned long sym_size
= 0;
10156 char *longnames
= NULL
;
10157 unsigned long longnames_size
= 0;
10158 size_t file_name_size
;
10163 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10164 if (got
!= sizeof arhdr
)
10169 error (_("%s: failed to read archive header\n"), file_name
);
10173 /* See if this is the archive symbol table. */
10174 if (const_strneq (arhdr
.ar_name
, "/ ")
10175 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
10177 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10178 size
= size
+ (size
& 1);
10180 if (do_archive_index
)
10183 /* A buffer used to hold numbers read in from an archive index.
10184 These are always 4 bytes long and stored in big-endian format. */
10185 #define SIZEOF_AR_INDEX_NUMBERS 4
10186 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10187 unsigned char * index_buffer
;
10189 /* Check the size of the archive index. */
10190 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10192 error (_("%s: the archive index is empty\n"), file_name
);
10196 /* Read the numer of entries in the archive index. */
10197 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10198 if (got
!= sizeof (integer_buffer
))
10200 error (_("%s: failed to read archive index\n"), file_name
);
10203 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10204 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10206 /* Read in the archive index. */
10207 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10209 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10210 file_name
, index_num
);
10213 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10214 if (index_buffer
== NULL
)
10216 error (_("Out of memory whilst trying to read archive symbol index\n"));
10219 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
10220 if (got
!= index_num
)
10222 free (index_buffer
);
10223 error (_("%s: failed to read archive index\n"), file_name
);
10227 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10229 /* Convert the index numbers into the host's numeric format. */
10230 index_array
= malloc (index_num
* sizeof (* index_array
));
10231 if (index_array
== NULL
)
10233 free (index_buffer
);
10234 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10238 for (i
= 0; i
< index_num
; i
++)
10239 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10240 SIZEOF_AR_INDEX_NUMBERS
);
10241 free (index_buffer
);
10243 /* The remaining space in the header is taken up by the symbol table. */
10246 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10250 sym_table
= malloc (size
);
10252 if (sym_table
== NULL
)
10254 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10258 got
= fread (sym_table
, 1, size
, file
);
10261 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10268 if (fseek (file
, size
, SEEK_CUR
) != 0)
10270 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10275 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10276 if (got
!= sizeof arhdr
)
10284 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10289 else if (do_archive_index
)
10290 printf (_("%s has no archive index\n"), file_name
);
10292 if (const_strneq (arhdr
.ar_name
, "// "))
10294 /* This is the archive string table holding long member
10297 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10298 longnames
= malloc (longnames_size
);
10299 if (longnames
== NULL
)
10301 error (_("Out of memory reading long symbol names in archive\n"));
10306 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10309 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10314 if ((longnames_size
& 1) != 0)
10317 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10318 if (got
!= sizeof arhdr
)
10324 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10331 if (do_archive_index
)
10333 if (sym_table
== NULL
)
10334 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10337 unsigned int i
, j
, k
, l
;
10339 unsigned long current_pos
;
10341 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10342 file_name
, index_num
, sym_size
);
10343 current_pos
= ftell (file
);
10345 for (i
= l
= 0; i
< index_num
; i
++)
10347 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10349 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10351 error (_("%s: failed to seek to next file name\n"), file_name
);
10355 got
= fread (elf_name
, 1, 16, file
);
10358 error (_("%s: failed to read file name\n"), file_name
);
10363 if (elf_name
[0] == '/')
10365 /* We have a long name. */
10366 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10367 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10369 longnames
[j
] = '\0';
10370 printf (_("Binary %s contains:\n"), longnames
+ k
);
10371 longnames
[j
] = '/';
10376 while ((elf_name
[j
] != '/') && (j
< 16))
10378 elf_name
[j
] = '\0';
10379 printf(_("Binary %s contains:\n"), elf_name
);
10384 error (_("%s: end of the symbol table reached before the end of the index\n"),
10388 printf ("\t%s\n", sym_table
+ l
);
10389 l
+= strlen (sym_table
+ l
) + 1;
10393 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10396 free (index_array
);
10397 index_array
= NULL
;
10400 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10402 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10407 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10408 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10409 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10410 && !do_section_groups
)
10411 return 0; /* Archive index only. */
10414 file_name_size
= strlen (file_name
);
10423 if (arhdr
.ar_name
[0] == '/')
10427 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10428 if (off
>= longnames_size
)
10430 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10435 name
= longnames
+ off
;
10436 nameend
= memchr (name
, '/', longnames_size
- off
);
10440 name
= arhdr
.ar_name
;
10441 nameend
= memchr (name
, '/', 16);
10444 if (nameend
== NULL
)
10446 error (_("%s: bad archive file name\n"), file_name
);
10451 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10452 if (namealc
== NULL
)
10454 error (_("Out of memory\n"));
10459 memcpy (namealc
, file_name
, file_name_size
);
10460 namealc
[file_name_size
] = '(';
10461 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10462 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10463 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10465 archive_file_offset
= ftell (file
);
10466 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10468 ret
|= process_object (namealc
, file
);
10473 (archive_file_offset
10474 + archive_file_size
10475 + (archive_file_size
& 1)),
10478 error (_("%s: failed to seek to next archive header\n"), file_name
);
10483 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10484 if (got
!= sizeof arhdr
)
10489 error (_("%s: failed to read archive header\n"), file_name
);
10496 if (index_array
!= NULL
)
10497 free (index_array
);
10498 if (sym_table
!= NULL
)
10500 if (longnames
!= NULL
)
10507 process_file (char *file_name
)
10510 struct stat statbuf
;
10511 char armag
[SARMAG
];
10514 if (stat (file_name
, &statbuf
) < 0)
10516 if (errno
== ENOENT
)
10517 error (_("'%s': No such file\n"), file_name
);
10519 error (_("Could not locate '%s'. System error message: %s\n"),
10520 file_name
, strerror (errno
));
10524 if (! S_ISREG (statbuf
.st_mode
))
10526 error (_("'%s' is not an ordinary file\n"), file_name
);
10530 file
= fopen (file_name
, "rb");
10533 error (_("Input file '%s' is not readable.\n"), file_name
);
10537 if (fread (armag
, SARMAG
, 1, file
) != 1)
10539 error (_("%s: Failed to read file's magic number\n"), file_name
);
10544 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10545 ret
= process_archive (file_name
, file
);
10548 if (do_archive_index
)
10549 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10553 archive_file_size
= archive_file_offset
= 0;
10554 ret
= process_object (file_name
, file
);
10562 #ifdef SUPPORT_DISASSEMBLY
10563 /* Needed by the i386 disassembler. For extra credit, someone could
10564 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10568 print_address (unsigned int addr
, FILE *outfile
)
10570 fprintf (outfile
,"0x%8.8x", addr
);
10573 /* Needed by the i386 disassembler. */
10575 db_task_printsym (unsigned int addr
)
10577 print_address (addr
, stderr
);
10582 main (int argc
, char **argv
)
10586 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10587 setlocale (LC_MESSAGES
, "");
10589 #if defined (HAVE_SETLOCALE)
10590 setlocale (LC_CTYPE
, "");
10592 bindtextdomain (PACKAGE
, LOCALEDIR
);
10593 textdomain (PACKAGE
);
10595 expandargv (&argc
, &argv
);
10597 parse_args (argc
, argv
);
10599 if (num_dump_sects
> 0)
10601 /* Make a copy of the dump_sects array. */
10602 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
10603 if (cmdline_dump_sects
== NULL
)
10604 error (_("Out of memory allocating dump request table.\n"));
10607 memcpy (cmdline_dump_sects
, dump_sects
,
10608 num_dump_sects
* sizeof (* dump_sects
));
10609 num_cmdline_dump_sects
= num_dump_sects
;
10613 if (optind
< (argc
- 1))
10617 while (optind
< argc
)
10618 err
|= process_file (argv
[optind
++]);
10620 if (dump_sects
!= NULL
)
10622 if (cmdline_dump_sects
!= NULL
)
10623 free (cmdline_dump_sects
);