1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 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
496 return nc
+ printf ("%llx", vma
);
498 return nc
+ print_hex_vma (vma
);
502 #if BFD_HOST_64BIT_LONG
503 return printf ("%ld", vma
);
504 #elif BFD_HOST_64BIT_LONG_LONG
505 return printf ("%lld", vma
);
507 return print_dec_vma (vma
, 1);
511 #if BFD_HOST_64BIT_LONG
513 return printf ("%5ld", vma
);
515 return printf ("%#lx", vma
);
516 #elif BFD_HOST_64BIT_LONG_LONG
518 return printf ("%5lld", vma
);
520 return printf ("%#llx", vma
);
523 return printf ("%5ld", _bfd_int64_low (vma
));
525 return print_hex_vma (vma
);
529 #if BFD_HOST_64BIT_LONG
530 return printf ("%lu", vma
);
531 #elif BFD_HOST_64BIT_LONG_LONG
532 return printf ("%llu", vma
);
534 return print_dec_vma (vma
, 0);
542 /* Display a symbol on stdout. If do_wide is not true then
543 format the symbol to be at most WIDTH characters,
544 truncating as necessary. If WIDTH is negative then
545 format the string to be exactly - WIDTH characters,
546 truncating or padding as necessary. */
549 print_symbol (int width
, const char *symbol
)
552 printf ("%s", symbol
);
554 printf ("%-*.*s", width
, width
, symbol
);
556 printf ("%-.*s", width
, symbol
);
560 byte_put_big_endian (unsigned char *field
, bfd_vma value
, int size
)
565 field
[7] = value
& 0xff;
566 field
[6] = (value
>> 8) & 0xff;
567 field
[5] = (value
>> 16) & 0xff;
568 field
[4] = (value
>> 24) & 0xff;
573 field
[3] = value
& 0xff;
574 field
[2] = (value
>> 8) & 0xff;
578 field
[1] = value
& 0xff;
582 field
[0] = value
& 0xff;
586 error (_("Unhandled data length: %d\n"), size
);
591 /* Return a pointer to section NAME, or NULL if no such section exists. */
593 static Elf_Internal_Shdr
*
594 find_section (const char *name
)
598 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
599 if (streq (SECTION_NAME (section_headers
+ i
), name
))
600 return section_headers
+ i
;
605 /* Guess the relocation size commonly used by the specific machines. */
608 guess_is_rela (unsigned long e_machine
)
612 /* Targets that use REL relocations. */
628 /* Targets that use RELA relocations. */
632 case EM_ALTERA_NIOS2
:
657 case EM_CYGNUS_MN10200
:
659 case EM_CYGNUS_MN10300
:
700 warn (_("Don't know about relocations on this machine architecture\n"));
706 slurp_rela_relocs (FILE *file
,
707 unsigned long rel_offset
,
708 unsigned long rel_size
,
709 Elf_Internal_Rela
**relasp
,
710 unsigned long *nrelasp
)
712 Elf_Internal_Rela
*relas
;
713 unsigned long nrelas
;
718 Elf32_External_Rela
*erelas
;
720 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
724 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
726 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
731 error (_("out of memory parsing relocs\n"));
735 for (i
= 0; i
< nrelas
; i
++)
737 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
738 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
739 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
746 Elf64_External_Rela
*erelas
;
748 erelas
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
752 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
754 relas
= cmalloc (nrelas
, sizeof (Elf_Internal_Rela
));
759 error (_("out of memory parsing relocs\n"));
763 for (i
= 0; i
< nrelas
; i
++)
765 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
766 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
767 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
778 slurp_rel_relocs (FILE *file
,
779 unsigned long rel_offset
,
780 unsigned long rel_size
,
781 Elf_Internal_Rela
**relsp
,
782 unsigned long *nrelsp
)
784 Elf_Internal_Rela
*rels
;
790 Elf32_External_Rel
*erels
;
792 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
796 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
798 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
803 error (_("out of memory parsing relocs\n"));
807 for (i
= 0; i
< nrels
; i
++)
809 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
810 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
811 rels
[i
].r_addend
= 0;
818 Elf64_External_Rel
*erels
;
820 erels
= get_data (NULL
, file
, rel_offset
, 1, rel_size
, _("relocs"));
824 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
826 rels
= cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
831 error (_("out of memory parsing relocs\n"));
835 for (i
= 0; i
< nrels
; i
++)
837 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
838 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
839 rels
[i
].r_addend
= 0;
849 /* Returns the reloc type extracted from the reloc info field. */
852 get_reloc_type (bfd_vma reloc_info
)
855 return ELF32_R_TYPE (reloc_info
);
857 switch (elf_header
.e_machine
)
860 /* Note: We assume that reloc_info has already been adjusted for us. */
861 return ELF64_MIPS_R_TYPE (reloc_info
);
864 return ELF64_R_TYPE_ID (reloc_info
);
867 return ELF64_R_TYPE (reloc_info
);
871 /* Return the symbol index extracted from the reloc info field. */
874 get_reloc_symindex (bfd_vma reloc_info
)
876 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
879 /* Display the contents of the relocation data found at the specified
883 dump_relocations (FILE *file
,
884 unsigned long rel_offset
,
885 unsigned long rel_size
,
886 Elf_Internal_Sym
*symtab
,
889 unsigned long strtablen
,
893 Elf_Internal_Rela
*rels
;
896 if (is_rela
== UNKNOWN
)
897 is_rela
= guess_is_rela (elf_header
.e_machine
);
901 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
906 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
915 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
917 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
922 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
924 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
932 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
934 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
939 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
941 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
945 for (i
= 0; i
< rel_size
; i
++)
950 bfd_vma symtab_index
;
953 offset
= rels
[i
].r_offset
;
954 info
= rels
[i
].r_info
;
956 /* The #ifdef BFD64 below is to prevent a compile time warning.
957 We know that if we do not have a 64 bit data type that we
958 will never execute this code anyway. */
961 && elf_header
.e_machine
== EM_MIPS
962 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
964 /* In little-endian objects, r_info isn't really a 64-bit
965 little-endian value: it has a 32-bit little-endian
966 symbol index followed by four individual byte fields.
967 Reorder INFO accordingly. */
968 info
= (((info
& 0xffffffff) << 32)
969 | ((info
>> 56) & 0xff)
970 | ((info
>> 40) & 0xff00)
971 | ((info
>> 24) & 0xff0000)
972 | ((info
>> 8) & 0xff000000));
976 type
= get_reloc_type (info
);
977 symtab_index
= get_reloc_symindex (info
);
981 printf ("%8.8lx %8.8lx ",
982 (unsigned long) offset
& 0xffffffff,
983 (unsigned long) info
& 0xffffffff);
987 #if BFD_HOST_64BIT_LONG
989 ? "%16.16lx %16.16lx "
990 : "%12.12lx %12.12lx ",
992 #elif BFD_HOST_64BIT_LONG_LONG
994 ? "%16.16llx %16.16llx "
995 : "%12.12llx %12.12llx ",
999 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1000 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1001 _bfd_int64_high (offset
),
1002 _bfd_int64_low (offset
),
1003 _bfd_int64_high (info
),
1004 _bfd_int64_low (info
));
1008 switch (elf_header
.e_machine
)
1015 case EM_CYGNUS_M32R
:
1016 rtype
= elf_m32r_reloc_type (type
);
1021 rtype
= elf_i386_reloc_type (type
);
1026 rtype
= elf_m68hc11_reloc_type (type
);
1030 rtype
= elf_m68k_reloc_type (type
);
1034 rtype
= elf_i960_reloc_type (type
);
1039 rtype
= elf_avr_reloc_type (type
);
1042 case EM_OLD_SPARCV9
:
1043 case EM_SPARC32PLUS
:
1046 rtype
= elf_sparc_reloc_type (type
);
1050 rtype
= elf_spu_reloc_type (type
);
1054 case EM_CYGNUS_V850
:
1055 rtype
= v850_reloc_type (type
);
1059 case EM_CYGNUS_D10V
:
1060 rtype
= elf_d10v_reloc_type (type
);
1064 case EM_CYGNUS_D30V
:
1065 rtype
= elf_d30v_reloc_type (type
);
1069 rtype
= elf_dlx_reloc_type (type
);
1073 rtype
= elf_sh_reloc_type (type
);
1077 case EM_CYGNUS_MN10300
:
1078 rtype
= elf_mn10300_reloc_type (type
);
1082 case EM_CYGNUS_MN10200
:
1083 rtype
= elf_mn10200_reloc_type (type
);
1087 case EM_CYGNUS_FR30
:
1088 rtype
= elf_fr30_reloc_type (type
);
1092 rtype
= elf_frv_reloc_type (type
);
1096 rtype
= elf_mcore_reloc_type (type
);
1100 rtype
= elf_mmix_reloc_type (type
);
1105 rtype
= elf_msp430_reloc_type (type
);
1109 rtype
= elf_ppc_reloc_type (type
);
1113 rtype
= elf_ppc64_reloc_type (type
);
1117 case EM_MIPS_RS3_LE
:
1118 rtype
= elf_mips_reloc_type (type
);
1122 rtype
= elf_alpha_reloc_type (type
);
1126 rtype
= elf_arm_reloc_type (type
);
1130 rtype
= elf_arc_reloc_type (type
);
1134 rtype
= elf_hppa_reloc_type (type
);
1140 rtype
= elf_h8_reloc_type (type
);
1145 rtype
= elf_or32_reloc_type (type
);
1150 rtype
= elf_pj_reloc_type (type
);
1153 rtype
= elf_ia64_reloc_type (type
);
1157 rtype
= elf_cris_reloc_type (type
);
1161 rtype
= elf_i860_reloc_type (type
);
1165 rtype
= elf_x86_64_reloc_type (type
);
1169 rtype
= i370_reloc_type (type
);
1174 rtype
= elf_s390_reloc_type (type
);
1178 rtype
= elf_score_reloc_type (type
);
1182 rtype
= elf_xstormy16_reloc_type (type
);
1186 rtype
= elf_crx_reloc_type (type
);
1190 rtype
= elf_vax_reloc_type (type
);
1195 rtype
= elf_ip2k_reloc_type (type
);
1199 rtype
= elf_iq2000_reloc_type (type
);
1204 rtype
= elf_xtensa_reloc_type (type
);
1208 rtype
= elf_m32c_reloc_type (type
);
1212 rtype
= elf_mt_reloc_type (type
);
1216 rtype
= elf_bfin_reloc_type (type
);
1220 rtype
= elf_mep_reloc_type (type
);
1224 rtype
= elf_cr16_reloc_type (type
);
1229 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1231 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1233 if (elf_header
.e_machine
== EM_ALPHA
1235 && streq (rtype
, "R_ALPHA_LITUSE")
1238 switch (rels
[i
].r_addend
)
1240 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1241 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1242 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1243 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1244 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1245 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1246 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1247 default: rtype
= NULL
;
1250 printf (" (%s)", rtype
);
1254 printf (_("<unknown addend: %lx>"),
1255 (unsigned long) rels
[i
].r_addend
);
1258 else if (symtab_index
)
1260 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1261 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1264 Elf_Internal_Sym
*psym
;
1266 psym
= symtab
+ symtab_index
;
1269 print_vma (psym
->st_value
, LONG_HEX
);
1270 printf (is_32bit_elf
? " " : " ");
1272 if (psym
->st_name
== 0)
1274 const char *sec_name
= "<null>";
1277 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1279 bfd_vma sec_index
= (bfd_vma
) -1;
1281 if (psym
->st_shndx
< SHN_LORESERVE
)
1282 sec_index
= psym
->st_shndx
;
1283 else if (psym
->st_shndx
> SHN_HIRESERVE
)
1284 sec_index
= psym
->st_shndx
- (SHN_HIRESERVE
+ 1
1287 if (sec_index
!= (bfd_vma
) -1)
1288 sec_name
= SECTION_NAME (section_headers
+ sec_index
);
1289 else if (psym
->st_shndx
== SHN_ABS
)
1291 else if (psym
->st_shndx
== SHN_COMMON
)
1292 sec_name
= "COMMON";
1293 else if (elf_header
.e_machine
== EM_MIPS
1294 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1295 sec_name
= "SCOMMON";
1296 else if (elf_header
.e_machine
== EM_MIPS
1297 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1298 sec_name
= "SUNDEF";
1299 else if (elf_header
.e_machine
== EM_X86_64
1300 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1301 sec_name
= "LARGE_COMMON";
1302 else if (elf_header
.e_machine
== EM_IA_64
1303 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1304 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1305 sec_name
= "ANSI_COM";
1308 sprintf (name_buf
, "<section 0x%x>",
1309 (unsigned int) psym
->st_shndx
);
1310 sec_name
= name_buf
;
1313 print_symbol (22, sec_name
);
1315 else if (strtab
== NULL
)
1316 printf (_("<string table index: %3ld>"), psym
->st_name
);
1317 else if (psym
->st_name
>= strtablen
)
1318 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1320 print_symbol (22, strtab
+ psym
->st_name
);
1323 printf (" + %lx", (unsigned long) rels
[i
].r_addend
);
1328 printf ("%*c", is_32bit_elf
?
1329 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1330 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1333 if (elf_header
.e_machine
== EM_SPARCV9
1335 && streq (rtype
, "R_SPARC_OLO10"))
1336 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1341 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1343 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (info
);
1344 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (info
);
1345 const char *rtype2
= elf_mips_reloc_type (type2
);
1346 const char *rtype3
= elf_mips_reloc_type (type3
);
1348 printf (" Type2: ");
1351 printf (_("unrecognized: %-7lx"),
1352 (unsigned long) type2
& 0xffffffff);
1354 printf ("%-17.17s", rtype2
);
1356 printf ("\n Type3: ");
1359 printf (_("unrecognized: %-7lx"),
1360 (unsigned long) type3
& 0xffffffff);
1362 printf ("%-17.17s", rtype3
);
1373 get_mips_dynamic_type (unsigned long type
)
1377 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1378 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1379 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1380 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1381 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1382 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1383 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1384 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1385 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1386 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1387 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1388 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1389 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1390 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1391 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1392 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1393 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1394 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1395 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1396 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1397 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1398 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1399 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1400 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1401 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1402 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1403 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1404 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1405 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1406 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1407 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1408 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1409 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1410 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1411 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1412 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1413 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1414 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1415 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1416 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1417 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1418 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1419 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1426 get_sparc64_dynamic_type (unsigned long type
)
1430 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1437 get_ppc_dynamic_type (unsigned long type
)
1441 case DT_PPC_GOT
: return "PPC_GOT";
1448 get_ppc64_dynamic_type (unsigned long type
)
1452 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1453 case DT_PPC64_OPD
: return "PPC64_OPD";
1454 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1461 get_parisc_dynamic_type (unsigned long type
)
1465 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1466 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1467 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1468 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1469 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1470 case DT_HP_PREINIT
: return "HP_PREINIT";
1471 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1472 case DT_HP_NEEDED
: return "HP_NEEDED";
1473 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1474 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1475 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1476 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1477 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1478 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1479 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1480 case DT_HP_FILTERED
: return "HP_FILTERED";
1481 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1482 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1483 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1484 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1485 case DT_PLT
: return "PLT";
1486 case DT_PLT_SIZE
: return "PLT_SIZE";
1487 case DT_DLT
: return "DLT";
1488 case DT_DLT_SIZE
: return "DLT_SIZE";
1495 get_ia64_dynamic_type (unsigned long type
)
1499 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1506 get_alpha_dynamic_type (unsigned long type
)
1510 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1517 get_score_dynamic_type (unsigned long type
)
1521 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1522 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1523 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1524 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1525 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1526 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1534 get_dynamic_type (unsigned long type
)
1536 static char buff
[64];
1540 case DT_NULL
: return "NULL";
1541 case DT_NEEDED
: return "NEEDED";
1542 case DT_PLTRELSZ
: return "PLTRELSZ";
1543 case DT_PLTGOT
: return "PLTGOT";
1544 case DT_HASH
: return "HASH";
1545 case DT_STRTAB
: return "STRTAB";
1546 case DT_SYMTAB
: return "SYMTAB";
1547 case DT_RELA
: return "RELA";
1548 case DT_RELASZ
: return "RELASZ";
1549 case DT_RELAENT
: return "RELAENT";
1550 case DT_STRSZ
: return "STRSZ";
1551 case DT_SYMENT
: return "SYMENT";
1552 case DT_INIT
: return "INIT";
1553 case DT_FINI
: return "FINI";
1554 case DT_SONAME
: return "SONAME";
1555 case DT_RPATH
: return "RPATH";
1556 case DT_SYMBOLIC
: return "SYMBOLIC";
1557 case DT_REL
: return "REL";
1558 case DT_RELSZ
: return "RELSZ";
1559 case DT_RELENT
: return "RELENT";
1560 case DT_PLTREL
: return "PLTREL";
1561 case DT_DEBUG
: return "DEBUG";
1562 case DT_TEXTREL
: return "TEXTREL";
1563 case DT_JMPREL
: return "JMPREL";
1564 case DT_BIND_NOW
: return "BIND_NOW";
1565 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1566 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1567 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1568 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1569 case DT_RUNPATH
: return "RUNPATH";
1570 case DT_FLAGS
: return "FLAGS";
1572 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1573 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1575 case DT_CHECKSUM
: return "CHECKSUM";
1576 case DT_PLTPADSZ
: return "PLTPADSZ";
1577 case DT_MOVEENT
: return "MOVEENT";
1578 case DT_MOVESZ
: return "MOVESZ";
1579 case DT_FEATURE
: return "FEATURE";
1580 case DT_POSFLAG_1
: return "POSFLAG_1";
1581 case DT_SYMINSZ
: return "SYMINSZ";
1582 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1584 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1585 case DT_CONFIG
: return "CONFIG";
1586 case DT_DEPAUDIT
: return "DEPAUDIT";
1587 case DT_AUDIT
: return "AUDIT";
1588 case DT_PLTPAD
: return "PLTPAD";
1589 case DT_MOVETAB
: return "MOVETAB";
1590 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1592 case DT_VERSYM
: return "VERSYM";
1594 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1595 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1596 case DT_RELACOUNT
: return "RELACOUNT";
1597 case DT_RELCOUNT
: return "RELCOUNT";
1598 case DT_FLAGS_1
: return "FLAGS_1";
1599 case DT_VERDEF
: return "VERDEF";
1600 case DT_VERDEFNUM
: return "VERDEFNUM";
1601 case DT_VERNEED
: return "VERNEED";
1602 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1604 case DT_AUXILIARY
: return "AUXILIARY";
1605 case DT_USED
: return "USED";
1606 case DT_FILTER
: return "FILTER";
1608 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1609 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1610 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1611 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1612 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1613 case DT_GNU_HASH
: return "GNU_HASH";
1616 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1620 switch (elf_header
.e_machine
)
1623 case EM_MIPS_RS3_LE
:
1624 result
= get_mips_dynamic_type (type
);
1627 result
= get_sparc64_dynamic_type (type
);
1630 result
= get_ppc_dynamic_type (type
);
1633 result
= get_ppc64_dynamic_type (type
);
1636 result
= get_ia64_dynamic_type (type
);
1639 result
= get_alpha_dynamic_type (type
);
1642 result
= get_score_dynamic_type (type
);
1652 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1654 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1655 || (elf_header
.e_machine
== EM_PARISC
1656 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1660 switch (elf_header
.e_machine
)
1663 result
= get_parisc_dynamic_type (type
);
1673 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1677 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1684 get_file_type (unsigned e_type
)
1686 static char buff
[32];
1690 case ET_NONE
: return _("NONE (None)");
1691 case ET_REL
: return _("REL (Relocatable file)");
1692 case ET_EXEC
: return _("EXEC (Executable file)");
1693 case ET_DYN
: return _("DYN (Shared object file)");
1694 case ET_CORE
: return _("CORE (Core file)");
1697 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1698 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1699 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1700 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1702 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1708 get_machine_name (unsigned e_machine
)
1710 static char buff
[64]; /* XXX */
1714 case EM_NONE
: return _("None");
1715 case EM_M32
: return "WE32100";
1716 case EM_SPARC
: return "Sparc";
1717 case EM_SPU
: return "SPU";
1718 case EM_386
: return "Intel 80386";
1719 case EM_68K
: return "MC68000";
1720 case EM_88K
: return "MC88000";
1721 case EM_486
: return "Intel 80486";
1722 case EM_860
: return "Intel 80860";
1723 case EM_MIPS
: return "MIPS R3000";
1724 case EM_S370
: return "IBM System/370";
1725 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1726 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1727 case EM_PARISC
: return "HPPA";
1728 case EM_PPC_OLD
: return "Power PC (old)";
1729 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1730 case EM_960
: return "Intel 90860";
1731 case EM_PPC
: return "PowerPC";
1732 case EM_PPC64
: return "PowerPC64";
1733 case EM_V800
: return "NEC V800";
1734 case EM_FR20
: return "Fujitsu FR20";
1735 case EM_RH32
: return "TRW RH32";
1736 case EM_MCORE
: return "MCORE";
1737 case EM_ARM
: return "ARM";
1738 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1739 case EM_SH
: return "Renesas / SuperH SH";
1740 case EM_SPARCV9
: return "Sparc v9";
1741 case EM_TRICORE
: return "Siemens Tricore";
1742 case EM_ARC
: return "ARC";
1743 case EM_H8_300
: return "Renesas H8/300";
1744 case EM_H8_300H
: return "Renesas H8/300H";
1745 case EM_H8S
: return "Renesas H8S";
1746 case EM_H8_500
: return "Renesas H8/500";
1747 case EM_IA_64
: return "Intel IA-64";
1748 case EM_MIPS_X
: return "Stanford MIPS-X";
1749 case EM_COLDFIRE
: return "Motorola Coldfire";
1750 case EM_68HC12
: return "Motorola M68HC12";
1751 case EM_ALPHA
: return "Alpha";
1752 case EM_CYGNUS_D10V
:
1753 case EM_D10V
: return "d10v";
1754 case EM_CYGNUS_D30V
:
1755 case EM_D30V
: return "d30v";
1756 case EM_CYGNUS_M32R
:
1757 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1758 case EM_CYGNUS_V850
:
1759 case EM_V850
: return "NEC v850";
1760 case EM_CYGNUS_MN10300
:
1761 case EM_MN10300
: return "mn10300";
1762 case EM_CYGNUS_MN10200
:
1763 case EM_MN10200
: return "mn10200";
1764 case EM_CYGNUS_FR30
:
1765 case EM_FR30
: return "Fujitsu FR30";
1766 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1768 case EM_PJ
: return "picoJava";
1769 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1770 case EM_PCP
: return "Siemens PCP";
1771 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1772 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1773 case EM_STARCORE
: return "Motorola Star*Core processor";
1774 case EM_ME16
: return "Toyota ME16 processor";
1775 case EM_ST100
: return "STMicroelectronics ST100 processor";
1776 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1777 case EM_FX66
: return "Siemens FX66 microcontroller";
1778 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1779 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1780 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1781 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1782 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1783 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1784 case EM_SVX
: return "Silicon Graphics SVx";
1785 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1786 case EM_VAX
: return "Digital VAX";
1788 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1789 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1790 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1791 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1792 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1793 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1794 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1795 case EM_PRISM
: return "Vitesse Prism";
1796 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1798 case EM_S390
: return "IBM S/390";
1799 case EM_SCORE
: return "SUNPLUS S+Core";
1800 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1802 case EM_OR32
: return "OpenRISC";
1803 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1804 case EM_DLX
: return "OpenDLX";
1806 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1807 case EM_IQ2000
: return "Vitesse IQ2000";
1809 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1810 case EM_M32C
: return "Renesas M32c";
1811 case EM_MT
: return "Morpho Techologies MT processor";
1812 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1813 case EM_NIOS32
: return "Altera Nios";
1814 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1815 case EM_XC16X
: return "Infineon Technologies xc16x";
1816 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
1817 case EM_CR16
: return "National Semiconductor's CR16";
1819 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
1825 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
1830 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1831 e_flags
&= ~ EF_ARM_EABIMASK
;
1833 /* Handle "generic" ARM flags. */
1834 if (e_flags
& EF_ARM_RELEXEC
)
1836 strcat (buf
, ", relocatable executable");
1837 e_flags
&= ~ EF_ARM_RELEXEC
;
1840 if (e_flags
& EF_ARM_HASENTRY
)
1842 strcat (buf
, ", has entry point");
1843 e_flags
&= ~ EF_ARM_HASENTRY
;
1846 /* Now handle EABI specific flags. */
1850 strcat (buf
, ", <unrecognized EABI>");
1855 case EF_ARM_EABI_VER1
:
1856 strcat (buf
, ", Version1 EABI");
1861 /* Process flags one bit at a time. */
1862 flag
= e_flags
& - e_flags
;
1867 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1868 strcat (buf
, ", sorted symbol tables");
1878 case EF_ARM_EABI_VER2
:
1879 strcat (buf
, ", Version2 EABI");
1884 /* Process flags one bit at a time. */
1885 flag
= e_flags
& - e_flags
;
1890 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1891 strcat (buf
, ", sorted symbol tables");
1894 case EF_ARM_DYNSYMSUSESEGIDX
:
1895 strcat (buf
, ", dynamic symbols use segment index");
1898 case EF_ARM_MAPSYMSFIRST
:
1899 strcat (buf
, ", mapping symbols precede others");
1909 case EF_ARM_EABI_VER3
:
1910 strcat (buf
, ", Version3 EABI");
1913 case EF_ARM_EABI_VER4
:
1914 strcat (buf
, ", Version4 EABI");
1917 case EF_ARM_EABI_VER5
:
1918 strcat (buf
, ", Version5 EABI");
1924 /* Process flags one bit at a time. */
1925 flag
= e_flags
& - e_flags
;
1931 strcat (buf
, ", BE8");
1935 strcat (buf
, ", LE8");
1945 case EF_ARM_EABI_UNKNOWN
:
1946 strcat (buf
, ", GNU EABI");
1951 /* Process flags one bit at a time. */
1952 flag
= e_flags
& - e_flags
;
1957 case EF_ARM_INTERWORK
:
1958 strcat (buf
, ", interworking enabled");
1961 case EF_ARM_APCS_26
:
1962 strcat (buf
, ", uses APCS/26");
1965 case EF_ARM_APCS_FLOAT
:
1966 strcat (buf
, ", uses APCS/float");
1970 strcat (buf
, ", position independent");
1974 strcat (buf
, ", 8 bit structure alignment");
1977 case EF_ARM_NEW_ABI
:
1978 strcat (buf
, ", uses new ABI");
1981 case EF_ARM_OLD_ABI
:
1982 strcat (buf
, ", uses old ABI");
1985 case EF_ARM_SOFT_FLOAT
:
1986 strcat (buf
, ", software FP");
1989 case EF_ARM_VFP_FLOAT
:
1990 strcat (buf
, ", VFP");
1993 case EF_ARM_MAVERICK_FLOAT
:
1994 strcat (buf
, ", Maverick FP");
2005 strcat (buf
,", <unknown>");
2009 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2011 static char buf
[1024];
2023 decode_ARM_machine_flags (e_flags
, buf
);
2027 switch (e_flags
& EF_FRV_CPU_MASK
)
2029 case EF_FRV_CPU_GENERIC
:
2033 strcat (buf
, ", fr???");
2036 case EF_FRV_CPU_FR300
:
2037 strcat (buf
, ", fr300");
2040 case EF_FRV_CPU_FR400
:
2041 strcat (buf
, ", fr400");
2043 case EF_FRV_CPU_FR405
:
2044 strcat (buf
, ", fr405");
2047 case EF_FRV_CPU_FR450
:
2048 strcat (buf
, ", fr450");
2051 case EF_FRV_CPU_FR500
:
2052 strcat (buf
, ", fr500");
2054 case EF_FRV_CPU_FR550
:
2055 strcat (buf
, ", fr550");
2058 case EF_FRV_CPU_SIMPLE
:
2059 strcat (buf
, ", simple");
2061 case EF_FRV_CPU_TOMCAT
:
2062 strcat (buf
, ", tomcat");
2068 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2069 strcat (buf
, ", m68000");
2070 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2071 strcat (buf
, ", cpu32");
2072 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2073 strcat (buf
, ", fido_a");
2076 char const *isa
= _("unknown");
2077 char const *mac
= _("unknown mac");
2078 char const *additional
= NULL
;
2080 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2082 case EF_M68K_CF_ISA_A_NODIV
:
2084 additional
= ", nodiv";
2086 case EF_M68K_CF_ISA_A
:
2089 case EF_M68K_CF_ISA_A_PLUS
:
2092 case EF_M68K_CF_ISA_B_NOUSP
:
2094 additional
= ", nousp";
2096 case EF_M68K_CF_ISA_B
:
2100 strcat (buf
, ", cf, isa ");
2103 strcat (buf
, additional
);
2104 if (e_flags
& EF_M68K_CF_FLOAT
)
2105 strcat (buf
, ", float");
2106 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2111 case EF_M68K_CF_MAC
:
2114 case EF_M68K_CF_EMAC
:
2127 if (e_flags
& EF_PPC_EMB
)
2128 strcat (buf
, ", emb");
2130 if (e_flags
& EF_PPC_RELOCATABLE
)
2131 strcat (buf
, ", relocatable");
2133 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2134 strcat (buf
, ", relocatable-lib");
2138 case EM_CYGNUS_V850
:
2139 switch (e_flags
& EF_V850_ARCH
)
2142 strcat (buf
, ", v850e1");
2145 strcat (buf
, ", v850e");
2148 strcat (buf
, ", v850");
2151 strcat (buf
, ", unknown v850 architecture variant");
2157 case EM_CYGNUS_M32R
:
2158 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2159 strcat (buf
, ", m32r");
2163 case EM_MIPS_RS3_LE
:
2164 if (e_flags
& EF_MIPS_NOREORDER
)
2165 strcat (buf
, ", noreorder");
2167 if (e_flags
& EF_MIPS_PIC
)
2168 strcat (buf
, ", pic");
2170 if (e_flags
& EF_MIPS_CPIC
)
2171 strcat (buf
, ", cpic");
2173 if (e_flags
& EF_MIPS_UCODE
)
2174 strcat (buf
, ", ugen_reserved");
2176 if (e_flags
& EF_MIPS_ABI2
)
2177 strcat (buf
, ", abi2");
2179 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2180 strcat (buf
, ", odk first");
2182 if (e_flags
& EF_MIPS_32BITMODE
)
2183 strcat (buf
, ", 32bitmode");
2185 switch ((e_flags
& EF_MIPS_MACH
))
2187 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2188 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2189 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2190 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2191 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2192 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2193 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2194 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2195 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2196 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2198 /* We simply ignore the field in this case to avoid confusion:
2199 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2202 default: strcat (buf
, ", unknown CPU"); break;
2205 switch ((e_flags
& EF_MIPS_ABI
))
2207 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2208 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2209 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2210 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2212 /* We simply ignore the field in this case to avoid confusion:
2213 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2214 This means it is likely to be an o32 file, but not for
2217 default: strcat (buf
, ", unknown ABI"); break;
2220 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2221 strcat (buf
, ", mdmx");
2223 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2224 strcat (buf
, ", mips16");
2226 switch ((e_flags
& EF_MIPS_ARCH
))
2228 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2229 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2230 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2231 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2232 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2233 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2234 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2235 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2236 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2237 default: strcat (buf
, ", unknown ISA"); break;
2243 switch ((e_flags
& EF_SH_MACH_MASK
))
2245 case EF_SH1
: strcat (buf
, ", sh1"); break;
2246 case EF_SH2
: strcat (buf
, ", sh2"); break;
2247 case EF_SH3
: strcat (buf
, ", sh3"); break;
2248 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2249 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2250 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2251 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2252 case EF_SH4
: strcat (buf
, ", sh4"); break;
2253 case EF_SH5
: strcat (buf
, ", sh5"); break;
2254 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2255 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2256 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2257 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2258 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2259 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2260 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2261 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2262 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2263 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2264 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2265 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2266 default: strcat (buf
, ", unknown ISA"); break;
2272 if (e_flags
& EF_SPARC_32PLUS
)
2273 strcat (buf
, ", v8+");
2275 if (e_flags
& EF_SPARC_SUN_US1
)
2276 strcat (buf
, ", ultrasparcI");
2278 if (e_flags
& EF_SPARC_SUN_US3
)
2279 strcat (buf
, ", ultrasparcIII");
2281 if (e_flags
& EF_SPARC_HAL_R1
)
2282 strcat (buf
, ", halr1");
2284 if (e_flags
& EF_SPARC_LEDATA
)
2285 strcat (buf
, ", ledata");
2287 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2288 strcat (buf
, ", tso");
2290 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2291 strcat (buf
, ", pso");
2293 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2294 strcat (buf
, ", rmo");
2298 switch (e_flags
& EF_PARISC_ARCH
)
2300 case EFA_PARISC_1_0
:
2301 strcpy (buf
, ", PA-RISC 1.0");
2303 case EFA_PARISC_1_1
:
2304 strcpy (buf
, ", PA-RISC 1.1");
2306 case EFA_PARISC_2_0
:
2307 strcpy (buf
, ", PA-RISC 2.0");
2312 if (e_flags
& EF_PARISC_TRAPNIL
)
2313 strcat (buf
, ", trapnil");
2314 if (e_flags
& EF_PARISC_EXT
)
2315 strcat (buf
, ", ext");
2316 if (e_flags
& EF_PARISC_LSB
)
2317 strcat (buf
, ", lsb");
2318 if (e_flags
& EF_PARISC_WIDE
)
2319 strcat (buf
, ", wide");
2320 if (e_flags
& EF_PARISC_NO_KABP
)
2321 strcat (buf
, ", no kabp");
2322 if (e_flags
& EF_PARISC_LAZYSWAP
)
2323 strcat (buf
, ", lazyswap");
2328 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2329 strcat (buf
, ", new calling convention");
2331 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2332 strcat (buf
, ", gnu calling convention");
2336 if ((e_flags
& EF_IA_64_ABI64
))
2337 strcat (buf
, ", 64-bit");
2339 strcat (buf
, ", 32-bit");
2340 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2341 strcat (buf
, ", reduced fp model");
2342 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2343 strcat (buf
, ", no function descriptors, constant gp");
2344 else if ((e_flags
& EF_IA_64_CONS_GP
))
2345 strcat (buf
, ", constant gp");
2346 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2347 strcat (buf
, ", absolute");
2351 if ((e_flags
& EF_VAX_NONPIC
))
2352 strcat (buf
, ", non-PIC");
2353 if ((e_flags
& EF_VAX_DFLOAT
))
2354 strcat (buf
, ", D-Float");
2355 if ((e_flags
& EF_VAX_GFLOAT
))
2356 strcat (buf
, ", G-Float");
2365 get_osabi_name (unsigned int osabi
)
2367 static char buff
[32];
2371 case ELFOSABI_NONE
: return "UNIX - System V";
2372 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2373 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2374 case ELFOSABI_LINUX
: return "UNIX - Linux";
2375 case ELFOSABI_HURD
: return "GNU/Hurd";
2376 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2377 case ELFOSABI_AIX
: return "UNIX - AIX";
2378 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2379 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2380 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2381 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2382 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2383 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2384 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2385 case ELFOSABI_AROS
: return "Amiga Research OS";
2386 case ELFOSABI_STANDALONE
: return _("Standalone App");
2387 case ELFOSABI_ARM
: return "ARM";
2389 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2395 get_arm_segment_type (unsigned long type
)
2409 get_mips_segment_type (unsigned long type
)
2413 case PT_MIPS_REGINFO
:
2415 case PT_MIPS_RTPROC
:
2417 case PT_MIPS_OPTIONS
:
2427 get_parisc_segment_type (unsigned long type
)
2431 case PT_HP_TLS
: return "HP_TLS";
2432 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2433 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2434 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2435 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2436 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2437 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2438 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2439 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2440 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2441 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2442 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2443 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2444 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2445 case PT_HP_STACK
: return "HP_STACK";
2446 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2447 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2448 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2449 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2458 get_ia64_segment_type (unsigned long type
)
2462 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2463 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2464 case PT_HP_TLS
: return "HP_TLS";
2465 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2466 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2467 case PT_IA_64_HP_STACK
: return "HP_STACK";
2476 get_segment_type (unsigned long p_type
)
2478 static char buff
[32];
2482 case PT_NULL
: return "NULL";
2483 case PT_LOAD
: return "LOAD";
2484 case PT_DYNAMIC
: return "DYNAMIC";
2485 case PT_INTERP
: return "INTERP";
2486 case PT_NOTE
: return "NOTE";
2487 case PT_SHLIB
: return "SHLIB";
2488 case PT_PHDR
: return "PHDR";
2489 case PT_TLS
: return "TLS";
2491 case PT_GNU_EH_FRAME
:
2492 return "GNU_EH_FRAME";
2493 case PT_GNU_STACK
: return "GNU_STACK";
2494 case PT_GNU_RELRO
: return "GNU_RELRO";
2497 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2501 switch (elf_header
.e_machine
)
2504 result
= get_arm_segment_type (p_type
);
2507 case EM_MIPS_RS3_LE
:
2508 result
= get_mips_segment_type (p_type
);
2511 result
= get_parisc_segment_type (p_type
);
2514 result
= get_ia64_segment_type (p_type
);
2524 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2526 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2530 switch (elf_header
.e_machine
)
2533 result
= get_parisc_segment_type (p_type
);
2536 result
= get_ia64_segment_type (p_type
);
2546 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2549 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2556 get_mips_section_type_name (unsigned int sh_type
)
2560 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2561 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2562 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2563 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2564 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2565 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2566 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2567 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2568 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2569 case SHT_MIPS_RELD
: return "MIPS_RELD";
2570 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2571 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2572 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2573 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2574 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2575 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2576 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2577 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2578 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2579 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2580 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2581 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2582 case SHT_MIPS_LINE
: return "MIPS_LINE";
2583 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2584 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2585 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2586 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2587 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2588 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2589 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2590 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2591 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2592 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2593 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2594 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2595 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2596 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2597 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2598 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2606 get_parisc_section_type_name (unsigned int sh_type
)
2610 case SHT_PARISC_EXT
: return "PARISC_EXT";
2611 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2612 case SHT_PARISC_DOC
: return "PARISC_DOC";
2613 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2614 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2615 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2616 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2624 get_ia64_section_type_name (unsigned int sh_type
)
2626 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2627 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2628 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2632 case SHT_IA_64_EXT
: return "IA_64_EXT";
2633 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2634 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2642 get_x86_64_section_type_name (unsigned int sh_type
)
2646 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2654 get_arm_section_type_name (unsigned int sh_type
)
2660 case SHT_ARM_PREEMPTMAP
:
2661 return "ARM_PREEMPTMAP";
2662 case SHT_ARM_ATTRIBUTES
:
2663 return "ARM_ATTRIBUTES";
2671 get_section_type_name (unsigned int sh_type
)
2673 static char buff
[32];
2677 case SHT_NULL
: return "NULL";
2678 case SHT_PROGBITS
: return "PROGBITS";
2679 case SHT_SYMTAB
: return "SYMTAB";
2680 case SHT_STRTAB
: return "STRTAB";
2681 case SHT_RELA
: return "RELA";
2682 case SHT_HASH
: return "HASH";
2683 case SHT_DYNAMIC
: return "DYNAMIC";
2684 case SHT_NOTE
: return "NOTE";
2685 case SHT_NOBITS
: return "NOBITS";
2686 case SHT_REL
: return "REL";
2687 case SHT_SHLIB
: return "SHLIB";
2688 case SHT_DYNSYM
: return "DYNSYM";
2689 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
2690 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
2691 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2692 case SHT_GNU_HASH
: return "GNU_HASH";
2693 case SHT_GROUP
: return "GROUP";
2694 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
2695 case SHT_GNU_verdef
: return "VERDEF";
2696 case SHT_GNU_verneed
: return "VERNEED";
2697 case SHT_GNU_versym
: return "VERSYM";
2698 case 0x6ffffff0: return "VERSYM";
2699 case 0x6ffffffc: return "VERDEF";
2700 case 0x7ffffffd: return "AUXILIARY";
2701 case 0x7fffffff: return "FILTER";
2702 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
2705 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
2709 switch (elf_header
.e_machine
)
2712 case EM_MIPS_RS3_LE
:
2713 result
= get_mips_section_type_name (sh_type
);
2716 result
= get_parisc_section_type_name (sh_type
);
2719 result
= get_ia64_section_type_name (sh_type
);
2722 result
= get_x86_64_section_type_name (sh_type
);
2725 result
= get_arm_section_type_name (sh_type
);
2735 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2737 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2738 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2739 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2740 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2742 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
2748 #define OPTION_DEBUG_DUMP 512
2750 static struct option options
[] =
2752 {"all", no_argument
, 0, 'a'},
2753 {"file-header", no_argument
, 0, 'h'},
2754 {"program-headers", no_argument
, 0, 'l'},
2755 {"headers", no_argument
, 0, 'e'},
2756 {"histogram", no_argument
, 0, 'I'},
2757 {"segments", no_argument
, 0, 'l'},
2758 {"sections", no_argument
, 0, 'S'},
2759 {"section-headers", no_argument
, 0, 'S'},
2760 {"section-groups", no_argument
, 0, 'g'},
2761 {"section-details", no_argument
, 0, 't'},
2762 {"full-section-name",no_argument
, 0, 'N'},
2763 {"symbols", no_argument
, 0, 's'},
2764 {"syms", no_argument
, 0, 's'},
2765 {"relocs", no_argument
, 0, 'r'},
2766 {"notes", no_argument
, 0, 'n'},
2767 {"dynamic", no_argument
, 0, 'd'},
2768 {"arch-specific", no_argument
, 0, 'A'},
2769 {"version-info", no_argument
, 0, 'V'},
2770 {"use-dynamic", no_argument
, 0, 'D'},
2771 {"unwind", no_argument
, 0, 'u'},
2772 {"archive-index", no_argument
, 0, 'c'},
2773 {"hex-dump", required_argument
, 0, 'x'},
2774 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
2775 {"string-dump", required_argument
, 0, 'p'},
2776 #ifdef SUPPORT_DISASSEMBLY
2777 {"instruction-dump", required_argument
, 0, 'i'},
2780 {"version", no_argument
, 0, 'v'},
2781 {"wide", no_argument
, 0, 'W'},
2782 {"help", no_argument
, 0, 'H'},
2783 {0, no_argument
, 0, 0}
2787 usage (FILE *stream
)
2789 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
2790 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
2791 fprintf (stream
, _(" Options are:\n\
2792 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2793 -h --file-header Display the ELF file header\n\
2794 -l --program-headers Display the program headers\n\
2795 --segments An alias for --program-headers\n\
2796 -S --section-headers Display the sections' header\n\
2797 --sections An alias for --section-headers\n\
2798 -g --section-groups Display the section groups\n\
2799 -t --section-details Display the section details\n\
2800 -e --headers Equivalent to: -h -l -S\n\
2801 -s --syms Display the symbol table\n\
2802 --symbols An alias for --syms\n\
2803 -n --notes Display the core notes (if present)\n\
2804 -r --relocs Display the relocations (if present)\n\
2805 -u --unwind Display the unwind info (if present)\n\
2806 -d --dynamic Display the dynamic section (if present)\n\
2807 -V --version-info Display the version sections (if present)\n\
2808 -A --arch-specific Display architecture specific information (if any).\n\
2809 -c --archive-index Display the symbol/file index in an archive\n\
2810 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2811 -x --hex-dump=<number|name>\n\
2812 Dump the contents of section <number|name> as bytes\n\
2813 -p --string-dump=<number|name>\n\
2814 Dump the contents of section <number|name> as strings\n\
2815 -w[liaprmfFsoR] or\n\
2816 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2817 Display the contents of DWARF2 debug sections\n"));
2818 #ifdef SUPPORT_DISASSEMBLY
2819 fprintf (stream
, _("\
2820 -i --instruction-dump=<number|name>\n\
2821 Disassemble the contents of section <number|name>\n"));
2823 fprintf (stream
, _("\
2824 -I --histogram Display histogram of bucket list lengths\n\
2825 -W --wide Allow output width to exceed 80 characters\n\
2826 @<file> Read options from <file>\n\
2827 -H --help Display this information\n\
2828 -v --version Display the version number of readelf\n"));
2830 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
2831 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2833 exit (stream
== stdout
? 0 : 1);
2836 /* Record the fact that the user wants the contents of section number
2837 SECTION to be displayed using the method(s) encoded as flags bits
2838 in TYPE. Note, TYPE can be zero if we are creating the array for
2842 request_dump_bynumber (unsigned int section
, dump_type type
)
2844 if (section
>= num_dump_sects
)
2846 dump_type
*new_dump_sects
;
2848 new_dump_sects
= calloc (section
+ 1, sizeof (* dump_sects
));
2850 if (new_dump_sects
== NULL
)
2851 error (_("Out of memory allocating dump request table.\n"));
2854 /* Copy current flag settings. */
2855 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
2859 dump_sects
= new_dump_sects
;
2860 num_dump_sects
= section
+ 1;
2865 dump_sects
[section
] |= type
;
2870 /* Request a dump by section name. */
2873 request_dump_byname (const char *section
, dump_type type
)
2875 struct dump_list_entry
*new_request
;
2877 new_request
= malloc (sizeof (struct dump_list_entry
));
2879 error (_("Out of memory allocating dump request table.\n"));
2881 new_request
->name
= strdup (section
);
2882 if (!new_request
->name
)
2883 error (_("Out of memory allocating dump request table.\n"));
2885 new_request
->type
= type
;
2887 new_request
->next
= dump_sects_byname
;
2888 dump_sects_byname
= new_request
;
2892 parse_args (int argc
, char **argv
)
2899 while ((c
= getopt_long
2900 (argc
, argv
, "ADHINSVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
2921 do_section_groups
++;
2929 do_section_groups
++;
2934 do_section_details
++;
2979 section
= strtoul (optarg
, & cp
, 0);
2980 if (! *cp
&& section
>= 0)
2981 request_dump_bynumber (section
, HEX_DUMP
);
2983 request_dump_byname (optarg
, HEX_DUMP
);
2987 section
= strtoul (optarg
, & cp
, 0);
2988 if (! *cp
&& section
>= 0)
2989 request_dump_bynumber (section
, STRING_DUMP
);
2991 request_dump_byname (optarg
, STRING_DUMP
);
2999 unsigned int index
= 0;
3003 while (optarg
[index
])
3004 switch (optarg
[index
++])
3013 do_debug_abbrevs
= 1;
3023 do_debug_pubnames
= 1;
3027 do_debug_aranges
= 1;
3031 do_debug_ranges
= 1;
3035 do_debug_frames_interp
= 1;
3037 do_debug_frames
= 1;
3042 do_debug_macinfo
= 1;
3056 warn (_("Unrecognized debug option '%s'\n"), optarg
);
3061 case OPTION_DEBUG_DUMP
:
3069 const char * option
;
3072 debug_dump_long_opts
;
3074 debug_dump_long_opts opts_table
[] =
3076 /* Please keep this table alpha- sorted. */
3077 { "Ranges", & do_debug_ranges
},
3078 { "abbrev", & do_debug_abbrevs
},
3079 { "aranges", & do_debug_aranges
},
3080 { "frames", & do_debug_frames
},
3081 { "frames-interp", & do_debug_frames_interp
},
3082 { "info", & do_debug_info
},
3083 { "line", & do_debug_lines
},
3084 { "loc", & do_debug_loc
},
3085 { "macro", & do_debug_macinfo
},
3086 { "pubnames", & do_debug_pubnames
},
3087 /* This entry is for compatability
3088 with earlier versions of readelf. */
3089 { "ranges", & do_debug_aranges
},
3090 { "str", & do_debug_str
},
3101 debug_dump_long_opts
* entry
;
3103 for (entry
= opts_table
; entry
->option
; entry
++)
3105 size_t len
= strlen (entry
->option
);
3107 if (strneq (p
, entry
->option
, len
)
3108 && (p
[len
] == ',' || p
[len
] == '\0'))
3110 * entry
->variable
= 1;
3112 /* The --debug-dump=frames-interp option also
3113 enables the --debug-dump=frames option. */
3114 if (do_debug_frames_interp
)
3115 do_debug_frames
= 1;
3122 if (entry
->option
== NULL
)
3124 warn (_("Unrecognized debug option '%s'\n"), p
);
3125 p
= strchr (p
, ',');
3135 #ifdef SUPPORT_DISASSEMBLY
3138 section
= strtoul (optarg
, & cp
, 0);
3139 if (! *cp
&& section
>= 0)
3140 request_dump_bynumber (section
, DISASS_DUMP
);
3142 request_dump_byname (optarg
, DISASS_DUMP
);
3145 print_version (program_name
);
3154 /* xgettext:c-format */
3155 error (_("Invalid option '-%c'\n"), c
);
3162 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3163 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3164 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3165 && !do_section_groups
&& !do_archive_index
)
3169 warn (_("Nothing to do.\n"));
3175 get_elf_class (unsigned int elf_class
)
3177 static char buff
[32];
3181 case ELFCLASSNONE
: return _("none");
3182 case ELFCLASS32
: return "ELF32";
3183 case ELFCLASS64
: return "ELF64";
3185 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3191 get_data_encoding (unsigned int encoding
)
3193 static char buff
[32];
3197 case ELFDATANONE
: return _("none");
3198 case ELFDATA2LSB
: return _("2's complement, little endian");
3199 case ELFDATA2MSB
: return _("2's complement, big endian");
3201 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3206 /* Decode the data held in 'elf_header'. */
3209 process_file_header (void)
3211 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3212 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3213 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3214 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3217 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3225 printf (_("ELF Header:\n"));
3226 printf (_(" Magic: "));
3227 for (i
= 0; i
< EI_NIDENT
; i
++)
3228 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3230 printf (_(" Class: %s\n"),
3231 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3232 printf (_(" Data: %s\n"),
3233 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3234 printf (_(" Version: %d %s\n"),
3235 elf_header
.e_ident
[EI_VERSION
],
3236 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3238 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3241 printf (_(" OS/ABI: %s\n"),
3242 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3243 printf (_(" ABI Version: %d\n"),
3244 elf_header
.e_ident
[EI_ABIVERSION
]);
3245 printf (_(" Type: %s\n"),
3246 get_file_type (elf_header
.e_type
));
3247 printf (_(" Machine: %s\n"),
3248 get_machine_name (elf_header
.e_machine
));
3249 printf (_(" Version: 0x%lx\n"),
3250 (unsigned long) elf_header
.e_version
);
3252 printf (_(" Entry point address: "));
3253 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3254 printf (_("\n Start of program headers: "));
3255 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3256 printf (_(" (bytes into file)\n Start of section headers: "));
3257 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3258 printf (_(" (bytes into file)\n"));
3260 printf (_(" Flags: 0x%lx%s\n"),
3261 (unsigned long) elf_header
.e_flags
,
3262 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3263 printf (_(" Size of this header: %ld (bytes)\n"),
3264 (long) elf_header
.e_ehsize
);
3265 printf (_(" Size of program headers: %ld (bytes)\n"),
3266 (long) elf_header
.e_phentsize
);
3267 printf (_(" Number of program headers: %ld\n"),
3268 (long) elf_header
.e_phnum
);
3269 printf (_(" Size of section headers: %ld (bytes)\n"),
3270 (long) elf_header
.e_shentsize
);
3271 printf (_(" Number of section headers: %ld"),
3272 (long) elf_header
.e_shnum
);
3273 if (section_headers
!= NULL
&& elf_header
.e_shnum
== 0)
3274 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3275 putc ('\n', stdout
);
3276 printf (_(" Section header string table index: %ld"),
3277 (long) elf_header
.e_shstrndx
);
3278 if (section_headers
!= NULL
&& elf_header
.e_shstrndx
== SHN_XINDEX
)
3279 printf (" (%ld)", (long) section_headers
[0].sh_link
);
3280 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3281 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3282 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3283 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3284 printf (" <corrupt: out of range>");
3285 putc ('\n', stdout
);
3288 if (section_headers
!= NULL
)
3290 if (elf_header
.e_shnum
== 0)
3291 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3292 if (elf_header
.e_shstrndx
== SHN_XINDEX
)
3293 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3294 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3295 && (elf_header
.e_shstrndx
>= elf_header
.e_shnum
3296 || (elf_header
.e_shstrndx
>= SHN_LORESERVE
3297 && elf_header
.e_shstrndx
<= SHN_HIRESERVE
)))
3298 elf_header
.e_shstrndx
= SHN_UNDEF
;
3299 free (section_headers
);
3300 section_headers
= NULL
;
3308 get_32bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3310 Elf32_External_Phdr
*phdrs
;
3311 Elf32_External_Phdr
*external
;
3312 Elf_Internal_Phdr
*internal
;
3315 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3316 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3317 _("program headers"));
3321 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3322 i
< elf_header
.e_phnum
;
3323 i
++, internal
++, external
++)
3325 internal
->p_type
= BYTE_GET (external
->p_type
);
3326 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3327 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3328 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3329 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3330 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3331 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3332 internal
->p_align
= BYTE_GET (external
->p_align
);
3341 get_64bit_program_headers (FILE *file
, Elf_Internal_Phdr
*program_headers
)
3343 Elf64_External_Phdr
*phdrs
;
3344 Elf64_External_Phdr
*external
;
3345 Elf_Internal_Phdr
*internal
;
3348 phdrs
= get_data (NULL
, file
, elf_header
.e_phoff
,
3349 elf_header
.e_phentsize
, elf_header
.e_phnum
,
3350 _("program headers"));
3354 for (i
= 0, internal
= program_headers
, external
= phdrs
;
3355 i
< elf_header
.e_phnum
;
3356 i
++, internal
++, external
++)
3358 internal
->p_type
= BYTE_GET (external
->p_type
);
3359 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3360 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3361 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3362 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3363 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3364 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3365 internal
->p_align
= BYTE_GET (external
->p_align
);
3373 /* Returns 1 if the program headers were read into `program_headers'. */
3376 get_program_headers (FILE *file
)
3378 Elf_Internal_Phdr
*phdrs
;
3380 /* Check cache of prior read. */
3381 if (program_headers
!= NULL
)
3384 phdrs
= cmalloc (elf_header
.e_phnum
, sizeof (Elf_Internal_Phdr
));
3388 error (_("Out of memory\n"));
3393 ? get_32bit_program_headers (file
, phdrs
)
3394 : get_64bit_program_headers (file
, phdrs
))
3396 program_headers
= phdrs
;
3404 /* Returns 1 if the program headers were loaded. */
3407 process_program_headers (FILE *file
)
3409 Elf_Internal_Phdr
*segment
;
3412 if (elf_header
.e_phnum
== 0)
3415 printf (_("\nThere are no program headers in this file.\n"));
3419 if (do_segments
&& !do_header
)
3421 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3422 printf (_("Entry point "));
3423 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3424 printf (_("\nThere are %d program headers, starting at offset "),
3425 elf_header
.e_phnum
);
3426 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3430 if (! get_program_headers (file
))
3435 if (elf_header
.e_phnum
> 1)
3436 printf (_("\nProgram Headers:\n"));
3438 printf (_("\nProgram Headers:\n"));
3442 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3445 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3449 (_(" Type Offset VirtAddr PhysAddr\n"));
3451 (_(" FileSiz MemSiz Flags Align\n"));
3458 for (i
= 0, segment
= program_headers
;
3459 i
< elf_header
.e_phnum
;
3464 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3468 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3469 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3470 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3471 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3472 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3474 (segment
->p_flags
& PF_R
? 'R' : ' '),
3475 (segment
->p_flags
& PF_W
? 'W' : ' '),
3476 (segment
->p_flags
& PF_X
? 'E' : ' '));
3477 printf ("%#lx", (unsigned long) segment
->p_align
);
3481 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3482 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3485 print_vma (segment
->p_offset
, FULL_HEX
);
3489 print_vma (segment
->p_vaddr
, FULL_HEX
);
3491 print_vma (segment
->p_paddr
, FULL_HEX
);
3494 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3495 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3498 print_vma (segment
->p_filesz
, FULL_HEX
);
3502 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3503 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3506 print_vma (segment
->p_offset
, FULL_HEX
);
3510 (segment
->p_flags
& PF_R
? 'R' : ' '),
3511 (segment
->p_flags
& PF_W
? 'W' : ' '),
3512 (segment
->p_flags
& PF_X
? 'E' : ' '));
3514 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3515 printf ("%#lx", (unsigned long) segment
->p_align
);
3518 print_vma (segment
->p_align
, PREFIX_HEX
);
3523 print_vma (segment
->p_offset
, FULL_HEX
);
3525 print_vma (segment
->p_vaddr
, FULL_HEX
);
3527 print_vma (segment
->p_paddr
, FULL_HEX
);
3529 print_vma (segment
->p_filesz
, FULL_HEX
);
3531 print_vma (segment
->p_memsz
, FULL_HEX
);
3533 (segment
->p_flags
& PF_R
? 'R' : ' '),
3534 (segment
->p_flags
& PF_W
? 'W' : ' '),
3535 (segment
->p_flags
& PF_X
? 'E' : ' '));
3536 print_vma (segment
->p_align
, HEX
);
3540 switch (segment
->p_type
)
3544 error (_("more than one dynamic segment\n"));
3546 /* By default, assume that the .dynamic section is the first
3547 section in the DYNAMIC segment. */
3548 dynamic_addr
= segment
->p_offset
;
3549 dynamic_size
= segment
->p_filesz
;
3551 /* Try to locate the .dynamic section. If there is
3552 a section header table, we can easily locate it. */
3553 if (section_headers
!= NULL
)
3555 Elf_Internal_Shdr
*sec
;
3557 sec
= find_section (".dynamic");
3558 if (sec
== NULL
|| sec
->sh_size
== 0)
3560 error (_("no .dynamic section in the dynamic segment\n"));
3564 if (sec
->sh_type
== SHT_NOBITS
)
3570 dynamic_addr
= sec
->sh_offset
;
3571 dynamic_size
= sec
->sh_size
;
3573 if (dynamic_addr
< segment
->p_offset
3574 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3575 warn (_("the .dynamic section is not contained"
3576 " within the dynamic segment\n"));
3577 else if (dynamic_addr
> segment
->p_offset
)
3578 warn (_("the .dynamic section is not the first section"
3579 " in the dynamic segment.\n"));
3584 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3586 error (_("Unable to find program interpreter name\n"));
3590 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3592 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3593 error (_("Internal error: failed to create format string to display program interpreter\n"));
3595 program_interpreter
[0] = 0;
3596 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3597 error (_("Unable to read program interpreter name\n"));
3600 printf (_("\n [Requesting program interpreter: %s]"),
3601 program_interpreter
);
3607 putc ('\n', stdout
);
3610 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3612 printf (_("\n Section to Segment mapping:\n"));
3613 printf (_(" Segment Sections...\n"));
3615 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3618 Elf_Internal_Shdr
*section
;
3620 segment
= program_headers
+ i
;
3621 section
= section_headers
;
3623 printf (" %2.2d ", i
);
3625 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3627 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section
, segment
))
3628 printf ("%s ", SECTION_NAME (section
));
3639 /* Find the file offset corresponding to VMA by using the program headers. */
3642 offset_from_vma (FILE *file
, bfd_vma vma
, bfd_size_type size
)
3644 Elf_Internal_Phdr
*seg
;
3646 if (! get_program_headers (file
))
3648 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3652 for (seg
= program_headers
;
3653 seg
< program_headers
+ elf_header
.e_phnum
;
3656 if (seg
->p_type
!= PT_LOAD
)
3659 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3660 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3661 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3664 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3671 get_32bit_section_headers (FILE *file
, unsigned int num
)
3673 Elf32_External_Shdr
*shdrs
;
3674 Elf_Internal_Shdr
*internal
;
3677 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3678 elf_header
.e_shentsize
, num
, _("section headers"));
3682 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3684 if (section_headers
== NULL
)
3686 error (_("Out of memory\n"));
3690 for (i
= 0, internal
= section_headers
;
3694 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3695 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3696 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3697 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3698 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3699 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3700 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3701 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3702 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3703 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3712 get_64bit_section_headers (FILE *file
, unsigned int num
)
3714 Elf64_External_Shdr
*shdrs
;
3715 Elf_Internal_Shdr
*internal
;
3718 shdrs
= get_data (NULL
, file
, elf_header
.e_shoff
,
3719 elf_header
.e_shentsize
, num
, _("section headers"));
3723 section_headers
= cmalloc (num
, sizeof (Elf_Internal_Shdr
));
3725 if (section_headers
== NULL
)
3727 error (_("Out of memory\n"));
3731 for (i
= 0, internal
= section_headers
;
3735 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3736 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3737 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3738 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3739 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3740 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3741 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3742 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3743 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3744 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3752 static Elf_Internal_Sym
*
3753 get_32bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3755 unsigned long number
;
3756 Elf32_External_Sym
*esyms
;
3757 Elf_External_Sym_Shndx
*shndx
;
3758 Elf_Internal_Sym
*isyms
;
3759 Elf_Internal_Sym
*psym
;
3762 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3768 if (symtab_shndx_hdr
!= NULL
3769 && (symtab_shndx_hdr
->sh_link
3770 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3772 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3773 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3781 number
= section
->sh_size
/ section
->sh_entsize
;
3782 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3786 error (_("Out of memory\n"));
3793 for (j
= 0, psym
= isyms
;
3797 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3798 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3799 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3800 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3801 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3803 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3804 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3805 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3815 static Elf_Internal_Sym
*
3816 get_64bit_elf_symbols (FILE *file
, Elf_Internal_Shdr
*section
)
3818 unsigned long number
;
3819 Elf64_External_Sym
*esyms
;
3820 Elf_External_Sym_Shndx
*shndx
;
3821 Elf_Internal_Sym
*isyms
;
3822 Elf_Internal_Sym
*psym
;
3825 esyms
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
3831 if (symtab_shndx_hdr
!= NULL
3832 && (symtab_shndx_hdr
->sh_link
3833 == (unsigned long) SECTION_HEADER_NUM (section
- section_headers
)))
3835 shndx
= get_data (NULL
, file
, symtab_shndx_hdr
->sh_offset
,
3836 1, symtab_shndx_hdr
->sh_size
, _("symtab shndx"));
3844 number
= section
->sh_size
/ section
->sh_entsize
;
3845 isyms
= cmalloc (number
, sizeof (Elf_Internal_Sym
));
3849 error (_("Out of memory\n"));
3856 for (j
= 0, psym
= isyms
;
3860 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
3861 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
3862 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
3863 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
3864 if (psym
->st_shndx
== SHN_XINDEX
&& shndx
!= NULL
)
3866 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
3867 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
3868 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
3879 get_elf_section_flags (bfd_vma sh_flags
)
3881 static char buff
[1024];
3883 int field_size
= is_32bit_elf
? 8 : 16;
3884 int index
, size
= sizeof (buff
) - (field_size
+ 4 + 1);
3885 bfd_vma os_flags
= 0;
3886 bfd_vma proc_flags
= 0;
3887 bfd_vma unknown_flags
= 0;
3901 { "LINK ORDER", 10 },
3902 { "OS NONCONF", 10 },
3907 if (do_section_details
)
3909 sprintf (buff
, "[%*.*lx]: ",
3910 field_size
, field_size
, (unsigned long) sh_flags
);
3911 p
+= field_size
+ 4;
3918 flag
= sh_flags
& - sh_flags
;
3921 if (do_section_details
)
3925 case SHF_WRITE
: index
= 0; break;
3926 case SHF_ALLOC
: index
= 1; break;
3927 case SHF_EXECINSTR
: index
= 2; break;
3928 case SHF_MERGE
: index
= 3; break;
3929 case SHF_STRINGS
: index
= 4; break;
3930 case SHF_INFO_LINK
: index
= 5; break;
3931 case SHF_LINK_ORDER
: index
= 6; break;
3932 case SHF_OS_NONCONFORMING
: index
= 7; break;
3933 case SHF_GROUP
: index
= 8; break;
3934 case SHF_TLS
: index
= 9; break;
3943 if (p
!= buff
+ field_size
+ 4)
3945 if (size
< (10 + 2))
3952 size
-= flags
[index
].len
;
3953 p
= stpcpy (p
, flags
[index
].str
);
3955 else if (flag
& SHF_MASKOS
)
3957 else if (flag
& SHF_MASKPROC
)
3960 unknown_flags
|= flag
;
3966 case SHF_WRITE
: *p
= 'W'; break;
3967 case SHF_ALLOC
: *p
= 'A'; break;
3968 case SHF_EXECINSTR
: *p
= 'X'; break;
3969 case SHF_MERGE
: *p
= 'M'; break;
3970 case SHF_STRINGS
: *p
= 'S'; break;
3971 case SHF_INFO_LINK
: *p
= 'I'; break;
3972 case SHF_LINK_ORDER
: *p
= 'L'; break;
3973 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
3974 case SHF_GROUP
: *p
= 'G'; break;
3975 case SHF_TLS
: *p
= 'T'; break;
3978 if (elf_header
.e_machine
== EM_X86_64
3979 && flag
== SHF_X86_64_LARGE
)
3981 else if (flag
& SHF_MASKOS
)
3984 sh_flags
&= ~ SHF_MASKOS
;
3986 else if (flag
& SHF_MASKPROC
)
3989 sh_flags
&= ~ SHF_MASKPROC
;
3999 if (do_section_details
)
4003 size
-= 5 + field_size
;
4004 if (p
!= buff
+ field_size
+ 4)
4012 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4013 (unsigned long) os_flags
);
4014 p
+= 5 + field_size
;
4018 size
-= 7 + field_size
;
4019 if (p
!= buff
+ field_size
+ 4)
4027 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4028 (unsigned long) proc_flags
);
4029 p
+= 7 + field_size
;
4033 size
-= 10 + field_size
;
4034 if (p
!= buff
+ field_size
+ 4)
4042 sprintf (p
, "UNKNOWN (%*.*lx)", field_size
, field_size
,
4043 (unsigned long) unknown_flags
);
4044 p
+= 10 + field_size
;
4053 process_section_headers (FILE *file
)
4055 Elf_Internal_Shdr
*section
;
4058 section_headers
= NULL
;
4060 if (elf_header
.e_shnum
== 0)
4063 printf (_("\nThere are no sections in this file.\n"));
4068 if (do_sections
&& !do_header
)
4069 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4070 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4074 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4077 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4080 /* Read in the string table, so that we have names to display. */
4081 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4082 && SECTION_HEADER_INDEX (elf_header
.e_shstrndx
) < elf_header
.e_shnum
)
4084 section
= SECTION_HEADER (elf_header
.e_shstrndx
);
4086 if (section
->sh_size
!= 0)
4088 string_table
= get_data (NULL
, file
, section
->sh_offset
,
4089 1, section
->sh_size
, _("string table"));
4091 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4095 /* Scan the sections for the dynamic symbol table
4096 and dynamic string table and debug sections. */
4097 dynamic_symbols
= NULL
;
4098 dynamic_strings
= NULL
;
4099 dynamic_syminfo
= NULL
;
4100 symtab_shndx_hdr
= NULL
;
4102 eh_addr_size
= is_32bit_elf
? 4 : 8;
4103 switch (elf_header
.e_machine
)
4106 case EM_MIPS_RS3_LE
:
4107 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4108 FDE addresses. However, the ABI also has a semi-official ILP32
4109 variant for which the normal FDE address size rules apply.
4111 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4112 section, where XX is the size of longs in bits. Unfortunately,
4113 earlier compilers provided no way of distinguishing ILP32 objects
4114 from LP64 objects, so if there's any doubt, we should assume that
4115 the official LP64 form is being used. */
4116 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4117 && find_section (".gcc_compiled_long32") == NULL
)
4123 switch (elf_header
.e_flags
& EF_H8_MACH
)
4125 case E_H8_MACH_H8300
:
4126 case E_H8_MACH_H8300HN
:
4127 case E_H8_MACH_H8300SN
:
4128 case E_H8_MACH_H8300SXN
:
4131 case E_H8_MACH_H8300H
:
4132 case E_H8_MACH_H8300S
:
4133 case E_H8_MACH_H8300SX
:
4139 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4142 size_t expected_entsize \
4143 = is_32bit_elf ? size32 : size64; \
4144 if (section->sh_entsize != expected_entsize) \
4145 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4146 i, (unsigned long int) section->sh_entsize, \
4147 (unsigned long int) expected_entsize); \
4148 section->sh_entsize = expected_entsize; \
4151 #define CHECK_ENTSIZE(section, i, type) \
4152 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4153 sizeof (Elf64_External_##type))
4155 for (i
= 0, section
= section_headers
;
4156 i
< elf_header
.e_shnum
;
4159 char *name
= SECTION_NAME (section
);
4161 if (section
->sh_type
== SHT_DYNSYM
)
4163 if (dynamic_symbols
!= NULL
)
4165 error (_("File contains multiple dynamic symbol tables\n"));
4169 CHECK_ENTSIZE (section
, i
, Sym
);
4170 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4171 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4173 else if (section
->sh_type
== SHT_STRTAB
4174 && streq (name
, ".dynstr"))
4176 if (dynamic_strings
!= NULL
)
4178 error (_("File contains multiple dynamic string tables\n"));
4182 dynamic_strings
= get_data (NULL
, file
, section
->sh_offset
,
4183 1, section
->sh_size
, _("dynamic strings"));
4184 dynamic_strings_length
= section
->sh_size
;
4186 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4188 if (symtab_shndx_hdr
!= NULL
)
4190 error (_("File contains multiple symtab shndx tables\n"));
4193 symtab_shndx_hdr
= section
;
4195 else if (section
->sh_type
== SHT_SYMTAB
)
4196 CHECK_ENTSIZE (section
, i
, Sym
);
4197 else if (section
->sh_type
== SHT_GROUP
)
4198 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4199 else if (section
->sh_type
== SHT_REL
)
4200 CHECK_ENTSIZE (section
, i
, Rel
);
4201 else if (section
->sh_type
== SHT_RELA
)
4202 CHECK_ENTSIZE (section
, i
, Rela
);
4203 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4204 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
4205 || do_debug_frames
|| do_debug_macinfo
|| do_debug_str
4206 || do_debug_loc
|| do_debug_ranges
)
4207 && const_strneq (name
, ".debug_"))
4212 || (do_debug_info
&& streq (name
, "info"))
4213 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4214 || (do_debug_lines
&& streq (name
, "line"))
4215 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4216 || (do_debug_aranges
&& streq (name
, "aranges"))
4217 || (do_debug_ranges
&& streq (name
, "ranges"))
4218 || (do_debug_frames
&& streq (name
, "frame"))
4219 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4220 || (do_debug_str
&& streq (name
, "str"))
4221 || (do_debug_loc
&& streq (name
, "loc"))
4223 request_dump_bynumber (i
, DEBUG_DUMP
);
4225 /* linkonce section to be combined with .debug_info at link time. */
4226 else if ((do_debugging
|| do_debug_info
)
4227 && const_strneq (name
, ".gnu.linkonce.wi."))
4228 request_dump_bynumber (i
, DEBUG_DUMP
);
4229 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4230 request_dump_bynumber (i
, DEBUG_DUMP
);
4236 if (elf_header
.e_shnum
> 1)
4237 printf (_("\nSection Headers:\n"));
4239 printf (_("\nSection Header:\n"));
4243 if (do_section_details
)
4245 printf (_(" [Nr] Name\n"));
4246 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4250 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4254 if (do_section_details
)
4256 printf (_(" [Nr] Name\n"));
4257 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4261 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4265 if (do_section_details
)
4267 printf (_(" [Nr] Name\n"));
4268 printf (_(" Type Address Offset Link\n"));
4269 printf (_(" Size EntSize Info Align\n"));
4273 printf (_(" [Nr] Name Type Address Offset\n"));
4274 printf (_(" Size EntSize Flags Link Info Align\n"));
4278 if (do_section_details
)
4279 printf (_(" Flags\n"));
4281 for (i
= 0, section
= section_headers
;
4282 i
< elf_header
.e_shnum
;
4285 if (do_section_details
)
4287 printf (" [%2u] %s\n",
4288 SECTION_HEADER_NUM (i
),
4289 SECTION_NAME (section
));
4290 if (is_32bit_elf
|| do_wide
)
4291 printf (" %-15.15s ",
4292 get_section_type_name (section
->sh_type
));
4295 printf (" [%2u] %-17.17s %-15.15s ",
4296 SECTION_HEADER_NUM (i
),
4297 SECTION_NAME (section
),
4298 get_section_type_name (section
->sh_type
));
4302 print_vma (section
->sh_addr
, LONG_HEX
);
4304 printf ( " %6.6lx %6.6lx %2.2lx",
4305 (unsigned long) section
->sh_offset
,
4306 (unsigned long) section
->sh_size
,
4307 (unsigned long) section
->sh_entsize
);
4309 if (do_section_details
)
4310 fputs (" ", stdout
);
4312 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4314 printf ("%2ld %3lu %2ld\n",
4315 (unsigned long) section
->sh_link
,
4316 (unsigned long) section
->sh_info
,
4317 (unsigned long) section
->sh_addralign
);
4321 print_vma (section
->sh_addr
, LONG_HEX
);
4323 if ((long) section
->sh_offset
== section
->sh_offset
)
4324 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4328 print_vma (section
->sh_offset
, LONG_HEX
);
4331 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4332 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4336 print_vma (section
->sh_size
, LONG_HEX
);
4339 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4340 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4344 print_vma (section
->sh_entsize
, LONG_HEX
);
4347 if (do_section_details
)
4348 fputs (" ", stdout
);
4350 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4352 printf ("%2ld %3lu ",
4353 (unsigned long) section
->sh_link
,
4354 (unsigned long) section
->sh_info
);
4356 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4357 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
4360 print_vma (section
->sh_addralign
, DEC
);
4364 else if (do_section_details
)
4366 printf (" %-15.15s ",
4367 get_section_type_name (section
->sh_type
));
4368 print_vma (section
->sh_addr
, LONG_HEX
);
4369 if ((long) section
->sh_offset
== section
->sh_offset
)
4370 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4374 print_vma (section
->sh_offset
, LONG_HEX
);
4376 printf (" %ld\n ", (unsigned long) section
->sh_link
);
4377 print_vma (section
->sh_size
, LONG_HEX
);
4379 print_vma (section
->sh_entsize
, LONG_HEX
);
4381 printf (" %-16lu %ld\n",
4382 (unsigned long) section
->sh_info
,
4383 (unsigned long) section
->sh_addralign
);
4388 print_vma (section
->sh_addr
, LONG_HEX
);
4389 if ((long) section
->sh_offset
== section
->sh_offset
)
4390 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4394 print_vma (section
->sh_offset
, LONG_HEX
);
4397 print_vma (section
->sh_size
, LONG_HEX
);
4399 print_vma (section
->sh_entsize
, LONG_HEX
);
4401 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4403 printf (" %2ld %3lu %ld\n",
4404 (unsigned long) section
->sh_link
,
4405 (unsigned long) section
->sh_info
,
4406 (unsigned long) section
->sh_addralign
);
4409 if (do_section_details
)
4410 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4413 if (!do_section_details
)
4414 printf (_("Key to Flags:\n\
4415 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4416 I (info), L (link order), G (group), x (unknown)\n\
4417 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4423 get_group_flags (unsigned int flags
)
4425 static char buff
[32];
4432 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x]"), flags
);
4439 process_section_groups (FILE *file
)
4441 Elf_Internal_Shdr
*section
;
4443 struct group
*group
;
4444 Elf_Internal_Shdr
*symtab_sec
, *strtab_sec
;
4445 Elf_Internal_Sym
*symtab
;
4449 /* Don't process section groups unless needed. */
4450 if (!do_unwind
&& !do_section_groups
)
4453 if (elf_header
.e_shnum
== 0)
4455 if (do_section_groups
)
4456 printf (_("\nThere are no sections in this file.\n"));
4461 if (section_headers
== NULL
)
4463 error (_("Section headers are not available!\n"));
4467 section_headers_groups
= calloc (elf_header
.e_shnum
,
4468 sizeof (struct group
*));
4470 if (section_headers_groups
== NULL
)
4472 error (_("Out of memory\n"));
4476 /* Scan the sections for the group section. */
4478 for (i
= 0, section
= section_headers
;
4479 i
< elf_header
.e_shnum
;
4481 if (section
->sh_type
== SHT_GROUP
)
4484 if (group_count
== 0)
4486 if (do_section_groups
)
4487 printf (_("\nThere are no section groups in this file.\n"));
4492 section_groups
= calloc (group_count
, sizeof (struct group
));
4494 if (section_groups
== NULL
)
4496 error (_("Out of memory\n"));
4505 for (i
= 0, section
= section_headers
, group
= section_groups
;
4506 i
< elf_header
.e_shnum
;
4509 if (section
->sh_type
== SHT_GROUP
)
4511 char *name
= SECTION_NAME (section
);
4513 unsigned char *start
, *indices
;
4514 unsigned int entry
, j
, size
;
4515 Elf_Internal_Shdr
*sec
;
4516 Elf_Internal_Sym
*sym
;
4518 /* Get the symbol table. */
4519 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
4520 || ((sec
= SECTION_HEADER (section
->sh_link
))->sh_type
4523 error (_("Bad sh_link in group section `%s'\n"), name
);
4527 if (symtab_sec
!= sec
)
4532 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4535 sym
= symtab
+ section
->sh_info
;
4537 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4539 bfd_vma sec_index
= SECTION_HEADER_INDEX (sym
->st_shndx
);
4542 error (_("Bad sh_info in group section `%s'\n"), name
);
4546 group_name
= SECTION_NAME (section_headers
+ sec_index
);
4555 /* Get the string table. */
4556 if (SECTION_HEADER_INDEX (symtab_sec
->sh_link
)
4557 >= elf_header
.e_shnum
)
4566 != (sec
= SECTION_HEADER (symtab_sec
->sh_link
)))
4571 strtab
= get_data (NULL
, file
, strtab_sec
->sh_offset
,
4572 1, strtab_sec
->sh_size
,
4574 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4576 group_name
= sym
->st_name
< strtab_size
4577 ? strtab
+ sym
->st_name
: "<corrupt>";
4580 start
= get_data (NULL
, file
, section
->sh_offset
,
4581 1, section
->sh_size
, _("section data"));
4584 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4585 entry
= byte_get (indices
, 4);
4588 if (do_section_groups
)
4590 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4591 get_group_flags (entry
), i
, name
, group_name
, size
);
4593 printf (_(" [Index] Name\n"));
4596 group
->group_index
= i
;
4598 for (j
= 0; j
< size
; j
++)
4600 struct group_list
*g
;
4602 entry
= byte_get (indices
, 4);
4605 if (SECTION_HEADER_INDEX (entry
) >= elf_header
.e_shnum
)
4607 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4608 entry
, i
, elf_header
.e_shnum
- 1);
4611 else if (entry
>= SHN_LORESERVE
&& entry
<= SHN_HIRESERVE
)
4613 error (_("invalid section [%5u] in group section [%5u]\n"),
4618 if (section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4623 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4625 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4630 /* Intel C/C++ compiler may put section 0 in a
4631 section group. We just warn it the first time
4632 and ignore it afterwards. */
4633 static int warned
= 0;
4636 error (_("section 0 in group section [%5u]\n"),
4637 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]->group_index
);
4643 section_headers_groups
[SECTION_HEADER_INDEX (entry
)]
4646 if (do_section_groups
)
4648 sec
= SECTION_HEADER (entry
);
4649 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
4652 g
= xmalloc (sizeof (struct group_list
));
4653 g
->section_index
= entry
;
4654 g
->next
= group
->root
;
4678 } dynamic_relocations
[] =
4680 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
4681 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
4682 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
4685 /* Process the reloc section. */
4688 process_relocs (FILE *file
)
4690 unsigned long rel_size
;
4691 unsigned long rel_offset
;
4697 if (do_using_dynamic
)
4701 int has_dynamic_reloc
;
4704 has_dynamic_reloc
= 0;
4706 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
4708 is_rela
= dynamic_relocations
[i
].rela
;
4709 name
= dynamic_relocations
[i
].name
;
4710 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
4711 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
4713 has_dynamic_reloc
|= rel_size
;
4715 if (is_rela
== UNKNOWN
)
4717 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
4718 switch (dynamic_info
[DT_PLTREL
])
4732 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4733 name
, rel_offset
, rel_size
);
4735 dump_relocations (file
,
4736 offset_from_vma (file
, rel_offset
, rel_size
),
4738 dynamic_symbols
, num_dynamic_syms
,
4739 dynamic_strings
, dynamic_strings_length
, is_rela
);
4743 if (! has_dynamic_reloc
)
4744 printf (_("\nThere are no dynamic relocations in this file.\n"));
4748 Elf_Internal_Shdr
*section
;
4752 for (i
= 0, section
= section_headers
;
4753 i
< elf_header
.e_shnum
;
4756 if ( section
->sh_type
!= SHT_RELA
4757 && section
->sh_type
!= SHT_REL
)
4760 rel_offset
= section
->sh_offset
;
4761 rel_size
= section
->sh_size
;
4765 Elf_Internal_Shdr
*strsec
;
4768 printf (_("\nRelocation section "));
4770 if (string_table
== NULL
)
4771 printf ("%d", section
->sh_name
);
4773 printf (_("'%s'"), SECTION_NAME (section
));
4775 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4776 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
4778 is_rela
= section
->sh_type
== SHT_RELA
;
4780 if (section
->sh_link
4781 && SECTION_HEADER_INDEX (section
->sh_link
)
4782 < elf_header
.e_shnum
)
4784 Elf_Internal_Shdr
*symsec
;
4785 Elf_Internal_Sym
*symtab
;
4786 unsigned long nsyms
;
4787 unsigned long strtablen
= 0;
4788 char *strtab
= NULL
;
4790 symsec
= SECTION_HEADER (section
->sh_link
);
4791 if (symsec
->sh_type
!= SHT_SYMTAB
4792 && symsec
->sh_type
!= SHT_DYNSYM
)
4795 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
4796 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
4801 if (SECTION_HEADER_INDEX (symsec
->sh_link
)
4802 < elf_header
.e_shnum
)
4804 strsec
= SECTION_HEADER (symsec
->sh_link
);
4806 strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
4809 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
4812 dump_relocations (file
, rel_offset
, rel_size
,
4813 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
4819 dump_relocations (file
, rel_offset
, rel_size
,
4820 NULL
, 0, NULL
, 0, is_rela
);
4827 printf (_("\nThere are no relocations in this file.\n"));
4833 /* Process the unwind section. */
4835 #include "unwind-ia64.h"
4837 /* An absolute address consists of a section and an offset. If the
4838 section is NULL, the offset itself is the address, otherwise, the
4839 address equals to LOAD_ADDRESS(section) + offset. */
4843 unsigned short section
;
4847 #define ABSADDR(a) \
4849 ? section_headers [(a).section].sh_addr + (a).offset \
4852 struct ia64_unw_aux_info
4854 struct ia64_unw_table_entry
4856 struct absaddr start
;
4858 struct absaddr info
;
4860 *table
; /* Unwind table. */
4861 unsigned long table_len
; /* Length of unwind table. */
4862 unsigned char *info
; /* Unwind info. */
4863 unsigned long info_size
; /* Size of unwind info. */
4864 bfd_vma info_addr
; /* starting address of unwind info. */
4865 bfd_vma seg_base
; /* Starting address of segment. */
4866 Elf_Internal_Sym
*symtab
; /* The symbol table. */
4867 unsigned long nsyms
; /* Number of symbols. */
4868 char *strtab
; /* The string table. */
4869 unsigned long strtab_size
; /* Size of string table. */
4873 find_symbol_for_address (Elf_Internal_Sym
*symtab
,
4874 unsigned long nsyms
,
4876 unsigned long strtab_size
,
4877 struct absaddr addr
,
4878 const char **symname
,
4881 bfd_vma dist
= 0x100000;
4882 Elf_Internal_Sym
*sym
, *best
= NULL
;
4885 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
4887 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
4888 && sym
->st_name
!= 0
4889 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
4890 && addr
.offset
>= sym
->st_value
4891 && addr
.offset
- sym
->st_value
< dist
)
4894 dist
= addr
.offset
- sym
->st_value
;
4901 *symname
= (best
->st_name
>= strtab_size
4902 ? "<corrupt>" : strtab
+ best
->st_name
);
4907 *offset
= addr
.offset
;
4911 dump_ia64_unwind (struct ia64_unw_aux_info
*aux
)
4913 struct ia64_unw_table_entry
*tp
;
4916 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
4920 const unsigned char *dp
;
4921 const unsigned char *head
;
4922 const char *procname
;
4924 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
4925 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
4927 fputs ("\n<", stdout
);
4931 fputs (procname
, stdout
);
4934 printf ("+%lx", (unsigned long) offset
);
4937 fputs (">: [", stdout
);
4938 print_vma (tp
->start
.offset
, PREFIX_HEX
);
4939 fputc ('-', stdout
);
4940 print_vma (tp
->end
.offset
, PREFIX_HEX
);
4941 printf ("], info at +0x%lx\n",
4942 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
4944 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
4945 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
4947 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4948 (unsigned) UNW_VER (stamp
),
4949 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
4950 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
4951 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
4952 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
4954 if (UNW_VER (stamp
) != 1)
4956 printf ("\tUnknown version.\n");
4961 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
4962 dp
= unw_decode (dp
, in_body
, & in_body
);
4967 slurp_ia64_unwind_table (FILE *file
,
4968 struct ia64_unw_aux_info
*aux
,
4969 Elf_Internal_Shdr
*sec
)
4971 unsigned long size
, nrelas
, i
;
4972 Elf_Internal_Phdr
*seg
;
4973 struct ia64_unw_table_entry
*tep
;
4974 Elf_Internal_Shdr
*relsec
;
4975 Elf_Internal_Rela
*rela
, *rp
;
4976 unsigned char *table
, *tp
;
4977 Elf_Internal_Sym
*sym
;
4978 const char *relname
;
4980 /* First, find the starting address of the segment that includes
4983 if (elf_header
.e_phnum
)
4985 if (! get_program_headers (file
))
4988 for (seg
= program_headers
;
4989 seg
< program_headers
+ elf_header
.e_phnum
;
4992 if (seg
->p_type
!= PT_LOAD
)
4995 if (sec
->sh_addr
>= seg
->p_vaddr
4996 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
4998 aux
->seg_base
= seg
->p_vaddr
;
5004 /* Second, build the unwind table from the contents of the unwind section: */
5005 size
= sec
->sh_size
;
5006 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5010 aux
->table
= xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5012 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * eh_addr_size
, ++tep
)
5014 tep
->start
.section
= SHN_UNDEF
;
5015 tep
->end
.section
= SHN_UNDEF
;
5016 tep
->info
.section
= SHN_UNDEF
;
5019 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5020 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5021 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
5025 tep
->start
.offset
= BYTE_GET ((unsigned char *) tp
+ 0);
5026 tep
->end
.offset
= BYTE_GET ((unsigned char *) tp
+ 8);
5027 tep
->info
.offset
= BYTE_GET ((unsigned char *) tp
+ 16);
5029 tep
->start
.offset
+= aux
->seg_base
;
5030 tep
->end
.offset
+= aux
->seg_base
;
5031 tep
->info
.offset
+= aux
->seg_base
;
5035 /* Third, apply any relocations to the unwind table: */
5036 for (relsec
= section_headers
;
5037 relsec
< section_headers
+ elf_header
.e_shnum
;
5040 if (relsec
->sh_type
!= SHT_RELA
5041 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5042 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5045 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5049 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5051 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5052 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5054 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5056 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5060 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5062 switch (rp
->r_offset
/eh_addr_size
% 3)
5065 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5066 aux
->table
[i
].start
.offset
+= rp
->r_addend
+ sym
->st_value
;
5069 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5070 aux
->table
[i
].end
.offset
+= rp
->r_addend
+ sym
->st_value
;
5073 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5074 aux
->table
[i
].info
.offset
+= rp
->r_addend
+ sym
->st_value
;
5084 aux
->table_len
= size
/ (3 * eh_addr_size
);
5089 ia64_process_unwind (FILE *file
)
5091 Elf_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
5092 unsigned long i
, unwcount
= 0, unwstart
= 0;
5093 struct ia64_unw_aux_info aux
;
5095 memset (& aux
, 0, sizeof (aux
));
5097 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5099 if (sec
->sh_type
== SHT_SYMTAB
5100 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5102 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5103 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5105 strsec
= SECTION_HEADER (sec
->sh_link
);
5106 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5107 1, strsec
->sh_size
, _("string table"));
5108 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5110 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5115 printf (_("\nThere are no unwind sections in this file.\n"));
5117 while (unwcount
-- > 0)
5122 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5123 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5124 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5131 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5133 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5135 /* We need to find which section group it is in. */
5136 struct group_list
*g
= section_headers_groups
[i
]->root
;
5138 for (; g
!= NULL
; g
= g
->next
)
5140 sec
= SECTION_HEADER (g
->section_index
);
5142 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5147 i
= elf_header
.e_shnum
;
5149 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5151 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5152 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5153 suffix
= SECTION_NAME (unwsec
) + len
;
5154 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5156 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5157 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5162 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5163 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5164 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5165 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5167 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5168 suffix
= SECTION_NAME (unwsec
) + len
;
5169 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5171 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5172 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5176 if (i
== elf_header
.e_shnum
)
5178 printf (_("\nCould not find unwind info section for "));
5180 if (string_table
== NULL
)
5181 printf ("%d", unwsec
->sh_name
);
5183 printf (_("'%s'"), SECTION_NAME (unwsec
));
5187 aux
.info_size
= sec
->sh_size
;
5188 aux
.info_addr
= sec
->sh_addr
;
5189 aux
.info
= get_data (NULL
, file
, sec
->sh_offset
, 1, aux
.info_size
,
5192 printf (_("\nUnwind section "));
5194 if (string_table
== NULL
)
5195 printf ("%d", unwsec
->sh_name
);
5197 printf (_("'%s'"), SECTION_NAME (unwsec
));
5199 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5200 (unsigned long) unwsec
->sh_offset
,
5201 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5203 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5205 if (aux
.table_len
> 0)
5206 dump_ia64_unwind (& aux
);
5209 free ((char *) aux
.table
);
5211 free ((char *) aux
.info
);
5220 free ((char *) aux
.strtab
);
5225 struct hppa_unw_aux_info
5227 struct hppa_unw_table_entry
5229 struct absaddr start
;
5231 unsigned int Cannot_unwind
:1; /* 0 */
5232 unsigned int Millicode
:1; /* 1 */
5233 unsigned int Millicode_save_sr0
:1; /* 2 */
5234 unsigned int Region_description
:2; /* 3..4 */
5235 unsigned int reserved1
:1; /* 5 */
5236 unsigned int Entry_SR
:1; /* 6 */
5237 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5238 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5239 unsigned int Args_stored
:1; /* 16 */
5240 unsigned int Variable_Frame
:1; /* 17 */
5241 unsigned int Separate_Package_Body
:1; /* 18 */
5242 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5243 unsigned int Stack_Overflow_Check
:1; /* 20 */
5244 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5245 unsigned int Ada_Region
:1; /* 22 */
5246 unsigned int cxx_info
:1; /* 23 */
5247 unsigned int cxx_try_catch
:1; /* 24 */
5248 unsigned int sched_entry_seq
:1; /* 25 */
5249 unsigned int reserved2
:1; /* 26 */
5250 unsigned int Save_SP
:1; /* 27 */
5251 unsigned int Save_RP
:1; /* 28 */
5252 unsigned int Save_MRP_in_frame
:1; /* 29 */
5253 unsigned int extn_ptr_defined
:1; /* 30 */
5254 unsigned int Cleanup_defined
:1; /* 31 */
5256 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5257 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5258 unsigned int Large_frame
:1; /* 2 */
5259 unsigned int Pseudo_SP_Set
:1; /* 3 */
5260 unsigned int reserved4
:1; /* 4 */
5261 unsigned int Total_frame_size
:27; /* 5..31 */
5263 *table
; /* Unwind table. */
5264 unsigned long table_len
; /* Length of unwind table. */
5265 bfd_vma seg_base
; /* Starting address of segment. */
5266 Elf_Internal_Sym
*symtab
; /* The symbol table. */
5267 unsigned long nsyms
; /* Number of symbols. */
5268 char *strtab
; /* The string table. */
5269 unsigned long strtab_size
; /* Size of string table. */
5273 dump_hppa_unwind (struct hppa_unw_aux_info
*aux
)
5275 struct hppa_unw_table_entry
*tp
;
5277 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5280 const char *procname
;
5282 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5283 aux
->strtab_size
, tp
->start
, &procname
,
5286 fputs ("\n<", stdout
);
5290 fputs (procname
, stdout
);
5293 printf ("+%lx", (unsigned long) offset
);
5296 fputs (">: [", stdout
);
5297 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5298 fputc ('-', stdout
);
5299 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5302 #define PF(_m) if (tp->_m) printf (#_m " ");
5303 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5306 PF(Millicode_save_sr0
);
5307 /* PV(Region_description); */
5313 PF(Separate_Package_Body
);
5314 PF(Frame_Extension_Millicode
);
5315 PF(Stack_Overflow_Check
);
5316 PF(Two_Instruction_SP_Increment
);
5320 PF(sched_entry_seq
);
5323 PF(Save_MRP_in_frame
);
5324 PF(extn_ptr_defined
);
5325 PF(Cleanup_defined
);
5326 PF(MPE_XL_interrupt_marker
);
5327 PF(HP_UX_interrupt_marker
);
5330 PV(Total_frame_size
);
5339 slurp_hppa_unwind_table (FILE *file
,
5340 struct hppa_unw_aux_info
*aux
,
5341 Elf_Internal_Shdr
*sec
)
5343 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5344 Elf_Internal_Phdr
*seg
;
5345 struct hppa_unw_table_entry
*tep
;
5346 Elf_Internal_Shdr
*relsec
;
5347 Elf_Internal_Rela
*rela
, *rp
;
5348 unsigned char *table
, *tp
;
5349 Elf_Internal_Sym
*sym
;
5350 const char *relname
;
5352 /* First, find the starting address of the segment that includes
5355 if (elf_header
.e_phnum
)
5357 if (! get_program_headers (file
))
5360 for (seg
= program_headers
;
5361 seg
< program_headers
+ elf_header
.e_phnum
;
5364 if (seg
->p_type
!= PT_LOAD
)
5367 if (sec
->sh_addr
>= seg
->p_vaddr
5368 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5370 aux
->seg_base
= seg
->p_vaddr
;
5376 /* Second, build the unwind table from the contents of the unwind
5378 size
= sec
->sh_size
;
5379 table
= get_data (NULL
, file
, sec
->sh_offset
, 1, size
, _("unwind table"));
5384 nentries
= size
/ unw_ent_size
;
5385 size
= unw_ent_size
* nentries
;
5387 tep
= aux
->table
= xcmalloc (nentries
, sizeof (aux
->table
[0]));
5389 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5391 unsigned int tmp1
, tmp2
;
5393 tep
->start
.section
= SHN_UNDEF
;
5394 tep
->end
.section
= SHN_UNDEF
;
5396 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5397 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5398 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5399 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5401 tep
->start
.offset
+= aux
->seg_base
;
5402 tep
->end
.offset
+= aux
->seg_base
;
5404 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
5405 tep
->Millicode
= (tmp1
>> 30) & 0x1;
5406 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
5407 tep
->Region_description
= (tmp1
>> 27) & 0x3;
5408 tep
->reserved1
= (tmp1
>> 26) & 0x1;
5409 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
5410 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
5411 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
5412 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
5413 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
5414 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
5415 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
5416 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
5417 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
5418 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
5419 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
5420 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
5421 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
5422 tep
->reserved2
= (tmp1
>> 5) & 0x1;
5423 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
5424 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
5425 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
5426 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
5427 tep
->Cleanup_defined
= tmp1
& 0x1;
5429 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
5430 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
5431 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
5432 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
5433 tep
->reserved4
= (tmp2
>> 27) & 0x1;
5434 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
5438 /* Third, apply any relocations to the unwind table. */
5439 for (relsec
= section_headers
;
5440 relsec
< section_headers
+ elf_header
.e_shnum
;
5443 if (relsec
->sh_type
!= SHT_RELA
5444 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
5445 || SECTION_HEADER (relsec
->sh_info
) != sec
)
5448 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5452 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5454 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
5455 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5457 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5458 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
5460 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5464 i
= rp
->r_offset
/ unw_ent_size
;
5466 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
5469 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5470 aux
->table
[i
].start
.offset
+= sym
->st_value
+ rp
->r_addend
;
5473 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5474 aux
->table
[i
].end
.offset
+= sym
->st_value
+ rp
->r_addend
;
5484 aux
->table_len
= nentries
;
5490 hppa_process_unwind (FILE *file
)
5492 struct hppa_unw_aux_info aux
;
5493 Elf_Internal_Shdr
*unwsec
= NULL
;
5494 Elf_Internal_Shdr
*strsec
;
5495 Elf_Internal_Shdr
*sec
;
5498 memset (& aux
, 0, sizeof (aux
));
5500 if (string_table
== NULL
)
5503 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5505 if (sec
->sh_type
== SHT_SYMTAB
5506 && SECTION_HEADER_INDEX (sec
->sh_link
) < elf_header
.e_shnum
)
5508 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5509 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5511 strsec
= SECTION_HEADER (sec
->sh_link
);
5512 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
5513 1, strsec
->sh_size
, _("string table"));
5514 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5516 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5521 printf (_("\nThere are no unwind sections in this file.\n"));
5523 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5525 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
5527 printf (_("\nUnwind section "));
5528 printf (_("'%s'"), SECTION_NAME (sec
));
5530 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5531 (unsigned long) sec
->sh_offset
,
5532 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
5534 slurp_hppa_unwind_table (file
, &aux
, sec
);
5535 if (aux
.table_len
> 0)
5536 dump_hppa_unwind (&aux
);
5539 free ((char *) aux
.table
);
5547 free ((char *) aux
.strtab
);
5553 process_unwind (FILE *file
)
5555 struct unwind_handler
{
5557 int (*handler
)(FILE *file
);
5559 { EM_IA_64
, ia64_process_unwind
},
5560 { EM_PARISC
, hppa_process_unwind
},
5568 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
5569 if (elf_header
.e_machine
== handlers
[i
].machtype
)
5570 return handlers
[i
].handler (file
);
5572 printf (_("\nThere are no unwind sections in this file.\n"));
5577 dynamic_section_mips_val (Elf_Internal_Dyn
*entry
)
5579 switch (entry
->d_tag
)
5582 if (entry
->d_un
.d_val
== 0)
5586 static const char * opts
[] =
5588 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5589 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5590 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5591 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5596 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
5597 if (entry
->d_un
.d_val
& (1 << cnt
))
5599 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
5606 case DT_MIPS_IVERSION
:
5607 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
5608 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
5610 printf ("<corrupt: %ld>\n", (long) entry
->d_un
.d_ptr
);
5613 case DT_MIPS_TIME_STAMP
:
5618 time_t time
= entry
->d_un
.d_val
;
5619 tmp
= gmtime (&time
);
5620 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
5621 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
5622 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
5623 printf ("Time Stamp: %s\n", timebuf
);
5627 case DT_MIPS_RLD_VERSION
:
5628 case DT_MIPS_LOCAL_GOTNO
:
5629 case DT_MIPS_CONFLICTNO
:
5630 case DT_MIPS_LIBLISTNO
:
5631 case DT_MIPS_SYMTABNO
:
5632 case DT_MIPS_UNREFEXTNO
:
5633 case DT_MIPS_HIPAGENO
:
5634 case DT_MIPS_DELTA_CLASS_NO
:
5635 case DT_MIPS_DELTA_INSTANCE_NO
:
5636 case DT_MIPS_DELTA_RELOC_NO
:
5637 case DT_MIPS_DELTA_SYM_NO
:
5638 case DT_MIPS_DELTA_CLASSSYM_NO
:
5639 case DT_MIPS_COMPACT_SIZE
:
5640 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
5644 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
5650 dynamic_section_parisc_val (Elf_Internal_Dyn
*entry
)
5652 switch (entry
->d_tag
)
5654 case DT_HP_DLD_FLAGS
:
5663 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
5664 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
5665 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
5666 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
5667 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
5668 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
5669 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
5670 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
5671 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
5672 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
5673 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
5674 { DT_HP_GST
, "HP_GST" },
5675 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
5676 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
5677 { DT_HP_NODELETE
, "HP_NODELETE" },
5678 { DT_HP_GROUP
, "HP_GROUP" },
5679 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
5683 bfd_vma val
= entry
->d_un
.d_val
;
5685 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
5686 if (val
& flags
[cnt
].bit
)
5690 fputs (flags
[cnt
].str
, stdout
);
5692 val
^= flags
[cnt
].bit
;
5695 if (val
!= 0 || first
)
5699 print_vma (val
, HEX
);
5705 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5712 dynamic_section_ia64_val (Elf_Internal_Dyn
*entry
)
5714 switch (entry
->d_tag
)
5716 case DT_IA_64_PLT_RESERVE
:
5717 /* First 3 slots reserved. */
5718 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5720 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
5724 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
5731 get_32bit_dynamic_section (FILE *file
)
5733 Elf32_External_Dyn
*edyn
, *ext
;
5734 Elf_Internal_Dyn
*entry
;
5736 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5737 _("dynamic section"));
5741 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5742 might not have the luxury of section headers. Look for the DT_NULL
5743 terminator to determine the number of entries. */
5744 for (ext
= edyn
, dynamic_nent
= 0;
5745 (char *) ext
< (char *) edyn
+ dynamic_size
;
5749 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5753 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5754 if (dynamic_section
== NULL
)
5756 error (_("Out of memory\n"));
5761 for (ext
= edyn
, entry
= dynamic_section
;
5762 entry
< dynamic_section
+ dynamic_nent
;
5765 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5766 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5775 get_64bit_dynamic_section (FILE *file
)
5777 Elf64_External_Dyn
*edyn
, *ext
;
5778 Elf_Internal_Dyn
*entry
;
5780 edyn
= get_data (NULL
, file
, dynamic_addr
, 1, dynamic_size
,
5781 _("dynamic section"));
5785 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5786 might not have the luxury of section headers. Look for the DT_NULL
5787 terminator to determine the number of entries. */
5788 for (ext
= edyn
, dynamic_nent
= 0;
5789 (char *) ext
< (char *) edyn
+ dynamic_size
;
5793 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
5797 dynamic_section
= cmalloc (dynamic_nent
, sizeof (*entry
));
5798 if (dynamic_section
== NULL
)
5800 error (_("Out of memory\n"));
5805 for (ext
= edyn
, entry
= dynamic_section
;
5806 entry
< dynamic_section
+ dynamic_nent
;
5809 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
5810 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
5819 print_dynamic_flags (bfd_vma flags
)
5827 flag
= flags
& - flags
;
5837 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
5838 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
5839 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
5840 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
5841 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
5842 default: fputs ("unknown", stdout
); break;
5848 /* Parse and display the contents of the dynamic section. */
5851 process_dynamic_section (FILE *file
)
5853 Elf_Internal_Dyn
*entry
;
5855 if (dynamic_size
== 0)
5858 printf (_("\nThere is no dynamic section in this file.\n"));
5865 if (! get_32bit_dynamic_section (file
))
5868 else if (! get_64bit_dynamic_section (file
))
5871 /* Find the appropriate symbol table. */
5872 if (dynamic_symbols
== NULL
)
5874 for (entry
= dynamic_section
;
5875 entry
< dynamic_section
+ dynamic_nent
;
5878 Elf_Internal_Shdr section
;
5880 if (entry
->d_tag
!= DT_SYMTAB
)
5883 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
5885 /* Since we do not know how big the symbol table is,
5886 we default to reading in the entire file (!) and
5887 processing that. This is overkill, I know, but it
5889 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5891 if (archive_file_offset
!= 0)
5892 section
.sh_size
= archive_file_size
- section
.sh_offset
;
5895 if (fseek (file
, 0, SEEK_END
))
5896 error (_("Unable to seek to end of file!\n"));
5898 section
.sh_size
= ftell (file
) - section
.sh_offset
;
5902 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
5904 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
5906 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
5907 if (num_dynamic_syms
< 1)
5909 error (_("Unable to determine the number of symbols to load\n"));
5913 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
5917 /* Similarly find a string table. */
5918 if (dynamic_strings
== NULL
)
5920 for (entry
= dynamic_section
;
5921 entry
< dynamic_section
+ dynamic_nent
;
5924 unsigned long offset
;
5927 if (entry
->d_tag
!= DT_STRTAB
)
5930 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
5932 /* Since we do not know how big the string table is,
5933 we default to reading in the entire file (!) and
5934 processing that. This is overkill, I know, but it
5937 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
5939 if (archive_file_offset
!= 0)
5940 str_tab_len
= archive_file_size
- offset
;
5943 if (fseek (file
, 0, SEEK_END
))
5944 error (_("Unable to seek to end of file\n"));
5945 str_tab_len
= ftell (file
) - offset
;
5948 if (str_tab_len
< 1)
5951 (_("Unable to determine the length of the dynamic string table\n"));
5955 dynamic_strings
= get_data (NULL
, file
, offset
, 1, str_tab_len
,
5956 _("dynamic string table"));
5957 dynamic_strings_length
= str_tab_len
;
5962 /* And find the syminfo section if available. */
5963 if (dynamic_syminfo
== NULL
)
5965 unsigned long syminsz
= 0;
5967 for (entry
= dynamic_section
;
5968 entry
< dynamic_section
+ dynamic_nent
;
5971 if (entry
->d_tag
== DT_SYMINENT
)
5973 /* Note: these braces are necessary to avoid a syntax
5974 error from the SunOS4 C compiler. */
5975 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
5977 else if (entry
->d_tag
== DT_SYMINSZ
)
5978 syminsz
= entry
->d_un
.d_val
;
5979 else if (entry
->d_tag
== DT_SYMINFO
)
5980 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
5984 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
5986 Elf_External_Syminfo
*extsyminfo
, *extsym
;
5987 Elf_Internal_Syminfo
*syminfo
;
5989 /* There is a syminfo section. Read the data. */
5990 extsyminfo
= get_data (NULL
, file
, dynamic_syminfo_offset
, 1,
5991 syminsz
, _("symbol information"));
5995 dynamic_syminfo
= malloc (syminsz
);
5996 if (dynamic_syminfo
== NULL
)
5998 error (_("Out of memory\n"));
6002 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
6003 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
6004 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
6005 ++syminfo
, ++extsym
)
6007 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
6008 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
6015 if (do_dynamic
&& dynamic_addr
)
6016 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6017 dynamic_addr
, dynamic_nent
);
6019 printf (_(" Tag Type Name/Value\n"));
6021 for (entry
= dynamic_section
;
6022 entry
< dynamic_section
+ dynamic_nent
;
6030 print_vma (entry
->d_tag
, FULL_HEX
);
6031 dtype
= get_dynamic_type (entry
->d_tag
);
6032 printf (" (%s)%*s", dtype
,
6033 ((is_32bit_elf
? 27 : 19)
6034 - (int) strlen (dtype
)),
6038 switch (entry
->d_tag
)
6042 print_dynamic_flags (entry
->d_un
.d_val
);
6052 switch (entry
->d_tag
)
6055 printf (_("Auxiliary library"));
6059 printf (_("Filter library"));
6063 printf (_("Configuration file"));
6067 printf (_("Dependency audit library"));
6071 printf (_("Audit library"));
6075 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6076 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6080 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6089 printf (_("Flags:"));
6091 if (entry
->d_un
.d_val
== 0)
6092 printf (_(" None\n"));
6095 unsigned long int val
= entry
->d_un
.d_val
;
6097 if (val
& DTF_1_PARINIT
)
6099 printf (" PARINIT");
6100 val
^= DTF_1_PARINIT
;
6102 if (val
& DTF_1_CONFEXP
)
6104 printf (" CONFEXP");
6105 val
^= DTF_1_CONFEXP
;
6108 printf (" %lx", val
);
6117 printf (_("Flags:"));
6119 if (entry
->d_un
.d_val
== 0)
6120 printf (_(" None\n"));
6123 unsigned long int val
= entry
->d_un
.d_val
;
6125 if (val
& DF_P1_LAZYLOAD
)
6127 printf (" LAZYLOAD");
6128 val
^= DF_P1_LAZYLOAD
;
6130 if (val
& DF_P1_GROUPPERM
)
6132 printf (" GROUPPERM");
6133 val
^= DF_P1_GROUPPERM
;
6136 printf (" %lx", val
);
6145 printf (_("Flags:"));
6146 if (entry
->d_un
.d_val
== 0)
6147 printf (_(" None\n"));
6150 unsigned long int val
= entry
->d_un
.d_val
;
6157 if (val
& DF_1_GLOBAL
)
6162 if (val
& DF_1_GROUP
)
6167 if (val
& DF_1_NODELETE
)
6169 printf (" NODELETE");
6170 val
^= DF_1_NODELETE
;
6172 if (val
& DF_1_LOADFLTR
)
6174 printf (" LOADFLTR");
6175 val
^= DF_1_LOADFLTR
;
6177 if (val
& DF_1_INITFIRST
)
6179 printf (" INITFIRST");
6180 val
^= DF_1_INITFIRST
;
6182 if (val
& DF_1_NOOPEN
)
6187 if (val
& DF_1_ORIGIN
)
6192 if (val
& DF_1_DIRECT
)
6197 if (val
& DF_1_TRANS
)
6202 if (val
& DF_1_INTERPOSE
)
6204 printf (" INTERPOSE");
6205 val
^= DF_1_INTERPOSE
;
6207 if (val
& DF_1_NODEFLIB
)
6209 printf (" NODEFLIB");
6210 val
^= DF_1_NODEFLIB
;
6212 if (val
& DF_1_NODUMP
)
6217 if (val
& DF_1_CONLFAT
)
6219 printf (" CONLFAT");
6220 val
^= DF_1_CONLFAT
;
6223 printf (" %lx", val
);
6230 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6232 puts (get_dynamic_type (entry
->d_un
.d_val
));
6252 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6258 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6259 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6265 switch (entry
->d_tag
)
6268 printf (_("Shared library: [%s]"), name
);
6270 if (streq (name
, program_interpreter
))
6271 printf (_(" program interpreter"));
6275 printf (_("Library soname: [%s]"), name
);
6279 printf (_("Library rpath: [%s]"), name
);
6283 printf (_("Library runpath: [%s]"), name
);
6287 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6292 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6305 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
6309 case DT_INIT_ARRAYSZ
:
6310 case DT_FINI_ARRAYSZ
:
6311 case DT_GNU_CONFLICTSZ
:
6312 case DT_GNU_LIBLISTSZ
:
6315 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6316 printf (" (bytes)\n");
6326 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
6339 if (entry
->d_tag
== DT_USED
6340 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6342 char *name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
6346 printf (_("Not needed object: [%s]\n"), name
);
6351 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6357 /* The value of this entry is ignored. */
6362 case DT_GNU_PRELINKED
:
6366 time_t time
= entry
->d_un
.d_val
;
6368 tmp
= gmtime (&time
);
6369 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6370 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6371 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6377 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
6380 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6386 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
6387 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
6392 switch (elf_header
.e_machine
)
6395 case EM_MIPS_RS3_LE
:
6396 dynamic_section_mips_val (entry
);
6399 dynamic_section_parisc_val (entry
);
6402 dynamic_section_ia64_val (entry
);
6405 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
6417 get_ver_flags (unsigned int flags
)
6419 static char buff
[32];
6426 if (flags
& VER_FLG_BASE
)
6427 strcat (buff
, "BASE ");
6429 if (flags
& VER_FLG_WEAK
)
6431 if (flags
& VER_FLG_BASE
)
6432 strcat (buff
, "| ");
6434 strcat (buff
, "WEAK ");
6437 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
6438 strcat (buff
, "| <unknown>");
6443 /* Display the contents of the version sections. */
6445 process_version_sections (FILE *file
)
6447 Elf_Internal_Shdr
*section
;
6454 for (i
= 0, section
= section_headers
;
6455 i
< elf_header
.e_shnum
;
6458 switch (section
->sh_type
)
6460 case SHT_GNU_verdef
:
6462 Elf_External_Verdef
*edefs
;
6470 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6471 SECTION_NAME (section
), section
->sh_info
);
6473 printf (_(" Addr: 0x"));
6474 printf_vma (section
->sh_addr
);
6475 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6476 (unsigned long) section
->sh_offset
, section
->sh_link
,
6477 SECTION_HEADER_INDEX (section
->sh_link
)
6478 < elf_header
.e_shnum
6479 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6482 edefs
= get_data (NULL
, file
, section
->sh_offset
, 1,
6484 _("version definition section"));
6485 endbuf
= (char *) edefs
+ section
->sh_size
;
6489 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6492 Elf_External_Verdef
*edef
;
6493 Elf_Internal_Verdef ent
;
6494 Elf_External_Verdaux
*eaux
;
6495 Elf_Internal_Verdaux aux
;
6499 vstart
= ((char *) edefs
) + idx
;
6500 if (vstart
+ sizeof (*edef
) > endbuf
)
6503 edef
= (Elf_External_Verdef
*) vstart
;
6505 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
6506 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
6507 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
6508 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
6509 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
6510 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
6511 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
6513 printf (_(" %#06x: Rev: %d Flags: %s"),
6514 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
6516 printf (_(" Index: %d Cnt: %d "),
6517 ent
.vd_ndx
, ent
.vd_cnt
);
6519 vstart
+= ent
.vd_aux
;
6521 eaux
= (Elf_External_Verdaux
*) vstart
;
6523 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6524 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6526 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6527 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
6529 printf (_("Name index: %ld\n"), aux
.vda_name
);
6531 isum
= idx
+ ent
.vd_aux
;
6533 for (j
= 1; j
< ent
.vd_cnt
; j
++)
6535 isum
+= aux
.vda_next
;
6536 vstart
+= aux
.vda_next
;
6538 eaux
= (Elf_External_Verdaux
*) vstart
;
6539 if (vstart
+ sizeof (*eaux
) > endbuf
)
6542 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
6543 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
6545 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
6546 printf (_(" %#06x: Parent %d: %s\n"),
6547 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
6549 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6550 isum
, j
, aux
.vda_name
);
6553 printf (_(" Version def aux past end of section\n"));
6557 if (cnt
< section
->sh_info
)
6558 printf (_(" Version definition past end of section\n"));
6564 case SHT_GNU_verneed
:
6566 Elf_External_Verneed
*eneed
;
6573 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6574 SECTION_NAME (section
), section
->sh_info
);
6576 printf (_(" Addr: 0x"));
6577 printf_vma (section
->sh_addr
);
6578 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6579 (unsigned long) section
->sh_offset
, section
->sh_link
,
6580 SECTION_HEADER_INDEX (section
->sh_link
)
6581 < elf_header
.e_shnum
6582 ? SECTION_NAME (SECTION_HEADER (section
->sh_link
))
6585 eneed
= get_data (NULL
, file
, section
->sh_offset
, 1,
6587 _("version need section"));
6588 endbuf
= (char *) eneed
+ section
->sh_size
;
6592 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
6594 Elf_External_Verneed
*entry
;
6595 Elf_Internal_Verneed ent
;
6600 vstart
= ((char *) eneed
) + idx
;
6601 if (vstart
+ sizeof (*entry
) > endbuf
)
6604 entry
= (Elf_External_Verneed
*) vstart
;
6606 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
6607 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
6608 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
6609 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
6610 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
6612 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
6614 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
6615 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
6617 printf (_(" File: %lx"), ent
.vn_file
);
6619 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
6621 vstart
+= ent
.vn_aux
;
6623 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
6625 Elf_External_Vernaux
*eaux
;
6626 Elf_Internal_Vernaux aux
;
6628 if (vstart
+ sizeof (*eaux
) > endbuf
)
6630 eaux
= (Elf_External_Vernaux
*) vstart
;
6632 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
6633 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
6634 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
6635 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
6636 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
6638 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
6639 printf (_(" %#06x: Name: %s"),
6640 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
6642 printf (_(" %#06x: Name index: %lx"),
6643 isum
, aux
.vna_name
);
6645 printf (_(" Flags: %s Version: %d\n"),
6646 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
6648 isum
+= aux
.vna_next
;
6649 vstart
+= aux
.vna_next
;
6652 printf (_(" Version need aux past end of section\n"));
6656 if (cnt
< section
->sh_info
)
6657 printf (_(" Version need past end of section\n"));
6663 case SHT_GNU_versym
:
6665 Elf_Internal_Shdr
*link_section
;
6668 unsigned char *edata
;
6669 unsigned short *data
;
6671 Elf_Internal_Sym
*symbols
;
6672 Elf_Internal_Shdr
*string_sec
;
6675 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
6678 link_section
= SECTION_HEADER (section
->sh_link
);
6679 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
6681 if (SECTION_HEADER_INDEX (link_section
->sh_link
)
6682 >= elf_header
.e_shnum
)
6687 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
6689 string_sec
= SECTION_HEADER (link_section
->sh_link
);
6691 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
6692 string_sec
->sh_size
, _("version string table"));
6696 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6697 SECTION_NAME (section
), total
);
6699 printf (_(" Addr: "));
6700 printf_vma (section
->sh_addr
);
6701 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6702 (unsigned long) section
->sh_offset
, section
->sh_link
,
6703 SECTION_NAME (link_section
));
6705 off
= offset_from_vma (file
,
6706 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
6707 total
* sizeof (short));
6708 edata
= get_data (NULL
, file
, off
, total
, sizeof (short),
6709 _("version symbol data"));
6716 data
= cmalloc (total
, sizeof (short));
6718 for (cnt
= total
; cnt
--;)
6719 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
6724 for (cnt
= 0; cnt
< total
; cnt
+= 4)
6727 int check_def
, check_need
;
6730 printf (" %03x:", cnt
);
6732 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
6733 switch (data
[cnt
+ j
])
6736 fputs (_(" 0 (*local*) "), stdout
);
6740 fputs (_(" 1 (*global*) "), stdout
);
6744 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
6745 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
6749 if (SECTION_HEADER_INDEX (symbols
[cnt
+ j
].st_shndx
)
6750 >= elf_header
.e_shnum
6751 || SECTION_HEADER (symbols
[cnt
+ j
].st_shndx
)->sh_type
6754 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
6761 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
6763 Elf_Internal_Verneed ivn
;
6764 unsigned long offset
;
6766 offset
= offset_from_vma
6767 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
6768 sizeof (Elf_External_Verneed
));
6772 Elf_Internal_Vernaux ivna
;
6773 Elf_External_Verneed evn
;
6774 Elf_External_Vernaux evna
;
6775 unsigned long a_off
;
6777 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
6780 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
6781 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
6783 a_off
= offset
+ ivn
.vn_aux
;
6787 get_data (&evna
, file
, a_off
, sizeof (evna
),
6788 1, _("version need aux (2)"));
6790 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
6791 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
6793 a_off
+= ivna
.vna_next
;
6795 while (ivna
.vna_other
!= data
[cnt
+ j
]
6796 && ivna
.vna_next
!= 0);
6798 if (ivna
.vna_other
== data
[cnt
+ j
])
6800 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
6802 if (ivna
.vna_name
>= string_sec
->sh_size
)
6803 name
= _("*invalid*");
6805 name
= strtab
+ ivna
.vna_name
;
6806 nn
+= printf ("(%s%-*s",
6808 12 - (int) strlen (name
),
6814 offset
+= ivn
.vn_next
;
6816 while (ivn
.vn_next
);
6819 if (check_def
&& data
[cnt
+ j
] != 0x8001
6820 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
6822 Elf_Internal_Verdef ivd
;
6823 Elf_External_Verdef evd
;
6824 unsigned long offset
;
6826 offset
= offset_from_vma
6827 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
6832 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
6835 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
6836 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
6838 offset
+= ivd
.vd_next
;
6840 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
6841 && ivd
.vd_next
!= 0);
6843 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
6845 Elf_External_Verdaux evda
;
6846 Elf_Internal_Verdaux ivda
;
6848 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
6850 get_data (&evda
, file
,
6851 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
6853 _("version def aux"));
6855 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
6857 if (ivda
.vda_name
>= string_sec
->sh_size
)
6858 name
= _("*invalid*");
6860 name
= strtab
+ ivda
.vda_name
;
6861 nn
+= printf ("(%s%-*s",
6863 12 - (int) strlen (name
),
6869 printf ("%*c", 18 - nn
, ' ');
6887 printf (_("\nNo version information found in this file.\n"));
6893 get_symbol_binding (unsigned int binding
)
6895 static char buff
[32];
6899 case STB_LOCAL
: return "LOCAL";
6900 case STB_GLOBAL
: return "GLOBAL";
6901 case STB_WEAK
: return "WEAK";
6903 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
6904 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
6906 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
6907 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
6909 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
6915 get_symbol_type (unsigned int type
)
6917 static char buff
[32];
6921 case STT_NOTYPE
: return "NOTYPE";
6922 case STT_OBJECT
: return "OBJECT";
6923 case STT_FUNC
: return "FUNC";
6924 case STT_SECTION
: return "SECTION";
6925 case STT_FILE
: return "FILE";
6926 case STT_COMMON
: return "COMMON";
6927 case STT_TLS
: return "TLS";
6928 case STT_RELC
: return "RELC";
6929 case STT_SRELC
: return "SRELC";
6931 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
6933 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
6934 return "THUMB_FUNC";
6936 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
6939 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
6940 return "PARISC_MILLI";
6942 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
6944 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
6946 if (elf_header
.e_machine
== EM_PARISC
)
6948 if (type
== STT_HP_OPAQUE
)
6950 if (type
== STT_HP_STUB
)
6954 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
6957 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
6963 get_symbol_visibility (unsigned int visibility
)
6967 case STV_DEFAULT
: return "DEFAULT";
6968 case STV_INTERNAL
: return "INTERNAL";
6969 case STV_HIDDEN
: return "HIDDEN";
6970 case STV_PROTECTED
: return "PROTECTED";
6976 get_mips_symbol_other (unsigned int other
)
6980 case STO_OPTIONAL
: return "OPTIONAL";
6981 case STO_MIPS16
: return "MIPS16";
6982 default: return NULL
;
6987 get_symbol_other (unsigned int other
)
6989 const char * result
= NULL
;
6990 static char buff
[32];
6995 switch (elf_header
.e_machine
)
6998 result
= get_mips_symbol_other (other
);
7006 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
7011 get_symbol_index_type (unsigned int type
)
7013 static char buff
[32];
7017 case SHN_UNDEF
: return "UND";
7018 case SHN_ABS
: return "ABS";
7019 case SHN_COMMON
: return "COM";
7021 if (type
== SHN_IA_64_ANSI_COMMON
7022 && elf_header
.e_machine
== EM_IA_64
7023 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
7025 else if (elf_header
.e_machine
== EM_X86_64
7026 && type
== SHN_X86_64_LCOMMON
)
7028 else if (type
== SHN_MIPS_SCOMMON
7029 && elf_header
.e_machine
== EM_MIPS
)
7031 else if (type
== SHN_MIPS_SUNDEFINED
7032 && elf_header
.e_machine
== EM_MIPS
)
7034 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
7035 sprintf (buff
, "PRC[0x%04x]", type
);
7036 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
7037 sprintf (buff
, "OS [0x%04x]", type
);
7038 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
7039 sprintf (buff
, "RSV[0x%04x]", type
);
7041 sprintf (buff
, "%3d", type
);
7049 get_dynamic_data (FILE *file
, unsigned int number
, unsigned int ent_size
)
7051 unsigned char *e_data
;
7054 e_data
= cmalloc (number
, ent_size
);
7058 error (_("Out of memory\n"));
7062 if (fread (e_data
, ent_size
, number
, file
) != number
)
7064 error (_("Unable to read in dynamic data\n"));
7068 i_data
= cmalloc (number
, sizeof (*i_data
));
7072 error (_("Out of memory\n"));
7078 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
7086 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
7088 Elf_Internal_Sym
*psym
;
7091 psym
= dynamic_symbols
+ si
;
7093 n
= print_vma (si
, DEC_5
);
7095 fputs (" " + n
, stdout
);
7096 printf (" %3lu: ", hn
);
7097 print_vma (psym
->st_value
, LONG_HEX
);
7099 print_vma (psym
->st_size
, DEC_5
);
7101 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7102 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7103 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7104 /* Check to see if any other bits in the st_other field are set.
7105 Note - displaying this information disrupts the layout of the
7106 table being generated, but for the moment this case is very
7108 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7109 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7110 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
7111 if (VALID_DYNAMIC_NAME (psym
->st_name
))
7112 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
7114 printf (" <corrupt: %14ld>", psym
->st_name
);
7118 /* Dump the symbol table. */
7120 process_symbol_table (FILE *file
)
7122 Elf_Internal_Shdr
*section
;
7123 bfd_vma nbuckets
= 0;
7124 bfd_vma nchains
= 0;
7125 bfd_vma
*buckets
= NULL
;
7126 bfd_vma
*chains
= NULL
;
7127 bfd_vma ngnubuckets
= 0;
7128 bfd_vma
*gnubuckets
= NULL
;
7129 bfd_vma
*gnuchains
= NULL
;
7130 bfd_vma gnusymidx
= 0;
7132 if (! do_syms
&& !do_histogram
)
7135 if (dynamic_info
[DT_HASH
]
7137 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7139 unsigned char nb
[8];
7140 unsigned char nc
[8];
7141 int hash_ent_size
= 4;
7143 if ((elf_header
.e_machine
== EM_ALPHA
7144 || elf_header
.e_machine
== EM_S390
7145 || elf_header
.e_machine
== EM_S390_OLD
)
7146 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
7150 (archive_file_offset
7151 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
7152 sizeof nb
+ sizeof nc
)),
7155 error (_("Unable to seek to start of dynamic information\n"));
7159 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
7161 error (_("Failed to read in number of buckets\n"));
7165 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
7167 error (_("Failed to read in number of chains\n"));
7171 nbuckets
= byte_get (nb
, hash_ent_size
);
7172 nchains
= byte_get (nc
, hash_ent_size
);
7174 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
7175 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
7177 if (buckets
== NULL
|| chains
== NULL
)
7181 if (dynamic_info_DT_GNU_HASH
7183 || (do_using_dynamic
&& dynamic_strings
!= NULL
)))
7185 unsigned char nb
[16];
7186 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
7187 bfd_vma buckets_vma
;
7190 (archive_file_offset
7191 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
7195 error (_("Unable to seek to start of dynamic information\n"));
7199 if (fread (nb
, 16, 1, file
) != 1)
7201 error (_("Failed to read in number of buckets\n"));
7205 ngnubuckets
= byte_get (nb
, 4);
7206 gnusymidx
= byte_get (nb
+ 4, 4);
7207 bitmaskwords
= byte_get (nb
+ 8, 4);
7208 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
7210 buckets_vma
+= bitmaskwords
* 4;
7212 buckets_vma
+= bitmaskwords
* 8;
7215 (archive_file_offset
7216 + offset_from_vma (file
, buckets_vma
, 4)),
7219 error (_("Unable to seek to start of dynamic information\n"));
7223 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
7225 if (gnubuckets
== NULL
)
7228 for (i
= 0; i
< ngnubuckets
; i
++)
7229 if (gnubuckets
[i
] != 0)
7231 if (gnubuckets
[i
] < gnusymidx
)
7234 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
7235 maxchain
= gnubuckets
[i
];
7238 if (maxchain
== 0xffffffff)
7241 maxchain
-= gnusymidx
;
7244 (archive_file_offset
7245 + offset_from_vma (file
, buckets_vma
7246 + 4 * (ngnubuckets
+ maxchain
), 4)),
7249 error (_("Unable to seek to start of dynamic information\n"));
7255 if (fread (nb
, 4, 1, file
) != 1)
7257 error (_("Failed to determine last chain length\n"));
7261 if (maxchain
+ 1 == 0)
7266 while ((byte_get (nb
, 4) & 1) == 0);
7269 (archive_file_offset
7270 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
7273 error (_("Unable to seek to start of dynamic information\n"));
7277 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
7279 if (gnuchains
== NULL
)
7283 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
7286 && dynamic_strings
!= NULL
)
7290 if (dynamic_info
[DT_HASH
])
7294 printf (_("\nSymbol table for image:\n"));
7296 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7298 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7300 for (hn
= 0; hn
< nbuckets
; hn
++)
7305 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
7306 print_dynamic_symbol (si
, hn
);
7310 if (dynamic_info_DT_GNU_HASH
)
7312 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7314 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7316 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7318 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7319 if (gnubuckets
[hn
] != 0)
7321 bfd_vma si
= gnubuckets
[hn
];
7322 bfd_vma off
= si
- gnusymidx
;
7326 print_dynamic_symbol (si
, hn
);
7329 while ((gnuchains
[off
++] & 1) == 0);
7333 else if (do_syms
&& !do_using_dynamic
)
7337 for (i
= 0, section
= section_headers
;
7338 i
< elf_header
.e_shnum
;
7342 char *strtab
= NULL
;
7343 unsigned long int strtab_size
= 0;
7344 Elf_Internal_Sym
*symtab
;
7345 Elf_Internal_Sym
*psym
;
7348 if ( section
->sh_type
!= SHT_SYMTAB
7349 && section
->sh_type
!= SHT_DYNSYM
)
7352 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7353 SECTION_NAME (section
),
7354 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
7356 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7358 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7360 symtab
= GET_ELF_SYMBOLS (file
, section
);
7364 if (section
->sh_link
== elf_header
.e_shstrndx
)
7366 strtab
= string_table
;
7367 strtab_size
= string_table_length
;
7369 else if (SECTION_HEADER_INDEX (section
->sh_link
) < elf_header
.e_shnum
)
7371 Elf_Internal_Shdr
*string_sec
;
7373 string_sec
= SECTION_HEADER (section
->sh_link
);
7375 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
,
7376 1, string_sec
->sh_size
, _("string table"));
7377 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
7380 for (si
= 0, psym
= symtab
;
7381 si
< section
->sh_size
/ section
->sh_entsize
;
7384 printf ("%6d: ", si
);
7385 print_vma (psym
->st_value
, LONG_HEX
);
7387 print_vma (psym
->st_size
, DEC_5
);
7388 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
7389 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
7390 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
7391 /* Check to see if any other bits in the st_other field are set.
7392 Note - displaying this information disrupts the layout of the
7393 table being generated, but for the moment this case is very rare. */
7394 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
7395 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
7396 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
7397 print_symbol (25, psym
->st_name
< strtab_size
7398 ? strtab
+ psym
->st_name
: "<corrupt>");
7400 if (section
->sh_type
== SHT_DYNSYM
&&
7401 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
7403 unsigned char data
[2];
7404 unsigned short vers_data
;
7405 unsigned long offset
;
7409 offset
= offset_from_vma
7410 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7411 sizeof data
+ si
* sizeof (vers_data
));
7413 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
7414 sizeof (data
), 1, _("version data"));
7416 vers_data
= byte_get (data
, 2);
7418 is_nobits
= (SECTION_HEADER_INDEX (psym
->st_shndx
)
7419 < elf_header
.e_shnum
7420 && SECTION_HEADER (psym
->st_shndx
)->sh_type
7423 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
7425 if ((vers_data
& 0x8000) || vers_data
> 1)
7427 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
7428 && (is_nobits
|| ! check_def
))
7430 Elf_External_Verneed evn
;
7431 Elf_Internal_Verneed ivn
;
7432 Elf_Internal_Vernaux ivna
;
7434 /* We must test both. */
7435 offset
= offset_from_vma
7436 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
7441 unsigned long vna_off
;
7443 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
7446 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
7447 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
7449 vna_off
= offset
+ ivn
.vn_aux
;
7453 Elf_External_Vernaux evna
;
7455 get_data (&evna
, file
, vna_off
,
7457 _("version need aux (3)"));
7459 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
7460 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
7461 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
7463 vna_off
+= ivna
.vna_next
;
7465 while (ivna
.vna_other
!= vers_data
7466 && ivna
.vna_next
!= 0);
7468 if (ivna
.vna_other
== vers_data
)
7471 offset
+= ivn
.vn_next
;
7473 while (ivn
.vn_next
!= 0);
7475 if (ivna
.vna_other
== vers_data
)
7478 ivna
.vna_name
< strtab_size
7479 ? strtab
+ ivna
.vna_name
: "<corrupt>",
7483 else if (! is_nobits
)
7484 error (_("bad dynamic symbol\n"));
7491 if (vers_data
!= 0x8001
7492 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
7494 Elf_Internal_Verdef ivd
;
7495 Elf_Internal_Verdaux ivda
;
7496 Elf_External_Verdaux evda
;
7497 unsigned long offset
;
7499 offset
= offset_from_vma
7501 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
7502 sizeof (Elf_External_Verdef
));
7506 Elf_External_Verdef evd
;
7508 get_data (&evd
, file
, offset
, sizeof (evd
),
7509 1, _("version def"));
7511 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
7512 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
7513 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
7515 offset
+= ivd
.vd_next
;
7517 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
7518 && ivd
.vd_next
!= 0);
7520 offset
-= ivd
.vd_next
;
7521 offset
+= ivd
.vd_aux
;
7523 get_data (&evda
, file
, offset
, sizeof (evda
),
7524 1, _("version def aux"));
7526 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
7528 if (psym
->st_name
!= ivda
.vda_name
)
7529 printf ((vers_data
& 0x8000)
7531 ivda
.vda_name
< strtab_size
7532 ? strtab
+ ivda
.vda_name
: "<corrupt>");
7542 if (strtab
!= string_table
)
7548 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7550 if (do_histogram
&& buckets
!= NULL
)
7552 unsigned long *lengths
;
7553 unsigned long *counts
;
7556 unsigned long maxlength
= 0;
7557 unsigned long nzero_counts
= 0;
7558 unsigned long nsyms
= 0;
7560 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7561 (unsigned long) nbuckets
);
7562 printf (_(" Length Number %% of total Coverage\n"));
7564 lengths
= calloc (nbuckets
, sizeof (*lengths
));
7565 if (lengths
== NULL
)
7567 error (_("Out of memory\n"));
7570 for (hn
= 0; hn
< nbuckets
; ++hn
)
7572 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
7575 if (maxlength
< ++lengths
[hn
])
7580 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7583 error (_("Out of memory\n"));
7587 for (hn
= 0; hn
< nbuckets
; ++hn
)
7588 ++counts
[lengths
[hn
]];
7593 printf (" 0 %-10lu (%5.1f%%)\n",
7594 counts
[0], (counts
[0] * 100.0) / nbuckets
);
7595 for (i
= 1; i
<= maxlength
; ++i
)
7597 nzero_counts
+= counts
[i
] * i
;
7598 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7599 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
7600 (nzero_counts
* 100.0) / nsyms
);
7608 if (buckets
!= NULL
)
7614 if (do_histogram
&& dynamic_info_DT_GNU_HASH
)
7616 unsigned long *lengths
;
7617 unsigned long *counts
;
7619 unsigned long maxlength
= 0;
7620 unsigned long nzero_counts
= 0;
7621 unsigned long nsyms
= 0;
7623 lengths
= calloc (ngnubuckets
, sizeof (*lengths
));
7624 if (lengths
== NULL
)
7626 error (_("Out of memory\n"));
7630 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7631 (unsigned long) ngnubuckets
);
7632 printf (_(" Length Number %% of total Coverage\n"));
7634 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7635 if (gnubuckets
[hn
] != 0)
7637 bfd_vma off
, length
= 1;
7639 for (off
= gnubuckets
[hn
] - gnusymidx
;
7640 (gnuchains
[off
] & 1) == 0; ++off
)
7642 lengths
[hn
] = length
;
7643 if (length
> maxlength
)
7648 counts
= calloc (maxlength
+ 1, sizeof (*counts
));
7651 error (_("Out of memory\n"));
7655 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
7656 ++counts
[lengths
[hn
]];
7658 if (ngnubuckets
> 0)
7661 printf (" 0 %-10lu (%5.1f%%)\n",
7662 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
7663 for (j
= 1; j
<= maxlength
; ++j
)
7665 nzero_counts
+= counts
[j
] * j
;
7666 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7667 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
7668 (nzero_counts
* 100.0) / nsyms
);
7682 process_syminfo (FILE *file ATTRIBUTE_UNUSED
)
7686 if (dynamic_syminfo
== NULL
7688 /* No syminfo, this is ok. */
7691 /* There better should be a dynamic symbol section. */
7692 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
7696 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7697 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
7699 printf (_(" Num: Name BoundTo Flags\n"));
7700 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
7702 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
7704 printf ("%4d: ", i
);
7705 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
7706 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
7708 printf ("<corrupt: %19ld>", dynamic_symbols
[i
].st_name
);
7711 switch (dynamic_syminfo
[i
].si_boundto
)
7713 case SYMINFO_BT_SELF
:
7714 fputs ("SELF ", stdout
);
7716 case SYMINFO_BT_PARENT
:
7717 fputs ("PARENT ", stdout
);
7720 if (dynamic_syminfo
[i
].si_boundto
> 0
7721 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
7722 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
7724 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
7728 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
7732 if (flags
& SYMINFO_FLG_DIRECT
)
7734 if (flags
& SYMINFO_FLG_PASSTHRU
)
7735 printf (" PASSTHRU");
7736 if (flags
& SYMINFO_FLG_COPY
)
7738 if (flags
& SYMINFO_FLG_LAZYLOAD
)
7739 printf (" LAZYLOAD");
7747 #ifdef SUPPORT_DISASSEMBLY
7749 disassemble_section (Elf_Internal_Shdr
*section
, FILE *file
)
7751 printf (_("\nAssembly dump of section %s\n"),
7752 SECTION_NAME (section
));
7754 /* XXX -- to be done --- XXX */
7761 dump_section_as_strings (Elf_Internal_Shdr
*section
, FILE *file
)
7763 Elf_Internal_Shdr
*relsec
;
7764 bfd_size_type num_bytes
;
7769 char *name
= SECTION_NAME (section
);
7770 bfd_boolean some_strings_shown
;
7772 num_bytes
= section
->sh_size
;
7774 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7776 printf (_("\nSection '%s' has no data to dump.\n"), name
);
7780 addr
= section
->sh_addr
;
7782 start
= get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
7787 printf (_("\nString dump of section '%s':\n"), name
);
7789 /* If the section being dumped has relocations against it the user might
7790 be expecting these relocations to have been applied. Check for this
7791 case and issue a warning message in order to avoid confusion.
7792 FIXME: Maybe we ought to have an option that dumps a section with
7794 for (relsec
= section_headers
;
7795 relsec
< section_headers
+ elf_header
.e_shnum
;
7798 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7799 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7800 || SECTION_HEADER (relsec
->sh_info
) != section
7801 || relsec
->sh_size
== 0
7802 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7805 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7810 end
= start
+ num_bytes
;
7811 some_strings_shown
= FALSE
;
7815 while (!ISPRINT (* data
))
7821 printf (" [%6tx] %s\n", data
- start
, data
);
7822 data
+= strlen (data
);
7823 some_strings_shown
= TRUE
;
7827 if (! some_strings_shown
)
7828 printf (_(" No strings found in this section."));
7838 dump_section_as_bytes (Elf_Internal_Shdr
*section
, FILE *file
)
7840 Elf_Internal_Shdr
*relsec
;
7841 bfd_size_type bytes
;
7843 unsigned char *data
;
7844 unsigned char *start
;
7846 bytes
= section
->sh_size
;
7848 if (bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
7850 printf (_("\nSection '%s' has no data to dump.\n"),
7851 SECTION_NAME (section
));
7855 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
7857 addr
= section
->sh_addr
;
7859 start
= get_data (NULL
, file
, section
->sh_offset
, 1, bytes
,
7864 /* If the section being dumped has relocations against it the user might
7865 be expecting these relocations to have been applied. Check for this
7866 case and issue a warning message in order to avoid confusion.
7867 FIXME: Maybe we ought to have an option that dumps a section with
7869 for (relsec
= section_headers
;
7870 relsec
< section_headers
+ elf_header
.e_shnum
;
7873 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
7874 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
7875 || SECTION_HEADER (relsec
->sh_info
) != section
7876 || relsec
->sh_size
== 0
7877 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
7880 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7892 lbytes
= (bytes
> 16 ? 16 : bytes
);
7894 printf (" 0x%8.8lx ", (unsigned long) addr
);
7896 for (j
= 0; j
< 16; j
++)
7899 printf ("%2.2x", data
[j
]);
7907 for (j
= 0; j
< lbytes
; j
++)
7910 if (k
>= ' ' && k
< 0x7f)
7929 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7930 DWARF debug sections. This is a target specific test. Note - we do not
7931 go through the whole including-target-headers-multiple-times route, (as
7932 we have already done with <elf/h8.h>) because this would become very
7933 messy and even then this function would have to contain target specific
7934 information (the names of the relocs instead of their numeric values).
7935 FIXME: This is not the correct way to solve this problem. The proper way
7936 is to have target specific reloc sizing and typing functions created by
7937 the reloc-macros.h header, in the same way that it already creates the
7938 reloc naming functions. */
7941 is_32bit_abs_reloc (unsigned int reloc_type
)
7943 switch (elf_header
.e_machine
)
7947 return reloc_type
== 1; /* R_386_32. */
7949 return reloc_type
== 1; /* R_68K_32. */
7951 return reloc_type
== 1; /* R_860_32. */
7953 return reloc_type
== 1; /* XXX Is this right ? */
7955 return reloc_type
== 1; /* R_ARC_32. */
7957 return reloc_type
== 2; /* R_ARM_ABS32 */
7960 return reloc_type
== 1;
7962 return reloc_type
== 0x12; /* R_byte4_data. */
7964 return reloc_type
== 3; /* R_CRIS_32. */
7966 return reloc_type
== 3; /* R_CR16_NUM32. */
7968 return reloc_type
== 15; /* R_CRX_NUM32. */
7970 return reloc_type
== 1;
7971 case EM_CYGNUS_D10V
:
7973 return reloc_type
== 6; /* R_D10V_32. */
7974 case EM_CYGNUS_D30V
:
7976 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
7978 return reloc_type
== 3; /* R_DLX_RELOC_32. */
7979 case EM_CYGNUS_FR30
:
7981 return reloc_type
== 3; /* R_FR30_32. */
7985 return reloc_type
== 1; /* R_H8_DIR32. */
7987 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
7990 return reloc_type
== 2; /* R_IP2K_32. */
7992 return reloc_type
== 2; /* R_IQ2000_32. */
7994 return reloc_type
== 3; /* R_M32C_32. */
7996 return reloc_type
== 34; /* R_M32R_32_RELA. */
7998 return reloc_type
== 1; /* R_MCORE_ADDR32. */
8000 return reloc_type
== 4; /* R_MEP_32. */
8002 return reloc_type
== 2; /* R_MIPS_32. */
8004 return reloc_type
== 4; /* R_MMIX_32. */
8005 case EM_CYGNUS_MN10200
:
8007 return reloc_type
== 1; /* R_MN10200_32. */
8008 case EM_CYGNUS_MN10300
:
8010 return reloc_type
== 1; /* R_MN10300_32. */
8013 return reloc_type
== 1; /* R_MSP43_32. */
8015 return reloc_type
== 2; /* R_MT_32. */
8016 case EM_ALTERA_NIOS2
:
8018 return reloc_type
== 1; /* R_NIOS_32. */
8021 return reloc_type
== 1; /* R_OR32_32. */
8023 return reloc_type
== 1; /* R_PARISC_DIR32. */
8026 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
8028 return reloc_type
== 1; /* R_PPC64_ADDR32. */
8030 return reloc_type
== 1; /* R_PPC_ADDR32. */
8032 return reloc_type
== 1; /* R_I370_ADDR31. */
8035 return reloc_type
== 4; /* R_S390_32. */
8037 return reloc_type
== 8; /* R_SCORE_ABS32. */
8039 return reloc_type
== 1; /* R_SH_DIR32. */
8040 case EM_SPARC32PLUS
:
8043 return reloc_type
== 3 /* R_SPARC_32. */
8044 || reloc_type
== 23; /* R_SPARC_UA32. */
8045 case EM_CYGNUS_V850
:
8047 return reloc_type
== 6; /* R_V850_ABS32. */
8049 return reloc_type
== 1; /* R_VAX_32. */
8051 return reloc_type
== 10; /* R_X86_64_32. */
8053 return reloc_type
== 1; /* R_XSTROMY16_32. */
8056 return reloc_type
== 1; /* R_XTENSA_32. */
8059 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8060 elf_header
.e_machine
);
8065 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8066 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8069 is_32bit_pcrel_reloc (unsigned int reloc_type
)
8071 switch (elf_header
.e_machine
)
8075 return reloc_type
== 2; /* R_386_PC32. */
8077 return reloc_type
== 4; /* R_68K_PC32. */
8079 return reloc_type
== 10; /* R_ALPHA_SREL32. */
8081 return reloc_type
== 3; /* R_ARM_REL32 */
8083 return reloc_type
== 0; /* R_PARISC_NONE. *//* FIXME: This reloc is generated, but it may be a bug. */
8085 return reloc_type
== 26; /* R_PPC_REL32. */
8087 return reloc_type
== 26; /* R_PPC64_REL32. */
8090 return reloc_type
== 5; /* R_390_PC32. */
8092 return reloc_type
== 2; /* R_SH_REL32. */
8093 case EM_SPARC32PLUS
:
8096 return reloc_type
== 6; /* R_SPARC_DISP32. */
8098 return reloc_type
== 2; /* R_X86_64_PC32. */
8100 /* Do not abort or issue an error message here. Not all targets use
8101 pc-relative 32-bit relocs in their DWARF debug information and we
8102 have already tested for target coverage in is_32bit_abs_reloc. A
8103 more helpful warning message will be generated by
8104 debug_apply_relocations anyway, so just return. */
8109 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8110 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8113 is_64bit_abs_reloc (unsigned int reloc_type
)
8115 switch (elf_header
.e_machine
)
8118 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
8120 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
8122 return reloc_type
== 80; /* R_PARISC_DIR64. */
8124 return reloc_type
== 38; /* R_PPC64_ADDR64. */
8125 case EM_SPARC32PLUS
:
8128 return reloc_type
== 54; /* R_SPARC_UA64. */
8130 return reloc_type
== 1; /* R_X86_64_64. */
8136 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8137 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8140 is_16bit_abs_reloc (unsigned int reloc_type
)
8142 switch (elf_header
.e_machine
)
8146 return reloc_type
== 4; /* R_AVR_16. */
8147 case EM_CYGNUS_D10V
:
8149 return reloc_type
== 3; /* R_D10V_16. */
8153 return reloc_type
== R_H8_DIR16
;
8156 return reloc_type
== 1; /* R_IP2K_16. */
8159 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
8160 case EM_ALTERA_NIOS2
:
8162 return reloc_type
== 9; /* R_NIOS_16. */
8168 /* Apply relocations to a debug section. */
8171 debug_apply_relocations (void *file
,
8172 Elf_Internal_Shdr
*section
,
8173 unsigned char *start
)
8175 Elf_Internal_Shdr
*relsec
;
8176 unsigned char *end
= start
+ section
->sh_size
;
8178 if (elf_header
.e_type
!= ET_REL
)
8181 /* Find the reloc section associated with the debug section. */
8182 for (relsec
= section_headers
;
8183 relsec
< section_headers
+ elf_header
.e_shnum
;
8186 bfd_boolean is_rela
;
8187 unsigned long num_relocs
;
8188 Elf_Internal_Rela
*relocs
, *rp
;
8189 Elf_Internal_Shdr
*symsec
;
8190 Elf_Internal_Sym
*symtab
;
8191 Elf_Internal_Sym
*sym
;
8193 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
8194 || SECTION_HEADER_INDEX (relsec
->sh_info
) >= elf_header
.e_shnum
8195 || SECTION_HEADER (relsec
->sh_info
) != section
8196 || relsec
->sh_size
== 0
8197 || SECTION_HEADER_INDEX (relsec
->sh_link
) >= elf_header
.e_shnum
)
8200 is_rela
= relsec
->sh_type
== SHT_RELA
;
8204 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8205 & relocs
, & num_relocs
))
8210 if (!slurp_rel_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
8211 & relocs
, & num_relocs
))
8215 /* SH uses RELA but uses in place value instead of the addend field. */
8216 if (elf_header
.e_machine
== EM_SH
)
8219 symsec
= SECTION_HEADER (relsec
->sh_link
);
8220 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
8222 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
8225 unsigned int reloc_type
;
8226 unsigned int reloc_size
;
8227 unsigned char * loc
;
8229 /* In MIPS little-endian objects, r_info isn't really a
8230 64-bit little-endian value: it has a 32-bit little-endian
8231 symbol index followed by four individual byte fields.
8232 Reorder INFO accordingly. */
8234 && elf_header
.e_machine
== EM_MIPS
8235 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
8236 rp
->r_info
= (((rp
->r_info
& 0xffffffff) << 32)
8237 | ((rp
->r_info
>> 56) & 0xff)
8238 | ((rp
->r_info
>> 40) & 0xff00)
8239 | ((rp
->r_info
>> 24) & 0xff0000)
8240 | ((rp
->r_info
>> 8) & 0xff000000));
8242 reloc_type
= get_reloc_type (rp
->r_info
);
8244 if (is_32bit_abs_reloc (reloc_type
)
8245 || is_32bit_pcrel_reloc (reloc_type
))
8247 else if (is_64bit_abs_reloc (reloc_type
))
8249 else if (is_16bit_abs_reloc (reloc_type
))
8253 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8254 reloc_type
, SECTION_NAME (section
));
8258 loc
= start
+ rp
->r_offset
;
8259 if ((loc
+ reloc_size
) > end
)
8261 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8262 (unsigned long) rp
->r_offset
,
8263 SECTION_NAME (section
));
8267 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
8269 /* If the reloc has a symbol associated with it,
8270 make sure that it is of an appropriate type. */
8272 && ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
8273 /* Relocations against symbols without type can happen.
8274 Gcc -feliminate-dwarf2-dups may generate symbols
8275 without type for debug info. */
8276 && ELF_ST_TYPE (sym
->st_info
) != STT_NOTYPE
8277 /* Relocations against object symbols can happen,
8278 eg when referencing a global array. For an
8279 example of this see the _clz.o binary in libgcc.a. */
8280 && ELF_ST_TYPE (sym
->st_info
) != STT_OBJECT
)
8282 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8283 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
8284 (long int)(rp
- relocs
),
8285 SECTION_NAME (relsec
));
8289 addend
= is_rela
? rp
->r_addend
: byte_get (loc
, reloc_size
);
8291 if (is_32bit_pcrel_reloc (reloc_type
))
8292 byte_put (loc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
8295 byte_put (loc
, addend
+ sym
->st_value
, reloc_size
);
8305 load_debug_section (enum dwarf_section_display_enum debug
, void *file
)
8307 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8308 Elf_Internal_Shdr
*sec
;
8311 /* If it is already loaded, do nothing. */
8312 if (section
->start
!= NULL
)
8315 /* Locate the debug section. */
8316 sec
= find_section (section
->name
);
8320 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
8321 section
->address
= sec
->sh_addr
;
8322 section
->size
= sec
->sh_size
;
8323 section
->start
= get_data (NULL
, file
, sec
->sh_offset
, 1,
8326 if (debug_displays
[debug
].relocate
)
8327 debug_apply_relocations (file
, sec
, section
->start
);
8329 return section
->start
!= NULL
;
8333 free_debug_section (enum dwarf_section_display_enum debug
)
8335 struct dwarf_section
*section
= &debug_displays
[debug
].section
;
8337 if (section
->start
== NULL
)
8340 free ((char *) section
->start
);
8341 section
->start
= NULL
;
8342 section
->address
= 0;
8347 display_debug_section (Elf_Internal_Shdr
*section
, FILE *file
)
8349 char *name
= SECTION_NAME (section
);
8350 bfd_size_type length
;
8352 enum dwarf_section_display_enum i
;
8354 length
= section
->sh_size
;
8357 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8361 if (const_strneq (name
, ".gnu.linkonce.wi."))
8362 name
= ".debug_info";
8364 /* See if we know how to display the contents of this section. */
8365 for (i
= 0; i
< max
; i
++)
8366 if (streq (debug_displays
[i
].section
.name
, name
))
8368 struct dwarf_section
*sec
= &debug_displays
[i
].section
;
8370 if (load_debug_section (i
, file
))
8372 result
&= debug_displays
[i
].display (sec
, file
);
8374 if (i
!= info
&& i
!= abbrev
)
8375 free_debug_section (i
);
8383 printf (_("Unrecognized debug section: %s\n"), name
);
8390 /* Set DUMP_SECTS for all sections where dumps were requested
8391 based on section name. */
8394 initialise_dumps_byname (void)
8396 struct dump_list_entry
*cur
;
8398 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
8403 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
8404 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
8406 request_dump_bynumber (i
, cur
->type
);
8411 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8417 process_section_contents (FILE *file
)
8419 Elf_Internal_Shdr
*section
;
8425 initialise_dumps_byname ();
8427 for (i
= 0, section
= section_headers
;
8428 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8431 #ifdef SUPPORT_DISASSEMBLY
8432 if (dump_sects
[i
] & DISASS_DUMP
)
8433 disassemble_section (section
, file
);
8435 if (dump_sects
[i
] & HEX_DUMP
)
8436 dump_section_as_bytes (section
, file
);
8438 if (dump_sects
[i
] & DEBUG_DUMP
)
8439 display_debug_section (section
, file
);
8441 if (dump_sects
[i
] & STRING_DUMP
)
8442 dump_section_as_strings (section
, file
);
8445 /* Check to see if the user requested a
8446 dump of a section that does not exist. */
8447 while (i
++ < num_dump_sects
)
8449 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
8453 process_mips_fpe_exception (int mask
)
8458 if (mask
& OEX_FPU_INEX
)
8459 fputs ("INEX", stdout
), first
= 0;
8460 if (mask
& OEX_FPU_UFLO
)
8461 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8462 if (mask
& OEX_FPU_OFLO
)
8463 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8464 if (mask
& OEX_FPU_DIV0
)
8465 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8466 if (mask
& OEX_FPU_INVAL
)
8467 printf ("%sINVAL", first
? "" : "|");
8470 fputs ("0", stdout
);
8473 /* ARM EABI attributes section. */
8478 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8481 } arm_attr_public_tag
;
8483 static const char *arm_attr_tag_CPU_arch
[] =
8484 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8486 static const char *arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
8487 static const char *arm_attr_tag_THUMB_ISA_use
[] =
8488 {"No", "Thumb-1", "Thumb-2"};
8489 /* FIXME: VFPv3 encoding was extrapolated! */
8490 static const char *arm_attr_tag_VFP_arch
[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8491 static const char *arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1"};
8492 static const char *arm_attr_tag_NEON_arch
[] = {"No", "NEONv1"};
8493 static const char *arm_attr_tag_ABI_PCS_config
[] =
8494 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8495 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8496 static const char *arm_attr_tag_ABI_PCS_R9_use
[] =
8497 {"V6", "SB", "TLS", "Unused"};
8498 static const char *arm_attr_tag_ABI_PCS_RW_data
[] =
8499 {"Absolute", "PC-relative", "SB-relative", "None"};
8500 static const char *arm_attr_tag_ABI_PCS_RO_DATA
[] =
8501 {"Absolute", "PC-relative", "None"};
8502 static const char *arm_attr_tag_ABI_PCS_GOT_use
[] =
8503 {"None", "direct", "GOT-indirect"};
8504 static const char *arm_attr_tag_ABI_PCS_wchar_t
[] =
8505 {"None", "??? 1", "2", "??? 3", "4"};
8506 static const char *arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
8507 static const char *arm_attr_tag_ABI_FP_denormal
[] = {"Unused", "Needed"};
8508 static const char *arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
8509 static const char *arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
8510 static const char *arm_attr_tag_ABI_FP_number_model
[] =
8511 {"Unused", "Finite", "RTABI", "IEEE 754"};
8512 static const char *arm_attr_tag_ABI_align8_needed
[] = {"No", "Yes", "4-byte"};
8513 static const char *arm_attr_tag_ABI_align8_preserved
[] =
8514 {"No", "Yes, except leaf SP", "Yes"};
8515 static const char *arm_attr_tag_ABI_enum_size
[] =
8516 {"Unused", "small", "int", "forced to int"};
8517 static const char *arm_attr_tag_ABI_HardFP_use
[] =
8518 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8519 static const char *arm_attr_tag_ABI_VFP_args
[] =
8520 {"AAPCS", "VFP registers", "custom"};
8521 static const char *arm_attr_tag_ABI_WMMX_args
[] =
8522 {"AAPCS", "WMMX registers", "custom"};
8523 static const char *arm_attr_tag_ABI_optimization_goals
[] =
8524 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8525 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8526 static const char *arm_attr_tag_ABI_FP_optimization_goals
[] =
8527 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8528 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8530 #define LOOKUP(id, name) \
8531 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8532 static arm_attr_public_tag arm_attr_public_tags
[] =
8534 {4, "CPU_raw_name", 1, NULL
},
8535 {5, "CPU_name", 1, NULL
},
8536 LOOKUP(6, CPU_arch
),
8537 {7, "CPU_arch_profile", 0, NULL
},
8538 LOOKUP(8, ARM_ISA_use
),
8539 LOOKUP(9, THUMB_ISA_use
),
8540 LOOKUP(10, VFP_arch
),
8541 LOOKUP(11, WMMX_arch
),
8542 LOOKUP(12, NEON_arch
),
8543 LOOKUP(13, ABI_PCS_config
),
8544 LOOKUP(14, ABI_PCS_R9_use
),
8545 LOOKUP(15, ABI_PCS_RW_data
),
8546 LOOKUP(16, ABI_PCS_RO_DATA
),
8547 LOOKUP(17, ABI_PCS_GOT_use
),
8548 LOOKUP(18, ABI_PCS_wchar_t
),
8549 LOOKUP(19, ABI_FP_rounding
),
8550 LOOKUP(20, ABI_FP_denormal
),
8551 LOOKUP(21, ABI_FP_exceptions
),
8552 LOOKUP(22, ABI_FP_user_exceptions
),
8553 LOOKUP(23, ABI_FP_number_model
),
8554 LOOKUP(24, ABI_align8_needed
),
8555 LOOKUP(25, ABI_align8_preserved
),
8556 LOOKUP(26, ABI_enum_size
),
8557 LOOKUP(27, ABI_HardFP_use
),
8558 LOOKUP(28, ABI_VFP_args
),
8559 LOOKUP(29, ABI_WMMX_args
),
8560 LOOKUP(30, ABI_optimization_goals
),
8561 LOOKUP(31, ABI_FP_optimization_goals
),
8562 {32, "compatibility", 0, NULL
}
8566 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8569 read_uleb128 (unsigned char *p
, unsigned int *plen
)
8583 val
|= ((unsigned int)c
& 0x7f) << shift
;
8592 static unsigned char *
8593 display_arm_attribute (unsigned char *p
)
8598 arm_attr_public_tag
*attr
;
8602 tag
= read_uleb128 (p
, &len
);
8605 for (i
= 0; i
< ARRAY_SIZE(arm_attr_public_tags
); i
++)
8607 if (arm_attr_public_tags
[i
].tag
== tag
)
8609 attr
= &arm_attr_public_tags
[i
];
8616 printf (" Tag_%s: ", attr
->name
);
8622 case 7: /* Tag_CPU_arch_profile. */
8623 val
= read_uleb128 (p
, &len
);
8627 case 0: printf ("None\n"); break;
8628 case 'A': printf ("Application\n"); break;
8629 case 'R': printf ("Realtime\n"); break;
8630 case 'M': printf ("Microcontroller\n"); break;
8631 default: printf ("??? (%d)\n", val
); break;
8635 case 32: /* Tag_compatibility. */
8636 val
= read_uleb128 (p
, &len
);
8638 printf ("flag = %d, vendor = %s\n", val
, p
);
8639 p
+= strlen((char *)p
) + 1;
8653 assert (attr
->type
& 0x80);
8654 val
= read_uleb128 (p
, &len
);
8656 type
= attr
->type
& 0x7f;
8658 printf ("??? (%d)\n", val
);
8660 printf ("%s\n", attr
->table
[val
]);
8667 type
= 1; /* String. */
8669 type
= 2; /* uleb128. */
8670 printf (" Tag_unknown_%d: ", tag
);
8675 printf ("\"%s\"\n", p
);
8676 p
+= strlen((char *)p
) + 1;
8680 val
= read_uleb128 (p
, &len
);
8682 printf ("%d (0x%x)\n", val
, val
);
8688 static unsigned char *
8689 display_gnu_attribute (unsigned char * p
,
8690 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8697 tag
= read_uleb128 (p
, &len
);
8700 /* Tag_compatibility is the only generic GNU attribute defined at
8704 val
= read_uleb128 (p
, &len
);
8706 printf ("flag = %d, vendor = %s\n", val
, p
);
8707 p
+= strlen ((char *) p
) + 1;
8711 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
8712 return display_proc_gnu_attribute (p
, tag
);
8715 type
= 1; /* String. */
8717 type
= 2; /* uleb128. */
8718 printf (" Tag_unknown_%d: ", tag
);
8722 printf ("\"%s\"\n", p
);
8723 p
+= strlen ((char *) p
) + 1;
8727 val
= read_uleb128 (p
, &len
);
8729 printf ("%d (0x%x)\n", val
, val
);
8735 static unsigned char *
8736 display_power_gnu_attribute (unsigned char *p
, int tag
)
8742 if (tag
== Tag_GNU_Power_ABI_FP
)
8744 val
= read_uleb128 (p
, &len
);
8746 printf (" Tag_GNU_Power_ABI_FP: ");
8751 printf ("Hard or soft float\n");
8754 printf ("Hard float\n");
8757 printf ("Soft float\n");
8760 printf ("??? (%d)\n", val
);
8766 if (tag
== Tag_GNU_Power_ABI_Vector
)
8768 val
= read_uleb128 (p
, &len
);
8770 printf (" Tag_GNU_Power_ABI_Vector: ");
8777 printf ("Generic\n");
8780 printf ("AltiVec\n");
8786 printf ("??? (%d)\n", val
);
8793 type
= 1; /* String. */
8795 type
= 2; /* uleb128. */
8796 printf (" Tag_unknown_%d: ", tag
);
8800 printf ("\"%s\"\n", p
);
8801 p
+= strlen ((char *) p
) + 1;
8805 val
= read_uleb128 (p
, &len
);
8807 printf ("%d (0x%x)\n", val
, val
);
8813 static unsigned char *
8814 display_mips_gnu_attribute (unsigned char *p
, int tag
)
8820 if (tag
== Tag_GNU_MIPS_ABI_FP
)
8822 val
= read_uleb128 (p
, &len
);
8824 printf (" Tag_GNU_MIPS_ABI_FP: ");
8829 printf ("Hard or soft float\n");
8832 printf ("Hard float (-mdouble-float)\n");
8835 printf ("Hard float (-msingle-float)\n");
8838 printf ("Soft float\n");
8841 printf ("64-bit float (-mips32r2 -mfp64)\n");
8844 printf ("??? (%d)\n", val
);
8851 type
= 1; /* String. */
8853 type
= 2; /* uleb128. */
8854 printf (" Tag_unknown_%d: ", tag
);
8858 printf ("\"%s\"\n", p
);
8859 p
+= strlen ((char *) p
) + 1;
8863 val
= read_uleb128 (p
, &len
);
8865 printf ("%d (0x%x)\n", val
, val
);
8872 process_attributes (FILE * file
,
8873 const char * public_name
,
8874 unsigned int proc_type
,
8875 unsigned char * (* display_pub_attribute
) (unsigned char *),
8876 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
8878 Elf_Internal_Shdr
*sect
;
8879 unsigned char *contents
;
8882 bfd_vma section_len
;
8886 /* Find the section header so that we get the size. */
8887 for (i
= 0, sect
= section_headers
;
8888 i
< elf_header
.e_shnum
;
8891 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
8894 contents
= get_data (NULL
, file
, sect
->sh_offset
, 1, sect
->sh_size
,
8896 if (contents
== NULL
)
8902 len
= sect
->sh_size
- 1;
8908 bfd_boolean public_section
;
8909 bfd_boolean gnu_section
;
8911 section_len
= byte_get (p
, 4);
8914 if (section_len
> len
)
8916 printf (_("ERROR: Bad section length (%d > %d)\n"),
8917 (int) section_len
, (int) len
);
8922 printf ("Attribute Section: %s\n", p
);
8924 if (public_name
&& streq ((char *) p
, public_name
))
8925 public_section
= TRUE
;
8927 public_section
= FALSE
;
8929 if (streq ((char *) p
, "gnu"))
8932 gnu_section
= FALSE
;
8934 namelen
= strlen ((char *) p
) + 1;
8936 section_len
-= namelen
+ 4;
8938 while (section_len
> 0)
8944 size
= byte_get (p
, 4);
8945 if (size
> section_len
)
8947 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8948 (int) size
, (int) section_len
);
8952 section_len
-= size
;
8959 printf ("File Attributes\n");
8962 printf ("Section Attributes:");
8965 printf ("Symbol Attributes:");
8971 val
= read_uleb128 (p
, &i
);
8975 printf (" %d", val
);
8980 printf ("Unknown tag: %d\n", tag
);
8981 public_section
= FALSE
;
8988 p
= display_pub_attribute (p
);
8990 else if (gnu_section
)
8993 p
= display_gnu_attribute (p
,
8994 display_proc_gnu_attribute
);
8998 /* ??? Do something sensible, like dump hex. */
8999 printf (" Unknown section contexts\n");
9006 printf (_("Unknown format '%c'\n"), *p
);
9014 process_arm_specific (FILE *file
)
9016 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
9017 display_arm_attribute
, NULL
);
9021 process_power_specific (FILE *file
)
9023 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9024 display_power_gnu_attribute
);
9028 process_mips_specific (FILE *file
)
9030 Elf_Internal_Dyn
*entry
;
9031 size_t liblist_offset
= 0;
9032 size_t liblistno
= 0;
9033 size_t conflictsno
= 0;
9034 size_t options_offset
= 0;
9035 size_t conflicts_offset
= 0;
9037 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
9038 display_mips_gnu_attribute
);
9040 /* We have a lot of special sections. Thanks SGI! */
9041 if (dynamic_section
== NULL
)
9042 /* No information available. */
9045 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
9046 switch (entry
->d_tag
)
9048 case DT_MIPS_LIBLIST
:
9050 = offset_from_vma (file
, entry
->d_un
.d_val
,
9051 liblistno
* sizeof (Elf32_External_Lib
));
9053 case DT_MIPS_LIBLISTNO
:
9054 liblistno
= entry
->d_un
.d_val
;
9056 case DT_MIPS_OPTIONS
:
9057 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9059 case DT_MIPS_CONFLICT
:
9061 = offset_from_vma (file
, entry
->d_un
.d_val
,
9062 conflictsno
* sizeof (Elf32_External_Conflict
));
9064 case DT_MIPS_CONFLICTNO
:
9065 conflictsno
= entry
->d_un
.d_val
;
9071 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
9073 Elf32_External_Lib
*elib
;
9076 elib
= get_data (NULL
, file
, liblist_offset
,
9077 liblistno
, sizeof (Elf32_External_Lib
),
9081 printf ("\nSection '.liblist' contains %lu entries:\n",
9082 (unsigned long) liblistno
);
9083 fputs (" Library Time Stamp Checksum Version Flags\n",
9086 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
9093 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9094 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9095 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9096 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9097 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9099 tmp
= gmtime (&time
);
9100 snprintf (timebuf
, sizeof (timebuf
),
9101 "%04u-%02u-%02uT%02u:%02u:%02u",
9102 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9103 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9105 printf ("%3lu: ", (unsigned long) cnt
);
9106 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
9107 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
9109 printf ("<corrupt: %9ld>", liblist
.l_name
);
9110 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
9113 if (liblist
.l_flags
== 0)
9124 { " EXACT_MATCH", LL_EXACT_MATCH
},
9125 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
9126 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
9127 { " EXPORTS", LL_EXPORTS
},
9128 { " DELAY_LOAD", LL_DELAY_LOAD
},
9129 { " DELTA", LL_DELTA
}
9131 int flags
= liblist
.l_flags
;
9134 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
9135 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
9137 fputs (l_flags_vals
[fcnt
].name
, stdout
);
9138 flags
^= l_flags_vals
[fcnt
].bit
;
9141 printf (" %#x", (unsigned int) flags
);
9151 if (options_offset
!= 0)
9153 Elf_External_Options
*eopt
;
9154 Elf_Internal_Shdr
*sect
= section_headers
;
9155 Elf_Internal_Options
*iopt
;
9156 Elf_Internal_Options
*option
;
9160 /* Find the section header so that we get the size. */
9161 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
9164 eopt
= get_data (NULL
, file
, options_offset
, 1, sect
->sh_size
,
9168 iopt
= cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (*iopt
));
9171 error (_("Out of memory\n"));
9178 while (offset
< sect
->sh_size
)
9180 Elf_External_Options
*eoption
;
9182 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
9184 option
->kind
= BYTE_GET (eoption
->kind
);
9185 option
->size
= BYTE_GET (eoption
->size
);
9186 option
->section
= BYTE_GET (eoption
->section
);
9187 option
->info
= BYTE_GET (eoption
->info
);
9189 offset
+= option
->size
;
9195 printf (_("\nSection '%s' contains %d entries:\n"),
9196 SECTION_NAME (sect
), cnt
);
9204 switch (option
->kind
)
9207 /* This shouldn't happen. */
9208 printf (" NULL %d %lx", option
->section
, option
->info
);
9211 printf (" REGINFO ");
9212 if (elf_header
.e_machine
== EM_MIPS
)
9215 Elf32_External_RegInfo
*ereg
;
9216 Elf32_RegInfo reginfo
;
9218 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
9219 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9220 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9221 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9222 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9223 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9224 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9226 printf ("GPR %08lx GP 0x%lx\n",
9228 (unsigned long) reginfo
.ri_gp_value
);
9229 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9230 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9231 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9236 Elf64_External_RegInfo
*ereg
;
9237 Elf64_Internal_RegInfo reginfo
;
9239 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
9240 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
9241 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
9242 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
9243 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
9244 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
9245 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
9247 printf ("GPR %08lx GP 0x",
9248 reginfo
.ri_gprmask
);
9249 printf_vma (reginfo
.ri_gp_value
);
9252 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9253 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
9254 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
9258 case ODK_EXCEPTIONS
:
9259 fputs (" EXCEPTIONS fpe_min(", stdout
);
9260 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
9261 fputs (") fpe_max(", stdout
);
9262 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
9263 fputs (")", stdout
);
9265 if (option
->info
& OEX_PAGE0
)
9266 fputs (" PAGE0", stdout
);
9267 if (option
->info
& OEX_SMM
)
9268 fputs (" SMM", stdout
);
9269 if (option
->info
& OEX_FPDBUG
)
9270 fputs (" FPDBUG", stdout
);
9271 if (option
->info
& OEX_DISMISS
)
9272 fputs (" DISMISS", stdout
);
9275 fputs (" PAD ", stdout
);
9276 if (option
->info
& OPAD_PREFIX
)
9277 fputs (" PREFIX", stdout
);
9278 if (option
->info
& OPAD_POSTFIX
)
9279 fputs (" POSTFIX", stdout
);
9280 if (option
->info
& OPAD_SYMBOL
)
9281 fputs (" SYMBOL", stdout
);
9284 fputs (" HWPATCH ", stdout
);
9285 if (option
->info
& OHW_R4KEOP
)
9286 fputs (" R4KEOP", stdout
);
9287 if (option
->info
& OHW_R8KPFETCH
)
9288 fputs (" R8KPFETCH", stdout
);
9289 if (option
->info
& OHW_R5KEOP
)
9290 fputs (" R5KEOP", stdout
);
9291 if (option
->info
& OHW_R5KCVTL
)
9292 fputs (" R5KCVTL", stdout
);
9295 fputs (" FILL ", stdout
);
9296 /* XXX Print content of info word? */
9299 fputs (" TAGS ", stdout
);
9300 /* XXX Print content of info word? */
9303 fputs (" HWAND ", stdout
);
9304 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9305 fputs (" R4KEOP_CHECKED", stdout
);
9306 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9307 fputs (" R4KEOP_CLEAN", stdout
);
9310 fputs (" HWOR ", stdout
);
9311 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
9312 fputs (" R4KEOP_CHECKED", stdout
);
9313 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
9314 fputs (" R4KEOP_CLEAN", stdout
);
9317 printf (" GP_GROUP %#06lx self-contained %#06lx",
9318 option
->info
& OGP_GROUP
,
9319 (option
->info
& OGP_SELF
) >> 16);
9322 printf (" IDENT %#06lx self-contained %#06lx",
9323 option
->info
& OGP_GROUP
,
9324 (option
->info
& OGP_SELF
) >> 16);
9327 /* This shouldn't happen. */
9328 printf (" %3d ??? %d %lx",
9329 option
->kind
, option
->section
, option
->info
);
9333 len
= sizeof (*eopt
);
9334 while (len
< option
->size
)
9335 if (((char *) option
)[len
] >= ' '
9336 && ((char *) option
)[len
] < 0x7f)
9337 printf ("%c", ((char *) option
)[len
++]);
9339 printf ("\\%03o", ((char *) option
)[len
++]);
9341 fputs ("\n", stdout
);
9349 if (conflicts_offset
!= 0 && conflictsno
!= 0)
9351 Elf32_Conflict
*iconf
;
9354 if (dynamic_symbols
== NULL
)
9356 error (_("conflict list found without a dynamic symbol table\n"));
9360 iconf
= cmalloc (conflictsno
, sizeof (*iconf
));
9363 error (_("Out of memory\n"));
9369 Elf32_External_Conflict
*econf32
;
9371 econf32
= get_data (NULL
, file
, conflicts_offset
,
9372 conflictsno
, sizeof (*econf32
), _("conflict"));
9376 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9377 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
9383 Elf64_External_Conflict
*econf64
;
9385 econf64
= get_data (NULL
, file
, conflicts_offset
,
9386 conflictsno
, sizeof (*econf64
), _("conflict"));
9390 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9391 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
9396 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9397 (unsigned long) conflictsno
);
9398 puts (_(" Num: Index Value Name"));
9400 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
9402 Elf_Internal_Sym
*psym
= & dynamic_symbols
[iconf
[cnt
]];
9404 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
9405 print_vma (psym
->st_value
, FULL_HEX
);
9407 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9408 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9410 printf ("<corrupt: %14ld>", psym
->st_name
);
9421 process_gnu_liblist (FILE *file
)
9423 Elf_Internal_Shdr
*section
, *string_sec
;
9424 Elf32_External_Lib
*elib
;
9433 for (i
= 0, section
= section_headers
;
9434 i
< elf_header
.e_shnum
;
9437 switch (section
->sh_type
)
9439 case SHT_GNU_LIBLIST
:
9440 if (SECTION_HEADER_INDEX (section
->sh_link
) >= elf_header
.e_shnum
)
9443 elib
= get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
9448 string_sec
= SECTION_HEADER (section
->sh_link
);
9450 strtab
= get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9451 string_sec
->sh_size
, _("liblist string table"));
9452 strtab_size
= string_sec
->sh_size
;
9455 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
9461 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9462 SECTION_NAME (section
),
9463 (long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
9465 puts (" Library Time Stamp Checksum Version Flags");
9467 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
9475 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
9476 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
9477 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
9478 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
9479 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
9481 tmp
= gmtime (&time
);
9482 snprintf (timebuf
, sizeof (timebuf
),
9483 "%04u-%02u-%02uT%02u:%02u:%02u",
9484 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9485 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9487 printf ("%3lu: ", (unsigned long) cnt
);
9489 printf ("%-20s", liblist
.l_name
< strtab_size
9490 ? strtab
+ liblist
.l_name
: "<corrupt>");
9492 printf ("%-20.20s", liblist
.l_name
< strtab_size
9493 ? strtab
+ liblist
.l_name
: "<corrupt>");
9494 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
9495 liblist
.l_version
, liblist
.l_flags
);
9506 get_note_type (unsigned e_type
)
9508 static char buff
[64];
9510 if (elf_header
.e_type
== ET_CORE
)
9514 return _("NT_AUXV (auxiliary vector)");
9516 return _("NT_PRSTATUS (prstatus structure)");
9518 return _("NT_FPREGSET (floating point registers)");
9520 return _("NT_PRPSINFO (prpsinfo structure)");
9522 return _("NT_TASKSTRUCT (task structure)");
9524 return _("NT_PRXFPREG (user_xfpregs structure)");
9526 return _("NT_PPC_VMX (ppc Altivec registers)");
9528 return _("NT_PSTATUS (pstatus structure)");
9530 return _("NT_FPREGS (floating point registers)");
9532 return _("NT_PSINFO (psinfo structure)");
9534 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9536 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9537 case NT_WIN32PSTATUS
:
9538 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9546 return _("NT_VERSION (version)");
9548 return _("NT_ARCH (architecture)");
9553 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9558 get_gnu_elf_note_type (unsigned e_type
)
9560 static char buff
[64];
9564 case NT_GNU_ABI_TAG
:
9565 return _("NT_GNU_ABI_TAG (ABI version tag)");
9567 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9568 case NT_GNU_BUILD_ID
:
9569 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9574 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9579 get_netbsd_elfcore_note_type (unsigned e_type
)
9581 static char buff
[64];
9583 if (e_type
== NT_NETBSDCORE_PROCINFO
)
9585 /* NetBSD core "procinfo" structure. */
9586 return _("NetBSD procinfo structure");
9589 /* As of Jan 2002 there are no other machine-independent notes
9590 defined for NetBSD core files. If the note type is less
9591 than the start of the machine-dependent note types, we don't
9594 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
9596 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
9600 switch (elf_header
.e_machine
)
9602 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9603 and PT_GETFPREGS == mach+2. */
9608 case EM_SPARC32PLUS
:
9612 case NT_NETBSDCORE_FIRSTMACH
+0:
9613 return _("PT_GETREGS (reg structure)");
9614 case NT_NETBSDCORE_FIRSTMACH
+2:
9615 return _("PT_GETFPREGS (fpreg structure)");
9621 /* On all other arch's, PT_GETREGS == mach+1 and
9622 PT_GETFPREGS == mach+3. */
9626 case NT_NETBSDCORE_FIRSTMACH
+1:
9627 return _("PT_GETREGS (reg structure)");
9628 case NT_NETBSDCORE_FIRSTMACH
+3:
9629 return _("PT_GETFPREGS (fpreg structure)");
9635 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
9636 e_type
- NT_NETBSDCORE_FIRSTMACH
);
9640 /* Note that by the ELF standard, the name field is already null byte
9641 terminated, and namesz includes the terminating null byte.
9642 I.E. the value of namesz for the name "FSF" is 4.
9644 If the value of namesz is zero, there is no name present. */
9646 process_note (Elf_Internal_Note
*pnote
)
9648 const char *name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
9651 if (pnote
->namesz
== 0)
9652 /* If there is no note name, then use the default set of
9653 note type strings. */
9654 nt
= get_note_type (pnote
->type
);
9656 else if (const_strneq (pnote
->namedata
, "GNU"))
9657 /* GNU-specific object file notes. */
9658 nt
= get_gnu_elf_note_type (pnote
->type
);
9660 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
9661 /* NetBSD-specific core file notes. */
9662 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
9664 else if (strneq (pnote
->namedata
, "SPU/", 4))
9666 /* SPU-specific core file notes. */
9667 nt
= pnote
->namedata
+ 4;
9672 /* Don't recognize this note name; just use the default set of
9673 note type strings. */
9674 nt
= get_note_type (pnote
->type
);
9676 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
9682 process_corefile_note_segment (FILE *file
, bfd_vma offset
, bfd_vma length
)
9684 Elf_External_Note
*pnotes
;
9685 Elf_External_Note
*external
;
9691 pnotes
= get_data (NULL
, file
, offset
, 1, length
, _("notes"));
9697 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9698 (unsigned long) offset
, (unsigned long) length
);
9699 printf (_(" Owner\t\tData size\tDescription\n"));
9701 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
9703 Elf_External_Note
*next
;
9704 Elf_Internal_Note inote
;
9707 inote
.type
= BYTE_GET (external
->type
);
9708 inote
.namesz
= BYTE_GET (external
->namesz
);
9709 inote
.namedata
= external
->name
;
9710 inote
.descsz
= BYTE_GET (external
->descsz
);
9711 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
9712 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
9714 next
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
9716 if (((char *) next
) > (((char *) pnotes
) + length
))
9718 warn (_("corrupt note found at offset %lx into core notes\n"),
9719 (long)((char *)external
- (char *)pnotes
));
9720 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
9721 inote
.type
, inote
.namesz
, inote
.descsz
);
9727 /* Verify that name is null terminated. It appears that at least
9728 one version of Linux (RedHat 6.0) generates corefiles that don't
9729 comply with the ELF spec by failing to include the null byte in
9731 if (inote
.namedata
[inote
.namesz
] != '\0')
9733 temp
= malloc (inote
.namesz
+ 1);
9737 error (_("Out of memory\n"));
9742 strncpy (temp
, inote
.namedata
, inote
.namesz
);
9743 temp
[inote
.namesz
] = 0;
9745 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9746 inote
.namedata
= temp
;
9749 res
&= process_note (& inote
);
9764 process_corefile_note_segments (FILE *file
)
9766 Elf_Internal_Phdr
*segment
;
9770 if (! get_program_headers (file
))
9773 for (i
= 0, segment
= program_headers
;
9774 i
< elf_header
.e_phnum
;
9777 if (segment
->p_type
== PT_NOTE
)
9778 res
&= process_corefile_note_segment (file
,
9779 (bfd_vma
) segment
->p_offset
,
9780 (bfd_vma
) segment
->p_filesz
);
9787 process_note_sections (FILE *file
)
9789 Elf_Internal_Shdr
*section
;
9793 for (i
= 0, section
= section_headers
;
9794 i
< elf_header
.e_shnum
;
9796 if (section
->sh_type
== SHT_NOTE
)
9797 res
&= process_corefile_note_segment (file
,
9798 (bfd_vma
) section
->sh_offset
,
9799 (bfd_vma
) section
->sh_size
);
9805 process_notes (FILE *file
)
9807 /* If we have not been asked to display the notes then do nothing. */
9811 if (elf_header
.e_type
!= ET_CORE
)
9812 return process_note_sections (file
);
9814 /* No program headers means no NOTE segment. */
9815 if (elf_header
.e_phnum
> 0)
9816 return process_corefile_note_segments (file
);
9818 printf (_("No note segments present in the core file.\n"));
9823 process_arch_specific (FILE *file
)
9828 switch (elf_header
.e_machine
)
9831 return process_arm_specific (file
);
9833 case EM_MIPS_RS3_LE
:
9834 return process_mips_specific (file
);
9837 return process_power_specific (file
);
9846 get_file_header (FILE *file
)
9848 /* Read in the identity array. */
9849 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9852 /* Determine how to read the rest of the header. */
9853 switch (elf_header
.e_ident
[EI_DATA
])
9855 default: /* fall through */
9856 case ELFDATANONE
: /* fall through */
9858 byte_get
= byte_get_little_endian
;
9859 byte_put
= byte_put_little_endian
;
9862 byte_get
= byte_get_big_endian
;
9863 byte_put
= byte_put_big_endian
;
9867 /* For now we only support 32 bit and 64 bit ELF files. */
9868 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9870 /* Read in the rest of the header. */
9873 Elf32_External_Ehdr ehdr32
;
9875 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9878 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9879 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9880 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9881 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9882 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9883 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9884 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9885 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9886 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9887 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9888 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9889 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9890 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9894 Elf64_External_Ehdr ehdr64
;
9896 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9897 we will not be able to cope with the 64bit data found in
9898 64 ELF files. Detect this now and abort before we start
9899 overwriting things. */
9900 if (sizeof (bfd_vma
) < 8)
9902 error (_("This instance of readelf has been built without support for a\n\
9903 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9907 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9910 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9911 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9912 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9913 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
9914 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
9915 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
9916 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9917 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9918 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9919 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9920 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9921 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9922 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9925 if (elf_header
.e_shoff
)
9927 /* There may be some extensions in the first section header. Don't
9928 bomb if we can't read it. */
9930 get_32bit_section_headers (file
, 1);
9932 get_64bit_section_headers (file
, 1);
9938 /* Process one ELF object file according to the command line options.
9939 This file may actually be stored in an archive. The file is
9940 positioned at the start of the ELF object. */
9943 process_object (char *file_name
, FILE *file
)
9947 if (! get_file_header (file
))
9949 error (_("%s: Failed to read file header\n"), file_name
);
9953 /* Initialise per file variables. */
9954 for (i
= ARRAY_SIZE (version_info
); i
--;)
9955 version_info
[i
] = 0;
9957 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
9958 dynamic_info
[i
] = 0;
9960 /* Process the file. */
9962 printf (_("\nFile: %s\n"), file_name
);
9964 /* Initialise the dump_sects array from the cmdline_dump_sects array.
9965 Note we do this even if cmdline_dump_sects is empty because we
9966 must make sure that the dump_sets array is zeroed out before each
9967 object file is processed. */
9968 if (num_dump_sects
> num_cmdline_dump_sects
)
9969 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
9971 if (num_cmdline_dump_sects
> 0)
9973 if (num_dump_sects
== 0)
9974 /* A sneaky way of allocating the dump_sects array. */
9975 request_dump_bynumber (num_cmdline_dump_sects
, 0);
9977 assert (num_dump_sects
>= num_cmdline_dump_sects
);
9978 memcpy (dump_sects
, cmdline_dump_sects
,
9979 num_cmdline_dump_sects
* sizeof (* dump_sects
));
9982 if (! process_file_header ())
9985 if (! process_section_headers (file
))
9987 /* Without loaded section headers we cannot process lots of
9989 do_unwind
= do_version
= do_dump
= do_arch
= 0;
9991 if (! do_using_dynamic
)
9992 do_syms
= do_reloc
= 0;
9995 if (! process_section_groups (file
))
9997 /* Without loaded section groups we cannot process unwind. */
10001 if (process_program_headers (file
))
10002 process_dynamic_section (file
);
10004 process_relocs (file
);
10006 process_unwind (file
);
10008 process_symbol_table (file
);
10010 process_syminfo (file
);
10012 process_version_sections (file
);
10014 process_section_contents (file
);
10016 process_notes (file
);
10018 process_gnu_liblist (file
);
10020 process_arch_specific (file
);
10022 if (program_headers
)
10024 free (program_headers
);
10025 program_headers
= NULL
;
10028 if (section_headers
)
10030 free (section_headers
);
10031 section_headers
= NULL
;
10036 free (string_table
);
10037 string_table
= NULL
;
10038 string_table_length
= 0;
10041 if (dynamic_strings
)
10043 free (dynamic_strings
);
10044 dynamic_strings
= NULL
;
10045 dynamic_strings_length
= 0;
10048 if (dynamic_symbols
)
10050 free (dynamic_symbols
);
10051 dynamic_symbols
= NULL
;
10052 num_dynamic_syms
= 0;
10055 if (dynamic_syminfo
)
10057 free (dynamic_syminfo
);
10058 dynamic_syminfo
= NULL
;
10061 if (section_headers_groups
)
10063 free (section_headers_groups
);
10064 section_headers_groups
= NULL
;
10067 if (section_groups
)
10069 struct group_list
*g
, *next
;
10071 for (i
= 0; i
< group_count
; i
++)
10073 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
10080 free (section_groups
);
10081 section_groups
= NULL
;
10084 free_debug_memory ();
10089 /* Process an ELF archive.
10090 On entry the file is positioned just after the ARMAG string. */
10093 process_archive (char *file_name
, FILE *file
)
10095 struct ar_hdr arhdr
;
10097 unsigned long size
;
10098 unsigned long index_num
= 0;
10099 unsigned long *index_array
= NULL
;
10100 char *sym_table
= NULL
;
10101 unsigned long sym_size
= 0;
10102 char *longnames
= NULL
;
10103 unsigned long longnames_size
= 0;
10104 size_t file_name_size
;
10109 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10110 if (got
!= sizeof arhdr
)
10115 error (_("%s: failed to read archive header\n"), file_name
);
10119 /* See if this is the archive symbol table. */
10120 if (const_strneq (arhdr
.ar_name
, "/ ")
10121 || const_strneq (arhdr
.ar_name
, "/SYM64/ "))
10123 size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10124 size
= size
+ (size
& 1);
10126 if (do_archive_index
)
10129 /* A buffer used to hold numbers read in from an archive index.
10130 These are always 4 bytes long and stored in big-endian format. */
10131 #define SIZEOF_AR_INDEX_NUMBERS 4
10132 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
10133 unsigned char * index_buffer
;
10135 /* Check the size of the archive index. */
10136 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
10138 error (_("%s: the archive index is empty\n"), file_name
);
10142 /* Read the numer of entries in the archive index. */
10143 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
10144 if (got
!= sizeof (integer_buffer
))
10146 error (_("%s: failed to read archive index\n"), file_name
);
10149 index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
10150 size
-= SIZEOF_AR_INDEX_NUMBERS
;
10152 /* Read in the archive index. */
10153 if (size
< index_num
* SIZEOF_AR_INDEX_NUMBERS
)
10155 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10156 file_name
, index_num
);
10159 index_buffer
= malloc (index_num
* SIZEOF_AR_INDEX_NUMBERS
);
10160 if (index_buffer
== NULL
)
10162 error (_("Out of memory whilst trying to read archive symbol index\n"));
10165 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, index_num
, file
);
10166 if (got
!= index_num
)
10168 free (index_buffer
);
10169 error (_("%s: failed to read archive index\n"), file_name
);
10173 size
-= index_num
* SIZEOF_AR_INDEX_NUMBERS
;
10175 /* Convert the index numbers into the host's numeric format. */
10176 index_array
= malloc (index_num
* sizeof (* index_array
));
10177 if (index_array
== NULL
)
10179 free (index_buffer
);
10180 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10184 for (i
= 0; i
< index_num
; i
++)
10185 index_array
[i
] = byte_get_big_endian ((unsigned char *)(index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
10186 SIZEOF_AR_INDEX_NUMBERS
);
10187 free (index_buffer
);
10189 /* The remaining space in the header is taken up by the symbol table. */
10192 error (_("%s: the archive has an index but no symbols\n"), file_name
);
10196 sym_table
= malloc (size
);
10198 if (sym_table
== NULL
)
10200 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10204 got
= fread (sym_table
, 1, size
, file
);
10207 error (_("%s: failed to read archive index symbol table\n"), file_name
);
10214 if (fseek (file
, size
, SEEK_CUR
) != 0)
10216 error (_("%s: failed to skip archive symbol table\n"), file_name
);
10221 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10222 if (got
!= sizeof arhdr
)
10230 error (_("%s: failed to read archive header following archive index\n"), file_name
);
10235 else if (do_archive_index
)
10236 printf (_("%s has no archive index\n"), file_name
);
10238 if (const_strneq (arhdr
.ar_name
, "// "))
10240 /* This is the archive string table holding long member
10243 longnames_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10244 longnames
= malloc (longnames_size
);
10245 if (longnames
== NULL
)
10247 error (_("Out of memory reading long symbol names in archive\n"));
10252 if (fread (longnames
, longnames_size
, 1, file
) != 1)
10255 error (_("%s: failed to read long symbol name string table\n"), file_name
);
10260 if ((longnames_size
& 1) != 0)
10263 got
= fread (& arhdr
, 1, sizeof arhdr
, file
);
10264 if (got
!= sizeof arhdr
)
10270 error (_("%s: failed to read archive header following long symbol names\n"), file_name
);
10277 if (do_archive_index
)
10279 if (sym_table
== NULL
)
10280 error (_("%s: unable to dump the index as none was found\n"), file_name
);
10283 unsigned int i
, j
, k
, l
;
10285 unsigned long current_pos
;
10287 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10288 file_name
, index_num
, sym_size
);
10289 current_pos
= ftell (file
);
10291 for (i
= l
= 0; i
< index_num
; i
++)
10293 if ((i
== 0) || ((i
> 0) && (index_array
[i
] != index_array
[i
- 1])))
10295 if (fseek (file
, index_array
[i
], SEEK_SET
) != 0)
10297 error (_("%s: failed to seek to next file name\n"), file_name
);
10301 got
= fread (elf_name
, 1, 16, file
);
10304 error (_("%s: failed to read file name\n"), file_name
);
10309 if (elf_name
[0] == '/')
10311 /* We have a long name. */
10312 k
= j
= strtoul (elf_name
+ 1, NULL
, 10);
10313 while ((j
< longnames_size
) && (longnames
[j
] != '/'))
10315 longnames
[j
] = '\0';
10316 printf (_("Binary %s contains:\n"), longnames
+ k
);
10317 longnames
[j
] = '/';
10322 while ((elf_name
[j
] != '/') && (j
< 16))
10324 elf_name
[j
] = '\0';
10325 printf(_("Binary %s contains:\n"), elf_name
);
10330 error (_("%s: end of the symbol table reached before the end of the index\n"),
10334 printf ("\t%s\n", sym_table
+ l
);
10335 l
+= strlen (sym_table
+ l
) + 1;
10339 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10342 free (index_array
);
10343 index_array
= NULL
;
10346 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
10348 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
10353 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
10354 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
10355 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
10356 && !do_section_groups
)
10357 return 0; /* Archive index only. */
10360 file_name_size
= strlen (file_name
);
10369 if (arhdr
.ar_name
[0] == '/')
10373 off
= strtoul (arhdr
.ar_name
+ 1, NULL
, 10);
10374 if (off
>= longnames_size
)
10376 error (_("%s: invalid archive string table offset %lu\n"), file_name
, off
);
10381 name
= longnames
+ off
;
10382 nameend
= memchr (name
, '/', longnames_size
- off
);
10386 name
= arhdr
.ar_name
;
10387 nameend
= memchr (name
, '/', 16);
10390 if (nameend
== NULL
)
10392 error (_("%s: bad archive file name\n"), file_name
);
10397 namealc
= malloc (file_name_size
+ (nameend
- name
) + 3);
10398 if (namealc
== NULL
)
10400 error (_("Out of memory\n"));
10405 memcpy (namealc
, file_name
, file_name_size
);
10406 namealc
[file_name_size
] = '(';
10407 memcpy (namealc
+ file_name_size
+ 1, name
, nameend
- name
);
10408 namealc
[file_name_size
+ 1 + (nameend
- name
)] = ')';
10409 namealc
[file_name_size
+ 2 + (nameend
- name
)] = '\0';
10411 archive_file_offset
= ftell (file
);
10412 archive_file_size
= strtoul (arhdr
.ar_size
, NULL
, 10);
10414 ret
|= process_object (namealc
, file
);
10419 (archive_file_offset
10420 + archive_file_size
10421 + (archive_file_size
& 1)),
10424 error (_("%s: failed to seek to next archive header\n"), file_name
);
10429 got
= fread (&arhdr
, 1, sizeof arhdr
, file
);
10430 if (got
!= sizeof arhdr
)
10435 error (_("%s: failed to read archive header\n"), file_name
);
10442 if (index_array
!= NULL
)
10443 free (index_array
);
10444 if (sym_table
!= NULL
)
10446 if (longnames
!= NULL
)
10453 process_file (char *file_name
)
10456 struct stat statbuf
;
10457 char armag
[SARMAG
];
10460 if (stat (file_name
, &statbuf
) < 0)
10462 if (errno
== ENOENT
)
10463 error (_("'%s': No such file\n"), file_name
);
10465 error (_("Could not locate '%s'. System error message: %s\n"),
10466 file_name
, strerror (errno
));
10470 if (! S_ISREG (statbuf
.st_mode
))
10472 error (_("'%s' is not an ordinary file\n"), file_name
);
10476 file
= fopen (file_name
, "rb");
10479 error (_("Input file '%s' is not readable.\n"), file_name
);
10483 if (fread (armag
, SARMAG
, 1, file
) != 1)
10485 error (_("%s: Failed to read file's magic number\n"), file_name
);
10490 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
10491 ret
= process_archive (file_name
, file
);
10494 if (do_archive_index
)
10495 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10499 archive_file_size
= archive_file_offset
= 0;
10500 ret
= process_object (file_name
, file
);
10508 #ifdef SUPPORT_DISASSEMBLY
10509 /* Needed by the i386 disassembler. For extra credit, someone could
10510 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10514 print_address (unsigned int addr
, FILE *outfile
)
10516 fprintf (outfile
,"0x%8.8x", addr
);
10519 /* Needed by the i386 disassembler. */
10521 db_task_printsym (unsigned int addr
)
10523 print_address (addr
, stderr
);
10528 main (int argc
, char **argv
)
10532 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10533 setlocale (LC_MESSAGES
, "");
10535 #if defined (HAVE_SETLOCALE)
10536 setlocale (LC_CTYPE
, "");
10538 bindtextdomain (PACKAGE
, LOCALEDIR
);
10539 textdomain (PACKAGE
);
10541 expandargv (&argc
, &argv
);
10543 parse_args (argc
, argv
);
10545 if (num_dump_sects
> 0)
10547 /* Make a copy of the dump_sects array. */
10548 cmdline_dump_sects
= malloc (num_dump_sects
* sizeof (* dump_sects
));
10549 if (cmdline_dump_sects
== NULL
)
10550 error (_("Out of memory allocating dump request table.\n"));
10553 memcpy (cmdline_dump_sects
, dump_sects
,
10554 num_dump_sects
* sizeof (* dump_sects
));
10555 num_cmdline_dump_sects
= num_dump_sects
;
10559 if (optind
< (argc
- 1))
10563 while (optind
< argc
)
10564 err
|= process_file (argv
[optind
++]);
10566 if (dump_sects
!= NULL
)
10568 if (cmdline_dump_sects
!= NULL
)
10569 free (cmdline_dump_sects
);